← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/pars/pars0lex.l

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/pars/pars0lex.l
 
1
/******************************************************
 
2
SQL parser lexical analyzer: input file for the GNU Flex lexer generator
 
3
 
 
4
(c) 1997 Innobase Oy
 
5
 
 
6
Created 12/14/1997 Heikki Tuuri
 
7
Published under the GPL version 2
 
8
 
 
9
The InnoDB parser is frozen because MySQL takes care of SQL parsing.
 
10
Therefore we normally keep the InnoDB parser C files as they are, and do
 
11
not automatically generate them from pars0grm.y and pars0lex.l.
 
12
 
 
13
How to make the InnoDB parser and lexer C files:
 
14
 
 
15
1. Run ./make_flex.sh to generate lexer files.
 
16
 
 
17
2. Run ./make_bison.sh to generate parser files.
 
18
 
 
19
These instructions seem to work at least with bison-1.875d and flex-2.5.31 on
 
20
Linux.
 
21
*******************************************************/
 
22
 
 
23
%option nostdinit
 
24
%option 8bit
 
25
%option warn
 
26
%option pointer
 
27
%option never-interactive
 
28
%option nodefault
 
29
%option noinput
 
30
%option nounput
 
31
%option noyywrap
 
32
%option noyy_scan_buffer
 
33
%option noyy_scan_bytes
 
34
%option noyy_scan_string
 
35
%option nounistd
 
36
 
 
37
%{
 
38
#define YYSTYPE que_node_t*
 
39
 
 
40
#include "univ.i"
 
41
#include "pars0pars.h"
 
42
#include "pars0grm.h"
 
43
#include "pars0sym.h"
 
44
#include "mem0mem.h"
 
45
#include "os0proc.h"
 
46
 
 
47
#define malloc(A)       ut_malloc(A)
 
48
#define free(A)         ut_free(A)
 
49
#define realloc(P, A)   ut_realloc(P, A)
 
50
#define exit(A)         ut_error
 
51
 
 
52
#define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size)
 
53
 
 
54
/* String buffer for removing quotes */
 
55
static ulint    stringbuf_len_alloc = 0; /* Allocated length */
 
56
static ulint    stringbuf_len = 0; /* Current length */
 
57
static char*    stringbuf; /* Start of buffer */
 
58
/* Appends a string to the buffer. */
 
59
static
 
60
void
 
61
string_append(
 
62
/*==========*/
 
63
        const char*     str,    /* in: string to be appended */
 
64
        ulint           len)    /* in: length of the string */
 
65
{
 
66
        if (stringbuf == NULL) {
 
67
                stringbuf = malloc(1);
 
68
                stringbuf_len_alloc = 1;
 
69
        }
 
70
 
 
71
        if (stringbuf_len + len > stringbuf_len_alloc) {
 
72
                while (stringbuf_len + len > stringbuf_len_alloc) {
 
73
                        stringbuf_len_alloc <<= 1;
 
74
                }
 
75
                stringbuf = realloc(stringbuf, stringbuf_len_alloc);
 
76
        }
 
77
 
 
78
        memcpy(stringbuf + stringbuf_len, str, len);
 
79
        stringbuf_len += len;
 
80
}
 
81
 
 
82
%}
 
83
 
 
84
DIGIT   [0-9]
 
85
ID      [a-z_A-Z][a-z_A-Z0-9]*
 
86
BOUND_LIT       \:[a-z_A-Z0-9]+
 
87
BOUND_ID        \$[a-z_A-Z0-9]+
 
88
 
 
89
%x comment
 
90
%x quoted
 
91
%x id
 
92
%%
 
93
 
 
94
{DIGIT}+        {
 
95
                        yylval = sym_tab_add_int_lit(pars_sym_tab_global,
 
96
                                                                atoi(yytext));
 
97
                        return(PARS_INT_LIT);
 
98
}
 
99
 
 
100
{DIGIT}+"."{DIGIT}* {
 
101
                        ut_error;       /* not implemented */
 
102
 
 
103
                        return(PARS_FLOAT_LIT);
 
104
}
 
105
 
 
106
{BOUND_LIT}     {
 
107
                        ulint   type;
 
108
 
 
109
                        yylval = sym_tab_add_bound_lit(pars_sym_tab_global,
 
110
                                yytext + 1, &type);
 
111
 
 
112
                        return((int) type);
 
113
}
 
