third_party/sqlite/src/src/complete.c - cobalt - Git at Google

 /*
 ** 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.
 */
 #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_ASCII
 #define IdChar(C)  ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
 #endif
 #ifdef SQLITE_EBCDIC
 extern 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
 #ifndef SQLITE_OMIT_TRIGGER
 #define tkEXPLAIN 3
 #define tkCREATE  4
 #define tkTEMP    5
 #define tkTRIGGER 6
 #define tkEND     7
 #endif

 /*
 ** 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 8 states:
 **
 **   (0) INVALID   We have not yet seen a non-whitespace character.
 **
 **   (1) 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.
 **
 **   (2) NORMAL    We are in the middle of statement which ends with a single
 **                 semicolon.
 **
 **   (3) EXPLAIN   The keyword EXPLAIN has been seen at the beginning of
 **                 a statement.
 **
 **   (4) CREATE    The keyword CREATE has been seen at the beginning of a
 **                 statement, possibly preceeded by EXPLAIN and/or followed by
 **                 TEMP or TEMPORARY
 **
 **   (5) TRIGGER   We are in the middle of a trigger definition that must be
 **                 ended by a semicolon, the keyword END, and another semicolon.
 **
 **   (6) SEMI      We've seen the first semicolon in the ";END;" that occurs at
 **                 the end of a trigger definition.
 **
 **   (7) 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.
 ** This means that a SQL string of all whitespace is invalid.
 **
 ** 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[8][8] = {
                      /* Token:                                                */
      /* State:       **  SEMI  WS  OTHER  EXPLAIN  CREATE  TEMP  TRIGGER  END */
      /* 0 INVALID: */ {    1,  0,     2,       3,      4,    2,       2,   2, },
      /* 1   START: */ {    1,  1,     2,       3,      4,    2,       2,   2, },
      /* 2  NORMAL: */ {    1,  2,     2,       2,      2,    2,       2,   2, },
      /* 3 EXPLAIN: */ {    1,  3,     3,       2,      4,    2,       2,   2, },
      /* 4  CREATE: */ {    1,  4,     2,       2,      2,    4,       5,   2, },
      /* 5 TRIGGER: */ {    6,  5,     5,       5,      5,    5,       5,   5, },
      /* 6    SEMI: */ {    6,  6,     5,       5,      5,    5,       5,   7, },
      /* 7     END: */ {    1,  7,     5,       5,      5,    5,       5,   5, },
   };
 #else
   /* If triggers are not supported by this compile then the statement machine
   ** used to detect the end of a statement is much simplier
   */
   static const u8 trans[3][3] = {
                      /* Token:           */
      /* State:       **  SEMI  WS  OTHER */
      /* 0 INVALID: */ {    1,  0,     2, },
      /* 1   START: */ {    1,  1,     2, },
      /* 2  NORMAL: */ {    1,  2,     2, },
   };
 #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==1;
         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: {
 #ifdef SQLITE_EBCDIC
         unsigned char c;
 #endif
         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==1;
 }

 #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 */
	/*
	** 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.
	*/
	#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_ASCII
	#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
	#endif
	#ifdef SQLITE_EBCDIC
	extern 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
	#ifndef SQLITE_OMIT_TRIGGER
	#define tkEXPLAIN 3
	#define tkCREATE 4
	#define tkTEMP 5
	#define tkTRIGGER 6
	#define tkEND 7
	#endif

	/*
	** 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 8 states:
	**
	** (0) INVALID We have not yet seen a non-whitespace character.
	**
	** (1) 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.
	**
	** (2) NORMAL We are in the middle of statement which ends with a single
	** semicolon.
	**
	** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of
	** a statement.
	**
	** (4) CREATE The keyword CREATE has been seen at the beginning of a
	** statement, possibly preceeded by EXPLAIN and/or followed by
	** TEMP or TEMPORARY
	**
	** (5) TRIGGER We are in the middle of a trigger definition that must be
	** ended by a semicolon, the keyword END, and another semicolon.
	**
	** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at
	** the end of a trigger definition.
	**
	** (7) 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.
	** This means that a SQL string of all whitespace is invalid.
	**
	** 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[8][8] = {
	/* Token: */
	/* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */
	/* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, },
	/* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, },
	/* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, },
	/* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, },
	/* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, },
	/* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, },
	/* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, },
	/* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, },
	};
	#else
	/* If triggers are not supported by this compile then the statement machine
	** used to detect the end of a statement is much simplier
	*/
	static const u8 trans[3][3] = {
	/* Token: */
	/* State: ** SEMI WS OTHER */
	/* 0 INVALID: */ { 1, 0, 2, },
	/* 1 START: */ { 1, 1, 2, },
	/* 2 NORMAL: */ { 1, 2, 2, },
	};
	#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==1;
	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: {
	#ifdef SQLITE_EBCDIC
	unsigned char c;
	#endif
	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==1;
	}

	#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 */