Annotation of embedaddon/sqlite3/src/complete.c, revision 1.1
1.1 ! misho 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 implements the sqlite3_complete() API.
! 15: ** This code used to be part of the tokenizer.c source file. But by
! 16: ** separating it out, the code will be automatically omitted from
! 17: ** static links that do not use it.
! 18: */
! 19: #include "sqliteInt.h"
! 20: #ifndef SQLITE_OMIT_COMPLETE
! 21:
! 22: /*
! 23: ** This is defined in tokenize.c. We just have to import the definition.
! 24: */
! 25: #ifndef SQLITE_AMALGAMATION
! 26: #ifdef SQLITE_ASCII
! 27: #define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
! 28: #endif
! 29: #ifdef SQLITE_EBCDIC
! 30: extern const char sqlite3IsEbcdicIdChar[];
! 31: #define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
! 32: #endif
! 33: #endif /* SQLITE_AMALGAMATION */
! 34:
! 35:
! 36: /*
! 37: ** Token types used by the sqlite3_complete() routine. See the header
! 38: ** comments on that procedure for additional information.
! 39: */
! 40: #define tkSEMI 0
! 41: #define tkWS 1
! 42: #define tkOTHER 2
! 43: #ifndef SQLITE_OMIT_TRIGGER
! 44: #define tkEXPLAIN 3
! 45: #define tkCREATE 4
! 46: #define tkTEMP 5
! 47: #define tkTRIGGER 6
! 48: #define tkEND 7
! 49: #endif
! 50:
! 51: /*
! 52: ** Return TRUE if the given SQL string ends in a semicolon.
! 53: **
! 54: ** Special handling is require for CREATE TRIGGER statements.
! 55: ** Whenever the CREATE TRIGGER keywords are seen, the statement
! 56: ** must end with ";END;".
! 57: **
! 58: ** This implementation uses a state machine with 8 states:
! 59: **
! 60: ** (0) INVALID We have not yet seen a non-whitespace character.
! 61: **
! 62: ** (1) START At the beginning or end of an SQL statement. This routine
! 63: ** returns 1 if it ends in the START state and 0 if it ends
! 64: ** in any other state.
! 65: **
! 66: ** (2) NORMAL We are in the middle of statement which ends with a single
! 67: ** semicolon.
! 68: **
! 69: ** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of
! 70: ** a statement.
! 71: **
! 72: ** (4) CREATE The keyword CREATE has been seen at the beginning of a
! 73: ** statement, possibly preceeded by EXPLAIN and/or followed by
! 74: ** TEMP or TEMPORARY
! 75: **
! 76: ** (5) TRIGGER We are in the middle of a trigger definition that must be
! 77: ** ended by a semicolon, the keyword END, and another semicolon.
! 78: **
! 79: ** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at
! 80: ** the end of a trigger definition.
! 81: **
! 82: ** (7) END We've seen the ";END" of the ";END;" that occurs at the end
! 83: ** of a trigger difinition.
! 84: **
! 85: ** Transitions between states above are determined by tokens extracted
! 86: ** from the input. The following tokens are significant:
! 87: **
! 88: ** (0) tkSEMI A semicolon.
! 89: ** (1) tkWS Whitespace.
! 90: ** (2) tkOTHER Any other SQL token.
! 91: ** (3) tkEXPLAIN The "explain" keyword.
! 92: ** (4) tkCREATE The "create" keyword.
! 93: ** (5) tkTEMP The "temp" or "temporary" keyword.
! 94: ** (6) tkTRIGGER The "trigger" keyword.
! 95: ** (7) tkEND The "end" keyword.
! 96: **
! 97: ** Whitespace never causes a state transition and is always ignored.
! 98: ** This means that a SQL string of all whitespace is invalid.
! 99: **
! 100: ** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
! 101: ** to recognize the end of a trigger can be omitted. All we have to do
! 102: ** is look for a semicolon that is not part of an string or comment.
! 103: */
! 104: int sqlite3_complete(const char *zSql){
! 105: u8 state = 0; /* Current state, using numbers defined in header comment */
! 106: u8 token; /* Value of the next token */
! 107:
! 108: #ifndef SQLITE_OMIT_TRIGGER
! 109: /* A complex statement machine used to detect the end of a CREATE TRIGGER
! 110: ** statement. This is the normal case.
! 111: */
! 112: static const u8 trans[8][8] = {
! 113: /* Token: */
! 114: /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */
! 115: /* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, },
! 116: /* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, },
! 117: /* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, },
! 118: /* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, },
! 119: /* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, },
! 120: /* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, },
! 121: /* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, },
! 122: /* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, },
! 123: };
! 124: #else
! 125: /* If triggers are not supported by this compile then the statement machine
! 126: ** used to detect the end of a statement is much simplier
! 127: */
! 128: static const u8 trans[3][3] = {
! 129: /* Token: */
! 130: /* State: ** SEMI WS OTHER */
! 131: /* 0 INVALID: */ { 1, 0, 2, },
! 132: /* 1 START: */ { 1, 1, 2, },
! 133: /* 2 NORMAL: */ { 1, 2, 2, },
! 134: };
! 135: #endif /* SQLITE_OMIT_TRIGGER */
! 136:
! 137: while( *zSql ){
! 138: switch( *zSql ){
! 139: case ';': { /* A semicolon */
! 140: token = tkSEMI;
! 141: break;
! 142: }
! 143: case ' ':
! 144: case '\r':
! 145: case '\t':
! 146: case '\n':
! 147: case '\f': { /* White space is ignored */
! 148: token = tkWS;
! 149: break;
! 150: }
! 151: case '/': { /* C-style comments */
! 152: if( zSql[1]!='*' ){
! 153: token = tkOTHER;
! 154: break;
! 155: }
! 156: zSql += 2;
! 157: while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
! 158: if( zSql[0]==0 ) return 0;
! 159: zSql++;
! 160: token = tkWS;
! 161: break;
! 162: }
! 163: case '-': { /* SQL-style comments from "--" to end of line */
! 164: if( zSql[1]!='-' ){
! 165: token = tkOTHER;
! 166: break;
! 167: }
! 168: while( *zSql && *zSql!='\n' ){ zSql++; }
! 169: if( *zSql==0 ) return state==1;
! 170: token = tkWS;
! 171: break;
! 172: }
! 173: case '[': { /* Microsoft-style identifiers in [...] */
! 174: zSql++;
! 175: while( *zSql && *zSql!=']' ){ zSql++; }
! 176: if( *zSql==0 ) return 0;
! 177: token = tkOTHER;
! 178: break;
! 179: }
! 180: case '`': /* Grave-accent quoted symbols used by MySQL */
! 181: case '"': /* single- and double-quoted strings */
! 182: case '\'': {
! 183: int c = *zSql;
! 184: zSql++;
! 185: while( *zSql && *zSql!=c ){ zSql++; }
! 186: if( *zSql==0 ) return 0;
! 187: token = tkOTHER;
! 188: break;
! 189: }
! 190: default: {
! 191: #ifdef SQLITE_EBCDIC
! 192: unsigned char c;
! 193: #endif
! 194: if( IdChar((u8)*zSql) ){
! 195: /* Keywords and unquoted identifiers */
! 196: int nId;
! 197: for(nId=1; IdChar(zSql[nId]); nId++){}
! 198: #ifdef SQLITE_OMIT_TRIGGER
! 199: token = tkOTHER;
! 200: #else
! 201: switch( *zSql ){
! 202: case 'c': case 'C': {
! 203: if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
! 204: token = tkCREATE;
! 205: }else{
! 206: token = tkOTHER;
! 207: }
! 208: break;
! 209: }
! 210: case 't': case 'T': {
! 211: if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
! 212: token = tkTRIGGER;
! 213: }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
! 214: token = tkTEMP;
! 215: }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
! 216: token = tkTEMP;
! 217: }else{
! 218: token = tkOTHER;
! 219: }
! 220: break;
! 221: }
! 222: case 'e': case 'E': {
! 223: if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
! 224: token = tkEND;
! 225: }else
! 226: #ifndef SQLITE_OMIT_EXPLAIN
! 227: if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
! 228: token = tkEXPLAIN;
! 229: }else
! 230: #endif
! 231: {
! 232: token = tkOTHER;
! 233: }
! 234: break;
! 235: }
! 236: default: {
! 237: token = tkOTHER;
! 238: break;
! 239: }
! 240: }
! 241: #endif /* SQLITE_OMIT_TRIGGER */
! 242: zSql += nId-1;
! 243: }else{
! 244: /* Operators and special symbols */
! 245: token = tkOTHER;
! 246: }
! 247: break;
! 248: }
! 249: }
! 250: state = trans[state][token];
! 251: zSql++;
! 252: }
! 253: return state==1;
! 254: }
! 255:
! 256: #ifndef SQLITE_OMIT_UTF16
! 257: /*
! 258: ** This routine is the same as the sqlite3_complete() routine described
! 259: ** above, except that the parameter is required to be UTF-16 encoded, not
! 260: ** UTF-8.
! 261: */
! 262: int sqlite3_complete16(const void *zSql){
! 263: sqlite3_value *pVal;
! 264: char const *zSql8;
! 265: int rc = SQLITE_NOMEM;
! 266:
! 267: #ifndef SQLITE_OMIT_AUTOINIT
! 268: rc = sqlite3_initialize();
! 269: if( rc ) return rc;
! 270: #endif
! 271: pVal = sqlite3ValueNew(0);
! 272: sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
! 273: zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
! 274: if( zSql8 ){
! 275: rc = sqlite3_complete(zSql8);
! 276: }else{
! 277: rc = SQLITE_NOMEM;
! 278: }
! 279: sqlite3ValueFree(pVal);
! 280: return sqlite3ApiExit(0, rc);
! 281: }
! 282: #endif /* SQLITE_OMIT_UTF16 */
! 283: #endif /* SQLITE_OMIT_COMPLETE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to complete.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src