114
 
 
115
{BOUND_ID}      {
 
116
                        yylval = sym_tab_add_bound_id(pars_sym_tab_global,
 
117
                                yytext + 1);
 
118
 
 
119
                        return(PARS_ID_TOKEN);
 
120
}
 
121
 
 
122
"'"             {
 
123
/* Quoted character string literals are handled in an explicit
 
124
start state 'quoted'.  This state is entered and the buffer for
 
125
the scanned string is emptied upon encountering a starting quote.
 
126
 
 
127
In the state 'quoted', only two actions are possible (defined below). */
 
128
                        BEGIN(quoted);
 
129
                        stringbuf_len = 0;
 
130
}
 
131
<quoted>[^\']+  {
 
132
                        /* Got a sequence of characters other than "'":
 
133
                        append to string buffer */
 
134
                        string_append(yytext, yyleng);
 
135
}
 
136
<quoted>"'"+    {
 
137
                        /* Got a sequence of "'" characters:
 
138
                        append half of them to string buffer,
 
139
                        as "''" represents a single "'".
 
140
                        We apply truncating division,
 
141
                        so that "'''" will result in "'". */
 
142
 
 
143
                        string_append(yytext, yyleng / 2);
 
144
 
 
145
                        /* If we got an odd number of quotes, then the
 
146
                        last quote we got is the terminating quote.
 
147
                        At the end of the string, we return to the
 
148
                        initial start state and report the scanned
 
149
                        string literal. */
 
150
 
 
151
                        if (yyleng % 2) {
 
152
                                BEGIN(INITIAL);
 
153
                                yylval = sym_tab_add_str_lit(
 
154
                                        pars_sym_tab_global,
 
155
                                        (byte*) stringbuf, stringbuf_len);
 
156
                                return(PARS_STR_LIT);
 
157
                        }
 
158
}
 
159
 
 
160
\"              {
 
161
/* Quoted identifiers are handled in an explicit start state 'id'.
 
162
This state is entered and the buffer for the scanned string is emptied
 
163
upon encountering a starting quote.
 
164
 
 
165
In the state 'id', only two actions are possible (defined below). */
 
166
                        BEGIN(id);
 
167
                        stringbuf_len = 0;
 
168
}
 
169
<id>[^\"]+      {
 
170
                        /* Got a sequence of characters other than '"':
 
171
                        append to string buffer */
 
172
                        string_append(yytext, yyleng);
 
173
}
 
174
<id>\"+ {
 
175
                        /* Got a sequence of '"' characters:
 
176
                        append half of them to string buffer,
 
177
                        as '""' represents a single '"'.
 
178
                        We apply truncating division,
 
179
                        so that '"""' will result in '"'. */
 
180
 
 
181
                        string_append(yytext, yyleng / 2);
 
182
 
 
183
                        /* If we got an odd number of quotes, then the
 
184
                        last quote we got is the terminating quote.
 
185
                        At the end of the string, we return to the
 
186
                        initial start state and report the scanned
 
187
                        identifier. */
 
188
 
 
189
                        if (yyleng % 2) {
 
190
                                BEGIN(INITIAL);
 
191
                                yylval = sym_tab_add_id(
 
192
                                        pars_sym_tab_global,
 
193
                                        (byte*) stringbuf, stringbuf_len);
 
194
 
 
195
                                return(PARS_ID_TOKEN);
 
196
                        }
 
197
}
 
198
 
 
199
"NULL"          {
 
200
                        yylval = sym_tab_add_null_lit(pars_sym_tab_global);
 
201
 
 
202
                        return(PARS_NULL_LIT);
 
203
}
 
204
 
 
205
"SQL"           {
 
206
                        /* Implicit cursor name */
 
207
                        yylval = sym_tab_add_str_lit(pars_sym_tab_global,
 
208
                                                        (byte*) yytext, yyleng);
 
209
                        return(PARS_SQL_TOKEN);
 
210
}
 
211
 
 
212
"AND"           {
 
213
                        return(PARS_AND_TOKEN);
 
214
}
 
215
 
 
216
"OR"            {
 
217
                        return(PARS_OR_TOKEN);
 
218
}
 
