← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/sqlite/tokenize.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/sqlite/tokenize.c
 
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 splits an SQL input string up into
 
15
** individual tokens and sends those tokens one-by-one over to the
 
16
** parser for analysis.
 
17
**
 
18
** $Id: tokenize.c,v 1.101 2005/02/26 17:31:27 drh Exp $
 
19
*/
 
20
#include "sqliteInt.h"
 
21
#include "os.h"
 
22
#include <ctype.h>
 
23
#include <stdlib.h>
 
24
 
 
25
/*
 
26
** The sqlite3KeywordCode function looks up an identifier to determine if
 
27
** it is a keyword.  If it is a keyword, the token code of that keyword is 
 
28
** returned.  If the input is not a keyword, TK_ID is returned.
 
29
**
 
30
** The implementation of this routine was generated by a program,
 
31
** mkkeywordhash.h, located in the tool subdirectory of the distribution.
 
32
** The output of the mkkeywordhash.c program is written into a file
 
33
** named keywordhash.h and then included into this source file by
 
34
** the #include below.
 
35
*/
 
36
#include "keywordhash.h"
 
37
 
 
38
 
 
39
/*
 
40
** If X is a character that can be used in an identifier and
 
41
** X&0x80==0 then isIdChar[X] will be 1.  If X&0x80==0x80 then
 
42
** X is always an identifier character.  (Hence all UTF-8
 
43
** characters can be part of an identifier).  isIdChar[X] will
 
44
** be 0 for every character in the lower 128 ASCII characters
 
45
** that cannot be used as part of an identifier.
 
46
**
 
47
** In this implementation, an identifier can be a string of
 
48
** alphabetic characters, digits, and "_" plus any character
 
49
** with the high-order bit set.  The latter rule means that
 
50
** any sequence of UTF-8 characters or characters taken from
 
51
** an extended ISO8859 character set can form an identifier.
 
52
**
 
53
** Ticket #1066.  the SQL standard does not allow '$' in the
 
54
** middle of identfiers.  But many SQL implementations do. 
 
55
** SQLite will allow '$' in identifiers for compatibility.
 
56
** But the feature is undocumented.
 
57
*/
 
58
static const char isIdChar[] = {
 
59
/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
 
60
    0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 2x */
 
61
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
 
62
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
 
63
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
 
64
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
 
65
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
 
66
};
 
67
 
 
68
#define IdChar(C)  (((c=C)&0x80)!=0 || (c>0x1f && isIdChar[c-0x20]))
 
69
 
 
70
/*
 
71
** Return the length of the token that begins at z[0]. 
 
72
** Store the token type in *tokenType before returning.
 
73
*/
 
