From 52fb6d71f5b89e1b0b37029ce199dd55080fbfa8 Mon Sep 17 00:00:00 2001 From: drh Date: Wed, 3 Nov 2004 03:59:57 +0000 Subject: [PATCH] The makefile now runs mkkeywordhash.c. Keywords that are unused are omitted from the keyword hash table. (CVS 2045) FossilOrigin-Name: 007aec11333432e08d1091b728773011e9078bc3 --- Makefile.in | 19 ++- main.mk | 12 +- manifest | 22 ++-- manifest.uuid | 2 +- src/parse.y | 3 +- src/tokenize.c | 101 ++-------------- tool/mkkeywordhash.c | 282 ++++++++++++++++++++++++++++--------------- 7 files changed, 225 insertions(+), 216 deletions(-) diff --git a/Makefile.in b/Makefile.in index d1fc8c3d69..d662686d4d 100644 --- a/Makefile.in +++ b/Makefile.in @@ -77,6 +77,8 @@ TEMP_STORE = -DTEMP_STORE=@TEMP_STORE@ # You should not have to change anything below this line ############################################################################### +BEXE = @BUILD_EXEEXT@ + # Object files for the SQLite library. # LIBOBJ = attach.lo auth.lo btree.lo build.lo date.lo delete.lo \ @@ -211,17 +213,17 @@ sqlite3@TARGET_EXEEXT@: $(TOP)/src/shell.c libsqlite3.la sqlite3.h # files are automatically generated. This target takes care of # all that automatic generation. # -target_source: $(SRC) $(VDBEHDR) +target_source: $(SRC) parse.c opcodes.c keywordhash.c $(VDBEHDR) rm -rf tsrc mkdir -p tsrc cp $(SRC) $(VDBEHDR) tsrc rm tsrc/sqlite.h.in tsrc/parse.y - cp parse.c opcodes.c tsrc + cp parse.c opcodes.c keywordhash.c tsrc cp $(TOP)/sqlite3.def tsrc # Rules to build the LEMON compiler generator # -lemon@BUILD_EXEEXT@: $(TOP)/tool/lemon.c $(TOP)/tool/lempar.c +lemon$(BEXE): $(TOP)/tool/lemon.c $(TOP)/tool/lempar.c $(BCC) -o lemon $(TOP)/tool/lemon.c cp $(TOP)/tool/lempar.c . @@ -306,7 +308,7 @@ parse.lo: parse.c $(HDR) parse.h: parse.c -parse.c: $(TOP)/src/parse.y lemon@BUILD_EXEEXT@ +parse.c: $(TOP)/src/parse.y lemon$(BEXE) cp $(TOP)/src/parse.y . ./lemon $(OPTS) parse.y @@ -332,9 +334,13 @@ table.lo: $(TOP)/src/table.c $(HDR) tclsqlite.lo: $(TOP)/src/tclsqlite.c $(HDR) $(LTCOMPILE) $(TCL_FLAGS) -c $(TOP)/src/tclsqlite.c -tokenize.lo: $(TOP)/src/tokenize.c $(HDR) +tokenize.lo: $(TOP)/src/tokenize.c keywordhash.c $(HDR) $(LTCOMPILE) -c $(TOP)/src/tokenize.c +keywordhash.c: $(TOP)/tool/mkkeywordhash.c + $(BCC) -o mkkeywordhash$(BEXE) $(OPTS) $(TOP)/tool/mkkeywordhash.c + ./mkkeywordhash$(BEXE) >keywordhash.c + trigger.lo: $(TOP)/src/trigger.c $(HDR) $(LTCOMPILE) -c $(TOP)/src/trigger.c @@ -554,7 +560,8 @@ clean: rm -f *.lo *.la *.o sqlite3@TARGET_EXEEXT@ libsqlite3.la rm -f sqlite3.h opcodes.* rm -rf .libs .deps - rm -f lemon@BUILD_EXEEXT@ lempar.c parse.* sqlite*.tar.gz + rm -f lemon$(BEXE) lempar.c parse.* sqlite*.tar.gz + rm -f mkkeywordhash$(BEXE) keywordhash.c rm -f $(PUBLISH) rm -f *.da *.bb *.bbg gmon.out rm -f testfixture@TARGET_EXEEXT@ test.db diff --git a/main.mk b/main.mk index f2b81ebe0b..d517773ed0 100644 --- a/main.mk +++ b/main.mk @@ -181,12 +181,12 @@ objects: $(LIBOBJ_ORIG) # files are automatically generated. This target takes care of # all that automatic generation. # -target_source: $(SRC) $(VDBEHDR) opcodes.c +target_source: $(SRC) $(VDBEHDR) opcodes.c keyworkhash.c rm -rf tsrc mkdir tsrc cp $(SRC) $(VDBEHDR) tsrc rm tsrc/sqlite.h.in tsrc/parse.y - cp parse.c opcodes.c tsrc + cp parse.c opcodes.c keywordhash.c tsrc cp $(TOP)/sqlite3.def tsrc # Rules to build the LEMON compiler generator @@ -302,9 +302,13 @@ table.o: $(TOP)/src/table.c $(HDR) tclsqlite.o: $(TOP)/src/tclsqlite.c $(HDR) $(TCCX) $(TCL_FLAGS) -c $(TOP)/src/tclsqlite.c -tokenize.o: $(TOP)/src/tokenize.c $(HDR) +tokenize.o: $(TOP)/src/tokenize.c keywordhash.c $(HDR) $(TCCX) -c $(TOP)/src/tokenize.c +keywordhash.c: $(TOP)/tool/mkkeywordhash.c + $(BCC) -o mkkeywordhash $(OPTS) $(TOP)/tool/mkkeywordhash.c + ./mkkeywordhash >keywordhash.c + trigger.o: $(TOP)/src/trigger.c $(HDR) $(TCCX) -c $(TOP)/src/trigger.c @@ -527,7 +531,7 @@ install: sqlite3 libsqlite3.a sqlite3.h clean: rm -f *.o sqlite3 libsqlite3.a sqlite3.h opcodes.* - rm -f lemon lempar.c parse.* sqlite*.tar.gz + rm -f lemon lempar.c parse.* sqlite*.tar.gz mkkeywordhash keywordhash.c rm -f $(PUBLISH) rm -f *.da *.bb *.bbg gmon.out rm -rf tsrc diff --git a/manifest b/manifest index 65b980d5c8..e289ceb2e6 100644 --- a/manifest +++ b/manifest @@ -1,6 +1,6 @@ -C Auto-vacuum\sbugfix:\sDo\snot\sattempt\sto\smove\sa\spointer-map\spage\sduring\sauto-vacuum.\s(CVS\s2044) -D 2004-11-03T03:52:37 -F Makefile.in 9e90c685d69f09039015a6b1f3b0a48e9738c9e5 +C The\smakefile\snow\sruns\smkkeywordhash.c.\s\sKeywords\sthat\sare\sunused\sare\nomitted\sfrom\sthe\skeyword\shash\stable.\s(CVS\s2045) +D 2004-11-03T03:59:57 +F Makefile.in c4d2416860f472a1e3393714d0372074197565df F Makefile.linux-gcc a9e5a0d309fa7c38e7c14d3ecf7690879d3a5457 F README a01693e454a00cc117967e3f9fdab2d4d52e9bc1 F VERSION 342b6d5fde93b6d45023e2fee0163dda6464b9d6 @@ -16,7 +16,7 @@ F doc/lemon.html f0f682f50210928c07e562621c3b7e8ab912a538 F doc/report1.txt a031aaf37b185e4fa540223cb516d3bccec7eeac F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 F ltmain.sh f6b283068efa69f06eb8aa1fe4bddfdbdeb35826 -F main.mk c7c97f809e5e7897bc843db64f692c7ef9013a92 +F main.mk 594a756a761111da9415ca4b1ca7cbf3d269a3a3 F mkdll.sh 468d4f41d3ea98221371df4825cfbffbaac4d7e4 F mkopcodec.awk 14a794f7b206976afc416b30fe8e0fc97f3434e9 F mkopcodeh.awk 4090944e4de0a2ccb99aa0083290f73bce4db406 @@ -54,7 +54,7 @@ F src/os_win.c 9482dfc92f289b68205bb2c9315757c7e3946bfb F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b F src/pager.c 6b00c0d5aac601b9f556b8fdba25e69438245f1a F src/pager.h cbe4ba356d9dd3f30260f322b3dc77408164df14 -F src/parse.y 08f4971f89e651f47b3f83fe7369c7edde254331 +F src/parse.y 625750bf4b01a7c2b4c15e5367a7539a66e6c909 F src/pragma.c 44e192eb5928157bdb015926f858a7c6e3ef6c98 F src/printf.c 7a92adc00b758cd5ce087dae80181a8bbdb70ed2 F src/random.c eff68e3f257e05e81eae6c4d50a51eb88beb4ff3 @@ -69,7 +69,7 @@ F src/test2.c b11fa244fff02190707dd0879987c37c75e61fc8 F src/test3.c f423597e220b3d446a65c9cc0c49cb4eb00c0215 F src/test4.c 7c6b9fc33dd1f3f93c7f1ee6e5e6d016afa6c1df F src/test5.c b001fa7f1b9e2dc5c2331de62fc641b5ab2bd7a1 -F src/tokenize.c a0a999bf4800e7295ac66c8694f84414ceff1755 +F src/tokenize.c bf9de9689b3bb813d65784bf54472804bf9595e6 F src/trigger.c f9a0a8d3a87238de1a934eeb7d0b6b1f13e6a55b F src/update.c ee15b7ba712c2292802eba2d465f039b5deada39 F src/utf.c f4f83acd73389090e32d6589d307fc55d794c7ed @@ -201,7 +201,7 @@ F tool/lempar.c 1e61d2b6cb9d8affa264a13336bc0c088498caa4 F tool/memleak.awk b744b6109566206c746d826f6ecdba34662216bc F tool/memleak2.awk 9cc20c8e8f3c675efac71ea0721ee6874a1566e8 F tool/memleak3.tcl 336eb50b0849dbf99b1d5462d9c37291b01b2b43 -F tool/mkkeywordhash.c ed1f2a21a4e7f2757281c4cf7a8392c0e0ad2d5d +F tool/mkkeywordhash.c f1cb22f47cc6c60d50ac4af19a55c0e8757ac92c F tool/mkopts.tcl 66ac10d240cc6e86abd37dc908d50382f84ff46e x F tool/opcodeDoc.awk b3a2a3d5d3075b8bd90b7afe24283efdd586659c F tool/report1.txt 9eae07f26a8fc53889b45fc833a66a33daa22816 @@ -252,7 +252,7 @@ F www/tclsqlite.tcl 560ecd6a916b320e59f2917317398f3d59b7cc25 F www/vdbe.tcl 59288db1ac5c0616296b26dce071c36cb611dfe9 F www/version3.tcl 092a01f5ef430d2c4acc0ae558d74c4bb89638a0 F www/whentouse.tcl fdacb0ba2d39831e8a6240d05a490026ad4c4e4c -P b7d953e1195897de4869ec241a65e8a3d1320efb -R e185cf7676cc794eee9060c09350688b -U danielk1977 -Z 0648ce34f782ce635735be96e8684487 +P bd50fbb5fecd1829c87e8ca72c458c71f590274b +R c93f4ae3ede116e4f0e25ff57fd95e47 +U drh +Z 2a91aed8200460991cb047467354dda3 diff --git a/manifest.uuid b/manifest.uuid index 8c4d612636..0b8c94064b 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -bd50fbb5fecd1829c87e8ca72c458c71f590274b \ No newline at end of file +007aec11333432e08d1091b728773011e9078bc3 \ No newline at end of file diff --git a/src/parse.y b/src/parse.y index 8a4ee62e3d..c918d4554f 100644 --- a/src/parse.y +++ b/src/parse.y @@ -14,7 +14,7 @@ ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** -** @(#) $Id: parse.y,v 1.145 2004/10/31 02:22:49 drh Exp $ +** @(#) $Id: parse.y,v 1.146 2004/11/03 03:59:57 drh Exp $ */ %token_prefix TK_ %token_type {Token} @@ -150,6 +150,7 @@ id(A) ::= ID(X). {A = X;} %ifdef SQLITE_OMIT_COMPOUND_SELECT EXCEPT INTERSECT UNION %endif + REINDEX RENAME AUTOINCR CDATE CTIME CTIMESTAMP ALTER . // Define operator precedence early so that this is the first occurance diff --git a/src/tokenize.c b/src/tokenize.c index 574077d679..ff2d3d2f51 100644 --- a/src/tokenize.c +++ b/src/tokenize.c @@ -15,7 +15,7 @@ ** individual tokens and sends those tokens one-by-one over to the ** parser for analysis. ** -** $Id: tokenize.c,v 1.93 2004/10/31 02:22:49 drh Exp $ +** $Id: tokenize.c,v 1.94 2004/11/03 03:59:58 drh Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -23,104 +23,17 @@ #include /* -** This function looks up an identifier to determine if it is a -** keyword. If it is a keyword, the token code of that keyword is +** The sqlite3KeywordCode function looks up an identifier to determine if +** it is a keyword. If it is a keyword, the token code of that keyword is ** returned. If the input is not a keyword, TK_ID is returned. ** ** The implementation of this routine was generated by a program, ** mkkeywordhash.c, located in the tool subdirectory of the distribution. -** The output of the mkkeywordhash.c program was manually cut and pasted -** into this file. When the set of keywords for SQLite changes, you -** must modify the mkkeywordhash.c program (to add or remove keywords from -** the data tables) then rerun that program to regenerate this function. +** The output of the mkkeywordhash.c program is written into a file +** named keywordhash.c and then included into this source file by +** the #include below. */ -int sqlite3KeywordCode(const char *z, int n){ - static const char zText[443] = - "ABORTABLEFTEMPORARYAFTERAISELECTHENDATABASEACHECKEYANDEFAULTRANSACTION" - "ATURALIKELSEXCEPTRIGGEREFERENCESTATEMENTATTACHAVINGLOBEFOREIGN" - "OREPLACEXCLUSIVEXPLAINDEXBEGINITIALLYBETWEENOTNULLIMITBYCASCADE" - "FERRABLECASECOLLATECOMMITCONFLICTCONSTRAINTERSECTCREATECROSSDEFERRED" - "ELETEDESCDETACHDISTINCTDROPRAGMATCHFAILFROMFULLGROUPDATEIMMEDIATE" - "INNERESTRICTINSERTINSTEADINTOFFSETISNULLJOINORDERIGHTOUTEROLLBACK" - "PRIMARYROWHENUNIONUNIQUEUSINGVACUUMVALUESVIEWHERE"; - static const unsigned char aHash[154] = { - 0, 26, 82, 0, 0, 91, 90, 0, 27, 0, 0, 0, 0, - 0, 0, 49, 0, 96, 17, 0, 0, 0, 0, 0, 0, 0, - 0, 97, 5, 31, 0, 62, 51, 28, 58, 52, 0, 0, 60, - 61, 0, 12, 41, 50, 0, 0, 0, 36, 63, 0, 0, 15, - 0, 0, 0, 39, 0, 42, 0, 0, 0, 0, 78, 0, 34, - 29, 0, 74, 71, 0, 66, 70, 37, 0, 0, 59, 0, 33, - 0, 53, 0, 54, 0, 55, 0, 83, 72, 67, 0, 24, 0, - 0, 79, 80, 84, 0, 0, 0, 0, 0, 0, 0, 75, 0, - 0, 0, 0, 0, 45, 77, 35, 44, 57, 0, 0, 0, 0, - 20, 2, 0, 38, 0, 3, 46, 93, 0, 0, 40, 0, 94, - 0, 43, 87, 98, 0, 0, 0, 0, 0, 81, 0, 0, 0, - 0, 10, 0, 0, 0, 0, 0, 92, 19, 0, 95, - }; - static const unsigned char aNext[98] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, - 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, - 0, 0, 0, 0, 0, 18, 22, 0, 0, 0, 0, 0, 0, - 0, 23, 0, 16, 21, 8, 0, 32, 0, 0, 30, 0, 48, - 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, - 0, 56, 0, 1, 0, 69, 64, 0, 0, 65, 0, 0, 13, - 68, 0, 0, 76, 47, 0, 0, 0, 85, 6, 0, 89, 25, - 4, 73, 88, 86, 0, 0, 0, - }; - static const unsigned char aLen[98] = { - 5, 5, 4, 4, 9, 2, 5, 5, 6, 4, 3, 8, 2, - 4, 5, 3, 3, 7, 11, 2, 7, 4, 4, 6, 7, 10, - 9, 6, 6, 4, 6, 3, 7, 6, 7, 9, 7, 5, 5, - 9, 3, 7, 3, 7, 4, 5, 2, 7, 3, 10, 4, 7, - 6, 8, 10, 2, 9, 6, 5, 8, 6, 4, 6, 8, 2, - 4, 6, 5, 4, 4, 4, 5, 6, 9, 5, 8, 6, 7, - 4, 2, 6, 3, 6, 4, 5, 5, 5, 8, 7, 3, 4, - 5, 6, 5, 6, 6, 4, 5, - }; - static const unsigned short int aOffset[98] = { - 0, 4, 7, 10, 10, 14, 19, 23, 26, 31, 33, 35, 40, - 42, 44, 48, 51, 53, 59, 68, 69, 75, 78, 81, 86, 92, - 101, 110, 115, 120, 123, 125, 125, 129, 133, 139, 147, 152, 157, - 160, 165, 169, 175, 175, 178, 181, 186, 188, 189, 193, 203, 207, - 214, 220, 228, 235, 235, 244, 250, 255, 262, 268, 272, 278, 279, - 286, 289, 293, 298, 302, 306, 310, 313, 319, 328, 332, 340, 346, - 353, 356, 356, 359, 362, 368, 372, 376, 381, 385, 393, 400, 402, - 406, 411, 417, 422, 428, 434, 437, - }; - static const unsigned char aCode[98] = { - TK_ABORT, TK_TABLE, TK_JOIN_KW, TK_TEMP, TK_TEMP, - TK_OR, TK_AFTER, TK_RAISE, TK_SELECT, TK_THEN, - TK_END, TK_DATABASE, TK_AS, TK_EACH, TK_CHECK, - TK_KEY, TK_AND, TK_DEFAULT, TK_TRANSACTION,TK_ON, - TK_JOIN_KW, TK_LIKE, TK_ELSE, TK_EXCEPT, TK_TRIGGER, - TK_REFERENCES, TK_STATEMENT, TK_ATTACH, TK_HAVING, TK_GLOB, - TK_BEFORE, TK_FOR, TK_FOREIGN, TK_IGNORE, TK_REPLACE, - TK_EXCLUSIVE, TK_EXPLAIN, TK_INDEX, TK_BEGIN, TK_INITIALLY, - TK_ALL, TK_BETWEEN, TK_NOT, TK_NOTNULL, TK_NULL, - TK_LIMIT, TK_BY, TK_CASCADE, TK_ASC, TK_DEFERRABLE, - TK_CASE, TK_COLLATE, TK_COMMIT, TK_CONFLICT, TK_CONSTRAINT, - TK_IN, TK_INTERSECT, TK_CREATE, TK_JOIN_KW, TK_DEFERRED, - TK_DELETE, TK_DESC, TK_DETACH, TK_DISTINCT, TK_IS, - TK_DROP, TK_PRAGMA, TK_MATCH, TK_FAIL, TK_FROM, - TK_JOIN_KW, TK_GROUP, TK_UPDATE, TK_IMMEDIATE, TK_JOIN_KW, - TK_RESTRICT, TK_INSERT, TK_INSTEAD, TK_INTO, TK_OF, - TK_OFFSET, TK_SET, TK_ISNULL, TK_JOIN, TK_ORDER, - TK_JOIN_KW, TK_JOIN_KW, TK_ROLLBACK, TK_PRIMARY, TK_ROW, - TK_WHEN, TK_UNION, TK_UNIQUE, TK_USING, TK_VACUUM, - TK_VALUES, TK_VIEW, TK_WHERE, - }; - int h, i; - if( n<2 ) return TK_ID; - h = (sqlite3UpperToLower[((unsigned char*)z)[0]]*5 + - sqlite3UpperToLower[((unsigned char*)z)[n-1]]*3 + - n) % 154; - for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){ - if( aLen[i]==n && sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){ - return aCode[i]; - } - } - return TK_ID; -} +#include "keywordhash.c" /* diff --git a/tool/mkkeywordhash.c b/tool/mkkeywordhash.c index 6fb90446e5..e601feba0f 100644 --- a/tool/mkkeywordhash.c +++ b/tool/mkkeywordhash.c @@ -15,6 +15,7 @@ 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 id; /* Unique ID for this record */ int hash; /* Hash on the keyword */ int offset; /* Offset to start of name string */ @@ -25,112 +26,185 @@ struct Keyword { int substrOffset; /* Offset into substrId for start of this keyword */ }; +/* +** Define masks used to determine which keywords are allowed +*/ +#ifdef SQLITE_OMIT_ALTER_TABLE +# define ALTER 0 +#else +# define ALTER 1 +#endif +#define ALWAYS 2 +#ifdef SQLITE_OMIT_ATTACH +# define ATTACH 0 +#else +# define ATTACH 4 +#endif +#ifdef SQLITE_OMIT_AUTOINCREMENT +# define AUTOINCR 0 +#else +# define AUTOINCR 8 +#endif +#ifdef SQLITE_OMIT_COMPOUND_SELECT +# define COMPOUND 0 +#else +# define COMPOUND 16 +#endif +#ifdef SQLITE_OMIT_CONFLICT_CLAUSE +# define CONFLICT 0 +#else +# define CONFLICT 32 +#endif +#ifdef SQLITE_OMIT_EXPLAIN +# define EXPLAIN 0 +#else +# define EXPLAIN 64 +#endif +#ifdef SQLITE_OMIT_FOREIGN_KEY +# define FKEY 0 +#else +# define FKEY 128 +#endif +#ifdef SQLITE_OMIT_PRAGMA +# define PRAGMA 0 +#else +# define PRAGMA 256 +#endif +#ifdef SQLITE_OMIT_REINDEX +# define REINDEX 0 +#else +# define REINDEX 512 +#endif +#ifdef SQLITE_OMIT_TRIGGER +# define TRIGGER 0 +#else +# define TRIGGER 1024 +#endif +#ifdef SQLITE_OMIT_VACUUM +# define VACUUM 0 +#else +# define VACUUM 2048 +#endif +#ifdef SQLITE_OMIT_VIEW +# define VIEW 0 +#else +# define VIEW 4096 +#endif + + /* ** These are the keywords */ static Keyword aKeywordTable[] = { - { "ABORT", "TK_ABORT", }, - { "AFTER", "TK_AFTER", }, - { "ALL", "TK_ALL", }, - { "AND", "TK_AND", }, - { "AS", "TK_AS", }, - { "ASC", "TK_ASC", }, - { "ATTACH", "TK_ATTACH", }, - { "BEFORE", "TK_BEFORE", }, - { "BEGIN", "TK_BEGIN", }, - { "BETWEEN", "TK_BETWEEN", }, - { "BY", "TK_BY", }, - { "CASCADE", "TK_CASCADE", }, - { "CASE", "TK_CASE", }, - { "CHECK", "TK_CHECK", }, - { "COLLATE", "TK_COLLATE", }, - { "COMMIT", "TK_COMMIT", }, - { "CONFLICT", "TK_CONFLICT", }, - { "CONSTRAINT", "TK_CONSTRAINT", }, - { "CREATE", "TK_CREATE", }, - { "CROSS", "TK_JOIN_KW", }, - { "DATABASE", "TK_DATABASE", }, - { "DEFAULT", "TK_DEFAULT", }, - { "DEFERRED", "TK_DEFERRED", }, - { "DEFERRABLE", "TK_DEFERRABLE", }, - { "DELETE", "TK_DELETE", }, - { "DESC", "TK_DESC", }, - { "DETACH", "TK_DETACH", }, - { "DISTINCT", "TK_DISTINCT", }, - { "DROP", "TK_DROP", }, - { "END", "TK_END", }, - { "EACH", "TK_EACH", }, - { "ELSE", "TK_ELSE", }, - { "EXCEPT", "TK_EXCEPT", }, - { "EXCLUSIVE", "TK_EXCLUSIVE", }, - { "EXPLAIN", "TK_EXPLAIN", }, - { "FAIL", "TK_FAIL", }, - { "FOR", "TK_FOR", }, - { "FOREIGN", "TK_FOREIGN", }, - { "FROM", "TK_FROM", }, - { "FULL", "TK_JOIN_KW", }, - { "GLOB", "TK_GLOB", }, - { "GROUP", "TK_GROUP", }, - { "HAVING", "TK_HAVING", }, - { "IGNORE", "TK_IGNORE", }, - { "IMMEDIATE", "TK_IMMEDIATE", }, - { "IN", "TK_IN", }, - { "INDEX", "TK_INDEX", }, - { "INITIALLY", "TK_INITIALLY", }, - { "INNER", "TK_JOIN_KW", }, - { "INSERT", "TK_INSERT", }, - { "INSTEAD", "TK_INSTEAD", }, - { "INTERSECT", "TK_INTERSECT", }, - { "INTO", "TK_INTO", }, - { "IS", "TK_IS", }, - { "ISNULL", "TK_ISNULL", }, - { "JOIN", "TK_JOIN", }, - { "KEY", "TK_KEY", }, - { "LEFT", "TK_JOIN_KW", }, - { "LIKE", "TK_LIKE", }, - { "LIMIT", "TK_LIMIT", }, - { "MATCH", "TK_MATCH", }, - { "NATURAL", "TK_JOIN_KW", }, - { "NOT", "TK_NOT", }, - { "NOTNULL", "TK_NOTNULL", }, - { "NULL", "TK_NULL", }, - { "OF", "TK_OF", }, - { "OFFSET", "TK_OFFSET", }, - { "ON", "TK_ON", }, - { "OR", "TK_OR", }, - { "ORDER", "TK_ORDER", }, - { "OUTER", "TK_JOIN_KW", }, - { "PRAGMA", "TK_PRAGMA", }, - { "PRIMARY", "TK_PRIMARY", }, - { "RAISE", "TK_RAISE", }, - { "REFERENCES", "TK_REFERENCES", }, - { "REPLACE", "TK_REPLACE", }, - { "RESTRICT", "TK_RESTRICT", }, - { "RIGHT", "TK_JOIN_KW", }, - { "ROLLBACK", "TK_ROLLBACK", }, - { "ROW", "TK_ROW", }, - { "SELECT", "TK_SELECT", }, - { "SET", "TK_SET", }, - { "STATEMENT", "TK_STATEMENT", }, - { "TABLE", "TK_TABLE", }, - { "TEMP", "TK_TEMP", }, - { "TEMPORARY", "TK_TEMP", }, - { "THEN", "TK_THEN", }, - { "TRANSACTION", "TK_TRANSACTION", }, - { "TRIGGER", "TK_TRIGGER", }, - { "UNION", "TK_UNION", }, - { "UNIQUE", "TK_UNIQUE", }, - { "UPDATE", "TK_UPDATE", }, - { "USING", "TK_USING", }, - { "VACUUM", "TK_VACUUM", }, - { "VALUES", "TK_VALUES", }, - { "VIEW", "TK_VIEW", }, - { "WHEN", "TK_WHEN", }, - { "WHERE", "TK_WHERE", }, + { "ABORT", "TK_ABORT", CONFLICT|TRIGGER }, + { "AFTER", "TK_AFTER", TRIGGER }, + { "ALL", "TK_ALL", ALWAYS }, + { "ALTER", "TK_ALTER", ALTER }, + { "AND", "TK_AND", ALWAYS }, + { "AS", "TK_AS", ALWAYS }, + { "ASC", "TK_ASC", ALWAYS }, + { "ATTACH", "TK_ATTACH", ATTACH }, + { "AUTOINCREMENT", "TK_AUTOINCR", AUTOINCR }, + { "BEFORE", "TK_BEFORE", TRIGGER }, + { "BEGIN", "TK_BEGIN", ALWAYS }, + { "BETWEEN", "TK_BETWEEN", ALWAYS }, + { "BY", "TK_BY", ALWAYS }, + { "CASCADE", "TK_CASCADE", FKEY }, + { "CASE", "TK_CASE", ALWAYS }, + { "CHECK", "TK_CHECK", ALWAYS }, + { "COLLATE", "TK_COLLATE", ALWAYS }, + { "COMMIT", "TK_COMMIT", ALWAYS }, + { "CONFLICT", "TK_CONFLICT", CONFLICT }, + { "CONSTRAINT", "TK_CONSTRAINT", ALWAYS }, + { "CREATE", "TK_CREATE", ALWAYS }, + { "CROSS", "TK_JOIN_KW", ALWAYS }, + { "CURRENT_DATE", "TK_CDATE", ALWAYS }, + { "CURRENT_TIME", "TK_CTIME", ALWAYS }, + { "CURRENT_TIMESTAMP","TK_CTIMESTAMP", ALWAYS }, + { "DATABASE", "TK_DATABASE", ATTACH }, + { "DEFAULT", "TK_DEFAULT", ALWAYS }, + { "DEFERRED", "TK_DEFERRED", FKEY }, + { "DEFERRABLE", "TK_DEFERRABLE", FKEY }, + { "DELETE", "TK_DELETE", ALWAYS }, + { "DESC", "TK_DESC", ALWAYS }, + { "DETACH", "TK_DETACH", ATTACH }, + { "DISTINCT", "TK_DISTINCT", ALWAYS }, + { "DROP", "TK_DROP", ALWAYS }, + { "END", "TK_END", ALWAYS }, + { "EACH", "TK_EACH", TRIGGER }, + { "ELSE", "TK_ELSE", ALWAYS }, + { "EXCEPT", "TK_EXCEPT", COMPOUND }, + { "EXCLUSIVE", "TK_EXCLUSIVE", ALWAYS }, + { "EXPLAIN", "TK_EXPLAIN", EXPLAIN }, + { "FAIL", "TK_FAIL", CONFLICT|TRIGGER }, + { "FOR", "TK_FOR", TRIGGER }, + { "FOREIGN", "TK_FOREIGN", FKEY }, + { "FROM", "TK_FROM", ALWAYS }, + { "FULL", "TK_JOIN_KW", ALWAYS }, + { "GLOB", "TK_GLOB", ALWAYS }, + { "GROUP", "TK_GROUP", ALWAYS }, + { "HAVING", "TK_HAVING", ALWAYS }, + { "IGNORE", "TK_IGNORE", CONFLICT|TRIGGER }, + { "IMMEDIATE", "TK_IMMEDIATE", FKEY }, + { "IN", "TK_IN", ALWAYS }, + { "INDEX", "TK_INDEX", ALWAYS }, + { "INITIALLY", "TK_INITIALLY", FKEY }, + { "INNER", "TK_JOIN_KW", ALWAYS }, + { "INSERT", "TK_INSERT", ALWAYS }, + { "INSTEAD", "TK_INSTEAD", TRIGGER }, + { "INTERSECT", "TK_INTERSECT", COMPOUND }, + { "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", ALWAYS }, + { "LIMIT", "TK_LIMIT", ALWAYS }, + { "MATCH", "TK_MATCH", ALWAYS }, + { "NATURAL", "TK_JOIN_KW", ALWAYS }, + { "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 }, + { "PRAGMA", "TK_PRAGMA", PRAGMA }, + { "PRIMARY", "TK_PRIMARY", ALWAYS }, + { "RAISE", "TK_RAISE", TRIGGER }, + { "REFERENCES", "TK_REFERENCES", FKEY }, + { "REINDEX", "TK_REINDEX", REINDEX }, + { "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 }, + { "SELECT", "TK_SELECT", ALWAYS }, + { "SET", "TK_SET", ALWAYS }, + { "STATEMENT", "TK_STATEMENT", TRIGGER }, + { "TABLE", "TK_TABLE", ALWAYS }, + { "TEMP", "TK_TEMP", ALWAYS }, + { "TEMPORARY", "TK_TEMP", ALWAYS }, + { "THEN", "TK_THEN", 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 }, + { "WHEN", "TK_WHEN", ALWAYS }, + { "WHERE", "TK_WHERE", ALWAYS }, }; /* Number of keywords */ -#define NKEYWORD (sizeof(aKeywordTable)/sizeof(aKeywordTable[0])) +static int NKEYWORD = (sizeof(aKeywordTable)/sizeof(aKeywordTable[0])); /* An array to map all upper-case characters into their corresponding ** lower-case character. @@ -201,6 +275,16 @@ int main(int argc, char **argv){ int nChar; int aHash[1000]; /* 1000 is much bigger than NKEYWORD */ + /* Remove entries from the list of keywords that have mask==0 */ + for(i=j=0; i