Ruby: tool/lrama/template/bison/yacc.c Source File

Ruby 3.4.8p72 (2025-12-17 revision 995b59f66677d44767ce9faac6957e5543617ff9)

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