219
 
 
220
"NOT"           {
 
221
                        return(PARS_NOT_TOKEN);
 
222
}
 
223
 
 
224
"PROCEDURE"     {
 
225
                        return(PARS_PROCEDURE_TOKEN);
 
226
}
 
227
 
 
228
"IN"            {
 
229
                        return(PARS_IN_TOKEN);
 
230
}
 
231
 
 
232
"OUT"           {
 
233
                        return(PARS_OUT_TOKEN);
 
234
}
 
235
 
 
236
"BINARY"        {
 
237
                        return(PARS_BINARY_TOKEN);
 
238
}
 
239
 
 
240
"BLOB"          {
 
241
                        return(PARS_BLOB_TOKEN);
 
242
}
 
243
 
 
244
"INT"           {
 
245
                        return(PARS_INT_TOKEN);
 
246
}
 
247
 
 
248
"INTEGER"       {
 
249
                        return(PARS_INT_TOKEN);
 
250
}
 
251
 
 
252
"FLOAT"         {
 
253
                        return(PARS_FLOAT_TOKEN);
 
254
}
 
255
 
 
256
"CHAR"          {
 
257
                        return(PARS_CHAR_TOKEN);
 
258
}
 
259
 
 
260
"IS"            {
 
261
                        return(PARS_IS_TOKEN);
 
262
}
 
263
 
 
264
"BEGIN"         {
 
265
                        return(PARS_BEGIN_TOKEN);
 
266
}
 
267
 
 
268
"END"           {
 
269
                        return(PARS_END_TOKEN);
 
270
}
 
271
 
 
272
"IF"            {
 
273
                        return(PARS_IF_TOKEN);
 
274
}
 
275
 
 
276
"THEN"          {
 
277
                        return(PARS_THEN_TOKEN);
 
278
}
 
279
 
 
280
"ELSE"          {
 
281
                        return(PARS_ELSE_TOKEN);
 
282
}
 
283
 
 
284
"ELSIF"         {
 
285
                        return(PARS_ELSIF_TOKEN);
 
286
}
 
287
 
 
288
"LOOP"          {
 
289
                        return(PARS_LOOP_TOKEN);
 
290
}
 
291
 
 
292
"WHILE"         {
 
293
                        return(PARS_WHILE_TOKEN);
 
294
}
 
295
 
 
296
"RETURN"        {
 
297
                        return(PARS_RETURN_TOKEN);
 
298
}
 
299
 
 
300
"SELECT"        {
 
301
                        return(PARS_SELECT_TOKEN);
 
302
}
 
303
 
 
304
"SUM"           {
 
305
                        return(PARS_SUM_TOKEN);
 
306
}
 
307
 
 
308
"COUNT"         {
 
309
                        return(PARS_COUNT_TOKEN);
 
310
}
 
311
 
 
312
"DISTINCT"      {
 
313
                        return(PARS_DISTINCT_TOKEN);
 
314
}
 
315
 
 
316
"FROM"          {
 
317
                        return(PARS_FROM_TOKEN);
 
318
}
 
319
 
 
320
"WHERE"         {
 
321
                        return(PARS_WHERE_TOKEN);
 
322
}
 
323
 
 
324
"FOR"           {
 
325
                        return(PARS_FOR_TOKEN);
 
326
}
 
327
 
 
328
"READ"          {
 
329
                        return(PARS_READ_TOKEN);
 
330
}
 
331
 
 
332
"ORDER"         {
 
333
                        return(PARS_ORDER_TOKEN);
 
334
}
 
335
 
 
336
"BY"            {
 
337
                        return(PARS_BY_TOKEN);
 
338
}
 
339
 
 
340
"ASC"           {
 
341
                        return(PARS_ASC_TOKEN);
 
342
}
 
343
 
 
344
"DESC"          {
 
345
                        return(PARS_DESC_TOKEN);
 
346
}
 
347
 
 
348
"INSERT"        {
 
349
                        return(PARS_INSERT_TOKEN);
 
350
}
 
351
 
 
352
"INTO"          {
 
353
                        return(PARS_INTO_TOKEN);
 
354
}
 
355
 
 
356
"VALUES"        {
 
357
                        return(PARS_VALUES_TOKEN);
 
358
}
 
359
 
 
360
"UPDATE"        {
 
361
                        return(PARS_UPDATE_TOKEN);
 
362
}
 
