/*** 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 implements the sqlite3_complete() API.** This code used to be part of the tokenizer.c source file.  But by** separating it out, the code will be automatically omitted from** static links that do not use it.**** $Id: complete.c,v 1.7 2008/06/13 18:24:27 drh Exp $*/#include "sqliteInt.h"#ifndef SQLITE_OMIT_COMPLETE/*** This is defined in tokenize.c.  We just have to import the definition.*/#ifndef SQLITE_AMALGAMATION#ifdef SQLITE_ASCIIextern const char sqlite3IsAsciiIdChar[];#define IdChar(C)  (((c=C)&0x80)!=0 || (c>0x1f && sqlite3IsAsciiIdChar[c-0x20]))#endif#ifdef SQLITE_EBCDICextern const char sqlite3IsEbcdicIdChar[];#define IdChar(C)  (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))#endif#endif /* SQLITE_AMALGAMATION *//*** Token types used by the sqlite3_complete() routine.  See the header** comments on that procedure for additional information.*/#define tkSEMI    0#define tkWS      1#define tkOTHER   2#define tkEXPLAIN 3#define tkCREATE  4#define tkTEMP    5#define tkTRIGGER 6#define tkEND     7/*** Return TRUE if the given SQL string ends in a semicolon.**** Special handling is require for CREATE TRIGGER statements.** Whenever the CREATE TRIGGER keywords are seen, the statement** must end with ";END;".**** This implementation uses a state machine with 7 states:****   (0) START     At the beginning or end of an SQL statement.  This routine**                 returns 1 if it ends in the START state and 0 if it ends**                 in any other state.****   (1) NORMAL    We are in the middle of statement which ends with a single**                 semicolon.****   (2) EXPLAIN   The keyword EXPLAIN has been seen at the beginning of **                 a statement.****   (3) CREATE    The keyword CREATE has been seen at the beginning of a**                 statement, possibly preceeded by EXPLAIN and/or followed by**                 TEMP or TEMPORARY****   (4) TRIGGER   We are in the middle of a trigger definition that must be**                 ended by a semicolon, the keyword END, and another semicolon.****   (5) SEMI      We've seen the first semicolon in the ";END;" that occurs at**                 the end of a trigger definition.****   (6) END       We've seen the ";END" of the ";END;" that occurs at the end**                 of a trigger difinition.**** Transitions between states above are determined by tokens extracted** from the input.  The following tokens are significant:****   (0) tkSEMI      A semicolon.**   (1) tkWS        Whitespace**   (2) tkOTHER     Any other SQL token.**   (3) tkEXPLAIN   The "explain" keyword.**   (4) tkCREATE    The "create" keyword.**   (5) tkTEMP      The "temp" or "temporary" keyword.**   (6) tkTRIGGER   The "trigger" keyword.**   (7) tkEND       The "end" keyword.**** Whitespace never causes a state transition and is always ignored.**** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed** to recognize the end of a trigger can be omitted.  All we have to do** is look for a semicolon that is not part of an string or comment.*/int sqlite3_complete(const char *zSql){  u8 state = 0;   /* Current state, using numbers defined in header comment */  u8 token;       /* Value of the next token */#ifndef SQLITE_OMIT_TRIGGER  /* A complex statement machine used to detect the end of a CREATE TRIGGER  ** statement.  This is the normal case.  */  static const u8 trans[7][8] = {                     /* Token:                                                */     /* State:       **  SEMI  WS  OTHER EXPLAIN  CREATE  TEMP  TRIGGER  END  */     /* 0   START: */ {    0,  0,     1,      2,      3,    1,       1,   1,  },     /* 1  NORMAL: */ {    0,  1,     1,      1,      1,    1,       1,   1,  },     /* 2 EXPLAIN: */ {    0,  2,     1,      1,      3,    1,       1,   1,  },     /* 3  CREATE: */ {    0,  3,     1,      1,      1,    3,       4,   1,  },     /* 4 TRIGGER: */ {    5,  4,     4,      4,      4,    4,       4,   4,  },     /* 5    SEMI: */ {    5,  5,     4,      4,      4,    4,       4,   6,  },     /* 6     END: */ {    0,  6,     4,      4,      4,    4,       4,   4,  },  };#else  /* If triggers are not suppored by this compile then the statement machine  ** used to detect the end of a statement is much simplier  */  static const u8 trans[2][3] = {                     /* Token:           */     /* State:       **  SEMI  WS  OTHER */     /* 0   START: */ {    0,  0,     1, },     /* 1  NORMAL: */ {    0,  1,     1, },  };#endif /* SQLITE_OMIT_TRIGGER */  while( *zSql ){    switch( *zSql ){      case ';': {  /* A semicolon */        token = tkSEMI;        break;      }      case ' ':      case '\r':      case '\t':      case '\n':      case '\f': {  /* White space is ignored */        token = tkWS;        break;      }      case '/': {   /* C-style comments */        if( zSql[1]!='*' ){          token = tkOTHER;          break;        }        zSql += 2;        while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }        if( zSql[0]==0 ) return 0;        zSql++;        token = tkWS;        break;      }      case '-': {   /* SQL-style comments from "--" to end of line */        if( zSql[1]!='-' ){          token = tkOTHER;          break;        }        while( *zSql && *zSql!='\n' ){ zSql++; }        if( *zSql==0 ) return state==0;        token = tkWS;        break;      }      case '[': {   /* Microsoft-style identifiers in [...] */        zSql++;        while( *zSql && *zSql!=']' ){ zSql++; }        if( *zSql==0 ) return 0;        token = tkOTHER;        break;      }      case '`':     /* Grave-accent quoted symbols used by MySQL */      case '"':     /* single- and double-quoted strings */      case '\'': {        int c = *zSql;        zSql++;        while( *zSql && *zSql!=c ){ zSql++; }        if( *zSql==0 ) return 0;        token = tkOTHER;        break;      }      default: {        int c;        if( IdChar((u8)*zSql) ){          /* Keywords and unquoted identifiers */          int nId;          for(nId=1; IdChar(zSql[nId]); nId++){}#ifdef SQLITE_OMIT_TRIGGER          token = tkOTHER;#else          switch( *zSql ){            case 'c': case 'C': {              if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){                token = tkCREATE;              }else{                token = tkOTHER;              }              break;            }            case 't': case 'T': {              if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){                token = tkTRIGGER;              }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){                token = tkTEMP;              }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){                token = tkTEMP;              }else{                token = tkOTHER;              }              break;            }            case 'e':  case 'E': {              if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){                token = tkEND;              }else#ifndef SQLITE_OMIT_EXPLAIN              if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){                token = tkEXPLAIN;              }else#endif              {                token = tkOTHER;              }              break;            }            default: {              token = tkOTHER;              break;            }          }#endif /* SQLITE_OMIT_TRIGGER */          zSql += nId-1;        }else{          /* Operators and special symbols */          token = tkOTHER;        }        break;      }    }    state = trans[state][token];    zSql++;  }  return state==0;}#ifndef SQLITE_OMIT_UTF16/*** This routine is the same as the sqlite3_complete() routine described** above, except that the parameter is required to be UTF-16 encoded, not** UTF-8.*/int sqlite3_complete16(const void *zSql){  sqlite3_value *pVal;  char const *zSql8;  int rc = SQLITE_NOMEM;#ifndef SQLITE_OMIT_AUTOINIT  rc = sqlite3_initialize();  if( rc ) return rc;#endif  pVal = sqlite3ValueNew(0);  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);  if( zSql8 ){    rc = sqlite3_complete(zSql8);  }else{    rc = SQLITE_NOMEM;  }  sqlite3ValueFree(pVal);  return sqlite3ApiExit(0, rc);}#endif /* SQLITE_OMIT_UTF16 */#endif /* SQLITE_OMIT_COMPLETE */