Import SQLite 3.8.7.4.

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>
 
@@ skipping 120 matching lines @@
 #ifdef SQLITE_OMIT_VIRTUALTABLE
 #  define VTAB       0
 #else
 #  define VTAB       0x00010000
 #endif
 #ifdef SQLITE_OMIT_AUTOVACUUM
 #  define AUTOVACUUM 0
 #else
 #  define AUTOVACUUM 0x00020000
 #endif
+#ifdef SQLITE_OMIT_CTE
+#  define CTE        0
+#else
+#  define CTE        0x00040000
+#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                 },
@@ skipping 76 matching lines @@
   { "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                },
   { "PRAGMA",           "TK_PRAGMA",       PRAGMA                 },
   { "PRIMARY",          "TK_PRIMARY",      ALWAYS                 },
   { "QUERY",            "TK_QUERY",        EXPLAIN                },
   { "RAISE",            "TK_RAISE",        TRIGGER                },
+  { "RECURSIVE",        "TK_RECURSIVE",    CTE                    },
   { "REFERENCES",       "TK_REFERENCES",   FKEY                   },
   { "REGEXP",           "TK_LIKE_KW",      ALWAYS                 },
   { "REINDEX",          "TK_REINDEX",      REINDEX                },
   { "RELEASE",          "TK_RELEASE",      ALWAYS                 },
   { "RENAME",           "TK_RENAME",       ALTER                  },
   { "REPLACE",          "TK_REPLACE",      CONFLICT               },
   { "RESTRICT",         "TK_RESTRICT",     FKEY                   },
   { "RIGHT",            "TK_JOIN_KW",      ALWAYS                 },
   { "ROLLBACK",         "TK_ROLLBACK",     ALWAYS                 },
   { "ROW",              "TK_ROW",          TRIGGER                },
   { "SAVEPOINT",        "TK_SAVEPOINT",    ALWAYS                 },
   { "SELECT",           "TK_SELECT",       ALWAYS                 },
   { "SET",              "TK_SET",          ALWAYS                 },
   { "TABLE",            "TK_TABLE",        ALWAYS                 },
   { "TEMP",             "TK_TEMP",         ALWAYS                 },
   { "TEMPORARY",        "TK_TEMP",         ALWAYS                 },
   { "THEN",             "TK_THEN",         ALWAYS                 },
   { "TO",               "TK_TO",           ALWAYS                 },
   { "TRANSACTION",      "TK_TRANSACTION",  ALWAYS                 },
   { "TRIGGER",          "TK_TRIGGER",      TRIGGER                },
   { "UNION",            "TK_UNION",        COMPOUND               },
   { "UNIQUE",           "TK_UNIQUE",       ALWAYS                 },
   { "UPDATE",           "TK_UPDATE",       ALWAYS                 },
   { "USING",            "TK_USING",        ALWAYS                 },
   { "VACUUM",           "TK_VACUUM",       VACUUM                 },
   { "VALUES",           "TK_VALUES",       ALWAYS                 },
   { "VIEW",             "TK_VIEW",         VIEW                   },
   { "VIRTUAL",          "TK_VIRTUAL",      VTAB                   },
+  { "WITH",             "TK_WITH",         CTE                    },
+  { "WITHOUT",          "TK_WITHOUT",      ALWAYS                 },
   { "WHEN",             "TK_WHEN",         ALWAYS                 },
   { "WHERE",            "TK_WHERE",        ALWAYS                 },
 };
 
 /* Number of keywords */
 static int nKeyword = (sizeof(aKeywordTable)/sizeof(aKeywordTable[0]));
 
 /* An array to map all upper-case characters into their corresponding
 ** lower-case character. 
 */
@@ skipping 78 matching lines @@
     if( j<i ){
       aKeywordTable[j] = aKeywordTable[i];
     }
     j++;
   }
   nKeyword = j;
 
   /* Fill in the lengths of strings and hashes for all entries. */
   for(i=0; i<nKeyword; i++){
     Keyword *p = &aKeywordTable[i];
-    p->len = strlen(p->zName);
+    p->len = (int)strlen(p->zName);
     assert( p->len<sizeof(p->zOrigName) );
-    strcpy(p->zOrigName, p->zName);
+    memcpy(p->zOrigName, p->zName, p->len+1);
     totalLen += p->len;
     p->hash = (UpperToLower[(int)p->zName[0]]*4) ^
               (UpperToLower[(int)p->zName[p->len-1]]*3) ^ p->len;
     p->id = i+1;
   }
 
   /* Sort the table from shortest to longest keyword */
   qsort(aKeywordTable, nKeyword, sizeof(aKeywordTable[0]), keywordCompare1);
 
   /* Look for short keywords embedded in longer keywords */
@@ skipping 217 matching lines @@
   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;
 }