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 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    13625387 : keyword_key(char *k, int *l)
      26             : {
      27    13625387 :         char *s = k;
      28    13625387 :         unsigned int h = 1;
      29             : 
      30    81880016 :         while (*k) {
      31    68254629 :                 h <<= 5;
      32    68254629 :                 h += (*k - 'a');
      33    68254629 :                 k++;
      34             :         }
      35    13625387 :         *l = (int) (k - s);
      36    13625387 :         h <<= 4;
      37    13625387 :         h += *l;
      38    13625387 :         return (int) ((h & 0x80000000) ? ~h + 1 : h);
      39             : }
      40             : 
      41             : int
      42      144289 : keywords_insert(char *k, int token)
      43             : {
      44      144289 :         keyword *kw = MNEW(keyword);
      45      144289 :         if(kw) {
      46      144289 :                 int len = 0;
      47      144289 :                 int bucket = keyword_key(k = toLower(k), &len) & HASH_MASK;
      48             : #ifndef NDEBUG
      49             :                 /* no duplicate keywords */
      50      144289 :                 keyword *kw2;
      51      177417 :                 for (kw2 = keywords[bucket]; kw2; kw2 = kw2->next)
      52       33128 :                         assert(strcmp(kw2->keyword, k) != 0);
      53             : #endif
      54             : 
      55      144289 :                 *kw = (keyword) {
      56             :                         .keyword = k,
      57             :                         .len = len,
      58             :                         .token = token,
      59             :                         .next = keywords[bucket],
      60             :                 };
      61      144289 :                 keywords[bucket] = kw;
      62      144289 :                 return 0;
      63             :         } else {
      64             :                 return -1;
      65             :         }
      66             : }
      67             : 
      68             : keyword *
      69    13481117 : find_keyword(char *text)
      70             : {
      71    13481117 :         int len = 0;
      72    13481117 :         int bucket = keyword_key(mkLower(text), &len) & HASH_MASK;
      73    13481190 :         keyword *k = keywords[bucket];
      74             : 
      75    16326650 :         while (k) {
      76    11117808 :                 if (len == k->len && strcmp(k->keyword, text) == 0)
      77     8272348 :                         return k;
      78             : 
      79     2845460 :                 k = k->next;
      80             :         }
      81             :         return NULL;
      82             : }
      83             : 
      84             : int
      85       10101 : keyword_exists(char *text)
      86             : {
      87       10101 :         if (find_keyword(text)) {
      88        6855 :                 return 1;
      89             :         }
      90             :         return 0;
      91             : }
      92             : 
      93             : void
      94         328 : keyword_init(void)
      95             : {
      96         328 :         int i;
      97             : 
      98         328 :         if (keywords_init_done)
      99             :                 return;
     100         328 :         keywords_init_done = 1;
     101             : 
     102    10748232 :         for (i = 0; i < HASH_SIZE; i++)
     103    10747904 :                 keywords[i] = NULL;
     104             : }
     105             : 
     106             : void
     107         327 : keyword_exit(void)
     108             : {
     109         327 :         int i;
     110             : 
     111         327 :         if (keywords_init_done == 0)
     112             :                 return;
     113         327 :         keywords_init_done = 0;
     114             : 
     115    10715463 :         for (i = 0; i < HASH_SIZE; i++) {
     116    10715136 :                 keyword *k = keywords[i];
     117             : 
     118    10715136 :                 while (k) {
     119      143851 :                         keyword *l = k;
     120             : 
     121      143851 :                         k = k->next;
     122      143851 :                         _DELETE(l->keyword);
     123             : 
     124    10858987 :                         _DELETE(l);
     125             :                 }
     126             :         }
     127             : }