← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Toru Maesaka
  • Date: 2008-12-10 18:33:08 UTC
  • mto: (670.1.11 devel)
  • mto: This revision was merged to the branch mainline in revision 672.
  • Revision ID: dev@torum.net-20081210183308-mb6a5x0sbl1dhc5c
Replaced MySQL's my_stpncpy() with libc and c++ calls

Show diffs side-by-side

added added

removed removed

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