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