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