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