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 #include "sqliteInt.h"
19 #include <stdlib.h>
20
21 /* Character classes for tokenizing
22 **
23 ** In the sqlite3GetToken() function, a switch() on aiClass[c] is implemented
24 ** using a lookup table, whereas a switch() directly on c uses a binary search.
25 ** The lookup table is much faster. To maximize speed, and to ensure that
26 ** a lookup table is used, all of the classes need to be small integers and
27 ** all of them need to be used within the switch.
28 */
29 #define CC_X 0 /* The letter 'x', or start of BLOB literal */
30 #define CC_KYWD 1 /* Alphabetics or '_'. Usable in a keyword */
31 #define CC_ID 2 /* unicode characters usable in IDs */
32 #define CC_DIGIT 3 /* Digits */
33 #define CC_DOLLAR 4 /* '$' */
34 #define CC_VARALPHA 5 /* '@', '#', ':'. Alphabetic SQL variables */
35 #define CC_VARNUM 6 /* '?'. Numeric SQL variables */
36 #define CC_SPACE 7 /* Space characters */
37 #define CC_QUOTE 8 /* '"', '\'', or '`'. String literals, quoted ids */
38 #define CC_QUOTE2 9 /* '['. [...] style quoted ids */
39 #define CC_PIPE 10 /* '|'. Bitwise OR or concatenate */
40 #define CC_MINUS 11 /* '-'. Minus or SQL-style comment */
41 #define CC_LT 12 /* '<'. Part of < or <= or <> */
42 #define CC_GT 13 /* '>'. Part of > or >= */
43 #define CC_EQ 14 /* '='. Part of = or == */
44 #define CC_BANG 15 /* '!'. Part of != */
45 #define CC_SLASH 16 /* '/'. / or c-style comment */
46 #define CC_LP 17 /* '(' */
47 #define CC_RP 18 /* ')' */
48 #define CC_SEMI 19 /* ';' */
49 #define CC_PLUS 20 /* '+' */
50 #define CC_STAR 21 /* '*' */
51 #define CC_PERCENT 22 /* '%' */
52 #define CC_COMMA 23 /* ',' */
53 #define CC_AND 24 /* '&' */
54 #define CC_TILDA 25 /* '~' */
55 #define CC_DOT 26 /* '.' */
56 #define CC_ILLEGAL 27 /* Illegal character */
57
58 static const unsigned char aiClass[] = {
59 #ifdef SQLITE_ASCII
60 /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */
61 /* 0x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 7, 7, 27, 7, 7, 27, 27,
62 /* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
63 /* 2x */ 7, 15, 8, 5, 4, 22, 24, 8, 17, 18, 21, 20, 23, 11, 26, 16,
64 /* 3x */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 19, 12, 14, 13, 6,
65 /* 4x */ 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
66 /* 5x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 9, 27, 27, 27, 1,
67 /* 6x */ 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
68 /* 7x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 27, 10, 27, 25, 27,
69 /* 8x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
70 /* 9x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71 /* Ax */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
72 /* Bx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
73 /* Cx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
74 /* Dx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
75 /* Ex */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
76 /* Fx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
77 #endif
78 #ifdef SQLITE_EBCDIC
79 /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */
80 /* 0x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 7, 7, 27, 27,
81 /* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
82 /* 2x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
83 /* 3x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
84 /* 4x */ 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 12, 17, 20, 10,
85 /* 5x */ 24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15, 4, 21, 18, 19, 27,
86 /* 6x */ 11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22, 1, 13, 6,
87 /* 7x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 8, 5, 5, 5, 8, 14, 8,
88 /* 8x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27,
89 /* 9x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27,
90 /* Ax */ 27, 25, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27,
91 /* Bx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 9, 27, 27, 27, 27, 27,
92 /* Cx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27,
93 /* Dx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27,
94 /* Ex */ 27, 27, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27,
95 /* Fx */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 27, 27, 27, 27, 27, 27,
96 #endif
97 };
98
99 /*
100 ** The charMap() macro maps alphabetic characters (only) into their
101 ** lower-case ASCII equivalent. On ASCII machines, this is just
102 ** an upper-to-lower case map. On EBCDIC machines we also need
103 ** to adjust the encoding. The mapping is only valid for alphabetics
104 ** which are the only characters for which this feature is used.
105 **
106 ** Used by keywordhash.h
107 */
108 #ifdef SQLITE_ASCII
109 # define charMap(X) sqlite3UpperToLower[(unsigned char)X]
110 #endif
111 #ifdef SQLITE_EBCDIC
112 # define charMap(X) ebcdicToAscii[(unsigned char)X]
113 const unsigned char ebcdicToAscii[] = {
114 /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
117 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
118 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */
119 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
120 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
121 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 0, /* 6x */
122 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
123 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* 8x */
124 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* 9x */
125 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ax */
126 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
127 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* Cx */
128 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* Dx */
129 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ex */
130 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Fx */
131 };
132 #endif
133
134 /*
135 ** The sqlite3KeywordCode function looks up an identifier to determine if
136 ** it is a keyword. If it is a keyword, the token code of that keyword is
137 ** returned. If the input is not a keyword, TK_ID is returned.
138 **
139 ** The implementation of this routine was generated by a program,
140 ** mkkeywordhash.c, located in the tool subdirectory of the distribution.
141 ** The output of the mkkeywordhash.c program is written into a file
142 ** named keywordhash.h and then included into this source file by
143 ** the #include below.
144 */
145 #include "keywordhash.h"
146
147
148 /*
149 ** If X is a character that can be used in an identifier then
150 ** IdChar(X) will be true. Otherwise it is false.
151 **
152 ** For ASCII, any character with the high-order bit set is
153 ** allowed in an identifier. For 7-bit characters,
154 ** sqlite3IsIdChar[X] must be 1.
155 **
156 ** For EBCDIC, the rules are more complex but have the same
157 ** end result.
158 **
159 ** Ticket #1066. the SQL standard does not allow '$' in the
160 ** middle of identifiers. But many SQL implementations do.
161 ** SQLite will allow '$' in identifiers for compatibility.
162 ** But the feature is undocumented.
163 */
164 #ifdef SQLITE_ASCII
165 #define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
166 #endif
167 #ifdef SQLITE_EBCDIC
168 const char sqlite3IsEbcdicIdChar[] = {
169 /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
170 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 4x */
171 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, /* 5x */
172 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 6x */
173 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* 7x */
174 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, /* 8x */
175 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, /* 9x */
176 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, /* Ax */
177 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
178 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Cx */
179 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Dx */
180 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Ex */
181 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, /* Fx */
182 };
183 #define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
184 #endif
185
186 /* Make the IdChar function accessible from ctime.c */
187 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
sqlite3IsIdChar(u8 c)188 int sqlite3IsIdChar(u8 c){ return IdChar(c); }
189 #endif
190
191
192 /*
193 ** Return the length (in bytes) of the token that begins at z[0].
194 ** Store the token type in *tokenType before returning.
195 */
sqlite3GetToken(const unsigned char * z,int * tokenType)196 int sqlite3GetToken(const unsigned char *z, int *tokenType){
197 int i, c;
198 switch( aiClass[*z] ){ /* Switch on the character-class of the first byte
199 ** of the token. See the comment on the CC_ defines
200 ** above. */
201 case CC_SPACE: {
202 testcase( z[0]==' ' );
203 testcase( z[0]=='\t' );
204 testcase( z[0]=='\n' );
205 testcase( z[0]=='\f' );
206 testcase( z[0]=='\r' );
207 for(i=1; sqlite3Isspace(z[i]); i++){}
208 *tokenType = TK_SPACE;
209 return i;
210 }
211 case CC_MINUS: {
212 if( z[1]=='-' ){
213 for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
214 *tokenType = TK_SPACE; /* IMP: R-22934-25134 */
215 return i;
216 }
217 *tokenType = TK_MINUS;
218 return 1;
219 }
220 case CC_LP: {
221 *tokenType = TK_LP;
222 return 1;
223 }
224 case CC_RP: {
225 *tokenType = TK_RP;
226 return 1;
227 }
228 case CC_SEMI: {
229 *tokenType = TK_SEMI;
230 return 1;
231 }
232 case CC_PLUS: {
233 *tokenType = TK_PLUS;
234 return 1;
235 }
236 case CC_STAR: {
237 *tokenType = TK_STAR;
238 return 1;
239 }
240 case CC_SLASH: {
241 if( z[1]!='*' || z[2]==0 ){
242 *tokenType = TK_SLASH;
243 return 1;
244 }
245 for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
246 if( c ) i++;
247 *tokenType = TK_SPACE; /* IMP: R-22934-25134 */
248 return i;
249 }
250 case CC_PERCENT: {
251 *tokenType = TK_REM;
252 return 1;
253 }
254 case CC_EQ: {
255 *tokenType = TK_EQ;
256 return 1 + (z[1]=='=');
257 }
258 case CC_LT: {
259 if( (c=z[1])=='=' ){
260 *tokenType = TK_LE;
261 return 2;
262 }else if( c=='>' ){
263 *tokenType = TK_NE;
264 return 2;
265 }else if( c=='<' ){
266 *tokenType = TK_LSHIFT;
267 return 2;
268 }else{
269 *tokenType = TK_LT;
270 return 1;
271 }
272 }
273 case CC_GT: {
274 if( (c=z[1])=='=' ){
275 *tokenType = TK_GE;
276 return 2;
277 }else if( c=='>' ){
278 *tokenType = TK_RSHIFT;
279 return 2;
280 }else{
281 *tokenType = TK_GT;
282 return 1;
283 }
284 }
285 case CC_BANG: {
286 if( z[1]!='=' ){
287 *tokenType = TK_ILLEGAL;
288 return 1;
289 }else{
290 *tokenType = TK_NE;
291 return 2;
292 }
293 }
294 case CC_PIPE: {
295 if( z[1]!='|' ){
296 *tokenType = TK_BITOR;
297 return 1;
298 }else{
299 *tokenType = TK_CONCAT;
300 return 2;
301 }
302 }
303 case CC_COMMA: {
304 *tokenType = TK_COMMA;
305 return 1;
306 }
307 case CC_AND: {
308 *tokenType = TK_BITAND;
309 return 1;
310 }
311 case CC_TILDA: {
312 *tokenType = TK_BITNOT;
313 return 1;
314 }
315 case CC_QUOTE: {
316 int delim = z[0];
317 testcase( delim=='`' );
318 testcase( delim=='\'' );
319 testcase( delim=='"' );
320 for(i=1; (c=z[i])!=0; i++){
321 if( c==delim ){
322 if( z[i+1]==delim ){
323 i++;
324 }else{
325 break;
326 }
327 }
328 }
329 if( c=='\'' ){
330 *tokenType = TK_STRING;
331 return i+1;
332 }else if( c!=0 ){
333 *tokenType = TK_ID;
334 return i+1;
335 }else{
336 *tokenType = TK_ILLEGAL;
337 return i;
338 }
339 }
340 case CC_DOT: {
341 #ifndef SQLITE_OMIT_FLOATING_POINT
342 if( !sqlite3Isdigit(z[1]) )
343 #endif
344 {
345 *tokenType = TK_DOT;
346 return 1;
347 }
348 /* If the next character is a digit, this is a floating point
349 ** number that begins with ".". Fall thru into the next case */
350 }
351 case CC_DIGIT: {
352 testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' );
353 testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' );
354 testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' );
355 testcase( z[0]=='9' );
356 *tokenType = TK_INTEGER;
357 #ifndef SQLITE_OMIT_HEX_INTEGER
358 if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){
359 for(i=3; sqlite3Isxdigit(z[i]); i++){}
360 return i;
361 }
362 #endif
363 for(i=0; sqlite3Isdigit(z[i]); i++){}
364 #ifndef SQLITE_OMIT_FLOATING_POINT
365 if( z[i]=='.' ){
366 i++;
367 while( sqlite3Isdigit(z[i]) ){ i++; }
368 *tokenType = TK_FLOAT;
369 }
370 if( (z[i]=='e' || z[i]=='E') &&
371 ( sqlite3Isdigit(z[i+1])
372 || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
373 )
374 ){
375 i += 2;
376 while( sqlite3Isdigit(z[i]) ){ i++; }
377 *tokenType = TK_FLOAT;
378 }
379 #endif
380 while( IdChar(z[i]) ){
381 *tokenType = TK_ILLEGAL;
382 i++;
383 }
384 return i;
385 }
386 case CC_QUOTE2: {
387 for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
388 *tokenType = c==']' ? TK_ID : TK_ILLEGAL;
389 return i;
390 }
391 case CC_VARNUM: {
392 *tokenType = TK_VARIABLE;
393 for(i=1; sqlite3Isdigit(z[i]); i++){}
394 return i;
395 }
396 case CC_DOLLAR:
397 case CC_VARALPHA: {
398 int n = 0;
399 testcase( z[0]=='$' ); testcase( z[0]=='@' );
400 testcase( z[0]==':' ); testcase( z[0]=='#' );
401 *tokenType = TK_VARIABLE;
402 for(i=1; (c=z[i])!=0; i++){
403 if( IdChar(c) ){
404 n++;
405 #ifndef SQLITE_OMIT_TCL_VARIABLE
406 }else if( c=='(' && n>0 ){
407 do{
408 i++;
409 }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' );
410 if( c==')' ){
411 i++;
412 }else{
413 *tokenType = TK_ILLEGAL;
414 }
415 break;
416 }else if( c==':' && z[i+1]==':' ){
417 i++;
418 #endif
419 }else{
420 break;
421 }
422 }
423 if( n==0 ) *tokenType = TK_ILLEGAL;
424 return i;
425 }
426 case CC_KYWD: {
427 for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}
428 if( IdChar(z[i]) ){
429 /* This token started out using characters that can appear in keywords,
430 ** but z[i] is a character not allowed within keywords, so this must
431 ** be an identifier instead */
432 i++;
433 break;
434 }
435 *tokenType = TK_ID;
436 return keywordCode((char*)z, i, tokenType);
437 }
438 case CC_X: {
439 #ifndef SQLITE_OMIT_BLOB_LITERAL
440 testcase( z[0]=='x' ); testcase( z[0]=='X' );
441 if( z[1]=='\'' ){
442 *tokenType = TK_BLOB;
443 for(i=2; sqlite3Isxdigit(z[i]); i++){}
444 if( z[i]!='\'' || i%2 ){
445 *tokenType = TK_ILLEGAL;
446 while( z[i] && z[i]!='\'' ){ i++; }
447 }
448 if( z[i] ) i++;
449 return i;
450 }
451 #endif
452 /* If it is not a BLOB literal, then it must be an ID, since no
453 ** SQL keywords start with the letter 'x'. Fall through */
454 }
455 case CC_ID: {
456 i = 1;
457 break;
458 }
459 default: {
460 *tokenType = TK_ILLEGAL;
461 return 1;
462 }
463 }
464 while( IdChar(z[i]) ){ i++; }
465 *tokenType = TK_ID;
466 return i;
467 }
468
469 /*
470 ** Run the parser on the given SQL string. The parser structure is
471 ** passed in. An SQLITE_ status code is returned. If an error occurs
472 ** then an and attempt is made to write an error message into
473 ** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that
474 ** error message.
475 */
sqlite3RunParser(Parse * pParse,const char * zSql,char ** pzErrMsg)476 int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
477 int nErr = 0; /* Number of errors encountered */
478 void *pEngine; /* The LEMON-generated LALR(1) parser */
479 int n = 0; /* Length of the next token token */
480 int tokenType; /* type of the next token */
481 int lastTokenParsed = -1; /* type of the previous token */
482 sqlite3 *db = pParse->db; /* The database connection */
483 int mxSqlLen; /* Max length of an SQL string */
484 #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
485 yyParser sEngine; /* Space to hold the Lemon-generated Parser object */
486 #endif
487
488 assert( zSql!=0 );
489 mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
490 if( db->nVdbeActive==0 ){
491 db->u1.isInterrupted = 0;
492 }
493 pParse->rc = SQLITE_OK;
494 pParse->zTail = zSql;
495 assert( pzErrMsg!=0 );
496 /* sqlite3ParserTrace(stdout, "parser: "); */
497 #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
498 pEngine = &sEngine;
499 sqlite3ParserInit(pEngine);
500 #else
501 pEngine = sqlite3ParserAlloc(sqlite3Malloc);
502 if( pEngine==0 ){
503 sqlite3OomFault(db);
504 return SQLITE_NOMEM_BKPT;
505 }
506 #endif
507 assert( pParse->pNewTable==0 );
508 assert( pParse->pNewTrigger==0 );
509 assert( pParse->nVar==0 );
510 assert( pParse->pVList==0 );
511 while( 1 ){
512 if( zSql[0]!=0 ){
513 n = sqlite3GetToken((u8*)zSql, &tokenType);
514 mxSqlLen -= n;
515 if( mxSqlLen<0 ){
516 pParse->rc = SQLITE_TOOBIG;
517 break;
518 }
519 }else{
520 /* Upon reaching the end of input, call the parser two more times
521 ** with tokens TK_SEMI and 0, in that order. */
522 if( lastTokenParsed==TK_SEMI ){
523 tokenType = 0;
524 }else if( lastTokenParsed==0 ){
525 break;
526 }else{
527 tokenType = TK_SEMI;
528 }
529 zSql -= n;
530 }
531 if( tokenType>=TK_SPACE ){
532 assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
533 if( db->u1.isInterrupted ){
534 pParse->rc = SQLITE_INTERRUPT;
535 break;
536 }
537 if( tokenType==TK_ILLEGAL ){
538 sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql);
539 break;
540 }
541 zSql += n;
542 }else{
543 pParse->sLastToken.z = zSql;
544 pParse->sLastToken.n = n;
545 sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
546 lastTokenParsed = tokenType;
547 zSql += n;
548 if( pParse->rc!=SQLITE_OK || db->mallocFailed ) break;
549 }
550 }
551 assert( nErr==0 );
552 pParse->zTail = zSql;
553 #ifdef YYTRACKMAXSTACKDEPTH
554 sqlite3_mutex_enter(sqlite3MallocMutex());
555 sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK,
556 sqlite3ParserStackPeak(pEngine)
557 );
558 sqlite3_mutex_leave(sqlite3MallocMutex());
559 #endif /* YYDEBUG */
560 #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
561 sqlite3ParserFinalize(pEngine);
562 #else
563 sqlite3ParserFree(pEngine, sqlite3_free);
564 #endif
565 if( db->mallocFailed ){
566 pParse->rc = SQLITE_NOMEM_BKPT;
567 }
568 if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
569 pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc));
570 }
571 assert( pzErrMsg!=0 );
572 if( pParse->zErrMsg ){
573 *pzErrMsg = pParse->zErrMsg;
574 sqlite3_log(pParse->rc, "%s", *pzErrMsg);
575 pParse->zErrMsg = 0;
576 nErr++;
577 }
578 if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
579 sqlite3VdbeDelete(pParse->pVdbe);
580 pParse->pVdbe = 0;
581 }
582 #ifndef SQLITE_OMIT_SHARED_CACHE
583 if( pParse->nested==0 ){
584 sqlite3DbFree(db, pParse->aTableLock);
585 pParse->aTableLock = 0;
586 pParse->nTableLock = 0;
587 }
588 #endif
589 #ifndef SQLITE_OMIT_VIRTUALTABLE
590 sqlite3_free(pParse->apVtabLock);
591 #endif
592
593 if( !IN_DECLARE_VTAB ){
594 /* If the pParse->declareVtab flag is set, do not delete any table
595 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
596 ** will take responsibility for freeing the Table structure.
597 */
598 sqlite3DeleteTable(db, pParse->pNewTable);
599 }
600
601 if( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree);
602 sqlite3DeleteTrigger(db, pParse->pNewTrigger);
603 sqlite3DbFree(db, pParse->pVList);
604 while( pParse->pAinc ){
605 AutoincInfo *p = pParse->pAinc;
606 pParse->pAinc = p->pNext;
607 sqlite3DbFreeNN(db, p);
608 }
609 while( pParse->pZombieTab ){
610 Table *p = pParse->pZombieTab;
611 pParse->pZombieTab = p->pNextZombie;
612 sqlite3DeleteTable(db, p);
613 }
614 assert( nErr==0 || pParse->rc!=SQLITE_OK );
615 return nErr;
616 }
617