← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/pars/lexyy.c

  • Committer: Padraig O'Sullivan
  • Date: 2009-03-21 01:02:23 UTC
  • mto: (960.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 961.
  • Revision ID: osullivan.padraig@gmail.com-20090321010223-j8cph7eeyt1u3xol
Fixed function object to ensure it correctly returns a boolean type since
memcmp returns an integer. Added some more comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/pars/lexyy.c
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
 
4
 
 
5
This program is free software; you can redistribute it and/or modify it under
 
6
the terms of the GNU General Public License as published by the Free Software
 
7
Foundation; version 2 of the License.
 
8
 
 
9
This program is distributed in the hope that it will be useful, but WITHOUT
 
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
12
 
 
13
You should have received a copy of the GNU General Public License along with
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
#include "univ.i"
 
20
#line 2 "lexyy.c"
 
21
 
 
22
#line 4 "lexyy.c"
 
23
 
 
24
#define  YY_INT_ALIGNED short int
 
25
 
 
26
/* A lexical scanner generated by flex */
 
27
 
 
28
#define FLEX_SCANNER
 
29
#define YY_FLEX_MAJOR_VERSION 2
 
30
#define YY_FLEX_MINOR_VERSION 5
 
31
#define YY_FLEX_SUBMINOR_VERSION 31
 
32
#if YY_FLEX_SUBMINOR_VERSION > 0
 
33
#define FLEX_BETA
 
34
#endif
 
35
 
 
36
/* First, we deal with  platform-specific or compiler-specific issues. */
 
37
 
 
38
/* begin standard C headers. */
 
39
#include <stdio.h>
 
40
#include <string.h>
 
41
#include <errno.h>
 
42
#include <stdlib.h>
 
43
 
 
44
/* end standard C headers. */
 
45
 
 
46
/* flex integer type definitions */
 
47
 
 
48
#ifndef FLEXINT_H
 
49
#define FLEXINT_H
 
50
 
 
51
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
 
52
 
 
53
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
 
54
#include <inttypes.h>
 
55
typedef int8_t flex_int8_t;
 
56
typedef uint8_t flex_uint8_t;
 
57
typedef int16_t flex_int16_t;
 
58
typedef uint16_t flex_uint16_t;
 
59
typedef int32_t flex_int32_t;
 
60
typedef uint32_t flex_uint32_t;
 
61
#else
 
62
typedef signed char flex_int8_t;
 
63
typedef short int flex_int16_t;
 
64
typedef int flex_int32_t;
 
65
typedef unsigned char flex_uint8_t; 
 
66
typedef unsigned short int flex_uint16_t;
 
67
typedef unsigned int flex_uint32_t;
 
68
#endif /* ! C99 */
 
69
 
 
70
/* Limits of integral types. */
 
71
#ifndef INT8_MIN
 
72
#define INT8_MIN               (-128)
 
73
#endif
 
74
#ifndef INT16_MIN
 
75
#define INT16_MIN              (-32767-1)
 
76
#endif
 
77
#ifndef INT32_MIN
 
78
#define INT32_MIN              (-2147483647-1)
 
79
#endif
 
80
#ifndef INT8_MAX
 
81
#define INT8_MAX               (127)
 
82
#endif
 
83
#ifndef INT16_MAX
 
84
#define INT16_MAX              (32767)
 
85
#endif
 
86
#ifndef INT32_MAX
 
87
#define INT32_MAX              (2147483647)
 
88
#endif
 
89
#ifndef UINT8_MAX
 
90
#define UINT8_MAX              (255U)
 
91
#endif
 
92
#ifndef UINT16_MAX
 
93
#define UINT16_MAX             (65535U)
 
94
#endif
 
95
#ifndef UINT32_MAX
 
96
#define UINT32_MAX             (4294967295U)
 
97
#endif
 
98
 
 
99
#endif /* ! FLEXINT_H */
 
100
 
 
101
#ifdef __cplusplus
 
102
 
 
103
/* The "const" storage-class-modifier is valid. */
 
104
#define YY_USE_CONST
 
105
 
 
106
#else   /* ! __cplusplus */
 
107
 
 
108
#if __STDC__
 
109
 
 
110
#define YY_USE_CONST
 
111
 
 
112
#endif  /* __STDC__ */
 
113
#endif  /* ! __cplusplus */
 
114
 
 
115
#ifdef YY_USE_CONST
 
116
#define yyconst const
 
117
#else
 
118
#define yyconst
 
119
#endif
 
120
 
 
121
/* Returned upon end-of-file. */
 
122
#define YY_NULL 0
 
123
 
 
124
/* Promotes a possibly negative, possibly signed char to an unsigned
 
125
 * integer for use as an array index.  If the signed char is negative,
 
126
 * we want to instead treat it as an 8-bit unsigned char, hence the
 
127
 * double cast.
 
128
 */
 
129
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 
130
 
 
131
/* Enter a start condition.  This macro really ought to take a parameter,
 
132
 * but we do it the disgusting crufty way forced on us by the ()-less
 
133
 * definition of BEGIN.
 
134
 */
 
135
#define BEGIN (yy_start) = 1 + 2 *
 
136
 
 
137
/* Translate the current start state into a value that can be later handed
 
138
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 
139
 * compatibility.
 
140
 */
 
141
#define YY_START (((yy_start) - 1) / 2)
 
142
#define YYSTATE YY_START
 
143
 
 
144
/* Action number for EOF rule of a given start state. */
 
145
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
146
 
 
147
/* Special action meaning "start processing a new file". */
 
148
#define YY_NEW_FILE yyrestart(yyin  )
 
149
 
 
150
#define YY_END_OF_BUFFER_CHAR 0
 
151
 
 
152
/* Size of default input buffer. */
 
153
#ifndef YY_BUF_SIZE
 
154
#define YY_BUF_SIZE 16384
 
155
#endif
 
156
 
 
157
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
 
158
#define YY_TYPEDEF_YY_BUFFER_STATE
 
159
typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
160
#endif
 
161
 
 
162
static FILE *yyin, *yyout;
 
163
 
 
164
#define EOB_ACT_CONTINUE_SCAN 0
 
165
#define EOB_ACT_END_OF_FILE 1
 
166
#define EOB_ACT_LAST_MATCH 2
 
167
 
 
168
    #define YY_LESS_LINENO(n)
 
169
    
 
170
/* Return all but the first "n" matched characters back to the input stream. */
 
171
#define yyless(n) \
 
172
        do \
 
173
                { \
 
174
                /* Undo effects of setting up yytext. */ \
 
175
        int yyless_macro_arg = (n); \
 
176
        YY_LESS_LINENO(yyless_macro_arg);\
 
177
                *yy_cp = (yy_hold_char); \
 
178
                YY_RESTORE_YY_MORE_OFFSET \
 
179
                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 
180
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 
181
                } \
 
182
        while ( 0 )
 
183
 
 
184
#define unput(c) yyunput( c, (yytext_ptr)  )
 
185
 
 
186
/* The following is because we cannot portably get our hands on size_t
 
187
 * (without autoconf's help, which isn't available because we want
 
188
 * flex-generated scanners to compile on their own).
 
189
 */
 
190
 
 
191
#ifndef YY_TYPEDEF_YY_SIZE_T
 
192
#define YY_TYPEDEF_YY_SIZE_T
 
193
typedef unsigned int yy_size_t;
 
194
#endif
 
195
 
 
196
#ifndef YY_STRUCT_YY_BUFFER_STATE
 
197
#define YY_STRUCT_YY_BUFFER_STATE
 
198
struct yy_buffer_state
 
199
        {
 
200
        FILE *yy_input_file;
 
201
 
 
202
        char *yy_ch_buf;                /* input buffer */
 
203
        char *yy_buf_pos;               /* current position in input buffer */
 
204
 
 
205
        /* Size of input buffer in bytes, not including room for EOB
 
206
         * characters.
 
207
         */
 
208
        yy_size_t yy_buf_size;
 
209
 
 
210
        /* Number of characters read into yy_ch_buf, not including EOB
 
211
         * characters.
 
212
         */
 
213
        int yy_n_chars;
 
214
 
 
215
        /* Whether we "own" the buffer - i.e., we know we created it,
 
216
         * and can realloc() it to grow it, and should free() it to
 
217
         * delete it.
 
218
         */
 
219
        int yy_is_our_buffer;
 
220
 
 
221
        /* Whether this is an "interactive" input source; if so, and
 
222
         * if we're using stdio for input, then we want to use getc()
 
223
         * instead of fread(), to make sure we stop fetching input after
 
224
         * each newline.
 
225
         */
 
226
        int yy_is_interactive;
 
227
 
 
228
        /* Whether we're considered to be at the beginning of a line.
 
229
         * If so, '^' rules will be active on the next match, otherwise
 
230
         * not.
 
231
         */
 
232
        int yy_at_bol;
 
233
 
 
234
    int yy_bs_lineno; /**< The line count. */
 
235
    int yy_bs_column; /**< The column count. */
 
236
    
 
237
        /* Whether to try to fill the input buffer when we reach the
 
238
         * end of it.
 
239
         */
 
240
        int yy_fill_buffer;
 
241
 
 
242
        int yy_buffer_status;
 
243
 
 
244
#define YY_BUFFER_NEW 0
 
245
#define YY_BUFFER_NORMAL 1
 
246
        /* When an EOF's been seen but there's still some text to process
 
247
         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 
248
         * shouldn't try reading from the input source any more.  We might
 
249
         * still have a bunch of tokens to match, though, because of
 
250
         * possible backing-up.
 
251
         *
 
252
         * When we actually see the EOF, we change the status to "new"
 
253
         * (via yyrestart()), so that the user can continue scanning by
 
254
         * just pointing yyin at a new input file.
 
255
         */
 
256
#define YY_BUFFER_EOF_PENDING 2
 
257
 
 
258
        };
 
259
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
260
 
 
261
/* Stack of input buffers. */
 
262
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 
263
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 
264
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
265
 
 
266
/* We provide macros for accessing buffer states in case in the
 
267
 * future we want to put the buffer states in a more general
 
268
 * "scanner state".
 
269
 *
 
270
 * Returns the top of the stack, or NULL.
 
271
 */
 
272
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 
273
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 
274
                          : NULL)
 
275
 
 
276
/* Same as previous macro, but useful when we know that the buffer stack is not
 
277
 * NULL or when we need an lvalue. For internal use only.
 
278
 */
 
279
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 
280
 
 
281
/* yy_hold_char holds the character lost when yytext is formed. */
 
282
static char yy_hold_char;
 
283
static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 
284
static int yyleng;
 
285
 
 
286
/* Points to current character in buffer. */
 
287
static char *yy_c_buf_p = (char *) 0;
 
288
static int yy_init = 1;         /* whether we need to initialize */
 
289
static int yy_start = 0;        /* start state number */
 
290
 
 
291
/* Flag which is used to allow yywrap()'s to do buffer switches
 
292
 * instead of setting up a fresh yyin.  A bit of a hack ...
 
293
 */
 
294
static int yy_did_buffer_switch_on_eof;
 
295
 
 
296
static void yyrestart (FILE *input_file  );
 
297
__attribute__((unused)) static void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 
298
static YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 
299
static void yy_delete_buffer (YY_BUFFER_STATE b  );
 
300
static void yy_flush_buffer (YY_BUFFER_STATE b  );
 
301
__attribute__((unused)) static void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 
302
__attribute__((unused)) static void yypop_buffer_state (void );
 
303
 
 
304
static void yyensure_buffer_stack (void );
 
305
static void yy_load_buffer_state (void );
 
306
static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 
307
 
 
308
#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 
309
 
 
310
YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 
311
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 
312
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 
313
 
 
314
static void *yyalloc (yy_size_t  );
 
315
static void *yyrealloc (void *,yy_size_t  );
 
316
static void yyfree (void *  );
 
317
 
 
318
#define yy_new_buffer yy_create_buffer
 
319
 
 
320
#define yy_set_interactive(is_interactive) \
 
321
        { \
 
322
        if ( ! YY_CURRENT_BUFFER ){ \
 
323
        yyensure_buffer_stack (); \
 
324
                YY_CURRENT_BUFFER_LVALUE =    \
 
325
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
 
326
        } \
 
327
        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 
328
        }
 
329
 
 
330
#define yy_set_bol(at_bol) \
 
331
        { \
 
332
        if ( ! YY_CURRENT_BUFFER ){\
 
333
        yyensure_buffer_stack (); \
 
334
                YY_CURRENT_BUFFER_LVALUE =    \
 
335
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
 
336
        } \
 
337
        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 
338
        }
 
339
 
 
340
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
341
 
 
342
/* Begin user sect3 */
 
343
 
 
344
#define yywrap(n) 1
 
345
#define YY_SKIP_YYWRAP
 
346
 
 
347
typedef unsigned char YY_CHAR;
 
348
 
 
349
static FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 
350
 
 
351
typedef int yy_state_type;
 
352
 
 
353
static int yylineno;
 
354
 
 
355
static int yylineno = 1;
 
356
 
 
357
static char *yytext;
 
358
#define yytext_ptr yytext
 
359
 
 
360
static yy_state_type yy_get_previous_state (void );
 
361
static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 
362
static int yy_get_next_buffer (void );
 
363
static void yy_fatal_error (yyconst char msg[]  );
 
364
 
 
365
/* Done after the current pattern has been matched and before the
 
366
 * corresponding action - sets up yytext.
 
367
 */
 
