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