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