368
#define YY_DO_BEFORE_ACTION \
 
369
        (yytext_ptr) = yy_bp; \
 
370
        yyleng = (size_t) (yy_cp - yy_bp); \
 
371
        (yy_hold_char) = *yy_cp; \
 
372
        *yy_cp = '\0'; \
 
373
        (yy_c_buf_p) = yy_cp;
 
374
 
 
375
#define YY_NUM_RULES 119
 
376
#define YY_END_OF_BUFFER 120
 
377
/* This struct is not used in this scanner,
 
378
   but its presence is necessary. */
 
379
struct yy_trans_info
 
380
        {
 
381
        flex_int32_t yy_verify;
 
382
        flex_int32_t yy_nxt;
 
383
        };
 
384
static yyconst flex_int16_t yy_accept[399] =
 
385
    {   0,
 
386
        0,    0,  114,  114,    0,    0,    0,    0,  120,  118,
 
387
      117,  117,    8,  118,  109,    5,   98,  104,  107,  105,
 
388
      102,  106,  118,  108,    1,  118,  103,  101,   99,  100,
 
389
      112,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 
390
       92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 
391
      110,  111,  114,  115,    6,    7,    9,   10,  117,    4,
 
392
       93,  113,    2,    1,    3,   94,   95,   97,   96,   92,
 
393
       92,   92,   92,   92,   92,   44,   92,   92,   92,   92,
 
394
       92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 
395
       92,   92,   28,   17,   25,   92,   92,   92,   92,   92,
 
396
 
 
397
       54,   61,   92,   14,   92,   92,   92,   92,   92,   92,
 
398
       92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 
399
       92,   92,  114,  115,  115,  116,    6,    7,    9,   10,
 
400
        2,   13,   45,   92,   92,   92,   92,   92,   92,   92,
 
401
       92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 
402
       92,   27,   92,   92,   92,   41,   92,   92,   92,   92,
 
403
       21,   92,   92,   92,   92,   15,   92,   92,   92,   18,
 
404
       92,   92,   92,   92,   92,   80,   92,   92,   92,   51,
 
405
       92,   12,   92,   36,   92,   92,   92,   92,   92,   92,
 
406
       92,   92,   92,   92,   92,   92,   92,   92,   20,   24,
 
407
 
 
408
       92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 
409
       46,   92,   92,   30,   92,   87,   92,   92,   39,   92,
 
410
       92,   92,   92,   92,   48,   92,   89,   32,   91,   92,
 
411
       11,   64,   92,   92,   92,   42,   92,   92,   92,   92,
 
412
       92,   92,   92,   92,   92,   92,   29,   92,   92,   92,
 
413
       92,   92,   92,   92,   92,   92,   85,   92,   26,   92,
 
414
       66,   92,   92,   92,   37,   92,   92,   92,   92,   92,
 
415
       92,   92,   31,   65,   23,   92,   57,   92,   75,   92,
 
416
       92,   92,   43,   92,   92,   92,   92,   92,   92,   92,
 
417
       92,   90,   92,   92,   56,   92,   92,   92,   92,   92,
 
418
 
 
419
       92,   92,   40,   33,   79,   19,   92,   83,   74,   55,
 
420
       92,   63,   92,   52,   92,   92,   92,   47,   92,   76,
 
421
       92,   78,   92,   92,   34,   92,   92,   92,   35,   72,
 
422
       92,   92,   92,   92,   58,   92,   50,   49,   92,   92,
 
423
       53,   62,   92,   92,   92,   22,   92,   92,   73,   81,
 
424
       92,   92,   77,   92,   68,   92,   92,   92,   92,   38,
 
425
       92,   88,   67,   92,   84,   92,   92,   92,   86,   92,
 
426
       59,   92,   16,   92,   70,   69,   92,   92,   82,   92,
 
427
       92,   92,   92,   92,   92,   92,   92,   92,   92,   71,
 
428
       92,   92,   92,   92,   92,   92,   60,    0
 
429
 
 
430
    } ;
 
431
 
 
432
static yyconst flex_int32_t yy_ec[256] =
 
433
    {   0,
 
434
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 
435
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
436
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
437
        1,    2,    1,    4,    1,    5,    6,    1,    7,    8,
 
438
        9,   10,   11,   12,   13,   14,   15,   16,   16,   16,
 
439
       16,   16,   16,   16,   16,   16,   16,   17,   18,   19,
 
440
       20,   21,   22,    1,   23,   24,   25,   26,   27,   28,
 
441
       29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
 
442
       39,   40,   41,   42,   43,   44,   45,   46,   47,   32,
 
443
        1,    1,    1,    1,   48,    1,   32,   32,   32,   32,
 
444
 
 
445
       32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 
446
       32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 
447
       32,   32,   49,    1,   50,    1,    1,    1,    1,    1,
 
448
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
449
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
450
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
451
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
452
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
453
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
454
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
455
 
 
456
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
457
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
458
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
459
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
460
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
461
        1,    1,    1,    1,    1
 
462
    } ;
 
463
 
 
464
static yyconst flex_int32_t yy_meta[51] =
 
465
    {   0,
 
466
        1,    1,    1,    2,    1,    1,    3,    1,    1,    4,
 
467
        1,    1,    1,    1,    1,    5,    1,    1,    1,    6,
 
468
        1,    1,    5,    5,    5,    5,    5,    5,    5,    5,
 
469
        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 
470
        5,    5,    5,    5,    5,    5,    5,    5,    1,    1
 
471
    } ;
 
472
 
 
473
static yyconst flex_int16_t yy_base[409] =
 
474
    {   0,
 
475
        0,    0,  437,  436,  438,  437,  439,  438,  441,  448,
 
476
       49,   51,  448,    0,  448,  448,  448,  448,  448,  448,
 
477
      448,  448,  426,  429,   41,  418,  448,   38,  448,  417,
 
478
      448,   20,   33,   32,   46,   40,   44,    0,   54,   52,
 
479
      399,   48,   60,  395,   65,   67,   81,   27,  411,   75,
 
480
      448,  448,    0,   98,    0,  426,    0,  428,  113,    0,
 
481
      448,  448,  415,   54,  410,  448,  448,  448,  448,    0,
 
482
      403,   68,  399,  391,  389,    0,  402,   80,   84,  397,
 
483
      383,   96,  381,  394,  379,  393,  387,  375,  379,  375,
 
484
      377,  377,    0,   98,    0,  376,   97,  385,  368,  375,
 
485
 
 
486
        0,    0,  381,  381,  364,   94,  103,  379,   98,   65,
 
487
      381,  369,  109,  361,  377,  373,  351,   97,  372,  363,
 
488
      115,  356,    0,  137,  138,  448,    0,  388,    0,  390,
 
489
      377,    0,    0,  365,  360,  367,  365,  348,  346,  345,
 
490
      350,  359,  347,  359,   95,  347,  353,  354,  336,  336,
 
491
      123,    0,  334,  350,  351,    0,  338,  347,  344,  122,
 
492
      124,  341,  336,  330,  340,  338,  331,  328,  336,    0,
 
493
      326,  336,  334,  325,  315,  309,  322,  307,  327,    0,
 
494
      313,    0,  311,    0,  325,  316,  313,  131,  309,  316,
 
495
      323,  302,  304,  309,  309,  301,  304,  299,    0,    0,
 
496
 
 
497
      311,  295,  305,  312,  292,  291,  305,  294,  307,  287,
 
498
        0,  297,  279,    0,  298,    0,  295,  282,    0,  281,
 
499
      276,  281,  280,  290,    0,  276,    0,    0,    0,  280,
 
500
        0,    0,  276,  273,  287,    0,  272,  272,  270,  286,
 
501
      271,  283,  280,  264,  282,  277,    0,  272,  272,  258,
 
502
      257,  270,  256,  270,  269,  268,    0,  252,    0,  246,
 
503
        0,  265,  249,  248,    0,  262,  252,  247,  246,  258,
 
504
      248,  247,    0,    0,    0,  251,    0,  239,    0,  253,
 
505
      249,  235,    0,  249,  250,  233,  238,  231,  249,  231,
 
506
      228,    0,  229,  226,    0,  231,  243,  230,  237,  227,
 
507
 
 
508
      235,  220,    0,    0,    0,  212,  219,    0,    0,    0,
 
509
      216,    0,  230,    0,  231,  218,  217,    0,  213,    0,
 
510
      216,    0,  208,  210,    0,  209,  223,  216,    0,    0,
 
511
      219,  222,  204,  219,    0,  215,    0,    0,  199,  213,
 
512
        0,    0,  197,  196,  201,    0,  210,  195,    0,    0,
 
513
      201,  197,    0,  192,    0,  204,  204,  192,  202,    0,
 
514
      179,    0,    0,  199,    0,  183,  177,  183,    0,  174,
 
515
        0,  193,    0,  192,    0,    0,  183,  187,    0,  174,
 
516
      174,  180,  166,  189,  181,  180,  166,  151,  118,    0,
 
517
      130,  136,  127,  123,  119,  111,    0,  448,  167,  173,
 
518
 
 
519
      179,  152,  181,  124,  187,  193,  199,  205
 
520
    } ;
 
521
 
 
522
static yyconst flex_int16_t yy_def[409] =
 
523
    {   0,
 
524
      398,    1,  399,  399,  400,  400,  401,  401,  398,  398,
 
525
      398,  398,  398,  402,  398,  398,  398,  398,  398,  398,
 
526
      398,  398,  398,  398,  398,  403,  398,  398,  398,  398,
 
527
      398,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
528
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
529
      398,  398,  405,  406,  407,  398,  408,  398,  398,  402,
 
530
      398,  398,  398,  398,  403,  398,  398,  398,  398,  404,
 
531
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
532
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
533
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
534
 
 
535
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
536
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
537
      404,  404,  405,  406,  406,  398,  407,  398,  408,  398,
 
538
      398,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
539
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
540
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
541
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
542
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
543
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
544
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
545
 
 
546
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
547
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
548
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
549
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
550
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
551
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
552
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
553
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
554
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
555
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
556
 
 
557
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
558
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
559
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
560
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
561
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
562
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
563
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
564
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
565
      404,  404,  404,  404,  404,  404,  404,  404,  404,  404,
 
566
      404,  404,  404,  404,  404,  404,  404,    0,  398,  398,
 
567
 
 
568
      398,  398,  398,  398,  398,  398,  398,  398
 
569
    } ;
 
570
 
 
571
static yyconst flex_int16_t yy_nxt[499] =
 
572
    {   0,
 
573
       10,   11,   12,   13,   14,   15,   16,   17,   18,   19,
 
574
       20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
 
575
       30,   31,   32,   33,   34,   35,   36,   37,   38,   38,
 
576
       39,   38,   38,   40,   41,   42,   43,   44,   38,   45,
 
577
       46,   47,   48,   49,   50,   38,   38,   38,   51,   52,
 
578
       59,   59,   59,   59,   63,   71,   64,   67,   68,   73,
 
579
       72,   77,  118,   74,  119,   78,   75,   63,   79,   64,
 
580
       88,   80,   82,   85,   81,   86,   83,   89,   96,   76,
 
581
       90,   93,   84,   91,   99,   87,   92,  101,   97,   94,
 
582
      100,  107,  133,  110,   95,  102,  111,  103,  179,  104,
 
583
 
 
584
      108,  109,  105,  115,  121,  112,  180,  125,  134,  113,
 
585
      116,  122,  126,  114,   59,   59,  139,  117,  141,  142,
 
586
      146,  163,  140,  159,  171,  173,  143,  189,   70,  147,
 
587
      172,  177,  183,  164,  207,  208,  148,  190,  160,  161,
 
588
      174,  193,  178,  184,  175,  194,  398,  125,  222,  214,
 
589
      224,  398,  126,  215,  248,  249,   60,  397,  396,  395,
 
590
      225,  394,  393,  223,  392,  391,  250,   53,   53,   53,
 
591
       53,   53,   53,   55,   55,   55,   55,   55,   55,   57,
 
592
       57,   57,   57,   57,   57,   65,   65,  123,  123,  123,
 
593
      390,  123,  123,  124,  124,  124,  124,  124,  124,  127,
 
594
 
 
595
      127,  389,  127,  127,  127,  129,  388,  129,  129,  129,
 
596
      129,  387,  386,  385,  384,  383,  382,  381,  380,  379,
 
597
      378,  377,  376,  375,  374,  373,  372,  371,  370,  369,
 
598
      368,  367,  366,  365,  364,  363,  362,  361,  360,  359,
 
599
      358,  357,  356,  355,  354,  353,  352,  351,  350,  349,
 
600
      348,  347,  346,  345,  344,  343,  342,  341,  340,  339,
 
601
      338,  337,  336,  335,  334,  333,  332,  331,  330,  329,
 
602
      328,  327,  326,  325,  324,  323,  322,  321,  320,  319,
 
603
      318,  317,  316,  315,  314,  313,  312,  311,  310,  309,
 
604
      308,  307,  306,  305,  304,  303,  302,  301,  300,  299,
 
605
 
 
606
      298,  297,  296,  295,  294,  293,  292,  291,  290,  289,
 
607
      288,  287,  286,  285,  284,  283,  282,  281,  280,  279,
 
608
      278,  277,  276,  275,  274,  273,  272,  271,  270,  269,
 
609
      268,  267,  266,  265,  264,  263,  262,  261,  260,  259,
 
610
      258,  257,  256,  255,  254,  253,  252,  251,  247,  246,
 
611
      245,  244,  243,  242,  241,  240,  239,  238,  237,  236,
 
612
      235,  234,  233,  232,  231,  230,  229,  228,  227,  226,
 
613
      221,  220,  219,  218,  217,  216,  213,  212,  211,  210,
 
614
      209,  206,  205,  204,  203,  202,  201,  200,  199,  198,
 
615
      197,  196,  131,  130,  128,  195,  192,  191,  188,  187,
 
616
 
 
617
      186,  185,  182,  181,  176,  170,  169,  168,  167,  166,
 
618
      165,  162,  158,  157,  156,  155,  154,  153,  152,  151,
 
619
      150,  149,  145,  144,  138,  137,  136,  135,  132,  398,
 
620
      131,  130,  128,  120,  106,   98,   69,   66,   62,   61,
 
621
      398,   58,   58,   56,   56,   54,   54,    9,  398,  398,
 
622
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
623
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
624
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
625
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
626
      398,  398,  398,  398,  398,  398,  398,  398
 
627
 
 
628
    } ;
 
