database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-11-11 01:42:22 +03:00
Code Activity

The makefile now runs mkkeywordhash.c. Keywords that are unused are

Browse Source 
omitted from the keyword hash table. (CVS 2045)

FossilOrigin-Name: 007aec11333432e08d1091b728773011e9078bc3
This commit is contained in:
drh
2004-11-03 03:59:57 +00:00
parent 4fa03bde07
commit 52fb6d71f5
7 changed files with 225 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
Makefile.in
View File

@@ -77,6 +77,8 @@ TEMP_STORE = -DTEMP_STORE=@TEMP_STORE@
# You should not have to change anything below this line # You should not have to change anything below this line
############################################################################### ###############################################################################
BEXE = @BUILD_EXEEXT@
# Object files for the SQLite library. # Object files for the SQLite library.
# #
LIBOBJ = attach.lo auth.lo btree.lo build.lo date.lo delete.lo \ 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 # files are automatically generated. This target takes care of
# all that automatic generation. # all that automatic generation.
# #
target_source: $(SRC) $(VDBEHDR) target_source: $(SRC) parse.c opcodes.c keywordhash.c $(VDBEHDR)
rm -rf tsrc rm -rf tsrc
mkdir -p tsrc mkdir -p tsrc
cp $(SRC) $(VDBEHDR) tsrc cp $(SRC) $(VDBEHDR) tsrc
rm tsrc/sqlite.h.in tsrc/parse.y 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 cp $(TOP)/sqlite3.def tsrc
# Rules to build the LEMON compiler generator # 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 $(BCC) -o lemon $(TOP)/tool/lemon.c
cp $(TOP)/tool/lempar.c . cp $(TOP)/tool/lempar.c .
@@ -306,7 +308,7 @@ parse.lo: parse.c $(HDR)
parse.h: parse.c 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 . cp $(TOP)/src/parse.y .
./lemon $(OPTS) parse.y ./lemon $(OPTS) parse.y
@@ -332,9 +334,13 @@ table.lo: $(TOP)/src/table.c $(HDR)
tclsqlite.lo: $(TOP)/src/tclsqlite.c $(HDR) tclsqlite.lo: $(TOP)/src/tclsqlite.c $(HDR)
$(LTCOMPILE) $(TCL_FLAGS) -c $(TOP)/src/tclsqlite.c $(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 $(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) trigger.lo: $(TOP)/src/trigger.c $(HDR)
$(LTCOMPILE) -c $(TOP)/src/trigger.c $(LTCOMPILE) -c $(TOP)/src/trigger.c
@@ -554,7 +560,8 @@ clean:
rm -f *.lo *.la *.o sqlite3@TARGET_EXEEXT@ libsqlite3.la rm -f *.lo *.la *.o sqlite3@TARGET_EXEEXT@ libsqlite3.la
rm -f sqlite3.h opcodes.* rm -f sqlite3.h opcodes.*
rm -rf .libs .deps 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 $(PUBLISH)
rm -f *.da *.bb *.bbg gmon.out rm -f *.da *.bb *.bbg gmon.out
rm -f testfixture@TARGET_EXEEXT@ test.db rm -f testfixture@TARGET_EXEEXT@ test.db

12
main.mk
View File

@@ -181,12 +181,12 @@ objects: $(LIBOBJ_ORIG)
# files are automatically generated. This target takes care of # files are automatically generated. This target takes care of
# all that automatic generation. # all that automatic generation.
# #
target_source: $(SRC) $(VDBEHDR) opcodes.c target_source: $(SRC) $(VDBEHDR) opcodes.c keyworkhash.c
rm -rf tsrc rm -rf tsrc
mkdir tsrc mkdir tsrc
cp $(SRC) $(VDBEHDR) tsrc cp $(SRC) $(VDBEHDR) tsrc
rm tsrc/sqlite.h.in tsrc/parse.y 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 cp $(TOP)/sqlite3.def tsrc
# Rules to build the LEMON compiler generator # 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) tclsqlite.o: $(TOP)/src/tclsqlite.c $(HDR)
$(TCCX) $(TCL_FLAGS) -c $(TOP)/src/tclsqlite.c $(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 $(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) trigger.o: $(TOP)/src/trigger.c $(HDR)
$(TCCX) -c $(TOP)/src/trigger.c $(TCCX) -c $(TOP)/src/trigger.c
@@ -527,7 +531,7 @@ install: sqlite3 libsqlite3.a sqlite3.h
clean: clean:
rm -f *.o sqlite3 libsqlite3.a sqlite3.h opcodes.* 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 $(PUBLISH)
rm -f *.da *.bb *.bbg gmon.out rm -f *.da *.bb *.bbg gmon.out
rm -rf tsrc rm -rf tsrc

22
manifest
View File

@@ -1,6 +1,6 @@
C Auto-vacuum\sbugfix:\sDo\snot\sattempt\sto\smove\sa\spointer-map\spage\sduring\sauto-vacuum.\s(CVS\s2044) 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:52:37 D 2004-11-03T03:59:57
F Makefile.in 9e90c685d69f09039015a6b1f3b0a48e9738c9e5 F Makefile.in c4d2416860f472a1e3393714d0372074197565df
F Makefile.linux-gcc a9e5a0d309fa7c38e7c14d3ecf7690879d3a5457 F Makefile.linux-gcc a9e5a0d309fa7c38e7c14d3ecf7690879d3a5457
F README a01693e454a00cc117967e3f9fdab2d4d52e9bc1 F README a01693e454a00cc117967e3f9fdab2d4d52e9bc1
F VERSION 342b6d5fde93b6d45023e2fee0163dda6464b9d6 F VERSION 342b6d5fde93b6d45023e2fee0163dda6464b9d6
@@ -16,7 +16,7 @@ F doc/lemon.html f0f682f50210928c07e562621c3b7e8ab912a538
F doc/report1.txt a031aaf37b185e4fa540223cb516d3bccec7eeac F doc/report1.txt a031aaf37b185e4fa540223cb516d3bccec7eeac
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895
F ltmain.sh f6b283068efa69f06eb8aa1fe4bddfdbdeb35826 F ltmain.sh f6b283068efa69f06eb8aa1fe4bddfdbdeb35826
F main.mk c7c97f809e5e7897bc843db64f692c7ef9013a92 F main.mk 594a756a761111da9415ca4b1ca7cbf3d269a3a3
F mkdll.sh 468d4f41d3ea98221371df4825cfbffbaac4d7e4 F mkdll.sh 468d4f41d3ea98221371df4825cfbffbaac4d7e4
F mkopcodec.awk 14a794f7b206976afc416b30fe8e0fc97f3434e9 F mkopcodec.awk 14a794f7b206976afc416b30fe8e0fc97f3434e9
F mkopcodeh.awk 4090944e4de0a2ccb99aa0083290f73bce4db406 F mkopcodeh.awk 4090944e4de0a2ccb99aa0083290f73bce4db406
@@ -54,7 +54,7 @@ F src/os_win.c 9482dfc92f289b68205bb2c9315757c7e3946bfb
F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b
F src/pager.c 6b00c0d5aac601b9f556b8fdba25e69438245f1a F src/pager.c 6b00c0d5aac601b9f556b8fdba25e69438245f1a
F src/pager.h cbe4ba356d9dd3f30260f322b3dc77408164df14 F src/pager.h cbe4ba356d9dd3f30260f322b3dc77408164df14
F src/parse.y 08f4971f89e651f47b3f83fe7369c7edde254331 F src/parse.y 625750bf4b01a7c2b4c15e5367a7539a66e6c909
F src/pragma.c 44e192eb5928157bdb015926f858a7c6e3ef6c98 F src/pragma.c 44e192eb5928157bdb015926f858a7c6e3ef6c98
F src/printf.c 7a92adc00b758cd5ce087dae80181a8bbdb70ed2 F src/printf.c 7a92adc00b758cd5ce087dae80181a8bbdb70ed2
F src/random.c eff68e3f257e05e81eae6c4d50a51eb88beb4ff3 F src/random.c eff68e3f257e05e81eae6c4d50a51eb88beb4ff3
@@ -69,7 +69,7 @@ F src/test2.c b11fa244fff02190707dd0879987c37c75e61fc8
F src/test3.c f423597e220b3d446a65c9cc0c49cb4eb00c0215 F src/test3.c f423597e220b3d446a65c9cc0c49cb4eb00c0215
F src/test4.c 7c6b9fc33dd1f3f93c7f1ee6e5e6d016afa6c1df F src/test4.c 7c6b9fc33dd1f3f93c7f1ee6e5e6d016afa6c1df
F src/test5.c b001fa7f1b9e2dc5c2331de62fc641b5ab2bd7a1 F src/test5.c b001fa7f1b9e2dc5c2331de62fc641b5ab2bd7a1
F src/tokenize.c a0a999bf4800e7295ac66c8694f84414ceff1755 F src/tokenize.c bf9de9689b3bb813d65784bf54472804bf9595e6
F src/trigger.c f9a0a8d3a87238de1a934eeb7d0b6b1f13e6a55b F src/trigger.c f9a0a8d3a87238de1a934eeb7d0b6b1f13e6a55b
F src/update.c ee15b7ba712c2292802eba2d465f039b5deada39 F src/update.c ee15b7ba712c2292802eba2d465f039b5deada39
F src/utf.c f4f83acd73389090e32d6589d307fc55d794c7ed F src/utf.c f4f83acd73389090e32d6589d307fc55d794c7ed
@@ -201,7 +201,7 @@ F tool/lempar.c 1e61d2b6cb9d8affa264a13336bc0c088498caa4
F tool/memleak.awk b744b6109566206c746d826f6ecdba34662216bc F tool/memleak.awk b744b6109566206c746d826f6ecdba34662216bc
F tool/memleak2.awk 9cc20c8e8f3c675efac71ea0721ee6874a1566e8 F tool/memleak2.awk 9cc20c8e8f3c675efac71ea0721ee6874a1566e8
F tool/memleak3.tcl 336eb50b0849dbf99b1d5462d9c37291b01b2b43 F tool/memleak3.tcl 336eb50b0849dbf99b1d5462d9c37291b01b2b43
F tool/mkkeywordhash.c ed1f2a21a4e7f2757281c4cf7a8392c0e0ad2d5d F tool/mkkeywordhash.c f1cb22f47cc6c60d50ac4af19a55c0e8757ac92c
F tool/mkopts.tcl 66ac10d240cc6e86abd37dc908d50382f84ff46e x F tool/mkopts.tcl 66ac10d240cc6e86abd37dc908d50382f84ff46e x
F tool/opcodeDoc.awk b3a2a3d5d3075b8bd90b7afe24283efdd586659c F tool/opcodeDoc.awk b3a2a3d5d3075b8bd90b7afe24283efdd586659c
F tool/report1.txt 9eae07f26a8fc53889b45fc833a66a33daa22816 F tool/report1.txt 9eae07f26a8fc53889b45fc833a66a33daa22816
@@ -252,7 +252,7 @@ F www/tclsqlite.tcl 560ecd6a916b320e59f2917317398f3d59b7cc25
F www/vdbe.tcl 59288db1ac5c0616296b26dce071c36cb611dfe9 F www/vdbe.tcl 59288db1ac5c0616296b26dce071c36cb611dfe9
F www/version3.tcl 092a01f5ef430d2c4acc0ae558d74c4bb89638a0 F www/version3.tcl 092a01f5ef430d2c4acc0ae558d74c4bb89638a0
F www/whentouse.tcl fdacb0ba2d39831e8a6240d05a490026ad4c4e4c F www/whentouse.tcl fdacb0ba2d39831e8a6240d05a490026ad4c4e4c
P b7d953e1195897de4869ec241a65e8a3d1320efb P bd50fbb5fecd1829c87e8ca72c458c71f590274b
R e185cf7676cc794eee9060c09350688b R c93f4ae3ede116e4f0e25ff57fd95e47
U danielk1977 U drh
Z 0648ce34f782ce635735be96e8684487 Z 2a91aed8200460991cb047467354dda3

2
manifest.uuid
View File

@@ -1 +1 @@
bd50fbb5fecd1829c87e8ca72c458c71f590274b 007aec11333432e08d1091b728773011e9078bc3

3
src/parse.y
View File

@@ -14,7 +14,7 @@
** the parser. Lemon will also generate a header file containing ** the parser. Lemon will also generate a header file containing
** numeric codes for all of the tokens. ** 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_prefix TK_
%token_type {Token} %token_type {Token}
@@ -150,6 +150,7 @@ id(A) ::= ID(X). {A = X;}
%ifdef SQLITE_OMIT_COMPOUND_SELECT %ifdef SQLITE_OMIT_COMPOUND_SELECT
EXCEPT INTERSECT UNION EXCEPT INTERSECT UNION
%endif %endif
REINDEX RENAME AUTOINCR CDATE CTIME CTIMESTAMP ALTER
. .
// Define operator precedence early so that this is the first occurance // Define operator precedence early so that this is the first occurance

101
src/tokenize.c
View File

@@ -15,7 +15,7 @@
** individual tokens and sends those tokens one-by-one over to the ** individual tokens and sends those tokens one-by-one over to the
** parser for analysis. ** 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 "sqliteInt.h"
#include "os.h" #include "os.h"
@@ -23,104 +23,17 @@
#include <stdlib.h> #include <stdlib.h>
/* /*
** This function looks up an identifier to determine if it is a ** The sqlite3KeywordCode function looks up an identifier to determine if
** keyword. If it is a keyword, the token code of that keyword is ** 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. ** returned. If the input is not a keyword, TK_ID is returned.
** **
** The implementation of this routine was generated by a program, ** The implementation of this routine was generated by a program,
** mkkeywordhash.c, located in the tool subdirectory of the distribution. ** mkkeywordhash.c, located in the tool subdirectory of the distribution.
** The output of the mkkeywordhash.c program was manually cut and pasted ** The output of the mkkeywordhash.c program is written into a file
** into this file. When the set of keywords for SQLite changes, you ** named keywordhash.c and then included into this source file by
** must modify the mkkeywordhash.c program (to add or remove keywords from ** the #include below.
** the data tables) then rerun that program to regenerate this function.
*/ */
int sqlite3KeywordCode(const char *z, int n){ #include "keywordhash.c"
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;
}
/* /*

282
tool/mkkeywordhash.c
View File

@@ -15,6 +15,7 @@ typedef struct Keyword Keyword;
struct Keyword { struct Keyword {
char *zName; /* The keyword name */ char *zName; /* The keyword name */
char *zTokenType; /* Token value for this keyword */ char *zTokenType; /* Token value for this keyword */
int mask; /* Code this keyword if non-zero */
int id; /* Unique ID for this record */ int id; /* Unique ID for this record */
int hash; /* Hash on the keyword */ int hash; /* Hash on the keyword */
int offset; /* Offset to start of name string */ int offset; /* Offset to start of name string */
@@ -25,112 +26,185 @@ struct Keyword {
int substrOffset; /* Offset into substrId for start of this 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 ** These are the keywords
*/ */
static Keyword aKeywordTable[] = { static Keyword aKeywordTable[] = {
{ "ABORT", "TK_ABORT", }, { "ABORT", "TK_ABORT", CONFLICT|TRIGGER },
{ "AFTER", "TK_AFTER", }, { "AFTER", "TK_AFTER", TRIGGER },
{ "ALL", "TK_ALL", }, { "ALL", "TK_ALL", ALWAYS },
{ "AND", "TK_AND", }, { "ALTER", "TK_ALTER", ALTER },
{ "AS", "TK_AS", }, { "AND", "TK_AND", ALWAYS },
{ "ASC", "TK_ASC", }, { "AS", "TK_AS", ALWAYS },
{ "ATTACH", "TK_ATTACH", }, { "ASC", "TK_ASC", ALWAYS },
{ "BEFORE", "TK_BEFORE", }, { "ATTACH", "TK_ATTACH", ATTACH },
{ "BEGIN", "TK_BEGIN", }, { "AUTOINCREMENT", "TK_AUTOINCR", AUTOINCR },
{ "BETWEEN", "TK_BETWEEN", }, { "BEFORE", "TK_BEFORE", TRIGGER },
{ "BY", "TK_BY", }, { "BEGIN", "TK_BEGIN", ALWAYS },
{ "CASCADE", "TK_CASCADE", }, { "BETWEEN", "TK_BETWEEN", ALWAYS },
{ "CASE", "TK_CASE", }, { "BY", "TK_BY", ALWAYS },
{ "CHECK", "TK_CHECK", }, { "CASCADE", "TK_CASCADE", FKEY },
{ "COLLATE", "TK_COLLATE", }, { "CASE", "TK_CASE", ALWAYS },
{ "COMMIT", "TK_COMMIT", }, { "CHECK", "TK_CHECK", ALWAYS },
{ "CONFLICT", "TK_CONFLICT", }, { "COLLATE", "TK_COLLATE", ALWAYS },
{ "CONSTRAINT", "TK_CONSTRAINT", }, { "COMMIT", "TK_COMMIT", ALWAYS },
{ "CREATE", "TK_CREATE", }, { "CONFLICT", "TK_CONFLICT", CONFLICT },
{ "CROSS", "TK_JOIN_KW", }, { "CONSTRAINT", "TK_CONSTRAINT", ALWAYS },
{ "DATABASE", "TK_DATABASE", }, { "CREATE", "TK_CREATE", ALWAYS },
{ "DEFAULT", "TK_DEFAULT", }, { "CROSS", "TK_JOIN_KW", ALWAYS },
{ "DEFERRED", "TK_DEFERRED", }, { "CURRENT_DATE", "TK_CDATE", ALWAYS },
{ "DEFERRABLE", "TK_DEFERRABLE", }, { "CURRENT_TIME", "TK_CTIME", ALWAYS },
{ "DELETE", "TK_DELETE", }, { "CURRENT_TIMESTAMP","TK_CTIMESTAMP", ALWAYS },
{ "DESC", "TK_DESC", }, { "DATABASE", "TK_DATABASE", ATTACH },
{ "DETACH", "TK_DETACH", }, { "DEFAULT", "TK_DEFAULT", ALWAYS },
{ "DISTINCT", "TK_DISTINCT", }, { "DEFERRED", "TK_DEFERRED", FKEY },
{ "DROP", "TK_DROP", }, { "DEFERRABLE", "TK_DEFERRABLE", FKEY },
{ "END", "TK_END", }, { "DELETE", "TK_DELETE", ALWAYS },
{ "EACH", "TK_EACH", }, { "DESC", "TK_DESC", ALWAYS },
{ "ELSE", "TK_ELSE", }, { "DETACH", "TK_DETACH", ATTACH },
{ "EXCEPT", "TK_EXCEPT", }, { "DISTINCT", "TK_DISTINCT", ALWAYS },
{ "EXCLUSIVE", "TK_EXCLUSIVE", }, { "DROP", "TK_DROP", ALWAYS },
{ "EXPLAIN", "TK_EXPLAIN", }, { "END", "TK_END", ALWAYS },
{ "FAIL", "TK_FAIL", }, { "EACH", "TK_EACH", TRIGGER },
{ "FOR", "TK_FOR", }, { "ELSE", "TK_ELSE", ALWAYS },
{ "FOREIGN", "TK_FOREIGN", }, { "EXCEPT", "TK_EXCEPT", COMPOUND },
{ "FROM", "TK_FROM", }, { "EXCLUSIVE", "TK_EXCLUSIVE", ALWAYS },
{ "FULL", "TK_JOIN_KW", }, { "EXPLAIN", "TK_EXPLAIN", EXPLAIN },
{ "GLOB", "TK_GLOB", }, { "FAIL", "TK_FAIL", CONFLICT|TRIGGER },
{ "GROUP", "TK_GROUP", }, { "FOR", "TK_FOR", TRIGGER },
{ "HAVING", "TK_HAVING", }, { "FOREIGN", "TK_FOREIGN", FKEY },
{ "IGNORE", "TK_IGNORE", }, { "FROM", "TK_FROM", ALWAYS },
{ "IMMEDIATE", "TK_IMMEDIATE", }, { "FULL", "TK_JOIN_KW", ALWAYS },
{ "IN", "TK_IN", }, { "GLOB", "TK_GLOB", ALWAYS },
{ "INDEX", "TK_INDEX", }, { "GROUP", "TK_GROUP", ALWAYS },
{ "INITIALLY", "TK_INITIALLY", }, { "HAVING", "TK_HAVING", ALWAYS },
{ "INNER", "TK_JOIN_KW", }, { "IGNORE", "TK_IGNORE", CONFLICT|TRIGGER },
{ "INSERT", "TK_INSERT", }, { "IMMEDIATE", "TK_IMMEDIATE", FKEY },
{ "INSTEAD", "TK_INSTEAD", }, { "IN", "TK_IN", ALWAYS },
{ "INTERSECT", "TK_INTERSECT", }, { "INDEX", "TK_INDEX", ALWAYS },
{ "INTO", "TK_INTO", }, { "INITIALLY", "TK_INITIALLY", FKEY },
{ "IS", "TK_IS", }, { "INNER", "TK_JOIN_KW", ALWAYS },
{ "ISNULL", "TK_ISNULL", }, { "INSERT", "TK_INSERT", ALWAYS },
{ "JOIN", "TK_JOIN", }, { "INSTEAD", "TK_INSTEAD", TRIGGER },
{ "KEY", "TK_KEY", }, { "INTERSECT", "TK_INTERSECT", COMPOUND },
{ "LEFT", "TK_JOIN_KW", }, { "INTO", "TK_INTO", ALWAYS },
{ "LIKE", "TK_LIKE", }, { "IS", "TK_IS", ALWAYS },
{ "LIMIT", "TK_LIMIT", }, { "ISNULL", "TK_ISNULL", ALWAYS },
{ "MATCH", "TK_MATCH", }, { "JOIN", "TK_JOIN", ALWAYS },
{ "NATURAL", "TK_JOIN_KW", }, { "KEY", "TK_KEY", ALWAYS },
{ "NOT", "TK_NOT", }, { "LEFT", "TK_JOIN_KW", ALWAYS },
{ "NOTNULL", "TK_NOTNULL", }, { "LIKE", "TK_LIKE", ALWAYS },
{ "NULL", "TK_NULL", }, { "LIMIT", "TK_LIMIT", ALWAYS },
{ "OF", "TK_OF", }, { "MATCH", "TK_MATCH", ALWAYS },
{ "OFFSET", "TK_OFFSET", }, { "NATURAL", "TK_JOIN_KW", ALWAYS },
{ "ON", "TK_ON", }, { "NOT", "TK_NOT", ALWAYS },
{ "OR", "TK_OR", }, { "NOTNULL", "TK_NOTNULL", ALWAYS },
{ "ORDER", "TK_ORDER", }, { "NULL", "TK_NULL", ALWAYS },
{ "OUTER", "TK_JOIN_KW", }, { "OF", "TK_OF", ALWAYS },
{ "PRAGMA", "TK_PRAGMA", }, { "OFFSET", "TK_OFFSET", ALWAYS },
{ "PRIMARY", "TK_PRIMARY", }, { "ON", "TK_ON", ALWAYS },
{ "RAISE", "TK_RAISE", }, { "OR", "TK_OR", ALWAYS },
{ "REFERENCES", "TK_REFERENCES", }, { "ORDER", "TK_ORDER", ALWAYS },
{ "REPLACE", "TK_REPLACE", }, { "OUTER", "TK_JOIN_KW", ALWAYS },
{ "RESTRICT", "TK_RESTRICT", }, { "PRAGMA", "TK_PRAGMA", PRAGMA },
{ "RIGHT", "TK_JOIN_KW", }, { "PRIMARY", "TK_PRIMARY", ALWAYS },
{ "ROLLBACK", "TK_ROLLBACK", }, { "RAISE", "TK_RAISE", TRIGGER },
{ "ROW", "TK_ROW", }, { "REFERENCES", "TK_REFERENCES", FKEY },
{ "SELECT", "TK_SELECT", }, { "REINDEX", "TK_REINDEX", REINDEX },
{ "SET", "TK_SET", }, { "RENAME", "TK_RENAME", ALTER },
{ "STATEMENT", "TK_STATEMENT", }, { "REPLACE", "TK_REPLACE", CONFLICT },
{ "TABLE", "TK_TABLE", }, { "RESTRICT", "TK_RESTRICT", FKEY },
{ "TEMP", "TK_TEMP", }, { "RIGHT", "TK_JOIN_KW", ALWAYS },
{ "TEMPORARY", "TK_TEMP", }, { "ROLLBACK", "TK_ROLLBACK", ALWAYS },
{ "THEN", "TK_THEN", }, { "ROW", "TK_ROW", TRIGGER },
{ "TRANSACTION", "TK_TRANSACTION", }, { "SELECT", "TK_SELECT", ALWAYS },
{ "TRIGGER", "TK_TRIGGER", }, { "SET", "TK_SET", ALWAYS },
{ "UNION", "TK_UNION", }, { "STATEMENT", "TK_STATEMENT", TRIGGER },
{ "UNIQUE", "TK_UNIQUE", }, { "TABLE", "TK_TABLE", ALWAYS },
{ "UPDATE", "TK_UPDATE", }, { "TEMP", "TK_TEMP", ALWAYS },
{ "USING", "TK_USING", }, { "TEMPORARY", "TK_TEMP", ALWAYS },
{ "VACUUM", "TK_VACUUM", }, { "THEN", "TK_THEN", ALWAYS },
{ "VALUES", "TK_VALUES", }, { "TRANSACTION", "TK_TRANSACTION", ALWAYS },
{ "VIEW", "TK_VIEW", }, { "TRIGGER", "TK_TRIGGER", TRIGGER },
{ "WHEN", "TK_WHEN", }, { "UNION", "TK_UNION", COMPOUND },
{ "WHERE", "TK_WHERE", }, { "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 */ /* 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 /* An array to map all upper-case characters into their corresponding
** lower-case character. ** lower-case character.
@@ -201,6 +275,16 @@ int main(int argc, char **argv){
int nChar; int nChar;
int aHash[1000]; /* 1000 is much bigger than NKEYWORD */ 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<NKEYWORD; i++){
if( aKeywordTable[i].mask==0 ) continue;
if( j<i ){
aKeywordTable[j] = aKeywordTable[i];
}
j++;
}
NKEYWORD = j;
/* Fill in the lengths of strings and hashes for all entries. */ /* Fill in the lengths of strings and hashes for all entries. */
for(i=0; i<NKEYWORD; i++){ for(i=0; i<NKEYWORD; i++){
Keyword *p = &aKeywordTable[i]; Keyword *p = &aKeywordTable[i];