1 /* A Bison parser, made by GNU Bison 3.0.2. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "3.0.2"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 1
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61
62
63
64 /* Copy the first part of user declarations. */
65
66
67 #if USE_WINDOWS
68 #pragma warning(push,1)
69 #pragma warning(disable:4702) // unreachable code
70 #endif
71
72
73
74 # ifndef YY_NULLPTR
75 # if defined __cplusplus && 201103L <= __cplusplus
76 # define YY_NULLPTR nullptr
77 # else
78 # define YY_NULLPTR 0
79 # endif
80 # endif
81
82 /* Enabling verbose error messages. */
83 #ifdef YYERROR_VERBOSE
84 # undef YYERROR_VERBOSE
85 # define YYERROR_VERBOSE 1
86 #else
87 # define YYERROR_VERBOSE 1
88 #endif
89
90 /* In a future release of Bison, this section will be replaced
91 by #include "yysphinxselect.h". */
92 #ifndef YY_YY_YYSPHINXSELECT_H_INCLUDED
93 # define YY_YY_YYSPHINXSELECT_H_INCLUDED
94 /* Debug traces. */
95 #ifndef YYDEBUG
96 # define YYDEBUG 0
97 #endif
98 #if YYDEBUG
99 extern int yydebug;
100 #endif
101
102 /* Token type. */
103 #ifndef YYTOKENTYPE
104 # define YYTOKENTYPE
105 enum yytokentype
106 {
107 SEL_TOKEN = 258,
108 SEL_ID = 259,
109 SEL_AS = 260,
110 SEL_AVG = 261,
111 SEL_MAX = 262,
112 SEL_MIN = 263,
113 SEL_SUM = 264,
114 SEL_GROUP_CONCAT = 265,
115 SEL_GROUPBY = 266,
116 SEL_COUNT = 267,
117 SEL_WEIGHT = 268,
118 SEL_DISTINCT = 269,
119 SEL_OPTION = 270,
120 SEL_COMMENT_OPEN = 271,
121 SEL_COMMENT_CLOSE = 272,
122 TOK_DIV = 273,
123 TOK_MOD = 274,
124 TOK_NEG = 275,
125 TOK_LTE = 276,
126 TOK_GTE = 277,
127 TOK_EQ = 278,
128 TOK_NE = 279,
129 TOK_CONST_STRING = 280,
130 TOK_OR = 281,
131 TOK_AND = 282,
132 TOK_NOT = 283,
133 TOK_IS = 284,
134 TOK_NULL = 285,
135 TOK_FOR = 286,
136 TOK_FUNC_IN = 287
137 };
138 #endif
139
140 /* Value type. */
141 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
142 typedef int YYSTYPE;
143 # define YYSTYPE_IS_TRIVIAL 1
144 # define YYSTYPE_IS_DECLARED 1
145 #endif
146
147
148
149 int yyparse (SelectParser_t * pParser);
150
151 #endif /* !YY_YY_YYSPHINXSELECT_H_INCLUDED */
152
153 /* Copy the second part of user declarations. */
154
155
156
157 #ifdef short
158 # undef short
159 #endif
160
161 #ifdef YYTYPE_UINT8
162 typedef YYTYPE_UINT8 yytype_uint8;
163 #else
164 typedef unsigned char yytype_uint8;
165 #endif
166
167 #ifdef YYTYPE_INT8
168 typedef YYTYPE_INT8 yytype_int8;
169 #else
170 typedef signed char yytype_int8;
171 #endif
172
173 #ifdef YYTYPE_UINT16
174 typedef YYTYPE_UINT16 yytype_uint16;
175 #else
176 typedef unsigned short int yytype_uint16;
177 #endif
178
179 #ifdef YYTYPE_INT16
180 typedef YYTYPE_INT16 yytype_int16;
181 #else
182 typedef short int yytype_int16;
183 #endif
184
185 #ifndef YYSIZE_T
186 # ifdef __SIZE_TYPE__
187 # define YYSIZE_T __SIZE_TYPE__
188 # elif defined size_t
189 # define YYSIZE_T size_t
190 # elif ! defined YYSIZE_T
191 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
192 # define YYSIZE_T size_t
193 # else
194 # define YYSIZE_T unsigned int
195 # endif
196 #endif
197
198 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
199
200 #ifndef YY_
201 # if defined YYENABLE_NLS && YYENABLE_NLS
202 # if ENABLE_NLS
203 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
204 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
205 # endif
206 # endif
207 # ifndef YY_
208 # define YY_(Msgid) Msgid
209 # endif
210 #endif
211
212 #ifndef YY_ATTRIBUTE
213 # if (defined __GNUC__ \
214 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
215 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
216 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
217 # else
218 # define YY_ATTRIBUTE(Spec) /* empty */
219 # endif
220 #endif
221
222 #ifndef YY_ATTRIBUTE_PURE
223 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
224 #endif
225
226 #ifndef YY_ATTRIBUTE_UNUSED
227 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
228 #endif
229
230 #if !defined _Noreturn \
231 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
232 # if defined _MSC_VER && 1200 <= _MSC_VER
233 # define _Noreturn __declspec (noreturn)
234 # else
235 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
236 # endif
237 #endif
238
239 /* Suppress unused-variable warnings by "using" E. */
240 #if ! defined lint || defined __GNUC__
241 # define YYUSE(E) ((void) (E))
242 #else
243 # define YYUSE(E) /* empty */
244 #endif
245
246 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
247 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
248 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
249 _Pragma ("GCC diagnostic push") \
250 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
251 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
252 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
253 _Pragma ("GCC diagnostic pop")
254 #else
255 # define YY_INITIAL_VALUE(Value) Value
256 #endif
257 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
258 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
259 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
260 #endif
261 #ifndef YY_INITIAL_VALUE
262 # define YY_INITIAL_VALUE(Value) /* Nothing. */
263 #endif
264
265
266 #if ! defined yyoverflow || YYERROR_VERBOSE
267
268 /* The parser invokes alloca or malloc; define the necessary symbols. */
269
270 # ifdef YYSTACK_USE_ALLOCA
271 # if YYSTACK_USE_ALLOCA
272 # ifdef __GNUC__
273 # define YYSTACK_ALLOC __builtin_alloca
274 # elif defined __BUILTIN_VA_ARG_INCR
275 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
276 # elif defined _AIX
277 # define YYSTACK_ALLOC __alloca
278 # elif defined _MSC_VER
279 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
280 # define alloca _alloca
281 # else
282 # define YYSTACK_ALLOC alloca
283 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
284 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
285 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
286 # ifndef EXIT_SUCCESS
287 # define EXIT_SUCCESS 0
288 # endif
289 # endif
290 # endif
291 # endif
292 # endif
293
294 # ifdef YYSTACK_ALLOC
295 /* Pacify GCC's 'empty if-body' warning. */
296 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
297 # ifndef YYSTACK_ALLOC_MAXIMUM
298 /* The OS might guarantee only one guard page at the bottom of the stack,
299 and a page size can be as small as 4096 bytes. So we cannot safely
300 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
301 to allow for a few compiler-allocated temporary stack slots. */
302 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
303 # endif
304 # else
305 # define YYSTACK_ALLOC YYMALLOC
306 # define YYSTACK_FREE YYFREE
307 # ifndef YYSTACK_ALLOC_MAXIMUM
308 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
309 # endif
310 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
311 && ! ((defined YYMALLOC || defined malloc) \
312 && (defined YYFREE || defined free)))
313 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
314 # ifndef EXIT_SUCCESS
315 # define EXIT_SUCCESS 0
316 # endif
317 # endif
318 # ifndef YYMALLOC
319 # define YYMALLOC malloc
320 # if ! defined malloc && ! defined EXIT_SUCCESS
321 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
322 # endif
323 # endif
324 # ifndef YYFREE
325 # define YYFREE free
326 # if ! defined free && ! defined EXIT_SUCCESS
327 void free (void *); /* INFRINGES ON USER NAME SPACE */
328 # endif
329 # endif
330 # endif
331 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
332
333
334 #if (! defined yyoverflow \
335 && (! defined __cplusplus \
336 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
337
338 /* A type that is properly aligned for any stack member. */
339 union yyalloc
340 {
341 yytype_int16 yyss_alloc;
342 YYSTYPE yyvs_alloc;
343 };
344
345 /* The size of the maximum gap between one aligned stack and the next. */
346 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
347
348 /* The size of an array large to enough to hold all stacks, each with
349 N elements. */
350 # define YYSTACK_BYTES(N) \
351 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
352 + YYSTACK_GAP_MAXIMUM)
353
354 # define YYCOPY_NEEDED 1
355
356 /* Relocate STACK from its old location to the new one. The
357 local variables YYSIZE and YYSTACKSIZE give the old and new number of
358 elements in the stack, and YYPTR gives the new location of the
359 stack. Advance YYPTR to a properly aligned location for the next
360 stack. */
361 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
362 do \
363 { \
364 YYSIZE_T yynewbytes; \
365 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
366 Stack = &yyptr->Stack_alloc; \
367 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
368 yyptr += yynewbytes / sizeof (*yyptr); \
369 } \
370 while (0)
371
372 #endif
373
374 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
375 /* Copy COUNT objects from SRC to DST. The source and destination do
376 not overlap. */
377 # ifndef YYCOPY
378 # if defined __GNUC__ && 1 < __GNUC__
379 # define YYCOPY(Dst, Src, Count) \
380 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
381 # else
382 # define YYCOPY(Dst, Src, Count) \
383 do \
384 { \
385 YYSIZE_T yyi; \
386 for (yyi = 0; yyi < (Count); yyi++) \
387 (Dst)[yyi] = (Src)[yyi]; \
388 } \
389 while (0)
390 # endif
391 # endif
392 #endif /* !YYCOPY_NEEDED */
393
394 /* YYFINAL -- State number of the termination state. */
395 #define YYFINAL 75
396 /* YYLAST -- Last index in YYTABLE. */
397 #define YYLAST 818
398
399 /* YYNTOKENS -- Number of terminals. */
400 #define YYNTOKENS 51
401 /* YYNNTS -- Number of nonterminals. */
402 #define YYNNTS 20
403 /* YYNRULES -- Number of rules. */
404 #define YYNRULES 99
405 /* YYNSTATES -- Number of states. */
406 #define YYNSTATES 193
407
408 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
409 by yylex, with out-of-bounds checking. */
410 #define YYUNDEFTOK 2
411 #define YYMAXUTOK 287
412
413 #define YYTRANSLATE(YYX) \
414 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
415
416 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
417 as returned by yylex, without out-of-bounds checking. */
418 static const yytype_uint8 yytranslate[] =
419 {
420 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 2, 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, 36, 29, 2,
424 43, 44, 34, 32, 42, 33, 48, 35, 2, 2,
425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
426 30, 2, 31, 2, 2, 2, 2, 2, 2, 2,
427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
429 2, 49, 2, 50, 2, 2, 45, 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, 46, 28, 47, 2, 2, 2, 2,
433 2, 2, 2, 2, 2, 2, 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, 1, 2, 3, 4,
446 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
447 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
448 25, 26, 27, 37, 38, 39, 40, 41
449 };
450
451 #if YYDEBUG
452 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
453 static const yytype_uint8 yyrline[] =
454 {
455 0, 57, 57, 58, 59, 63, 64, 68, 69, 71,
456 73, 74, 78, 79, 80, 81, 82, 83, 84, 85,
457 86, 92, 93, 94, 95, 96, 97, 98, 99, 100,
458 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
459 111, 112, 113, 114, 115, 116, 117, 118, 119, 123,
460 124, 128, 129, 130, 131, 132, 133, 134, 138, 139,
461 143, 144, 148, 149, 153, 154, 158, 165, 166, 170,
462 174, 175, 179, 180, 180, 180, 180, 180, 180, 180,
463 181, 181, 181, 181, 181, 181, 182, 182, 182, 182,
464 182, 182, 182, 182, 183, 183, 187, 188, 189, 193
465 };
466 #endif
467
468 #if YYDEBUG || YYERROR_VERBOSE || 1
469 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
470 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
471 static const char *const yytname[] =
472 {
473 "$end", "error", "$undefined", "SEL_TOKEN", "SEL_ID", "SEL_AS",
474 "SEL_AVG", "SEL_MAX", "SEL_MIN", "SEL_SUM", "SEL_GROUP_CONCAT",
475 "SEL_GROUPBY", "SEL_COUNT", "SEL_WEIGHT", "SEL_DISTINCT", "SEL_OPTION",
476 "SEL_COMMENT_OPEN", "SEL_COMMENT_CLOSE", "TOK_DIV", "TOK_MOD", "TOK_NEG",
477 "TOK_LTE", "TOK_GTE", "TOK_EQ", "TOK_NE", "TOK_CONST_STRING", "TOK_OR",
478 "TOK_AND", "'|'", "'&'", "'<'", "'>'", "'+'", "'-'", "'*'", "'/'", "'%'",
479 "TOK_NOT", "TOK_IS", "TOK_NULL", "TOK_FOR", "TOK_FUNC_IN", "','", "'('",
480 "')'", "'`'", "'{'", "'}'", "'.'", "'['", "']'", "$accept", "select",
481 "select_list", "select_item", "opt_alias", "select_expr", "expr",
482 "select_atom", "function", "arglist", "consthash", "hash_key", "arg",
483 "comment", "json_field", "json_expr", "subscript", "ident", "subkey",
484 "for_loop", YY_NULLPTR
485 };
486 #endif
487
488 # ifdef YYPRINT
489 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
490 (internal) symbol number NUM (which must be that of a token). */
491 static const yytype_uint16 yytoknum[] =
492 {
493 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
494 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
495 275, 276, 277, 278, 279, 280, 281, 282, 124, 38,
496 60, 62, 43, 45, 42, 47, 37, 283, 284, 285,
497 286, 287, 44, 40, 41, 96, 123, 125, 46, 91,
498 93
499 };
500 # endif
501
502 #define YYPACT_NINF -44
503
504 #define yypact_value_is_default(Yystate) \
505 (!!((Yystate) == (-44)))
506
507 #define YYTABLE_NINF -74
508
509 #define yytable_value_is_error(Yytable_value) \
510 0
511
512 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
513 STATE-NUM. */
514 static const yytype_int16 yypact[] =
515 {
516 72, -31, -15, -44, -7, 31, 46, 61, 67, 71,
517 73, 76, -44, -44, 82, -44, -44, -44, -44, -44,
518 -44, -44, -44, -44, 358, -44, 358, -44, 77, 358,
519 10, 0, 126, -12, -44, 5, 718, -44, -44, -44,
520 90, 91, -44, 138, 402, 182, 54, -44, 358, 358,
521 358, 358, 358, 83, -5, 86, 128, -44, 92, 93,
522 -44, -44, -44, -44, -44, -44, 226, 540, -44, -44,
523 87, -44, -44, -36, 111, -44, 270, -44, -44, 134,
524 -44, 358, 358, 358, 358, 314, 358, 358, 358, 358,
525 358, 358, 358, 358, 358, 358, 358, 358, -17, -44,
526 -44, 698, 11, -44, -44, -44, -44, -44, -44, -44,
527 -44, 104, 461, -44, 559, 486, 513, 578, 597, -44,
528 136, 122, -44, 132, 358, 358, 718, 12, -44, -44,
529 0, -44, 164, -44, -44, -44, -44, 89, 89, -44,
530 782, 782, 16, 737, 756, 775, 89, 89, -3, -3,
531 -44, -44, -44, 129, -44, 402, 125, 226, -44, -44,
532 -44, -44, 358, -44, 358, -44, -44, -44, 130, -44,
533 167, 654, 676, -44, 149, -44, -44, 135, -44, -44,
534 616, 635, -44, 156, 175, 439, -44, -44, -44, -44,
535 54, -44, -44
536 };
537
538 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
539 Performed when YYTABLE does not specify something else to do. Zero
540 means the default is an error. */
541 static const yytype_uint8 yydefact[] =
542 {
543 0, 50, 49, 74, 75, 76, 77, 78, 79, 80,
544 81, 82, 83, 84, 0, 85, 86, 87, 88, 89,
545 90, 91, 92, 93, 0, 7, 94, 95, 0, 0,
546 0, 0, 0, 2, 5, 9, 12, 21, 44, 4,
547 0, 45, 68, 0, 0, 0, 69, 70, 0, 0,
548 0, 0, 0, 0, 0, 0, 0, 75, 76, 77,
549 78, 79, 80, 81, 23, 24, 0, 0, 50, 49,
550 0, 62, 63, 0, 0, 1, 0, 3, 10, 0,
551 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
552 0, 0, 0, 0, 0, 0, 0, 0, 0, 65,
553 52, 64, 0, 58, 72, 73, 76, 77, 82, 94,
554 96, 0, 0, 71, 0, 0, 0, 0, 0, 18,
555 0, 0, 55, 0, 0, 0, 64, 0, 42, 22,
556 0, 43, 0, 6, 11, 34, 35, 36, 37, 48,
557 38, 39, 41, 40, 32, 31, 29, 30, 25, 26,
558 27, 28, 33, 0, 46, 0, 0, 0, 51, 98,
559 97, 13, 0, 14, 0, 15, 16, 17, 0, 19,
560 0, 0, 0, 57, 0, 60, 47, 0, 56, 59,
561 0, 0, 20, 0, 0, 0, 54, 53, 66, 61,
562 72, 99, 67
563 };
564
565 /* YYPGOTO[NTERM-NUM]. */
566 static const yytype_int16 yypgoto[] =
567 {
568 -44, -44, -44, 123, -44, -44, -24, 150, -44, 144,
569 -44, 68, 55, 178, 28, 29, -44, -43, 170, -44
570 };
571
572 /* YYDEFGOTO[NTERM-NUM]. */
573 static const yytype_int16 yydefgoto[] =
574 {
575 -1, 32, 33, 34, 80, 35, 36, 37, 38, 102,
576 73, 74, 103, 39, 40, 41, 46, 42, 47, 156
577 };
578
579 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
580 positive, shift that token. If negative, reduce the rule whose
581 number is the opposite. If YYTABLE_NINF, syntax error. */
582 static const yytype_int16 yytable[] =
583 {
584 64, 110, 65, 71, 14, 67, 130, -72, 78, 120,
585 79, 131, 43, 68, 69, 81, 82, 44, 45, 101,
586 153, 112, 154, -73, 114, 115, 116, 117, 118, 121,
587 76, 95, 96, 97, 81, 82, 48, 83, 84, 85,
588 86, 72, 126, 88, 89, 90, 91, 92, 93, 94,
589 95, 96, 97, 157, 157, 158, 173, 135, 136, 137,
590 138, 140, 141, 142, 143, 144, 145, 146, 147, 148,
591 149, 150, 151, 152, 49, 1, 2, 3, 4, 5,
592 6, 7, 8, 9, 10, 11, 12, 13, 14, 50,
593 15, 16, 17, 18, 19, 20, 21, 56, 22, 23,
594 171, 172, 44, 45, 51, 24, 25, 81, 82, 26,
595 52, 27, 177, 28, 53, 29, 54, 30, 31, 55,
596 66, 93, 94, 95, 96, 97, 75, 119, 98, -67,
597 122, 123, 129, 126, 132, 124, 125, 134, 180, 168,
598 181, 1, 2, 3, 57, 58, 59, 60, 61, 62,
599 63, 11, 12, 13, 159, 170, 15, 16, 17, 18,
600 19, 20, 21, 99, 22, 23, 169, 175, 176, 178,
601 183, 24, 184, 188, 182, 26, 185, 27, 189, 28,
602 70, 29, 100, 30, 31, 1, 2, 3, 57, 58,
603 59, 60, 61, 62, 63, 11, 12, 13, 174, 133,
604 15, 16, 17, 18, 19, 20, 21, 111, 22, 23,
605 127, 77, 179, 191, 192, 24, 113, 0, 0, 26,
606 0, 27, 0, 28, 0, 29, 0, 30, 31, 1,
607 2, 3, 57, 58, 59, 60, 61, 62, 63, 11,
608 12, 13, 0, 0, 15, 16, 17, 18, 19, 20,
609 21, 99, 22, 23, 0, 0, 0, 0, 0, 24,
610 0, 0, 0, 26, 0, 27, 0, 28, 0, 29,
611 0, 30, 31, 1, 2, 3, 4, 5, 6, 7,
612 8, 9, 10, 11, 12, 13, 0, 0, 15, 16,
613 17, 18, 19, 20, 21, 0, 22, 23, 0, 0,
614 0, 0, 0, 24, 25, 0, 0, 26, 0, 27,
615 0, 28, 0, 29, 0, 30, 31, 1, 2, 3,
616 57, 58, 59, 60, 61, 62, 63, 11, 12, 13,
617 0, 0, 15, 16, 17, 18, 19, 20, 21, 139,
618 22, 23, 0, 0, 0, 0, 0, 24, 0, 0,
619 0, 26, 0, 27, 0, 28, 0, 29, 0, 30,
620 31, 1, 2, 3, 57, 58, 59, 60, 61, 62,
621 63, 11, 12, 13, 0, 0, 15, 16, 17, 18,
622 19, 20, 21, 0, 22, 23, 0, 0, 0, 0,
623 0, 24, 0, 0, 0, 26, 0, 27, 0, 28,
624 0, 29, 0, 30, 31, 104, 105, 3, 57, 106,
625 107, 60, 61, 62, 63, 108, 12, 13, 0, 0,
626 15, 16, 17, 18, 19, 20, 21, 0, 22, 23,
627 0, 0, 0, 0, 0, 0, 0, 0, 0, 109,
628 0, 27, 190, 105, 3, 57, 106, 107, 60, 61,
629 62, 63, 108, 12, 13, 0, 0, 15, 16, 17,
630 18, 19, 20, 21, 0, 22, 23, 0, 0, 0,
631 0, 0, 0, 0, 0, 0, 109, 0, 27, 81,
632 82, 0, 83, 84, 85, 86, 0, 87, 88, 89,
633 90, 91, 92, 93, 94, 95, 96, 97, 0, 0,
634 0, 0, 0, 0, 81, 82, 0, 83, 84, 85,
635 86, 160, 87, 88, 89, 90, 91, 92, 93, 94,
636 95, 96, 97, 0, 0, 0, 0, 0, 162, 0,
637 163, 81, 82, 0, 83, 84, 85, 86, 0, 87,
638 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
639 0, 0, 0, 0, 0, 164, 0, 165, 81, 82,
640 0, 83, 84, 85, 86, 0, 87, 88, 89, 90,
641 91, 92, 93, 94, 95, 96, 97, 81, 82, 0,
642 83, 84, 85, 86, 128, 87, 88, 89, 90, 91,
643 92, 93, 94, 95, 96, 97, 81, 82, 0, 83,
644 84, 85, 86, 161, 87, 88, 89, 90, 91, 92,
645 93, 94, 95, 96, 97, 81, 82, 0, 83, 84,
646 85, 86, 166, 87, 88, 89, 90, 91, 92, 93,
647 94, 95, 96, 97, 81, 82, 0, 83, 84, 85,
648 86, 167, 87, 88, 89, 90, 91, 92, 93, 94,
649 95, 96, 97, 81, 82, 0, 83, 84, 85, 86,
650 186, 87, 88, 89, 90, 91, 92, 93, 94, 95,
651 96, 97, 81, 82, 0, 83, 84, 85, 86, 187,
652 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
653 97, 0, 0, 0, 81, 82, 162, 83, 84, 85,
654 86, 0, 87, 88, 89, 90, 91, 92, 93, 94,
655 95, 96, 97, 0, 0, 0, 81, 82, 164, 83,
656 84, 85, 86, 0, 87, 88, 89, 90, 91, 92,
657 93, 94, 95, 96, 97, 0, 81, 82, 155, 83,
658 84, 85, 86, 0, 87, 88, 89, 90, 91, 92,
659 93, 94, 95, 96, 97, 81, 82, 0, 83, 84,
660 85, 86, 0, 0, 0, 89, 90, 91, 92, 93,
661 94, 95, 96, 97, 81, 82, 0, 83, 84, 85,
662 86, 0, 0, 0, 0, 90, 91, 92, 93, 94,
663 95, 96, 97, 81, 82, 0, 83, 84, 85, 86,
664 81, 82, 0, 83, 84, 91, 92, 93, 94, 95,
665 96, 97, 91, 92, 93, 94, 95, 96, 97
666 };
667
668 static const yytype_int16 yycheck[] =
669 {
670 24, 44, 26, 3, 16, 29, 42, 38, 3, 14,
671 5, 47, 43, 3, 4, 18, 19, 48, 49, 43,
672 37, 45, 39, 38, 48, 49, 50, 51, 52, 34,
673 42, 34, 35, 36, 18, 19, 43, 21, 22, 23,
674 24, 41, 66, 27, 28, 29, 30, 31, 32, 33,
675 34, 35, 36, 42, 42, 44, 44, 81, 82, 83,
676 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
677 94, 95, 96, 97, 43, 3, 4, 5, 6, 7,
678 8, 9, 10, 11, 12, 13, 14, 15, 16, 43,
679 18, 19, 20, 21, 22, 23, 24, 15, 26, 27,
680 124, 125, 48, 49, 43, 33, 34, 18, 19, 37,
681 43, 39, 155, 41, 43, 43, 43, 45, 46, 43,
682 43, 32, 33, 34, 35, 36, 0, 44, 38, 38,
683 44, 3, 45, 157, 23, 43, 43, 3, 162, 3,
684 164, 3, 4, 5, 6, 7, 8, 9, 10, 11,
685 12, 13, 14, 15, 50, 23, 18, 19, 20, 21,
686 22, 23, 24, 25, 26, 27, 44, 3, 39, 44,
687 3, 33, 23, 17, 44, 37, 41, 39, 3, 41,
688 30, 43, 44, 45, 46, 3, 4, 5, 6, 7,
689 8, 9, 10, 11, 12, 13, 14, 15, 130, 76,
690 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
691 66, 33, 157, 185, 185, 33, 46, -1, -1, 37,
692 -1, 39, -1, 41, -1, 43, -1, 45, 46, 3,
693 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
694 14, 15, -1, -1, 18, 19, 20, 21, 22, 23,
695 24, 25, 26, 27, -1, -1, -1, -1, -1, 33,
696 -1, -1, -1, 37, -1, 39, -1, 41, -1, 43,
697 -1, 45, 46, 3, 4, 5, 6, 7, 8, 9,
698 10, 11, 12, 13, 14, 15, -1, -1, 18, 19,
699 20, 21, 22, 23, 24, -1, 26, 27, -1, -1,
700 -1, -1, -1, 33, 34, -1, -1, 37, -1, 39,
701 -1, 41, -1, 43, -1, 45, 46, 3, 4, 5,
702 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
703 -1, -1, 18, 19, 20, 21, 22, 23, 24, 25,
704 26, 27, -1, -1, -1, -1, -1, 33, -1, -1,
705 -1, 37, -1, 39, -1, 41, -1, 43, -1, 45,
706 46, 3, 4, 5, 6, 7, 8, 9, 10, 11,
707 12, 13, 14, 15, -1, -1, 18, 19, 20, 21,
708 22, 23, 24, -1, 26, 27, -1, -1, -1, -1,
709 -1, 33, -1, -1, -1, 37, -1, 39, -1, 41,
710 -1, 43, -1, 45, 46, 3, 4, 5, 6, 7,
711 8, 9, 10, 11, 12, 13, 14, 15, -1, -1,
712 18, 19, 20, 21, 22, 23, 24, -1, 26, 27,
713 -1, -1, -1, -1, -1, -1, -1, -1, -1, 37,
714 -1, 39, 3, 4, 5, 6, 7, 8, 9, 10,
715 11, 12, 13, 14, 15, -1, -1, 18, 19, 20,
716 21, 22, 23, 24, -1, 26, 27, -1, -1, -1,
717 -1, -1, -1, -1, -1, -1, 37, -1, 39, 18,
718 19, -1, 21, 22, 23, 24, -1, 26, 27, 28,
719 29, 30, 31, 32, 33, 34, 35, 36, -1, -1,
720 -1, -1, -1, -1, 18, 19, -1, 21, 22, 23,
721 24, 50, 26, 27, 28, 29, 30, 31, 32, 33,
722 34, 35, 36, -1, -1, -1, -1, -1, 42, -1,
723 44, 18, 19, -1, 21, 22, 23, 24, -1, 26,
724 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
725 -1, -1, -1, -1, -1, 42, -1, 44, 18, 19,
726 -1, 21, 22, 23, 24, -1, 26, 27, 28, 29,
727 30, 31, 32, 33, 34, 35, 36, 18, 19, -1,
728 21, 22, 23, 24, 44, 26, 27, 28, 29, 30,
729 31, 32, 33, 34, 35, 36, 18, 19, -1, 21,
730 22, 23, 24, 44, 26, 27, 28, 29, 30, 31,
731 32, 33, 34, 35, 36, 18, 19, -1, 21, 22,
732 23, 24, 44, 26, 27, 28, 29, 30, 31, 32,
733 33, 34, 35, 36, 18, 19, -1, 21, 22, 23,
734 24, 44, 26, 27, 28, 29, 30, 31, 32, 33,
735 34, 35, 36, 18, 19, -1, 21, 22, 23, 24,
736 44, 26, 27, 28, 29, 30, 31, 32, 33, 34,
737 35, 36, 18, 19, -1, 21, 22, 23, 24, 44,
738 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
739 36, -1, -1, -1, 18, 19, 42, 21, 22, 23,
740 24, -1, 26, 27, 28, 29, 30, 31, 32, 33,
741 34, 35, 36, -1, -1, -1, 18, 19, 42, 21,
742 22, 23, 24, -1, 26, 27, 28, 29, 30, 31,
743 32, 33, 34, 35, 36, -1, 18, 19, 40, 21,
744 22, 23, 24, -1, 26, 27, 28, 29, 30, 31,
745 32, 33, 34, 35, 36, 18, 19, -1, 21, 22,
746 23, 24, -1, -1, -1, 28, 29, 30, 31, 32,
747 33, 34, 35, 36, 18, 19, -1, 21, 22, 23,
748 24, -1, -1, -1, -1, 29, 30, 31, 32, 33,
749 34, 35, 36, 18, 19, -1, 21, 22, 23, 24,
750 18, 19, -1, 21, 22, 30, 31, 32, 33, 34,
751 35, 36, 30, 31, 32, 33, 34, 35, 36
752 };
753
754 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
755 symbol of state STATE-NUM. */
756 static const yytype_uint8 yystos[] =
757 {
758 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
759 12, 13, 14, 15, 16, 18, 19, 20, 21, 22,
760 23, 24, 26, 27, 33, 34, 37, 39, 41, 43,
761 45, 46, 52, 53, 54, 56, 57, 58, 59, 64,
762 65, 66, 68, 43, 48, 49, 67, 69, 43, 43,
763 43, 43, 43, 43, 43, 43, 15, 6, 7, 8,
764 9, 10, 11, 12, 57, 57, 43, 57, 3, 4,
765 58, 3, 41, 61, 62, 0, 42, 64, 3, 5,
766 55, 18, 19, 21, 22, 23, 24, 26, 27, 28,
767 29, 30, 31, 32, 33, 34, 35, 36, 38, 25,
768 44, 57, 60, 63, 3, 4, 7, 8, 13, 37,
769 68, 25, 57, 69, 57, 57, 57, 57, 57, 44,
770 14, 34, 44, 3, 43, 43, 57, 60, 44, 45,
771 42, 47, 23, 54, 3, 57, 57, 57, 57, 25,
772 57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
773 57, 57, 57, 37, 39, 40, 70, 42, 44, 50,
774 50, 44, 42, 44, 42, 44, 44, 44, 3, 44,
775 23, 57, 57, 44, 62, 3, 39, 68, 44, 63,
776 57, 57, 44, 3, 23, 41, 44, 44, 17, 3,
777 3, 65, 66
778 };
779
780 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
781 static const yytype_uint8 yyr1[] =
782 {
783 0, 51, 52, 52, 52, 53, 53, 54, 54, 55,
784 55, 55, 56, 56, 56, 56, 56, 56, 56, 56,
785 56, 57, 57, 57, 57, 57, 57, 57, 57, 57,
786 57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
787 57, 57, 57, 57, 57, 57, 57, 57, 57, 58,
788 58, 59, 59, 59, 59, 59, 59, 59, 60, 60,
789 61, 61, 62, 62, 63, 63, 64, 65, 65, 66,
790 67, 67, 68, 68, 68, 68, 68, 68, 68, 68,
791 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
792 68, 68, 68, 68, 68, 68, 69, 69, 69, 70
793 };
794
795 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
796 static const yytype_uint8 yyr2[] =
797 {
798 0, 2, 1, 2, 1, 1, 3, 1, 2, 0,
799 1, 2, 1, 4, 4, 4, 4, 4, 3, 4,
800 5, 1, 3, 2, 2, 3, 3, 3, 3, 3,
801 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
802 3, 3, 3, 3, 1, 1, 3, 4, 3, 1,
803 1, 4, 3, 6, 6, 3, 5, 4, 1, 3,
804 3, 5, 1, 1, 1, 1, 6, 1, 1, 2,
805 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
806 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
807 1, 1, 1, 1, 1, 1, 2, 3, 3, 4
808 };
809
810
811 #define yyerrok (yyerrstatus = 0)
812 #define yyclearin (yychar = YYEMPTY)
813 #define YYEMPTY (-2)
814 #define YYEOF 0
815
816 #define YYACCEPT goto yyacceptlab
817 #define YYABORT goto yyabortlab
818 #define YYERROR goto yyerrorlab
819
820
821 #define YYRECOVERING() (!!yyerrstatus)
822
823 #define YYBACKUP(Token, Value) \
824 do \
825 if (yychar == YYEMPTY) \
826 { \
827 yychar = (Token); \
828 yylval = (Value); \
829 YYPOPSTACK (yylen); \
830 yystate = *yyssp; \
831 goto yybackup; \
832 } \
833 else \
834 { \
835 yyerror (pParser, YY_("syntax error: cannot back up")); \
836 YYERROR; \
837 } \
838 while (0)
839
840 /* Error token number */
841 #define YYTERROR 1
842 #define YYERRCODE 256
843
844
845
846 /* Enable debugging if requested. */
847 #if YYDEBUG
848
849 # ifndef YYFPRINTF
850 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
851 # define YYFPRINTF fprintf
852 # endif
853
854 # define YYDPRINTF(Args) \
855 do { \
856 if (yydebug) \
857 YYFPRINTF Args; \
858 } while (0)
859
860 /* This macro is provided for backward compatibility. */
861 #ifndef YY_LOCATION_PRINT
862 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
863 #endif
864
865
866 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
867 do { \
868 if (yydebug) \
869 { \
870 YYFPRINTF (stderr, "%s ", Title); \
871 yy_symbol_print (stderr, \
872 Type, Value, pParser); \
873 YYFPRINTF (stderr, "\n"); \
874 } \
875 } while (0)
876
877
878 /*----------------------------------------.
879 | Print this symbol's value on YYOUTPUT. |
880 `----------------------------------------*/
881
882 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,SelectParser_t * pParser)883 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, SelectParser_t * pParser)
884 {
885 FILE *yyo = yyoutput;
886 YYUSE (yyo);
887 YYUSE (pParser);
888 if (!yyvaluep)
889 return;
890 # ifdef YYPRINT
891 if (yytype < YYNTOKENS)
892 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
893 # endif
894 YYUSE (yytype);
895 }
896
897
898 /*--------------------------------.
899 | Print this symbol on YYOUTPUT. |
900 `--------------------------------*/
901
902 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,SelectParser_t * pParser)903 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, SelectParser_t * pParser)
904 {
905 YYFPRINTF (yyoutput, "%s %s (",
906 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
907
908 yy_symbol_value_print (yyoutput, yytype, yyvaluep, pParser);
909 YYFPRINTF (yyoutput, ")");
910 }
911
912 /*------------------------------------------------------------------.
913 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
914 | TOP (included). |
915 `------------------------------------------------------------------*/
916
917 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)918 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
919 {
920 YYFPRINTF (stderr, "Stack now");
921 for (; yybottom <= yytop; yybottom++)
922 {
923 int yybot = *yybottom;
924 YYFPRINTF (stderr, " %d", yybot);
925 }
926 YYFPRINTF (stderr, "\n");
927 }
928
929 # define YY_STACK_PRINT(Bottom, Top) \
930 do { \
931 if (yydebug) \
932 yy_stack_print ((Bottom), (Top)); \
933 } while (0)
934
935
936 /*------------------------------------------------.
937 | Report that the YYRULE is going to be reduced. |
938 `------------------------------------------------*/
939
940 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,int yyrule,SelectParser_t * pParser)941 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, SelectParser_t * pParser)
942 {
943 unsigned long int yylno = yyrline[yyrule];
944 int yynrhs = yyr2[yyrule];
945 int yyi;
946 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
947 yyrule - 1, yylno);
948 /* The symbols being reduced. */
949 for (yyi = 0; yyi < yynrhs; yyi++)
950 {
951 YYFPRINTF (stderr, " $%d = ", yyi + 1);
952 yy_symbol_print (stderr,
953 yystos[yyssp[yyi + 1 - yynrhs]],
954 &(yyvsp[(yyi + 1) - (yynrhs)])
955 , pParser);
956 YYFPRINTF (stderr, "\n");
957 }
958 }
959
960 # define YY_REDUCE_PRINT(Rule) \
961 do { \
962 if (yydebug) \
963 yy_reduce_print (yyssp, yyvsp, Rule, pParser); \
964 } while (0)
965
966 /* Nonzero means print parse trace. It is left uninitialized so that
967 multiple parsers can coexist. */
968 int yydebug;
969 #else /* !YYDEBUG */
970 # define YYDPRINTF(Args)
971 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
972 # define YY_STACK_PRINT(Bottom, Top)
973 # define YY_REDUCE_PRINT(Rule)
974 #endif /* !YYDEBUG */
975
976
977 /* YYINITDEPTH -- initial size of the parser's stacks. */
978 #ifndef YYINITDEPTH
979 # define YYINITDEPTH 200
980 #endif
981
982 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
983 if the built-in stack extension method is used).
984
985 Do not make this value too large; the results are undefined if
986 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
987 evaluated with infinite-precision integer arithmetic. */
988
989 #ifndef YYMAXDEPTH
990 # define YYMAXDEPTH 10000
991 #endif
992
993
994 #if YYERROR_VERBOSE
995
996 # ifndef yystrlen
997 # if defined __GLIBC__ && defined _STRING_H
998 # define yystrlen strlen
999 # else
1000 /* Return the length of YYSTR. */
1001 static YYSIZE_T
yystrlen(const char * yystr)1002 yystrlen (const char *yystr)
1003 {
1004 YYSIZE_T yylen;
1005 for (yylen = 0; yystr[yylen]; yylen++)
1006 continue;
1007 return yylen;
1008 }
1009 # endif
1010 # endif
1011
1012 # ifndef yystpcpy
1013 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1014 # define yystpcpy stpcpy
1015 # else
1016 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1017 YYDEST. */
1018 static char *
yystpcpy(char * yydest,const char * yysrc)1019 yystpcpy (char *yydest, const char *yysrc)
1020 {
1021 char *yyd = yydest;
1022 const char *yys = yysrc;
1023
1024 while ((*yyd++ = *yys++) != '\0')
1025 continue;
1026
1027 return yyd - 1;
1028 }
1029 # endif
1030 # endif
1031
1032 # ifndef yytnamerr
1033 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1034 quotes and backslashes, so that it's suitable for yyerror. The
1035 heuristic is that double-quoting is unnecessary unless the string
1036 contains an apostrophe, a comma, or backslash (other than
1037 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1038 null, do not copy; instead, return the length of what the result
1039 would have been. */
1040 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1041 yytnamerr (char *yyres, const char *yystr)
1042 {
1043 if (*yystr == '"')
1044 {
1045 YYSIZE_T yyn = 0;
1046 char const *yyp = yystr;
1047
1048 for (;;)
1049 switch (*++yyp)
1050 {
1051 case '\'':
1052 case ',':
1053 goto do_not_strip_quotes;
1054
1055 case '\\':
1056 if (*++yyp != '\\')
1057 goto do_not_strip_quotes;
1058 /* Fall through. */
1059 default:
1060 if (yyres)
1061 yyres[yyn] = *yyp;
1062 yyn++;
1063 break;
1064
1065 case '"':
1066 if (yyres)
1067 yyres[yyn] = '\0';
1068 return yyn;
1069 }
1070 do_not_strip_quotes: ;
1071 }
1072
1073 if (! yyres)
1074 return yystrlen (yystr);
1075
1076 return yystpcpy (yyres, yystr) - yyres;
1077 }
1078 # endif
1079
1080 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1081 about the unexpected token YYTOKEN for the state stack whose top is
1082 YYSSP.
1083
1084 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1085 not large enough to hold the message. In that case, also set
1086 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1087 required number of bytes is too large to store. */
1088 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)1089 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1090 yytype_int16 *yyssp, int yytoken)
1091 {
1092 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1093 YYSIZE_T yysize = yysize0;
1094 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1095 /* Internationalized format string. */
1096 const char *yyformat = YY_NULLPTR;
1097 /* Arguments of yyformat. */
1098 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1099 /* Number of reported tokens (one for the "unexpected", one per
1100 "expected"). */
1101 int yycount = 0;
1102
1103 /* There are many possibilities here to consider:
1104 - If this state is a consistent state with a default action, then
1105 the only way this function was invoked is if the default action
1106 is an error action. In that case, don't check for expected
1107 tokens because there are none.
1108 - The only way there can be no lookahead present (in yychar) is if
1109 this state is a consistent state with a default action. Thus,
1110 detecting the absence of a lookahead is sufficient to determine
1111 that there is no unexpected or expected token to report. In that
1112 case, just report a simple "syntax error".
1113 - Don't assume there isn't a lookahead just because this state is a
1114 consistent state with a default action. There might have been a
1115 previous inconsistent state, consistent state with a non-default
1116 action, or user semantic action that manipulated yychar.
1117 - Of course, the expected token list depends on states to have
1118 correct lookahead information, and it depends on the parser not
1119 to perform extra reductions after fetching a lookahead from the
1120 scanner and before detecting a syntax error. Thus, state merging
1121 (from LALR or IELR) and default reductions corrupt the expected
1122 token list. However, the list is correct for canonical LR with
1123 one exception: it will still contain any token that will not be
1124 accepted due to an error action in a later state.
1125 */
1126 if (yytoken != YYEMPTY)
1127 {
1128 int yyn = yypact[*yyssp];
1129 yyarg[yycount++] = yytname[yytoken];
1130 if (!yypact_value_is_default (yyn))
1131 {
1132 /* Start YYX at -YYN if negative to avoid negative indexes in
1133 YYCHECK. In other words, skip the first -YYN actions for
1134 this state because they are default actions. */
1135 int yyxbegin = yyn < 0 ? -yyn : 0;
1136 /* Stay within bounds of both yycheck and yytname. */
1137 int yychecklim = YYLAST - yyn + 1;
1138 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1139 int yyx;
1140
1141 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1142 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1143 && !yytable_value_is_error (yytable[yyx + yyn]))
1144 {
1145 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1146 {
1147 yycount = 1;
1148 yysize = yysize0;
1149 break;
1150 }
1151 yyarg[yycount++] = yytname[yyx];
1152 {
1153 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1154 if (! (yysize <= yysize1
1155 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1156 return 2;
1157 yysize = yysize1;
1158 }
1159 }
1160 }
1161 }
1162
1163 switch (yycount)
1164 {
1165 # define YYCASE_(N, S) \
1166 case N: \
1167 yyformat = S; \
1168 break
1169 YYCASE_(0, YY_("syntax error"));
1170 YYCASE_(1, YY_("syntax error, unexpected %s"));
1171 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1172 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1173 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1174 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1175 # undef YYCASE_
1176 }
1177
1178 {
1179 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1180 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1181 return 2;
1182 yysize = yysize1;
1183 }
1184
1185 if (*yymsg_alloc < yysize)
1186 {
1187 *yymsg_alloc = 2 * yysize;
1188 if (! (yysize <= *yymsg_alloc
1189 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1190 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1191 return 1;
1192 }
1193
1194 /* Avoid sprintf, as that infringes on the user's name space.
1195 Don't have undefined behavior even if the translation
1196 produced a string with the wrong number of "%s"s. */
1197 {
1198 char *yyp = *yymsg;
1199 int yyi = 0;
1200 while ((*yyp = *yyformat) != '\0')
1201 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1202 {
1203 yyp += yytnamerr (yyp, yyarg[yyi++]);
1204 yyformat += 2;
1205 }
1206 else
1207 {
1208 yyp++;
1209 yyformat++;
1210 }
1211 }
1212 return 0;
1213 }
1214 #endif /* YYERROR_VERBOSE */
1215
1216 /*-----------------------------------------------.
1217 | Release the memory associated to this symbol. |
1218 `-----------------------------------------------*/
1219
1220 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,SelectParser_t * pParser)1221 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, SelectParser_t * pParser)
1222 {
1223 YYUSE (yyvaluep);
1224 YYUSE (pParser);
1225 if (!yymsg)
1226 yymsg = "Deleting";
1227 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1228
1229 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1230 YYUSE (yytype);
1231 YY_IGNORE_MAYBE_UNINITIALIZED_END
1232 }
1233
1234
1235
1236
1237 /*----------.
1238 | yyparse. |
1239 `----------*/
1240
1241 int
yyparse(SelectParser_t * pParser)1242 yyparse (SelectParser_t * pParser)
1243 {
1244 /* The lookahead symbol. */
1245 int yychar;
1246
1247
1248 /* The semantic value of the lookahead symbol. */
1249 /* Default value used for initialization, for pacifying older GCCs
1250 or non-GCC compilers. */
1251 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1252 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1253
1254 /* Number of syntax errors so far. */
1255 int yynerrs;
1256
1257 int yystate;
1258 /* Number of tokens to shift before error messages enabled. */
1259 int yyerrstatus;
1260
1261 /* The stacks and their tools:
1262 'yyss': related to states.
1263 'yyvs': related to semantic values.
1264
1265 Refer to the stacks through separate pointers, to allow yyoverflow
1266 to reallocate them elsewhere. */
1267
1268 /* The state stack. */
1269 yytype_int16 yyssa[YYINITDEPTH];
1270 yytype_int16 *yyss;
1271 yytype_int16 *yyssp;
1272
1273 /* The semantic value stack. */
1274 YYSTYPE yyvsa[YYINITDEPTH];
1275 YYSTYPE *yyvs;
1276 YYSTYPE *yyvsp;
1277
1278 YYSIZE_T yystacksize;
1279
1280 int yyn;
1281 int yyresult;
1282 /* Lookahead token as an internal (translated) token number. */
1283 int yytoken = 0;
1284 /* The variables used to return semantic value and location from the
1285 action routines. */
1286 YYSTYPE yyval;
1287
1288 #if YYERROR_VERBOSE
1289 /* Buffer for error messages, and its allocated size. */
1290 char yymsgbuf[128];
1291 char *yymsg = yymsgbuf;
1292 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1293 #endif
1294
1295 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1296
1297 /* The number of symbols on the RHS of the reduced rule.
1298 Keep to zero when no symbol should be popped. */
1299 int yylen = 0;
1300
1301 yyssp = yyss = yyssa;
1302 yyvsp = yyvs = yyvsa;
1303 yystacksize = YYINITDEPTH;
1304
1305 YYDPRINTF ((stderr, "Starting parse\n"));
1306
1307 yystate = 0;
1308 yyerrstatus = 0;
1309 yynerrs = 0;
1310 yychar = YYEMPTY; /* Cause a token to be read. */
1311 goto yysetstate;
1312
1313 /*------------------------------------------------------------.
1314 | yynewstate -- Push a new state, which is found in yystate. |
1315 `------------------------------------------------------------*/
1316 yynewstate:
1317 /* In all cases, when you get here, the value and location stacks
1318 have just been pushed. So pushing a state here evens the stacks. */
1319 yyssp++;
1320
1321 yysetstate:
1322 *yyssp = yystate;
1323
1324 if (yyss + yystacksize - 1 <= yyssp)
1325 {
1326 /* Get the current used size of the three stacks, in elements. */
1327 YYSIZE_T yysize = yyssp - yyss + 1;
1328
1329 #ifdef yyoverflow
1330 {
1331 /* Give user a chance to reallocate the stack. Use copies of
1332 these so that the &'s don't force the real ones into
1333 memory. */
1334 YYSTYPE *yyvs1 = yyvs;
1335 yytype_int16 *yyss1 = yyss;
1336
1337 /* Each stack pointer address is followed by the size of the
1338 data in use in that stack, in bytes. This used to be a
1339 conditional around just the two extra args, but that might
1340 be undefined if yyoverflow is a macro. */
1341 yyoverflow (YY_("memory exhausted"),
1342 &yyss1, yysize * sizeof (*yyssp),
1343 &yyvs1, yysize * sizeof (*yyvsp),
1344 &yystacksize);
1345
1346 yyss = yyss1;
1347 yyvs = yyvs1;
1348 }
1349 #else /* no yyoverflow */
1350 # ifndef YYSTACK_RELOCATE
1351 goto yyexhaustedlab;
1352 # else
1353 /* Extend the stack our own way. */
1354 if (YYMAXDEPTH <= yystacksize)
1355 goto yyexhaustedlab;
1356 yystacksize *= 2;
1357 if (YYMAXDEPTH < yystacksize)
1358 yystacksize = YYMAXDEPTH;
1359
1360 {
1361 yytype_int16 *yyss1 = yyss;
1362 union yyalloc *yyptr =
1363 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1364 if (! yyptr)
1365 goto yyexhaustedlab;
1366 YYSTACK_RELOCATE (yyss_alloc, yyss);
1367 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1368 # undef YYSTACK_RELOCATE
1369 if (yyss1 != yyssa)
1370 YYSTACK_FREE (yyss1);
1371 }
1372 # endif
1373 #endif /* no yyoverflow */
1374
1375 yyssp = yyss + yysize - 1;
1376 yyvsp = yyvs + yysize - 1;
1377
1378 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1379 (unsigned long int) yystacksize));
1380
1381 if (yyss + yystacksize - 1 <= yyssp)
1382 YYABORT;
1383 }
1384
1385 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1386
1387 if (yystate == YYFINAL)
1388 YYACCEPT;
1389
1390 goto yybackup;
1391
1392 /*-----------.
1393 | yybackup. |
1394 `-----------*/
1395 yybackup:
1396
1397 /* Do appropriate processing given the current state. Read a
1398 lookahead token if we need one and don't already have one. */
1399
1400 /* First try to decide what to do without reference to lookahead token. */
1401 yyn = yypact[yystate];
1402 if (yypact_value_is_default (yyn))
1403 goto yydefault;
1404
1405 /* Not known => get a lookahead token if don't already have one. */
1406
1407 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1408 if (yychar == YYEMPTY)
1409 {
1410 YYDPRINTF ((stderr, "Reading a token: "));
1411 yychar = yylex (&yylval, pParser);
1412 }
1413
1414 if (yychar <= YYEOF)
1415 {
1416 yychar = yytoken = YYEOF;
1417 YYDPRINTF ((stderr, "Now at end of input.\n"));
1418 }
1419 else
1420 {
1421 yytoken = YYTRANSLATE (yychar);
1422 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1423 }
1424
1425 /* If the proper action on seeing token YYTOKEN is to reduce or to
1426 detect an error, take that action. */
1427 yyn += yytoken;
1428 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1429 goto yydefault;
1430 yyn = yytable[yyn];
1431 if (yyn <= 0)
1432 {
1433 if (yytable_value_is_error (yyn))
1434 goto yyerrlab;
1435 yyn = -yyn;
1436 goto yyreduce;
1437 }
1438
1439 /* Count tokens shifted since error; after three, turn off error
1440 status. */
1441 if (yyerrstatus)
1442 yyerrstatus--;
1443
1444 /* Shift the lookahead token. */
1445 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1446
1447 /* Discard the shifted token. */
1448 yychar = YYEMPTY;
1449
1450 yystate = yyn;
1451 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1452 *++yyvsp = yylval;
1453 YY_IGNORE_MAYBE_UNINITIALIZED_END
1454
1455 goto yynewstate;
1456
1457
1458 /*-----------------------------------------------------------.
1459 | yydefault -- do the default action for the current state. |
1460 `-----------------------------------------------------------*/
1461 yydefault:
1462 yyn = yydefact[yystate];
1463 if (yyn == 0)
1464 goto yyerrlab;
1465 goto yyreduce;
1466
1467
1468 /*-----------------------------.
1469 | yyreduce -- Do a reduction. |
1470 `-----------------------------*/
1471 yyreduce:
1472 /* yyn is the number of a rule to reduce with. */
1473 yylen = yyr2[yyn];
1474
1475 /* If YYLEN is nonzero, implement the default value of the action:
1476 '$$ = $1'.
1477
1478 Otherwise, the following line sets YYVAL to garbage.
1479 This behavior is undocumented and Bison
1480 users should not rely upon it. Assigning to YYVAL
1481 unconditionally makes the parser a bit smaller, and it avoids a
1482 GCC warning that YYVAL may be used uninitialized. */
1483 yyval = yyvsp[1-yylen];
1484
1485
1486 YY_REDUCE_PRINT (yyn);
1487 switch (yyn)
1488 {
1489 case 7:
1490
1491 { pParser->AddItem ( &(yyvsp[0]) ); }
1492
1493 break;
1494
1495 case 10:
1496
1497 { pParser->AliasLastItem ( &(yyvsp[0]) ); }
1498
1499 break;
1500
1501 case 11:
1502
1503 { pParser->AliasLastItem ( &(yyvsp[0]) ); }
1504
1505 break;
1506
1507 case 12:
1508
1509 { pParser->AddItem ( &(yyvsp[0]) ); }
1510
1511 break;
1512
1513 case 13:
1514
1515 { pParser->AddItem ( &(yyvsp[-1]), SPH_AGGR_AVG, &(yyvsp[-3]), &(yyvsp[0]) ); }
1516
1517 break;
1518
1519 case 14:
1520
1521 { pParser->AddItem ( &(yyvsp[-1]), SPH_AGGR_MAX, &(yyvsp[-3]), &(yyvsp[0]) ); }
1522
1523 break;
1524
1525 case 15:
1526
1527 { pParser->AddItem ( &(yyvsp[-1]), SPH_AGGR_MIN, &(yyvsp[-3]), &(yyvsp[0]) ); }
1528
1529 break;
1530
1531 case 16:
1532
1533 { pParser->AddItem ( &(yyvsp[-1]), SPH_AGGR_SUM, &(yyvsp[-3]), &(yyvsp[0]) ); }
1534
1535 break;
1536
1537 case 17:
1538
1539 { pParser->AddItem ( &(yyvsp[-1]), SPH_AGGR_CAT, &(yyvsp[-3]), &(yyvsp[0]) ); }
1540
1541 break;
1542
1543 case 18:
1544
1545 { pParser->AddItem ( "groupby()", &(yyvsp[-2]), &(yyvsp[0]) ); }
1546
1547 break;
1548
1549 case 19:
1550
1551 { pParser->AddItem ( "count(*)", &(yyvsp[-3]), &(yyvsp[0]) ); }
1552
1553 break;
1554
1555 case 20:
1556
1557 { pParser->AddItem ( "@distinct", &(yyvsp[-4]), &(yyvsp[0]) ); }
1558
1559 break;
1560
1561 case 22:
1562
1563 { (yyval) = (yyvsp[-1]); (yyval).m_iEnd = (yyvsp[-1]).m_iEnd; }
1564
1565 break;
1566
1567 case 23:
1568
1569 { (yyval) = (yyvsp[-1]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1570
1571 break;
1572
1573 case 24:
1574
1575 { (yyval) = (yyvsp[-1]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1576
1577 break;
1578
1579 case 25:
1580
1581 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1582
1583 break;
1584
1585 case 26:
1586
1587 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1588
1589 break;
1590
1591 case 27:
1592
1593 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1594
1595 break;
1596
1597 case 28:
1598
1599 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1600
1601 break;
1602
1603 case 29:
1604
1605 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1606
1607 break;
1608
1609 case 30:
1610
1611 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1612
1613 break;
1614
1615 case 31:
1616
1617 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1618
1619 break;
1620
1621 case 32:
1622
1623 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1624
1625 break;
1626
1627 case 33:
1628
1629 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1630
1631 break;
1632
1633 case 34:
1634
1635 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1636
1637 break;
1638
1639 case 35:
1640
1641 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1642
1643 break;
1644
1645 case 36:
1646
1647 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1648
1649 break;
1650
1651 case 37:
1652
1653 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1654
1655 break;
1656
1657 case 38:
1658
1659 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1660
1661 break;
1662
1663 case 39:
1664
1665 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1666
1667 break;
1668
1669 case 40:
1670
1671 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1672
1673 break;
1674
1675 case 41:
1676
1677 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1678
1679 break;
1680
1681 case 42:
1682
1683 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1684
1685 break;
1686
1687 case 43:
1688
1689 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1690
1691 break;
1692
1693 case 46:
1694
1695 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1696
1697 break;
1698
1699 case 47:
1700
1701 { (yyval) = (yyvsp[-3]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1702
1703 break;
1704
1705 case 48:
1706
1707 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1708
1709 break;
1710
1711 case 51:
1712
1713 { (yyval) = (yyvsp[-3]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1714
1715 break;
1716
1717 case 52:
1718
1719 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1720
1721 break;
1722
1723 case 53:
1724
1725 { (yyval) = (yyvsp[-5]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1726
1727 break;
1728
1729 case 54:
1730
1731 { (yyval) = (yyvsp[-5]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1732
1733 break;
1734
1735 case 55:
1736
1737 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1738
1739 break;
1740
1741 case 56:
1742
1743 { (yyval) = (yyvsp[-4]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1744
1745 break;
1746
1747 case 57:
1748
1749 { (yyval) = (yyvsp[-3]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1750
1751 break;
1752
1753 case 66:
1754
1755 {
1756 pParser->AddOption ( &(yyvsp[-3]), &(yyvsp[-1]) );
1757 }
1758
1759 break;
1760
1761 case 69:
1762
1763 { (yyval) = (yyvsp[-1]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1764
1765 break;
1766
1767 case 71:
1768
1769 { (yyval) = (yyvsp[-1]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1770
1771 break;
1772
1773 case 96:
1774
1775 { (yyval) = (yyvsp[-1]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1776
1777 break;
1778
1779 case 97:
1780
1781 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1782
1783 break;
1784
1785 case 98:
1786
1787 { (yyval) = (yyvsp[-2]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1788
1789 break;
1790
1791 case 99:
1792
1793 { (yyval) = (yyvsp[-3]); (yyval).m_iEnd = (yyvsp[0]).m_iEnd; }
1794
1795 break;
1796
1797
1798
1799 default: break;
1800 }
1801 /* User semantic actions sometimes alter yychar, and that requires
1802 that yytoken be updated with the new translation. We take the
1803 approach of translating immediately before every use of yytoken.
1804 One alternative is translating here after every semantic action,
1805 but that translation would be missed if the semantic action invokes
1806 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1807 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1808 incorrect destructor might then be invoked immediately. In the
1809 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1810 to an incorrect destructor call or verbose syntax error message
1811 before the lookahead is translated. */
1812 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1813
1814 YYPOPSTACK (yylen);
1815 yylen = 0;
1816 YY_STACK_PRINT (yyss, yyssp);
1817
1818 *++yyvsp = yyval;
1819
1820 /* Now 'shift' the result of the reduction. Determine what state
1821 that goes to, based on the state we popped back to and the rule
1822 number reduced by. */
1823
1824 yyn = yyr1[yyn];
1825
1826 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1827 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1828 yystate = yytable[yystate];
1829 else
1830 yystate = yydefgoto[yyn - YYNTOKENS];
1831
1832 goto yynewstate;
1833
1834
1835 /*--------------------------------------.
1836 | yyerrlab -- here on detecting error. |
1837 `--------------------------------------*/
1838 yyerrlab:
1839 /* Make sure we have latest lookahead translation. See comments at
1840 user semantic actions for why this is necessary. */
1841 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1842
1843 /* If not already recovering from an error, report this error. */
1844 if (!yyerrstatus)
1845 {
1846 ++yynerrs;
1847 #if ! YYERROR_VERBOSE
1848 yyerror (pParser, YY_("syntax error"));
1849 #else
1850 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1851 yyssp, yytoken)
1852 {
1853 char const *yymsgp = YY_("syntax error");
1854 int yysyntax_error_status;
1855 yysyntax_error_status = YYSYNTAX_ERROR;
1856 if (yysyntax_error_status == 0)
1857 yymsgp = yymsg;
1858 else if (yysyntax_error_status == 1)
1859 {
1860 if (yymsg != yymsgbuf)
1861 YYSTACK_FREE (yymsg);
1862 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1863 if (!yymsg)
1864 {
1865 yymsg = yymsgbuf;
1866 yymsg_alloc = sizeof yymsgbuf;
1867 yysyntax_error_status = 2;
1868 }
1869 else
1870 {
1871 yysyntax_error_status = YYSYNTAX_ERROR;
1872 yymsgp = yymsg;
1873 }
1874 }
1875 yyerror (pParser, yymsgp);
1876 if (yysyntax_error_status == 2)
1877 goto yyexhaustedlab;
1878 }
1879 # undef YYSYNTAX_ERROR
1880 #endif
1881 }
1882
1883
1884
1885 if (yyerrstatus == 3)
1886 {
1887 /* If just tried and failed to reuse lookahead token after an
1888 error, discard it. */
1889
1890 if (yychar <= YYEOF)
1891 {
1892 /* Return failure if at end of input. */
1893 if (yychar == YYEOF)
1894 YYABORT;
1895 }
1896 else
1897 {
1898 yydestruct ("Error: discarding",
1899 yytoken, &yylval, pParser);
1900 yychar = YYEMPTY;
1901 }
1902 }
1903
1904 /* Else will try to reuse lookahead token after shifting the error
1905 token. */
1906 goto yyerrlab1;
1907
1908
1909 /*---------------------------------------------------.
1910 | yyerrorlab -- error raised explicitly by YYERROR. |
1911 `---------------------------------------------------*/
1912 yyerrorlab:
1913
1914 /* Pacify compilers like GCC when the user code never invokes
1915 YYERROR and the label yyerrorlab therefore never appears in user
1916 code. */
1917 if (/*CONSTCOND*/ 0)
1918 goto yyerrorlab;
1919
1920 /* Do not reclaim the symbols of the rule whose action triggered
1921 this YYERROR. */
1922 YYPOPSTACK (yylen);
1923 yylen = 0;
1924 YY_STACK_PRINT (yyss, yyssp);
1925 yystate = *yyssp;
1926 goto yyerrlab1;
1927
1928
1929 /*-------------------------------------------------------------.
1930 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1931 `-------------------------------------------------------------*/
1932 yyerrlab1:
1933 yyerrstatus = 3; /* Each real token shifted decrements this. */
1934
1935 for (;;)
1936 {
1937 yyn = yypact[yystate];
1938 if (!yypact_value_is_default (yyn))
1939 {
1940 yyn += YYTERROR;
1941 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1942 {
1943 yyn = yytable[yyn];
1944 if (0 < yyn)
1945 break;
1946 }
1947 }
1948
1949 /* Pop the current state because it cannot handle the error token. */
1950 if (yyssp == yyss)
1951 YYABORT;
1952
1953
1954 yydestruct ("Error: popping",
1955 yystos[yystate], yyvsp, pParser);
1956 YYPOPSTACK (1);
1957 yystate = *yyssp;
1958 YY_STACK_PRINT (yyss, yyssp);
1959 }
1960
1961 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1962 *++yyvsp = yylval;
1963 YY_IGNORE_MAYBE_UNINITIALIZED_END
1964
1965
1966 /* Shift the error token. */
1967 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1968
1969 yystate = yyn;
1970 goto yynewstate;
1971
1972
1973 /*-------------------------------------.
1974 | yyacceptlab -- YYACCEPT comes here. |
1975 `-------------------------------------*/
1976 yyacceptlab:
1977 yyresult = 0;
1978 goto yyreturn;
1979
1980 /*-----------------------------------.
1981 | yyabortlab -- YYABORT comes here. |
1982 `-----------------------------------*/
1983 yyabortlab:
1984 yyresult = 1;
1985 goto yyreturn;
1986
1987 #if !defined yyoverflow || YYERROR_VERBOSE
1988 /*-------------------------------------------------.
1989 | yyexhaustedlab -- memory exhaustion comes here. |
1990 `-------------------------------------------------*/
1991 yyexhaustedlab:
1992 yyerror (pParser, YY_("memory exhausted"));
1993 yyresult = 2;
1994 /* Fall through. */
1995 #endif
1996
1997 yyreturn:
1998 if (yychar != YYEMPTY)
1999 {
2000 /* Make sure we have latest lookahead translation. See comments at
2001 user semantic actions for why this is necessary. */
2002 yytoken = YYTRANSLATE (yychar);
2003 yydestruct ("Cleanup: discarding lookahead",
2004 yytoken, &yylval, pParser);
2005 }
2006 /* Do not reclaim the symbols of the rule whose action triggered
2007 this YYABORT or YYACCEPT. */
2008 YYPOPSTACK (yylen);
2009 YY_STACK_PRINT (yyss, yyssp);
2010 while (yyssp != yyss)
2011 {
2012 yydestruct ("Cleanup: popping",
2013 yystos[*yyssp], yyvsp, pParser);
2014 YYPOPSTACK (1);
2015 }
2016 #ifndef yyoverflow
2017 if (yyss != yyssa)
2018 YYSTACK_FREE (yyss);
2019 #endif
2020 #if YYERROR_VERBOSE
2021 if (yymsg != yymsgbuf)
2022 YYSTACK_FREE (yymsg);
2023 #endif
2024 return yyresult;
2025 }
2026
2027
2028
2029 #if USE_WINDOWS
2030 #pragma warning(pop)
2031 #endif
2032