629
 
 
630
static yyconst flex_int16_t yy_chk[499] =
 
631
    {   0,
 
632
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
633
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
634
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
635
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
636
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
637
       11,   11,   12,   12,   25,   32,   25,   28,   28,   33,
 
638
       32,   34,   48,   33,   48,   34,   33,   64,   34,   64,
 
639
       37,   34,   35,   36,   34,   36,   35,   37,   40,   33,
 
640
       37,   39,   35,   37,   42,   36,   37,   43,   40,   39,
 
641
       42,   45,   72,   46,   39,   43,   46,   43,  110,   43,
 
642
 
 
643
       45,   45,   43,   47,   50,   46,  110,   54,   72,   46,
 
644
       47,   50,   54,   46,   59,   59,   78,   47,   79,   79,
 
645
       82,   97,   78,   94,  106,  107,   79,  118,  404,   82,
 
646
      106,  109,  113,   97,  145,  145,   82,  118,   94,   94,
 
647
      107,  121,  109,  113,  107,  121,  124,  125,  160,  151,
 
648
      161,  124,  125,  151,  188,  188,  402,  396,  395,  394,
 
649
      161,  393,  392,  160,  391,  389,  188,  399,  399,  399,
 
650
      399,  399,  399,  400,  400,  400,  400,  400,  400,  401,
 
651
      401,  401,  401,  401,  401,  403,  403,  405,  405,  405,
 
652
      388,  405,  405,  406,  406,  406,  406,  406,  406,  407,
 
653
 
 
654
      407,  387,  407,  407,  407,  408,  386,  408,  408,  408,
 
655
      408,  385,  384,  383,  382,  381,  380,  378,  377,  374,
 
656
      372,  370,  368,  367,  366,  364,  361,  359,  358,  357,
 
657
      356,  354,  352,  351,  348,  347,  345,  344,  343,  340,
 
658
      339,  336,  334,  333,  332,  331,  328,  327,  326,  324,
 
659
      323,  321,  319,  317,  316,  315,  313,  311,  307,  306,
 
660
      302,  301,  300,  299,  298,  297,  296,  294,  293,  291,
 
661
      290,  289,  288,  287,  286,  285,  284,  282,  281,  280,
 
662
      278,  276,  272,  271,  270,  269,  268,  267,  266,  264,
 
663
      263,  262,  260,  258,  256,  255,  254,  253,  252,  251,
 
664
 
 
665
      250,  249,  248,  246,  245,  244,  243,  242,  241,  240,
 
666
      239,  238,  237,  235,  234,  233,  230,  226,  224,  223,
 
667
      222,  221,  220,  218,  217,  215,  213,  212,  210,  209,
 
668
      208,  207,  206,  205,  204,  203,  202,  201,  198,  197,
 
669
      196,  195,  194,  193,  192,  191,  190,  189,  187,  186,
 
670
      185,  183,  181,  179,  178,  177,  176,  175,  174,  173,
 
671
      172,  171,  169,  168,  167,  166,  165,  164,  163,  162,
 
672
      159,  158,  157,  155,  154,  153,  150,  149,  148,  147,
 
673
      146,  144,  143,  142,  141,  140,  139,  138,  137,  136,
 
674
      135,  134,  131,  130,  128,  122,  120,  119,  117,  116,
 
675
 
 
676
      115,  114,  112,  111,  108,  105,  104,  103,  100,   99,
 
677
       98,   96,   92,   91,   90,   89,   88,   87,   86,   85,
 
678
       84,   83,   81,   80,   77,   75,   74,   73,   71,   65,
 
679
       63,   58,   56,   49,   44,   41,   30,   26,   24,   23,
 
680
        9,    8,    7,    6,    5,    4,    3,  398,  398,  398,
 
681
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
682
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
683
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
684
      398,  398,  398,  398,  398,  398,  398,  398,  398,  398,
 
685
      398,  398,  398,  398,  398,  398,  398,  398
 
686
 
 
687
    } ;
 
688
 
 
689
static yy_state_type yy_last_accepting_state;
 
690
static char *yy_last_accepting_cpos;
 
691
 
 
692
static int yy_flex_debug;
 
693
static int yy_flex_debug = 0;
 
694
 
 
695
/* The intent behind this definition is that it'll catch
 
696
 * any uses of REJECT which flex missed.
 
697
 */
 
698
#define REJECT reject_used_but_not_detected
 
699
#define yymore() yymore_used_but_not_detected
 
700
#define YY_MORE_ADJ 0
 
701
#define YY_RESTORE_YY_MORE_OFFSET
 
702
#line 1 "pars0lex.l"
 
703
/******************************************************
 
704
SQL parser lexical analyzer: input file for the GNU Flex lexer generator
 
705
 
 
706
(c) 1997 Innobase Oy
 
707
 
 
708
Created 12/14/1997 Heikki Tuuri
 
709
Published under the GPL version 2
 
710
 
 
711
The InnoDB parser is frozen because MySQL takes care of SQL parsing.
 
712
Therefore we normally keep the InnoDB parser C files as they are, and do
 
713
not automatically generate them from pars0grm.y and pars0lex.l.
 
714
 
 
715
How to make the InnoDB parser and lexer C files:
 
716
 
 
717
1. Run ./make_flex.sh to generate lexer files.
 
718
 
 
719
2. Run ./make_bison.sh to generate parser files.
 
720
 
 
721
These instructions seem to work at least with bison-1.875d and flex-2.5.31 on
 
722
Linux.
 
723
*******************************************************/
 
724
#define YY_NO_INPUT 1
 
725
#define YY_NO_UNISTD_H 1
 
726
#line 38 "pars0lex.l"
 
727
#define YYSTYPE que_node_t*
 
728
 
 
729
#include "univ.i"
 
730
#include "pars0pars.h"
 
731
#include "pars0grm.h"
 
732
#include "pars0sym.h"
 
733
#include "mem0mem.h"
 
734
#include "os0proc.h"
 
735
 
 
736
#define malloc(A)       ut_malloc(A)
 
737
#define free(A)         ut_free(A)
 
738
#define realloc(P, A)   ut_realloc(P, A)
 
739
#define exit(A)         ut_error
 
740
 
 
741
#define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size)
 
742
 
 
743
/* String buffer for removing quotes */
 
744
static ulint    stringbuf_len_alloc = 0; /* Allocated length */
 
745
static ulint    stringbuf_len = 0; /* Current length */
 
746
static char*    stringbuf; /* Start of buffer */
 
747
/* Appends a string to the buffer. */
 
748
static
 
749
void
 
750
string_append(
 
751
/*==========*/
 
752
        const char*     str,    /* in: string to be appended */
 
753
        ulint           len)    /* in: length of the string */
 
754
{
 
755
        if (stringbuf == NULL) {
 
756
                stringbuf = malloc(1);
 
757
                stringbuf_len_alloc = 1;
 
758
        }
 
759
 
 
760
        if (stringbuf_len + len > stringbuf_len_alloc) {
 
761
                while (stringbuf_len + len > stringbuf_len_alloc) {
 
762
                        stringbuf_len_alloc <<= 1;
 
763
                }
 
764
                stringbuf = realloc(stringbuf, stringbuf_len_alloc);
 
765
        }
 
766
 
 
767
        memcpy(stringbuf + stringbuf_len, str, len);
 
768
        stringbuf_len += len;
 
769
}
 
770
 
 
771
 
 
772
 
 
773
 
 
774
#line 759 "lexyy.c"
 
775
 
 
776
#define INITIAL 0
 
777
#define comment 1
 
778
#define quoted 2
 
779
#define id 3
 
780
 
 
781
#ifndef YY_NO_UNISTD_H
 
782
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 
783
 * down here because we want the user's section 1 to have been scanned first.
 
784
 * The user has a chance to override it with an option.
 
785
 */
 
786
#include <unistd.h>
 
787
#endif
 
788
 
 
789
#ifndef YY_EXTRA_TYPE
 
790
#define YY_EXTRA_TYPE void *
 
791
#endif
 
792
 
 
793
/* Macros after this point can all be overridden by user definitions in
 
794
 * section 1.
 
795
 */
 
796
 
 
797
#ifndef YY_SKIP_YYWRAP
 
798
#ifdef __cplusplus
 
799
extern "C" int yywrap (void );
 
800
#else
 
801
extern int yywrap (void );
 
802
#endif
 
803
#endif
 
804
 
 
805
#ifndef yytext_ptr
 
806
static void yy_flex_strncpy (char *,yyconst char *,int );
 
807
#endif
 
808
 
 
809
#ifdef YY_NEED_STRLEN
 
810
static int yy_flex_strlen (yyconst char * );
 
811
#endif
 
812
 
 
813
#ifndef YY_NO_INPUT
 
814
 
 
815
#ifdef __cplusplus
 
816
static int yyinput (void );
 
817
#else
 
818
static int input (void );
 
819
#endif
 
820
 
 
821
#endif
 
822
 
 
823
/* Amount of stuff to slurp up with each read. */
 
824
#ifndef YY_READ_BUF_SIZE
 
825
#define YY_READ_BUF_SIZE 8192
 
826
#endif
 
827
 
 
828
/* Copy whatever the last rule matched to the standard output. */
 
829
#ifndef ECHO
 
830
/* This used to be an fputs(), but since the string might contain NUL's,
 
831
 * we now use fwrite().
 
832
 */
 
833
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 
834
#endif
 
835
 
 
836
/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 
837
 * is returned in "result".
 
838
 */
 
839
#ifndef YY_INPUT
 
840
#define YY_INPUT(buf,result,max_size) \
 
841
        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 
