| /* |
| ** 2001 September 15 |
| ** |
| ** The author disclaims copyright to this source code. In place of |
| ** a legal notice, here is a blessing: |
| ** |
| ** May you do good and not evil. |
| ** May you find forgiveness for yourself and forgive others. |
| ** May you share freely, never taking more than you give. |
| ** |
| ************************************************************************* |
| ** An tokenizer for SQL |
| ** |
| ** This file contains C code that splits an SQL input string up into |
| ** individual tokens and sends those tokens one-by-one over to the |
| ** parser for analysis. |
| */ |
| #include "sqliteInt.h" |
| #include <stdlib.h> |
| |
| /* Character classes for tokenizing |
| ** |
| ** In the sqlite3GetToken() function, a switch() on aiClass[c] is implemented |
| ** using a lookup table, whereas a switch() directly on c uses a binary search. |
| ** The lookup table is much faster. To maximize speed, and to ensure that |
| ** a lookup table is used, all of the classes need to be small integers and |
| ** all of them need to be used within the switch. |
| */ |
| #define CC_X 0 /* The letter 'x', or start of BLOB literal */ |
| #define CC_KYWD 1 /* Alphabetics or '_'. Usable in a keyword */ |
| #define CC_ID 2 /* unicode characters usable in IDs */ |
| #define CC_DIGIT 3 /* Digits */ |
| #define CC_DOLLAR 4 /* '$' */ |
| #define CC_VARALPHA 5 /* '@', '#', ':'. Alphabetic SQL variables */ |
| #define CC_VARNUM 6 /* '?'. Numeric SQL variables */ |
| #define CC_SPACE 7 /* Space characters */ |
| #define CC_QUOTE 8 /* '"', '\'', or '`'. String literals, quoted ids */ |
| #define CC_QUOTE2 9 /* '['. [...] style quoted ids */ |
| #define CC_PIPE 10 /* '|'. Bitwise OR or concatenate */ |
| #define CC_MINUS 11 /* '-'. Minus or SQL-style comment */ |
| #define CC_LT 12 /* '<'. Part of < or <= or <> */ |
| #define CC_GT 13 /* '>'. Part of > or >= */ |
| #define CC_EQ 14 /* '='. Part of = or == */ |
| #define CC_BANG 15 /* '!'. Part of != */ |
| #define CC_SLASH 16 /* '/'. / or c-style comment */ |
| #define CC_LP 17 /* '(' */ |
| #define CC_RP 18 /* ')' */ |
| #define CC_SEMI 19 /* ';' */ |
| #define CC_PLUS 20 /* '+' */ |
| #define CC_STAR 21 /* '*' */ |
| #define CC_PERCENT 22 /* '%' */ |
| #define CC_COMMA 23 /* ',' */ |
| #define CC_AND 24 /* '&' */ |
| #define CC_TILDA 25 /* '~' */ |
| #define CC_DOT 26 /* '.' */ |
| #define CC_ILLEGAL 27 /* Illegal character */ |
| #define CC_NUL 28 /* 0x00 */ |
| |
| static const unsigned char aiClass[] = { |
| #ifdef SQLITE_ASCII |
| /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ |
| /* 0x */ 28, 27, 27, 27, 27, 27, 27, 27, 27, 7, 7, 27, 7, 7, 27, 27, |
| /* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, |
| /* 2x */ 7, 15, 8, 5, 4, 22, 24, 8, 17, 18, 21, 20, 23, 11, 26, 16, |
| /* 3x */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 19, 12, 14, 13, 6, |
| /* 4x */ 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| /* 5x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 9, 27, 27, 27, 1, |
| /* 6x */ 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| /* 7x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 27, 10, 27, 25, 27, |
| /* 8x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| /* 9x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| /* Ax */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| /* Bx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| /* Cx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| /* Dx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| /* Ex */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| /* Fx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 |
| #endif |
| #ifdef SQLITE_EBCDIC |
| /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ |
| /* 0x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 7, 7, 27, 27, |
| /* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, |
| /* 2x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, |
| /* 3x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, |
| /* 4x */ 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 12, 17, 20, 10, |
| /* 5x */ 24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15, 4, 21, 18, 19, 27, |
| /* 6x */ 11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22, 1, 13, 6, |
| /* 7x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 8, 5, 5, 5, 8, 14, 8, |
| /* 8x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, |
| /* 9x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, |
| /* Ax */ 27, 25, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27, |
| /* Bx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 9, 27, 27, 27, 27, 27, |
| /* Cx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, |
| /* Dx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, |
| /* Ex */ 27, 27, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27, |
| /* Fx */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 27, 27, 27, 27, 27, 27, |
| #endif |
| }; |
| |
| /* |
| ** The charMap() macro maps alphabetic characters (only) into their |
| ** lower-case ASCII equivalent. On ASCII machines, this is just |
| ** an upper-to-lower case map. On EBCDIC machines we also need |
| ** to adjust the encoding. The mapping is only valid for alphabetics |
| ** which are the only characters for which this feature is used. |
| ** |
| ** Used by keywordhash.h |
| */ |
| #ifdef SQLITE_ASCII |
| # define charMap(X) sqlite3UpperToLower[(unsigned char)X] |
| #endif |
| #ifdef SQLITE_EBCDIC |
| # define charMap(X) ebcdicToAscii[(unsigned char)X] |
| const unsigned char ebcdicToAscii[] = { |
| /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 0, /* 6x */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */ |
| 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* 8x */ |
| 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* 9x */ |
| 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ax */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ |
| 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* Cx */ |
| 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* Dx */ |
| 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ex */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Fx */ |
| }; |
| #endif |
| |
| /* |
| ** 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 is written into a file |
| ** named keywordhash.h and then included into this source file by |
| ** the #include below. |
| */ |
| #include "keywordhash.h" |
| |
| |
| /* |
| ** If X is a character that can be used in an identifier then |
| ** IdChar(X) will be true. Otherwise it is false. |
| ** |
| ** For ASCII, any character with the high-order bit set is |
| ** allowed in an identifier. For 7-bit characters, |
| ** sqlite3IsIdChar[X] must be 1. |
| ** |
| ** For EBCDIC, the rules are more complex but have the same |
| ** end result. |
| ** |
| ** Ticket #1066. the SQL standard does not allow '$' in the |
| ** middle of identifiers. But many SQL implementations do. |
| ** SQLite will allow '$' in identifiers for compatibility. |
| ** But the feature is undocumented. |
| */ |
| #ifdef SQLITE_ASCII |
| #define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0) |
| #endif |
| #ifdef SQLITE_EBCDIC |
| const char sqlite3IsEbcdicIdChar[] = { |
| /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ |
| 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 4x */ |
| 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, /* 5x */ |
| 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 6x */ |
| 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* 7x */ |
| 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, /* 8x */ |
| 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, /* 9x */ |
| 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, /* Ax */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ |
| 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Cx */ |
| 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Dx */ |
| 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Ex */ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, /* Fx */ |
| }; |
| #define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) |
| #endif |
| |
| /* Make the IdChar function accessible from ctime.c and alter.c */ |
| int sqlite3IsIdChar(u8 c){ return IdChar(c); } |
| |
| #ifndef SQLITE_OMIT_WINDOWFUNC |
| /* |
| ** Return the id of the next token in string (*pz). Before returning, set |
| ** (*pz) to point to the byte following the parsed token. |
| */ |
| static int getToken(const unsigned char **pz){ |
| const unsigned char *z = *pz; |
| int t; /* Token type to return */ |
| do { |
| z += sqlite3GetToken(z, &t); |
| }while( t==TK_SPACE ); |
| if( t==TK_ID |
| || t==TK_STRING |
| || t==TK_JOIN_KW |
| || t==TK_WINDOW |
| || t==TK_OVER |
| || sqlite3ParserFallback(t)==TK_ID |
| ){ |
| t = TK_ID; |
| } |
| *pz = z; |
| return t; |
| } |
| |
| /* |
| ** The following three functions are called immediately after the tokenizer |
| ** reads the keywords WINDOW, OVER and FILTER, respectively, to determine |
| ** whether the token should be treated as a keyword or an SQL identifier. |
| ** This cannot be handled by the usual lemon %fallback method, due to |
| ** the ambiguity in some constructions. e.g. |
| ** |
| ** SELECT sum(x) OVER ... |
| ** |
| ** In the above, "OVER" might be a keyword, or it might be an alias for the |
| ** sum(x) expression. If a "%fallback ID OVER" directive were added to |
| ** grammar, then SQLite would always treat "OVER" as an alias, making it |
| ** impossible to call a window-function without a FILTER clause. |
| ** |
| ** WINDOW is treated as a keyword if: |
| ** |
| ** * the following token is an identifier, or a keyword that can fallback |
| ** to being an identifier, and |
| ** * the token after than one is TK_AS. |
| ** |
| ** OVER is a keyword if: |
| ** |
| ** * the previous token was TK_RP, and |
| ** * the next token is either TK_LP or an identifier. |
| ** |
| ** FILTER is a keyword if: |
| ** |
| ** * the previous token was TK_RP, and |
| ** * the next token is TK_LP. |
| */ |
| static int analyzeWindowKeyword(const unsigned char *z){ |
| int t; |
| t = getToken(&z); |
| if( t!=TK_ID ) return TK_ID; |
| t = getToken(&z); |
| if( t!=TK_AS ) return TK_ID; |
| return TK_WINDOW; |
| } |
| static int analyzeOverKeyword(const unsigned char *z, int lastToken){ |
| if( lastToken==TK_RP ){ |
| int t = getToken(&z); |
| if( t==TK_LP || t==TK_ID ) return TK_OVER; |
| } |
| return TK_ID; |
| } |
| static int analyzeFilterKeyword(const unsigned char *z, int lastToken){ |
| if( lastToken==TK_RP && getToken(&z)==TK_LP ){ |
| return TK_FILTER; |
| } |
| return TK_ID; |
| } |
| #endif /* SQLITE_OMIT_WINDOWFUNC */ |
| |
| /* |
| ** Return the length (in bytes) of the token that begins at z[0]. |
| ** Store the token type in *tokenType before returning. |
| */ |
| int sqlite3GetToken(const unsigned char *z, int *tokenType){ |
| int i, c; |
| switch( aiClass[*z] ){ /* Switch on the character-class of the first byte |
| ** of the token. See the comment on the CC_ defines |
| ** above. */ |
| case CC_SPACE: { |
| testcase( z[0]==' ' ); |
| testcase( z[0]=='\t' ); |
| testcase( z[0]=='\n' ); |
| testcase( z[0]=='\f' ); |
| testcase( z[0]=='\r' ); |
| for(i=1; sqlite3Isspace(z[i]); i++){} |
| *tokenType = TK_SPACE; |
| return i; |
| } |
| case CC_MINUS: { |
| if( z[1]=='-' ){ |
| for(i=2; (c=z[i])!=0 && c!='\n'; i++){} |
| *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ |
| return i; |
| } |
| *tokenType = TK_MINUS; |
| return 1; |
| } |
| case CC_LP: { |
| *tokenType = TK_LP; |
| return 1; |
| } |
| case CC_RP: { |
| *tokenType = TK_RP; |
| return 1; |
| } |
| case CC_SEMI: { |
| *tokenType = TK_SEMI; |
| return 1; |
| } |
| case CC_PLUS: { |
| *tokenType = TK_PLUS; |
| return 1; |
| } |
| case CC_STAR: { |
| *tokenType = TK_STAR; |
| return 1; |
| } |
| case CC_SLASH: { |
| if( z[1]!='*' || z[2]==0 ){ |
| *tokenType = TK_SLASH; |
| return 1; |
| } |
| for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){} |
| if( c ) i++; |
| *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ |
| return i; |
| } |
| case CC_PERCENT: { |
| *tokenType = TK_REM; |
| return 1; |
| } |
| case CC_EQ: { |
| *tokenType = TK_EQ; |
| return 1 + (z[1]=='='); |
| } |
| case CC_LT: { |
| if( (c=z[1])=='=' ){ |
| *tokenType = TK_LE; |
| return 2; |
| }else if( c=='>' ){ |
| *tokenType = TK_NE; |
| return 2; |
| }else if( c=='<' ){ |
| *tokenType = TK_LSHIFT; |
| return 2; |
| }else{ |
| *tokenType = TK_LT; |
| return 1; |
| } |
| } |
| case CC_GT: { |
| if( (c=z[1])=='=' ){ |
| *tokenType = TK_GE; |
| return 2; |
| }else if( c=='>' ){ |
| *tokenType = TK_RSHIFT; |
| return 2; |
| }else{ |
| *tokenType = TK_GT; |
| return 1; |
| } |
| } |
| case CC_BANG: { |
| if( z[1]!='=' ){ |
| *tokenType = TK_ILLEGAL; |
| return 1; |
| }else{ |
| *tokenType = TK_NE; |
| return 2; |
| } |
| } |
| case CC_PIPE: { |
| if( z[1]!='|' ){ |
| *tokenType = TK_BITOR; |
| return 1; |
| }else{ |
| *tokenType = TK_CONCAT; |
| return 2; |
| } |
| } |
| case CC_COMMA: { |
| *tokenType = TK_COMMA; |
| return 1; |
| } |
| case CC_AND: { |
| *tokenType = TK_BITAND; |
| return 1; |
| } |
| case CC_TILDA: { |
| *tokenType = TK_BITNOT; |
| return 1; |
| } |
| case CC_QUOTE: { |
| int delim = z[0]; |
| testcase( delim=='`' ); |
| testcase( delim=='\'' ); |
| testcase( delim=='"' ); |
| for(i=1; (c=z[i])!=0; i++){ |
| if( c==delim ){ |
| if( z[i+1]==delim ){ |
| i++; |
| }else{ |
| break; |
| } |
| } |
| } |
| if( c=='\'' ){ |
| *tokenType = TK_STRING; |
| return i+1; |
| }else if( c!=0 ){ |
| *tokenType = TK_ID; |
| return i+1; |
| }else{ |
| *tokenType = TK_ILLEGAL; |
| return i; |
| } |
| } |
| case CC_DOT: { |
| #ifndef SQLITE_OMIT_FLOATING_POINT |
| if( !sqlite3Isdigit(z[1]) ) |
| #endif |
| { |
| *tokenType = TK_DOT; |
| return 1; |
| } |
| /* If the next character is a digit, this is a floating point |
| ** number that begins with ".". Fall thru into the next case */ |
| } |
| case CC_DIGIT: { |
| testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' ); |
| testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' ); |
| testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' ); |
| testcase( z[0]=='9' ); |
| *tokenType = TK_INTEGER; |
| #ifndef SQLITE_OMIT_HEX_INTEGER |
| if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){ |
| for(i=3; sqlite3Isxdigit(z[i]); i++){} |
| return i; |
| } |
| #endif |
| for(i=0; sqlite3Isdigit(z[i]); i++){} |
| #ifndef SQLITE_OMIT_FLOATING_POINT |
| if( z[i]=='.' ){ |
| i++; |
| while( sqlite3Isdigit(z[i]) ){ i++; } |
| *tokenType = TK_FLOAT; |
| } |
| if( (z[i]=='e' || z[i]=='E') && |
| ( sqlite3Isdigit(z[i+1]) |
| || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2])) |
| ) |
| ){ |
| i += 2; |
| while( sqlite3Isdigit(z[i]) ){ i++; } |
| *tokenType = TK_FLOAT; |
| } |
| #endif |
| while( IdChar(z[i]) ){ |
| *tokenType = TK_ILLEGAL; |
| i++; |
| } |
| return i; |
| } |
| case CC_QUOTE2: { |
| for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){} |
| *tokenType = c==']' ? TK_ID : TK_ILLEGAL; |
| return i; |
| } |
| case CC_VARNUM: { |
| *tokenType = TK_VARIABLE; |
| for(i=1; sqlite3Isdigit(z[i]); i++){} |
| return i; |
| } |
| case CC_DOLLAR: |
| case CC_VARALPHA: { |
| int n = 0; |
| testcase( z[0]=='$' ); testcase( z[0]=='@' ); |
| testcase( z[0]==':' ); testcase( z[0]=='#' ); |
| *tokenType = TK_VARIABLE; |
| for(i=1; (c=z[i])!=0; i++){ |
| if( IdChar(c) ){ |
| n++; |
| #ifndef SQLITE_OMIT_TCL_VARIABLE |
| }else if( c=='(' && n>0 ){ |
| do{ |
| i++; |
| }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' ); |
| if( c==')' ){ |
| i++; |
| }else{ |
| *tokenType = TK_ILLEGAL; |
| } |
| break; |
| }else if( c==':' && z[i+1]==':' ){ |
| i++; |
| #endif |
| }else{ |
| break; |
| } |
| } |
| if( n==0 ) *tokenType = TK_ILLEGAL; |
| return i; |
| } |
| case CC_KYWD: { |
| for(i=1; aiClass[z[i]]<=CC_KYWD; i++){} |
| if( IdChar(z[i]) ){ |
| /* This token started out using characters that can appear in keywords, |
| ** but z[i] is a character not allowed within keywords, so this must |
| ** be an identifier instead */ |
| i++; |
| break; |
| } |
| *tokenType = TK_ID; |
| return keywordCode((char*)z, i, tokenType); |
| } |
| case CC_X: { |
| #ifndef SQLITE_OMIT_BLOB_LITERAL |
| testcase( z[0]=='x' ); testcase( z[0]=='X' ); |
| if( z[1]=='\'' ){ |
| *tokenType = TK_BLOB; |
| for(i=2; sqlite3Isxdigit(z[i]); i++){} |
| if( z[i]!='\'' || i%2 ){ |
| *tokenType = TK_ILLEGAL; |
| while( z[i] && z[i]!='\'' ){ i++; } |
| } |
| if( z[i] ) i++; |
| return i; |
| } |
| #endif |
| /* If it is not a BLOB literal, then it must be an ID, since no |
| ** SQL keywords start with the letter 'x'. Fall through */ |
| } |
| case CC_ID: { |
| i = 1; |
| break; |
| } |
| case CC_NUL: { |
| *tokenType = TK_ILLEGAL; |
| return 0; |
| } |
| default: { |
| *tokenType = TK_ILLEGAL; |
| return 1; |
| } |
| } |
| while( IdChar(z[i]) ){ i++; } |
| *tokenType = TK_ID; |
| return i; |
| } |
| |
| /* |
| ** Run the parser on the given SQL string. The parser structure is |
| ** passed in. An SQLITE_ status code is returned. If an error occurs |
| ** then an and attempt is made to write an error message into |
| ** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that |
| ** error message. |
| */ |
| int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){ |
| int nErr = 0; /* Number of errors encountered */ |
| void *pEngine; /* The LEMON-generated LALR(1) parser */ |
| int n = 0; /* Length of the next token token */ |
| int tokenType; /* type of the next token */ |
| int lastTokenParsed = -1; /* type of the previous token */ |
| sqlite3 *db = pParse->db; /* The database connection */ |
| int mxSqlLen; /* Max length of an SQL string */ |
| #ifdef sqlite3Parser_ENGINEALWAYSONSTACK |
| yyParser sEngine; /* Space to hold the Lemon-generated Parser object */ |
| #endif |
| |
| assert( zSql!=0 ); |
| mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; |
| if( db->nVdbeActive==0 ){ |
| db->u1.isInterrupted = 0; |
| } |
| pParse->rc = SQLITE_OK; |
| pParse->zTail = zSql; |
| assert( pzErrMsg!=0 ); |
| /* sqlite3ParserTrace(stdout, "parser: "); */ |
| #ifdef sqlite3Parser_ENGINEALWAYSONSTACK |
| pEngine = &sEngine; |
| sqlite3ParserInit(pEngine, pParse); |
| #else |
| pEngine = sqlite3ParserAlloc(sqlite3Malloc, pParse); |
| if( pEngine==0 ){ |
| sqlite3OomFault(db); |
| return SQLITE_NOMEM_BKPT; |
| } |
| #endif |
| assert( pParse->pNewTable==0 ); |
| assert( pParse->pNewTrigger==0 ); |
| assert( pParse->nVar==0 ); |
| assert( pParse->pVList==0 ); |
| while( 1 ){ |
| n = sqlite3GetToken((u8*)zSql, &tokenType); |
| mxSqlLen -= n; |
| if( mxSqlLen<0 ){ |
| pParse->rc = SQLITE_TOOBIG; |
| break; |
| } |
| #ifndef SQLITE_OMIT_WINDOWFUNC |
| if( tokenType>=TK_WINDOW ){ |
| assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER |
| || tokenType==TK_ILLEGAL || tokenType==TK_WINDOW |
| ); |
| #else |
| if( tokenType>=TK_SPACE ){ |
| assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL ); |
| #endif /* SQLITE_OMIT_WINDOWFUNC */ |
| if( db->u1.isInterrupted ){ |
| pParse->rc = SQLITE_INTERRUPT; |
| break; |
| } |
| if( tokenType==TK_SPACE ){ |
| zSql += n; |
| continue; |
| } |
| if( zSql[0]==0 ){ |
| /* Upon reaching the end of input, call the parser two more times |
| ** with tokens TK_SEMI and 0, in that order. */ |
| if( lastTokenParsed==TK_SEMI ){ |
| tokenType = 0; |
| }else if( lastTokenParsed==0 ){ |
| break; |
| }else{ |
| tokenType = TK_SEMI; |
| } |
| n = 0; |
| #ifndef SQLITE_OMIT_WINDOWFUNC |
| }else if( tokenType==TK_WINDOW ){ |
| assert( n==6 ); |
| tokenType = analyzeWindowKeyword((const u8*)&zSql[6]); |
| }else if( tokenType==TK_OVER ){ |
| assert( n==4 ); |
| tokenType = analyzeOverKeyword((const u8*)&zSql[4], lastTokenParsed); |
| }else if( tokenType==TK_FILTER ){ |
| assert( n==6 ); |
| tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed); |
| #endif /* SQLITE_OMIT_WINDOWFUNC */ |
| }else{ |
| sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql); |
| break; |
| } |
| } |
| pParse->sLastToken.z = zSql; |
| pParse->sLastToken.n = n; |
| sqlite3Parser(pEngine, tokenType, pParse->sLastToken); |
| lastTokenParsed = tokenType; |
| zSql += n; |
| if( pParse->rc!=SQLITE_OK || db->mallocFailed ) break; |
| } |
| assert( nErr==0 ); |
| #ifdef YYTRACKMAXSTACKDEPTH |
| sqlite3_mutex_enter(sqlite3MallocMutex()); |
| sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK, |
| sqlite3ParserStackPeak(pEngine) |
| ); |
| sqlite3_mutex_leave(sqlite3MallocMutex()); |
| #endif /* YYDEBUG */ |
| #ifdef sqlite3Parser_ENGINEALWAYSONSTACK |
| sqlite3ParserFinalize(pEngine); |
| #else |
| sqlite3ParserFree(pEngine, sqlite3_free); |
| #endif |
| if( db->mallocFailed ){ |
| pParse->rc = SQLITE_NOMEM_BKPT; |
| } |
| if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){ |
| pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc)); |
| } |
| assert( pzErrMsg!=0 ); |
| if( pParse->zErrMsg ){ |
| *pzErrMsg = pParse->zErrMsg; |
| sqlite3_log(pParse->rc, "%s in \"%s\"", |
| *pzErrMsg, pParse->zTail); |
| pParse->zErrMsg = 0; |
| nErr++; |
| } |
| pParse->zTail = zSql; |
| if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){ |
| sqlite3VdbeDelete(pParse->pVdbe); |
| pParse->pVdbe = 0; |
| } |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| if( pParse->nested==0 ){ |
| sqlite3DbFree(db, pParse->aTableLock); |
| pParse->aTableLock = 0; |
| pParse->nTableLock = 0; |
| } |
| #endif |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| sqlite3_free(pParse->apVtabLock); |
| #endif |
| |
| if( !IN_SPECIAL_PARSE ){ |
| /* If the pParse->declareVtab flag is set, do not delete any table |
| ** structure built up in pParse->pNewTable. The calling code (see vtab.c) |
| ** will take responsibility for freeing the Table structure. |
| */ |
| sqlite3DeleteTable(db, pParse->pNewTable); |
| } |
| if( !IN_RENAME_OBJECT ){ |
| sqlite3DeleteTrigger(db, pParse->pNewTrigger); |
| } |
| |
| if( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree); |
| sqlite3DbFree(db, pParse->pVList); |
| while( pParse->pAinc ){ |
| AutoincInfo *p = pParse->pAinc; |
| pParse->pAinc = p->pNext; |
| sqlite3DbFreeNN(db, p); |
| } |
| while( pParse->pZombieTab ){ |
| Table *p = pParse->pZombieTab; |
| pParse->pZombieTab = p->pNextZombie; |
| sqlite3DeleteTable(db, p); |
| } |
| assert( nErr==0 || pParse->rc!=SQLITE_OK ); |
| return nErr; |
| } |
