LCOV - code coverage report
Current view: top level - sql/common - sql_keyword.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 43 43 100.0 %
Date: 2021-10-13 02:24:04 Functions: 6 6 100.0 %

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

Generated by: LCOV version 1.14