842
                { \
 
843
                int c = '*'; \
 
844
                size_t n; \
 
845
                for ( n = 0; n < max_size && \
 
846
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 
847
                        buf[n] = (char) c; \
 
848
                if ( c == '\n' ) \
 
849
                        buf[n++] = (char) c; \
 
850
                if ( c == EOF && ferror( yyin ) ) \
 
851
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
 
852
                result = n; \
 
853
                } \
 
854
        else \
 
855
                { \
 
856
                errno=0; \
 
857
                while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 
858
                        { \
 
859
                        if( errno != EINTR) \
 
860
                                { \
 
861
                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
 
862
                                break; \
 
863
                                } \
 
864
                        errno=0; \
 
865
                        clearerr(yyin); \
 
866
                        } \
 
867
                }\
 
868
\
 
869
 
 
870
#endif
 
871
 
 
872
/* No semi-colon after return; correct usage is to write "yyterminate();" -
 
873
 * we don't want an extra ';' after the "return" because that will cause
 
874
 * some compilers to complain about unreachable statements.
 
875
 */
 
876
#ifndef yyterminate
 
877
#define yyterminate() return YY_NULL
 
878
#endif
 
879
 
 
880
/* Number of entries by which start-condition stack grows. */
 
881
#ifndef YY_START_STACK_INCR
 
882
#define YY_START_STACK_INCR 25
 
883
#endif
 
884
 
 
885
/* Report a fatal error. */
 
886
#ifndef YY_FATAL_ERROR
 
887
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 
888
#endif
 
889
 
 
890
/* end tables serialization structures and prototypes */
 
891
 
 
892
/* Default declaration of generated scanner - a define so the user can
 
893
 * easily add parameters.
 
894
 */
 
895
#ifndef YY_DECL
 
896
#define YY_DECL_IS_OURS 1
 
897
 
 
898
UNIV_INTERN int yylex (void);
 
899
 
 
900
#define YY_DECL UNIV_INTERN int yylex (void)
 
901
#endif /* !YY_DECL */
 
902
 
 
903
/* Code executed at the beginning of each rule, after yytext and yyleng
 
904
 * have been set up.
 
905
 */
 
906
#ifndef YY_USER_ACTION
 
907
#define YY_USER_ACTION
 
908
#endif
 
909
 
 
910
/* Code executed at the end of each rule. */
 
911
#ifndef YY_BREAK
 
912
#define YY_BREAK break;
 
913
#endif
 
914
 
 
915
#define YY_RULE_SETUP \
 
916
        YY_USER_ACTION
 
917
 
 
918
/** The main scanner function which does all the work.
 
919
 */
 
920
YY_DECL
 
921
{
 
922
        register yy_state_type yy_current_state;
 
923
        register char *yy_cp, *yy_bp;
 
924
        register int yy_act;
 
925
    
 
926
#line 92 "pars0lex.l"
 
927
 
 
928
 
 
929
#line 914 "lexyy.c"
 
930
 
 
931
        if ( (yy_init) )
 
932
                {
 
933
                (yy_init) = 0;
 
934
 
 
935
#ifdef YY_USER_INIT
 
936
                YY_USER_INIT;
 
937
#endif
 
938
 
 
939
                if ( ! (yy_start) )
 
940
                        (yy_start) = 1; /* first start state */
 
941
 
 
942
                if ( ! yyin )
 
943
                        yyin = stdin;
 
944
 
 
945
                if ( ! yyout )
 
946
                        yyout = stdout;
 
947
 
 
948
                if ( ! YY_CURRENT_BUFFER ) {
 
949
                        yyensure_buffer_stack ();
 
950
                        YY_CURRENT_BUFFER_LVALUE =
 
951
                                yy_create_buffer(yyin,YY_BUF_SIZE );
 
952
                }
 
953
 
 
954
                yy_load_buffer_state( );
 
955
                }
 
956
 
 
957
        while ( 1 )             /* loops until end-of-file is reached */
 
958
                {
 
959
                yy_cp = (yy_c_buf_p);
 
960
 
 
961
                /* Support of yytext. */
 
962
                *yy_cp = (yy_hold_char);
 
963
 
 
964
                /* yy_bp points to the position in yy_ch_buf of the start of
 
965
                 * the current run.
 
966
                 */
 
967
                yy_bp = yy_cp;
 
968
 
 
969
                yy_current_state = (yy_start);
 
970
yy_match:
 
971
                do
 
972
                        {
 
973
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 
974
                        if ( yy_accept[yy_current_state] )
 
975
                                {
 
976
                                (yy_last_accepting_state) = yy_current_state;
 
977
                                (yy_last_accepting_cpos) = yy_cp;
 
978
                                }
 
979
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 
980
                                {
 
981
                                yy_current_state = (int) yy_def[yy_current_state];
 
982
                                if ( yy_current_state >= 399 )
 
983
                                        yy_c = yy_meta[(unsigned int) yy_c];
 
984
                                }
 
985
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 
986
                        ++yy_cp;
 
987
                        }
 
988
                while ( yy_current_state != 398 );
 
989
                yy_cp = (yy_last_accepting_cpos);
 
990
                yy_current_state = (yy_last_accepting_state);
 
991
 
 
992
yy_find_action:
 
993
                yy_act = yy_accept[yy_current_state];
 
994
 
 
995
                YY_DO_BEFORE_ACTION;
 
996
 
 
997
do_action:      /* This label is used only to access EOF actions. */
 
998
 
 
999
                switch ( yy_act )
 
1000
        { /* beginning of action switch */
 
1001
                        case 0: /* must back up */
 
1002
                        /* undo the effects of YY_DO_BEFORE_ACTION */
 
1003
                        *yy_cp = (yy_hold_char);
 
1004
                        yy_cp = (yy_last_accepting_cpos);
 
1005
                        yy_current_state = (yy_last_accepting_state);
 
1006
                        goto yy_find_action;
 
1007
 
 
1008
case 1:
 
1009
YY_RULE_SETUP
 
1010
#line 94 "pars0lex.l"
 
1011
{
 
1012
                        yylval = sym_tab_add_int_lit(pars_sym_tab_global,
 
1013
                                                                atoi(yytext));
 
1014
                        return(PARS_INT_LIT);
 
1015
}
 
1016
        YY_BREAK
 
1017
case 2:
 
1018
YY_RULE_SETUP
 
1019
#line 100 "pars0lex.l"
 
1020
{
 
1021
                        ut_error;       /* not implemented */
 
1022
 
 
1023
                        return(PARS_FLOAT_LIT);
 
1024
}
 
1025
        YY_BREAK
 
1026
case 3:
 
1027
YY_RULE_SETUP
 
1028
#line 106 "pars0lex.l"
 
1029
{
 
1030
                        ulint   type;
 
1031
 
 
1032
                        yylval = sym_tab_add_bound_lit(pars_sym_tab_global,
 
1033
                                yytext + 1, &type);
 
1034
 
 
1035
                        return((int) type);
 
1036
}
 
1037
        YY_BREAK
 
1038
case 4:
 
1039
YY_RULE_SETUP
 
1040
#line 115 "pars0lex.l"
 
1041
{
 
1042
                        yylval = sym_tab_add_bound_id(pars_sym_tab_global,
 
1043
                                yytext + 1);
 
1044
 
 
1045
                        return(PARS_ID_TOKEN);
 
1046
}
 
1047
        YY_BREAK
 
1048
case 5:
 
1049
YY_RULE_SETUP
 
1050
#line 122 "pars0lex.l"
 
1051
{
 
1052
/* Quoted character string literals are handled in an explicit
 
1053
start state 'quoted'.  This state is entered and the buffer for
 
1054
the scanned string is emptied upon encountering a starting quote.
 
1055
 
 
1056
In the state 'quoted', only two actions are possible (defined below). */
 
1057
                        BEGIN(quoted);
 
1058
                        stringbuf_len = 0;
 
1059
}
 
1060
        YY_BREAK
 
1061
case 6:
 
1062
/* rule 6 can match eol */
 
1063
YY_RULE_SETUP
 
1064
#line 131 "pars0lex.l"
 
1065
{
 
1066
                        /* Got a sequence of characters other than "'":
 
1067
                        append to string buffer */
 
1068
                        string_append(yytext, yyleng);
 
1069
}
 
1070
        YY_BREAK
 
1071
case 7:
 
1072
YY_RULE_SETUP
 
1073
#line 136 "pars0lex.l"
 
1074
{
 
1075
                        /* Got a sequence of "'" characters:
 
1076
                        append half of them to string buffer,
 
1077
                        as "''" represents a single "'".
 
1078
                        We apply truncating division,
 
1079
                        so that "'''" will result in "'". */
 
1080
 
 
1081
                        string_append(yytext, yyleng / 2);
 
1082
 
 
1083
                        /* If we got an odd number of quotes, then the
 
1084
                        last quote we got is the terminating quote.
 
1085
                        At the end of the string, we return to the
 
1086
                        initial start state and report the scanned
 
1087
                        string literal. */
 
1088
 
 
1089
                        if (yyleng % 2) {
 
1090
                                BEGIN(INITIAL);
 
1091
                                yylval = sym_tab_add_str_lit(
 
1092
                                        pars_sym_tab_global,
 
1093
                                        (byte*) stringbuf, stringbuf_len);
 
1094
                                return(PARS_STR_LIT);
 
1095
                        }
 
1096
}
 
1097
        YY_BREAK
 
1098
case 8:
 
1099
YY_RULE_SETUP
 
1100
#line 160 "pars0lex.l"
 
1101
{
 
1102
/* Quoted identifiers are handled in an explicit start state 'id'.
 
1103
This state is entered and the buffer for the scanned string is emptied
 
1104
upon encountering a starting quote.
 
1105
 
 
1106
In the state 'id', only two actions are possible (defined below). */
 
1107
                        BEGIN(id);
 
1108
                        stringbuf_len = 0;
 
1109
}
 
1110
        YY_BREAK
 
1111
case 9:
 
1112
/* rule 9 can match eol */
 
1113
YY_RULE_SETUP
 
1114
#line 169 "pars0lex.l"
 
1115
{
 
1116
                        /* Got a sequence of characters other than '"':
 
1117
                        append to string buffer */
 
1118
                        string_append(yytext, yyleng);
 
1119
}
 
1120
        YY_BREAK
 
1121
case 10:
 
1122
YY_RULE_SETUP
 
1123
#line 174 "pars0lex.l"
 
1124
{
 
1125
                        /* Got a sequence of '"' characters:
 
1126
                        append half of them to string buffer,
 
1127
                        as '""' represents a single '"'.
 
1128
                        We apply truncating division,
 
1129
                        so that '"""' will result in '"'. */
 
1130
 
 
1131
                        string_append(yytext, yyleng / 2);
 
1132
 
 
1133
                        /* If we got an odd number of quotes, then the
 
1134
                        last quote we got is the terminating quote.
 
1135
                        At the end of the string, we return to the
 
1136
                        initial start state and report the scanned
 
1137
                        identifier. */
 
1138
 
 
1139
                        if (yyleng % 2) {
 
1140
                                BEGIN(INITIAL);
 
1141
                                yylval = sym_tab_add_id(
 
1142
                                        pars_sym_tab_global,
 
1143
                                        (byte*) stringbuf, stringbuf_len);
 
1144
 
 
1145
                                return(PARS_ID_TOKEN);
 
1146
                        }
 
1147
}
 
1148
        YY_BREAK
 
1149
case 11:
 
1150
YY_RULE_SETUP
 
1151
#line 199 "pars0lex.l"
 
1152
{
 
1153
                        yylval = sym_tab_add_null_lit(pars_sym_tab_global);
 
1154
 
 
1155
                        return(PARS_NULL_LIT);
 
1156
}
 
1157
        YY_BREAK
 
1158
case 12:
 
1159
YY_RULE_SETUP
 
1160
#line 205 "pars0lex.l"
 
1161
{
 
1162
                        /* Implicit cursor name */
 
1163
                        yylval = sym_tab_add_str_lit(pars_sym_tab_global,
 
1164
                                                        (byte*) yytext, yyleng);
 
1165
                        return(PARS_SQL_TOKEN);
 
1166
}
 
1167
        YY_BREAK
 
1168
case 13:
 
1169
YY_RULE_SETUP
 
1170
#line 212 "pars0lex.l"
 
1171
{
 
1172
                        return(PARS_AND_TOKEN);
 
1173
}
 
1174
        YY_BREAK
 
1175
case 14:
 
1176
YY_RULE_SETUP
 
1177
#line 216 "pars0lex.l"
 
1178
{
 
1179
                        return(PARS_OR_TOKEN);
 
1180
}
 
1181
        YY_BREAK
 
1182
case 15:
 
1183
YY_RULE_SETUP
 
1184
#line 220 "pars0lex.l"
 
1185
{
 
1186
                        return(PARS_NOT_TOKEN);
 
1187
}
 
1188
        YY_BREAK
 
1189
case 16:
 
1190
YY_RULE_SETUP
 
1191
#line 224 "pars0lex.l"
 
1192
{
 
1193
                        return(PARS_PROCEDURE_TOKEN);
 
1194
}
 
1195
        YY_BREAK
 
1196
case 17:
 
1197
YY_RULE_SETUP
 
1198
#line 228 "pars0lex.l"
 
1199
{
 
1200
                        return(PARS_IN_TOKEN);
 
1201
}
 
1202
        YY_BREAK
 
1203
case 18:
 
1204
YY_RULE_SETUP
 
1205
#line 232 "pars0lex.l"
 
1206
{
 
1207
                        return(PARS_OUT_TOKEN);
 
1208
}
 
1209
        YY_BREAK
 
1210
case 19:
 
1211
YY_RULE_SETUP
 
1212
#line 236 "pars0lex.l"
 
1213
{
 
1214
                        return(PARS_BINARY_TOKEN);
 
1215
}
 
1216
        YY_BREAK
 
1217
case 20:
 
1218
YY_RULE_SETUP
 
1219
#line 240 "pars0lex.l"
 
1220
{
 
1221
                        return(PARS_BLOB_TOKEN);
 
1222
}
 
1223
        YY_BREAK
 
1224
case 21:
 
1225
YY_RULE_SETUP
 
1226
#line 244 "pars0lex.l"
 
1227
{
 
1228
                        return(PARS_INT_TOKEN);
 
1229
}
 
1230
        YY_BREAK
 
1231
case 22:
 
1232
YY_RULE_SETUP
 
1233
#line 248 "pars0lex.l"
 
1234
{
 
1235
                        return(PARS_INT_TOKEN);
 
1236
}
 
1237
        YY_BREAK
 
1238
case 23:
 
1239
YY_RULE_SETUP
 
1240
#line 252 "pars0lex.l"
 
1241
{
 
1242
                        return(PARS_FLOAT_TOKEN);
 
1243
}
 
1244
        YY_BREAK
 
1245
case 24:
 
1246
YY_RULE_SETUP
 
1247
#line 256 "pars0lex.l"
 
1248
{
 
1249
                        return(PARS_CHAR_TOKEN);
 
1250
}
 
1251
        YY_BREAK
 
1252
case 25:
 
1253
YY_RULE_SETUP
 
1254
#line 260 "pars0lex.l"
 
1255
{
 
1256
                        return(PARS_IS_TOKEN);
 
1257
}
 
1258
        YY_BREAK
 
1259
case 26:
 
1260
YY_RULE_SETUP
 
1261
#line 264 "pars0lex.l"
 
1262
{
 
1263
                        return(PARS_BEGIN_TOKEN);
 
1264
}
 
1265
        YY_BREAK
 
1266
case 27:
 
1267
YY_RULE_SETUP
 
1268
#line 268 "pars0lex.l"
 
1269
{
 
1270
                        return(PARS_END_TOKEN);
 
1271
}
 
1272
        YY_BREAK
 
1273
case 28:
 
1274
YY_RULE_SETUP
 
1275
#line 272 "pars0lex.l"
 
1276
{
 
1277
                        return(PARS_IF_TOKEN);
 
1278
}
 
1279
        YY_BREAK
 
1280
case 29:
 
1281
YY_RULE_SETUP
 
1282
#line 276 "pars0lex.l"
 
1283
{
 
1284
                        return(PARS_THEN_TOKEN);
 
1285
}
 
1286
        YY_BREAK
 
1287
case 30:
 
1288
YY_RULE_SETUP
 
1289
#line 280 "pars0lex.l"
 
1290
{
 
1291
                        return(PARS_ELSE_TOKEN);
 
1292
}
 
1293
        YY_BREAK
 
1294
case 31:
 
1295
YY_RULE_SETUP
 
1296
#line 284 "pars0lex.l"
 
1297
{
 
1298
                        return(PARS_ELSIF_TOKEN);
 
1299
}
 
1300
        YY_BREAK
 
1301
case 32:
 
1302
YY_RULE_SETUP
 
1303
#line 288 "pars0lex.l"
 
1304
{
 
1305
                        return(PARS_LOOP_TOKEN);
 
1306
}
 
1307
        YY_BREAK
 
1308
case 33:
 
1309
YY_RULE_SETUP
 
1310
#line 292 "pars0lex.l"
 
1311
{
 
1312
                        return(PARS_WHILE_TOKEN);
 
1313
}
 
1314
        YY_BREAK
 
1315
case 34:
 
1316
YY_RULE_SETUP
 
1317
#line 296 "pars0lex.l"
 
1318
{
 
1319
                        return(PARS_RETURN_TOKEN);
 
1320
}
 
1321
        YY_BREAK
 
1322
case 35:
 
1323
YY_RULE_SETUP
 
1324
#line 300 "pars0lex.l"
 
1325
{
 
1326
                        return(PARS_SELECT_TOKEN);
 
1327
}
 
1328
        YY_BREAK
 
1329
case 36:
 
1330
YY_RULE_SETUP
 
1331
#line 304 "pars0lex.l"
 
1332
{
 
1333
                        return(PARS_SUM_TOKEN);
 
1334
}
 
1335
        YY_BREAK
 
1336
case 37:
 
1337
YY_RULE_SETUP
 
1338
#line 308 "pars0lex.l"
 
1339
{
 
1340
                        return(PARS_COUNT_TOKEN);
 
1341
}
 
1342
        YY_BREAK
 
1343
case 38:
 
1344
YY_RULE_SETUP
 
1345
#line 312 "pars0lex.l"
 
1346
{
 
1347
                        return(PARS_DISTINCT_TOKEN);
 
1348
}
 
1349
        YY_BREAK
 
1350
case 39:
 
1351
YY_RULE_SETUP
 
1352
#line 316 "pars0lex.l"
 
1353
{
 
1354
                        return(PARS_FROM_TOKEN);
 
1355
}
 
1356
        YY_BREAK
 
1357
case 40:
 
1358
YY_RULE_SETUP
 
1359
#line 320 "pars0lex.l"
 
1360
{
 
1361
                        return(PARS_WHERE_TOKEN);
 
1362
}
 
1363
        YY_BREAK
 
1364
case 41:
 
1365
YY_RULE_SETUP
 
1366
#line 324 "pars0lex.l"
 
1367
{
 
1368
                        return(PARS_FOR_TOKEN);
 
1369
}
 
1370
        YY_BREAK
 
1371
case 42:
 
1372
YY_RULE_SETUP
 
1373
#line 328 "pars0lex.l"
 
1374
{
 
1375
                        return(PARS_READ_TOKEN);
 
1376
}
 
1377
        YY_BREAK
 
1378
case 43:
 
1379
YY_RULE_SETUP
 
1380
#line 332 "pars0lex.l"
 
1381
{
 
1382
                        return(PARS_ORDER_TOKEN);
 
1383
}
 
1384
        YY_BREAK
 
1385
case 44:
 
1386
YY_RULE_SETUP
 
1387
#line 336 "pars0lex.l"
 
1388
{
 
1389
                        return(PARS_BY_TOKEN);
 
1390
}
 
1391
        YY_BREAK
 
1392
case 45:
 
1393
YY_RULE_SETUP
 
1394
#line 340 "pars0lex.l"
 
1395
{
 
1396
                        return(PARS_ASC_TOKEN);
 
1397
}
 
1398
        YY_BREAK
 
1399
case 46:
 
1400
YY_RULE_SETUP
 
1401
#line 344 "pars0lex.l"
 
1402
{
 
1403
                        return(PARS_DESC_TOKEN);
 
1404
}
 
1405
        YY_BREAK
 
1406
case 47:
 
1407
YY_RULE_SETUP
 
1408
#line 348 "pars0lex.l"
 
1409
{
 
1410
                        return(PARS_INSERT_TOKEN);
 
1411
}
 
1412
        YY_BREAK
 
1413
case 48:
 
1414
YY_RULE_SETUP
 
1415
#line 352 "pars0lex.l"
 
1416
{
 
1417
                        return(PARS_INTO_TOKEN);
 
1418
}
 
1419
        YY_BREAK
 
1420
case 49:
 
1421
YY_RULE_SETUP
 
1422
#line 356 "pars0lex.l"
 
1423
{
 
1424
                        return(PARS_VALUES_TOKEN);
 
1425
}
 
1426
        YY_BREAK
 
1427
case 50:
 
1428
YY_RULE_SETUP
 
1429
#line 360 "pars0lex.l"
 
1430
{
 
1431
                        return(PARS_UPDATE_TOKEN);
 
1432
}
 
1433
        YY_BREAK
 
1434
case 51:
 
1435
YY_RULE_SETUP
 
1436
#line 364 "pars0lex.l"
 
1437
{
 
1438
                        return(PARS_SET_TOKEN);
 
1439
}
 
1440
        YY_BREAK
 
1441
case 52:
 
1442
YY_RULE_SETUP
 
1443
#line 368 "pars0lex.l"
 
1444
{
 
1445
                        return(PARS_DELETE_TOKEN);
 
1446
}
 
1447
        YY_BREAK
 
1448
case 53:
 
1449
YY_RULE_SETUP
 
1450
#line 372 "pars0lex.l"
 
1451
{
 
1452
                        return(PARS_CURRENT_TOKEN);
 
1453
}
 
1454
        YY_BREAK
 
1455
case 54:
 
1456
YY_RULE_SETUP
 
1457
#line 376 "pars0lex.l"
 
1458
{
 
1459
                        return(PARS_OF_TOKEN);
 
1460
}
 
1461
        YY_BREAK
 
1462
case 55:
 
1463
YY_RULE_SETUP
 
1464
#line 380 "pars0lex.l"
 
1465
{
 
1466
                        return(PARS_CREATE_TOKEN);
 
1467
}
 
1468
        YY_BREAK
 
1469
case 56:
 
1470
YY_RULE_SETUP
 
1471
#line 384 "pars0lex.l"
 
1472
{
 
1473
                        return(PARS_TABLE_TOKEN);
 
1474
}
 
1475
        YY_BREAK
 
1476
case 57:
 
1477
YY_RULE_SETUP
 
1478
#line 388 "pars0lex.l"
 
1479
{
 
1480
                        return(PARS_INDEX_TOKEN);
 
1481
}
 
1482
        YY_BREAK
 
1483
case 58:
 
1484
YY_RULE_SETUP
 
1485
#line 392 "pars0lex.l"
 
1486
{
 
1487
                        return(PARS_UNIQUE_TOKEN);
 
1488
}
 
1489
        YY_BREAK
 
1490
case 59:
 
1491
YY_RULE_SETUP
 
1492
#line 396 "pars0lex.l"
 
1493
{
 
1494
                        return(PARS_CLUSTERED_TOKEN);
 
1495
}
 
1496
        YY_BREAK
 
1497
case 60:
 
1498
YY_RULE_SETUP
 
1499
#line 400 "pars0lex.l"
 
1500
{
 
1501
                        return(PARS_DOES_NOT_FIT_IN_MEM_TOKEN);
 
1502
}
 
1503
        YY_BREAK
 
1504
case 61:
 
1505
YY_RULE_SETUP
 
1506
#line 404 "pars0lex.l"
 
1507
{
 
1508
                        return(PARS_ON_TOKEN);
 
1509
}
 
1510
        YY_BREAK
 
1511
case 62:
 
1512
YY_RULE_SETUP
 
1513
#line 408 "pars0lex.l"
 
1514
{
 
1515
                        return(PARS_DECLARE_TOKEN);
 
1516
}
 
1517
        YY_BREAK
 
1518
case 63:
 
1519
YY_RULE_SETUP
 
1520
#line 412 "pars0lex.l"
 
1521
{
 
1522
                        return(PARS_CURSOR_TOKEN);
 
1523
}
 
1524
        YY_BREAK
 
1525
case 64:
 
1526
YY_RULE_SETUP
 
1527
#line 416 "pars0lex.l"
 
1528
{
 
1529
                        return(PARS_OPEN_TOKEN);
 
1530
}
 
1531
        YY_BREAK
 
1532
case 65:
 
1533
YY_RULE_SETUP
 
1534
#line 420 "pars0lex.l"
 
1535
{
 
1536
                        return(PARS_FETCH_TOKEN);
 
1537
}
 
1538
        YY_BREAK
 
1539
case 66:
 
1540
YY_RULE_SETUP
 
1541
#line 424 "pars0lex.l"
 
1542
{
 
1543
                        return(PARS_CLOSE_TOKEN);
 
1544
}
 
1545
        YY_BREAK
 
1546
case 67:
 
1547
YY_RULE_SETUP
 
1548
#line 428 "pars0lex.l"
 
1549
{
 
1550
                        return(PARS_NOTFOUND_TOKEN);
 
1551
}
 
1552
        YY_BREAK
 
1553
case 68:
 
1554
YY_RULE_SETUP
 
1555
#line 432 "pars0lex.l"
 
1556
{
 
1557
                        return(PARS_TO_CHAR_TOKEN);
 
1558
}
 
1559
        YY_BREAK
 
1560
case 69:
 
1561
YY_RULE_SETUP
 
1562
#line 436 "pars0lex.l"
 
1563
{
 
1564
                        return(PARS_TO_NUMBER_TOKEN);
 
1565
}
 
1566
        YY_BREAK
 
1567
case 70:
 
1568
YY_RULE_SETUP
 
1569
#line 440 "pars0lex.l"
 
1570
{
 
1571
                        return(PARS_TO_BINARY_TOKEN);
 
1572
}
 
1573
        YY_BREAK
 
1574
case 71:
 
1575
YY_RULE_SETUP
 
1576
#line 444 "pars0lex.l"
 
1577
{
 
1578
                        return(PARS_BINARY_TO_NUMBER_TOKEN);
 
1579
}
 
1580
        YY_BREAK
 
1581
case 72:
 
1582
YY_RULE_SETUP
 
1583
#line 448 "pars0lex.l"
 
1584
{
 
1585
                        return(PARS_SUBSTR_TOKEN);
 
1586
}
 
1587
        YY_BREAK
 
1588
case 73:
 
1589
YY_RULE_SETUP
 
1590
#line 452 "pars0lex.l"
 
1591
{
 
1592
                        return(PARS_REPLSTR_TOKEN);
 
1593
}
 
1594
        YY_BREAK
 
1595
case 74:
 
1596
YY_RULE_SETUP
 
1597
#line 456 "pars0lex.l"
 
1598
{
 
1599
                        return(PARS_CONCAT_TOKEN);
 
1600
}
 
1601
        YY_BREAK
 
1602
case 75:
 
1603
YY_RULE_SETUP
 
1604
#line 460 "pars0lex.l"
 
1605
{
 
1606
                        return(PARS_INSTR_TOKEN);
 
1607
}
 
1608
        YY_BREAK
 
1609
case 76:
 
1610
YY_RULE_SETUP
 
1611
#line 464 "pars0lex.l"
 
1612
{
 
1613
                        return(PARS_LENGTH_TOKEN);
 
1614
}
 
1615
        YY_BREAK
 
1616
case 77:
 
1617
YY_RULE_SETUP
 
1618
#line 468 "pars0lex.l"
 
1619
{
 
1620
                        return(PARS_SYSDATE_TOKEN);
 
1621
}
 
1622
        YY_BREAK
 
1623
case 78:
 
1624
YY_RULE_SETUP
 
1625
#line 472 "pars0lex.l"
 
1626
{
 
1627
                        return(PARS_PRINTF_TOKEN);
 
1628
}
 
1629
        YY_BREAK
 
1630
case 79:
 
1631
YY_RULE_SETUP
 
1632
#line 476 "pars0lex.l"
 
1633
{
 
1634
                        return(PARS_ASSERT_TOKEN);
 
1635
}
 
1636
        YY_BREAK
 
1637
case 80:
 
1638
YY_RULE_SETUP
 
1639
#line 480 "pars0lex.l"
 
1640
{
 
1641
                        return(PARS_RND_TOKEN);
 
1642
}
 
1643
        YY_BREAK
 
1644
case 81:
 
1645
YY_RULE_SETUP
 
1646
#line 484 "pars0lex.l"
 
1647
{
 
1648
                        return(PARS_RND_STR_TOKEN);
 
1649
}
 
1650
        YY_BREAK
 
1651
case 82:
 
1652
YY_RULE_SETUP
 
1653
#line 488 "pars0lex.l"
 
1654
{
 
1655
                        return(PARS_ROW_PRINTF_TOKEN);
 
1656
}
 
1657
        YY_BREAK
 
1658
case 83:
 
1659
YY_RULE_SETUP
 
1660
#line 492 "pars0lex.l"
 
1661
{
 
1662
                        return(PARS_COMMIT_TOKEN);
 
1663
}
 
1664
        YY_BREAK
 
1665
case 84:
 
1666
YY_RULE_SETUP
 
1667
#line 496 "pars0lex.l"
 
1668
{
 
1669
                        return(PARS_ROLLBACK_TOKEN);
 
1670
}
 
1671
        YY_BREAK
 
1672
case 85:
 
1673
YY_RULE_SETUP
 
1674
#line 500 "pars0lex.l"
 
1675
{
 
1676
                        return(PARS_WORK_TOKEN);
 
1677
}
 
1678
        YY_BREAK
 
1679
case 86:
 
1680
YY_RULE_SETUP
 
1681
#line 504 "pars0lex.l"
 
1682
{
 
1683
                        return(PARS_UNSIGNED_TOKEN);
 
1684
}
 
1685
        YY_BREAK
 
1686
case 87:
 
1687
YY_RULE_SETUP
 
1688
#line 508 "pars0lex.l"
 
1689
{
 
1690
                        return(PARS_EXIT_TOKEN);
 
1691
}
 
1692
        YY_BREAK
 
1693
case 88:
 
1694
YY_RULE_SETUP
 
1695
#line 512 "pars0lex.l"
 
1696
{
 
1697
                        return(PARS_FUNCTION_TOKEN);
 
1698
}
 
1699
        YY_BREAK
 
1700
case 89:
 
1701
YY_RULE_SETUP
 
1702
#line 516 "pars0lex.l"
 
1703
{
 
1704
                        return(PARS_LOCK_TOKEN);
 
1705
}
 
1706
        YY_BREAK
 
1707
case 90:
 
1708
YY_RULE_SETUP
 
1709
#line 520 "pars0lex.l"
 
1710
{
 
1711
                        return(PARS_SHARE_TOKEN);
 
1712
}
 
1713
        YY_BREAK
 
1714
case 91:
 
1715
YY_RULE_SETUP
 
1716
#line 524 "pars0lex.l"
 
1717
{
 
1718
                        return(PARS_MODE_TOKEN);
 
1719
}
 
1720
        YY_BREAK
 
1721
case 92:
 
1722
YY_RULE_SETUP
 
1723
#line 528 "pars0lex.l"
 
1724
{
 
1725
                        yylval = sym_tab_add_id(pars_sym_tab_global,
 
1726
                                                        (byte*)yytext,
 
1727
                                                        ut_strlen(yytext));
 
1728
                        return(PARS_ID_TOKEN);
 
1729
}
 
1730
        YY_BREAK
 
1731
case 93:
 
1732
YY_RULE_SETUP
 
1733
#line 535 "pars0lex.l"
 
1734
{
 
1735
                        return(PARS_DDOT_TOKEN);
 
1736
}
 
1737
        YY_BREAK
 
1738
case 94:
 
1739
YY_RULE_SETUP
 
1740
#line 539 "pars0lex.l"
 
1741
{
 
1742
                        return(PARS_ASSIGN_TOKEN);
 
1743
}
 
1744
        YY_BREAK
 
1745
case 95:
 
1746
YY_RULE_SETUP
 
1747
#line 543 "pars0lex.l"
 
1748
{
 
1749
                        return(PARS_LE_TOKEN);
 
1750
}
 
1751
        YY_BREAK
 
1752
case 96:
 
1753
YY_RULE_SETUP
 
1754
#line 547 "pars0lex.l"
 
1755
{
 
1756
                        return(PARS_GE_TOKEN);
 
1757
}
 
1758
        YY_BREAK
 
1759
case 97:
 
1760
YY_RULE_SETUP
 
1761
#line 551 "pars0lex.l"
 
1762
{
 
1763
                        return(PARS_NE_TOKEN);
 
1764
}
 
1765
        YY_BREAK
 
1766
case 98:
 
1767
YY_RULE_SETUP
 
1768
#line 555 "pars0lex.l"
 
1769
{
 
1770
 
 
1771
                        return((int)(*yytext));
 
1772
}
 
1773
        YY_BREAK
 
1774
case 99:
 
1775
YY_RULE_SETUP
 
1776
#line 560 "pars0lex.l"
 
1777
{
 
1778
 
 
1779
                        return((int)(*yytext));
 
1780
}
 
1781
        YY_BREAK
 
1782
case 100:
 
1783
YY_RULE_SETUP
 
1784
#line 565 "pars0lex.l"
 
1785
{
 
1786
 
 
1787
                        return((int)(*yytext));
 
1788
}
 
1789
        YY_BREAK
 
1790
case 101:
 
1791
YY_RULE_SETUP
 
1792
#line 570 "pars0lex.l"
 
1793
{
 
1794
 
 
1795
                        return((int)(*yytext));
 
1796
}
 
1797
        YY_BREAK
 
1798
case 102:
 
1799
YY_RULE_SETUP
 
1800
#line 575 "pars0lex.l"
 
1801
{
 
1802
 
 
1803
                        return((int)(*yytext));
 
1804
}
 
1805
        YY_BREAK
 
1806
case 103:
 
1807
YY_RULE_SETUP
 
1808
#line 580 "pars0lex.l"
 
1809
{
 
1810
 
 
1811
                        return((int)(*yytext));
 
1812
}
 
1813
        YY_BREAK
 
1814
case 104:
 
1815
YY_RULE_SETUP
 
1816
#line 585 "pars0lex.l"
 
1817
{
 
1818
 
 
1819
                        return((int)(*yytext));
 
1820
}
 
1821
        YY_BREAK
 
1822
case 105:
 
1823
YY_RULE_SETUP
 
1824
#line 590 "pars0lex.l"
 
1825
{
 
1826
 
 
1827
                        return((int)(*yytext));
 
1828
}
 
1829
        YY_BREAK
 
1830
case 106:
 
1831
YY_RULE_SETUP
 
1832
#line 595 "pars0lex.l"
 
1833
{
 
1834
 
 
1835
                        return((int)(*yytext));
 
1836
}
 
1837
        YY_BREAK
 
1838
case 107:
 
1839
YY_RULE_SETUP
 
1840
#line 600 "pars0lex.l"
 
1841
{
 
1842
 
 
1843
                        return((int)(*yytext));
 
1844
}
 
1845
        YY_BREAK
 
1846
case 108:
 
1847
YY_RULE_SETUP
 
1848
#line 605 "pars0lex.l"
 
1849
{
 
1850
 
 
1851
                        return((int)(*yytext));
 
1852
}
 
1853
        YY_BREAK
 
1854
case 109:
 
1855
YY_RULE_SETUP
 
1856
#line 610 "pars0lex.l"
 
1857
{
 
1858
 
 
1859
                        return((int)(*yytext));
 
1860
}
 
1861
        YY_BREAK
 
1862
case 110:
 
1863
YY_RULE_SETUP
 
1864
#line 615 "pars0lex.l"
 
1865
{
 
1866
 
 
1867
                        return((int)(*yytext));
 
1868
}
 
1869
        YY_BREAK
 
1870
case 111:
 
1871
YY_RULE_SETUP
 
1872
#line 620 "pars0lex.l"
 
1873
{
 
1874
 
 
1875
                        return((int)(*yytext));
 
1876
}
 
1877
        YY_BREAK
 
1878
case 112:
 
1879
YY_RULE_SETUP
 
1880
#line 625 "pars0lex.l"
 
1881
{
 
1882
 
 
1883
                        return((int)(*yytext));
 
1884
}
 
1885
        YY_BREAK
 
1886
case 113:
 
1887
YY_RULE_SETUP
 
1888
#line 630 "pars0lex.l"
 
1889
BEGIN(comment); /* eat up comment */
 
1890
        YY_BREAK
 
1891
case 114:
 
1892
/* rule 114 can match eol */
 
1893
YY_RULE_SETUP
 
1894
#line 632 "pars0lex.l"
 
1895
 
 
1896
        YY_BREAK
 
1897
case 115:
 
1898
/* rule 115 can match eol */
 
1899
YY_RULE_SETUP
 
1900
#line 633 "pars0lex.l"
 
1901
 
 
1902
        YY_BREAK
 
1903
case 116:
 
1904
YY_RULE_SETUP
 
1905
#line 634 "pars0lex.l"
 
1906
BEGIN(INITIAL);
 
1907
        YY_BREAK
 
1908
case 117:
 
1909
/* rule 117 can match eol */
 
1910
YY_RULE_SETUP
 
1911
#line 636 "pars0lex.l"
 
1912
/* eat up whitespace */
 
1913
        YY_BREAK
 
1914
case 118:
 
1915
YY_RULE_SETUP
 
1916
#line 639 "pars0lex.l"
 
1917
{
 
1918
                        fprintf(stderr,"Unrecognized character: %02x\n",
 
1919
                                *yytext);
 
1920
 
 
1921
                        ut_error;
 
1922
 
 
1923
                        return(0);
 
1924
}
 
1925
        YY_BREAK
 
1926
case 119:
 
1927
YY_RULE_SETUP
 
1928
#line 648 "pars0lex.l"
 
1929
YY_FATAL_ERROR( "flex scanner jammed" );
 
1930
        YY_BREAK
 
1931
#line 1916 "lexyy.c"
 
1932
case YY_STATE_EOF(INITIAL):
 
1933
case YY_STATE_EOF(comment):
 
1934
case YY_STATE_EOF(quoted):
 
1935
case YY_STATE_EOF(id):
 
1936
        yyterminate();
 
1937
 
 
1938
        case YY_END_OF_BUFFER:
 
1939
                {
 
1940
                /* Amount of text matched not including the EOB char. */
 
1941
                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
1942
 
 
1943
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
 
1944
                *yy_cp = (yy_hold_char);
 
1945
                YY_RESTORE_YY_MORE_OFFSET
 
1946
 
 
1947
                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 
1948
                        {
 
1949
                        /* We're scanning a new file or input source.  It's
 
1950
                         * possible that this happened because the user
 
1951
                         * just pointed yyin at a new source and called
 
1952
                         * yylex().  If so, then we have to assure
 
1953
                         * consistency between YY_CURRENT_BUFFER and our
 
1954
                         * globals.  Here is the right place to do so, because
 
1955
                         * this is the first action (other than possibly a
 
1956
                         * back-up) that will match for the new input source.
 
1957
                         */
 
1958
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 
1959
                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 
1960
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 
1961
                        }
 
1962
 
 
1963
                /* Note that here we test for yy_c_buf_p "<=" to the position
 
1964
                 * of the first EOB in the buffer, since yy_c_buf_p will
 
1965
                 * already have been incremented past the NUL character
 
1966
                 * (since all states make transitions on EOB to the
 
1967
                 * end-of-buffer state).  Contrast this with the test
 
1968
                 * in input().
 
1969
                 */
 
1970
                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
 
1971
                        { /* This was really a NUL. */
 
1972
                        yy_state_type yy_next_state;
 
1973
 
 
1974
                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
1975
 
 
1976
                        yy_current_state = yy_get_previous_state(  );
 
1977
 
 
1978
                        /* Okay, we're now positioned to make the NUL
 
1979
                         * transition.  We couldn't have
 
1980
                         * yy_get_previous_state() go ahead and do it
 
1981
                         * for us because it doesn't know how to deal
 
1982
                         * with the possibility of jamming (and we don't
 
1983
                         * want to build jamming into it because then it
 
1984
                         * will run more slowly).
 
1985
                         */
 
1986
 
 
1987
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
 
1988
 
 
1989
                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
1990
 
 
1991
                        if ( yy_next_state )
 
1992
                                {
 
1993
                                /* Consume the NUL. */
 
1994
                                yy_cp = ++(yy_c_buf_p);
 
1995
                                yy_current_state = yy_next_state;
 
1996
                                goto yy_match;
 
1997
                                }
 
1998
 
 
1999
                        else
 
2000
                                {
 
2001
                                yy_cp = (yy_last_accepting_cpos);
 
2002
                                yy_current_state = (yy_last_accepting_state);
 
2003
                                goto yy_find_action;
 
2004
                                }
 
2005
                        }
 
2006
 
 
2007
                else switch ( yy_get_next_buffer(  ) )
 
2008
                        {
 
2009
                        case EOB_ACT_END_OF_FILE:
 
2010
                                {
 
2011
                                (yy_did_buffer_switch_on_eof) = 0;
 
2012
 
 
2013
                                if ( yywrap( ) )
 
2014
                                        {
 
2015
                                        /* Note: because we've taken care in
 
2016
                                         * yy_get_next_buffer() to have set up
 
2017
                                         * yytext, we can now set up
 
2018
                                         * yy_c_buf_p so that if some total
 
2019
                                         * hoser (like flex itself) wants to
 
2020
                                         * call the scanner after we return the
 
2021
                                         * YY_NULL, it'll still work - another
 
2022
                                         * YY_NULL will get returned.
 
2023
                                         */
 
2024
                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
2025
 
 
2026
                                        yy_act = YY_STATE_EOF(YY_START);
 
2027
                                        goto do_action;
 
2028
                                        }
 
2029
 
 
2030
                                else
 
2031
                                        {
 
2032
                                        if ( ! (yy_did_buffer_switch_on_eof) )
 
2033
                                                YY_NEW_FILE;
 
2034
                                        }
 
2035
                                break;
 
2036
                                }
 
2037
 
 
2038
                        case EOB_ACT_CONTINUE_SCAN:
 
2039
                                (yy_c_buf_p) =
 
2040
                                        (yytext_ptr) + yy_amount_of_matched_text;
 
2041
 
 
2042
                                yy_current_state = yy_get_previous_state(  );
 
2043
 
 
2044
                                yy_cp = (yy_c_buf_p);
 
2045
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
2046
                                goto yy_match;
 
2047
 
 
2048
                        case EOB_ACT_LAST_MATCH:
 
2049
                                (yy_c_buf_p) =
 
2050
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
2051
 
 
2052
                                yy_current_state = yy_get_previous_state(  );
 
2053
 
 
2054
                                yy_cp = (yy_c_buf_p);
 
2055
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
2056
                                goto yy_find_action;
 
2057
                        }
 
2058
                break;
 
2059
                }
 
2060
 
 
2061
        default:
 
2062
                YY_FATAL_ERROR(
 
2063
                        "fatal flex scanner internal error--no action found" );
 
2064
        } /* end of action switch */
 
2065
                } /* end of scanning one token */
 
2066
} /* end of yylex */
 
2067
 
 
2068
/* yy_get_next_buffer - try to read in a new buffer
 
2069
 *
 
2070
 * Returns a code representing an action:
 
2071
 *      EOB_ACT_LAST_MATCH -
 
2072
 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 
2073
 *      EOB_ACT_END_OF_FILE - end of file
 
2074
 */
 
2075
static int yy_get_next_buffer (void)
 
2076
{
 
2077
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
 
2078
        register char *source = (yytext_ptr);
 
2079
        register int number_to_move, i;
 
2080
        int ret_val;
 
2081
 
 
2082
        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
 
2083
                YY_FATAL_ERROR(
 
2084
                "fatal flex scanner internal error--end of buffer missed" );
 
2085
 
 
2086
        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
 
2087
                { /* Don't try to fill the buffer, so this is an EOF. */
 
2088
                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
 
2089
                        {
 
2090
                        /* We matched a single character, the EOB, so
 
2091
                         * treat this as a final EOF.
 
2092
                         */
 
2093
                        return EOB_ACT_END_OF_FILE;
 
2094
                        }
 
2095
 
 
2096
                else
 
2097
                        {
 
2098
                        /* We matched some text prior to the EOB, first
 
2099
                         * process it.
 
2100
                         */
 
2101
                        return EOB_ACT_LAST_MATCH;
 
2102
                        }
 
2103
                }
 
2104
 
 
2105
        /* Try to read more data. */
 
2106
 
 
2107
        /* First move last chars to start of buffer. */
 
2108
        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
 
2109
 
 
2110
        for ( i = 0; i < number_to_move; ++i )
 
2111
                *(dest++) = *(source++);
 
2112
 
 
2113
        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 
2114
                /* don't do the read, it's not guaranteed to return an EOF,
 
2115
                 * just force an EOF
 
2116
                 */
 
2117
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 
2118
 
 
2119
        else
 
2120
                {
 
2121
                        size_t num_to_read =
 
2122
                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
2123
 
 
2124
                while ( num_to_read <= 0 )
 
2125
                        { /* Not enough room in the buffer - grow it. */
 
2126
 
 
2127
                        /* just a shorter name for the current buffer */
 
2128
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
2129
 
 
2130
                        int yy_c_buf_p_offset =
 
2131
                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
 
2132
 
 
2133
                        if ( b->yy_is_our_buffer )
 
2134
                                {
 
2135
                                int new_size = b->yy_buf_size * 2;
 
2136
 
 
2137
                                if ( new_size <= 0 )
 
2138
                                        b->yy_buf_size += b->yy_buf_size / 8;
 
2139
                                else
 
2140
                                        b->yy_buf_size *= 2;
 
2141
 
 
2142
                                b->yy_ch_buf = (char *)
 
2143
                                        /* Include room in for 2 EOB chars. */
 
2144
                                        yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
 
2145
                                }
 
2146
                        else
 
2147
                                /* Can't grow it, we don't own it. */
 
2148
                                b->yy_ch_buf = 0;
 
2149
 
 
2150
                        if ( ! b->yy_ch_buf )
 
2151
                                YY_FATAL_ERROR(
 
2152
                                "fatal error - scanner input buffer overflow" );
 
2153
 
 
2154
                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 
2155
 
 
2156
                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
 
2157
                                                number_to_move - 1;
 
2158
 
 
2159
                        }
 
2160
 
 
2161
                if ( num_to_read > YY_READ_BUF_SIZE )
 
2162
                        num_to_read = YY_READ_BUF_SIZE;
 
2163
 
 
2164
                /* Read in more data. */
 
2165
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
 
2166
                        (yy_n_chars), num_to_read );
 
2167
 
 
2168
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 
2169
                }
 
2170
 
 
2171
        if ( (yy_n_chars) == 0 )
 
2172
                {
 
2173
                if ( number_to_move == YY_MORE_ADJ )
 
2174
                        {
 
2175
                        ret_val = EOB_ACT_END_OF_FILE;
 
2176
                        yyrestart(yyin  );
 
2177
                        }
 
2178
 
 
2179
                else
 
2180
                        {
 
2181
                        ret_val = EOB_ACT_LAST_MATCH;
 
2182
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
 
2183
                                YY_BUFFER_EOF_PENDING;
 
2184
                        }
 
2185
                }
 
2186
 
 
2187
        else
 
2188
                ret_val = EOB_ACT_CONTINUE_SCAN;
 
2189
 
 
2190
        (yy_n_chars) += number_to_move;
 
2191
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
 
2192
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 
2193
 
 
2194
        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
2195
 
 
2196
        return ret_val;
 
2197
}
 
