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