74
static int getToken(const unsigned char *z, int *tokenType){
 
75
  int i, c;
 
76
  switch( *z ){
 
77
    case ' ': case '\t': case '\n': case '\f': case '\r': {
 
78
      for(i=1; isspace(z[i]); i++){}
 
79
      *tokenType = TK_SPACE;
 
80
      return i;
 
81
    }
 
82
    case '-': {
 
83
      if( z[1]=='-' ){
 
84
        for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
 
85
        *tokenType = TK_COMMENT;
 
86
        return i;
 
87
      }
 
88
      *tokenType = TK_MINUS;
 
89
      return 1;
 
90
    }
 
91
    case '(': {
 
92
      *tokenType = TK_LP;
 
93
      return 1;
 
94
    }
 
95
    case ')': {
 
96
      *tokenType = TK_RP;
 
97
      return 1;
 
98
    }
 
99
    case ';': {
 
100
      *tokenType = TK_SEMI;
 
101
      return 1;
 
102
    }
 
103
    case '+': {
 
104
      *tokenType = TK_PLUS;
 
105
      return 1;
 
106
    }
 
107
    case '*': {
 
108
      *tokenType = TK_STAR;
 
109
      return 1;
 
110
    }
 
111
    case '/': {
 
112
      if( z[1]!='*' || z[2]==0 ){
 
113
        *tokenType = TK_SLASH;
 
114
        return 1;
 
115
      }
 
116
      for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
 
117
      if( c ) i++;
 
118
      *tokenType = TK_COMMENT;
 
119
      return i;
 
120
    }
 
121
    case '%': {
 
122
      *tokenType = TK_REM;
 
123
      return 1;
 
124
    }
 
125
    case '=': {
 
126
      *tokenType = TK_EQ;
 
127
      return 1 + (z[1]=='=');
 
128
    }
 
129
    case '<': {
 
130
      if( (c=z[1])=='=' ){
 
131
        *tokenType = TK_LE;
 
132
        return 2;
 
133
      }else if( c=='>' ){
 
134
        *tokenType = TK_NE;
 
135
        return 2;
 
136
      }else if( c=='<' ){
 
137
        *tokenType = TK_LSHIFT;
 
138
        return 2;
 
139
      }else{
 
140
        *tokenType = TK_LT;
 
141
        return 1;
 
142
      }
 
143
    }
 
144
    case '>': {
 
145
      if( (c=z[1])=='=' ){
 
146
        *tokenType = TK_GE;
 
147
        return 2;
 
148
      }else if( c=='>' ){
 
149
        *tokenType = TK_RSHIFT;
 
150
        return 2;
 
151
      }else{
 
152
        *tokenType = TK_GT;
 
153
        return 1;
 
154
      }
 
155
    }
 
156
    case '!': {
 
157
      if( z[1]!='=' ){
 
158
        *tokenType = TK_ILLEGAL;
 
159
        return 2;
 
160
      }else{
 
161
        *tokenType = TK_NE;
 
162
        return 2;
 
163
      }
 
164
    }
 
165
    case '|': {
 
166
      if( z[1]!='|' ){
 
167
        *tokenType = TK_BITOR;
 
168
        return 1;
 
169
      }else{
 
170
        *tokenType = TK_CONCAT;
 
171
        return 2;
 
172
      }
 
173
    }
 
174
    case ',': {
 
175
      *tokenType = TK_COMMA;
 
176
      return 1;
 
177
    }
 
178
    case '&': {
 
179
      *tokenType = TK_BITAND;
 
180
      return 1;
 
181
    }
 
182
    case '~': {
 
183
      *tokenType = TK_BITNOT;
 
184
      return 1;
 
185
    }
 
186
    case '#': {
 
187
      for(i=1; isdigit(z[i]) || (i==1 && z[1]=='-'); i++){}
 
188
      *tokenType = TK_REGISTER;
 
189
      return i;
 
190
    }
 
191
    case '\'': case '"': {
 
192
      int delim = z[0];
 
193
      for(i=1; (c=z[i])!=0; i++){
 
194
        if( c==delim ){
 
195
          if( z[i+1]==delim ){
 
196
            i++;
 
197
          }else{
 
198
            break;
 
199
          }
 
200
        }
 
201
      }
 
202
      if( c ) i++;
 
203
      *tokenType = TK_STRING;
 
204
      return i;
 
205
    }
 
206
    case '.': {
 
207
      *tokenType = TK_DOT;
 
208
      return 1;
 
209
    }
 
210
    case '0': case '1': case '2': case '3': case '4':
 
211
    case '5': case '6': case '7': case '8': case '9': {
 
212
      *tokenType = TK_INTEGER;
 
213
      for(i=1; isdigit(z[i]); i++){}
 
214
#ifndef SQLITE_OMIT_FLOATING_POINT
 
215
      if( z[i]=='.' && isdigit(z[i+1]) ){
 
216
        i += 2;
 
217
        while( isdigit(z[i]) ){ i++; }
 
218
        *tokenType = TK_FLOAT;
 
219
      }
 
220
      if( (z[i]=='e' || z[i]=='E') &&
 
221
           ( isdigit(z[i+1]) 
 
222
            || ((z[i+1]=='+' || z[i+1]=='-') && isdigit(z[i+2]))
 
223
           )
 
224
      ){
 
225
        i += 2;
 
226
        while( isdigit(z[i]) ){ i++; }
 
227
        *tokenType = TK_FLOAT;
 
228
      }
 
229
#endif
 
230
      return i;
 
231
    }
 
232
    case '[': {
 
233
      for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
 
234
      *tokenType = TK_ID;
 
235
      return i;
 
236
    }
 
237
    case '?': {
 
238
      *tokenType = TK_VARIABLE;
 
239
      for(i=1; isdigit(z[i]); i++){}
 
240
      return i;
 
241
    }
 
242
    case ':': {
 
243
      for(i=1; IdChar(z[i]); i++){}
 
244
      *tokenType = i>1 ? TK_VARIABLE : TK_ILLEGAL;
 
245
      return i;
 
246
    }
 
247
#ifndef SQLITE_OMIT_TCL_VARIABLE
 
248
    case '$': {
 
249
      *tokenType = TK_VARIABLE;
 
250
      if( z[1]=='{' ){
 
251
        int nBrace = 1;
 
252
        for(i=2; (c=z[i])!=0 && nBrace; i++){
 
253
          if( c=='{' ){
 
254
            nBrace++;
 
255
          }else if( c=='}' ){
 
256
            nBrace--;
 
257
          }
 
258
        }
 
259
        if( c==0 ) *tokenType = TK_ILLEGAL;
 
260
      }else{
 
261
        int n = 0;
 
262
        for(i=1; (c=z[i])!=0; i++){
 
263
          if( isalnum(c) || c=='_' ){
 
264
            n++;
 
265
          }else if( c=='(' && n>0 ){
 
266
            do{
 
267
              i++;
 
268
            }while( (c=z[i])!=0 && !isspace(c) && c!=')' );
 
269
            if( c==')' ){
 
270
              i++;
 
271
            }else{
 
272
              *tokenType = TK_ILLEGAL;
 
273
            }
 
274
            break;
 
275
          }else if( c==':' && z[i+1]==':' ){
 
276
            i++;
 
277
          }else{
 
278
            break;
 
279
          }
 
280
        }
 
281
        if( n==0 ) *tokenType = TK_ILLEGAL;
 
282
      }
 
283
      return i;
 
284
    }
 
285
#endif
 
286
#ifndef SQLITE_OMIT_BLOB_LITERAL
 
287
    case 'x': case 'X': {
 
288
      if( (c=z[1])=='\'' || c=='"' ){
 
289
        int delim = c;
 
290
        *tokenType = TK_BLOB;
 
291
        for(i=2; (c=z[i])!=0; i++){
 
292
          if( c==delim ){
 
293
            if( i%2 ) *tokenType = TK_ILLEGAL;
 
294
            break;
 
295
          }
 
296
          if( !isxdigit(c) ){
 
297
            *tokenType = TK_ILLEGAL;
 
298
            return i;
 
299
          }
 
300
        }
 
301
        if( c ) i++;
 
302
        return i;
 
303
      }
 
304
      /* Otherwise fall through to the next case */
 
305
    }
 
306
#endif
 
307
    default: {
 
308
      if( !IdChar(*z) ){
 
309
        break;
 
310
      }
 
311
      for(i=1; IdChar(z[i]); i++){}
 
312
      *tokenType = keywordCode((char*)z, i);
 
313
      return i;
 
314
    }
 
315
  }
 
316
  *tokenType = TK_ILLEGAL;
 
317
  return 1;
 
318
}
 