2198
 
 
2199
/* yy_get_previous_state - get the state just before the EOB char was reached */
 
2200
 
 
2201
    static yy_state_type yy_get_previous_state (void)
 
2202
{
 
2203
        register yy_state_type yy_current_state;
 
2204
        register char *yy_cp;
 
2205
    
 
2206
        yy_current_state = (yy_start);
 
2207
 
 
2208
        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
 
2209
                {
 
2210
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
 
2211
                if ( yy_accept[yy_current_state] )
 
2212
                        {
 
2213
                        (yy_last_accepting_state) = yy_current_state;
 
2214
                        (yy_last_accepting_cpos) = yy_cp;
 
2215
                        }
 
2216
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 
2217
                        {
 
2218
                        yy_current_state = (int) yy_def[yy_current_state];
 
2219
                        if ( yy_current_state >= 399 )
 
2220
                                yy_c = yy_meta[(unsigned int) yy_c];
 
2221
                        }
 
2222
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 
2223
                }
 
2224
 
 
2225
        return yy_current_state;
 
2226
}
 
2227
 
 
2228
/* yy_try_NUL_trans - try to make a transition on the NUL character
 
2229
 *
 
2230
 * synopsis
 
2231
 *      next_state = yy_try_NUL_trans( current_state );
 
2232
 */
 
