| OLD | NEW |
|---|
| (Empty) |
| 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 preceded 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 definition. | |
| 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 simpler | |
| 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 */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