319
int sqlite3GetToken(const unsigned char *z, int *tokenType){
 
320
  return getToken(z, tokenType);
 
321
}
 
322
 
 
323
/*
 
324
** Run the parser on the given SQL string.  The parser structure is
 
325
** passed in.  An SQLITE_ status code is returned.  If an error occurs
 
326
** and pzErrMsg!=NULL then an error message might be written into 
 
327
** memory obtained from malloc() and *pzErrMsg made to point to that
 
328
** error message.  Or maybe not.
 
329
*/
 
330
int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
 
331
  int nErr = 0;
 
332
  int i;
 
333
  void *pEngine;
 
334
  int tokenType;
 
335
  int lastTokenParsed = -1;
 
336
  sqlite3 *db = pParse->db;
 
337
  extern void *sqlite3ParserAlloc(void*(*)(int));
 
338
  extern void sqlite3ParserFree(void*, void(*)(void*));
 
339
  extern int sqlite3Parser(void*, int, Token, Parse*);
 
340
 
 
341
  db->flags &= ~SQLITE_Interrupt;
 
342
  pParse->rc = SQLITE_OK;
 
343
  i = 0;
 
344
  pEngine = sqlite3ParserAlloc((void*(*)(int))malloc);
 
345
  if( pEngine==0 ){
 
346
    sqlite3SetString(pzErrMsg, "out of memory", (char*)0);
 
347
    return 1;
 
348
  }
 
349
  assert( pParse->sLastToken.dyn==0 );
 
350
  assert( pParse->pNewTable==0 );
 
351
  assert( pParse->pNewTrigger==0 );
 
352
  assert( pParse->nVar==0 );
 
353
  assert( pParse->nVarExpr==0 );
 
354
  assert( pParse->nVarExprAlloc==0 );
 
355
  assert( pParse->apVarExpr==0 );
 
356
  pParse->zTail = pParse->zSql = zSql;
 