2233
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
 
2234
{
 
2235
        register int yy_is_jam;
 
2236
        register char *yy_cp = (yy_c_buf_p);
 
2237
 
 
2238
        register YY_CHAR yy_c = 1;
 
2239
        if ( yy_accept[yy_current_state] )
 
2240
                {
 
2241
                (yy_last_accepting_state) = yy_current_state;
 
2242
                (yy_last_accepting_cpos) = yy_cp;
 
2243
                }
 
2244
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 
2245
                {
 
2246
                yy_current_state = (int) yy_def[yy_current_state];
 
2247
                if ( yy_current_state >= 399 )
 
2248
                        yy_c = yy_meta[(unsigned int) yy_c];
 
2249
                }
 
2250
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 
2251
        yy_is_jam = (yy_current_state == 398);
 
2252
 
 
2253
        return yy_is_jam ? 0 : yy_current_state;
 
2254
}
 
2255
 
 
2256
#ifndef YY_NO_INPUT
 
2257
#ifdef __cplusplus
 
2258
    static int yyinput (void)
 
2259
#else
 
2260
    static int input  (void)
 
2261
#endif
 
2262
 
 
2263
{
 
2264
        int c;
 
2265
    
 
2266
        *(yy_c_buf_p) = (yy_hold_char);
 
2267
 
 
2268
        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
 
2269
                {
 
2270
                /* yy_c_buf_p now points to the character we want to return.
 
2271
                 * If this occurs *before* the EOB characters, then it's a
 
2272
                 * valid NUL; if not, then we've hit the end of the buffer.
 
2273
                 */
 
2274
                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
 
2275
                        /* This was really a NUL. */
 
2276
                        *(yy_c_buf_p) = '\0';
 
2277
 
 
2278
                else
 
2279
                        { /* need more input */
 
2280
                        int offset = (int)((yy_c_buf_p) - (yytext_ptr));
 
2281
                        ++(yy_c_buf_p);
 
2282
 
 
2283
                        switch ( yy_get_next_buffer(  ) )
 
2284
                                {
 
2285
                                case EOB_ACT_LAST_MATCH:
 
2286
                                        /* This happens because yy_g_n_b()
 
2287
                                         * sees that we've accumulated a
 
2288
                                         * token and flags that we need to
 
2289
                                         * try matching the token before
 
2290
                                         * proceeding.  But for input(),
 
2291
                                         * there's no matching to consider.
 
2292
                                         * So convert the EOB_ACT_LAST_MATCH
 
2293
                                         * to EOB_ACT_END_OF_FILE.
 
2294
                                         */
 
2295
 
 
2296
                                        /* Reset buffer status. */
 
2297
                                        yyrestart(yyin );
 
2298
 
 
2299
                                        /*FALLTHROUGH*/
 
2300
 
 
2301
                                case EOB_ACT_END_OF_FILE:
 
2302
                                        {
 
2303
                                        if ( yywrap( ) )
 
2304
                                                return EOF;
 
2305
 
 
2306
                                        if ( ! (yy_did_buffer_switch_on_eof) )
 
2307
                                                YY_NEW_FILE;
 
2308
#ifdef __cplusplus
 
2309
                                        return yyinput();
 
2310
#else
 
2311
                                        return input();
 
2312
#endif
 
2313
                                        }
 
2314
 
 
2315
                                case EOB_ACT_CONTINUE_SCAN:
 
2316
                                        (yy_c_buf_p) = (yytext_ptr) + offset;
 
2317
                                        break;
 
2318
                                }
 
2319
                        }
 
2320
                }
 
2321
 
 
2322
        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
 
2323
        *(yy_c_buf_p) = '\0';   /* preserve yytext */
 
2324
        (yy_hold_char) = *++(yy_c_buf_p);
 
2325
 
 
2326
        return c;
 
2327
}
 
