Drizzled Public API Documentation

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