Line data    Source code

       1             : /*
       2             :  * SPDX-License-Identifier: MPL-2.0
       3             :  *
       4             :  * This Source Code Form is subject to the terms of the Mozilla Public
       5             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       6             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       7             :  *
       8             :  * Copyright 2024, 2025 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : #include "monetdb_config.h"
      14             : #include "sql_mem.h"
      15             : #include "sql_string.h"
      16             : #include "sql_keyword.h"
      17             : 
      18             : #define HASH_SIZE 32768
      19             : #define HASH_MASK (HASH_SIZE-1)
      20             : 
      21             : static int keywords_init_done = 0;
      22             : static keyword *keywords[HASH_SIZE];
      23             : 
      24             : static int
      25    14215185 : keyword_key(char *k, int *l)
      26             : {
      27    14215185 :         char *s = k;
      28    14215185 :         unsigned int h = 1;
      29             : 
      30    85780569 :         while (*k) {
      31    71565384 :                 h <<= 5;
      32    71565384 :                 h += (*k - 'a');
      33    71565384 :                 k++;
      34             :         }
      35    14215185 :         *l = (int) (k - s);
      36    14215185 :         h <<= 4;
      37    14215185 :         h += *l;
      38    14215185 :         return (int) ((h & 0x80000000) ? ~h + 1 : h);
      39             : }
      40             : 
      41             : int
      42      157419 : keywords_insert(char *k, int token)
      43             : {
      44      157419 :         keyword *kw = MNEW(keyword);
      45      157419 :         if(kw) {
      46      157419 :                 int len = 0;
      47      157419 :                 int bucket = keyword_key(k = toLower(k), &len) & HASH_MASK;
      48             : #ifndef NDEBUG
      49             :                 /* no duplicate keywords */
      50      157419 :                 keyword *kw2;
      51      193476 :                 for (kw2 = keywords[bucket]; kw2; kw2 = kw2->next)
      52       36057 :                         assert(strcmp(kw2->keyword, k) != 0);
      53             : #endif
      54             : 
      55      157419 :                 *kw = (keyword) {
      56             :                         .keyword = k,
      57             :                         .len = len,
      58             :                         .token = token,
      59             :                         .next = keywords[bucket],
      60             :                 };
      61      157419 :                 keywords[bucket] = kw;
      62      157419 :                 return 0;
      63             :         } else {
      64             :                 return -1;
      65             :         }
      66             : }
      67             : 
      68             : keyword *
      69    14057777 : find_keyword(char *text)
      70             : {
      71    14057777 :         int len = 0;
      72    14057777 :         int bucket = keyword_key(mkLower(text), &len) & HASH_MASK;
      73    14057863 :         keyword *k = keywords[bucket];
      74             : 
      75    16956162 :         while (k) {
      76    11500320 :                 if (len == k->len && strcmp(k->keyword, text) == 0)
      77     8602021 :                         return k;
      78             : 
      79     2898299 :                 k = k->next;
      80             :         }
      81             :         return NULL;
      82             : }
      83             : 
      84             : int
      85       10656 : keyword_exists(char *text)
      86             : {
      87       10656 :         if (find_keyword(text)) {
      88        7464 :                 return 1;
      89             :         }
      90             :         return 0;
      91             : }
      92             : 
      93             : void
      94         357 : keyword_init(void)
      95             : {
      96         357 :         int i;
      97             : 
      98         357 :         if (keywords_init_done)
      99             :                 return;
     100         357 :         keywords_init_done = 1;
     101             : 
     102    11698533 :         for (i = 0; i < HASH_SIZE; i++)
     103    11698176 :                 keywords[i] = NULL;
     104             : }
     105             : 
     106             : void
     107         356 : keyword_exit(void)
     108             : {
     109         356 :         int i;
     110             : 
     111         356 :         if (keywords_init_done == 0)
     112             :                 return;
     113         356 :         keywords_init_done = 0;
     114             : 
     115    11665764 :         for (i = 0; i < HASH_SIZE; i++) {
     116    11665408 :                 keyword *k = keywords[i];
     117             : 
     118    11665408 :                 while (k) {
     119      156979 :                         keyword *l = k;
     120             : 
     121      156979 :                         k = k->next;
     122      156979 :                         _DELETE(l->keyword);
     123             : 
     124    11822387 :                         _DELETE(l);
     125             :                 }
     126             :         }
     127             : }