2328
#endif  /* ifndef YY_NO_INPUT */
 
2329
 
 
2330
/** Immediately switch to a different input stream.
 
2331
 * @param input_file A readable stream.
 
2332
 * 
 
2333
 * @note This function does not reset the start condition to @c INITIAL .
 
2334
 */
 
2335
    static void yyrestart  (FILE * input_file )
 
2336
{
 
2337
    
 
2338
        if ( ! YY_CURRENT_BUFFER ){
 
2339
        yyensure_buffer_stack ();
 
2340
                YY_CURRENT_BUFFER_LVALUE =
 
2341
            yy_create_buffer(yyin,YY_BUF_SIZE );
 
2342
        }
 
2343
 
 
2344
        yy_init_buffer(YY_CURRENT_BUFFER,input_file );
 
2345
        yy_load_buffer_state( );
 
2346
}
 
2347
 
 
2348
/** Switch to a different input buffer.
 
2349
 * @param new_buffer The new input buffer.
 
2350
 * 
 
2351
 */
 
2352
    __attribute__((unused)) static void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
 
2353
{
 
2354
    
 
2355
        /* TODO. We should be able to replace this entire function body
 
2356
         * with
 
2357
         *              yypop_buffer_state();
 
2358
         *              yypush_buffer_state(new_buffer);
 
2359
     */
 
2360
        yyensure_buffer_stack ();
 
2361
        if ( YY_CURRENT_BUFFER == new_buffer )
 
2362
                return;
 
2363
 
 
2364
        if ( YY_CURRENT_BUFFER )
 
2365
                {
 
2366
                /* Flush out information for old buffer. */
 
2367
                *(yy_c_buf_p) = (yy_hold_char);
 
2368
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
 
2369
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 
2370
                }
 
2371
 
 
2372
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
2373
        yy_load_buffer_state( );
 
2374
 
 
2375
        /* We don't actually know whether we did this switch during
 
2376
         * EOF (yywrap()) processing, but the only time this flag
 
2377
         * is looked at is after yywrap() is called, so it's safe
 
2378
         * to go ahead and always set it.
 
2379
         */
 
2380
        (yy_did_buffer_switch_on_eof) = 1;
 
2381
}
 
2382
 
 
2383
static void yy_load_buffer_state  (void)
 
2384
{
 
2385
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 
2386
        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
 
2387
        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
 
2388
        (yy_hold_char) = *(yy_c_buf_p);
 
2389
}
 
2390
 
 
2391
/** Allocate and initialize an input buffer state.
 
2392
 * @param file A readable stream.
 
2393
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 
2394
 * 
 
2395
 * @return the allocated buffer state.
 
2396
 */
 
2397
    static YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
 
