Drizzled Public API Documentation

pars0grm.cc
1 /* A Bison parser, made by GNU Bison 2.5. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
6 
7  This program is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /* As a special exception, you may create a larger work that contains
21  part or all of the Bison parser skeleton and distribute that work
22  under terms of your choice, so long as that work isn't itself a
23  parser generator using the skeleton or a modified version thereof
24  as a parser skeleton. Alternatively, if you modify or redistribute
25  the parser skeleton itself, you may (at your option) remove this
26  special exception, which will cause the skeleton and the resulting
27  Bison output files to be licensed under the GNU General Public
28  License without this special exception.
29 
30  This special exception was added by the Free Software Foundation in
31  version 2.2 of Bison. */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34  simplifying the original so-called "semantic" parser. */
35 
36 /* All symbols defined below should begin with yy or YY, to avoid
37  infringing on user name space. This should be done even for local
38  variables, as they might otherwise be expanded by user macros.
39  There are some unavoidable exceptions within include files to
40  define necessary library symbols; they are noted "INFRINGES ON
41  USER NAME SPACE" below. */
42 
43 /* Identify Bison output. */
44 #define YYBISON 1
45 
46 /* Bison version. */
47 #define YYBISON_VERSION "2.5"
48 
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers. */
53 #define YYPURE 0
54 
55 /* Push parsers. */
56 #define YYPUSH 0
57 
58 /* Pull parsers. */
59 #define YYPULL 1
60 
61 /* Using locations. */
62 #define YYLSP_NEEDED 0
63 
64 
65 
66 /* Copy the first part of user declarations. */
67 
68 /* Line 268 of yacc.c */
69 #line 25 "plugin/innobase/pars/pars0grm.y"
70 
71 /* The value of the semantic attribute is a pointer to a query tree node
72 que_node_t */
73 
74 #include "univ.i"
75 #include <math.h> /* Can't be before univ.i */
76 #include "pars0pars.h"
77 #include "mem0mem.h"
78 #include "que0types.h"
79 #include "que0que.h"
80 #include "row0sel.h"
81 
82 #define YYSTYPE que_node_t*
83 #define YYENABLE_NLS 0
84 #define YYLTYPE_IS_TRIVIAL 0
85 
86 /* #define __STDC__ */
87 
88 extern "C" int yylex(void);
89 
90 
91 /* Line 268 of yacc.c */
92 #line 93 "plugin/innobase/pars/pars0grm.cc"
93 
94 /* Enabling traces. */
95 #ifndef YYDEBUG
96 # define YYDEBUG 0
97 #endif
98 
99 /* Enabling verbose error messages. */
100 #ifdef YYERROR_VERBOSE
101 # undef YYERROR_VERBOSE
102 # define YYERROR_VERBOSE 1
103 #else
104 # define YYERROR_VERBOSE 0
105 #endif
106 
107 /* Enabling the token table. */
108 #ifndef YYTOKEN_TABLE
109 # define YYTOKEN_TABLE 0
110 #endif
111 
112 
113 /* Tokens. */
114 #ifndef YYTOKENTYPE
115 # define YYTOKENTYPE
116  /* Put the tokens into the symbol table, so that GDB and other debuggers
117  know about them. */
118  enum yytokentype {
119  PARS_INT_LIT = 258,
120  PARS_FLOAT_LIT = 259,
121  PARS_STR_LIT = 260,
122  PARS_FIXBINARY_LIT = 261,
123  PARS_BLOB_LIT = 262,
124  PARS_NULL_LIT = 263,
125  PARS_ID_TOKEN = 264,
126  PARS_AND_TOKEN = 265,
127  PARS_OR_TOKEN = 266,
128  PARS_NOT_TOKEN = 267,
129  PARS_GE_TOKEN = 268,
130  PARS_LE_TOKEN = 269,
131  PARS_NE_TOKEN = 270,
132  PARS_PROCEDURE_TOKEN = 271,
133  PARS_IN_TOKEN = 272,
134  PARS_OUT_TOKEN = 273,
135  PARS_BINARY_TOKEN = 274,
136  PARS_BLOB_TOKEN = 275,
137  PARS_INT_TOKEN = 276,
138  PARS_INTEGER_TOKEN = 277,
139  PARS_FLOAT_TOKEN = 278,
140  PARS_CHAR_TOKEN = 279,
141  PARS_IS_TOKEN = 280,
142  PARS_BEGIN_TOKEN = 281,
143  PARS_END_TOKEN = 282,
144  PARS_IF_TOKEN = 283,
145  PARS_THEN_TOKEN = 284,
146  PARS_ELSE_TOKEN = 285,
147  PARS_ELSIF_TOKEN = 286,
148  PARS_LOOP_TOKEN = 287,
149  PARS_WHILE_TOKEN = 288,
150  PARS_RETURN_TOKEN = 289,
151  PARS_SELECT_TOKEN = 290,
152  PARS_SUM_TOKEN = 291,
153  PARS_COUNT_TOKEN = 292,
154  PARS_DISTINCT_TOKEN = 293,
155  PARS_FROM_TOKEN = 294,
156  PARS_WHERE_TOKEN = 295,
157  PARS_FOR_TOKEN = 296,
158  PARS_DDOT_TOKEN = 297,
159  PARS_READ_TOKEN = 298,
160  PARS_ORDER_TOKEN = 299,
161  PARS_BY_TOKEN = 300,
162  PARS_ASC_TOKEN = 301,
163  PARS_DESC_TOKEN = 302,
164  PARS_INSERT_TOKEN = 303,
165  PARS_INTO_TOKEN = 304,
166  PARS_VALUES_TOKEN = 305,
167  PARS_UPDATE_TOKEN = 306,
168  PARS_SET_TOKEN = 307,
169  PARS_DELETE_TOKEN = 308,
170  PARS_CURRENT_TOKEN = 309,
171  PARS_OF_TOKEN = 310,
172  PARS_CREATE_TOKEN = 311,
173  PARS_TABLE_TOKEN = 312,
174  PARS_INDEX_TOKEN = 313,
175  PARS_UNIQUE_TOKEN = 314,
176  PARS_CLUSTERED_TOKEN = 315,
177  PARS_DOES_NOT_FIT_IN_MEM_TOKEN = 316,
178  PARS_ON_TOKEN = 317,
179  PARS_ASSIGN_TOKEN = 318,
180  PARS_DECLARE_TOKEN = 319,
181  PARS_CURSOR_TOKEN = 320,
182  PARS_SQL_TOKEN = 321,
183  PARS_OPEN_TOKEN = 322,
184  PARS_FETCH_TOKEN = 323,
185  PARS_CLOSE_TOKEN = 324,
186  PARS_NOTFOUND_TOKEN = 325,
187  PARS_TO_CHAR_TOKEN = 326,
188  PARS_TO_NUMBER_TOKEN = 327,
189  PARS_TO_BINARY_TOKEN = 328,
190  PARS_BINARY_TO_NUMBER_TOKEN = 329,
191  PARS_SUBSTR_TOKEN = 330,
192  PARS_REPLSTR_TOKEN = 331,
193  PARS_CONCAT_TOKEN = 332,
194  PARS_INSTR_TOKEN = 333,
195  PARS_LENGTH_TOKEN = 334,
196  PARS_SYSDATE_TOKEN = 335,
197  PARS_PRINTF_TOKEN = 336,
198  PARS_ASSERT_TOKEN = 337,
199  PARS_RND_TOKEN = 338,
200  PARS_RND_STR_TOKEN = 339,
201  PARS_ROW_PRINTF_TOKEN = 340,
202  PARS_COMMIT_TOKEN = 341,
203  PARS_ROLLBACK_TOKEN = 342,
204  PARS_WORK_TOKEN = 343,
205  PARS_UNSIGNED_TOKEN = 344,
206  PARS_EXIT_TOKEN = 345,
207  PARS_FUNCTION_TOKEN = 346,
208  PARS_LOCK_TOKEN = 347,
209  PARS_SHARE_TOKEN = 348,
210  PARS_MODE_TOKEN = 349,
211  NEG = 350
212  };
213 #endif
214 /* Tokens. */
215 #define PARS_INT_LIT 258
216 #define PARS_FLOAT_LIT 259
217 #define PARS_STR_LIT 260
218 #define PARS_FIXBINARY_LIT 261
219 #define PARS_BLOB_LIT 262
220 #define PARS_NULL_LIT 263
221 #define PARS_ID_TOKEN 264
222 #define PARS_AND_TOKEN 265
223 #define PARS_OR_TOKEN 266
224 #define PARS_NOT_TOKEN 267
225 #define PARS_GE_TOKEN 268
226 #define PARS_LE_TOKEN 269
227 #define PARS_NE_TOKEN 270
228 #define PARS_PROCEDURE_TOKEN 271
229 #define PARS_IN_TOKEN 272
230 #define PARS_OUT_TOKEN 273
231 #define PARS_BINARY_TOKEN 274
232 #define PARS_BLOB_TOKEN 275
233 #define PARS_INT_TOKEN 276
234 #define PARS_INTEGER_TOKEN 277
235 #define PARS_FLOAT_TOKEN 278
236 #define PARS_CHAR_TOKEN 279
237 #define PARS_IS_TOKEN 280
238 #define PARS_BEGIN_TOKEN 281
239 #define PARS_END_TOKEN 282
240 #define PARS_IF_TOKEN 283
241 #define PARS_THEN_TOKEN 284
242 #define PARS_ELSE_TOKEN 285
243 #define PARS_ELSIF_TOKEN 286
244 #define PARS_LOOP_TOKEN 287
245 #define PARS_WHILE_TOKEN 288
246 #define PARS_RETURN_TOKEN 289
247 #define PARS_SELECT_TOKEN 290
248 #define PARS_SUM_TOKEN 291
249 #define PARS_COUNT_TOKEN 292
250 #define PARS_DISTINCT_TOKEN 293
251 #define PARS_FROM_TOKEN 294
252 #define PARS_WHERE_TOKEN 295
253 #define PARS_FOR_TOKEN 296
254 #define PARS_DDOT_TOKEN 297
255 #define PARS_READ_TOKEN 298
256 #define PARS_ORDER_TOKEN 299
257 #define PARS_BY_TOKEN 300
258 #define PARS_ASC_TOKEN 301
259 #define PARS_DESC_TOKEN 302
260 #define PARS_INSERT_TOKEN 303
261 #define PARS_INTO_TOKEN 304
262 #define PARS_VALUES_TOKEN 305
263 #define PARS_UPDATE_TOKEN 306
264 #define PARS_SET_TOKEN 307
265 #define PARS_DELETE_TOKEN 308
266 #define PARS_CURRENT_TOKEN 309
267 #define PARS_OF_TOKEN 310
268 #define PARS_CREATE_TOKEN 311
269 #define PARS_TABLE_TOKEN 312
270 #define PARS_INDEX_TOKEN 313
271 #define PARS_UNIQUE_TOKEN 314
272 #define PARS_CLUSTERED_TOKEN 315
273 #define PARS_DOES_NOT_FIT_IN_MEM_TOKEN 316
274 #define PARS_ON_TOKEN 317
275 #define PARS_ASSIGN_TOKEN 318
276 #define PARS_DECLARE_TOKEN 319
277 #define PARS_CURSOR_TOKEN 320
278 #define PARS_SQL_TOKEN 321
279 #define PARS_OPEN_TOKEN 322
280 #define PARS_FETCH_TOKEN 323
281 #define PARS_CLOSE_TOKEN 324
282 #define PARS_NOTFOUND_TOKEN 325
283 #define PARS_TO_CHAR_TOKEN 326
284 #define PARS_TO_NUMBER_TOKEN 327
285 #define PARS_TO_BINARY_TOKEN 328
286 #define PARS_BINARY_TO_NUMBER_TOKEN 329
287 #define PARS_SUBSTR_TOKEN 330
288 #define PARS_REPLSTR_TOKEN 331
289 #define PARS_CONCAT_TOKEN 332
290 #define PARS_INSTR_TOKEN 333
291 #define PARS_LENGTH_TOKEN 334
292 #define PARS_SYSDATE_TOKEN 335
293 #define PARS_PRINTF_TOKEN 336
294 #define PARS_ASSERT_TOKEN 337
295 #define PARS_RND_TOKEN 338
296 #define PARS_RND_STR_TOKEN 339
297 #define PARS_ROW_PRINTF_TOKEN 340
298 #define PARS_COMMIT_TOKEN 341
299 #define PARS_ROLLBACK_TOKEN 342
300 #define PARS_WORK_TOKEN 343
301 #define PARS_UNSIGNED_TOKEN 344
302 #define PARS_EXIT_TOKEN 345
303 #define PARS_FUNCTION_TOKEN 346
304 #define PARS_LOCK_TOKEN 347
305 #define PARS_SHARE_TOKEN 348
306 #define PARS_MODE_TOKEN 349
307 #define NEG 350
308 
309 
310 
311 
312 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
313 typedef int YYSTYPE;
314 # define YYSTYPE_IS_TRIVIAL 1
315 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
316 # define YYSTYPE_IS_DECLARED 1
317 #endif
318 
319 
320 /* Copy the second part of user declarations. */
321 
322 
323 /* Line 343 of yacc.c */
324 #line 325 "plugin/innobase/pars/pars0grm.cc"
325 
326 #ifdef short
327 # undef short
328 #endif
329 
330 #ifdef YYTYPE_UINT8
331 typedef YYTYPE_UINT8 yytype_uint8;
332 #else
333 typedef unsigned char yytype_uint8;
334 #endif
335 
336 #ifdef YYTYPE_INT8
337 typedef YYTYPE_INT8 yytype_int8;
338 #elif (defined __STDC__ || defined __C99__FUNC__ \
339  || defined __cplusplus || defined _MSC_VER)
340 typedef signed char yytype_int8;
341 #else
342 typedef short int yytype_int8;
343 #endif
344 
345 #ifdef YYTYPE_UINT16
346 typedef YYTYPE_UINT16 yytype_uint16;
347 #else
348 typedef unsigned short int yytype_uint16;
349 #endif
350 
351 #ifdef YYTYPE_INT16
352 typedef YYTYPE_INT16 yytype_int16;
353 #else
354 typedef short int yytype_int16;
355 #endif
356 
357 #ifndef YYSIZE_T
358 # ifdef __SIZE_TYPE__
359 # define YYSIZE_T __SIZE_TYPE__
360 # elif defined size_t
361 # define YYSIZE_T size_t
362 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
363  || defined __cplusplus || defined _MSC_VER)
364 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
365 # define YYSIZE_T size_t
366 # else
367 # define YYSIZE_T unsigned int
368 # endif
369 #endif
370 
371 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
372 
373 #ifndef YY_
374 # if defined YYENABLE_NLS && YYENABLE_NLS
375 # if ENABLE_NLS
376 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
377 # define YY_(msgid) dgettext ("bison-runtime", msgid)
378 # endif
379 # endif
380 # ifndef YY_
381 # define YY_(msgid) msgid
382 # endif
383 #endif
384 
385 /* Suppress unused-variable warnings by "using" E. */
386 #if ! defined lint || defined __GNUC__
387 # define YYUSE(e) ((void) (e))
388 #else
389 # define YYUSE(e) /* empty */
390 #endif
391 
392 /* Identity function, used to suppress warnings about constant conditions. */
393 #ifndef lint
394 # define YYID(n) (n)
395 #else
396 #if (defined __STDC__ || defined __C99__FUNC__ \
397  || defined __cplusplus || defined _MSC_VER)
398 static int
399 YYID (int yyi)
400 #else
401 static int
402 YYID (yyi)
403  int yyi;
404 #endif
405 {
406  return yyi;
407 }
408 #endif
409 
410 #if ! defined yyoverflow || YYERROR_VERBOSE
411 
412 /* The parser invokes alloca or malloc; define the necessary symbols. */
413 
414 # ifdef YYSTACK_USE_ALLOCA
415 # if YYSTACK_USE_ALLOCA
416 # ifdef __GNUC__
417 # define YYSTACK_ALLOC __builtin_alloca
418 # elif defined __BUILTIN_VA_ARG_INCR
419 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
420 # elif defined _AIX
421 # define YYSTACK_ALLOC __alloca
422 # elif defined _MSC_VER
423 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
424 # define alloca _alloca
425 # else
426 # define YYSTACK_ALLOC alloca
427 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
428  || defined __cplusplus || defined _MSC_VER)
429 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
430 # ifndef EXIT_SUCCESS
431 # define EXIT_SUCCESS 0
432 # endif
433 # endif
434 # endif
435 # endif
436 # endif
437 
438 # ifdef YYSTACK_ALLOC
439  /* Pacify GCC's `empty if-body' warning. */
440 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
441 # ifndef YYSTACK_ALLOC_MAXIMUM
442  /* The OS might guarantee only one guard page at the bottom of the stack,
443  and a page size can be as small as 4096 bytes. So we cannot safely
444  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
445  to allow for a few compiler-allocated temporary stack slots. */
446 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
447 # endif
448 # else
449 # define YYSTACK_ALLOC YYMALLOC
450 # define YYSTACK_FREE YYFREE
451 # ifndef YYSTACK_ALLOC_MAXIMUM
452 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
453 # endif
454 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
455  && ! ((defined YYMALLOC || defined malloc) \
456  && (defined YYFREE || defined free)))
457 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
458 # ifndef EXIT_SUCCESS
459 # define EXIT_SUCCESS 0
460 # endif
461 # endif
462 # ifndef YYMALLOC
463 # define YYMALLOC malloc
464 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
465  || defined __cplusplus || defined _MSC_VER)
466 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
467 # endif
468 # endif
469 # ifndef YYFREE
470 # define YYFREE free
471 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
472  || defined __cplusplus || defined _MSC_VER)
473 void free (void *); /* INFRINGES ON USER NAME SPACE */
474 # endif
475 # endif
476 # endif
477 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
478 
479 
480 #if (! defined yyoverflow \
481  && (! defined __cplusplus \
482  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
483 
484 /* A type that is properly aligned for any stack member. */
485 union yyalloc
486 {
487  yytype_int16 yyss_alloc;
488  YYSTYPE yyvs_alloc;
489 };
490 
491 /* The size of the maximum gap between one aligned stack and the next. */
492 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
493 
494 /* The size of an array large to enough to hold all stacks, each with
495  N elements. */
496 # define YYSTACK_BYTES(N) \
497  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
498  + YYSTACK_GAP_MAXIMUM)
499 
500 # define YYCOPY_NEEDED 1
501 
502 /* Relocate STACK from its old location to the new one. The
503  local variables YYSIZE and YYSTACKSIZE give the old and new number of
504  elements in the stack, and YYPTR gives the new location of the
505  stack. Advance YYPTR to a properly aligned location for the next
506  stack. */
507 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
508  do \
509  { \
510  YYSIZE_T yynewbytes; \
511  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
512  Stack = &yyptr->Stack_alloc; \
513  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
514  yyptr += yynewbytes / sizeof (*yyptr); \
515  } \
516  while (YYID (0))
517 
518 #endif
519 
520 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
521 /* Copy COUNT objects from FROM to TO. The source and destination do
522  not overlap. */
523 # ifndef YYCOPY
524 # if defined __GNUC__ && 1 < __GNUC__
525 # define YYCOPY(To, From, Count) \
526  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
527 # else
528 # define YYCOPY(To, From, Count) \
529  do \
530  { \
531  YYSIZE_T yyi; \
532  for (yyi = 0; yyi < (Count); yyi++) \
533  (To)[yyi] = (From)[yyi]; \
534  } \
535  while (YYID (0))
536 # endif
537 # endif
538 #endif /* !YYCOPY_NEEDED */
539 
540 /* YYFINAL -- State number of the termination state. */
541 #define YYFINAL 5
542 /* YYLAST -- Last index in YYTABLE. */
543 #define YYLAST 752
544 
545 /* YYNTOKENS -- Number of terminals. */
546 #define YYNTOKENS 111
547 /* YYNNTS -- Number of nonterminals. */
548 #define YYNNTS 70
549 /* YYNRULES -- Number of rules. */
550 #define YYNRULES 175
551 /* YYNRULES -- Number of states. */
552 #define YYNSTATES 339
553 
554 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
555 #define YYUNDEFTOK 2
556 #define YYMAXUTOK 350
557 
558 #define YYTRANSLATE(YYX) \
559  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
560 
561 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
562 static const yytype_uint8 yytranslate[] =
563 {
564  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
565  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
566  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
567  2, 2, 2, 2, 2, 2, 2, 103, 2, 2,
568  105, 106, 100, 99, 108, 98, 2, 101, 2, 2,
569  2, 2, 2, 2, 2, 2, 2, 2, 2, 104,
570  96, 95, 97, 107, 2, 2, 2, 2, 2, 2,
571  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
572  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
573  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
575  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
576  2, 2, 2, 109, 2, 110, 2, 2, 2, 2,
577  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
589  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
590  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
591  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
592  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
593  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
594  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
595  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
596  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
597  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
598  85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
599  102
600 };
601 
602 #if YYDEBUG
603 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
604  YYRHS. */
605 static const yytype_uint16 yyprhs[] =
606 {
607  0, 0, 3, 6, 8, 11, 14, 17, 20, 23,
608  26, 29, 32, 35, 38, 41, 44, 47, 50, 53,
609  56, 59, 62, 65, 68, 71, 73, 76, 78, 83,
610  85, 87, 89, 91, 93, 95, 97, 101, 105, 109,
611  113, 116, 120, 124, 128, 132, 136, 140, 144, 148,
612  152, 155, 159, 163, 165, 167, 169, 171, 173, 175,
613  177, 179, 181, 183, 185, 186, 188, 192, 199, 204,
614  206, 208, 210, 214, 216, 220, 221, 223, 227, 228,
615  230, 234, 236, 241, 247, 252, 253, 255, 259, 261,
616  265, 267, 268, 271, 272, 275, 276, 281, 282, 284,
617  286, 287, 292, 301, 305, 311, 314, 318, 320, 324,
618  329, 334, 337, 340, 344, 347, 350, 353, 357, 362,
619  364, 367, 368, 371, 373, 381, 388, 399, 401, 403,
620  406, 409, 414, 419, 425, 427, 431, 432, 436, 437,
621  439, 440, 443, 444, 446, 454, 456, 460, 461, 463,
622  464, 466, 477, 480, 483, 485, 487, 489, 491, 493,
623  497, 501, 502, 504, 508, 512, 513, 515, 518, 525,
624  530, 532, 534, 535, 537, 540
625 };
626 
627 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
628 static const yytype_int16 yyrhs[] =
629 {
630  112, 0, -1, 180, 104, -1, 118, -1, 119, 104,
631  -1, 151, 104, -1, 152, 104, -1, 153, 104, -1,
632  150, 104, -1, 154, 104, -1, 146, 104, -1, 133,
633  104, -1, 135, 104, -1, 145, 104, -1, 143, 104,
634  -1, 144, 104, -1, 140, 104, -1, 141, 104, -1,
635  155, 104, -1, 157, 104, -1, 156, 104, -1, 169,
636  104, -1, 170, 104, -1, 164, 104, -1, 168, 104,
637  -1, 113, -1, 114, 113, -1, 9, -1, 116, 105,
638  124, 106, -1, 3, -1, 4, -1, 5, -1, 6,
639  -1, 7, -1, 8, -1, 66, -1, 115, 99, 115,
640  -1, 115, 98, 115, -1, 115, 100, 115, -1, 115,
641  101, 115, -1, 98, 115, -1, 105, 115, 106, -1,
642  115, 95, 115, -1, 115, 96, 115, -1, 115, 97,
643  115, -1, 115, 13, 115, -1, 115, 14, 115, -1,
644  115, 15, 115, -1, 115, 10, 115, -1, 115, 11,
645  115, -1, 12, 115, -1, 9, 103, 70, -1, 66,
646  103, 70, -1, 71, -1, 72, -1, 73, -1, 74,
647  -1, 75, -1, 77, -1, 78, -1, 79, -1, 80,
648  -1, 83, -1, 84, -1, -1, 107, -1, 117, 108,
649  107, -1, 109, 9, 105, 117, 106, 110, -1, 120,
650  105, 124, 106, -1, 76, -1, 81, -1, 82, -1,
651  9, 105, 106, -1, 9, -1, 122, 108, 9, -1,
652  -1, 9, -1, 123, 108, 9, -1, -1, 115, -1,
653  124, 108, 115, -1, 115, -1, 37, 105, 100, 106,
654  -1, 37, 105, 38, 9, 106, -1, 36, 105, 115,
655  106, -1, -1, 125, -1, 126, 108, 125, -1, 100,
656  -1, 126, 49, 123, -1, 126, -1, -1, 40, 115,
657  -1, -1, 41, 51, -1, -1, 92, 17, 93, 94,
658  -1, -1, 46, -1, 47, -1, -1, 44, 45, 9,
659  131, -1, 35, 127, 39, 122, 128, 129, 130, 132,
660  -1, 48, 49, 9, -1, 134, 50, 105, 124, 106,
661  -1, 134, 133, -1, 9, 95, 115, -1, 136, -1,
662  137, 108, 136, -1, 40, 54, 55, 9, -1, 51,
663  9, 52, 137, -1, 139, 128, -1, 139, 138, -1,
664  53, 39, 9, -1, 142, 128, -1, 142, 138, -1,
665  85, 133, -1, 9, 63, 115, -1, 31, 115, 29,
666  114, -1, 147, -1, 148, 147, -1, -1, 30, 114,
667  -1, 148, -1, 28, 115, 29, 114, 149, 27, 28,
668  -1, 33, 115, 32, 114, 27, 32, -1, 41, 9,
669  17, 115, 42, 115, 32, 114, 27, 32, -1, 90,
670  -1, 34, -1, 67, 9, -1, 69, 9, -1, 68,
671  9, 49, 123, -1, 68, 9, 49, 121, -1, 9,
672  171, 160, 161, 162, -1, 158, -1, 159, 108, 158,
673  -1, -1, 105, 3, 106, -1, -1, 89, -1, -1,
674  12, 8, -1, -1, 61, -1, 56, 57, 9, 105,
675  159, 106, 163, -1, 9, -1, 165, 108, 9, -1,
676  -1, 59, -1, -1, 60, -1, 56, 166, 167, 58,
677  9, 62, 9, 105, 165, 106, -1, 86, 88, -1,
678  87, 88, -1, 21, -1, 22, -1, 24, -1, 19,
679  -1, 20, -1, 9, 17, 171, -1, 9, 18, 171,
680  -1, -1, 172, -1, 173, 108, 172, -1, 9, 171,
681  104, -1, -1, 174, -1, 175, 174, -1, 64, 65,
682  9, 25, 133, 104, -1, 64, 91, 9, 104, -1,
683  176, -1, 177, -1, -1, 178, -1, 179, 178, -1,
684  16, 9, 105, 173, 106, 25, 175, 179, 26, 114,
685  27, -1
686 };
687 
688 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
689 static const yytype_uint16 yyrline[] =
690 {
691  0, 153, 153, 156, 157, 158, 159, 160, 161, 162,
692  163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
693  173, 174, 175, 176, 177, 181, 182, 187, 188, 190,
694  191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
695  201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
696  211, 212, 214, 219, 220, 221, 222, 224, 225, 226,
697  227, 228, 229, 230, 233, 235, 236, 240, 245, 250,
698  251, 252, 256, 260, 261, 266, 267, 268, 273, 274,
699  275, 279, 280, 285, 291, 298, 299, 300, 305, 307,
700  309, 313, 314, 318, 319, 324, 325, 330, 331, 332,
701  336, 337, 342, 352, 357, 359, 364, 368, 369, 374,
702  380, 387, 392, 397, 403, 408, 413, 418, 423, 429,
703  430, 435, 436, 438, 442, 449, 455, 463, 467, 471,
704  477, 483, 485, 490, 495, 496, 501, 502, 507, 508,
705  514, 515, 521, 522, 528, 534, 535, 540, 541, 545,
706  546, 550, 558, 563, 568, 569, 570, 571, 572, 576,
707  579, 585, 586, 587, 592, 596, 598, 599, 603, 609,
708  614, 615, 618, 620, 621, 625
709 };
710 #endif
711 
712 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
713 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
714  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
715 static const char *const yytname[] =
716 {
717  "$end", "error", "$undefined", "PARS_INT_LIT", "PARS_FLOAT_LIT",
718  "PARS_STR_LIT", "PARS_FIXBINARY_LIT", "PARS_BLOB_LIT", "PARS_NULL_LIT",
719  "PARS_ID_TOKEN", "PARS_AND_TOKEN", "PARS_OR_TOKEN", "PARS_NOT_TOKEN",
720  "PARS_GE_TOKEN", "PARS_LE_TOKEN", "PARS_NE_TOKEN",
721  "PARS_PROCEDURE_TOKEN", "PARS_IN_TOKEN", "PARS_OUT_TOKEN",
722  "PARS_BINARY_TOKEN", "PARS_BLOB_TOKEN", "PARS_INT_TOKEN",
723  "PARS_INTEGER_TOKEN", "PARS_FLOAT_TOKEN", "PARS_CHAR_TOKEN",
724  "PARS_IS_TOKEN", "PARS_BEGIN_TOKEN", "PARS_END_TOKEN", "PARS_IF_TOKEN",
725  "PARS_THEN_TOKEN", "PARS_ELSE_TOKEN", "PARS_ELSIF_TOKEN",
726  "PARS_LOOP_TOKEN", "PARS_WHILE_TOKEN", "PARS_RETURN_TOKEN",
727  "PARS_SELECT_TOKEN", "PARS_SUM_TOKEN", "PARS_COUNT_TOKEN",
728  "PARS_DISTINCT_TOKEN", "PARS_FROM_TOKEN", "PARS_WHERE_TOKEN",
729  "PARS_FOR_TOKEN", "PARS_DDOT_TOKEN", "PARS_READ_TOKEN",
730  "PARS_ORDER_TOKEN", "PARS_BY_TOKEN", "PARS_ASC_TOKEN", "PARS_DESC_TOKEN",
731  "PARS_INSERT_TOKEN", "PARS_INTO_TOKEN", "PARS_VALUES_TOKEN",
732  "PARS_UPDATE_TOKEN", "PARS_SET_TOKEN", "PARS_DELETE_TOKEN",
733  "PARS_CURRENT_TOKEN", "PARS_OF_TOKEN", "PARS_CREATE_TOKEN",
734  "PARS_TABLE_TOKEN", "PARS_INDEX_TOKEN", "PARS_UNIQUE_TOKEN",
735  "PARS_CLUSTERED_TOKEN", "PARS_DOES_NOT_FIT_IN_MEM_TOKEN",
736  "PARS_ON_TOKEN", "PARS_ASSIGN_TOKEN", "PARS_DECLARE_TOKEN",
737  "PARS_CURSOR_TOKEN", "PARS_SQL_TOKEN", "PARS_OPEN_TOKEN",
738  "PARS_FETCH_TOKEN", "PARS_CLOSE_TOKEN", "PARS_NOTFOUND_TOKEN",
739  "PARS_TO_CHAR_TOKEN", "PARS_TO_NUMBER_TOKEN", "PARS_TO_BINARY_TOKEN",
740  "PARS_BINARY_TO_NUMBER_TOKEN", "PARS_SUBSTR_TOKEN", "PARS_REPLSTR_TOKEN",
741  "PARS_CONCAT_TOKEN", "PARS_INSTR_TOKEN", "PARS_LENGTH_TOKEN",
742  "PARS_SYSDATE_TOKEN", "PARS_PRINTF_TOKEN", "PARS_ASSERT_TOKEN",
743  "PARS_RND_TOKEN", "PARS_RND_STR_TOKEN", "PARS_ROW_PRINTF_TOKEN",
744  "PARS_COMMIT_TOKEN", "PARS_ROLLBACK_TOKEN", "PARS_WORK_TOKEN",
745  "PARS_UNSIGNED_TOKEN", "PARS_EXIT_TOKEN", "PARS_FUNCTION_TOKEN",
746  "PARS_LOCK_TOKEN", "PARS_SHARE_TOKEN", "PARS_MODE_TOKEN", "'='", "'<'",
747  "'>'", "'-'", "'+'", "'*'", "'/'", "NEG", "'%'", "';'", "'('", "')'",
748  "'?'", "','", "'{'", "'}'", "$accept", "top_statement", "statement",
749  "statement_list", "exp", "function_name", "question_mark_list",
750  "stored_procedure_call", "predefined_procedure_call",
751  "predefined_procedure_name", "user_function_call", "table_list",
752  "variable_list", "exp_list", "select_item", "select_item_list",
753  "select_list", "search_condition", "for_update_clause",
754  "lock_shared_clause", "order_direction", "order_by_clause",
755  "select_statement", "insert_statement_start", "insert_statement",
756  "column_assignment", "column_assignment_list", "cursor_positioned",
757  "update_statement_start", "update_statement_searched",
758  "update_statement_positioned", "delete_statement_start",
759  "delete_statement_searched", "delete_statement_positioned",
760  "row_printf_statement", "assignment_statement", "elsif_element",
761  "elsif_list", "else_part", "if_statement", "while_statement",
762  "for_statement", "exit_statement", "return_statement",
763  "open_cursor_statement", "close_cursor_statement", "fetch_statement",
764  "column_def", "column_def_list", "opt_column_len", "opt_unsigned",
765  "opt_not_null", "not_fit_in_memory", "create_table", "column_list",
766  "unique_def", "clustered_def", "create_index", "commit_statement",
767  "rollback_statement", "type_name", "parameter_declaration",
768  "parameter_declaration_list", "variable_declaration",
769  "variable_declaration_list", "cursor_declaration",
770  "function_declaration", "declaration", "declaration_list",
771  "procedure_definition", 0
772 };
773 #endif
774 
775 # ifdef YYPRINT
776 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
777  token YYLEX-NUM. */
778 static const yytype_uint16 yytoknum[] =
779 {
780  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
781  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
782  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
783  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
784  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
785  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
786  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
787  325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
788  335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
789  345, 346, 347, 348, 349, 61, 60, 62, 45, 43,
790  42, 47, 350, 37, 59, 40, 41, 63, 44, 123,
791  125
792 };
793 # endif
794 
795 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
796 static const yytype_uint8 yyr1[] =
797 {
798  0, 111, 112, 113, 113, 113, 113, 113, 113, 113,
799  113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
800  113, 113, 113, 113, 113, 114, 114, 115, 115, 115,
801  115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
802  115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
803  115, 115, 115, 116, 116, 116, 116, 116, 116, 116,
804  116, 116, 116, 116, 117, 117, 117, 118, 119, 120,
805  120, 120, 121, 122, 122, 123, 123, 123, 124, 124,
806  124, 125, 125, 125, 125, 126, 126, 126, 127, 127,
807  127, 128, 128, 129, 129, 130, 130, 131, 131, 131,
808  132, 132, 133, 134, 135, 135, 136, 137, 137, 138,
809  139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
810  148, 149, 149, 149, 150, 151, 152, 153, 154, 155,
811  156, 157, 157, 158, 159, 159, 160, 160, 161, 161,
812  162, 162, 163, 163, 164, 165, 165, 166, 166, 167,
813  167, 168, 169, 170, 171, 171, 171, 171, 171, 172,
814  172, 173, 173, 173, 174, 175, 175, 175, 176, 177,
815  178, 178, 179, 179, 179, 180
816 };
817 
818 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
819 static const yytype_uint8 yyr2[] =
820 {
821  0, 2, 2, 1, 2, 2, 2, 2, 2, 2,
822  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
823  2, 2, 2, 2, 2, 1, 2, 1, 4, 1,
824  1, 1, 1, 1, 1, 1, 3, 3, 3, 3,
825  2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
826  2, 3, 3, 1, 1, 1, 1, 1, 1, 1,
827  1, 1, 1, 1, 0, 1, 3, 6, 4, 1,
828  1, 1, 3, 1, 3, 0, 1, 3, 0, 1,
829  3, 1, 4, 5, 4, 0, 1, 3, 1, 3,
830  1, 0, 2, 0, 2, 0, 4, 0, 1, 1,
831  0, 4, 8, 3, 5, 2, 3, 1, 3, 4,
832  4, 2, 2, 3, 2, 2, 2, 3, 4, 1,
833  2, 0, 2, 1, 7, 6, 10, 1, 1, 2,
834  2, 4, 4, 5, 1, 3, 0, 3, 0, 1,
835  0, 2, 0, 1, 7, 1, 3, 0, 1, 0,
836  1, 10, 2, 2, 1, 1, 1, 1, 1, 3,
837  3, 0, 1, 3, 3, 0, 1, 2, 6, 4,
838  1, 1, 0, 1, 2, 11
839 };
840 
841 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
842  Performed when YYTABLE doesn't specify something else to do. Zero
843  means the default is an error. */
844 static const yytype_uint8 yydefact[] =
845 {
846  0, 0, 0, 0, 0, 1, 2, 161, 0, 162,
847  0, 0, 0, 0, 0, 157, 158, 154, 155, 156,
848  159, 160, 165, 163, 0, 166, 172, 0, 0, 167,
849  170, 171, 173, 0, 164, 0, 0, 0, 174, 0,
850  0, 0, 0, 0, 128, 85, 0, 0, 0, 0,
851  147, 0, 0, 0, 69, 70, 71, 0, 0, 0,
852  127, 0, 25, 0, 3, 0, 0, 0, 0, 0,
853  91, 0, 0, 91, 0, 0, 0, 0, 0, 0,
854  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
855  0, 169, 0, 29, 30, 31, 32, 33, 34, 27,
856  0, 35, 53, 54, 55, 56, 57, 58, 59, 60,
857  61, 62, 63, 0, 0, 0, 0, 0, 0, 0,
858  88, 81, 86, 90, 0, 0, 0, 0, 0, 0,
859  148, 149, 129, 0, 130, 116, 152, 153, 0, 175,
860  26, 4, 78, 11, 0, 105, 12, 0, 111, 112,
861  16, 17, 114, 115, 14, 15, 13, 10, 8, 5,
862  6, 7, 9, 18, 20, 19, 23, 24, 21, 22,
863  0, 117, 0, 50, 0, 40, 0, 0, 0, 0,
864  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
865  78, 0, 0, 0, 75, 0, 0, 0, 103, 0,
866  113, 0, 150, 0, 75, 64, 79, 0, 78, 0,
867  92, 168, 51, 52, 41, 48, 49, 45, 46, 47,
868  121, 42, 43, 44, 37, 36, 38, 39, 0, 0,
869  0, 0, 0, 76, 89, 87, 73, 91, 0, 0,
870  107, 110, 0, 0, 76, 132, 131, 65, 0, 68,
871  0, 0, 0, 0, 0, 119, 123, 0, 28, 0,
872  84, 0, 82, 0, 0, 0, 93, 0, 0, 0,
873  0, 134, 0, 0, 0, 0, 0, 80, 104, 109,
874  122, 0, 120, 0, 125, 83, 77, 74, 0, 95,
875  0, 106, 108, 136, 142, 0, 0, 72, 67, 66,
876  0, 124, 94, 0, 100, 0, 0, 138, 143, 144,
877  135, 0, 118, 0, 0, 102, 0, 0, 139, 140,
878  0, 0, 0, 0, 137, 0, 133, 145, 0, 96,
879  97, 126, 141, 151, 0, 98, 99, 101, 146
880 };
881 
882 /* YYDEFGOTO[NTERM-NUM]. */
883 static const yytype_int16 yydefgoto[] =
884 {
885  -1, 2, 62, 63, 206, 116, 248, 64, 65, 66,
886  245, 237, 234, 207, 122, 123, 124, 148, 289, 304,
887  337, 315, 67, 68, 69, 240, 241, 149, 70, 71,
888  72, 73, 74, 75, 76, 77, 255, 256, 257, 78,
889  79, 80, 81, 82, 83, 84, 85, 271, 272, 307,
890  319, 326, 309, 86, 328, 131, 203, 87, 88, 89,
891  20, 9, 10, 25, 26, 30, 31, 32, 33, 3
892 };
893 
894 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
895  STATE-NUM. */
896 #define YYPACT_NINF -177
897 static const yytype_int16 yypact[] =
898 {
899  28, 38, 54, -46, -29, -177, -177, 56, 50, -177,
900  -75, 8, 8, 46, 56, -177, -177, -177, -177, -177,
901  -177, -177, 63, -177, 8, -177, 2, -26, -51, -177,
902  -177, -177, -177, -13, -177, 71, 72, 587, -177, 57,
903  -21, 26, 272, 272, -177, 13, 91, 55, 96, 67,
904  -22, 99, 100, 103, -177, -177, -177, 75, 29, 35,
905  -177, 116, -177, 396, -177, 22, 23, 27, -9, 30,
906  87, 31, 32, 87, 47, 49, 52, 58, 59, 60,
907  61, 62, 65, 66, 74, 77, 78, 86, 89, 102,
908  75, -177, 272, -177, -177, -177, -177, -177, -177, 39,
909  272, 51, -177, -177, -177, -177, -177, -177, -177, -177,
910  -177, -177, -177, 272, 272, 361, 25, 489, 45, 90,
911  -177, 651, -177, -39, 93, 142, 124, 108, 152, 170,
912  -177, 131, -177, 143, -177, -177, -177, -177, 98, -177,
913  -177, -177, 272, -177, 110, -177, -177, 256, -177, -177,
914  -177, -177, -177, -177, -177, -177, -177, -177, -177, -177,
915  -177, -177, -177, -177, -177, -177, -177, -177, -177, -177,
916  112, 651, 137, 101, 147, 204, 88, 272, 272, 272,
917  272, 272, 587, 272, 272, 272, 272, 272, 272, 272,
918  272, 587, 272, -30, 211, 168, 212, 272, -177, 213,
919  -177, 118, -177, 167, 217, 122, 651, -63, 272, 175,
920  651, -177, -177, -177, -177, 101, 101, 21, 21, 651,
921  332, 21, 21, 21, -6, -6, 204, 204, -60, 460,
922  198, 222, 126, -177, 125, -177, -177, -33, 584, 140,
923  -177, 128, 228, 229, 139, -177, 125, -177, -53, -177,
924  272, -49, 240, 587, 272, -177, 224, 226, -177, 225,
925  -177, 150, -177, 258, 272, 260, 230, 272, 272, 213,
926  8, -177, -45, 208, 166, 164, 176, 651, -177, -177,
927  587, 631, -177, 254, -177, -177, -177, -177, 234, 194,
928  638, 651, -177, 182, 227, 228, 280, -177, -177, -177,
929  587, -177, -177, 273, 247, 587, 289, 214, -177, -177,
930  -177, 195, 587, 209, 261, -177, 524, 199, -177, 295,
931  292, 215, 299, 279, -177, 304, -177, -177, -44, -177,
932  -8, -177, -177, -177, 305, -177, -177, -177, -177
933 };
934 
935 /* YYPGOTO[NTERM-NUM]. */
936 static const yytype_int16 yypgoto[] =
937 {
938  -177, -177, -62, -176, -40, -177, -177, -177, -177, -177,
939  -177, -177, 109, -166, 120, -177, -177, -69, -177, -177,
940  -177, -177, -34, -177, -177, 48, -177, 243, -177, -177,
941  -177, -177, -177, -177, -177, -177, 64, -177, -177, -177,
942  -177, -177, -177, -177, -177, -177, -177, 24, -177, -177,
943  -177, -177, -177, -177, -177, -177, -177, -177, -177, -177,
944  -12, 307, -177, 297, -177, -177, -177, 285, -177, -177
945 };
946 
947 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
948  positive, shift that token. If negative, reduce the rule which
949  number is the opposite. If YYTABLE_NINF, syntax error. */
950 #define YYTABLE_NINF -1
951 static const yytype_uint16 yytable[] =
952 {
953  21, 140, 115, 117, 152, 121, 220, 264, 231, 181,
954  194, 24, 27, 37, 35, 229, 93, 94, 95, 96,
955  97, 98, 99, 135, 228, 100, 45, 15, 16, 17,
956  18, 13, 19, 14, 145, 129, 181, 130, 335, 336,
957  36, 144, 251, 249, 1, 250, 258, 4, 250, 118,
958  119, 28, 171, 275, 5, 276, 170, 278, 6, 250,
959  173, 294, 333, 295, 334, 8, 28, 11, 12, 195,
960  232, 22, 24, 175, 176, 265, 7, 280, 34, 101,
961  39, 40, 90, 91, 102, 103, 104, 105, 106, 92,
962  107, 108, 109, 110, 188, 189, 111, 112, 177, 178,
963  125, 179, 180, 181, 126, 127, 128, 210, 132, 133,
964  45, 113, 134, 120, 179, 180, 181, 136, 114, 186,
965  187, 188, 189, 137, 312, 138, 141, 147, 142, 316,
966  190, 143, 196, 198, 146, 150, 151, 215, 216, 217,
967  218, 219, 172, 221, 222, 223, 224, 225, 226, 227,
968  192, 154, 230, 155, 174, 121, 156, 238, 140, 197,
969  199, 200, 157, 158, 159, 160, 161, 140, 266, 162,
970  163, 93, 94, 95, 96, 97, 98, 99, 164, 201,
971  100, 165, 166, 183, 184, 185, 186, 187, 188, 189,
972  167, 202, 204, 168, 214, 193, 183, 184, 185, 186,
973  187, 188, 189, 205, 118, 119, 169, 212, 177, 178,
974  277, 179, 180, 181, 281, 208, 211, 213, 140, 181,
975  233, 236, 239, 242, 210, 243, 244, 290, 291, 247,
976  252, 261, 262, 263, 101, 268, 269, 270, 273, 102,
977  103, 104, 105, 106, 274, 107, 108, 109, 110, 279,
978  140, 111, 112, 283, 140, 254, 285, 284, 293, 93,
979  94, 95, 96, 97, 98, 99, 113, 286, 100, 287,
980  296, 288, 297, 114, 298, 93, 94, 95, 96, 97,
981  98, 99, 301, 299, 100, 302, 303, 306, 308, 311,
982  313, 314, 317, 183, 184, 185, 186, 187, 188, 189,
983  320, 327, 321, 318, 260, 324, 322, 325, 330, 329,
984  209, 331, 332, 246, 338, 235, 153, 292, 38, 310,
985  282, 23, 101, 29, 0, 0, 0, 102, 103, 104,
986  105, 106, 0, 107, 108, 109, 110, 0, 101, 111,
987  112, 41, 0, 102, 103, 104, 105, 106, 0, 107,
988  108, 109, 110, 0, 113, 111, 112, 0, 0, 0,
989  42, 114, 253, 254, 0, 43, 44, 45, 0, 0,
990  113, 177, 178, 46, 179, 180, 181, 114, 0, 0,
991  47, 0, 0, 48, 0, 49, 0, 0, 50, 0,
992  182, 0, 0, 0, 0, 0, 0, 0, 0, 51,
993  52, 53, 0, 0, 0, 41, 0, 0, 54, 0,
994  0, 0, 0, 55, 56, 0, 0, 57, 58, 59,
995  0, 0, 60, 139, 42, 0, 0, 0, 0, 43,
996  44, 45, 0, 0, 0, 0, 0, 46, 0, 0,
997  0, 61, 0, 0, 47, 0, 0, 48, 0, 49,
998  0, 0, 50, 0, 0, 0, 183, 184, 185, 186,
999  187, 188, 189, 51, 52, 53, 0, 0, 0, 41,
1000  0, 0, 54, 0, 0, 0, 0, 55, 56, 0,
1001  0, 57, 58, 59, 0, 0, 60, 259, 42, 0,
1002  0, 0, 0, 43, 44, 45, 0, 0, 0, 177,
1003  178, 46, 179, 180, 181, 61, 0, 0, 47, 0,
1004  0, 48, 0, 49, 0, 0, 50, 0, 0, 0,
1005  0, 191, 0, 0, 0, 0, 0, 51, 52, 53,
1006  0, 0, 0, 41, 0, 0, 54, 0, 0, 0,
1007  0, 55, 56, 0, 0, 57, 58, 59, 0, 0,
1008  60, 323, 42, 0, 0, 0, 0, 43, 44, 45,
1009  0, 0, 0, 0, 0, 46, 0, 0, 0, 61,
1010  0, 0, 47, 0, 0, 48, 0, 49, 0, 0,
1011  50, 0, 0, 0, 183, 184, 185, 186, 187, 188,
1012  189, 51, 52, 53, 177, 178, 41, 179, 180, 181,
1013  54, 0, 0, 0, 0, 55, 56, 0, 0, 57,
1014  58, 59, 0, 0, 60, 42, 0, 0, 0, 0,
1015  43, 44, 45, 0, 0, 0, 267, 0, 46, 0,
1016  0, 0, 0, 61, 0, 47, 0, 0, 48, 0,
1017  49, 177, 178, 50, 179, 180, 181, 0, 177, 178,
1018  0, 179, 180, 181, 51, 52, 53, 0, 0, 0,
1019  300, 177, 178, 54, 179, 180, 181, 0, 55, 56,
1020  305, 0, 57, 58, 59, 0, 0, 60, 0, 183,
1021  184, 185, 186, 187, 188, 189, 0, 0, 0, 0,
1022  0, 0, 0, 0, 0, 0, 61, 0, 0, 0,
1023  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1024  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1025  0, 0, 0, 0, 0, 0, 183, 184, 185, 186,
1026  187, 188, 189, 183, 184, 185, 186, 187, 188, 189,
1027  0, 0, 0, 0, 0, 0, 183, 184, 185, 186,
1028  187, 188, 189
1029 };
1030 
1031 #define yypact_value_is_default(yystate) \
1032  ((yystate) == (-177))
1033 
1034 #define yytable_value_is_error(yytable_value) \
1035  YYID (0)
1036 
1037 static const yytype_int16 yycheck[] =
1038 {
1039  12, 63, 42, 43, 73, 45, 182, 40, 38, 15,
1040  49, 9, 24, 26, 65, 191, 3, 4, 5, 6,
1041  7, 8, 9, 57, 190, 12, 35, 19, 20, 21,
1042  22, 106, 24, 108, 68, 57, 15, 59, 46, 47,
1043  91, 50, 208, 106, 16, 108, 106, 9, 108, 36,
1044  37, 64, 92, 106, 0, 108, 90, 106, 104, 108,
1045  100, 106, 106, 108, 108, 9, 64, 17, 18, 108,
1046  100, 25, 9, 113, 114, 108, 105, 253, 104, 66,
1047  9, 9, 25, 104, 71, 72, 73, 74, 75, 63,
1048  77, 78, 79, 80, 100, 101, 83, 84, 10, 11,
1049  9, 13, 14, 15, 49, 9, 39, 147, 9, 9,
1050  35, 98, 9, 100, 13, 14, 15, 88, 105, 98,
1051  99, 100, 101, 88, 300, 9, 104, 40, 105, 305,
1052  105, 104, 39, 9, 104, 104, 104, 177, 178, 179,
1053  180, 181, 103, 183, 184, 185, 186, 187, 188, 189,
1054  105, 104, 192, 104, 103, 195, 104, 197, 220, 17,
1055  52, 9, 104, 104, 104, 104, 104, 229, 237, 104,
1056  104, 3, 4, 5, 6, 7, 8, 9, 104, 9,
1057  12, 104, 104, 95, 96, 97, 98, 99, 100, 101,
1058  104, 60, 49, 104, 106, 105, 95, 96, 97, 98,
1059  99, 100, 101, 105, 36, 37, 104, 70, 10, 11,
1060  250, 13, 14, 15, 254, 105, 104, 70, 280, 15,
1061  9, 9, 9, 105, 264, 58, 9, 267, 268, 107,
1062  55, 9, 106, 108, 66, 95, 108, 9, 9, 71,
1063  72, 73, 74, 75, 105, 77, 78, 79, 80, 9,
1064  312, 83, 84, 27, 316, 31, 106, 32, 270, 3,
1065  4, 5, 6, 7, 8, 9, 98, 9, 12, 9,
1066  62, 41, 106, 105, 110, 3, 4, 5, 6, 7,
1067  8, 9, 28, 107, 12, 51, 92, 105, 61, 9,
1068  17, 44, 3, 95, 96, 97, 98, 99, 100, 101,
1069  105, 9, 93, 89, 106, 106, 45, 12, 9, 94,
1070  54, 32, 8, 204, 9, 195, 73, 269, 33, 295,
1071  256, 14, 66, 26, -1, -1, -1, 71, 72, 73,
1072  74, 75, -1, 77, 78, 79, 80, -1, 66, 83,
1073  84, 9, -1, 71, 72, 73, 74, 75, -1, 77,
1074  78, 79, 80, -1, 98, 83, 84, -1, -1, -1,
1075  28, 105, 30, 31, -1, 33, 34, 35, -1, -1,
1076  98, 10, 11, 41, 13, 14, 15, 105, -1, -1,
1077  48, -1, -1, 51, -1, 53, -1, -1, 56, -1,
1078  29, -1, -1, -1, -1, -1, -1, -1, -1, 67,
1079  68, 69, -1, -1, -1, 9, -1, -1, 76, -1,
1080  -1, -1, -1, 81, 82, -1, -1, 85, 86, 87,
1081  -1, -1, 90, 27, 28, -1, -1, -1, -1, 33,
1082  34, 35, -1, -1, -1, -1, -1, 41, -1, -1,
1083  -1, 109, -1, -1, 48, -1, -1, 51, -1, 53,
1084  -1, -1, 56, -1, -1, -1, 95, 96, 97, 98,
1085  99, 100, 101, 67, 68, 69, -1, -1, -1, 9,
1086  -1, -1, 76, -1, -1, -1, -1, 81, 82, -1,
1087  -1, 85, 86, 87, -1, -1, 90, 27, 28, -1,
1088  -1, -1, -1, 33, 34, 35, -1, -1, -1, 10,
1089  11, 41, 13, 14, 15, 109, -1, -1, 48, -1,
1090  -1, 51, -1, 53, -1, -1, 56, -1, -1, -1,
1091  -1, 32, -1, -1, -1, -1, -1, 67, 68, 69,
1092  -1, -1, -1, 9, -1, -1, 76, -1, -1, -1,
1093  -1, 81, 82, -1, -1, 85, 86, 87, -1, -1,
1094  90, 27, 28, -1, -1, -1, -1, 33, 34, 35,
1095  -1, -1, -1, -1, -1, 41, -1, -1, -1, 109,
1096  -1, -1, 48, -1, -1, 51, -1, 53, -1, -1,
1097  56, -1, -1, -1, 95, 96, 97, 98, 99, 100,
1098  101, 67, 68, 69, 10, 11, 9, 13, 14, 15,
1099  76, -1, -1, -1, -1, 81, 82, -1, -1, 85,
1100  86, 87, -1, -1, 90, 28, -1, -1, -1, -1,
1101  33, 34, 35, -1, -1, -1, 42, -1, 41, -1,
1102  -1, -1, -1, 109, -1, 48, -1, -1, 51, -1,
1103  53, 10, 11, 56, 13, 14, 15, -1, 10, 11,
1104  -1, 13, 14, 15, 67, 68, 69, -1, -1, -1,
1105  29, 10, 11, 76, 13, 14, 15, -1, 81, 82,
1106  32, -1, 85, 86, 87, -1, -1, 90, -1, 95,
1107  96, 97, 98, 99, 100, 101, -1, -1, -1, -1,
1108  -1, -1, -1, -1, -1, -1, 109, -1, -1, -1,
1109  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1110  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1111  -1, -1, -1, -1, -1, -1, 95, 96, 97, 98,
1112  99, 100, 101, 95, 96, 97, 98, 99, 100, 101,
1113  -1, -1, -1, -1, -1, -1, 95, 96, 97, 98,
1114  99, 100, 101
1115 };
1116 
1117 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1118  symbol of state STATE-NUM. */
1119 static const yytype_uint8 yystos[] =
1120 {
1121  0, 16, 112, 180, 9, 0, 104, 105, 9, 172,
1122  173, 17, 18, 106, 108, 19, 20, 21, 22, 24,
1123  171, 171, 25, 172, 9, 174, 175, 171, 64, 174,
1124  176, 177, 178, 179, 104, 65, 91, 26, 178, 9,
1125  9, 9, 28, 33, 34, 35, 41, 48, 51, 53,
1126  56, 67, 68, 69, 76, 81, 82, 85, 86, 87,
1127  90, 109, 113, 114, 118, 119, 120, 133, 134, 135,
1128  139, 140, 141, 142, 143, 144, 145, 146, 150, 151,
1129  152, 153, 154, 155, 156, 157, 164, 168, 169, 170,
1130  25, 104, 63, 3, 4, 5, 6, 7, 8, 9,
1131  12, 66, 71, 72, 73, 74, 75, 77, 78, 79,
1132  80, 83, 84, 98, 105, 115, 116, 115, 36, 37,
1133  100, 115, 125, 126, 127, 9, 49, 9, 39, 57,
1134  59, 166, 9, 9, 9, 133, 88, 88, 9, 27,
1135  113, 104, 105, 104, 50, 133, 104, 40, 128, 138,
1136  104, 104, 128, 138, 104, 104, 104, 104, 104, 104,
1137  104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
1138  133, 115, 103, 115, 103, 115, 115, 10, 11, 13,
1139  14, 15, 29, 95, 96, 97, 98, 99, 100, 101,
1140  105, 32, 105, 105, 49, 108, 39, 17, 9, 52,
1141  9, 9, 60, 167, 49, 105, 115, 124, 105, 54,
1142  115, 104, 70, 70, 106, 115, 115, 115, 115, 115,
1143  114, 115, 115, 115, 115, 115, 115, 115, 124, 114,
1144  115, 38, 100, 9, 123, 125, 9, 122, 115, 9,
1145  136, 137, 105, 58, 9, 121, 123, 107, 117, 106,
1146  108, 124, 55, 30, 31, 147, 148, 149, 106, 27,
1147  106, 9, 106, 108, 40, 108, 128, 42, 95, 108,
1148  9, 158, 159, 9, 105, 106, 108, 115, 106, 9,
1149  114, 115, 147, 27, 32, 106, 9, 9, 41, 129,
1150  115, 115, 136, 171, 106, 108, 62, 106, 110, 107,
1151  29, 28, 51, 92, 130, 32, 105, 160, 61, 163,
1152  158, 9, 114, 17, 44, 132, 114, 3, 89, 161,
1153  105, 93, 45, 27, 106, 12, 162, 9, 165, 94,
1154  9, 32, 8, 106, 108, 46, 47, 131, 9
1155 };
1156 
1157 #define yyerrok (yyerrstatus = 0)
1158 #define yyclearin (yychar = YYEMPTY)
1159 #define YYEMPTY (-2)
1160 #define YYEOF 0
1161 
1162 #define YYACCEPT goto yyacceptlab
1163 #define YYABORT goto yyabortlab
1164 #define YYERROR goto yyerrorlab
1165 
1166 
1167 /* Like YYERROR except do call yyerror. This remains here temporarily
1168  to ease the transition to the new meaning of YYERROR, for GCC.
1169  Once GCC version 2 has supplanted version 1, this can go. However,
1170  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1171  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1172  discussed. */
1173 
1174 #define YYFAIL goto yyerrlab
1175 #if defined YYFAIL
1176  /* This is here to suppress warnings from the GCC cpp's
1177  -Wunused-macros. Normally we don't worry about that warning, but
1178  some users do, and we want to make it easy for users to remove
1179  YYFAIL uses, which will produce warnings from Bison 2.5. */
1180 #endif
1181 
1182 #define YYRECOVERING() (!!yyerrstatus)
1183 
1184 #define YYBACKUP(Token, Value) \
1185 do \
1186  if (yychar == YYEMPTY && yylen == 1) \
1187  { \
1188  yychar = (Token); \
1189  yylval = (Value); \
1190  YYPOPSTACK (1); \
1191  goto yybackup; \
1192  } \
1193  else \
1194  { \
1195  yyerror (YY_("syntax error: cannot back up")); \
1196  YYERROR; \
1197  } \
1198 while (YYID (0))
1199 
1200 
1201 #define YYTERROR 1
1202 #define YYERRCODE 256
1203 
1204 
1205 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1206  If N is 0, then set CURRENT to the empty location which ends
1207  the previous symbol: RHS[0] (always defined). */
1208 
1209 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1210 #ifndef YYLLOC_DEFAULT
1211 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1212  do \
1213  if (YYID (N)) \
1214  { \
1215  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1216  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1217  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1218  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1219  } \
1220  else \
1221  { \
1222  (Current).first_line = (Current).last_line = \
1223  YYRHSLOC (Rhs, 0).last_line; \
1224  (Current).first_column = (Current).last_column = \
1225  YYRHSLOC (Rhs, 0).last_column; \
1226  } \
1227  while (YYID (0))
1228 #endif
1229 
1230 
1231 /* This macro is provided for backward compatibility. */
1232 
1233 #ifndef YY_LOCATION_PRINT
1234 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1235 #endif
1236 
1237 
1238 /* YYLEX -- calling `yylex' with the right arguments. */
1239 
1240 #ifdef YYLEX_PARAM
1241 # define YYLEX yylex (YYLEX_PARAM)
1242 #else
1243 # define YYLEX yylex ()
1244 #endif
1245 
1246 /* Enable debugging if requested. */
1247 #if YYDEBUG
1248 
1249 # ifndef YYFPRINTF
1250 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1251 # define YYFPRINTF fprintf
1252 # endif
1253 
1254 # define YYDPRINTF(Args) \
1255 do { \
1256  if (yydebug) \
1257  YYFPRINTF Args; \
1258 } while (YYID (0))
1259 
1260 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1261 do { \
1262  if (yydebug) \
1263  { \
1264  YYFPRINTF (stderr, "%s ", Title); \
1265  yy_symbol_print (stderr, \
1266  Type, Value); \
1267  YYFPRINTF (stderr, "\n"); \
1268  } \
1269 } while (YYID (0))
1270 
1271 
1272 /*--------------------------------.
1273 | Print this symbol on YYOUTPUT. |
1274 `--------------------------------*/
1275 
1276 /*ARGSUSED*/
1277 #if (defined __STDC__ || defined __C99__FUNC__ \
1278  || defined __cplusplus || defined _MSC_VER)
1279 static void
1280 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1281 #else
1282 static void
1283 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1284  FILE *yyoutput;
1285  int yytype;
1286  YYSTYPE const * const yyvaluep;
1287 #endif
1288 {
1289  if (!yyvaluep)
1290  return;
1291 # ifdef YYPRINT
1292  if (yytype < YYNTOKENS)
1293  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1294 # else
1295  YYUSE (yyoutput);
1296 # endif
1297  switch (yytype)
1298  {
1299  default:
1300  break;
1301  }
1302 }
1303 
1304 
1305 /*--------------------------------.
1306 | Print this symbol on YYOUTPUT. |
1307 `--------------------------------*/
1308 
1309 #if (defined __STDC__ || defined __C99__FUNC__ \
1310  || defined __cplusplus || defined _MSC_VER)
1311 static void
1312 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1313 #else
1314 static void
1315 yy_symbol_print (yyoutput, yytype, yyvaluep)
1316  FILE *yyoutput;
1317  int yytype;
1318  YYSTYPE const * const yyvaluep;
1319 #endif
1320 {
1321  if (yytype < YYNTOKENS)
1322  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1323  else
1324  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1325 
1326  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1327  YYFPRINTF (yyoutput, ")");
1328 }
1329 
1330 /*------------------------------------------------------------------.
1331 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1332 | TOP (included). |
1333 `------------------------------------------------------------------*/
1334 
1335 #if (defined __STDC__ || defined __C99__FUNC__ \
1336  || defined __cplusplus || defined _MSC_VER)
1337 static void
1338 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1339 #else
1340 static void
1341 yy_stack_print (yybottom, yytop)
1342  yytype_int16 *yybottom;
1343  yytype_int16 *yytop;
1344 #endif
1345 {
1346  YYFPRINTF (stderr, "Stack now");
1347  for (; yybottom <= yytop; yybottom++)
1348  {
1349  int yybot = *yybottom;
1350  YYFPRINTF (stderr, " %d", yybot);
1351  }
1352  YYFPRINTF (stderr, "\n");
1353 }
1354 
1355 # define YY_STACK_PRINT(Bottom, Top) \
1356 do { \
1357  if (yydebug) \
1358  yy_stack_print ((Bottom), (Top)); \
1359 } while (YYID (0))
1360 
1361 
1362 /*------------------------------------------------.
1363 | Report that the YYRULE is going to be reduced. |
1364 `------------------------------------------------*/
1365 
1366 #if (defined __STDC__ || defined __C99__FUNC__ \
1367  || defined __cplusplus || defined _MSC_VER)
1368 static void
1369 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1370 #else
1371 static void
1372 yy_reduce_print (yyvsp, yyrule)
1373  YYSTYPE *yyvsp;
1374  int yyrule;
1375 #endif
1376 {
1377  int yynrhs = yyr2[yyrule];
1378  int yyi;
1379  unsigned long int yylno = yyrline[yyrule];
1380  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1381  yyrule - 1, yylno);
1382  /* The symbols being reduced. */
1383  for (yyi = 0; yyi < yynrhs; yyi++)
1384  {
1385  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1386  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1387  &(yyvsp[(yyi + 1) - (yynrhs)])
1388  );
1389  YYFPRINTF (stderr, "\n");
1390  }
1391 }
1392 
1393 # define YY_REDUCE_PRINT(Rule) \
1394 do { \
1395  if (yydebug) \
1396  yy_reduce_print (yyvsp, Rule); \
1397 } while (YYID (0))
1398 
1399 /* Nonzero means print parse trace. It is left uninitialized so that
1400  multiple parsers can coexist. */
1401 int yydebug;
1402 #else /* !YYDEBUG */
1403 # define YYDPRINTF(Args)
1404 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1405 # define YY_STACK_PRINT(Bottom, Top)
1406 # define YY_REDUCE_PRINT(Rule)
1407 #endif /* !YYDEBUG */
1408 
1409 
1410 /* YYINITDEPTH -- initial size of the parser's stacks. */
1411 #ifndef YYINITDEPTH
1412 # define YYINITDEPTH 200
1413 #endif
1414 
1415 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1416  if the built-in stack extension method is used).
1417 
1418  Do not make this value too large; the results are undefined if
1419  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1420  evaluated with infinite-precision integer arithmetic. */
1421 
1422 #ifndef YYMAXDEPTH
1423 # define YYMAXDEPTH 10000
1424 #endif
1425 
1426 
1427 #if YYERROR_VERBOSE
1428 
1429 # ifndef yystrlen
1430 # if defined __GLIBC__ && defined _STRING_H
1431 # define yystrlen strlen
1432 # else
1433 /* Return the length of YYSTR. */
1434 #if (defined __STDC__ || defined __C99__FUNC__ \
1435  || defined __cplusplus || defined _MSC_VER)
1436 static YYSIZE_T
1437 yystrlen (const char *yystr)
1438 #else
1439 static YYSIZE_T
1440 yystrlen (yystr)
1441  const char *yystr;
1442 #endif
1443 {
1444  YYSIZE_T yylen;
1445  for (yylen = 0; yystr[yylen]; yylen++)
1446  continue;
1447  return yylen;
1448 }
1449 # endif
1450 # endif
1451 
1452 # ifndef yystpcpy
1453 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1454 # define yystpcpy stpcpy
1455 # else
1456 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1457  YYDEST. */
1458 #if (defined __STDC__ || defined __C99__FUNC__ \
1459  || defined __cplusplus || defined _MSC_VER)
1460 static char *
1461 yystpcpy (char *yydest, const char *yysrc)
1462 #else
1463 static char *
1464 yystpcpy (yydest, yysrc)
1465  char *yydest;
1466  const char *yysrc;
1467 #endif
1468 {
1469  char *yyd = yydest;
1470  const char *yys = yysrc;
1471 
1472  while ((*yyd++ = *yys++) != '\0')
1473  continue;
1474 
1475  return yyd - 1;
1476 }
1477 # endif
1478 # endif
1479 
1480 # ifndef yytnamerr
1481 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1482  quotes and backslashes, so that it's suitable for yyerror. The
1483  heuristic is that double-quoting is unnecessary unless the string
1484  contains an apostrophe, a comma, or backslash (other than
1485  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1486  null, do not copy; instead, return the length of what the result
1487  would have been. */
1488 static YYSIZE_T
1489 yytnamerr (char *yyres, const char *yystr)
1490 {
1491  if (*yystr == '"')
1492  {
1493  YYSIZE_T yyn = 0;
1494  char const *yyp = yystr;
1495 
1496  for (;;)
1497  switch (*++yyp)
1498  {
1499  case '\'':
1500  case ',':
1501  goto do_not_strip_quotes;
1502 
1503  case '\\':
1504  if (*++yyp != '\\')
1505  goto do_not_strip_quotes;
1506  /* Fall through. */
1507  default:
1508  if (yyres)
1509  yyres[yyn] = *yyp;
1510  yyn++;
1511  break;
1512 
1513  case '"':
1514  if (yyres)
1515  yyres[yyn] = '\0';
1516  return yyn;
1517  }
1518  do_not_strip_quotes: ;
1519  }
1520 
1521  if (! yyres)
1522  return yystrlen (yystr);
1523 
1524  return yystpcpy (yyres, yystr) - yyres;
1525 }
1526 # endif
1527 
1528 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1529  about the unexpected token YYTOKEN for the state stack whose top is
1530  YYSSP.
1531 
1532  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1533  not large enough to hold the message. In that case, also set
1534  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1535  required number of bytes is too large to store. */
1536 static int
1537 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1538  yytype_int16 *yyssp, int yytoken)
1539 {
1540  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1541  YYSIZE_T yysize = yysize0;
1542  YYSIZE_T yysize1;
1543  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1544  /* Internationalized format string. */
1545  const char *yyformat = 0;
1546  /* Arguments of yyformat. */
1547  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1548  /* Number of reported tokens (one for the "unexpected", one per
1549  "expected"). */
1550  int yycount = 0;
1551 
1552  /* There are many possibilities here to consider:
1553  - Assume YYFAIL is not used. It's too flawed to consider. See
1554  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1555  for details. YYERROR is fine as it does not invoke this
1556  function.
1557  - If this state is a consistent state with a default action, then
1558  the only way this function was invoked is if the default action
1559  is an error action. In that case, don't check for expected
1560  tokens because there are none.
1561  - The only way there can be no lookahead present (in yychar) is if
1562  this state is a consistent state with a default action. Thus,
1563  detecting the absence of a lookahead is sufficient to determine
1564  that there is no unexpected or expected token to report. In that
1565  case, just report a simple "syntax error".
1566  - Don't assume there isn't a lookahead just because this state is a
1567  consistent state with a default action. There might have been a
1568  previous inconsistent state, consistent state with a non-default
1569  action, or user semantic action that manipulated yychar.
1570  - Of course, the expected token list depends on states to have
1571  correct lookahead information, and it depends on the parser not
1572  to perform extra reductions after fetching a lookahead from the
1573  scanner and before detecting a syntax error. Thus, state merging
1574  (from LALR or IELR) and default reductions corrupt the expected
1575  token list. However, the list is correct for canonical LR with
1576  one exception: it will still contain any token that will not be
1577  accepted due to an error action in a later state.
1578  */
1579  if (yytoken != YYEMPTY)
1580  {
1581  int yyn = yypact[*yyssp];
1582  yyarg[yycount++] = yytname[yytoken];
1583  if (!yypact_value_is_default (yyn))
1584  {
1585  /* Start YYX at -YYN if negative to avoid negative indexes in
1586  YYCHECK. In other words, skip the first -YYN actions for
1587  this state because they are default actions. */
1588  int yyxbegin = yyn < 0 ? -yyn : 0;
1589  /* Stay within bounds of both yycheck and yytname. */
1590  int yychecklim = YYLAST - yyn + 1;
1591  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1592  int yyx;
1593 
1594  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1595  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1596  && !yytable_value_is_error (yytable[yyx + yyn]))
1597  {
1598  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1599  {
1600  yycount = 1;
1601  yysize = yysize0;
1602  break;
1603  }
1604  yyarg[yycount++] = yytname[yyx];
1605  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1606  if (! (yysize <= yysize1
1607  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1608  return 2;
1609  yysize = yysize1;
1610  }
1611  }
1612  }
1613 
1614  switch (yycount)
1615  {
1616 # define YYCASE_(N, S) \
1617  case N: \
1618  yyformat = S; \
1619  break
1620  YYCASE_(0, YY_("syntax error"));
1621  YYCASE_(1, YY_("syntax error, unexpected %s"));
1622  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1623  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1624  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1625  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1626 # undef YYCASE_
1627  }
1628 
1629  yysize1 = yysize + yystrlen (yyformat);
1630  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1631  return 2;
1632  yysize = yysize1;
1633 
1634  if (*yymsg_alloc < yysize)
1635  {
1636  *yymsg_alloc = 2 * yysize;
1637  if (! (yysize <= *yymsg_alloc
1638  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1639  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1640  return 1;
1641  }
1642 
1643  /* Avoid sprintf, as that infringes on the user's name space.
1644  Don't have undefined behavior even if the translation
1645  produced a string with the wrong number of "%s"s. */
1646  {
1647  char *yyp = *yymsg;
1648  int yyi = 0;
1649  while ((*yyp = *yyformat) != '\0')
1650  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1651  {
1652  yyp += yytnamerr (yyp, yyarg[yyi++]);
1653  yyformat += 2;
1654  }
1655  else
1656  {
1657  yyp++;
1658  yyformat++;
1659  }
1660  }
1661  return 0;
1662 }
1663 #endif /* YYERROR_VERBOSE */
1664 
1665 /*-----------------------------------------------.
1666 | Release the memory associated to this symbol. |
1667 `-----------------------------------------------*/
1668 
1669 /*ARGSUSED*/
1670 #if (defined __STDC__ || defined __C99__FUNC__ \
1671  || defined __cplusplus || defined _MSC_VER)
1672 static void
1673 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1674 #else
1675 static void
1676 yydestruct (yymsg, yytype, yyvaluep)
1677  const char *yymsg;
1678  int yytype;
1679  YYSTYPE *yyvaluep;
1680 #endif
1681 {
1682  YYUSE (yyvaluep);
1683 
1684  if (!yymsg)
1685  yymsg = "Deleting";
1686  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1687 
1688  switch (yytype)
1689  {
1690 
1691  default:
1692  break;
1693  }
1694 }
1695 
1696 
1697 /* Prevent warnings from -Wmissing-prototypes. */
1698 #ifdef YYPARSE_PARAM
1699 #if defined __STDC__ || defined __cplusplus
1700 UNIV_INTERN int yyparse (void *YYPARSE_PARAM);
1701 #else
1702 UNIV_INTERN int yyparse ();
1703 #endif
1704 #else /* ! YYPARSE_PARAM */
1705 #if defined __STDC__ || defined __cplusplus
1706 UNIV_INTERN int yyparse (void);
1707 #else
1708 UNIV_INTERN int yyparse ();
1709 #endif
1710 #endif /* ! YYPARSE_PARAM */
1711 
1712 
1713 /* The lookahead symbol. */
1714 static int yychar;
1715 
1716 /* The semantic value of the lookahead symbol. */
1717 UNIV_INTERN YYSTYPE yylval;
1718 
1719 /* Number of syntax errors so far. */
1720 static int yynerrs;
1721 
1722 
1723 /*----------.
1724 | yyparse. |
1725 `----------*/
1726 
1727 #ifdef YYPARSE_PARAM
1728 #if (defined __STDC__ || defined __C99__FUNC__ \
1729  || defined __cplusplus || defined _MSC_VER)
1730 int
1731 yyparse (void *YYPARSE_PARAM)
1732 #else
1733 int
1734 yyparse (YYPARSE_PARAM)
1735  void *YYPARSE_PARAM;
1736 #endif
1737 #else /* ! YYPARSE_PARAM */
1738 #if (defined __STDC__ || defined __C99__FUNC__ \
1739  || defined __cplusplus || defined _MSC_VER)
1740 int
1741 yyparse (void)
1742 #else
1743 int
1744 yyparse ()
1745 
1746 #endif
1747 #endif
1748 {
1749  int yystate;
1750  /* Number of tokens to shift before error messages enabled. */
1751  int yyerrstatus;
1752 
1753  /* The stacks and their tools:
1754  `yyss': related to states.
1755  `yyvs': related to semantic values.
1756 
1757  Refer to the stacks thru separate pointers, to allow yyoverflow
1758  to reallocate them elsewhere. */
1759 
1760  /* The state stack. */
1761  yytype_int16 yyssa[YYINITDEPTH];
1762  yytype_int16 *yyss;
1763  yytype_int16 *yyssp;
1764 
1765  /* The semantic value stack. */
1766  YYSTYPE yyvsa[YYINITDEPTH];
1767  YYSTYPE *yyvs;
1768  YYSTYPE *yyvsp;
1769 
1770  YYSIZE_T yystacksize;
1771 
1772  int yyn;
1773  int yyresult;
1774  /* Lookahead token as an internal (translated) token number. */
1775  int yytoken;
1776  /* The variables used to return semantic value and location from the
1777  action routines. */
1778  YYSTYPE yyval;
1779 
1780 #if YYERROR_VERBOSE
1781  /* Buffer for error messages, and its allocated size. */
1782  char yymsgbuf[128];
1783  char *yymsg = yymsgbuf;
1784  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1785 #endif
1786 
1787 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1788 
1789  /* The number of symbols on the RHS of the reduced rule.
1790  Keep to zero when no symbol should be popped. */
1791  int yylen = 0;
1792 
1793  yytoken = 0;
1794  yyss = yyssa;
1795  yyvs = yyvsa;
1796  yystacksize = YYINITDEPTH;
1797 
1798  YYDPRINTF ((stderr, "Starting parse\n"));
1799 
1800  yystate = 0;
1801  yyerrstatus = 0;
1802  yynerrs = 0;
1803  yychar = YYEMPTY; /* Cause a token to be read. */
1804 
1805  /* Initialize stack pointers.
1806  Waste one element of value and location stack
1807  so that they stay on the same level as the state stack.
1808  The wasted elements are never initialized. */
1809  yyssp = yyss;
1810  yyvsp = yyvs;
1811 
1812  goto yysetstate;
1813 
1814 /*------------------------------------------------------------.
1815 | yynewstate -- Push a new state, which is found in yystate. |
1816 `------------------------------------------------------------*/
1817  yynewstate:
1818  /* In all cases, when you get here, the value and location stacks
1819  have just been pushed. So pushing a state here evens the stacks. */
1820  yyssp++;
1821 
1822  yysetstate:
1823  *yyssp = yystate;
1824 
1825  if (yyss + yystacksize - 1 <= yyssp)
1826  {
1827  /* Get the current used size of the three stacks, in elements. */
1828  YYSIZE_T yysize = yyssp - yyss + 1;
1829 
1830 #ifdef yyoverflow
1831  {
1832  /* Give user a chance to reallocate the stack. Use copies of
1833  these so that the &'s don't force the real ones into
1834  memory. */
1835  YYSTYPE *yyvs1 = yyvs;
1836  yytype_int16 *yyss1 = yyss;
1837 
1838  /* Each stack pointer address is followed by the size of the
1839  data in use in that stack, in bytes. This used to be a
1840  conditional around just the two extra args, but that might
1841  be undefined if yyoverflow is a macro. */
1842  yyoverflow (YY_("memory exhausted"),
1843  &yyss1, yysize * sizeof (*yyssp),
1844  &yyvs1, yysize * sizeof (*yyvsp),
1845  &yystacksize);
1846 
1847  yyss = yyss1;
1848  yyvs = yyvs1;
1849  }
1850 #else /* no yyoverflow */
1851 # ifndef YYSTACK_RELOCATE
1852  goto yyexhaustedlab;
1853 # else
1854  /* Extend the stack our own way. */
1855  if (YYMAXDEPTH <= yystacksize)
1856  goto yyexhaustedlab;
1857  yystacksize *= 2;
1858  if (YYMAXDEPTH < yystacksize)
1859  yystacksize = YYMAXDEPTH;
1860 
1861  {
1862  yytype_int16 *yyss1 = yyss;
1863  union yyalloc *yyptr =
1864  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1865  if (! yyptr)
1866  goto yyexhaustedlab;
1867  YYSTACK_RELOCATE (yyss_alloc, yyss);
1868  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1869 # undef YYSTACK_RELOCATE
1870  if (yyss1 != yyssa)
1871  YYSTACK_FREE (yyss1);
1872  }
1873 # endif
1874 #endif /* no yyoverflow */
1875 
1876  yyssp = yyss + yysize - 1;
1877  yyvsp = yyvs + yysize - 1;
1878 
1879  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1880  (unsigned long int) yystacksize));
1881 
1882  if (yyss + yystacksize - 1 <= yyssp)
1883  YYABORT;
1884  }
1885 
1886  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1887 
1888  if (yystate == YYFINAL)
1889  YYACCEPT;
1890 
1891  goto yybackup;
1892 
1893 /*-----------.
1894 | yybackup. |
1895 `-----------*/
1896 yybackup:
1897 
1898  /* Do appropriate processing given the current state. Read a
1899  lookahead token if we need one and don't already have one. */
1900 
1901  /* First try to decide what to do without reference to lookahead token. */
1902  yyn = yypact[yystate];
1903  if (yypact_value_is_default (yyn))
1904  goto yydefault;
1905 
1906  /* Not known => get a lookahead token if don't already have one. */
1907 
1908  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1909  if (yychar == YYEMPTY)
1910  {
1911  YYDPRINTF ((stderr, "Reading a token: "));
1912  yychar = YYLEX;
1913  }
1914 
1915  if (yychar <= YYEOF)
1916  {
1917  yychar = yytoken = YYEOF;
1918  YYDPRINTF ((stderr, "Now at end of input.\n"));
1919  }
1920  else
1921  {
1922  yytoken = YYTRANSLATE (yychar);
1923  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1924  }
1925 
1926  /* If the proper action on seeing token YYTOKEN is to reduce or to
1927  detect an error, take that action. */
1928  yyn += yytoken;
1929  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1930  goto yydefault;
1931  yyn = yytable[yyn];
1932  if (yyn <= 0)
1933  {
1934  if (yytable_value_is_error (yyn))
1935  goto yyerrlab;
1936  yyn = -yyn;
1937  goto yyreduce;
1938  }
1939 
1940  /* Count tokens shifted since error; after three, turn off error
1941  status. */
1942  if (yyerrstatus)
1943  yyerrstatus--;
1944 
1945  /* Shift the lookahead token. */
1946  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1947 
1948  /* Discard the shifted token. */
1949  yychar = YYEMPTY;
1950 
1951  yystate = yyn;
1952  *++yyvsp = yylval;
1953 
1954  goto yynewstate;
1955 
1956 
1957 /*-----------------------------------------------------------.
1958 | yydefault -- do the default action for the current state. |
1959 `-----------------------------------------------------------*/
1960 yydefault:
1961  yyn = yydefact[yystate];
1962  if (yyn == 0)
1963  goto yyerrlab;
1964  goto yyreduce;
1965 
1966 
1967 /*-----------------------------.
1968 | yyreduce -- Do a reduction. |
1969 `-----------------------------*/
1970 yyreduce:
1971  /* yyn is the number of a rule to reduce with. */
1972  yylen = yyr2[yyn];
1973 
1974  /* If YYLEN is nonzero, implement the default value of the action:
1975  `$$ = $1'.
1976 
1977  Otherwise, the following line sets YYVAL to garbage.
1978  This behavior is undocumented and Bison
1979  users should not rely upon it. Assigning to YYVAL
1980  unconditionally makes the parser a bit smaller, and it avoids a
1981  GCC warning that YYVAL may be used uninitialized. */
1982  yyval = yyvsp[1-yylen];
1983 
1984 
1985  YY_REDUCE_PRINT (yyn);
1986  switch (yyn)
1987  {
1988  case 25:
1989 
1990 /* Line 1806 of yacc.c */
1991 #line 181 "plugin/innobase/pars/pars0grm.y"
1992  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
1993  break;
1994 
1995  case 26:
1996 
1997 /* Line 1806 of yacc.c */
1998 #line 183 "plugin/innobase/pars/pars0grm.y"
1999  { (yyval) = que_node_list_add_last((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)])); }
2000  break;
2001 
2002  case 27:
2003 
2004 /* Line 1806 of yacc.c */
2005 #line 187 "plugin/innobase/pars/pars0grm.y"
2006  { (yyval) = (yyvsp[(1) - (1)]);}
2007  break;
2008 
2009  case 28:
2010 
2011 /* Line 1806 of yacc.c */
2012 #line 189 "plugin/innobase/pars/pars0grm.y"
2013  { (yyval) = pars_func((yyvsp[(1) - (4)]), (yyvsp[(3) - (4)])); }
2014  break;
2015 
2016  case 29:
2017 
2018 /* Line 1806 of yacc.c */
2019 #line 190 "plugin/innobase/pars/pars0grm.y"
2020  { (yyval) = (yyvsp[(1) - (1)]);}
2021  break;
2022 
2023  case 30:
2024 
2025 /* Line 1806 of yacc.c */
2026 #line 191 "plugin/innobase/pars/pars0grm.y"
2027  { (yyval) = (yyvsp[(1) - (1)]);}
2028  break;
2029 
2030  case 31:
2031 
2032 /* Line 1806 of yacc.c */
2033 #line 192 "plugin/innobase/pars/pars0grm.y"
2034  { (yyval) = (yyvsp[(1) - (1)]);}
2035  break;
2036 
2037  case 32:
2038 
2039 /* Line 1806 of yacc.c */
2040 #line 193 "plugin/innobase/pars/pars0grm.y"
2041  { (yyval) = (yyvsp[(1) - (1)]);}
2042  break;
2043 
2044  case 33:
2045 
2046 /* Line 1806 of yacc.c */
2047 #line 194 "plugin/innobase/pars/pars0grm.y"
2048  { (yyval) = (yyvsp[(1) - (1)]);}
2049  break;
2050 
2051  case 34:
2052 
2053 /* Line 1806 of yacc.c */
2054 #line 195 "plugin/innobase/pars/pars0grm.y"
2055  { (yyval) = (yyvsp[(1) - (1)]);}
2056  break;
2057 
2058  case 35:
2059 
2060 /* Line 1806 of yacc.c */
2061 #line 196 "plugin/innobase/pars/pars0grm.y"
2062  { (yyval) = (yyvsp[(1) - (1)]);}
2063  break;
2064 
2065  case 36:
2066 
2067 /* Line 1806 of yacc.c */
2068 #line 197 "plugin/innobase/pars/pars0grm.y"
2069  { (yyval) = pars_op('+', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2070  break;
2071 
2072  case 37:
2073 
2074 /* Line 1806 of yacc.c */
2075 #line 198 "plugin/innobase/pars/pars0grm.y"
2076  { (yyval) = pars_op('-', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2077  break;
2078 
2079  case 38:
2080 
2081 /* Line 1806 of yacc.c */
2082 #line 199 "plugin/innobase/pars/pars0grm.y"
2083  { (yyval) = pars_op('*', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2084  break;
2085 
2086  case 39:
2087 
2088 /* Line 1806 of yacc.c */
2089 #line 200 "plugin/innobase/pars/pars0grm.y"
2090  { (yyval) = pars_op('/', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2091  break;
2092 
2093  case 40:
2094 
2095 /* Line 1806 of yacc.c */
2096 #line 201 "plugin/innobase/pars/pars0grm.y"
2097  { (yyval) = pars_op('-', (yyvsp[(2) - (2)]), NULL); }
2098  break;
2099 
2100  case 41:
2101 
2102 /* Line 1806 of yacc.c */
2103 #line 202 "plugin/innobase/pars/pars0grm.y"
2104  { (yyval) = (yyvsp[(2) - (3)]); }
2105  break;
2106 
2107  case 42:
2108 
2109 /* Line 1806 of yacc.c */
2110 #line 203 "plugin/innobase/pars/pars0grm.y"
2111  { (yyval) = pars_op('=', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2112  break;
2113 
2114  case 43:
2115 
2116 /* Line 1806 of yacc.c */
2117 #line 204 "plugin/innobase/pars/pars0grm.y"
2118  { (yyval) = pars_op('<', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2119  break;
2120 
2121  case 44:
2122 
2123 /* Line 1806 of yacc.c */
2124 #line 205 "plugin/innobase/pars/pars0grm.y"
2125  { (yyval) = pars_op('>', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2126  break;
2127 
2128  case 45:
2129 
2130 /* Line 1806 of yacc.c */
2131 #line 206 "plugin/innobase/pars/pars0grm.y"
2132  { (yyval) = pars_op(PARS_GE_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2133  break;
2134 
2135  case 46:
2136 
2137 /* Line 1806 of yacc.c */
2138 #line 207 "plugin/innobase/pars/pars0grm.y"
2139  { (yyval) = pars_op(PARS_LE_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2140  break;
2141 
2142  case 47:
2143 
2144 /* Line 1806 of yacc.c */
2145 #line 208 "plugin/innobase/pars/pars0grm.y"
2146  { (yyval) = pars_op(PARS_NE_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2147  break;
2148 
2149  case 48:
2150 
2151 /* Line 1806 of yacc.c */
2152 #line 209 "plugin/innobase/pars/pars0grm.y"
2153  { (yyval) = pars_op(PARS_AND_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2154  break;
2155 
2156  case 49:
2157 
2158 /* Line 1806 of yacc.c */
2159 #line 210 "plugin/innobase/pars/pars0grm.y"
2160  { (yyval) = pars_op(PARS_OR_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2161  break;
2162 
2163  case 50:
2164 
2165 /* Line 1806 of yacc.c */
2166 #line 211 "plugin/innobase/pars/pars0grm.y"
2167  { (yyval) = pars_op(PARS_NOT_TOKEN, (yyvsp[(2) - (2)]), NULL); }
2168  break;
2169 
2170  case 51:
2171 
2172 /* Line 1806 of yacc.c */
2173 #line 213 "plugin/innobase/pars/pars0grm.y"
2174  { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[(1) - (3)]), NULL); }
2175  break;
2176 
2177  case 52:
2178 
2179 /* Line 1806 of yacc.c */
2180 #line 215 "plugin/innobase/pars/pars0grm.y"
2181  { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[(1) - (3)]), NULL); }
2182  break;
2183 
2184  case 53:
2185 
2186 /* Line 1806 of yacc.c */
2187 #line 219 "plugin/innobase/pars/pars0grm.y"
2188  { (yyval) = &pars_to_char_token; }
2189  break;
2190 
2191  case 54:
2192 
2193 /* Line 1806 of yacc.c */
2194 #line 220 "plugin/innobase/pars/pars0grm.y"
2195  { (yyval) = &pars_to_number_token; }
2196  break;
2197 
2198  case 55:
2199 
2200 /* Line 1806 of yacc.c */
2201 #line 221 "plugin/innobase/pars/pars0grm.y"
2202  { (yyval) = &pars_to_binary_token; }
2203  break;
2204 
2205  case 56:
2206 
2207 /* Line 1806 of yacc.c */
2208 #line 223 "plugin/innobase/pars/pars0grm.y"
2209  { (yyval) = &pars_binary_to_number_token; }
2210  break;
2211 
2212  case 57:
2213 
2214 /* Line 1806 of yacc.c */
2215 #line 224 "plugin/innobase/pars/pars0grm.y"
2216  { (yyval) = &pars_substr_token; }
2217  break;
2218 
2219  case 58:
2220 
2221 /* Line 1806 of yacc.c */
2222 #line 225 "plugin/innobase/pars/pars0grm.y"
2223  { (yyval) = &pars_concat_token; }
2224  break;
2225 
2226  case 59:
2227 
2228 /* Line 1806 of yacc.c */
2229 #line 226 "plugin/innobase/pars/pars0grm.y"
2230  { (yyval) = &pars_instr_token; }
2231  break;
2232 
2233  case 60:
2234 
2235 /* Line 1806 of yacc.c */
2236 #line 227 "plugin/innobase/pars/pars0grm.y"
2237  { (yyval) = &pars_length_token; }
2238  break;
2239 
2240  case 61:
2241 
2242 /* Line 1806 of yacc.c */
2243 #line 228 "plugin/innobase/pars/pars0grm.y"
2244  { (yyval) = &pars_sysdate_token; }
2245  break;
2246 
2247  case 62:
2248 
2249 /* Line 1806 of yacc.c */
2250 #line 229 "plugin/innobase/pars/pars0grm.y"
2251  { (yyval) = &pars_rnd_token; }
2252  break;
2253 
2254  case 63:
2255 
2256 /* Line 1806 of yacc.c */
2257 #line 230 "plugin/innobase/pars/pars0grm.y"
2258  { (yyval) = &pars_rnd_str_token; }
2259  break;
2260 
2261  case 67:
2262 
2263 /* Line 1806 of yacc.c */
2264 #line 241 "plugin/innobase/pars/pars0grm.y"
2265  { (yyval) = pars_stored_procedure_call(static_cast<sym_node_t *>((yyvsp[(2) - (6)]))); }
2266  break;
2267 
2268  case 68:
2269 
2270 /* Line 1806 of yacc.c */
2271 #line 246 "plugin/innobase/pars/pars0grm.y"
2272  { (yyval) = pars_procedure_call((yyvsp[(1) - (4)]), (yyvsp[(3) - (4)])); }
2273  break;
2274 
2275  case 69:
2276 
2277 /* Line 1806 of yacc.c */
2278 #line 250 "plugin/innobase/pars/pars0grm.y"
2279  { (yyval) = &pars_replstr_token; }
2280  break;
2281 
2282  case 70:
2283 
2284 /* Line 1806 of yacc.c */
2285 #line 251 "plugin/innobase/pars/pars0grm.y"
2286  { (yyval) = &pars_printf_token; }
2287  break;
2288 
2289  case 71:
2290 
2291 /* Line 1806 of yacc.c */
2292 #line 252 "plugin/innobase/pars/pars0grm.y"
2293  { (yyval) = &pars_assert_token; }
2294  break;
2295 
2296  case 72:
2297 
2298 /* Line 1806 of yacc.c */
2299 #line 256 "plugin/innobase/pars/pars0grm.y"
2300  { (yyval) = (yyvsp[(1) - (3)]); }
2301  break;
2302 
2303  case 73:
2304 
2305 /* Line 1806 of yacc.c */
2306 #line 260 "plugin/innobase/pars/pars0grm.y"
2307  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2308  break;
2309 
2310  case 74:
2311 
2312 /* Line 1806 of yacc.c */
2313 #line 262 "plugin/innobase/pars/pars0grm.y"
2314  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2315  break;
2316 
2317  case 75:
2318 
2319 /* Line 1806 of yacc.c */
2320 #line 266 "plugin/innobase/pars/pars0grm.y"
2321  { (yyval) = NULL; }
2322  break;
2323 
2324  case 76:
2325 
2326 /* Line 1806 of yacc.c */
2327 #line 267 "plugin/innobase/pars/pars0grm.y"
2328  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2329  break;
2330 
2331  case 77:
2332 
2333 /* Line 1806 of yacc.c */
2334 #line 269 "plugin/innobase/pars/pars0grm.y"
2335  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2336  break;
2337 
2338  case 78:
2339 
2340 /* Line 1806 of yacc.c */
2341 #line 273 "plugin/innobase/pars/pars0grm.y"
2342  { (yyval) = NULL; }
2343  break;
2344 
2345  case 79:
2346 
2347 /* Line 1806 of yacc.c */
2348 #line 274 "plugin/innobase/pars/pars0grm.y"
2349  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)]));}
2350  break;
2351 
2352  case 80:
2353 
2354 /* Line 1806 of yacc.c */
2355 #line 275 "plugin/innobase/pars/pars0grm.y"
2356  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2357  break;
2358 
2359  case 81:
2360 
2361 /* Line 1806 of yacc.c */
2362 #line 279 "plugin/innobase/pars/pars0grm.y"
2363  { (yyval) = (yyvsp[(1) - (1)]); }
2364  break;
2365 
2366  case 82:
2367 
2368 /* Line 1806 of yacc.c */
2369 #line 281 "plugin/innobase/pars/pars0grm.y"
2370  { (yyval) = pars_func(&pars_count_token,
2373  pars_sym_tab_global, 1))); }
2374  break;
2375 
2376  case 83:
2377 
2378 /* Line 1806 of yacc.c */
2379 #line 286 "plugin/innobase/pars/pars0grm.y"
2380  { (yyval) = pars_func(&pars_count_token,
2382  pars_func(&pars_distinct_token,
2384  NULL, (yyvsp[(4) - (5)]))))); }
2385  break;
2386 
2387  case 84:
2388 
2389 /* Line 1806 of yacc.c */
2390 #line 292 "plugin/innobase/pars/pars0grm.y"
2391  { (yyval) = pars_func(&pars_sum_token,
2393  (yyvsp[(3) - (4)]))); }
2394  break;
2395 
2396  case 85:
2397 
2398 /* Line 1806 of yacc.c */
2399 #line 298 "plugin/innobase/pars/pars0grm.y"
2400  { (yyval) = NULL; }
2401  break;
2402 
2403  case 86:
2404 
2405 /* Line 1806 of yacc.c */
2406 #line 299 "plugin/innobase/pars/pars0grm.y"
2407  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2408  break;
2409 
2410  case 87:
2411 
2412 /* Line 1806 of yacc.c */
2413 #line 301 "plugin/innobase/pars/pars0grm.y"
2414  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2415  break;
2416 
2417  case 88:
2418 
2419 /* Line 1806 of yacc.c */
2420 #line 305 "plugin/innobase/pars/pars0grm.y"
2421  { (yyval) = pars_select_list(&pars_star_denoter,
2422  NULL); }
2423  break;
2424 
2425  case 89:
2426 
2427 /* Line 1806 of yacc.c */
2428 #line 308 "plugin/innobase/pars/pars0grm.y"
2429  { (yyval) = pars_select_list(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), static_cast<sym_node_t *>((yyvsp[(3) - (3)]))); }
2430  break;
2431 
2432  case 90:
2433 
2434 /* Line 1806 of yacc.c */
2435 #line 309 "plugin/innobase/pars/pars0grm.y"
2436  { (yyval) = pars_select_list((yyvsp[(1) - (1)]), NULL); }
2437  break;
2438 
2439  case 91:
2440 
2441 /* Line 1806 of yacc.c */
2442 #line 313 "plugin/innobase/pars/pars0grm.y"
2443  { (yyval) = NULL; }
2444  break;
2445 
2446  case 92:
2447 
2448 /* Line 1806 of yacc.c */
2449 #line 314 "plugin/innobase/pars/pars0grm.y"
2450  { (yyval) = (yyvsp[(2) - (2)]); }
2451  break;
2452 
2453  case 93:
2454 
2455 /* Line 1806 of yacc.c */
2456 #line 318 "plugin/innobase/pars/pars0grm.y"
2457  { (yyval) = NULL; }
2458  break;
2459 
2460  case 94:
2461 
2462 /* Line 1806 of yacc.c */
2463 #line 320 "plugin/innobase/pars/pars0grm.y"
2464  { (yyval) = &pars_update_token; }
2465  break;
2466 
2467  case 95:
2468 
2469 /* Line 1806 of yacc.c */
2470 #line 324 "plugin/innobase/pars/pars0grm.y"
2471  { (yyval) = NULL; }
2472  break;
2473 
2474  case 96:
2475 
2476 /* Line 1806 of yacc.c */
2477 #line 326 "plugin/innobase/pars/pars0grm.y"
2478  { (yyval) = &pars_share_token; }
2479  break;
2480 
2481  case 97:
2482 
2483 /* Line 1806 of yacc.c */
2484 #line 330 "plugin/innobase/pars/pars0grm.y"
2485  { (yyval) = &pars_asc_token; }
2486  break;
2487 
2488  case 98:
2489 
2490 /* Line 1806 of yacc.c */
2491 #line 331 "plugin/innobase/pars/pars0grm.y"
2492  { (yyval) = &pars_asc_token; }
2493  break;
2494 
2495  case 99:
2496 
2497 /* Line 1806 of yacc.c */
2498 #line 332 "plugin/innobase/pars/pars0grm.y"
2499  { (yyval) = &pars_desc_token; }
2500  break;
2501 
2502  case 100:
2503 
2504 /* Line 1806 of yacc.c */
2505 #line 336 "plugin/innobase/pars/pars0grm.y"
2506  { (yyval) = NULL; }
2507  break;
2508 
2509  case 101:
2510 
2511 /* Line 1806 of yacc.c */
2512 #line 338 "plugin/innobase/pars/pars0grm.y"
2513  { (yyval) = pars_order_by(static_cast<sym_node_t *>((yyvsp[(3) - (4)])), static_cast<pars_res_word_t *>((yyvsp[(4) - (4)]))); }
2514  break;
2515 
2516  case 102:
2517 
2518 /* Line 1806 of yacc.c */
2519 #line 347 "plugin/innobase/pars/pars0grm.y"
2520  { (yyval) = pars_select_statement(static_cast<sel_node_t *>((yyvsp[(2) - (8)])), static_cast<sym_node_t *>((yyvsp[(4) - (8)])), (yyvsp[(5) - (8)]),
2521  static_cast<pars_res_word_t *>((yyvsp[(6) - (8)])), static_cast<pars_res_word_t *>((yyvsp[(7) - (8)])), static_cast<order_node_t *>((yyvsp[(8) - (8)]))); }
2522  break;
2523 
2524  case 103:
2525 
2526 /* Line 1806 of yacc.c */
2527 #line 353 "plugin/innobase/pars/pars0grm.y"
2528  { (yyval) = (yyvsp[(3) - (3)]); }
2529  break;
2530 
2531  case 104:
2532 
2533 /* Line 1806 of yacc.c */
2534 #line 358 "plugin/innobase/pars/pars0grm.y"
2535  { (yyval) = pars_insert_statement(static_cast<sym_node_t *>((yyvsp[(1) - (5)])), (yyvsp[(4) - (5)]), NULL); }
2536  break;
2537 
2538  case 105:
2539 
2540 /* Line 1806 of yacc.c */
2541 #line 360 "plugin/innobase/pars/pars0grm.y"
2542  { (yyval) = pars_insert_statement(static_cast<sym_node_t *>((yyvsp[(1) - (2)])), NULL, static_cast<sel_node_t *>((yyvsp[(2) - (2)]))); }
2543  break;
2544 
2545  case 106:
2546 
2547 /* Line 1806 of yacc.c */
2548 #line 364 "plugin/innobase/pars/pars0grm.y"
2549  { (yyval) = pars_column_assignment(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), (yyvsp[(3) - (3)])); }
2550  break;
2551 
2552  case 107:
2553 
2554 /* Line 1806 of yacc.c */
2555 #line 368 "plugin/innobase/pars/pars0grm.y"
2556  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2557  break;
2558 
2559  case 108:
2560 
2561 /* Line 1806 of yacc.c */
2562 #line 370 "plugin/innobase/pars/pars0grm.y"
2563  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2564  break;
2565 
2566  case 109:
2567 
2568 /* Line 1806 of yacc.c */
2569 #line 376 "plugin/innobase/pars/pars0grm.y"
2570  { (yyval) = (yyvsp[(4) - (4)]); }
2571  break;
2572 
2573  case 110:
2574 
2575 /* Line 1806 of yacc.c */
2576 #line 382 "plugin/innobase/pars/pars0grm.y"
2577  { (yyval) = pars_update_statement_start(FALSE,
2578  static_cast<sym_node_t *>((yyvsp[(2) - (4)])), static_cast<col_assign_node_t *>((yyvsp[(4) - (4)]))); }
2579  break;
2580 
2581  case 111:
2582 
2583 /* Line 1806 of yacc.c */
2584 #line 388 "plugin/innobase/pars/pars0grm.y"
2585  { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), NULL, (yyvsp[(2) - (2)])); }
2586  break;
2587 
2588  case 112:
2589 
2590 /* Line 1806 of yacc.c */
2591 #line 393 "plugin/innobase/pars/pars0grm.y"
2592  { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), static_cast<sym_node_t *>((yyvsp[(2) - (2)])), NULL); }
2593  break;
2594 
2595  case 113:
2596 
2597 /* Line 1806 of yacc.c */
2598 #line 398 "plugin/innobase/pars/pars0grm.y"
2599  { (yyval) = pars_update_statement_start(TRUE,
2600  static_cast<sym_node_t *>((yyvsp[(3) - (3)])), NULL); }
2601  break;
2602 
2603  case 114:
2604 
2605 /* Line 1806 of yacc.c */
2606 #line 404 "plugin/innobase/pars/pars0grm.y"
2607  { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), NULL, (yyvsp[(2) - (2)])); }
2608  break;
2609 
2610  case 115:
2611 
2612 /* Line 1806 of yacc.c */
2613 #line 409 "plugin/innobase/pars/pars0grm.y"
2614  { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), static_cast<sym_node_t *>((yyvsp[(2) - (2)])), NULL); }
2615  break;
2616 
2617  case 116:
2618 
2619 /* Line 1806 of yacc.c */
2620 #line 414 "plugin/innobase/pars/pars0grm.y"
2621  { (yyval) = pars_row_printf_statement(static_cast<sel_node_t *>((yyvsp[(2) - (2)]))); }
2622  break;
2623 
2624  case 117:
2625 
2626 /* Line 1806 of yacc.c */
2627 #line 419 "plugin/innobase/pars/pars0grm.y"
2628  { (yyval) = pars_assignment_statement(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), (yyvsp[(3) - (3)])); }
2629  break;
2630 
2631  case 118:
2632 
2633 /* Line 1806 of yacc.c */
2634 #line 425 "plugin/innobase/pars/pars0grm.y"
2635  { (yyval) = pars_elsif_element((yyvsp[(2) - (4)]), (yyvsp[(4) - (4)])); }
2636  break;
2637 
2638  case 119:
2639 
2640 /* Line 1806 of yacc.c */
2641 #line 429 "plugin/innobase/pars/pars0grm.y"
2642  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2643  break;
2644 
2645  case 120:
2646 
2647 /* Line 1806 of yacc.c */
2648 #line 431 "plugin/innobase/pars/pars0grm.y"
2649  { (yyval) = que_node_list_add_last((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)])); }
2650  break;
2651 
2652  case 121:
2653 
2654 /* Line 1806 of yacc.c */
2655 #line 435 "plugin/innobase/pars/pars0grm.y"
2656  { (yyval) = NULL; }
2657  break;
2658 
2659  case 122:
2660 
2661 /* Line 1806 of yacc.c */
2662 #line 437 "plugin/innobase/pars/pars0grm.y"
2663  { (yyval) = (yyvsp[(2) - (2)]); }
2664  break;
2665 
2666  case 123:
2667 
2668 /* Line 1806 of yacc.c */
2669 #line 438 "plugin/innobase/pars/pars0grm.y"
2670  { (yyval) = (yyvsp[(1) - (1)]); }
2671  break;
2672 
2673  case 124:
2674 
2675 /* Line 1806 of yacc.c */
2676 #line 445 "plugin/innobase/pars/pars0grm.y"
2677  { (yyval) = pars_if_statement((yyvsp[(2) - (7)]), (yyvsp[(4) - (7)]), (yyvsp[(5) - (7)])); }
2678  break;
2679 
2680  case 125:
2681 
2682 /* Line 1806 of yacc.c */
2683 #line 451 "plugin/innobase/pars/pars0grm.y"
2684  { (yyval) = pars_while_statement((yyvsp[(2) - (6)]), (yyvsp[(4) - (6)])); }
2685  break;
2686 
2687  case 126:
2688 
2689 /* Line 1806 of yacc.c */
2690 #line 459 "plugin/innobase/pars/pars0grm.y"
2691  { (yyval) = pars_for_statement(static_cast<sym_node_t *>((yyvsp[(2) - (10)])), (yyvsp[(4) - (10)]), (yyvsp[(6) - (10)]), (yyvsp[(8) - (10)])); }
2692  break;
2693 
2694  case 127:
2695 
2696 /* Line 1806 of yacc.c */
2697 #line 463 "plugin/innobase/pars/pars0grm.y"
2698  { (yyval) = pars_exit_statement(); }
2699  break;
2700 
2701  case 128:
2702 
2703 /* Line 1806 of yacc.c */
2704 #line 467 "plugin/innobase/pars/pars0grm.y"
2705  { (yyval) = pars_return_statement(); }
2706  break;
2707 
2708  case 129:
2709 
2710 /* Line 1806 of yacc.c */
2711 #line 472 "plugin/innobase/pars/pars0grm.y"
2713  static_cast<sym_node_t *>((yyvsp[(2) - (2)]))); }
2714  break;
2715 
2716  case 130:
2717 
2718 /* Line 1806 of yacc.c */
2719 #line 478 "plugin/innobase/pars/pars0grm.y"
2721  static_cast<sym_node_t *>((yyvsp[(2) - (2)]))); }
2722  break;
2723 
2724  case 131:
2725 
2726 /* Line 1806 of yacc.c */
2727 #line 484 "plugin/innobase/pars/pars0grm.y"
2728  { (yyval) = pars_fetch_statement(static_cast<sym_node_t *>((yyvsp[(2) - (4)])), static_cast<sym_node_t *>((yyvsp[(4) - (4)])), NULL); }
2729  break;
2730 
2731  case 132:
2732 
2733 /* Line 1806 of yacc.c */
2734 #line 486 "plugin/innobase/pars/pars0grm.y"
2735  { (yyval) = pars_fetch_statement(static_cast<sym_node_t *>((yyvsp[(2) - (4)])), NULL, static_cast<sym_node_t *>((yyvsp[(4) - (4)]))); }
2736  break;
2737 
2738  case 133:
2739 
2740 /* Line 1806 of yacc.c */
2741 #line 491 "plugin/innobase/pars/pars0grm.y"
2742  { (yyval) = pars_column_def(static_cast<sym_node_t *>((yyvsp[(1) - (5)])), static_cast<pars_res_word_t *>((yyvsp[(2) - (5)])), static_cast<sym_node_t *>((yyvsp[(3) - (5)])), (yyvsp[(4) - (5)]), (yyvsp[(5) - (5)])); }
2743  break;
2744 
2745  case 134:
2746 
2747 /* Line 1806 of yacc.c */
2748 #line 495 "plugin/innobase/pars/pars0grm.y"
2749  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2750  break;
2751 
2752  case 135:
2753 
2754 /* Line 1806 of yacc.c */
2755 #line 497 "plugin/innobase/pars/pars0grm.y"
2756  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2757  break;
2758 
2759  case 136:
2760 
2761 /* Line 1806 of yacc.c */
2762 #line 501 "plugin/innobase/pars/pars0grm.y"
2763  { (yyval) = NULL; }
2764  break;
2765 
2766  case 137:
2767 
2768 /* Line 1806 of yacc.c */
2769 #line 503 "plugin/innobase/pars/pars0grm.y"
2770  { (yyval) = (yyvsp[(2) - (3)]); }
2771  break;
2772 
2773  case 138:
2774 
2775 /* Line 1806 of yacc.c */
2776 #line 507 "plugin/innobase/pars/pars0grm.y"
2777  { (yyval) = NULL; }
2778  break;
2779 
2780  case 139:
2781 
2782 /* Line 1806 of yacc.c */
2783 #line 509 "plugin/innobase/pars/pars0grm.y"
2784  { (yyval) = &pars_int_token;
2785  /* pass any non-NULL pointer */ }
2786  break;
2787 
2788  case 140:
2789 
2790 /* Line 1806 of yacc.c */
2791 #line 514 "plugin/innobase/pars/pars0grm.y"
2792  { (yyval) = NULL; }
2793  break;
2794 
2795  case 141:
2796 
2797 /* Line 1806 of yacc.c */
2798 #line 516 "plugin/innobase/pars/pars0grm.y"
2799  { (yyval) = &pars_int_token;
2800  /* pass any non-NULL pointer */ }
2801  break;
2802 
2803  case 142:
2804 
2805 /* Line 1806 of yacc.c */
2806 #line 521 "plugin/innobase/pars/pars0grm.y"
2807  { (yyval) = NULL; }
2808  break;
2809 
2810  case 143:
2811 
2812 /* Line 1806 of yacc.c */
2813 #line 523 "plugin/innobase/pars/pars0grm.y"
2814  { (yyval) = &pars_int_token;
2815  /* pass any non-NULL pointer */ }
2816  break;
2817 
2818  case 144:
2819 
2820 /* Line 1806 of yacc.c */
2821 #line 530 "plugin/innobase/pars/pars0grm.y"
2822  { (yyval) = pars_create_table(static_cast<sym_node_t *>((yyvsp[(3) - (7)])), static_cast<sym_node_t *>((yyvsp[(5) - (7)])), (yyvsp[(7) - (7)])); }
2823  break;
2824 
2825  case 145:
2826 
2827 /* Line 1806 of yacc.c */
2828 #line 534 "plugin/innobase/pars/pars0grm.y"
2829  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2830  break;
2831 
2832  case 146:
2833 
2834 /* Line 1806 of yacc.c */
2835 #line 536 "plugin/innobase/pars/pars0grm.y"
2836  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2837  break;
2838 
2839  case 147:
2840 
2841 /* Line 1806 of yacc.c */
2842 #line 540 "plugin/innobase/pars/pars0grm.y"
2843  { (yyval) = NULL; }
2844  break;
2845 
2846  case 148:
2847 
2848 /* Line 1806 of yacc.c */
2849 #line 541 "plugin/innobase/pars/pars0grm.y"
2850  { (yyval) = &pars_unique_token; }
2851  break;
2852 
2853  case 149:
2854 
2855 /* Line 1806 of yacc.c */
2856 #line 545 "plugin/innobase/pars/pars0grm.y"
2857  { (yyval) = NULL; }
2858  break;
2859 
2860  case 150:
2861 
2862 /* Line 1806 of yacc.c */
2863 #line 546 "plugin/innobase/pars/pars0grm.y"
2864  { (yyval) = &pars_clustered_token; }
2865  break;
2866 
2867  case 151:
2868 
2869 /* Line 1806 of yacc.c */
2870 #line 554 "plugin/innobase/pars/pars0grm.y"
2871  { (yyval) = pars_create_index(static_cast<pars_res_word_t *>((yyvsp[(2) - (10)])), static_cast<pars_res_word_t *>((yyvsp[(3) - (10)])), static_cast<sym_node_t *>((yyvsp[(5) - (10)])), static_cast<sym_node_t *>((yyvsp[(7) - (10)])), static_cast<sym_node_t *>((yyvsp[(9) - (10)]))); }
2872  break;
2873 
2874  case 152:
2875 
2876 /* Line 1806 of yacc.c */
2877 #line 559 "plugin/innobase/pars/pars0grm.y"
2878  { (yyval) = pars_commit_statement(); }
2879  break;
2880 
2881  case 153:
2882 
2883 /* Line 1806 of yacc.c */
2884 #line 564 "plugin/innobase/pars/pars0grm.y"
2885  { (yyval) = pars_rollback_statement(); }
2886  break;
2887 
2888  case 154:
2889 
2890 /* Line 1806 of yacc.c */
2891 #line 568 "plugin/innobase/pars/pars0grm.y"
2892  { (yyval) = &pars_int_token; }
2893  break;
2894 
2895  case 155:
2896 
2897 /* Line 1806 of yacc.c */
2898 #line 569 "plugin/innobase/pars/pars0grm.y"
2899  { (yyval) = &pars_int_token; }
2900  break;
2901 
2902  case 156:
2903 
2904 /* Line 1806 of yacc.c */
2905 #line 570 "plugin/innobase/pars/pars0grm.y"
2906  { (yyval) = &pars_char_token; }
2907  break;
2908 
2909  case 157:
2910 
2911 /* Line 1806 of yacc.c */
2912 #line 571 "plugin/innobase/pars/pars0grm.y"
2913  { (yyval) = &pars_binary_token; }
2914  break;
2915 
2916  case 158:
2917 
2918 /* Line 1806 of yacc.c */
2919 #line 572 "plugin/innobase/pars/pars0grm.y"
2920  { (yyval) = &pars_blob_token; }
2921  break;
2922 
2923  case 159:
2924 
2925 /* Line 1806 of yacc.c */
2926 #line 577 "plugin/innobase/pars/pars0grm.y"
2927  { (yyval) = pars_parameter_declaration(static_cast<sym_node_t *>((yyvsp[(1) - (3)])),
2928  PARS_INPUT, static_cast<pars_res_word_t *>((yyvsp[(3) - (3)]))); }
2929  break;
2930 
2931  case 160:
2932 
2933 /* Line 1806 of yacc.c */
2934 #line 580 "plugin/innobase/pars/pars0grm.y"
2935  { (yyval) = pars_parameter_declaration(static_cast<sym_node_t *>((yyvsp[(1) - (3)])),
2936  PARS_OUTPUT, static_cast<pars_res_word_t *>((yyvsp[(3) - (3)]))); }
2937  break;
2938 
2939  case 161:
2940 
2941 /* Line 1806 of yacc.c */
2942 #line 585 "plugin/innobase/pars/pars0grm.y"
2943  { (yyval) = NULL; }
2944  break;
2945 
2946  case 162:
2947 
2948 /* Line 1806 of yacc.c */
2949 #line 586 "plugin/innobase/pars/pars0grm.y"
2950  { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
2951  break;
2952 
2953  case 163:
2954 
2955 /* Line 1806 of yacc.c */
2956 #line 588 "plugin/innobase/pars/pars0grm.y"
2957  { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2958  break;
2959 
2960  case 164:
2961 
2962 /* Line 1806 of yacc.c */
2963 #line 593 "plugin/innobase/pars/pars0grm.y"
2964  { (yyval) = pars_variable_declaration(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), static_cast<pars_res_word_t *>((yyvsp[(2) - (3)]))); }
2965  break;
2966 
2967  case 168:
2968 
2969 /* Line 1806 of yacc.c */
2970 #line 605 "plugin/innobase/pars/pars0grm.y"
2971  { (yyval) = pars_cursor_declaration(static_cast<sym_node_t *>((yyvsp[(3) - (6)])), static_cast<sel_node_t *>((yyvsp[(5) - (6)]))); }
2972  break;
2973 
2974  case 169:
2975 
2976 /* Line 1806 of yacc.c */
2977 #line 610 "plugin/innobase/pars/pars0grm.y"
2978  { (yyval) = pars_function_declaration(static_cast<sym_node_t *>((yyvsp[(3) - (4)]))); }
2979  break;
2980 
2981  case 175:
2982 
2983 /* Line 1806 of yacc.c */
2984 #line 631 "plugin/innobase/pars/pars0grm.y"
2985  { (yyval) = pars_procedure_definition(static_cast<sym_node_t *>((yyvsp[(2) - (11)])), static_cast<sym_node_t *>((yyvsp[(4) - (11)])),
2986  (yyvsp[(10) - (11)])); }
2987  break;
2988 
2989 
2990 
2991 /* Line 1806 of yacc.c */
2992 #line 2993 "plugin/innobase/pars/pars0grm.cc"
2993  default: break;
2994  }
2995  /* User semantic actions sometimes alter yychar, and that requires
2996  that yytoken be updated with the new translation. We take the
2997  approach of translating immediately before every use of yytoken.
2998  One alternative is translating here after every semantic action,
2999  but that translation would be missed if the semantic action invokes
3000  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3001  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
3002  incorrect destructor might then be invoked immediately. In the
3003  case of YYERROR or YYBACKUP, subsequent parser actions might lead
3004  to an incorrect destructor call or verbose syntax error message
3005  before the lookahead is translated. */
3006  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3007 
3008  YYPOPSTACK (yylen);
3009  yylen = 0;
3010  YY_STACK_PRINT (yyss, yyssp);
3011 
3012  *++yyvsp = yyval;
3013 
3014  /* Now `shift' the result of the reduction. Determine what state
3015  that goes to, based on the state we popped back to and the rule
3016  number reduced by. */
3017 
3018  yyn = yyr1[yyn];
3019 
3020  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3021  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3022  yystate = yytable[yystate];
3023  else
3024  yystate = yydefgoto[yyn - YYNTOKENS];
3025 
3026  goto yynewstate;
3027 
3028 
3029 /*------------------------------------.
3030 | yyerrlab -- here on detecting error |
3031 `------------------------------------*/
3032 yyerrlab:
3033  /* Make sure we have latest lookahead translation. See comments at
3034  user semantic actions for why this is necessary. */
3035  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3036 
3037  /* If not already recovering from an error, report this error. */
3038  if (!yyerrstatus)
3039  {
3040  ++yynerrs;
3041 #if ! YYERROR_VERBOSE
3042  yyerror (YY_("syntax error"));
3043 #else
3044 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3045  yyssp, yytoken)
3046  {
3047  char const *yymsgp = YY_("syntax error");
3048  int yysyntax_error_status;
3049  yysyntax_error_status = YYSYNTAX_ERROR;
3050  if (yysyntax_error_status == 0)
3051  yymsgp = yymsg;
3052  else if (yysyntax_error_status == 1)
3053  {
3054  if (yymsg != yymsgbuf)
3055  YYSTACK_FREE (yymsg);
3056  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3057  if (!yymsg)
3058  {
3059  yymsg = yymsgbuf;
3060  yymsg_alloc = sizeof yymsgbuf;
3061  yysyntax_error_status = 2;
3062  }
3063  else
3064  {
3065  yysyntax_error_status = YYSYNTAX_ERROR;
3066  yymsgp = yymsg;
3067  }
3068  }
3069  yyerror (yymsgp);
3070  if (yysyntax_error_status == 2)
3071  goto yyexhaustedlab;
3072  }
3073 # undef YYSYNTAX_ERROR
3074 #endif
3075  }
3076 
3077 
3078 
3079  if (yyerrstatus == 3)
3080  {
3081  /* If just tried and failed to reuse lookahead token after an
3082  error, discard it. */
3083 
3084  if (yychar <= YYEOF)
3085  {
3086  /* Return failure if at end of input. */
3087  if (yychar == YYEOF)
3088  YYABORT;
3089  }
3090  else
3091  {
3092  yydestruct ("Error: discarding",
3093  yytoken, &yylval);
3094  yychar = YYEMPTY;
3095  }
3096  }
3097 
3098  /* Else will try to reuse lookahead token after shifting the error
3099  token. */
3100  goto yyerrlab1;
3101 
3102 
3103 /*---------------------------------------------------.
3104 | yyerrorlab -- error raised explicitly by YYERROR. |
3105 `---------------------------------------------------*/
3106 yyerrorlab:
3107 
3108  /* Pacify compilers like GCC when the user code never invokes
3109  YYERROR and the label yyerrorlab therefore never appears in user
3110  code. */
3111  if (/*CONSTCOND*/ 0)
3112  goto yyerrorlab;
3113 
3114  /* Do not reclaim the symbols of the rule which action triggered
3115  this YYERROR. */
3116  YYPOPSTACK (yylen);
3117  yylen = 0;
3118  YY_STACK_PRINT (yyss, yyssp);
3119  yystate = *yyssp;
3120  goto yyerrlab1;
3121 
3122 
3123 /*-------------------------------------------------------------.
3124 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3125 `-------------------------------------------------------------*/
3126 yyerrlab1:
3127  yyerrstatus = 3; /* Each real token shifted decrements this. */
3128 
3129  for (;;)
3130  {
3131  yyn = yypact[yystate];
3132  if (!yypact_value_is_default (yyn))
3133  {
3134  yyn += YYTERROR;
3135  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3136  {
3137  yyn = yytable[yyn];
3138  if (0 < yyn)
3139  break;
3140  }
3141  }
3142 
3143  /* Pop the current state because it cannot handle the error token. */
3144  if (yyssp == yyss)
3145  YYABORT;
3146 
3147 
3148  yydestruct ("Error: popping",
3149  yystos[yystate], yyvsp);
3150  YYPOPSTACK (1);
3151  yystate = *yyssp;
3152  YY_STACK_PRINT (yyss, yyssp);
3153  }
3154 
3155  *++yyvsp = yylval;
3156 
3157 
3158  /* Shift the error token. */
3159  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3160 
3161  yystate = yyn;
3162  goto yynewstate;
3163 
3164 
3165 /*-------------------------------------.
3166 | yyacceptlab -- YYACCEPT comes here. |
3167 `-------------------------------------*/
3168 yyacceptlab:
3169  yyresult = 0;
3170  goto yyreturn;
3171 
3172 /*-----------------------------------.
3173 | yyabortlab -- YYABORT comes here. |
3174 `-----------------------------------*/
3175 yyabortlab:
3176  yyresult = 1;
3177  goto yyreturn;
3178 
3179 #if !defined(yyoverflow) || YYERROR_VERBOSE
3180 /*-------------------------------------------------.
3181 | yyexhaustedlab -- memory exhaustion comes here. |
3182 `-------------------------------------------------*/
3183 yyexhaustedlab:
3184  yyerror (YY_("memory exhausted"));
3185  yyresult = 2;
3186  /* Fall through. */
3187 #endif
3188 
3189 yyreturn:
3190  if (yychar != YYEMPTY)
3191  {
3192  /* Make sure we have latest lookahead translation. See comments at
3193  user semantic actions for why this is necessary. */
3194  yytoken = YYTRANSLATE (yychar);
3195  yydestruct ("Cleanup: discarding lookahead",
3196  yytoken, &yylval);
3197  }
3198  /* Do not reclaim the symbols of the rule which action triggered
3199  this YYABORT or YYACCEPT. */
3200  YYPOPSTACK (yylen);
3201  YY_STACK_PRINT (yyss, yyssp);
3202  while (yyssp != yyss)
3203  {
3204  yydestruct ("Cleanup: popping",
3205  yystos[*yyssp], yyvsp);
3206  YYPOPSTACK (1);
3207  }
3208 #ifndef yyoverflow
3209  if (yyss != yyssa)
3210  YYSTACK_FREE (yyss);
3211 #endif
3212 #if YYERROR_VERBOSE
3213  if (yymsg != yymsgbuf)
3214  YYSTACK_FREE (yymsg);
3215 #endif
3216  /* Make sure YYID is used. */
3217  return YYID (yyresult);
3218 }
3219 
3220 
3221 
3222 /* Line 2067 of yacc.c */
3223 #line 635 "plugin/innobase/pars/pars0grm.y"
3224 
3225