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