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