Index: third_party/sqlite/sqlite-src-3170000/src/tokenize.c |
diff --git a/third_party/sqlite/sqlite-src-3170000/src/tokenize.c b/third_party/sqlite/sqlite-src-3170000/src/tokenize.c |
new file mode 100644 |
index 0000000000000000000000000000000000000000..7bb1179e20aca69e9b2ad03396f5e8e8947bd63b |
--- /dev/null |
+++ b/third_party/sqlite/sqlite-src-3170000/src/tokenize.c |
@@ -0,0 +1,615 @@ |
+/* |
+** 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 */ |
+ |
+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 */ 27, 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 */ |
+#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS |
+int sqlite3IsIdChar(u8 c){ return IdChar(c); } |
+#endif |
+ |
+ |
+/* |
+** 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; |
+ } |
+ 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 */ |
+ int i; /* Loop counter */ |
+ void *pEngine; /* The LEMON-generated LALR(1) parser */ |
+ 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 |
+ unsigned char zSpace[sizeof(yyParser)]; /* Space for parser engine 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; |
+ i = 0; |
+ assert( pzErrMsg!=0 ); |
+ /* sqlite3ParserTrace(stdout, "parser: "); */ |
+#ifdef sqlite3Parser_ENGINEALWAYSONSTACK |
+ pEngine = zSpace; |
+ sqlite3ParserInit(pEngine); |
+#else |
+ pEngine = sqlite3ParserAlloc(sqlite3Malloc); |
+ 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 ){ |
+ assert( i>=0 ); |
+ if( zSql[i]!=0 ){ |
+ pParse->sLastToken.z = &zSql[i]; |
+ pParse->sLastToken.n = sqlite3GetToken((u8*)&zSql[i],&tokenType); |
+ i += pParse->sLastToken.n; |
+ if( i>mxSqlLen ){ |
+ pParse->rc = SQLITE_TOOBIG; |
+ break; |
+ } |
+ }else{ |
+ /* 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; |
+ } |
+ } |
+ if( tokenType>=TK_SPACE ){ |
+ assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL ); |
+ if( db->u1.isInterrupted ){ |
+ pParse->rc = SQLITE_INTERRUPT; |
+ break; |
+ } |
+ if( tokenType==TK_ILLEGAL ){ |
+ sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"", |
+ &pParse->sLastToken); |
+ break; |
+ } |
+ }else{ |
+ sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse); |
+ lastTokenParsed = tokenType; |
+ if( pParse->rc!=SQLITE_OK || db->mallocFailed ) break; |
+ } |
+ } |
+ assert( nErr==0 ); |
+ pParse->zTail = &zSql[i]; |
+#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", *pzErrMsg); |
+ pParse->zErrMsg = 0; |
+ nErr++; |
+ } |
+ 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_DECLARE_VTAB ){ |
+ /* 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( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree); |
+ sqlite3DeleteTrigger(db, pParse->pNewTrigger); |
+ sqlite3DbFree(db, pParse->pVList); |
+ while( pParse->pAinc ){ |
+ AutoincInfo *p = pParse->pAinc; |
+ pParse->pAinc = p->pNext; |
+ sqlite3DbFree(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; |
+} |