2398
{
 
2399
        YY_BUFFER_STATE b;
 
2400
    
 
2401
        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
 
2402
        if ( ! b )
 
2403
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
2404
 
 
2405
        b->yy_buf_size = size;
 
2406
 
 
2407
        /* yy_ch_buf has to be 2 characters longer than the size given because
 
2408
         * we need to put in 2 end-of-buffer characters.
 
2409
         */
 
2410
        b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
 
2411
        if ( ! b->yy_ch_buf )
 
2412
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
2413
 
 
2414
        b->yy_is_our_buffer = 1;
 
2415
 
 
2416
        yy_init_buffer(b,file );
 
2417
 
 
2418
        return b;
 
2419
}
 
2420
 
 
2421
/** Destroy the buffer.
 
2422
 * @param b a buffer created with yy_create_buffer()
 
2423
 * 
 
2424
 */
 
2425
    static void yy_delete_buffer (YY_BUFFER_STATE  b )
 
2426
{
 
2427
    
 
2428
        if ( ! b )
 
2429
                return;
 
2430
 
 
2431
        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
 
2432
                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
2433
 
 
2434
        if ( b->yy_is_our_buffer )
 
2435
                yyfree((void *) b->yy_ch_buf  );
 
2436
 
 
2437
        yyfree((void *) b  );
 
2438
}
 
2439
 
 
2440
/* Initializes or reinitializes a buffer.
 
2441
 * This function is sometimes called more than once on the same buffer,
 
2442
 * such as during a yyrestart() or at EOF.
 
2443
 */
 
2444
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 
2445
 
 
2446
{
 
2447
        int oerrno = errno;
 
2448
    
 
2449
        yy_flush_buffer(b );
 
2450
 
 
2451
        b->yy_input_file = file;
 
2452
        b->yy_fill_buffer = 1;
 
2453
 
 
2454
    /* If b is the current buffer, then yy_init_buffer was _probably_
 
2455
     * called from yyrestart() or through yy_get_next_buffer.
 
2456
     * In that case, we don't want to reset the lineno or column.
 
2457
     */
 
2458
    if (b != YY_CURRENT_BUFFER){
 
2459
        b->yy_bs_lineno = 1;
 
2460
        b->yy_bs_column = 0;
 
2461
    }
 
2462
 
 
2463
        b->yy_is_interactive = 0;
 
2464
    
 
2465
        errno = oerrno;
 
2466
}
 
2467
 
 
2468
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 
2469
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 
2470
 * 
 
2471
 */
 
2472
    static void yy_flush_buffer (YY_BUFFER_STATE  b )
 
2473
{
 
2474
        if ( ! b )
 
2475
                return;
 
2476
 
 
2477
        b->yy_n_chars = 0;
 
2478
 
 
2479
        /* We always need two end-of-buffer characters.  The first causes
 
2480
         * a transition to the end-of-buffer state.  The second causes
 
2481
         * a jam in that state.
 
2482
         */
 
2483
        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
 
2484
        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 
2485
 
 
2486
        b->yy_buf_pos = &b->yy_ch_buf[0];
 
2487
 
 
2488
        b->yy_at_bol = 1;
 
2489
        b->yy_buffer_status = YY_BUFFER_NEW;
 
2490
 
 
2491
        if ( b == YY_CURRENT_BUFFER )
 
2492
                yy_load_buffer_state( );
 
2493
}
 
2494
 
 
2495
/** Pushes the new state onto the stack. The new state becomes
 
2496
 *  the current state. This function will allocate the stack
 
2497
 *  if necessary.
 
2498
 *  @param new_buffer The new state.
 
2499
 *  
 
2500
 */
 
2501
__attribute__((unused)) static void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
 
2502
{
 
2503
        if (new_buffer == NULL)
 
2504
                return;
 
2505
 
 
2506
        yyensure_buffer_stack();
 
2507
 
 
2508
        /* This block is copied from yy_switch_to_buffer. */
 
2509
        if ( YY_CURRENT_BUFFER )
 
2510
                {
 
2511
                /* Flush out information for old buffer. */
 
2512
                *(yy_c_buf_p) = (yy_hold_char);
 
2513
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
 
2514
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 
2515
                }
 
2516
 
 
2517
        /* Only push if top exists. Otherwise, replace top. */
 
2518
        if (YY_CURRENT_BUFFER)
 
2519
                (yy_buffer_stack_top)++;
 
2520
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
2521
 
 
2522
        /* copied from yy_switch_to_buffer. */
 
2523
        yy_load_buffer_state( );
 
2524
        (yy_did_buffer_switch_on_eof) = 1;
 
2525
}
 
2526
 
 
2527
/** Removes and deletes the top of the stack, if present.
 
2528
 *  The next element becomes the new top.
 
2529
 *  
 
2530
 */
 
2531
__attribute__((unused)) static void yypop_buffer_state (void)
 
2532
{
 
2533
        if (!YY_CURRENT_BUFFER)
 
2534
                return;
 
2535
 
 
2536
        yy_delete_buffer(YY_CURRENT_BUFFER );
 
2537
        YY_CURRENT_BUFFER_LVALUE = NULL;
 
2538
        if ((yy_buffer_stack_top) > 0)
 
2539
                --(yy_buffer_stack_top);
 
2540
 
 
2541
        if (YY_CURRENT_BUFFER) {
 
2542
                yy_load_buffer_state( );
 
2543
                (yy_did_buffer_switch_on_eof) = 1;
 
2544
        }
 
2545
}
 
2546
 
 
2547
/* Allocates the stack if it does not exist.
 
2548
 *  Guarantees space for at least one push.
 
2549
 */
 
2550
static void yyensure_buffer_stack (void)
 
2551
{
 
2552
        int num_to_alloc;
 
2553
    
 
2554
        if (!(yy_buffer_stack)) {
 
2555
 
 
2556
                /* First allocation is just for 2 elements, since we don't know if this
 
2557
                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
 
2558
                 * immediate realloc on the next call.
 
2559
         */
 
2560
                num_to_alloc = 1;
 
2561
                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
 
2562
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
 
2563
                                                                );
 
2564
                
 
2565
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
 
2566
                                
 
2567
                (yy_buffer_stack_max) = num_to_alloc;
 
2568
                (yy_buffer_stack_top) = 0;
 
2569
                return;
 
2570
        }
 
2571
 
 
2572
        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
 
2573
 
 
2574
                /* Increase the buffer to prepare for a possible push. */
 
2575
                int grow_size = 8 /* arbitrary grow size */;
 
2576
 
 
2577
                num_to_alloc = (yy_buffer_stack_max) + grow_size;
 
2578
                (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
 
2579
                                                                ((yy_buffer_stack),
 
2580
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
 
2581
                                                                );
 
2582
 
 
2583
                /* zero only the new slots.*/
 
2584
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
 
2585
                (yy_buffer_stack_max) = num_to_alloc;
 
2586
        }
 
2587
}
 
2588
 
 
2589
#ifndef YY_EXIT_FAILURE
 
2590
#define YY_EXIT_FAILURE 2
 
2591
#endif
 
2592
 
 
2593
static void yy_fatal_error (yyconst char* msg )
 
2594
{
 
2595
        (void) fprintf( stderr, "%s\n", msg );
 
2596
        exit( YY_EXIT_FAILURE );
 
2597
}
 
2598
 
 
2599
/* Redefine yyless() so it works in section 3 code. */
 
2600
 
 
2601
#undef yyless
 
2602
#define yyless(n) \
 
2603
        do \
 
2604
                { \
 
2605
                /* Undo effects of setting up yytext. */ \
 
2606
        int yyless_macro_arg = (n); \
 
2607
        YY_LESS_LINENO(yyless_macro_arg);\
 
2608
                yytext[yyleng] = (yy_hold_char); \
 
2609
                (yy_c_buf_p) = yytext + yyless_macro_arg; \
 
2610
                (yy_hold_char) = *(yy_c_buf_p); \
 
2611
                *(yy_c_buf_p) = '\0'; \
 
2612
                yyleng = yyless_macro_arg; \
 
2613
                } \
 
2614
        while ( 0 )
 
2615
 
 
2616
/* Accessor  methods (get/set functions) to struct members. */
 
2617
 
 
2618
/** Get the current line number.
 
2619
 * 
 
2620
 */
 
2621
__attribute__((unused)) static int yyget_lineno  (void)
 
2622
{
 
2623
        
 
2624
    return yylineno;
 
2625
}
 
2626
 
 
2627
/** Get the input stream.
 
2628
 * 
 
2629
 */
 
2630
__attribute__((unused)) static FILE *yyget_in  (void)
 
2631
{
 
2632
        return yyin;
 
2633
}
 
2634
 
 
2635
/** Get the output stream.
 
2636
 * 
 
2637
 */
 
2638
__attribute__((unused)) static FILE *yyget_out  (void)
 
2639
{
 
2640
        return yyout;
 
2641
}
 
2642
 
 
2643
/** Get the length of the current token.
 
2644
 * 
 
2645
 */
 
2646
__attribute__((unused)) static int yyget_leng  (void)
 
2647
{
 
2648
        return yyleng;
 
2649
}
 
2650
 
 
2651
/** Get the current token.
 
2652
 * 
 
2653
 */
 
2654
 
 
2655
__attribute__((unused)) static char *yyget_text  (void)
 
2656
{
 
2657
        return yytext;
 
2658
}
 
2659
 
 
2660
/** Set the current line number.
 
2661
 * @param line_number
 
2662
 * 
 
2663
 */
 
2664
__attribute__((unused)) static void yyset_lineno (int  line_number )
 
2665
{
 
2666
    
 
2667
    yylineno = line_number;
 
2668
}
 
2669
 
 
2670
/** Set the input stream. This does not discard the current
 
2671
 * input buffer.
 
2672
 * @param in_str A readable stream.
 
2673
 * 
 
2674
 * @see yy_switch_to_buffer
 
2675
 */
 
2676
__attribute__((unused)) static void yyset_in (FILE *  in_str )
 
2677
{
 
2678
        yyin = in_str ;
 
2679
}
 
2680
 
 
2681
__attribute__((unused)) static void yyset_out (FILE *  out_str )
 
2682
{
 
2683
        yyout = out_str ;
 
2684
}
 
2685
 
 
2686
__attribute__((unused)) static int yyget_debug  (void)
 
2687
{
 
2688
        return yy_flex_debug;
 
2689
}
 
2690
 
 
2691
__attribute__((unused)) static void yyset_debug (int  bdebug )
 
2692
{
 
2693
        yy_flex_debug = bdebug ;
 
2694
}
 
2695
 
 
2696
/* yylex_destroy is for both reentrant and non-reentrant scanners. */
 
2697
__attribute__((unused)) static int yylex_destroy  (void)
 
2698
{
 
2699
    
 
2700
    /* Pop the buffer stack, destroying each element. */
 
2701
        while(YY_CURRENT_BUFFER){
 
2702
                yy_delete_buffer(YY_CURRENT_BUFFER  );
 
2703
                YY_CURRENT_BUFFER_LVALUE = NULL;
 
2704
                yypop_buffer_state();
 
2705
        }
 
2706
 
 
2707
        /* Destroy the stack itself. */
 
2708
        yyfree((yy_buffer_stack) );
 
2709
        (yy_buffer_stack) = NULL;
 
2710
 
 
2711
    return 0;
 
2712
}
 
2713
 
 
2714
/*
 
2715
 * Internal utility routines.
 
2716
 */
 
2717
 
 
2718
#ifndef yytext_ptr
 
2719
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 
2720
{
 
2721
        register int i;
 
2722
        for ( i = 0; i < n; ++i )
 
2723
                s1[i] = s2[i];
 
2724
}
 
2725
#endif
 
2726
 
 
2727
#ifdef YY_NEED_STRLEN
 
2728
static int yy_flex_strlen (yyconst char * s )
 
2729
{
 
2730
        register int n;
 
2731
        for ( n = 0; s[n]; ++n )
 
2732
                ;
 
2733
 
 
2734
        return n;
 
2735
}
 
2736
#endif
 
2737
 
 
2738
static void *yyalloc (yy_size_t  size )
 
2739
{
 
2740
        return (void *) malloc( size );
 
2741
}
 
2742
 
 
2743
static void *yyrealloc  (void * ptr, yy_size_t  size )
 
2744
{
 
2745
        /* The cast to (char *) in the following accommodates both
 
2746
         * implementations that use char* generic pointers, and those
 
2747
         * that use void* generic pointers.  It works with the latter
 
2748
         * because both ANSI C and C++ allow castless assignment from
 
2749
         * any pointer type to void*, and deal with argument conversions
 
2750
         * as though doing an assignment.
 
2751
         */
 
2752
        return (void *) realloc( (char *) ptr, size );
 
2753
}
 
2754
 
 
2755
static void yyfree (void * ptr )
 
2756
{
 
2757
        free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
 
2758
}
 
2759
 
 
2760
#define YYTABLES_NAME "yytables"
 
2761
 
 
2762
#undef YY_NEW_FILE
 
2763
#undef YY_FLUSH_BUFFER
 
2764
#undef yy_set_bol
 
2765
#undef yy_new_buffer
 
2766
#undef yy_set_interactive
 
2767
#undef yytext_ptr
 
2768
#undef YY_DO_BEFORE_ACTION
 
2769
 
 
2770
#ifdef YY_DECL_IS_OURS
 
2771
#undef YY_DECL_IS_OURS
 
2772
#undef YY_DECL
 
2773
#endif
 
2774
#line 648 "pars0lex.l"
 
2775
 
 
2776
 
 
2777