357
  while( sqlite3_malloc_failed==0 && zSql[i]!=0 ){
 
358
    assert( i>=0 );
 
359
    pParse->sLastToken.z = &zSql[i];
 
360
    assert( pParse->sLastToken.dyn==0 );
 
361
    pParse->sLastToken.n = getToken((unsigned char*)&zSql[i],&tokenType);
 
362
    i += pParse->sLastToken.n;
 
363
    switch( tokenType ){
 
364
      case TK_SPACE:
 
365
      case TK_COMMENT: {
 
366
        if( (db->flags & SQLITE_Interrupt)!=0 ){
 
367
          pParse->rc = SQLITE_INTERRUPT;
 
368
          sqlite3SetString(pzErrMsg, "interrupt", (char*)0);
 
369
          goto abort_parse;
 
370
        }
 
371
        break;
 
372
      }
 
373
      case TK_ILLEGAL: {
 
374
        if( pzErrMsg ){
 
375
          sqliteFree(*pzErrMsg);
 
376
          *pzErrMsg = sqlite3MPrintf("unrecognized token: \"%T\"",
 
377
                          &pParse->sLastToken);
 
378
        }
 
379
        nErr++;
 
380
        goto abort_parse;
 
381
      }
 
382
      case TK_SEMI: {
 
383
        pParse->zTail = &zSql[i];
 
384
        /* Fall thru into the default case */
 
385
      }
 
386
      default: {
 
387
        sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
 
388
        lastTokenParsed = tokenType;
 
389
        if( pParse->rc!=SQLITE_OK ){
 
390
          goto abort_parse;
 
391
        }
 
392
        break;
 
393
      }
 
394
    }
 
395
  }
 
396
abort_parse:
 
397
  if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
 
398
    if( lastTokenParsed!=TK_SEMI ){
 
399
      sqlite3Parser(pEngine, TK_SEMI, pParse->sLastToken, pParse);
 
400
      pParse->zTail = &zSql[i];
 
401
    }
 
402
    sqlite3Parser(pEngine, 0, pParse->sLastToken, pParse);
 
403
  }
 
404
  sqlite3ParserFree(pEngine, free);
 
405
  if( sqlite3_malloc_failed ){
 
406
    pParse->rc = SQLITE_NOMEM;
 
407
  }
 
408
  if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
 
409
    sqlite3SetString(&pParse->zErrMsg, sqlite3ErrStr(pParse->rc),
 
410
                    (char*)0);
 
411
  }
 
412
  if( pParse->zErrMsg ){
 
413
    if( pzErrMsg && *pzErrMsg==0 ){
 
414
      *pzErrMsg = pParse->zErrMsg;
 
415
    }else{
 
416
      sqliteFree(pParse->zErrMsg);
 
417
    }
 
418
    pParse->zErrMsg = 0;
 
419
    if( !nErr ) nErr++;
 
420
  }
 
421
  if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
 
422
    sqlite3VdbeDelete(pParse->pVdbe);
 
423
    pParse->pVdbe = 0;
 
424
  }
 
425
  sqlite3DeleteTable(pParse->db, pParse->pNewTable);
 
426
  sqlite3DeleteTrigger(pParse->pNewTrigger);
 
427
  sqliteFree(pParse->apVarExpr);
 
428
  if( nErr>0 && (pParse->rc==SQLITE_OK || pParse->rc==SQLITE_DONE) ){
 
429
    pParse->rc = SQLITE_ERROR;
 
430
  }
 
431
  return nErr;
 
432
}
 
433
 
 
434
/* The sqlite3_complete() API may be omitted (to save code space) by
 
435
** defining the following symbol.
 
436
*/
 
437
#ifndef SQLITE_OMIT_COMPLETE
 
438
 
 
439
/*
 
440
** Token types used by the sqlite3_complete() routine.  See the header
 
441
** comments on that procedure for additional information.
 
442
*/
 
443
#define tkSEMI    0
 
444
#define tkWS      1
 
445
#define tkOTHER   2
 
446
#define tkEXPLAIN 3
 
447
#define tkCREATE  4
 
448
#define tkTEMP    5
 
449
#define tkTRIGGER 6
 
450
#define tkEND     7
 