363
 
 
364
"SET"           {
 
365
                        return(PARS_SET_TOKEN);
 
366
}
 
367
 
 
368
"DELETE"        {
 
369
                        return(PARS_DELETE_TOKEN);
 
370
}
 
371
 
 
372
"CURRENT"       {
 
373
                        return(PARS_CURRENT_TOKEN);
 
374
}
 
375
 
 
376
"OF"            {
 
377
                        return(PARS_OF_TOKEN);
 
378
}
 
379
 
 
380
"CREATE"        {
 
381
                        return(PARS_CREATE_TOKEN);
 
382
}
 
383
 
 
384
"TABLE"         {
 
385
                        return(PARS_TABLE_TOKEN);
 
386
}
 
387
 
 
388
"INDEX"         {
 
389
                        return(PARS_INDEX_TOKEN);
 
390
}
 
391
 
 
392
"UNIQUE"        {
 
393
                        return(PARS_UNIQUE_TOKEN);
 
394
}
 
395
 
 
396
"CLUSTERED"     {
 
397
                        return(PARS_CLUSTERED_TOKEN);
 
398
}
 
399
 
 
400
"DOES_NOT_FIT_IN_MEMORY"        {
 
401
                        return(PARS_DOES_NOT_FIT_IN_MEM_TOKEN);
 
402
}
 
403
 
 
404
"ON"            {
 
405
                        return(PARS_ON_TOKEN);
 
406
}
 
407
 
 
408
"DECLARE"       {
 
409
                        return(PARS_DECLARE_TOKEN);
 
410
}
 
411
 
 
412
"CURSOR"        {
 
413
                        return(PARS_CURSOR_TOKEN);
 
414
}
 
415
 
 
416
"OPEN"  {
 
417
                        return(PARS_OPEN_TOKEN);
 
418
}
 
419
 
 
420
"FETCH" {
 
421
                        return(PARS_FETCH_TOKEN);
 
422
}
 
423
 
 
424
"CLOSE" {
 
425
                        return(PARS_CLOSE_TOKEN);
 
426
}
 
427
 
 
428
"NOTFOUND"      {
 
429
                        return(PARS_NOTFOUND_TOKEN);
 
430
}
 
431
 
 
432
"TO_CHAR"       {
 
433
                        return(PARS_TO_CHAR_TOKEN);
 
434
}
 
435
 
 
436
"TO_NUMBER"     {
 
437
                        return(PARS_TO_NUMBER_TOKEN);
 
438
}
 
439
 
 
440
"TO_BINARY"     {
 
441
                        return(PARS_TO_BINARY_TOKEN);
 
442
}
 
443
 
 
444
"BINARY_TO_NUMBER" {
 
445
                        return(PARS_BINARY_TO_NUMBER_TOKEN);
 
446
}
 
447
 
 
448
"SUBSTR"        {
 
449
                        return(PARS_SUBSTR_TOKEN);
 
450
}
 
451
 
 
452
"REPLSTR"       {
 
453
                        return(PARS_REPLSTR_TOKEN);
 
454
}
 
455
 
 
456
"CONCAT"        {
 
457
                        return(PARS_CONCAT_TOKEN);
 
458
}
 
459
 
 
460
"INSTR"         {
 
461
                        return(PARS_INSTR_TOKEN);
 
462
}
 
463
 
 
464
"LENGTH"        {
 
465
                        return(PARS_LENGTH_TOKEN);
 
466
}
 
467
 
 
468
"SYSDATE"       {
 
469
                        return(PARS_SYSDATE_TOKEN);
 
470
}
 
471
 
 
472
"PRINTF"        {
 
473
                        return(PARS_PRINTF_TOKEN);
 
474
}
 
475
 
 
476
"ASSERT"        {
 
477
                        return(PARS_ASSERT_TOKEN);
 
478
}
 
479
 
 
480
"RND"           {
 
481
                        return(PARS_RND_TOKEN);
 
482
}
 
483
 
 
484
"RND_STR"       {
 
485
                        return(PARS_RND_STR_TOKEN);
 
486
}
 
487
 
 
488
"ROW_PRINTF"    {
 
489
                        return(PARS_ROW_PRINTF_TOKEN);
 
490
}
 
