Annotation of embedaddon/php/ext/sqlite/libsqlite/src/tokenize.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2001 September 15
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** An tokenizer for SQL
13: **
14: ** This file contains C code that splits an SQL input string up into
15: ** individual tokens and sends those tokens one-by-one over to the
16: ** parser for analysis.
17: **
18: ** $Id: tokenize.c 195361 2005-09-07 15:11:33Z iliaa $
19: */
20: #include "sqliteInt.h"
21: #include "os.h"
22: #include <ctype.h>
23: #include <stdlib.h>
24:
25: /*
26: ** All the keywords of the SQL language are stored as in a hash
27: ** table composed of instances of the following structure.
28: */
29: typedef struct Keyword Keyword;
30: struct Keyword {
31: char *zName; /* The keyword name */
32: u8 tokenType; /* Token value for this keyword */
33: u8 len; /* Length of this keyword */
34: u8 iNext; /* Index in aKeywordTable[] of next with same hash */
35: };
36:
37: /*
38: ** These are the keywords
39: */
40: static Keyword aKeywordTable[] = {
41: { "ABORT", TK_ABORT, },
42: { "AFTER", TK_AFTER, },
43: { "ALL", TK_ALL, },
44: { "AND", TK_AND, },
45: { "AS", TK_AS, },
46: { "ASC", TK_ASC, },
47: { "ATTACH", TK_ATTACH, },
48: { "BEFORE", TK_BEFORE, },
49: { "BEGIN", TK_BEGIN, },
50: { "BETWEEN", TK_BETWEEN, },
51: { "BY", TK_BY, },
52: { "CASCADE", TK_CASCADE, },
53: { "CASE", TK_CASE, },
54: { "CHECK", TK_CHECK, },
55: { "CLUSTER", TK_CLUSTER, },
56: { "COLLATE", TK_COLLATE, },
57: { "COMMIT", TK_COMMIT, },
58: { "CONFLICT", TK_CONFLICT, },
59: { "CONSTRAINT", TK_CONSTRAINT, },
60: { "COPY", TK_COPY, },
61: { "CREATE", TK_CREATE, },
62: { "CROSS", TK_JOIN_KW, },
63: { "DATABASE", TK_DATABASE, },
64: { "DEFAULT", TK_DEFAULT, },
65: { "DEFERRED", TK_DEFERRED, },
66: { "DEFERRABLE", TK_DEFERRABLE, },
67: { "DELETE", TK_DELETE, },
68: { "DELIMITERS", TK_DELIMITERS, },
69: { "DESC", TK_DESC, },
70: { "DETACH", TK_DETACH, },
71: { "DISTINCT", TK_DISTINCT, },
72: { "DROP", TK_DROP, },
73: { "END", TK_END, },
74: { "EACH", TK_EACH, },
75: { "ELSE", TK_ELSE, },
76: { "EXCEPT", TK_EXCEPT, },
77: { "EXPLAIN", TK_EXPLAIN, },
78: { "FAIL", TK_FAIL, },
79: { "FOR", TK_FOR, },
80: { "FOREIGN", TK_FOREIGN, },
81: { "FROM", TK_FROM, },
82: { "FULL", TK_JOIN_KW, },
83: { "GLOB", TK_GLOB, },
84: { "GROUP", TK_GROUP, },
85: { "HAVING", TK_HAVING, },
86: { "IGNORE", TK_IGNORE, },
87: { "IMMEDIATE", TK_IMMEDIATE, },
88: { "IN", TK_IN, },
89: { "INDEX", TK_INDEX, },
90: { "INITIALLY", TK_INITIALLY, },
91: { "INNER", TK_JOIN_KW, },
92: { "INSERT", TK_INSERT, },
93: { "INSTEAD", TK_INSTEAD, },
94: { "INTERSECT", TK_INTERSECT, },
95: { "INTO", TK_INTO, },
96: { "IS", TK_IS, },
97: { "ISNULL", TK_ISNULL, },
98: { "JOIN", TK_JOIN, },
99: { "KEY", TK_KEY, },
100: { "LEFT", TK_JOIN_KW, },
101: { "LIKE", TK_LIKE, },
102: { "LIMIT", TK_LIMIT, },
103: { "MATCH", TK_MATCH, },
104: { "NATURAL", TK_JOIN_KW, },
105: { "NOT", TK_NOT, },
106: { "NOTNULL", TK_NOTNULL, },
107: { "NULL", TK_NULL, },
108: { "OF", TK_OF, },
109: { "OFFSET", TK_OFFSET, },
110: { "ON", TK_ON, },
111: { "OR", TK_OR, },
112: { "ORDER", TK_ORDER, },
113: { "OUTER", TK_JOIN_KW, },
114: { "PRAGMA", TK_PRAGMA, },
115: { "PRIMARY", TK_PRIMARY, },
116: { "RAISE", TK_RAISE, },
117: { "REFERENCES", TK_REFERENCES, },
118: { "REPLACE", TK_REPLACE, },
119: { "RESTRICT", TK_RESTRICT, },
120: { "RIGHT", TK_JOIN_KW, },
121: { "ROLLBACK", TK_ROLLBACK, },
122: { "ROW", TK_ROW, },
123: { "SELECT", TK_SELECT, },
124: { "SET", TK_SET, },
125: { "STATEMENT", TK_STATEMENT, },
126: { "TABLE", TK_TABLE, },
127: { "TEMP", TK_TEMP, },
128: { "TEMPORARY", TK_TEMP, },
129: { "THEN", TK_THEN, },
130: { "TRANSACTION", TK_TRANSACTION, },
131: { "TRIGGER", TK_TRIGGER, },
132: { "UNION", TK_UNION, },
133: { "UNIQUE", TK_UNIQUE, },
134: { "UPDATE", TK_UPDATE, },
135: { "USING", TK_USING, },
136: { "VACUUM", TK_VACUUM, },
137: { "VALUES", TK_VALUES, },
138: { "VIEW", TK_VIEW, },
139: { "WHEN", TK_WHEN, },
140: { "WHERE", TK_WHERE, },
141: };
142:
143: /*
144: ** This is the hash table
145: */
146: #define KEY_HASH_SIZE 101
147: static u8 aiHashTable[KEY_HASH_SIZE];
148:
149:
150: /*
151: ** This function looks up an identifier to determine if it is a
152: ** keyword. If it is a keyword, the token code of that keyword is
153: ** returned. If the input is not a keyword, TK_ID is returned.
154: */
155: int sqliteKeywordCode(const char *z, int n){
156: int h, i;
157: Keyword *p;
158: static char needInit = 1;
159: if( needInit ){
160: /* Initialize the keyword hash table */
161: sqliteOsEnterMutex();
162: if( needInit ){
163: int nk;
164: nk = sizeof(aKeywordTable)/sizeof(aKeywordTable[0]);
165: for(i=0; i<nk; i++){
166: aKeywordTable[i].len = strlen(aKeywordTable[i].zName);
167: h = sqliteHashNoCase(aKeywordTable[i].zName, aKeywordTable[i].len);
168: h %= KEY_HASH_SIZE;
169: aKeywordTable[i].iNext = aiHashTable[h];
170: aiHashTable[h] = i+1;
171: }
172: needInit = 0;
173: }
174: sqliteOsLeaveMutex();
175: }
176: h = sqliteHashNoCase(z, n) % KEY_HASH_SIZE;
177: for(i=aiHashTable[h]; i; i=p->iNext){
178: p = &aKeywordTable[i-1];
179: if( p->len==n && sqliteStrNICmp(p->zName, z, n)==0 ){
180: return p->tokenType;
181: }
182: }
183: return TK_ID;
184: }
185:
186:
187: /*
188: ** If X is a character that can be used in an identifier and
189: ** X&0x80==0 then isIdChar[X] will be 1. If X&0x80==0x80 then
190: ** X is always an identifier character. (Hence all UTF-8
191: ** characters can be part of an identifier). isIdChar[X] will
192: ** be 0 for every character in the lower 128 ASCII characters
193: ** that cannot be used as part of an identifier.
194: **
195: ** In this implementation, an identifier can be a string of
196: ** alphabetic characters, digits, and "_" plus any character
197: ** with the high-order bit set. The latter rule means that
198: ** any sequence of UTF-8 characters or characters taken from
199: ** an extended ISO8859 character set can form an identifier.
200: */
201: static const char isIdChar[] = {
202: /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
203: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
204: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
205: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
206: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */
207: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */
208: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */
209: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */
210: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */
211: };
212:
213:
214: /*
215: ** Return the length of the token that begins at z[0].
216: ** Store the token type in *tokenType before returning.
217: */
218: static int sqliteGetToken(const unsigned char *z, int *tokenType){
219: int i;
220: switch( *z ){
221: case ' ': case '\t': case '\n': case '\f': case '\r': {
222: for(i=1; isspace(z[i]); i++){}
223: *tokenType = TK_SPACE;
224: return i;
225: }
226: case '-': {
227: if( z[1]=='-' ){
228: for(i=2; z[i] && z[i]!='\n'; i++){}
229: *tokenType = TK_COMMENT;
230: return i;
231: }
232: *tokenType = TK_MINUS;
233: return 1;
234: }
235: case '(': {
236: *tokenType = TK_LP;
237: return 1;
238: }
239: case ')': {
240: *tokenType = TK_RP;
241: return 1;
242: }
243: case ';': {
244: *tokenType = TK_SEMI;
245: return 1;
246: }
247: case '+': {
248: *tokenType = TK_PLUS;
249: return 1;
250: }
251: case '*': {
252: *tokenType = TK_STAR;
253: return 1;
254: }
255: case '/': {
256: if( z[1]!='*' || z[2]==0 ){
257: *tokenType = TK_SLASH;
258: return 1;
259: }
260: for(i=3; z[i] && (z[i]!='/' || z[i-1]!='*'); i++){}
261: if( z[i] ) i++;
262: *tokenType = TK_COMMENT;
263: return i;
264: }
265: case '%': {
266: *tokenType = TK_REM;
267: return 1;
268: }
269: case '=': {
270: *tokenType = TK_EQ;
271: return 1 + (z[1]=='=');
272: }
273: case '<': {
274: if( z[1]=='=' ){
275: *tokenType = TK_LE;
276: return 2;
277: }else if( z[1]=='>' ){
278: *tokenType = TK_NE;
279: return 2;
280: }else if( z[1]=='<' ){
281: *tokenType = TK_LSHIFT;
282: return 2;
283: }else{
284: *tokenType = TK_LT;
285: return 1;
286: }
287: }
288: case '>': {
289: if( z[1]=='=' ){
290: *tokenType = TK_GE;
291: return 2;
292: }else if( z[1]=='>' ){
293: *tokenType = TK_RSHIFT;
294: return 2;
295: }else{
296: *tokenType = TK_GT;
297: return 1;
298: }
299: }
300: case '!': {
301: if( z[1]!='=' ){
302: *tokenType = TK_ILLEGAL;
303: return 2;
304: }else{
305: *tokenType = TK_NE;
306: return 2;
307: }
308: }
309: case '|': {
310: if( z[1]!='|' ){
311: *tokenType = TK_BITOR;
312: return 1;
313: }else{
314: *tokenType = TK_CONCAT;
315: return 2;
316: }
317: }
318: case ',': {
319: *tokenType = TK_COMMA;
320: return 1;
321: }
322: case '&': {
323: *tokenType = TK_BITAND;
324: return 1;
325: }
326: case '~': {
327: *tokenType = TK_BITNOT;
328: return 1;
329: }
330: case '\'': case '"': {
331: int delim = z[0];
332: for(i=1; z[i]; i++){
333: if( z[i]==delim ){
334: if( z[i+1]==delim ){
335: i++;
336: }else{
337: break;
338: }
339: }
340: }
341: if( z[i] ) i++;
342: *tokenType = TK_STRING;
343: return i;
344: }
345: case '.': {
346: *tokenType = TK_DOT;
347: return 1;
348: }
349: case '0': case '1': case '2': case '3': case '4':
350: case '5': case '6': case '7': case '8': case '9': {
351: *tokenType = TK_INTEGER;
352: for(i=1; isdigit(z[i]); i++){}
353: if( z[i]=='.' && isdigit(z[i+1]) ){
354: i += 2;
355: while( isdigit(z[i]) ){ i++; }
356: *tokenType = TK_FLOAT;
357: }
358: if( (z[i]=='e' || z[i]=='E') &&
359: ( isdigit(z[i+1])
360: || ((z[i+1]=='+' || z[i+1]=='-') && isdigit(z[i+2]))
361: )
362: ){
363: i += 2;
364: while( isdigit(z[i]) ){ i++; }
365: *tokenType = TK_FLOAT;
366: }
367: return i;
368: }
369: case '[': {
370: for(i=1; z[i] && z[i-1]!=']'; i++){}
371: *tokenType = TK_ID;
372: return i;
373: }
374: case '?': {
375: *tokenType = TK_VARIABLE;
376: return 1;
377: }
378: default: {
379: if( (*z&0x80)==0 && !isIdChar[*z] ){
380: break;
381: }
382: for(i=1; (z[i]&0x80)!=0 || isIdChar[z[i]]; i++){}
383: *tokenType = sqliteKeywordCode((char*)z, i);
384: return i;
385: }
386: }
387: *tokenType = TK_ILLEGAL;
388: return 1;
389: }
390:
391: /*
392: ** Run the parser on the given SQL string. The parser structure is
393: ** passed in. An SQLITE_ status code is returned. If an error occurs
394: ** and pzErrMsg!=NULL then an error message might be written into
395: ** memory obtained from malloc() and *pzErrMsg made to point to that
396: ** error message. Or maybe not.
397: */
398: int sqliteRunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
399: int nErr = 0;
400: int i;
401: void *pEngine;
402: int tokenType;
403: int lastTokenParsed = -1;
404: sqlite *db = pParse->db;
405: extern void *sqliteParserAlloc(void*(*)(int));
406: extern void sqliteParserFree(void*, void(*)(void*));
407: extern int sqliteParser(void*, int, Token, Parse*);
408:
409: db->flags &= ~SQLITE_Interrupt;
410: pParse->rc = SQLITE_OK;
411: i = 0;
412: pEngine = sqliteParserAlloc((void*(*)(int))malloc);
413: if( pEngine==0 ){
414: sqliteSetString(pzErrMsg, "out of memory", (char*)0);
415: return 1;
416: }
417: pParse->sLastToken.dyn = 0;
418: pParse->zTail = zSql;
419: while( sqlite_malloc_failed==0 && zSql[i]!=0 ){
420: assert( i>=0 );
421: pParse->sLastToken.z = &zSql[i];
422: assert( pParse->sLastToken.dyn==0 );
423: pParse->sLastToken.n = sqliteGetToken((unsigned char*)&zSql[i], &tokenType);
424: i += pParse->sLastToken.n;
425: switch( tokenType ){
426: case TK_SPACE:
427: case TK_COMMENT: {
428: if( (db->flags & SQLITE_Interrupt)!=0 ){
429: pParse->rc = SQLITE_INTERRUPT;
430: sqliteSetString(pzErrMsg, "interrupt", (char*)0);
431: goto abort_parse;
432: }
433: break;
434: }
435: case TK_ILLEGAL: {
436: sqliteSetNString(pzErrMsg, "unrecognized token: \"", -1,
437: pParse->sLastToken.z, pParse->sLastToken.n, "\"", 1, 0);
438: nErr++;
439: goto abort_parse;
440: }
441: case TK_SEMI: {
442: pParse->zTail = &zSql[i];
443: /* Fall thru into the default case */
444: }
445: default: {
446: sqliteParser(pEngine, tokenType, pParse->sLastToken, pParse);
447: lastTokenParsed = tokenType;
448: if( pParse->rc!=SQLITE_OK ){
449: goto abort_parse;
450: }
451: break;
452: }
453: }
454: }
455: abort_parse:
456: if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
457: if( lastTokenParsed!=TK_SEMI ){
458: sqliteParser(pEngine, TK_SEMI, pParse->sLastToken, pParse);
459: pParse->zTail = &zSql[i];
460: }
461: sqliteParser(pEngine, 0, pParse->sLastToken, pParse);
462: }
463: sqliteParserFree(pEngine, free);
464: if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
465: sqliteSetString(&pParse->zErrMsg, sqlite_error_string(pParse->rc),
466: (char*)0);
467: }
468: if( pParse->zErrMsg ){
469: if( pzErrMsg && *pzErrMsg==0 ){
470: *pzErrMsg = pParse->zErrMsg;
471: }else{
472: sqliteFree(pParse->zErrMsg);
473: }
474: pParse->zErrMsg = 0;
475: if( !nErr ) nErr++;
476: }
477: if( pParse->pVdbe && pParse->nErr>0 ){
478: sqliteVdbeDelete(pParse->pVdbe);
479: pParse->pVdbe = 0;
480: }
481: if( pParse->pNewTable ){
482: sqliteDeleteTable(pParse->db, pParse->pNewTable);
483: pParse->pNewTable = 0;
484: }
485: if( pParse->pNewTrigger ){
486: sqliteDeleteTrigger(pParse->pNewTrigger);
487: pParse->pNewTrigger = 0;
488: }
489: if( nErr>0 && (pParse->rc==SQLITE_OK || pParse->rc==SQLITE_DONE) ){
490: pParse->rc = SQLITE_ERROR;
491: }
492: return nErr;
493: }
494:
495: /*
496: ** Token types used by the sqlite_complete() routine. See the header
497: ** comments on that procedure for additional information.
498: */
499: #define tkEXPLAIN 0
500: #define tkCREATE 1
501: #define tkTEMP 2
502: #define tkTRIGGER 3
503: #define tkEND 4
504: #define tkSEMI 5
505: #define tkWS 6
506: #define tkOTHER 7
507:
508: /*
509: ** Return TRUE if the given SQL string ends in a semicolon.
510: **
511: ** Special handling is require for CREATE TRIGGER statements.
512: ** Whenever the CREATE TRIGGER keywords are seen, the statement
513: ** must end with ";END;".
514: **
515: ** This implementation uses a state machine with 7 states:
516: **
517: ** (0) START At the beginning or end of an SQL statement. This routine
518: ** returns 1 if it ends in the START state and 0 if it ends
519: ** in any other state.
520: **
521: ** (1) EXPLAIN The keyword EXPLAIN has been seen at the beginning of
522: ** a statement.
523: **
524: ** (2) CREATE The keyword CREATE has been seen at the beginning of a
525: ** statement, possibly preceeded by EXPLAIN and/or followed by
526: ** TEMP or TEMPORARY
527: **
528: ** (3) NORMAL We are in the middle of statement which ends with a single
529: ** semicolon.
530: **
531: ** (4) TRIGGER We are in the middle of a trigger definition that must be
532: ** ended by a semicolon, the keyword END, and another semicolon.
533: **
534: ** (5) SEMI We've seen the first semicolon in the ";END;" that occurs at
535: ** the end of a trigger definition.
536: **
537: ** (6) END We've seen the ";END" of the ";END;" that occurs at the end
538: ** of a trigger difinition.
539: **
540: ** Transitions between states above are determined by tokens extracted
541: ** from the input. The following tokens are significant:
542: **
543: ** (0) tkEXPLAIN The "explain" keyword.
544: ** (1) tkCREATE The "create" keyword.
545: ** (2) tkTEMP The "temp" or "temporary" keyword.
546: ** (3) tkTRIGGER The "trigger" keyword.
547: ** (4) tkEND The "end" keyword.
548: ** (5) tkSEMI A semicolon.
549: ** (6) tkWS Whitespace
550: ** (7) tkOTHER Any other SQL token.
551: **
552: ** Whitespace never causes a state transition and is always ignored.
553: */
554: int sqlite_complete(const char *zSql){
555: u8 state = 0; /* Current state, using numbers defined in header comment */
556: u8 token; /* Value of the next token */
557:
558: /* The following matrix defines the transition from one state to another
559: ** according to what token is seen. trans[state][token] returns the
560: ** next state.
561: */
562: static const u8 trans[7][8] = {
563: /* Token: */
564: /* State: ** EXPLAIN CREATE TEMP TRIGGER END SEMI WS OTHER */
565: /* 0 START: */ { 1, 2, 3, 3, 3, 0, 0, 3, },
566: /* 1 EXPLAIN: */ { 3, 2, 3, 3, 3, 0, 1, 3, },
567: /* 2 CREATE: */ { 3, 3, 2, 4, 3, 0, 2, 3, },
568: /* 3 NORMAL: */ { 3, 3, 3, 3, 3, 0, 3, 3, },
569: /* 4 TRIGGER: */ { 4, 4, 4, 4, 4, 5, 4, 4, },
570: /* 5 SEMI: */ { 4, 4, 4, 4, 6, 5, 5, 4, },
571: /* 6 END: */ { 4, 4, 4, 4, 4, 0, 6, 4, },
572: };
573:
574: while( *zSql ){
575: switch( *zSql ){
576: case ';': { /* A semicolon */
577: token = tkSEMI;
578: break;
579: }
580: case ' ':
581: case '\r':
582: case '\t':
583: case '\n':
584: case '\f': { /* White space is ignored */
585: token = tkWS;
586: break;
587: }
588: case '/': { /* C-style comments */
589: if( zSql[1]!='*' ){
590: token = tkOTHER;
591: break;
592: }
593: zSql += 2;
594: while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
595: if( zSql[0]==0 ) return 0;
596: zSql++;
597: token = tkWS;
598: break;
599: }
600: case '-': { /* SQL-style comments from "--" to end of line */
601: if( zSql[1]!='-' ){
602: token = tkOTHER;
603: break;
604: }
605: while( *zSql && *zSql!='\n' ){ zSql++; }
606: if( *zSql==0 ) return state==0;
607: token = tkWS;
608: break;
609: }
610: case '[': { /* Microsoft-style identifiers in [...] */
611: zSql++;
612: while( *zSql && *zSql!=']' ){ zSql++; }
613: if( *zSql==0 ) return 0;
614: token = tkOTHER;
615: break;
616: }
617: case '"': /* single- and double-quoted strings */
618: case '\'': {
619: int c = *zSql;
620: zSql++;
621: while( *zSql && *zSql!=c ){ zSql++; }
622: if( *zSql==0 ) return 0;
623: token = tkOTHER;
624: break;
625: }
626: default: {
627: if( isIdChar[(u8)*zSql] ){
628: /* Keywords and unquoted identifiers */
629: int nId;
630: for(nId=1; isIdChar[(u8)zSql[nId]]; nId++){}
631: switch( *zSql ){
632: case 'c': case 'C': {
633: if( nId==6 && sqliteStrNICmp(zSql, "create", 6)==0 ){
634: token = tkCREATE;
635: }else{
636: token = tkOTHER;
637: }
638: break;
639: }
640: case 't': case 'T': {
641: if( nId==7 && sqliteStrNICmp(zSql, "trigger", 7)==0 ){
642: token = tkTRIGGER;
643: }else if( nId==4 && sqliteStrNICmp(zSql, "temp", 4)==0 ){
644: token = tkTEMP;
645: }else if( nId==9 && sqliteStrNICmp(zSql, "temporary", 9)==0 ){
646: token = tkTEMP;
647: }else{
648: token = tkOTHER;
649: }
650: break;
651: }
652: case 'e': case 'E': {
653: if( nId==3 && sqliteStrNICmp(zSql, "end", 3)==0 ){
654: token = tkEND;
655: }else if( nId==7 && sqliteStrNICmp(zSql, "explain", 7)==0 ){
656: token = tkEXPLAIN;
657: }else{
658: token = tkOTHER;
659: }
660: break;
661: }
662: default: {
663: token = tkOTHER;
664: break;
665: }
666: }
667: zSql += nId-1;
668: }else{
669: /* Operators and special symbols */
670: token = tkOTHER;
671: }
672: break;
673: }
674: }
675: state = trans[state][token];
676: zSql++;
677: }
678: return state==0;
679: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tokenize.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src