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