SQLite

** table composed of instances of the following structure.
*/
typedef struct Keyword Keyword;
struct Keyword {
  char *zName;         /* The keyword name */
  char *zTokenType;    /* Token value for this keyword */
  int mask;            /* Code this keyword if non-zero */
  int priority;        /* Put higher priorities earlier in the hash chain */
  int id;              /* Unique ID for this record */
  int hash;            /* Hash on the keyword */
  int offset;          /* Offset to start of name string */
  int len;             /* Length of this keyword, not counting final \000 */
  int prefix;          /* Number of characters in prefix */
  int longestSuffix;   /* Longest suffix that is a prefix on another word */
  int iNext;           /* Index in aKeywordTable[] of next with same hash */

#  define WINDOWFUNC 0x00100000
#endif

/*
** These are the keywords
*/
static Keyword aKeywordTable[] = {
  { "ABORT",            "TK_ABORT",        CONFLICT|TRIGGER, 0      },
  { "ACTION",           "TK_ACTION",       FKEY,             0      },
  { "ADD",              "TK_ADD",          ALTER,            1      },
  { "AFTER",            "TK_AFTER",        TRIGGER,          0      },
  { "ALL",              "TK_ALL",          ALWAYS,           0      },
  { "ALTER",            "TK_ALTER",        ALTER,            0      },
  { "ALWAYS",           "TK_ALWAYS",       ALWAYS,           0      },
  { "ANALYZE",          "TK_ANALYZE",      ANALYZE,          0      },
  { "AND",              "TK_AND",          ALWAYS,           10     },
  { "AS",               "TK_AS",           ALWAYS,           10     },
  { "ASC",              "TK_ASC",          ALWAYS,           0      },
  { "ATTACH",           "TK_ATTACH",       ATTACH,           1      },
  { "AUTOINCREMENT",    "TK_AUTOINCR",     AUTOINCR,         0      },
  { "BEFORE",           "TK_BEFORE",       TRIGGER,          0      },
  { "BEGIN",            "TK_BEGIN",        ALWAYS,           1      },
  { "BETWEEN",          "TK_BETWEEN",      ALWAYS,           5      },
  { "BY",               "TK_BY",           ALWAYS,           10     },
  { "CASCADE",          "TK_CASCADE",      FKEY,             1      },
  { "CASE",             "TK_CASE",         ALWAYS,           5      },
  { "CAST",             "TK_CAST",         CAST,             5      },
  { "CHECK",            "TK_CHECK",        ALWAYS,           1      },
  { "COLLATE",          "TK_COLLATE",      ALWAYS,           1      },
  { "COLUMN",           "TK_COLUMNKW",     ALTER,            1      },
  { "COMMIT",           "TK_COMMIT",       ALWAYS,           1      },
  { "CONFLICT",         "TK_CONFLICT",     CONFLICT,         0      },
  { "CONSTRAINT",       "TK_CONSTRAINT",   ALWAYS,           1      },
  { "CREATE",           "TK_CREATE",       ALWAYS,           2      },
  { "CROSS",            "TK_JOIN_KW",      ALWAYS,           3      },
  { "CURRENT",          "TK_CURRENT",      WINDOWFUNC,       1      },
  { "CURRENT_DATE",     "TK_CTIME_KW",     ALWAYS,           1      },
  { "CURRENT_TIME",     "TK_CTIME_KW",     ALWAYS,           1      },
  { "CURRENT_TIMESTAMP","TK_CTIME_KW",     ALWAYS,           1      },
  { "DATABASE",         "TK_DATABASE",     ATTACH,           0      },
  { "DEFAULT",          "TK_DEFAULT",      ALWAYS,           1      },
  { "DEFERRED",         "TK_DEFERRED",     ALWAYS,           1      },
  { "DEFERRABLE",       "TK_DEFERRABLE",   FKEY,             1      },
  { "DELETE",           "TK_DELETE",       ALWAYS,           10     },
  { "DESC",             "TK_DESC",         ALWAYS,           3      },
  { "DETACH",           "TK_DETACH",       ATTACH,           0      },
  { "DISTINCT",         "TK_DISTINCT",     ALWAYS,           5      },
  { "DO",               "TK_DO",           UPSERT,           2      },
  { "DROP",             "TK_DROP",         ALWAYS,           1      },
  { "END",              "TK_END",          ALWAYS,           1      },
  { "EACH",             "TK_EACH",         TRIGGER,          1      },
  { "ELSE",             "TK_ELSE",         ALWAYS,           2      },
  { "ESCAPE",           "TK_ESCAPE",       ALWAYS,           4      },
  { "EXCEPT",           "TK_EXCEPT",       COMPOUND,         4      },
  { "EXCLUSIVE",        "TK_EXCLUSIVE",    ALWAYS,           1      },
  { "EXCLUDE",          "TK_EXCLUDE",      WINDOWFUNC,       1      },
  { "EXISTS",           "TK_EXISTS",       ALWAYS,           4      },
  { "EXPLAIN",          "TK_EXPLAIN",      EXPLAIN,          1      },
  { "FAIL",             "TK_FAIL",         CONFLICT|TRIGGER, 1      },
  { "FILTER",           "TK_FILTER",       WINDOWFUNC,       4      },
  { "FIRST",            "TK_FIRST",        ALWAYS,           4      },
  { "FOLLOWING",        "TK_FOLLOWING",    WINDOWFUNC,       4      },
  { "FOR",              "TK_FOR",          TRIGGER,          2      },
  { "FOREIGN",          "TK_FOREIGN",      FKEY,             1      },
  { "FROM",             "TK_FROM",         ALWAYS,           10     },
  { "FULL",             "TK_JOIN_KW",      ALWAYS,           3      },
  { "GENERATED",        "TK_GENERATED",    ALWAYS,           1      },
  { "GLOB",             "TK_LIKE_KW",      ALWAYS,           3      },
  { "GROUP",            "TK_GROUP",        ALWAYS,           5      },
  { "GROUPS",           "TK_GROUPS",       WINDOWFUNC,       2      },
  { "HAVING",           "TK_HAVING",       ALWAYS,           5      },
  { "IF",               "TK_IF",           ALWAYS,           2      },
  { "IGNORE",           "TK_IGNORE",       CONFLICT|TRIGGER, 1      },
  { "IMMEDIATE",        "TK_IMMEDIATE",    ALWAYS,           1      },
  { "IN",               "TK_IN",           ALWAYS,           10     },
  { "INDEX",            "TK_INDEX",        ALWAYS,           1      },
  { "INDEXED",          "TK_INDEXED",      ALWAYS,           0      },
  { "INITIALLY",        "TK_INITIALLY",    FKEY,             1      },
  { "INNER",            "TK_JOIN_KW",      ALWAYS,           1      },
  { "INSERT",           "TK_INSERT",       ALWAYS,           10     },
  { "INSTEAD",          "TK_INSTEAD",      TRIGGER,          1      },
  { "INTERSECT",        "TK_INTERSECT",    COMPOUND,         5      },
  { "INTO",             "TK_INTO",         ALWAYS,           10     },
  { "IS",               "TK_IS",           ALWAYS,           5      },
  { "ISNULL",           "TK_ISNULL",       ALWAYS,           5      },
  { "JOIN",             "TK_JOIN",         ALWAYS,           5      },
  { "KEY",              "TK_KEY",          ALWAYS,           1      },
  { "LAST",             "TK_LAST",         ALWAYS,           4      },
  { "LEFT",             "TK_JOIN_KW",      ALWAYS,           5      },
  { "LIKE",             "TK_LIKE_KW",      ALWAYS,           5      },
  { "LIMIT",            "TK_LIMIT",        ALWAYS,           3      },
  { "MATCH",            "TK_MATCH",        ALWAYS,           2      },
  { "NATURAL",          "TK_JOIN_KW",      ALWAYS,           3      },
  { "NO",               "TK_NO",           FKEY|WINDOWFUNC,  2      },
  { "NOT",              "TK_NOT",          ALWAYS,           10     },
  { "NOTHING",          "TK_NOTHING",      UPSERT,           1      },
  { "NOTNULL",          "TK_NOTNULL",      ALWAYS,           3      },
  { "NULL",             "TK_NULL",         ALWAYS,           10     },
  { "NULLS",            "TK_NULLS",        ALWAYS,           3      },
  { "OF",               "TK_OF",           ALWAYS,           3      },
  { "OFFSET",           "TK_OFFSET",       ALWAYS,           1      },
  { "ON",               "TK_ON",           ALWAYS,           1      },
  { "OR",               "TK_OR",           ALWAYS,           9      },
  { "ORDER",            "TK_ORDER",        ALWAYS,           10     },
  { "OTHERS",           "TK_OTHERS",       WINDOWFUNC,       3      },
  { "OUTER",            "TK_JOIN_KW",      ALWAYS,           5      },
  { "OVER",             "TK_OVER",         WINDOWFUNC,       3      },
  { "PARTITION",        "TK_PARTITION",    WINDOWFUNC,       3      },
  { "PLAN",             "TK_PLAN",         EXPLAIN,          0      },
  { "PRAGMA",           "TK_PRAGMA",       PRAGMA,           0      },
  { "PRECEDING",        "TK_PRECEDING",    WINDOWFUNC,       3      },
  { "PRIMARY",          "TK_PRIMARY",      ALWAYS,           1      },
  { "QUERY",            "TK_QUERY",        EXPLAIN,          0      },
  { "RAISE",            "TK_RAISE",        TRIGGER,          1      },
  { "RANGE",            "TK_RANGE",        WINDOWFUNC,       3      },
  { "RECURSIVE",        "TK_RECURSIVE",    CTE,              3      },
  { "REFERENCES",       "TK_REFERENCES",   FKEY,             1      },
  { "REGEXP",           "TK_LIKE_KW",      ALWAYS,           3      },
  { "REINDEX",          "TK_REINDEX",      REINDEX,          1      },
  { "RELEASE",          "TK_RELEASE",      ALWAYS,           1      },
  { "RENAME",           "TK_RENAME",       ALTER,            1      },
  { "REPLACE",          "TK_REPLACE",      CONFLICT,         10     },
  { "RESTRICT",         "TK_RESTRICT",     FKEY,             1      },
  { "RIGHT",            "TK_JOIN_KW",      ALWAYS,           0      },
  { "ROLLBACK",         "TK_ROLLBACK",     ALWAYS,           1      },
  { "ROW",              "TK_ROW",          TRIGGER,          1      },
  { "ROWS",             "TK_ROWS",         ALWAYS,           1      },
  { "SAVEPOINT",        "TK_SAVEPOINT",    ALWAYS,           1      },
  { "SELECT",           "TK_SELECT",       ALWAYS,           10     },
  { "SET",              "TK_SET",          ALWAYS,           10     },
  { "TABLE",            "TK_TABLE",        ALWAYS,           1      },
  { "TEMP",             "TK_TEMP",         ALWAYS,           1      },
  { "TEMPORARY",        "TK_TEMP",         ALWAYS,           1      },
  { "THEN",             "TK_THEN",         ALWAYS,           3      },
  { "TIES",             "TK_TIES",         WINDOWFUNC,       3      },
  { "TO",               "TK_TO",           ALWAYS,           3      },
  { "TRANSACTION",      "TK_TRANSACTION",  ALWAYS,           1      },
  { "TRIGGER",          "TK_TRIGGER",      TRIGGER,          1      },
  { "UNBOUNDED",        "TK_UNBOUNDED",    WINDOWFUNC,       3      },
  { "UNION",            "TK_UNION",        COMPOUND,         3      },
  { "UNIQUE",           "TK_UNIQUE",       ALWAYS,           1      },
  { "UPDATE",           "TK_UPDATE",       ALWAYS,           10     },
  { "USING",            "TK_USING",        ALWAYS,           8      },
  { "VACUUM",           "TK_VACUUM",       VACUUM,           1      },
  { "VALUES",           "TK_VALUES",       ALWAYS,           10     },
  { "VIEW",             "TK_VIEW",         VIEW,             1      },
  { "VIRTUAL",          "TK_VIRTUAL",      VTAB,             1      },
  { "WHEN",             "TK_WHEN",         ALWAYS,           1      },
  { "WHERE",            "TK_WHERE",        ALWAYS,           10     },
  { "WINDOW",           "TK_WINDOW",       WINDOWFUNC,       3      },
  { "WITH",             "TK_WITH",         CTE,              4      },
  { "WITHOUT",          "TK_WITHOUT",      ALWAYS,           1      },
};

/* Number of keywords */
static int nKeyword = (sizeof(aKeywordTable)/sizeof(aKeywordTable[0]));

/* Map all alphabetic characters into lower-case for hashing.  This is
** only valid for alphabetics.  In particular it does not work for '_'

static Keyword *findById(int id){
  int i;
  for(i=0; i<nKeyword; i++){
    if( aKeywordTable[i].id==id ) break;
  }
  return &aKeywordTable[i];
}

/*
** If aKeyword[*pFrom-1].iNext has a higher priority that aKeyword[*pFrom-1]
** itself, then swap them.
*/
static void reorder(int *pFrom){
  int i = *pFrom - 1;
  int j = aKeywordTable[i].iNext;
  if( j==0 ) return;
  j--;
  if( aKeywordTable[i].priority >= aKeywordTable[j].priority ) return;
  aKeywordTable[i].iNext = aKeywordTable[j].iNext;
  aKeywordTable[j].iNext = i+1;
  *pFrom = j+1;
  reorder(&aKeywordTable[i].iNext);
}

/*
** This routine does the work.  The generated code is printed on standard
** output.
*/
int main(int argc, char **argv){
  int i, j, k, h;

  /* Compute the hash */
  for(i=0; i<bestSize; i++) aKWHash[i] = 0;
  for(i=0; i<nKeyword; i++){
    h = aKeywordTable[i].hash % bestSize;
    aKeywordTable[i].iNext = aKWHash[h];
    aKWHash[h] = i+1;
    reorder(&aKWHash[h]);
  }

  /* Begin generating code */
  printf("%s", zHdr);
  printf("/* Hash score: %d */\n", bestCount);
  printf("/* zKWText[] encodes %d bytes of keyword text in %d bytes */\n",
          totalLen + nKeyword, nChar+1 );

    j++;
    if( j>=5 ){
      printf("\n");
      j = 0;
    }
  }
  printf("%s};\n", j==0 ? "" : "\n");
  printf("/* Hash table decoded:\n");
  for(i=0; i<bestSize; i++){
    j = aKWHash[i];
    printf("** %3d:", i);
    while( j ){
      printf(" %s", aKeywordTable[j-1].zOrigName);
      j = aKeywordTable[j-1].iNext;
    }
    printf("\n");
  }
  printf("*/\n");
  printf("/* Check to see if z[0..n-1] is a keyword. If it is, write the\n");
  printf("** parser symbol code for that keyword into *pType.  Always\n");
  printf("** return the integer n (the length of the token). */\n");
  printf("static int keywordCode(const char *z, int n, int *pType){\n");
  printf("  int i, j;\n");
  printf("  const char *zKW;\n");
  printf("  if( n>=2 ){\n");