451
 
 
452
/*
 
453
** Return TRUE if the given SQL string ends in a semicolon.
 
454
**
 
455
** Special handling is require for CREATE TRIGGER statements.
 
456
** Whenever the CREATE TRIGGER keywords are seen, the statement
 
457
** must end with ";END;".
 
458
**
 
459
** This implementation uses a state machine with 7 states:
 
460
**
 
461
**   (0) START     At the beginning or end of an SQL statement.  This routine
 
462
**                 returns 1 if it ends in the START state and 0 if it ends
 
463
**                 in any other state.
 
464
**
 
465
**   (1) NORMAL    We are in the middle of statement which ends with a single
 
466
**                 semicolon.
 
467
**
 
468
**   (2) EXPLAIN   The keyword EXPLAIN has been seen at the beginning of 
 
469
**                 a statement.
 
470
**
 
471
**   (3) CREATE    The keyword CREATE has been seen at the beginning of a
 
472
**                 statement, possibly preceeded by EXPLAIN and/or followed by
 
473
**                 TEMP or TEMPORARY
 
474
**
 
475
**   (4) TRIGGER   We are in the middle of a trigger definition that must be
 
476
**                 ended by a semicolon, the keyword END, and another semicolon.
 
477
**
 
478
**   (5) SEMI      We've seen the first semicolon in the ";END;" that occurs at
 
479
**                 the end of a trigger definition.
 
480
**
 
481
**   (6) END       We've seen the ";END" of the ";END;" that occurs at the end
 
482
**                 of a trigger difinition.
 
483
**
 
484
** Transitions between states above are determined by tokens extracted
 
485
** from the input.  The following tokens are significant:
 
486
**
 
487
**   (0) tkSEMI      A semicolon.
 
488
**   (1) tkWS        Whitespace
 
489
**   (2) tkOTHER     Any other SQL token.
 
490
**   (3) tkEXPLAIN   The "explain" keyword.
 
491
**   (4) tkCREATE    The "create" keyword.
 
492
**   (5) tkTEMP      The "temp" or "temporary" keyword.
 
493
**   (6) tkTRIGGER   The "trigger" keyword.
 
494
**   (7) tkEND       The "end" keyword.
 
495
**
 
496
** Whitespace never causes a state transition and is always ignored.
 
497
**
 
498
** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
 
499
** to recognize the end of a trigger can be omitted.  All we have to do
 
500
** is look for a semicolon that is not part of an string or comment.
 
501
*/
 
