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