491
 
 
492
"COMMIT"        {
 
493
                        return(PARS_COMMIT_TOKEN);
 
494
}
 
495
 
 
496
"ROLLBACK"      {
 
497
                        return(PARS_ROLLBACK_TOKEN);
 
498
}
 
499
 
 
500
"WORK"          {
 
501
                        return(PARS_WORK_TOKEN);
 
502
}
 
503
 
 
504
"UNSIGNED"      {
 
505
                        return(PARS_UNSIGNED_TOKEN);
 
506
}
 
507
 
 
508
"EXIT"          {
 
509
                        return(PARS_EXIT_TOKEN);
 
510
}
 
511
 
 
512
"FUNCTION"      {
 
513
                        return(PARS_FUNCTION_TOKEN);
 
514
}
 
515
 
 
516
"LOCK"  {
 
517
                        return(PARS_LOCK_TOKEN);
 
518
}
 
519
 
 
520
"SHARE" {
 
521
                        return(PARS_SHARE_TOKEN);
 
522
}
 
523
 
 
524
"MODE"  {
 
525
                        return(PARS_MODE_TOKEN);
 
526
}
 
527
 
 
528
{ID}            {
 
529
                        yylval = sym_tab_add_id(pars_sym_tab_global,
 
530
                                                        (byte*)yytext,
 
531
                                                        ut_strlen(yytext));
 
532
                        return(PARS_ID_TOKEN);
 
533
}
 
534
 
 
535
".."            {
 
536
                        return(PARS_DDOT_TOKEN);
 
537
}
 
538
 
 
539
":="            {
 
540
                        return(PARS_ASSIGN_TOKEN);
 
541
}
 
542
 
 
543
"<="            {
 
544
                        return(PARS_LE_TOKEN);
 
545
}
 
546
 
 
547
">="            {
 
548
                        return(PARS_GE_TOKEN);
 
549
}
 
550
 
 
551
"<>"            {
 
552
                        return(PARS_NE_TOKEN);
 
553
}
 
554
 
 
555
"("             {
 
556
 
 
557
                        return((int)(*yytext));
 
558
}
 
559
 
 
560
"="             {
 
561
 
 
562
                        return((int)(*yytext));
 
563
}
 
564
 
 
565
">"             {
 
566
 
 
567
                        return((int)(*yytext));
 
568
}
 
569
 
 
570
"<"             {
 
571
 
 
572
                        return((int)(*yytext));
 
573
}
 
574
 
 
575
","             {
 
576
 
 
577
                        return((int)(*yytext));
 
578
}
 
579
 
 
580
";"             {
 
581
 
 
582
                        return((int)(*yytext));
 
583
}
 
584
 
 
585
")"             {
 
586
 
 
587
                        return((int)(*yytext));
 
588
}
 
589
 
 
590
"+"             {
 
591
 
 
592
                        return((int)(*yytext));
 
593
}
 
594
 
 
595
"-"             {
 
596
 
 
597
                        return((int)(*yytext));
 
598
}
 
599
 
 
600
"*"             {
 
601
 
 
602
                        return((int)(*yytext));
 
603
}
 
604
 
 
605
"/"             {
 
606
 
 
607
                        return((int)(*yytext));
 
608
}
 
609
 
 
610
"%"             {
 
611
 
 
612
                        return((int)(*yytext));
 
613
}
 
614
 
 
615
"{"             {
 
616
 
 
617
                        return((int)(*yytext));
 
618
}
 
619
 
 
620
"}"             {
 
621
 
 
622
                        return((int)(*yytext));
 
623
}
 
624
 
 
625
"?"             {
 
626
 
 
627
                        return((int)(*yytext));
 
628
}
 
629
 
 
630
"/*"                    BEGIN(comment); /* eat up comment */
 
631
 
 
632
<comment>[^*]*
 
633
<comment>"*"+[^*/]*
 
634
<comment>"*"+"/"        BEGIN(INITIAL);
 
635
 
 
636
[ \t\n]+                /* eat up whitespace */
 
637
 
 
638
 
 
639
.               {
 
640
                        fprintf(stderr,"Unrecognized character: %02x\n",
 
641
                                *yytext);
 
642
 
 
643
                        ut_error;
 
644
 
 
645
                        return(0);
 
646
}
 
647
 
 
648
%%