502
int sqlite3_complete(const char *zSql){
 
503
  u8 state = 0;   /* Current state, using numbers defined in header comment */
 
504
  u8 token;       /* Value of the next token */
 
505
 
 
506
#ifndef SQLITE_OMIT_TRIGGER
 
507
  /* A complex statement machine used to detect the end of a CREATE TRIGGER
 
508
  ** statement.  This is the normal case.
 
509
  */
 
510
  static const u8 trans[7][8] = {
 
511
                     /* Token:                                                */
 
512
     /* State:       **  SEMI  WS  OTHER EXPLAIN  CREATE  TEMP  TRIGGER  END  */
 
513
     /* 0   START: */ {    0,  0,     1,      2,      3,    1,       1,   1,  },
 
514
     /* 1  NORMAL: */ {    0,  1,     1,      1,      1,    1,       1,   1,  },
 
515
     /* 2 EXPLAIN: */ {    0,  2,     1,      1,      3,    1,       1,   1,  },
 
516
     /* 3  CREATE: */ {    0,  3,     1,      1,      1,    3,       4,   1,  },
 
517
     /* 4 TRIGGER: */ {    5,  4,     4,      4,      4,    4,       4,   4,  },
 
518
     /* 5    SEMI: */ {    5,  5,     4,      4,      4,    4,       4,   6,  },
 
519
     /* 6     END: */ {    0,  6,     4,      4,      4,    4,       4,   4,  },
 
520
  };
 
521
#else
 
522
  /* If triggers are not suppored by this compile then the statement machine
 
523
  ** used to detect the end of a statement is much simplier
 
524
  */
 
525
  static const u8 trans[2][3] = {
 
526
                     /* Token:           */
 
527
     /* State:       **  SEMI  WS  OTHER */
 
528
     /* 0   START: */ {    0,  0,     1, },
 
529
     /* 1  NORMAL: */ {    0,  1,     1, },
 
530
  };
 
531
#endif /* SQLITE_OMIT_TRIGGER */
 
532
 
 
533
  while( *zSql ){
 
534
    switch( *zSql ){
 
535
      case ';': {  /* A semicolon */
 
536
        token = tkSEMI;
 
537
        break;
 
538
      }
 
539
      case ' ':
 
540
      case '\r':
 
541
      case '\t':
 
542
      case '\n':
 
543
      case '\f': {  /* White space is ignored */
 
544
        token = tkWS;
 
545
        break;
 
546
      }
 
547
      case '/': {   /* C-style comments */
 
548
        if( zSql[1]!='*' ){
 
549
          token = tkOTHER;
 
550
          break;
 
551
        }
 
552
        zSql += 2;
 
553
        while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
 
554
        if( zSql[0]==0 ) return 0;
 
555
        zSql++;
 
556
        token = tkWS;
 
557
        break;
 
558
      }
 
559
      case '-': {   /* SQL-style comments from "--" to end of line */
 
560
        if( zSql[1]!='-' ){
 
561
          token = tkOTHER;
 
562
          break;
 
563
        }
 
564
        while( *zSql && *zSql!='\n' ){ zSql++; }
 
565
        if( *zSql==0 ) return state==0;
 
566
        token = tkWS;
 
567
        break;
 
568
      }
 
569
      case '[': {   /* Microsoft-style identifiers in [...] */
 
570
        zSql++;
 
571
        while( *zSql && *zSql!=']' ){ zSql++; }
 
572
        if( *zSql==0 ) return 0;
 
573
        token = tkOTHER;
 
574
        break;
 
575
      }
 
576
      case '"':     /* single- and double-quoted strings */
 
577
      case '\'': {
 
578
        int c = *zSql;
 
579
        zSql++;
 
580
        while( *zSql && *zSql!=c ){ zSql++; }
 
581
        if( *zSql==0 ) return 0;
 
582
        token = tkOTHER;
 
583
        break;
 
584
      }
 
585
      default: {
 
586
        int c;
 
587
        if( IdChar((u8)*zSql) ){
 
588
          /* Keywords and unquoted identifiers */
 
589
          int nId;
 
590
          for(nId=1; IdChar(zSql[nId]); nId++){}
 
591
#ifdef SQLITE_OMIT_TRIGGER
 
592
          token = tkOTHER;
 
593
#else
 
594
          switch( *zSql ){
 
595
            case 'c': case 'C': {
 
596
              if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
 
597
                token = tkCREATE;
 
598
              }else{
 
599
                token = tkOTHER;
 
600
              }
 
601
              break;
 
602
            }
 
603
            case 't': case 'T': {
 
604
              if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
 
605
                token = tkTRIGGER;
 
606
              }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
 
607
                token = tkTEMP;
 
608
              }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
 
609
                token = tkTEMP;
 
610
              }else{
 
611
                token = tkOTHER;
 
612
              }
 
613
              break;
 
614
            }
 
615
            case 'e':  case 'E': {
 
616
              if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
 
617
                token = tkEND;
 
618
              }else
 
619
#ifndef SQLITE_OMIT_EXPLAIN
 
620
              if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
 
621
                token = tkEXPLAIN;
 
622
              }else
 
623
#endif
 
624
              {
 
625
                token = tkOTHER;
 
626
              }
 
627
              break;
 
628
            }
 
629
            default: {
 
630
              token = tkOTHER;
 
631
              break;
 
632
            }
 
633
          }
 
634
#endif /* SQLITE_OMIT_TRIGGER */
 
635
          zSql += nId-1;
 
636
        }else{
 
637
          /* Operators and special symbols */
 
638
          token = tkOTHER;
 
639
        }
 
640
        break;
 
641
      }
 
642
    }
 
643
    state = trans[state][token];
 
644
    zSql++;
 
645
  }
 
646
  return state==0;
 
647
}
 
648
 
 
649
#ifndef SQLITE_OMIT_UTF16
 
650
/*
 
651
** This routine is the same as the sqlite3_complete() routine described
 
652
** above, except that the parameter is required to be UTF-16 encoded, not
 
653
** UTF-8.
 
654
*/
 
655
int sqlite3_complete16(const void *zSql){
 
656
  sqlite3_value *pVal;
 
657
  char const *zSql8;
 
658
  int rc = 0;
 
659
 
 
660
  pVal = sqlite3ValueNew();
 
661
  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
 
662
  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
 
663
  if( zSql8 ){
 
664
    rc = sqlite3_complete(zSql8);
 
665
  }
 
666
  sqlite3ValueFree(pVal);
 
667
  return rc;
 
668
}
 
669
#endif /* SQLITE_OMIT_UTF16 */
 
670
#endif /* SQLITE_OMIT_COMPLETE */