000001  /*
000002  ** 2001 September 15
000003  **
000004  ** The author disclaims copyright to this source code.  In place of
000005  ** a legal notice, here is a blessing:
000006  **
000007  **    May you do good and not evil.
000008  **    May you find forgiveness for yourself and forgive others.
000009  **    May you share freely, never taking more than you give.
000010  **
000011  *************************************************************************
000012  ** An tokenizer for SQL
000013  **
000014  ** This file contains C code that splits an SQL input string up into
000015  ** individual tokens and sends those tokens one-by-one over to the
000016  ** parser for analysis.
000017  */
000018  #include "sqliteInt.h"
000019  #include <stdlib.h>
000020  
000021  /* Character classes for tokenizing
000022  **
000023  ** In the sqlite3GetToken() function, a switch() on aiClass[c] is implemented
000024  ** using a lookup table, whereas a switch() directly on c uses a binary search.
000025  ** The lookup table is much faster.  To maximize speed, and to ensure that
000026  ** a lookup table is used, all of the classes need to be small integers and
000027  ** all of them need to be used within the switch.
000028  */
000029  #define CC_X          0    /* The letter 'x', or start of BLOB literal */
000030  #define CC_KYWD       1    /* Alphabetics or '_'.  Usable in a keyword */
000031  #define CC_ID         2    /* unicode characters usable in IDs */
000032  #define CC_DIGIT      3    /* Digits */
000033  #define CC_DOLLAR     4    /* '$' */
000034  #define CC_VARALPHA   5    /* '@', '#', ':'.  Alphabetic SQL variables */
000035  #define CC_VARNUM     6    /* '?'.  Numeric SQL variables */
000036  #define CC_SPACE      7    /* Space characters */
000037  #define CC_QUOTE      8    /* '"', '\'', or '`'.  String literals, quoted ids */
000038  #define CC_QUOTE2     9    /* '['.   [...] style quoted ids */
000039  #define CC_PIPE      10    /* '|'.   Bitwise OR or concatenate */
000040  #define CC_MINUS     11    /* '-'.  Minus or SQL-style comment */
000041  #define CC_LT        12    /* '<'.  Part of < or <= or <> */
000042  #define CC_GT        13    /* '>'.  Part of > or >= */
000043  #define CC_EQ        14    /* '='.  Part of = or == */
000044  #define CC_BANG      15    /* '!'.  Part of != */
000045  #define CC_SLASH     16    /* '/'.  / or c-style comment */
000046  #define CC_LP        17    /* '(' */
000047  #define CC_RP        18    /* ')' */
000048  #define CC_SEMI      19    /* ';' */
000049  #define CC_PLUS      20    /* '+' */
000050  #define CC_STAR      21    /* '*' */
000051  #define CC_PERCENT   22    /* '%' */
000052  #define CC_COMMA     23    /* ',' */
000053  #define CC_AND       24    /* '&' */
000054  #define CC_TILDA     25    /* '~' */
000055  #define CC_DOT       26    /* '.' */
000056  #define CC_ILLEGAL   27    /* Illegal character */
000057  
000058  static const unsigned char aiClass[] = {
000059  #ifdef SQLITE_ASCII
000060  /*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
000061  /* 0x */   27, 27, 27, 27, 27, 27, 27, 27, 27,  7,  7, 27,  7,  7, 27, 27,
000062  /* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
000063  /* 2x */    7, 15,  8,  5,  4, 22, 24,  8, 17, 18, 21, 20, 23, 11, 26, 16,
000064  /* 3x */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  5, 19, 12, 14, 13,  6,
000065  /* 4x */    5,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
000066  /* 5x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  9, 27, 27, 27,  1,
000067  /* 6x */    8,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
000068  /* 7x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1, 27, 10, 27, 25, 27,
000069  /* 8x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
000070  /* 9x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
000071  /* Ax */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
000072  /* Bx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
000073  /* Cx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
000074  /* Dx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
000075  /* Ex */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
000076  /* Fx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2
000077  #endif
000078  #ifdef SQLITE_EBCDIC
000079  /*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
000080  /* 0x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27,  7,  7, 27, 27,
000081  /* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
000082  /* 2x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
000083  /* 3x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
000084  /* 4x */    7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 12, 17, 20, 10,
000085  /* 5x */   24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15,  4, 21, 18, 19, 27,
000086  /* 6x */   11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22,  1, 13,  6,
000087  /* 7x */   27, 27, 27, 27, 27, 27, 27, 27, 27,  8,  5,  5,  5,  8, 14,  8,
000088  /* 8x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
000089  /* 9x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
000090  /* Ax */   27, 25,  1,  1,  1,  1,  1,  0,  1,  1, 27, 27, 27, 27, 27, 27,
000091  /* Bx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27,  9, 27, 27, 27, 27, 27,
000092  /* Cx */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
000093  /* Dx */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
000094  /* Ex */   27, 27,  1,  1,  1,  1,  1,  0,  1,  1, 27, 27, 27, 27, 27, 27,
000095  /* Fx */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 27, 27, 27, 27, 27, 27,
000096  #endif
000097  };
000098  
000099  /*
000100  ** The charMap() macro maps alphabetic characters (only) into their
000101  ** lower-case ASCII equivalent.  On ASCII machines, this is just
000102  ** an upper-to-lower case map.  On EBCDIC machines we also need
000103  ** to adjust the encoding.  The mapping is only valid for alphabetics
000104  ** which are the only characters for which this feature is used. 
000105  **
000106  ** Used by keywordhash.h
000107  */
000108  #ifdef SQLITE_ASCII
000109  # define charMap(X) sqlite3UpperToLower[(unsigned char)X]
000110  #endif
000111  #ifdef SQLITE_EBCDIC
000112  # define charMap(X) ebcdicToAscii[(unsigned char)X]
000113  const unsigned char ebcdicToAscii[] = {
000114  /* 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
000115     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 0x */
000116     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 1x */
000117     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 2x */
000118     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 3x */
000119     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 4x */
000120     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 5x */
000121     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 95,  0,  0,  /* 6x */
000122     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 7x */
000123     0, 97, 98, 99,100,101,102,103,104,105,  0,  0,  0,  0,  0,  0,  /* 8x */
000124     0,106,107,108,109,110,111,112,113,114,  0,  0,  0,  0,  0,  0,  /* 9x */
000125     0,  0,115,116,117,118,119,120,121,122,  0,  0,  0,  0,  0,  0,  /* Ax */
000126     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* Bx */
000127     0, 97, 98, 99,100,101,102,103,104,105,  0,  0,  0,  0,  0,  0,  /* Cx */
000128     0,106,107,108,109,110,111,112,113,114,  0,  0,  0,  0,  0,  0,  /* Dx */
000129     0,  0,115,116,117,118,119,120,121,122,  0,  0,  0,  0,  0,  0,  /* Ex */
000130     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* Fx */
000131  };
000132  #endif
000133  
000134  /*
000135  ** The sqlite3KeywordCode function looks up an identifier to determine if
000136  ** it is a keyword.  If it is a keyword, the token code of that keyword is 
000137  ** returned.  If the input is not a keyword, TK_ID is returned.
000138  **
000139  ** The implementation of this routine was generated by a program,
000140  ** mkkeywordhash.c, located in the tool subdirectory of the distribution.
000141  ** The output of the mkkeywordhash.c program is written into a file
000142  ** named keywordhash.h and then included into this source file by
000143  ** the #include below.
000144  */
000145  #include "keywordhash.h"
000146  
000147  
000148  /*
000149  ** If X is a character that can be used in an identifier then
000150  ** IdChar(X) will be true.  Otherwise it is false.
000151  **
000152  ** For ASCII, any character with the high-order bit set is
000153  ** allowed in an identifier.  For 7-bit characters, 
000154  ** sqlite3IsIdChar[X] must be 1.
000155  **
000156  ** For EBCDIC, the rules are more complex but have the same
000157  ** end result.
000158  **
000159  ** Ticket #1066.  the SQL standard does not allow '$' in the
000160  ** middle of identifiers.  But many SQL implementations do. 
000161  ** SQLite will allow '$' in identifiers for compatibility.
000162  ** But the feature is undocumented.
000163  */
000164  #ifdef SQLITE_ASCII
000165  #define IdChar(C)  ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
000166  #endif
000167  #ifdef SQLITE_EBCDIC
000168  const char sqlite3IsEbcdicIdChar[] = {
000169  /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
000170      0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 4x */
000171      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0,  /* 5x */
000172      0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,  /* 6x */
000173      0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,  /* 7x */
000174      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,  /* 8x */
000175      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0,  /* 9x */
000176      1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,  /* Ax */
000177      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* Bx */
000178      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Cx */
000179      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Dx */
000180      0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Ex */
000181      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0,  /* Fx */
000182  };
000183  #define IdChar(C)  (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
000184  #endif
000185  
000186  /* Make the IdChar function accessible from ctime.c */
000187  #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
000188  int sqlite3IsIdChar(u8 c){ return IdChar(c); }
000189  #endif
000190  
000191  
000192  /*
000193  ** Return the length (in bytes) of the token that begins at z[0]. 
000194  ** Store the token type in *tokenType before returning.
000195  */
000196  int sqlite3GetToken(const unsigned char *z, int *tokenType){
000197    int i, c;
000198    switch( aiClass[*z] ){  /* Switch on the character-class of the first byte
000199                            ** of the token. See the comment on the CC_ defines
000200                            ** above. */
000201      case CC_SPACE: {
000202        testcase( z[0]==' ' );
000203        testcase( z[0]=='\t' );
000204        testcase( z[0]=='\n' );
000205        testcase( z[0]=='\f' );
000206        testcase( z[0]=='\r' );
000207        for(i=1; sqlite3Isspace(z[i]); i++){}
000208        *tokenType = TK_SPACE;
000209        return i;
000210      }
000211      case CC_MINUS: {
000212        if( z[1]=='-' ){
000213          for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
000214          *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
000215          return i;
000216        }
000217        *tokenType = TK_MINUS;
000218        return 1;
000219      }
000220      case CC_LP: {
000221        *tokenType = TK_LP;
000222        return 1;
000223      }
000224      case CC_RP: {
000225        *tokenType = TK_RP;
000226        return 1;
000227      }
000228      case CC_SEMI: {
000229        *tokenType = TK_SEMI;
000230        return 1;
000231      }
000232      case CC_PLUS: {
000233        *tokenType = TK_PLUS;
000234        return 1;
000235      }
000236      case CC_STAR: {
000237        *tokenType = TK_STAR;
000238        return 1;
000239      }
000240      case CC_SLASH: {
000241        if( z[1]!='*' || z[2]==0 ){
000242          *tokenType = TK_SLASH;
000243          return 1;
000244        }
000245        for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
000246        if( c ) i++;
000247        *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
000248        return i;
000249      }
000250      case CC_PERCENT: {
000251        *tokenType = TK_REM;
000252        return 1;
000253      }
000254      case CC_EQ: {
000255        *tokenType = TK_EQ;
000256        return 1 + (z[1]=='=');
000257      }
000258      case CC_LT: {
000259        if( (c=z[1])=='=' ){
000260          *tokenType = TK_LE;
000261          return 2;
000262        }else if( c=='>' ){
000263          *tokenType = TK_NE;
000264          return 2;
000265        }else if( c=='<' ){
000266          *tokenType = TK_LSHIFT;
000267          return 2;
000268        }else{
000269          *tokenType = TK_LT;
000270          return 1;
000271        }
000272      }
000273      case CC_GT: {
000274        if( (c=z[1])=='=' ){
000275          *tokenType = TK_GE;
000276          return 2;
000277        }else if( c=='>' ){
000278          *tokenType = TK_RSHIFT;
000279          return 2;
000280        }else{
000281          *tokenType = TK_GT;
000282          return 1;
000283        }
000284      }
000285      case CC_BANG: {
000286        if( z[1]!='=' ){
000287          *tokenType = TK_ILLEGAL;
000288          return 1;
000289        }else{
000290          *tokenType = TK_NE;
000291          return 2;
000292        }
000293      }
000294      case CC_PIPE: {
000295        if( z[1]!='|' ){
000296          *tokenType = TK_BITOR;
000297          return 1;
000298        }else{
000299          *tokenType = TK_CONCAT;
000300          return 2;
000301        }
000302      }
000303      case CC_COMMA: {
000304        *tokenType = TK_COMMA;
000305        return 1;
000306      }
000307      case CC_AND: {
000308        *tokenType = TK_BITAND;
000309        return 1;
000310      }
000311      case CC_TILDA: {
000312        *tokenType = TK_BITNOT;
000313        return 1;
000314      }
000315      case CC_QUOTE: {
000316        int delim = z[0];
000317        testcase( delim=='`' );
000318        testcase( delim=='\'' );
000319        testcase( delim=='"' );
000320        for(i=1; (c=z[i])!=0; i++){
000321          if( c==delim ){
000322            if( z[i+1]==delim ){
000323              i++;
000324            }else{
000325              break;
000326            }
000327          }
000328        }
000329        if( c=='\'' ){
000330          *tokenType = TK_STRING;
000331          return i+1;
000332        }else if( c!=0 ){
000333          *tokenType = TK_ID;
000334          return i+1;
000335        }else{
000336          *tokenType = TK_ILLEGAL;
000337          return i;
000338        }
000339      }
000340      case CC_DOT: {
000341  #ifndef SQLITE_OMIT_FLOATING_POINT
000342        if( !sqlite3Isdigit(z[1]) )
000343  #endif
000344        {
000345          *tokenType = TK_DOT;
000346          return 1;
000347        }
000348        /* If the next character is a digit, this is a floating point
000349        ** number that begins with ".".  Fall thru into the next case */
000350      }
000351      case CC_DIGIT: {
000352        testcase( z[0]=='0' );  testcase( z[0]=='1' );  testcase( z[0]=='2' );
000353        testcase( z[0]=='3' );  testcase( z[0]=='4' );  testcase( z[0]=='5' );
000354        testcase( z[0]=='6' );  testcase( z[0]=='7' );  testcase( z[0]=='8' );
000355        testcase( z[0]=='9' );
000356        *tokenType = TK_INTEGER;
000357  #ifndef SQLITE_OMIT_HEX_INTEGER
000358        if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){
000359          for(i=3; sqlite3Isxdigit(z[i]); i++){}
000360          return i;
000361        }
000362  #endif
000363        for(i=0; sqlite3Isdigit(z[i]); i++){}
000364  #ifndef SQLITE_OMIT_FLOATING_POINT
000365        if( z[i]=='.' ){
000366          i++;
000367          while( sqlite3Isdigit(z[i]) ){ i++; }
000368          *tokenType = TK_FLOAT;
000369        }
000370        if( (z[i]=='e' || z[i]=='E') &&
000371             ( sqlite3Isdigit(z[i+1]) 
000372              || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
000373             )
000374        ){
000375          i += 2;
000376          while( sqlite3Isdigit(z[i]) ){ i++; }
000377          *tokenType = TK_FLOAT;
000378        }
000379  #endif
000380        while( IdChar(z[i]) ){
000381          *tokenType = TK_ILLEGAL;
000382          i++;
000383        }
000384        return i;
000385      }
000386      case CC_QUOTE2: {
000387        for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
000388        *tokenType = c==']' ? TK_ID : TK_ILLEGAL;
000389        return i;
000390      }
000391      case CC_VARNUM: {
000392        *tokenType = TK_VARIABLE;
000393        for(i=1; sqlite3Isdigit(z[i]); i++){}
000394        return i;
000395      }
000396      case CC_DOLLAR:
000397      case CC_VARALPHA: {
000398        int n = 0;
000399        testcase( z[0]=='$' );  testcase( z[0]=='@' );
000400        testcase( z[0]==':' );  testcase( z[0]=='#' );
000401        *tokenType = TK_VARIABLE;
000402        for(i=1; (c=z[i])!=0; i++){
000403          if( IdChar(c) ){
000404            n++;
000405  #ifndef SQLITE_OMIT_TCL_VARIABLE
000406          }else if( c=='(' && n>0 ){
000407            do{
000408              i++;
000409            }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' );
000410            if( c==')' ){
000411              i++;
000412            }else{
000413              *tokenType = TK_ILLEGAL;
000414            }
000415            break;
000416          }else if( c==':' && z[i+1]==':' ){
000417            i++;
000418  #endif
000419          }else{
000420            break;
000421          }
000422        }
000423        if( n==0 ) *tokenType = TK_ILLEGAL;
000424        return i;
000425      }
000426      case CC_KYWD: {
000427        for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}
000428        if( IdChar(z[i]) ){
000429          /* This token started out using characters that can appear in keywords,
000430          ** but z[i] is a character not allowed within keywords, so this must
000431          ** be an identifier instead */
000432          i++;
000433          break;
000434        }
000435        *tokenType = TK_ID;
000436        return keywordCode((char*)z, i, tokenType);
000437      }
000438      case CC_X: {
000439  #ifndef SQLITE_OMIT_BLOB_LITERAL
000440        testcase( z[0]=='x' ); testcase( z[0]=='X' );
000441        if( z[1]=='\'' ){
000442          *tokenType = TK_BLOB;
000443          for(i=2; sqlite3Isxdigit(z[i]); i++){}
000444          if( z[i]!='\'' || i%2 ){
000445            *tokenType = TK_ILLEGAL;
000446            while( z[i] && z[i]!='\'' ){ i++; }
000447          }
000448          if( z[i] ) i++;
000449          return i;
000450        }
000451  #endif
000452        /* If it is not a BLOB literal, then it must be an ID, since no
000453        ** SQL keywords start with the letter 'x'.  Fall through */
000454      }
000455      case CC_ID: {
000456        i = 1;
000457        break;
000458      }
000459      default: {
000460        *tokenType = TK_ILLEGAL;
000461        return 1;
000462      }
000463    }
000464    while( IdChar(z[i]) ){ i++; }
000465    *tokenType = TK_ID;
000466    return i;
000467  }
000468  
000469  /*
000470  ** Run the parser on the given SQL string.  The parser structure is
000471  ** passed in.  An SQLITE_ status code is returned.  If an error occurs
000472  ** then an and attempt is made to write an error message into 
000473  ** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that
000474  ** error message.
000475  */
000476  int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
000477    int nErr = 0;                   /* Number of errors encountered */
000478    void *pEngine;                  /* The LEMON-generated LALR(1) parser */
000479    int n = 0;                      /* Length of the next token token */
000480    int tokenType;                  /* type of the next token */
000481    int lastTokenParsed = -1;       /* type of the previous token */
000482    sqlite3 *db = pParse->db;       /* The database connection */
000483    int mxSqlLen;                   /* Max length of an SQL string */
000484  #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
000485    yyParser sEngine;    /* Space to hold the Lemon-generated Parser object */
000486  #endif
000487  
000488    assert( zSql!=0 );
000489    mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
000490    if( db->nVdbeActive==0 ){
000491      db->u1.isInterrupted = 0;
000492    }
000493    pParse->rc = SQLITE_OK;
000494    pParse->zTail = zSql;
000495    assert( pzErrMsg!=0 );
000496    /* sqlite3ParserTrace(stdout, "parser: "); */
000497  #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
000498    pEngine = &sEngine;
000499    sqlite3ParserInit(pEngine);
000500  #else
000501    pEngine = sqlite3ParserAlloc(sqlite3Malloc);
000502    if( pEngine==0 ){
000503      sqlite3OomFault(db);
000504      return SQLITE_NOMEM_BKPT;
000505    }
000506  #endif
000507    assert( pParse->pNewTable==0 );
000508    assert( pParse->pNewTrigger==0 );
000509    assert( pParse->nVar==0 );
000510    assert( pParse->pVList==0 );
000511    while( 1 ){
000512      if( zSql[0]!=0 ){
000513        n = sqlite3GetToken((u8*)zSql, &tokenType);
000514        mxSqlLen -= n;
000515        if( mxSqlLen<0 ){
000516          pParse->rc = SQLITE_TOOBIG;
000517          break;
000518        }
000519      }else{
000520        /* Upon reaching the end of input, call the parser two more times
000521        ** with tokens TK_SEMI and 0, in that order. */
000522        if( lastTokenParsed==TK_SEMI ){
000523          tokenType = 0;
000524        }else if( lastTokenParsed==0 ){
000525          break;
000526        }else{
000527          tokenType = TK_SEMI;
000528        }
000529        zSql -= n;
000530      }
000531      if( tokenType>=TK_SPACE ){
000532        assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
000533        if( db->u1.isInterrupted ){
000534          pParse->rc = SQLITE_INTERRUPT;
000535          break;
000536        }
000537        if( tokenType==TK_ILLEGAL ){
000538          sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql);
000539          break;
000540        }
000541        zSql += n;
000542      }else{
000543        pParse->sLastToken.z = zSql;
000544        pParse->sLastToken.n = n;
000545        sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
000546        lastTokenParsed = tokenType;
000547        zSql += n;
000548        if( pParse->rc!=SQLITE_OK || db->mallocFailed ) break;
000549      }
000550    }
000551    assert( nErr==0 );
000552    pParse->zTail = zSql;
000553  #ifdef YYTRACKMAXSTACKDEPTH
000554    sqlite3_mutex_enter(sqlite3MallocMutex());
000555    sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK,
000556        sqlite3ParserStackPeak(pEngine)
000557    );
000558    sqlite3_mutex_leave(sqlite3MallocMutex());
000559  #endif /* YYDEBUG */
000560  #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
000561    sqlite3ParserFinalize(pEngine);
000562  #else
000563    sqlite3ParserFree(pEngine, sqlite3_free);
000564  #endif
000565    if( db->mallocFailed ){
000566      pParse->rc = SQLITE_NOMEM_BKPT;
000567    }
000568    if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
000569      pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc));
000570    }
000571    assert( pzErrMsg!=0 );
000572    if( pParse->zErrMsg ){
000573      *pzErrMsg = pParse->zErrMsg;
000574      sqlite3_log(pParse->rc, "%s", *pzErrMsg);
000575      pParse->zErrMsg = 0;
000576      nErr++;
000577    }
000578    if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
000579      sqlite3VdbeDelete(pParse->pVdbe);
000580      pParse->pVdbe = 0;
000581    }
000582  #ifndef SQLITE_OMIT_SHARED_CACHE
000583    if( pParse->nested==0 ){
000584      sqlite3DbFree(db, pParse->aTableLock);
000585      pParse->aTableLock = 0;
000586      pParse->nTableLock = 0;
000587    }
000588  #endif
000589  #ifndef SQLITE_OMIT_VIRTUALTABLE
000590    sqlite3_free(pParse->apVtabLock);
000591  #endif
000592  
000593    if( !IN_DECLARE_VTAB ){
000594      /* If the pParse->declareVtab flag is set, do not delete any table 
000595      ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
000596      ** will take responsibility for freeing the Table structure.
000597      */
000598      sqlite3DeleteTable(db, pParse->pNewTable);
000599    }
000600  
000601    if( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree);
000602    sqlite3DeleteTrigger(db, pParse->pNewTrigger);
000603    sqlite3DbFree(db, pParse->pVList);
000604    while( pParse->pAinc ){
000605      AutoincInfo *p = pParse->pAinc;
000606      pParse->pAinc = p->pNext;
000607      sqlite3DbFreeNN(db, p);
000608    }
000609    while( pParse->pZombieTab ){
000610      Table *p = pParse->pZombieTab;
000611      pParse->pZombieTab = p->pNextZombie;
000612      sqlite3DeleteTable(db, p);
000613    }
000614    assert( nErr==0 || pParse->rc!=SQLITE_OK );
000615    return nErr;
000616  }