Import SQLite 3.7.6.3.

third_party/sqlite/src/tool/mkkeywordhash.c

 /*
 ** Compile and run this standalone program in order to generate code that
 ** implements a function that will translate alphabetic identifiers into
 ** parser token codes.
 */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
 
 /*
 ** A header comment placed at the beginning of generated code.
 */
 static const char zHdr[] = 
   "/***** This file contains automatically generated code ******\n"
   "**\n"
   "** The code in this file has been automatically generated by\n"
   "**\n"
-  "**     $Header: /home/drh/sqlite/trans/cvs/sqlite/sqlite/tool/mkkeywordhash.c,v 1.38 2009/06/09 14:27:41 drh Exp $\n"
+  "**   sqlite/tool/mkkeywordhash.c\n"
   "**\n"
   "** The code in this file implements a function that determines whether\n"
   "** or not a given identifier is really an SQL keyword.  The same thing\n"
   "** might be implemented more directly using a hand-written hash table.\n"
   "** But by using this automatically generated code, the size of the code\n"
   "** is substantially reduced.  This is important for embedded applications\n"
   "** on platforms with limited memory.\n"
   "*/\n"
 ;
 
@@ skipping 107 matching lines @@
 #  define AUTOVACUUM 0
 #else
 #  define AUTOVACUUM 0x00020000
 #endif
 
 /*
 ** These are the keywords
 */
 static Keyword aKeywordTable[] = {
   { "ABORT",            "TK_ABORT",        CONFLICT|TRIGGER       },
+  { "ACTION",           "TK_ACTION",       FKEY                   },
   { "ADD",              "TK_ADD",          ALTER                  },
   { "AFTER",            "TK_AFTER",        TRIGGER                },
   { "ALL",              "TK_ALL",          ALWAYS                 },
   { "ALTER",            "TK_ALTER",        ALTER                  },
   { "ANALYZE",          "TK_ANALYZE",      ANALYZE                },
   { "AND",              "TK_AND",          ALWAYS                 },
   { "AS",               "TK_AS",           ALWAYS                 },
   { "ASC",              "TK_ASC",          ALWAYS                 },
   { "ATTACH",           "TK_ATTACH",       ATTACH                 },
   { "AUTOINCREMENT",    "TK_AUTOINCR",     AUTOINCR               },
@@ skipping 54 matching lines @@
   { "INTO",             "TK_INTO",         ALWAYS                 },
   { "IS",               "TK_IS",           ALWAYS                 },
   { "ISNULL",           "TK_ISNULL",       ALWAYS                 },
   { "JOIN",             "TK_JOIN",         ALWAYS                 },
   { "KEY",              "TK_KEY",          ALWAYS                 },
   { "LEFT",             "TK_JOIN_KW",      ALWAYS                 },
   { "LIKE",             "TK_LIKE_KW",      ALWAYS                 },
   { "LIMIT",            "TK_LIMIT",        ALWAYS                 },
   { "MATCH",            "TK_MATCH",        ALWAYS                 },
   { "NATURAL",          "TK_JOIN_KW",      ALWAYS                 },
+  { "NO",               "TK_NO",           FKEY                   },
   { "NOT",              "TK_NOT",          ALWAYS                 },
   { "NOTNULL",          "TK_NOTNULL",      ALWAYS                 },
   { "NULL",             "TK_NULL",         ALWAYS                 },
   { "OF",               "TK_OF",           ALWAYS                 },
   { "OFFSET",           "TK_OFFSET",       ALWAYS                 },
   { "ON",               "TK_ON",           ALWAYS                 },
   { "OR",               "TK_OR",           ALWAYS                 },
   { "ORDER",            "TK_ORDER",        ALWAYS                 },
   { "OUTER",            "TK_JOIN_KW",      ALWAYS                 },
   { "PLAN",             "TK_PLAN",         EXPLAIN                },
@@ skipping 61 matching lines @@
 /*
 ** Comparision function for two Keyword records
 */
 static int keywordCompare1(const void *a, const void *b){
   const Keyword *pA = (Keyword*)a;
   const Keyword *pB = (Keyword*)b;
   int n = pA->len - pB->len;
   if( n==0 ){
     n = strcmp(pA->zName, pB->zName);
   }
+  assert( n!=0 );
   return n;
 }
 static int keywordCompare2(const void *a, const void *b){
   const Keyword *pA = (Keyword*)a;
   const Keyword *pB = (Keyword*)b;
   int n = pB->longestSuffix - pA->longestSuffix;
   if( n==0 ){
     n = strcmp(pA->zName, pB->zName);
   }
+  assert( n!=0 );
   return n;
 }
 static int keywordCompare3(const void *a, const void *b){
   const Keyword *pA = (Keyword*)a;
   const Keyword *pB = (Keyword*)b;
   int n = pA->offset - pB->offset;
+  if( n==0 ) n = pB->id - pA->id;
+  assert( n!=0 );
   return n;
 }
 
 /*
 ** Return a KeywordTable entry with the given id
 */
 static Keyword *findById(int id){
   int i;
   for(i=0; i<nKeyword; i++){
     if( aKeywordTable[i].id==id ) break;
@@ skipping 256 matching lines @@
            i, aKeywordTable[i].zOrigName);
   }
   printf("      return aCode[i];\n");
   printf("    }\n");
   printf("  }\n");
   printf("  return TK_ID;\n");
   printf("}\n");
   printf("int sqlite3KeywordCode(const unsigned char *z, int n){\n");
   printf("  return keywordCode((char*)z, n);\n");
   printf("}\n");
+  printf("#define SQLITE_N_KEYWORD %d\n", nKeyword);
 
   return 0;
 }