3 # Yacc compatible skeleton for Bison
5 # Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation,
8 # This program is free software: you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation, either version 3 of the License, or
11 # (at your option) any later version.
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with this program. If not, see <http://www.gnu.org/licenses/>.
21 # Check the value of %define api.push-pull.
22 b4_percent_define_default([[api
.push
-pull
]], [[pull]])
23 b4_percent_define_check_values([[[[api
.push
-pull
]],
24 [[pull]], [[push]], [[both]]]])
25 b4_define_flag_if([pull
]) m4_define([b4_pull_flag
], [[1]])
26 b4_define_flag_if([push
]) m4_define([b4_push_flag
], [[1]])
27 m4_case(b4_percent_define_get([[api
.push
-pull
]]),
28 [pull
], [m4_define([b4_push_flag
], [[0]])],
29 [push
], [m4_define([b4_pull_flag
], [[0]])])
31 # Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing
32 # tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the
33 # behavior of Bison at all when push parsing is already requested.
34 b4_define_flag_if([use_push_for_pull
])
35 b4_use_push_for_pull_if([
36 b4_push_if([m4_define([b4_use_push_for_pull_flag
], [[0]])],
37 [m4_define([b4_push_flag
], [[1]])])])
39 # Check the value of %define parse.lac and friends, where LAC stands for
40 # lookahead correction.
41 b4_percent_define_default([[parse
.lac
]], [[none]])
42 b4_percent_define_default([[parse
.lac
.es
-capacity
-initial
]], [[20]])
43 b4_percent_define_default([[parse
.lac
.memory
-trace
]], [[failures]])
44 b4_percent_define_check_values([[[[parse
.lac
]], [[full]], [[none]]]],
45 [[[[parse
.lac
.memory
-trace
]],
46 [[failures]], [[full]]]])
47 b4_define_flag_if([lac
])
48 m4_define([b4_lac_flag
],
49 [m4_if(b4_percent_define_get([[parse
.lac
]]),
50 [none
], [[0]], [[1]])])
52 m4_include(b4_pkgdatadir
/[c
.m4
])
54 ## ---------------- ##
56 ## ---------------- ##
59 m4_define_default([b4_stack_depth_max
], [10000])
60 m4_define_default([b4_stack_depth_init
], [200])
63 ## ------------------------ ##
64 ## Pure/impure interfaces. ##
65 ## ------------------------ ##
67 b4_percent_define_default([[api
.pure
]], [[false]])
68 b4_define_flag_if([pure
])
69 m4_define([b4_pure_flag
],
70 [b4_percent_define_flag_if([[api
.pure
]], [[1]], [[0]])])
72 # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
73 # ----------------------------------
74 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
75 m4_define([b4_yacc_pure_if
],
76 [b4_pure_if([m4_ifset([b4_parse_param
],
83 # Arguments passed to yyerror: user args plus yylloc.
84 m4_define([b4_yyerror_args
],
85 [b4_yacc_pure_if([b4_locations_if([&yylloc
, ])])dnl
86 m4_ifset([b4_parse_param
], [b4_c_args(b4_parse_param
), ])])
91 # Accumulate in b4_lex_param all the yylex arguments.
92 # b4_lex_param arrives quoted twice, but we want to keep only one level.
93 m4_define([b4_lex_param
],
94 m4_dquote(b4_pure_if([[[[YYSTYPE
*]], [[&yylval
]]][]dnl
95 b4_locations_if([, [[YYLTYPE
*], [&yylloc
]]])m4_ifdef([b4_lex_param
], [, ])])dnl
96 m4_ifdef([b4_lex_param
], b4_lex_param
)))
103 # b4_int_type(MIN, MAX)
104 # ---------------------
105 # Return the smallest int type able to handle numbers ranging from
106 # MIN to MAX (included). Overwrite the version from c.m4, which
107 # uses only C89 types, so that the user can override the shorter
108 # types, and so that pre-C89 compilers are handled correctly.
109 m4_define([b4_int_type
],
110 [m4_if(b4_ints_in($@
, [0], [255]), [1], [yytype_uint8
],
111 b4_ints_in($@
, [-128], [127]), [1], [yytype_int8
],
113 b4_ints_in($@
, [0], [65535]), [1], [yytype_uint16
],
114 b4_ints_in($@
, [-32768], [32767]), [1], [yytype_int16
],
116 m4_eval([0 <= $
1]), [1], [unsigned int],
121 ## ----------------- ##
122 ## Semantic Values. ##
123 ## ----------------- ##
126 # b4_lhs_value([TYPE])
127 # --------------------
128 # Expansion of $<TYPE>$.
129 m4_define([b4_lhs_value
],
130 [(yyval
[]m4_ifval([$
1], [.$
1]))])
133 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
134 # --------------------------------------
135 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
137 m4_define([b4_rhs_value
],
138 [(yyvsp@
{($
2) - ($
1)@
}m4_ifval([$
3], [.$
3]))])
149 m4_define([b4_lhs_location
],
153 # b4_rhs_location(RULE-LENGTH, NUM)
154 # ---------------------------------
155 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
157 m4_define([b4_rhs_location
],
158 [(yylsp@
{($
2) - ($
1)@
})])
161 ## ------------------ ##
162 ## Parser variables. ##
163 ## ------------------ ##
165 # b4_declare_scanner_communication_variables
166 # ------------------------------------------
167 # Declare the variables that are global, or local to YYPARSE if
169 m4_define([b4_declare_scanner_communication_variables
], [[
170 /* The lookahead symbol. */
173 /* The semantic value of the lookahead symbol. */
174 YYSTYPE yylval
;]b4_locations_if([[
176 /* Location data for the lookahead symbol. */
177 YYLTYPE yylloc
;]])b4_pure_if([], [[
179 /* Number of syntax errors so far. */
183 # b4_declare_parser_state_variables
184 # ---------------------------------
185 # Declare all the variables that are needed to maintain the parser state
186 # between calls to yypush_parse.
187 m4_define([b4_declare_parser_state_variables
], [b4_pure_if([[
188 /* Number of syntax errors so far. */
192 /* Number of tokens to shift before error messages enabled. */
195 /* The stacks and their tools:
196 `yyss': related to states.
197 `yyvs': related to semantic values.]b4_locations_if([[
198 `yyls': related to locations.]])[
200 Refer to the stacks thru separate pointers, to allow yyoverflow
201 to reallocate them elsewhere. */
203 /* The state stack. */
204 yytype_int16 yyssa
[YYINITDEPTH
];
208 /* The semantic value stack. */
209 YYSTYPE yyvsa
[YYINITDEPTH
];
211 YYSTYPE
*yyvsp
;]b4_locations_if([[
213 /* The location stack. */
214 YYLTYPE yylsa
[YYINITDEPTH
];
218 /* The locations where the error started and ended. */
219 YYLTYPE yyerror_range
[3];]])[
221 YYSIZE_T yystacksize
;]b4_lac_if([[
223 yytype_int16 yyesa@
{]b4_percent_define_get([[parse
.lac
.es
-capacity
-initial
]])[@
};
225 YYSIZE_T yyes_capacity
;]])])
228 ## --------------------------------------------------------- ##
229 ## Defining symbol actions, e.g., printers and destructors. ##
230 ## --------------------------------------------------------- ##
232 # We do want M4 expansion after # for CPP macros.
235 @
output(b4_parser_file_name@
)@
236 b4_copyright([Bison implementation
for Yacc
-like parsers in C
],
237 [1984, 1989-1990, 2000-2011])[
239 /* C LALR(1) parser skeleton written by Richard Stallman, by
240 simplifying the original so-called "semantic" parser. */
242 /* All symbols defined below should begin with yy or YY, to avoid
243 infringing on user name space. This should be done even for local
244 variables, as they might otherwise be expanded by user macros.
245 There are some unavoidable exceptions within include files to
246 define necessary library symbols; they are noted "INFRINGES ON
247 USER NAME SPACE" below. */
250 b4_percent_code_get([[top]])[]dnl
251 m4_if(b4_prefix
, [yy
], [],
252 [[/* Substitute the variable and function names. */]b4_pull_if([[
253 #define yyparse ]b4_prefix[parse]])b4_push_if([[
254 #define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[
255 #define yypull_parse ]b4_prefix[pull_parse]])[
256 #define yypstate_new ]b4_prefix[pstate_new
257 #define yypstate_delete ]b4_prefix[pstate_delete
258 #define yypstate ]b4_prefix[pstate]])[
259 #define yylex ]b4_prefix[lex
260 #define yyerror ]b4_prefix[error
261 #define yylval ]b4_prefix[lval
262 #define yychar ]b4_prefix[char
263 #define yydebug ]b4_prefix[debug
264 #define yynerrs ]b4_prefix[nerrs
265 ]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[
267 /* Copy the first part of user declarations. */
268 ]b4_user_pre_prologue
[
270 /* Enabling traces. */
272 # define YYDEBUG ]b4_debug_flag[
275 /* Enabling verbose error messages. */
276 #ifdef YYERROR_VERBOSE
277 # undef YYERROR_VERBOSE
278 # define YYERROR_VERBOSE 1
280 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
283 /* Enabling the token table. */
284 #ifndef YYTOKEN_TABLE
285 # define YYTOKEN_TABLE ]b4_token_table[
288 ]b4_percent_code_get([[requires]])[]dnl
290 b4_token_enums_defines(b4_tokens
)[
292 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
293 ]m4_ifdef([b4_stype
],
294 [[typedef union ]b4_union_name
[
298 # define YYSTYPE_IS_TRIVIAL 1]],
299 [m4_if(b4_tag_seen_flag
, 0,
300 [[typedef int YYSTYPE
;
301 # define YYSTYPE_IS_TRIVIAL 1]])])[
302 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
303 # define YYSTYPE_IS_DECLARED 1
304 #endif]b4_locations_if([[
306 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
307 typedef struct YYLTYPE
314 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
315 # define YYLTYPE_IS_DECLARED 1
316 # define YYLTYPE_IS_TRIVIAL 1
317 #endif]])b4_push_if([[
320 # define YYPUSH_DECLS
322 typedef struct yypstate yypstate
;
323 enum { YYPUSH_MORE
= 4 };
325 ]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param
)
326 ])b4_c_function_decl([[yypush_parse]], [[int]],
327 [[[yypstate
*yyps
]], [[yyps]]]b4_pure_if([,
328 [[[int yypushed_char]], [[yypushed_char]]],
329 [[[YYSTYPE
const *yypushed_val
]], [[yypushed_val]]]b4_locations_if([,
330 [[[YYLTYPE
const *yypushed_loc
]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param
], [,
332 b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
333 [[[yypstate
*yyps
]], [[yyps]]]m4_ifset([b4_parse_param
], [,
335 b4_c_function_decl([[yypstate_new]], [[yypstate
*]], [[[void]], []])
336 b4_c_function_decl([[yypstate_delete]], [[void]],
337 [[[yypstate
*yyps
]], [[yyps]]])[
340 b4_percent_code_get([[provides]])[]dnl
342 [/* Copy the second part of user declarations. */
343 ]b4_user_post_prologue
344 b4_percent_code_get
[]dnl
351 typedef YYTYPE_UINT8 yytype_uint8
;
353 typedef unsigned char yytype_uint8
;
357 typedef YYTYPE_INT8 yytype_int8
;
359 typedef signed char yytype_int8
;
361 typedef short int yytype_int8
;
365 typedef YYTYPE_UINT16 yytype_uint16
;
367 typedef unsigned short int yytype_uint16
;
371 typedef YYTYPE_INT16 yytype_int16
;
373 typedef short int yytype_int16
;
377 # ifdef __SIZE_TYPE__
378 # define YYSIZE_T __SIZE_TYPE__
379 # elif defined size_t
380 # define YYSIZE_T size_t
381 # elif ! defined YYSIZE_T && ]b4_c_modern[
382 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
383 # define YYSIZE_T size_t
385 # define YYSIZE_T unsigned int
389 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
392 # if defined YYENABLE_NLS && YYENABLE_NLS
394 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
395 # define YY_(msgid) dgettext ("bison-runtime", msgid)
399 # define YY_(msgid) msgid
403 /* Suppress unused-variable warnings by "using" E. */
404 #if ! defined lint || defined __GNUC__
405 # define YYUSE(e) ((void) (e))
407 # define YYUSE(e) /* empty */
410 /* Identity function, used to suppress warnings about constant conditions. */
414 ]b4_c_function_def([YYID
], [static int], [[int yyi
], [yyi
]])[
420 #if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[
422 /* The parser invokes alloca or malloc; define the necessary symbols. */]dnl
423 b4_push_if([], [b4_lac_if([], [[
425 # ifdef YYSTACK_USE_ALLOCA
426 # if YYSTACK_USE_ALLOCA
428 # define YYSTACK_ALLOC __builtin_alloca
429 # elif defined __BUILTIN_VA_ARG_INCR
430 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
432 # define YYSTACK_ALLOC __alloca
433 # elif defined _MSC_VER
434 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
435 # define alloca _alloca
437 # define YYSTACK_ALLOC alloca
438 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && ]b4_c_modern[
439 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
440 # ifndef EXIT_SUCCESS
441 # define EXIT_SUCCESS 0
448 # ifdef YYSTACK_ALLOC
449 /* Pacify GCC's `empty if-body' warning. */
450 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
451 # ifndef YYSTACK_ALLOC_MAXIMUM
452 /* The OS might guarantee only one guard page at the bottom of the stack,
453 and a page size can be as small as 4096 bytes. So we cannot safely
454 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
455 to allow for a few compiler-allocated temporary stack slots. */
456 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
459 # define YYSTACK_ALLOC YYMALLOC
460 # define YYSTACK_FREE YYFREE
461 # ifndef YYSTACK_ALLOC_MAXIMUM
462 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
464 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
465 && ! ((defined YYMALLOC || defined malloc) \
466 && (defined YYFREE || defined free)))
467 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
468 # ifndef EXIT_SUCCESS
469 # define EXIT_SUCCESS 0
473 # define YYMALLOC malloc
474 # if ! defined malloc && ! defined EXIT_SUCCESS && ]b4_c_modern[
475 void *malloc (YYSIZE_T
); /* INFRINGES ON USER NAME SPACE */
480 # if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[
481 void free (void *); /* INFRINGES ON USER NAME SPACE */
485 # define YYCOPY_NEEDED 1]])[
486 #endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[
489 #if (! defined yyoverflow \
490 && (! defined __cplusplus \
491 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
492 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
494 /* A type that is properly aligned for any stack member. */
497 yytype_int16 yyss_alloc
;
498 YYSTYPE yyvs_alloc
;]b4_locations_if([
499 YYLTYPE yyls_alloc
;])[
502 /* The size of the maximum gap between one aligned stack and the next. */
503 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
505 /* The size of an array large to enough to hold all stacks, each with
508 [# define YYSTACK_BYTES(N) \
509 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
510 + 2 * YYSTACK_GAP_MAXIMUM)],
511 [# define YYSTACK_BYTES(N) \
512 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
513 + YYSTACK_GAP_MAXIMUM)])[
515 # define YYCOPY_NEEDED 1
517 /* Relocate STACK from its old location to the new one. The
518 local variables YYSIZE and YYSTACKSIZE give the old and new number of
519 elements in the stack, and YYPTR gives the new location of the
520 stack. Advance YYPTR to a properly aligned location for the next
522 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
525 YYSIZE_T yynewbytes; \
526 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
527 Stack = &yyptr->Stack_alloc; \
528 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
529 yyptr += yynewbytes / sizeof (*yyptr); \
535 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
536 /* Copy COUNT objects from FROM to TO. The source and destination do
539 # if defined __GNUC__ && 1 < __GNUC__
540 # define YYCOPY(To, From, Count) \
541 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
543 # define YYCOPY(To, From, Count) \
547 for (yyi = 0; yyi < (Count); yyi++) \
548 (To)[yyi] = (From)[yyi]; \
553 #endif /* !YYCOPY_NEEDED */
555 /* YYFINAL -- State number of the termination state. */
556 #define YYFINAL ]b4_final_state_number[
557 /* YYLAST -- Last index in YYTABLE. */
558 #define YYLAST ]b4_last[
560 /* YYNTOKENS -- Number of terminals. */
561 #define YYNTOKENS ]b4_tokens_number[
562 /* YYNNTS -- Number of nonterminals. */
563 #define YYNNTS ]b4_nterms_number[
564 /* YYNRULES -- Number of rules. */
565 #define YYNRULES ]b4_rules_number[
566 /* YYNRULES -- Number of states. */
567 #define YYNSTATES ]b4_states_number[
569 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
570 #define YYUNDEFTOK ]b4_undef_token_number[
571 #define YYMAXUTOK ]b4_user_token_number_max[
573 #define YYTRANSLATE(YYX) \
574 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
576 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
577 static const ]b4_int_type_for([b4_translate
])[ yytranslate
[] =
583 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
585 static const ]b4_int_type_for([b4_prhs
])[ yyprhs
[] =
590 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
591 static const ]b4_int_type_for([b4_rhs
])[ yyrhs
[] =
596 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
597 static const ]b4_int_type_for([b4_rline
])[ yyrline
[] =
603 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
604 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
605 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
606 static const char *const yytname
[] =
613 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
615 static const ]b4_int_type_for([b4_toknum
])[ yytoknum
[] =
621 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
622 static const ]b4_int_type_for([b4_r1
])[ yyr1
[] =
627 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
628 static const ]b4_int_type_for([b4_r2
])[ yyr2
[] =
633 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
634 Performed when YYTABLE doesn't specify something else to do. Zero
635 means the default is an error. */
636 static const ]b4_int_type_for([b4_defact
])[ yydefact
[] =
641 /* YYDEFGOTO[NTERM-NUM]. */
642 static const ]b4_int_type_for([b4_defgoto
])[ yydefgoto
[] =
647 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
649 #define YYPACT_NINF ]b4_pact_ninf[
650 static const ]b4_int_type_for([b4_pact
])[ yypact
[] =
655 /* YYPGOTO[NTERM-NUM]. */
656 static const ]b4_int_type_for([b4_pgoto
])[ yypgoto
[] =
661 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
662 positive, shift that token. If negative, reduce the rule which
663 number is the opposite. If YYTABLE_NINF, syntax error. */
664 #define YYTABLE_NINF ]b4_table_ninf[
665 static const ]b4_int_type_for([b4_table
])[ yytable
[] =
670 #define yypact_value_is_default(yystate) \
671 ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
673 #define yytable_value_is_error(yytable_value) \
674 ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
676 static const ]b4_int_type_for([b4_check
])[ yycheck
[] =
681 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
682 symbol of state STATE-NUM. */
683 static const ]b4_int_type_for([b4_stos
])[ yystos
[] =
688 #define yyerrok (yyerrstatus = 0)
689 #define yyclearin (yychar = YYEMPTY)
693 #define YYACCEPT goto yyacceptlab
694 #define YYABORT goto yyabortlab
695 #define YYERROR goto yyerrorlab
698 /* Like YYERROR except do call yyerror. This remains here temporarily
699 to ease the transition to the new meaning of YYERROR, for GCC.
700 Once GCC version 2 has supplanted version 1, this can go. However,
701 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
702 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
705 #define YYFAIL goto yyerrlab
707 /* This is here to suppress warnings from the GCC cpp's
708 -Wunused-macros. Normally we don't worry about that warning, but
709 some users do, and we want to make it easy for users to remove
710 YYFAIL uses, which will produce warnings from Bison 2.5. */
713 #define YYRECOVERING() (!!yyerrstatus)
715 #define YYBACKUP(Token, Value) \
717 if (yychar == YYEMPTY && yylen == 1) \
721 YYPOPSTACK (1); \]b4_lac_if([[
722 YY_LAC_DISCARD ("YYBACKUP"); \
]])[
727 yyerror (]b4_yyerror_args
[YY_("syntax error: cannot back up")); \
734 #define YYERRCODE 256
737 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
738 If N is 0, then set CURRENT to the empty location which ends
739 the previous symbol: RHS[0] (always defined). */
741 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
742 #ifndef YYLLOC_DEFAULT
743 # define YYLLOC_DEFAULT(Current, Rhs, N) \
747 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
748 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
749 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
750 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
754 (Current).first_line = (Current).last_line = \
755 YYRHSLOC (Rhs, 0).last_line; \
756 (Current).first_column = (Current).last_column = \
757 YYRHSLOC (Rhs, 0).last_column; \
760 #endif]b4_locations_if([[
763 /* YY_LOCATION_PRINT -- Print the location on the stream.
764 This macro was not mandated originally: define only if we know
765 we won't break user code: when these are the locations we know. */
767 #ifndef YY_LOCATION_PRINT
768 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
769 # define YY_LOCATION_PRINT(File, Loc) \
770 fprintf (File, "%d.%d-%d.%d", \
771 (Loc).first_line, (Loc).first_column, \
772 (Loc).last_line, (Loc).last_column)
774 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
779 /* This macro is provided for backward compatibility. */
781 #ifndef YY_LOCATION_PRINT
782 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
786 /* YYLEX -- calling `yylex' with the right arguments. */
789 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
791 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
794 /* Enable debugging if requested. */
798 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
799 # define YYFPRINTF fprintf
802 # define YYDPRINTF(Args) \
808 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
812 YYFPRINTF (stderr, "%s ", Title); \
813 yy_symbol_print (stderr, \
814 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
815 YYFPRINTF (stderr, "\n"); \
819 ]b4_yy_symbol_print_generate([b4_c_function_def
])[
821 /*------------------------------------------------------------------.
822 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
824 `------------------------------------------------------------------*/
826 ]b4_c_function_def([yy_stack_print
], [static void],
827 [[yytype_int16
*yybottom
], [yybottom
]],
828 [[yytype_int16
*yytop
], [yytop
]])[
830 YYFPRINTF (stderr
, "Stack now");
831 for (; yybottom
<= yytop
; yybottom
++)
833 int yybot
= *yybottom
;
834 YYFPRINTF (stderr
, " %d", yybot
);
836 YYFPRINTF (stderr
, "\n");
839 # define YY_STACK_PRINT(Bottom, Top) \
842 yy_stack_print ((Bottom), (Top)); \
846 /*------------------------------------------------.
847 | Report that the YYRULE is going to be reduced. |
848 `------------------------------------------------*/
850 ]b4_c_function_def([yy_reduce_print
], [static void],
851 [[YYSTYPE
*yyvsp
], [yyvsp
]],
852 b4_locations_if([[[YYLTYPE
*yylsp
], [yylsp
]],
853 ])[[int yyrule
], [yyrule
]]m4_ifset([b4_parse_param
], [,
856 int yynrhs
= yyr2
[yyrule
];
858 unsigned long int yylno
= yyrline
[yyrule
];
859 YYFPRINTF (stderr
, "Reducing stack by rule %d (line %lu):\n",
861 /* The symbols being reduced. */
862 for (yyi
= 0; yyi
< yynrhs
; yyi
++)
864 YYFPRINTF (stderr
, " $%d = ", yyi
+ 1);
865 yy_symbol_print (stderr
, yyrhs
[yyprhs
[yyrule
] + yyi
],
866 &]b4_rhs_value(yynrhs
, yyi
+ 1)[
867 ]b4_locations_if([, &]b4_rhs_location(yynrhs
, yyi
+ 1))[]dnl
869 YYFPRINTF (stderr
, "\n");
873 # define YY_REDUCE_PRINT(Rule) \
876 yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
879 /* Nonzero means print parse trace. It is left uninitialized so that
880 multiple parsers can coexist. */
883 # define YYDPRINTF(Args)
884 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
885 # define YY_STACK_PRINT(Bottom, Top)
886 # define YY_REDUCE_PRINT(Rule)
887 #endif /* !YYDEBUG */
890 /* YYINITDEPTH -- initial size of the parser's stacks. */
892 # define YYINITDEPTH ]b4_stack_depth_init[
895 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
896 if the built-in stack extension method is used).
898 Do not make this value too large; the results are undefined if
899 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
900 evaluated with infinite-precision integer arithmetic. */
903 # define YYMAXDEPTH ]b4_stack_depth_max[
906 /* Given a state stack such that *YYBOTTOM is its bottom, such that
907 *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty
908 stack, and such that *YYCAPACITY is the maximum number of elements it
909 can hold without a reallocation, make sure there is enough room to
910 store YYADD more elements. If not, allocate a new stack using
911 YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM,
912 *YYTOP, and *YYCAPACITY to reflect the new capacity and memory
913 location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack
914 using YYSTACK_FREE. Return 0 if successful or if no reallocation is
915 required. Return 1 if memory is exhausted. */
917 yy_lac_stack_realloc (YYSIZE_T
*yycapacity
, YYSIZE_T yyadd
,
919 char const *yydebug_prefix
,
920 char const *yydebug_suffix
,
922 yytype_int16
**yybottom
,
923 yytype_int16
*yybottom_no_free
,
924 yytype_int16
**yytop
, yytype_int16
*yytop_empty
)
926 YYSIZE_T yysize_old
=
927 *yytop
== yytop_empty
? 0 : *yytop
- *yybottom
+ 1;
928 YYSIZE_T yysize_new
= yysize_old
+ yyadd
;
929 if (*yycapacity
< yysize_new
)
931 YYSIZE_T yyalloc
= 2 * yysize_new
;
932 yytype_int16
*yybottom_new
;
933 /* Use YYMAXDEPTH for maximum stack size given that the stack
934 should never need to grow larger than the main state stack
935 needs to grow without LAC. */
936 if (YYMAXDEPTH
< yysize_new
)
938 YYDPRINTF ((stderr
, "%smax size exceeded%s", yydebug_prefix
,
942 if (YYMAXDEPTH
< yyalloc
)
943 yyalloc
= YYMAXDEPTH
;
945 (yytype_int16
*) YYSTACK_ALLOC (yyalloc
* sizeof *yybottom_new
);
948 YYDPRINTF ((stderr
, "%srealloc failed%s", yydebug_prefix
,
952 if (*yytop
!= yytop_empty
)
954 YYCOPY (yybottom_new
, *yybottom
, yysize_old
);
955 *yytop
= yybottom_new
+ (yysize_old
- 1);
957 if (*yybottom
!= yybottom_no_free
)
958 YYSTACK_FREE (*yybottom
);
959 *yybottom
= yybottom_new
;
960 *yycapacity
= yyalloc
;]m4_if(b4_percent_define_get([[parse
.lac
.memory
-trace
]]),
962 YYDPRINTF ((stderr
, "%srealloc to %lu%s", yydebug_prefix
,
963 (unsigned long int) yyalloc
, yydebug_suffix
));]])[
968 /* Establish the initial context for the current lookahead if no initial
969 context is currently established.
971 We define a context as a snapshot of the parser stacks. We define
972 the initial context for a lookahead as the context in which the
973 parser initially examines that lookahead in order to select a
974 syntactic action. Thus, if the lookahead eventually proves
975 syntactically unacceptable (possibly in a later context reached via a
976 series of reductions), the initial context can be used to determine
977 the exact set of tokens that would be syntactically acceptable in the
978 lookahead's place. Moreover, it is the context after which any
979 further semantic actions would be erroneous because they would be
980 determined by a syntactically unacceptable token.
982 YY_LAC_ESTABLISH should be invoked when a reduction is about to be
983 performed in an inconsistent state (which, for the purposes of LAC,
984 includes consistent states that don't know they're consistent because
985 their default reductions have been disabled). Iff there is a
986 lookahead token, it should also be invoked before reporting a syntax
987 error. This latter case is for the sake of the debugging output.
989 For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as
990 follows. If no initial context is currently established for the
991 current lookahead, then check if that lookahead can eventually be
992 shifted if syntactic actions continue from the current context.
993 Report a syntax error if it cannot. */
994 #define YY_LAC_ESTABLISH \
996 if (!yy_lac_established) \
998 YYDPRINTF ((stderr, \
999 "LAC: initial context established for %s\n", \
1000 yytname[yytoken])); \
1001 yy_lac_established = 1; \
1003 int yy_lac_status = \
1004 yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \
1005 if (yy_lac_status == 2) \
1006 goto yyexhaustedlab; \
1007 if (yy_lac_status == 1) \
1013 /* Discard any previous initial lookahead context because of Event,
1014 which may be a lookahead change or an invalidation of the currently
1015 established initial context for the current lookahead.
1017 The most common example of a lookahead change is a shift. An example
1018 of both cases is syntax error recovery. That is, a syntax error
1019 occurs when the lookahead is syntactically erroneous for the
1020 currently established initial context, so error recovery manipulates
1021 the parser stacks to try to find a new initial context in which the
1022 current lookahead is syntactically acceptable. If it fails to find
1023 such a context, it discards the lookahead. */
1025 # define YY_LAC_DISCARD(Event) \
1027 if (yy_lac_established) \
1030 YYFPRINTF (stderr, "LAC: initial context discarded due to " \
1032 yy_lac_established = 0; \
1036 # define YY_LAC_DISCARD(Event) yy_lac_established = 0
1039 /* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can
1040 eventually (after perhaps some reductions) be shifted, return 1 if
1041 not, or return 2 if memory is exhausted. As preconditions and
1042 postconditions: *YYES_CAPACITY is the allocated size of the array to
1043 which *YYES points, and either *YYES = YYESA or *YYES points to an
1044 array allocated with YYSTACK_ALLOC. yy_lac may overwrite the
1045 contents of either array, alter *YYES and *YYES_CAPACITY, and free
1046 any old *YYES other than YYESA. */
1048 yy_lac (yytype_int16
*yyesa
, yytype_int16
**yyes
,
1049 YYSIZE_T
*yyes_capacity
, yytype_int16
*yyssp
, int yytoken
)
1051 yytype_int16
*yyes_prev
= yyssp
;
1052 yytype_int16
*yyesp
= yyes_prev
;
1053 YYDPRINTF ((stderr
, "LAC: checking lookahead %s:", yytname
[yytoken
]));
1054 if (yytoken
== YYUNDEFTOK
)
1056 YYDPRINTF ((stderr
, " Always Err\n"));
1061 int yyrule
= yypact
[*yyesp
];
1062 if (yypact_value_is_default (yyrule
)
1063 || (yyrule
+= yytoken
) < 0 || YYLAST
< yyrule
1064 || yycheck
[yyrule
] != yytoken
)
1066 yyrule
= yydefact
[*yyesp
];
1069 YYDPRINTF ((stderr
, " Err\n"));
1075 yyrule
= yytable
[yyrule
];
1076 if (yytable_value_is_error (yyrule
))
1078 YYDPRINTF ((stderr
, " Err\n"));
1083 YYDPRINTF ((stderr
, " S%d\n", yyrule
));
1089 YYSIZE_T yylen
= yyr2
[yyrule
];
1090 YYDPRINTF ((stderr
, " R%d", yyrule
- 1));
1091 if (yyesp
!= yyes_prev
)
1093 YYSIZE_T yysize
= yyesp
- *yyes
+ 1;
1106 yyesp
= yyes_prev
-= yylen
;
1111 int yylhs
= yyr1
[yyrule
] - YYNTOKENS
;
1112 yystate
= yypgoto
[yylhs
] + *yyesp
;
1113 if (yystate
< 0 || YYLAST
< yystate
1114 || yycheck
[yystate
] != *yyesp
)
1115 yystate
= yydefgoto
[yylhs
];
1117 yystate
= yytable
[yystate
];
1119 if (yyesp
== yyes_prev
)
1126 if (yy_lac_stack_realloc (yyes_capacity
, 1,
1130 yyes
, yyesa
, &yyesp
, yyes_prev
))
1132 YYDPRINTF ((stderr
, "\n"));
1137 YYDPRINTF ((stderr
, " G%d", yystate
));
1146 # if defined __GLIBC__ && defined _STRING_H
1147 # define yystrlen strlen
1149 /* Return the length of YYSTR. */
1150 ]b4_c_function_def([yystrlen
], [static YYSIZE_T
],
1151 [[const char *yystr
], [yystr
]])[
1154 for (yylen
= 0; yystr
[yylen
]; yylen
++)
1162 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1163 # define yystpcpy stpcpy
1165 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1167 ]b4_c_function_def([yystpcpy
], [static char *],
1168 [[char *yydest
], [yydest
]], [[const char *yysrc
], [yysrc
]])[
1171 const char *yys
= yysrc
;
1173 while ((*yyd
++ = *yys
++) != '\0')
1182 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1183 quotes and backslashes, so that it's suitable for yyerror. The
1184 heuristic is that double-quoting is unnecessary unless the string
1185 contains an apostrophe, a comma, or backslash (other than
1186 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1187 null, do not copy; instead, return the length of what the result
1190 yytnamerr (char *yyres
, const char *yystr
)
1195 char const *yyp
= yystr
;
1202 goto do_not_strip_quotes
;
1206 goto do_not_strip_quotes
;
1219 do_not_strip_quotes
: ;
1223 return yystrlen (yystr
);
1225 return yystpcpy (yyres
, yystr
) - yyres
;
1229 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1230 about the unexpected token YYTOKEN for the state stack whose top is
1231 YYSSP.]b4_lac_if([[ In order to see if a particular token T is a
1232 valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[
1234 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1235 not large enough to hold the message. In that case, also set
1236 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1237 required number of bytes is too large to store]b4_lac_if([[ or if
1238 yy_lac returned 2]])[. */
1240 yysyntax_error (YYSIZE_T
*yymsg_alloc
, char **yymsg
,
1241 ]b4_lac_if([[yytype_int16
*yyesa
, yytype_int16
**yyes
,
1242 YYSIZE_T
*yyes_capacity
, ]])[yytype_int16
*yyssp
, int yytoken
)
1244 YYSIZE_T yysize0
= yytnamerr (0, yytname
[yytoken
]);
1245 YYSIZE_T yysize
= yysize0
;
1247 enum { YYERROR_VERBOSE_ARGS_MAXIMUM
= 5 };
1248 /* Internationalized format string. */
1249 const char *yyformat
= 0;
1250 /* Arguments of yyformat. */
1251 char const *yyarg
[YYERROR_VERBOSE_ARGS_MAXIMUM
];
1252 /* Number of reported tokens (one for the "unexpected", one per
1256 /* There are many possibilities here to consider:
1257 - Assume YYFAIL is not used. It's too flawed to consider. See
1258 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1259 for details. YYERROR is fine as it does not invoke this
1261 - If this state is a consistent state with a default action, then
1262 the only way this function was invoked is if the default action
1263 is an error action. In that case, don't check for expected
1264 tokens because there are none.
1265 - The only way there can be no lookahead present (in yychar) is if
1266 this state is a consistent state with a default action. Thus,
1267 detecting the absence of a lookahead is sufficient to determine
1268 that there is no unexpected or expected token to report. In that
1269 case, just report a simple "syntax error".
1270 - Don't assume there isn't a lookahead just because this state is a
1271 consistent state with a default action. There might have been a
1272 previous inconsistent state, consistent state with a non-default
1273 action, or user semantic action that manipulated yychar.]b4_lac_if([[
1274 In the first two cases, it might appear that the current syntax
1275 error should have been detected in the previous state when yy_lac
1276 was invoked. However, at that time, there might have been a
1277 different syntax error that discarded a different initial context
1278 during error recovery, leaving behind the current lookahead.]], [[
1279 - Of course, the expected token list depends on states to have
1280 correct lookahead information, and it depends on the parser not
1281 to perform extra reductions after fetching a lookahead from the
1282 scanner and before detecting a syntax error. Thus, state merging
1283 (from LALR or IELR) and default reductions corrupt the expected
1284 token list. However, the list is correct for canonical LR with
1285 one exception: it will still contain any token that will not be
1286 accepted due to an error action in a later state.]])[
1288 if (yytoken
!= YYEMPTY
)
1290 int yyn
= yypact
[*yyssp
];]b4_lac_if([[
1291 YYDPRINTF ((stderr
, "Constructing syntax error message\n"));]])[
1292 yyarg
[yycount
++] = yytname
[yytoken
];
1293 if (!yypact_value_is_default (yyn
))
1295 /* Start YYX at -YYN if negative to avoid negative indexes in
1296 YYCHECK. In other words, skip the first -YYN actions for
1297 this state because they are default actions. */
1298 int yyxbegin
= yyn
< 0 ? -yyn
: 0;
1299 /* Stay within bounds of both yycheck and yytname. */
1300 int yychecklim
= YYLAST
- yyn
+ 1;
1301 int yyxend
= yychecklim
< YYNTOKENS
? yychecklim
: YYNTOKENS
;]])[
1302 int yyx
;]b4_lac_if([[
1304 for (yyx
= 0; yyx
< YYNTOKENS
; ++yyx
)
1305 if (yyx
!= YYTERROR
&& yyx
!= YYUNDEFTOK
)
1308 int yy_lac_status
= yy_lac (yyesa
, yyes
, yyes_capacity
,
1310 if (yy_lac_status
== 2)
1312 if (yy_lac_status
== 1)
1316 for (yyx
= yyxbegin
; yyx
< yyxend
; ++yyx
)
1317 if (yycheck
[yyx
+ yyn
] == yyx
&& yyx
!= YYTERROR
1318 && !yytable_value_is_error (yytable
[yyx
+ yyn
]))
1320 if (yycount
== YYERROR_VERBOSE_ARGS_MAXIMUM
)
1326 yyarg
[yycount
++] = yytname
[yyx
];
1327 yysize1
= yysize
+ yytnamerr (0, yytname
[yyx
]);
1328 if (! (yysize
<= yysize1
1329 && yysize1
<= YYSTACK_ALLOC_MAXIMUM
))
1336 YYFPRINTF (stderr
, "No expected tokens.\n");
1342 # define YYCASE_(N, S) \
1346 YYCASE_(0, YY_("syntax error"));
1347 YYCASE_(1, YY_("syntax error, unexpected %s"));
1348 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1349 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1350 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1351 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1355 yysize1
= yysize
+ yystrlen (yyformat
);
1356 if (! (yysize
<= yysize1
&& yysize1
<= YYSTACK_ALLOC_MAXIMUM
))
1360 if (*yymsg_alloc
< yysize
)
1362 *yymsg_alloc
= 2 * yysize
;
1363 if (! (yysize
<= *yymsg_alloc
1364 && *yymsg_alloc
<= YYSTACK_ALLOC_MAXIMUM
))
1365 *yymsg_alloc
= YYSTACK_ALLOC_MAXIMUM
;
1369 /* Avoid sprintf, as that infringes on the user's name space.
1370 Don't have undefined behavior even if the translation
1371 produced a string with the wrong number of "%s"s. */
1375 while ((*yyp
= *yyformat
) != '\0')
1376 if (*yyp
== '%' && yyformat
[1] == 's' && yyi
< yycount
)
1378 yyp
+= yytnamerr (yyp
, yyarg
[yyi
++]);
1389 #endif /* YYERROR_VERBOSE */
1391 ]b4_yydestruct_generate([b4_c_function_def
])b4_push_if([], [[
1394 /* Prevent warnings from -Wmissing-prototypes. */
1395 #ifdef YYPARSE_PARAM
1396 ]b4_c_function_decl([yyparse
], [int],
1397 [[void *YYPARSE_PARAM
], [YYPARSE_PARAM
]])[
1398 #else /* ! YYPARSE_PARAM */
1399 ]b4_c_function_decl([yyparse
], [int], b4_parse_param
)[
1400 #endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [
1402 b4_declare_scanner_communication_variables
])[]b4_push_if([[
1406 {]b4_declare_parser_state_variables
[
1407 /* Used to determine if this is the first time this instance has
1410 };]b4_pure_if([], [[
1412 static char yypstate_allocated
= 0;]])b4_pull_if([
1414 b4_c_function_def([[yyparse]], [[int]], b4_parse_param
)[
1416 return yypull_parse (0]m4_ifset([b4_parse_param
],
1417 [[, ]b4_c_args(b4_parse_param
)])[);
1420 ]b4_c_function_def([[yypull_parse]], [[int]],
1421 [[[yypstate
*yyps
]], [[yyps]]]m4_ifset([b4_parse_param
], [,
1425 yypstate
*yyps_local
;]b4_pure_if([[
1427 YYSTYPE yylval
;]b4_locations_if([[
1428 YYLTYPE yylloc
;]])])[
1431 yyps_local
= yypstate_new ();
1434 yyerror (]b4_yyerror_args
[YY_("memory exhausted"));]], [[
1435 if (!yypstate_allocated
)
1436 yyerror (]b4_yyerror_args
[YY_("memory exhausted"));]])[
1445 yypush_parse (yyps_local
]b4_pure_if([[, yychar
, &yylval
]b4_locations_if([[, &yylloc
]])])m4_ifset([b4_parse_param
], [, b4_c_args(b4_parse_param
)])[);
1446 } while (yystatus
== YYPUSH_MORE
);
1448 yypstate_delete (yyps_local
);
1452 /* Initialize the parser data structure. */
1453 ]b4_c_function_def([[yypstate_new]], [[yypstate
*]])[
1455 yypstate
*yyps
;]b4_pure_if([], [[
1456 if (yypstate_allocated
)
1458 yyps
= (yypstate
*) malloc (sizeof *yyps
);
1461 yyps
->yynew
= 1;]b4_pure_if([], [[
1462 yypstate_allocated
= 1;]])[
1466 ]b4_c_function_def([[yypstate_delete]], [[void]],
1467 [[[yypstate
*yyps
]], [[yyps]]])[
1470 /* If the stack was reallocated but the parse did not complete, then the
1471 stack still needs to be freed. */
1472 if (!yyps
->yynew
&& yyps
->yyss
!= yyps
->yyssa
)
1473 YYSTACK_FREE (yyps
->yyss
);
1475 if (!yyps
->yynew
&& yyps
->yyes
!= yyps
->yyesa
)
1476 YYSTACK_FREE (yyps
->yyes
);]])[
1477 free (yyps
);]b4_pure_if([], [[
1478 yypstate_allocated
= 0;]])[
1481 #define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
1482 #define yystate yyps->yystate
1483 #define yyerrstatus yyps->yyerrstatus
1484 #define yyssa yyps->yyssa
1485 #define yyss yyps->yyss
1486 #define yyssp yyps->yyssp
1487 #define yyvsa yyps->yyvsa
1488 #define yyvs yyps->yyvs
1489 #define yyvsp yyps->yyvsp]b4_locations_if([[
1490 #define yylsa yyps->yylsa
1491 #define yyls yyps->yyls
1492 #define yylsp yyps->yylsp
1493 #define yyerror_range yyps->yyerror_range]])[
1494 #define yystacksize yyps->yystacksize]b4_lac_if([[
1495 #define yyesa yyps->yyesa
1496 #define yyes yyps->yyes
1497 #define yyes_capacity yyps->yyes_capacity]])[
1504 ]b4_c_function_def([[yypush_parse]], [[int]],
1505 [[[yypstate
*yyps
]], [[yyps]]]b4_pure_if([,
1506 [[[int yypushed_char]], [[yypushed_char]]],
1507 [[[YYSTYPE
const *yypushed_val
]], [[yypushed_val]]]b4_locations_if([,
1508 [[[YYLTYPE
const *yypushed_loc
]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param
], [,
1509 b4_parse_param
]))], [[
1516 #ifdef YYPARSE_PARAM
1517 ]b4_c_function_def([yyparse
], [int],
1518 [[void *YYPARSE_PARAM
], [YYPARSE_PARAM
]])[
1519 #else /* ! YYPARSE_PARAM */
1520 ]b4_c_function_def([yyparse
], [int], b4_parse_param
)[
1522 {]b4_pure_if([b4_declare_scanner_communication_variables
1523 ])b4_push_if([b4_pure_if([], [[
1524 int yypushed_char
= yychar
;
1525 YYSTYPE yypushed_val
= yylval
;]b4_locations_if([[
1526 YYLTYPE yypushed_loc
= yylloc
;]])
1528 [b4_declare_parser_state_variables
1530 int yy_lac_established
= 0;]])[
1533 /* Lookahead token as an internal (translated) token number. */
1535 /* The variables used to return semantic value and location from the
1537 YYSTYPE yyval
;]b4_locations_if([[
1541 /* Buffer for error messages, and its allocated size. */
1543 char *yymsg
= yymsgbuf
;
1544 YYSIZE_T yymsg_alloc
= sizeof yymsgbuf
;
1547 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1549 /* The number of symbols on the RHS of the reduced rule.
1550 Keep to zero when no symbol should be popped. */
1551 int yylen
= 0;]b4_push_if([[
1555 yyn
= yypact
[yystate
];
1556 goto yyread_pushed_token
;
1561 yyvs
= yyvsa
;]b4_locations_if([[
1563 yystacksize
= YYINITDEPTH
;]b4_lac_if([[
1566 yyes_capacity
= sizeof yyesa
/ sizeof *yyes
;
1567 if (YYMAXDEPTH
< yyes_capacity
)
1568 yyes_capacity
= YYMAXDEPTH
;]])[
1570 YYDPRINTF ((stderr
, "Starting parse\n"));
1575 yychar
= YYEMPTY
; /* Cause a token to be read. */
1577 /* Initialize stack pointers.
1578 Waste one element of value and location stack
1579 so that they stay on the same level as the state stack.
1580 The wasted elements are never initialized. */
1582 yyvsp
= yyvs
;]b4_locations_if([[
1585 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1586 /* Initialize the default location before parsing starts. */
1587 yylloc
.first_line
= yylloc
.last_line
= ]b4_location_initial_line
[;
1588 yylloc
.first_column
= yylloc
.last_column
= ]b4_location_initial_column
[;
1590 m4_ifdef([b4_initial_action
],[
1591 m4_pushdef([b4_at_dollar
], [m4_define([b4_at_dollar_used
])yylloc
])dnl
1592 m4_pushdef([b4_dollar_dollar
], [m4_define([b4_dollar_dollar_used
])yylval
])dnl
1593 /* User initialization code. */
1594 b4_user_initial_action
1595 m4_popdef([b4_dollar_dollar
])dnl
1596 m4_popdef([b4_at_dollar
])])dnl
1597 m4_ifdef([b4_dollar_dollar_used
],[[ yyvsp
[0] = yylval
;
1599 m4_ifdef([b4_at_dollar_used
], [[ yylsp
[0] = yylloc
;
1603 /*------------------------------------------------------------.
1604 | yynewstate -- Push a new state, which is found in yystate. |
1605 `------------------------------------------------------------*/
1607 /* In all cases, when you get here, the value and location stacks
1608 have just been pushed. So pushing a state here evens the stacks. */
1614 if (yyss
+ yystacksize
- 1 <= yyssp
)
1616 /* Get the current used size of the three stacks, in elements. */
1617 YYSIZE_T yysize
= yyssp
- yyss
+ 1;
1621 /* Give user a chance to reallocate the stack. Use copies of
1622 these so that the &'s don't force the real ones into
1624 YYSTYPE
*yyvs1
= yyvs
;
1625 yytype_int16
*yyss1
= yyss
;]b4_locations_if([
1626 YYLTYPE
*yyls1
= yyls
;])[
1628 /* Each stack pointer address is followed by the size of the
1629 data in use in that stack, in bytes. This used to be a
1630 conditional around just the two extra args, but that might
1631 be undefined if yyoverflow is a macro. */
1632 yyoverflow (YY_("memory exhausted"),
1633 &yyss1
, yysize
* sizeof (*yyssp
),
1634 &yyvs1
, yysize
* sizeof (*yyvsp
),]b4_locations_if([
1635 &yyls1
, yysize
* sizeof (*yylsp
),])[
1642 #else /* no yyoverflow */
1643 # ifndef YYSTACK_RELOCATE
1644 goto yyexhaustedlab
;
1646 /* Extend the stack our own way. */
1647 if (YYMAXDEPTH
<= yystacksize
)
1648 goto yyexhaustedlab
;
1650 if (YYMAXDEPTH
< yystacksize
)
1651 yystacksize
= YYMAXDEPTH
;
1654 yytype_int16
*yyss1
= yyss
;
1655 union yyalloc
*yyptr
=
1656 (union yyalloc
*) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize
));
1658 goto yyexhaustedlab
;
1659 YYSTACK_RELOCATE (yyss_alloc
, yyss
);
1660 YYSTACK_RELOCATE (yyvs_alloc
, yyvs
);]b4_locations_if([
1661 YYSTACK_RELOCATE (yyls_alloc
, yyls
);])[
1662 # undef YYSTACK_RELOCATE
1664 YYSTACK_FREE (yyss1
);
1667 #endif /* no yyoverflow */
1669 yyssp
= yyss
+ yysize
- 1;
1670 yyvsp
= yyvs
+ yysize
- 1;]b4_locations_if([
1671 yylsp
= yyls
+ yysize
- 1;])[
1673 YYDPRINTF ((stderr
, "Stack size increased to %lu\n",
1674 (unsigned long int) yystacksize
));
1676 if (yyss
+ yystacksize
- 1 <= yyssp
)
1680 YYDPRINTF ((stderr
, "Entering state %d\n", yystate
));
1682 if (yystate
== YYFINAL
)
1692 /* Do appropriate processing given the current state. Read a
1693 lookahead token if we need one and don't already have one. */
1695 /* First try to decide what to do without reference to lookahead token. */
1696 yyn
= yypact
[yystate
];
1697 if (yypact_value_is_default (yyn
))
1700 /* Not known => get a lookahead token if don't already have one. */
1702 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1703 if (yychar
== YYEMPTY
)
1706 {]b4_use_push_for_pull_if([], [[
1707 YYDPRINTF ((stderr
, "Return for a new token:\n"));]])[
1708 yyresult
= YYPUSH_MORE
;
1711 yyps
->yynew
= 0;]b4_pure_if([], [[
1712 /* Restoring the pushed token is only necessary for the first
1713 yypush_parse invocation since subsequent invocations don't overwrite
1714 it before jumping to yyread_pushed_token. */
1715 yychar
= yypushed_char
;
1716 yylval
= yypushed_val
;]b4_locations_if([[
1717 yylloc
= yypushed_loc
;]])])[
1718 yyread_pushed_token
:]])[
1719 YYDPRINTF ((stderr
, "Reading a token: "));]b4_push_if([b4_pure_if([[
1720 yychar
= yypushed_char
;
1722 yylval
= *yypushed_val
;]b4_locations_if([[
1724 yylloc
= *yypushed_loc
;]])])], [[
1728 if (yychar
<= YYEOF
)
1730 yychar
= yytoken
= YYEOF
;
1731 YYDPRINTF ((stderr
, "Now at end of input.\n"));
1735 yytoken
= YYTRANSLATE (yychar
);
1736 YY_SYMBOL_PRINT ("Next token is", yytoken
, &yylval
, &yylloc
);
1739 /* If the proper action on seeing token YYTOKEN is to reduce or to
1740 detect an error, take that action. */
1742 if (yyn
< 0 || YYLAST
< yyn
|| yycheck
[yyn
] != yytoken
)]b4_lac_if([[
1751 if (yytable_value_is_error (yyn
))
1752 goto yyerrlab
;]b4_lac_if([[
1753 YY_LAC_ESTABLISH
;]])[
1758 /* Count tokens shifted since error; after three, turn off error
1763 /* Shift the lookahead token. */
1764 YY_SYMBOL_PRINT ("Shifting", yytoken
, &yylval
, &yylloc
);
1766 /* Discard the shifted token. */
1767 yychar
= YYEMPTY
;]b4_lac_if([[
1768 YY_LAC_DISCARD ("shift");]])[
1772 ]b4_locations_if([ *++yylsp
= yylloc
;])[
1776 /*-----------------------------------------------------------.
1777 | yydefault -- do the default action for the current state. |
1778 `-----------------------------------------------------------*/
1780 yyn
= yydefact
[yystate
];
1786 /*-----------------------------.
1787 | yyreduce -- Do a reduction. |
1788 `-----------------------------*/
1790 /* yyn is the number of a rule to reduce with. */
1793 /* If YYLEN is nonzero, implement the default value of the action:
1796 Otherwise, the following line sets YYVAL to garbage.
1797 This behavior is undocumented and Bison
1798 users should not rely upon it. Assigning to YYVAL
1799 unconditionally makes the parser a bit smaller, and it avoids a
1800 GCC warning that YYVAL may be used uninitialized. */
1801 yyval
= yyvsp
[1-yylen
];
1804 [[ /* Default location. */
1805 YYLLOC_DEFAULT (yyloc
, (yylsp
- yylen
), yylen
);]])[
1806 YY_REDUCE_PRINT (yyn
);]b4_lac_if([[
1808 int yychar_backup
= yychar
;
1814 if (yychar_backup
!= yychar
)
1815 YY_LAC_DISCARD ("yychar change");
1822 /* User semantic actions sometimes alter yychar, and that requires
1823 that yytoken be updated with the new translation. We take the
1824 approach of translating immediately before every use of yytoken.
1825 One alternative is translating here after every semantic action,
1826 but that translation would be missed if the semantic action invokes
1827 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1828 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1829 incorrect destructor might then be invoked immediately. In the
1830 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1831 to an incorrect destructor call or verbose syntax error message
1832 before the lookahead is translated. */
1833 YY_SYMBOL_PRINT ("-> $$ =", yyr1
[yyn
], &yyval
, &yyloc
);
1837 YY_STACK_PRINT (yyss
, yyssp
);
1839 *++yyvsp
= yyval
;]b4_locations_if([
1840 *++yylsp
= yyloc
;])[
1842 /* Now `shift' the result of the reduction. Determine what state
1843 that goes to, based on the state we popped back to and the rule
1844 number reduced by. */
1848 yystate
= yypgoto
[yyn
- YYNTOKENS
] + *yyssp
;
1849 if (0 <= yystate
&& yystate
<= YYLAST
&& yycheck
[yystate
] == *yyssp
)
1850 yystate
= yytable
[yystate
];
1852 yystate
= yydefgoto
[yyn
- YYNTOKENS
];
1857 /*------------------------------------.
1858 | yyerrlab -- here on detecting error |
1859 `------------------------------------*/
1861 /* Make sure we have latest lookahead translation. See comments at
1862 user semantic actions for why this is necessary. */
1863 yytoken
= yychar
== YYEMPTY
? YYEMPTY
: YYTRANSLATE (yychar
);
1865 /* If not already recovering from an error, report this error. */
1869 #if ! YYERROR_VERBOSE
1870 yyerror (]b4_yyerror_args
[YY_("syntax error"));
1872 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[
1873 yyesa
, &yyes
, &yyes_capacity
, \
]])[
1876 char const *yymsgp
= YY_("syntax error");
1877 int yysyntax_error_status
;]b4_lac_if([[
1878 if (yychar
!= YYEMPTY
)
1879 YY_LAC_ESTABLISH
;]])[
1880 yysyntax_error_status
= YYSYNTAX_ERROR
;
1881 if (yysyntax_error_status
== 0)
1883 else if (yysyntax_error_status
== 1)
1885 if (yymsg
!= yymsgbuf
)
1886 YYSTACK_FREE (yymsg
);
1887 yymsg
= (char *) YYSTACK_ALLOC (yymsg_alloc
);
1891 yymsg_alloc
= sizeof yymsgbuf
;
1892 yysyntax_error_status
= 2;
1896 yysyntax_error_status
= YYSYNTAX_ERROR
;
1900 yyerror (]b4_yyerror_args
[yymsgp
);
1901 if (yysyntax_error_status
== 2)
1902 goto yyexhaustedlab
;
1904 # undef YYSYNTAX_ERROR
1908 ]b4_locations_if([[ yyerror_range
[1] = yylloc
;]])[
1910 if (yyerrstatus
== 3)
1912 /* If just tried and failed to reuse lookahead token after an
1913 error, discard it. */
1915 if (yychar
<= YYEOF
)
1917 /* Return failure if at end of input. */
1918 if (yychar
== YYEOF
)
1923 yydestruct ("Error: discarding",
1924 yytoken
, &yylval
]b4_locations_if([, &yylloc
])[]b4_user_args
[);
1929 /* Else will try to reuse lookahead token after shifting the error
1934 /*---------------------------------------------------.
1935 | yyerrorlab -- error raised explicitly by YYERROR. |
1936 `---------------------------------------------------*/
1939 /* Pacify compilers like GCC when the user code never invokes
1940 YYERROR and the label yyerrorlab therefore never appears in user
1942 if (/*CONSTCOND*/ 0)
1945 ]b4_locations_if([[ yyerror_range
[1] = yylsp
[1-yylen
];
1946 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1950 YY_STACK_PRINT (yyss
, yyssp
);
1955 /*-------------------------------------------------------------.
1956 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1957 `-------------------------------------------------------------*/
1959 yyerrstatus
= 3; /* Each real token shifted decrements this. */
1963 yyn
= yypact
[yystate
];
1964 if (!yypact_value_is_default (yyn
))
1967 if (0 <= yyn
&& yyn
<= YYLAST
&& yycheck
[yyn
] == YYTERROR
)
1975 /* Pop the current state because it cannot handle the error token. */
1979 ]b4_locations_if([[ yyerror_range
[1] = *yylsp
;]])[
1980 yydestruct ("Error: popping",
1981 yystos
[yystate
], yyvsp
]b4_locations_if([, yylsp
])[]b4_user_args
[);
1984 YY_STACK_PRINT (yyss
, yyssp
);
1987 /* If the stack popping above didn't lose the initial context for the
1988 current lookahead token, the shift below will for sure. */
1989 YY_LAC_DISCARD ("error recovery");]])[
1993 yyerror_range
[2] = yylloc
;
1994 /* Using YYLLOC is tempting, but would change the location of
1995 the lookahead. YYLOC is available though. */
1996 YYLLOC_DEFAULT (yyloc
, yyerror_range
, 2);
1997 *++yylsp
= yyloc
;]])[
1999 /* Shift the error token. */
2000 YY_SYMBOL_PRINT ("Shifting", yystos
[yyn
], yyvsp
, yylsp
);
2006 /*-------------------------------------.
2007 | yyacceptlab -- YYACCEPT comes here. |
2008 `-------------------------------------*/
2013 /*-----------------------------------.
2014 | yyabortlab -- YYABORT comes here. |
2015 `-----------------------------------*/
2020 #if ]b4_lac_if([[1]], [[!defined(yyoverflow) || YYERROR_VERBOSE]])[
2021 /*-------------------------------------------------.
2022 | yyexhaustedlab -- memory exhaustion comes here. |
2023 `-------------------------------------------------*/
2025 yyerror (]b4_yyerror_args
[YY_("memory exhausted"));
2031 if (yychar
!= YYEMPTY
)
2033 /* Make sure we have latest lookahead translation. See comments at
2034 user semantic actions for why this is necessary. */
2035 yytoken
= YYTRANSLATE (yychar
);
2036 yydestruct ("Cleanup: discarding lookahead",
2037 yytoken
, &yylval
]b4_locations_if([, &yylloc
])[]b4_user_args
[);
2039 /* Do not reclaim the symbols of the rule which action triggered
2040 this YYABORT or YYACCEPT. */
2042 YY_STACK_PRINT (yyss
, yyssp
);
2043 while (yyssp
!= yyss
)
2045 yydestruct ("Cleanup: popping",
2046 yystos
[*yyssp
], yyvsp
]b4_locations_if([, yylsp
])[]b4_user_args
[);
2051 YYSTACK_FREE (yyss
);
2054 YYSTACK_FREE (yyes
);]])b4_push_if([[
2059 if (yymsg
!= yymsgbuf
)
2060 YYSTACK_FREE (yymsg
);
2062 /* Make sure YYID is used. */
2063 return YYID (yyresult
);
2069 [@
output(b4_spec_defines_file@
)@
2070 b4_copyright([Bison interface
for Yacc
-like parsers in C
],
2071 [1984, 1989-1990, 2000-2011])
2073 b4_percent_code_get([[requires]])[]dnl
2075 b4_token_enums_defines(b4_tokens
)
2077 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
2078 ]m4_ifdef([b4_stype
],
2079 [[typedef union ]b4_union_name
[
2083 # define YYSTYPE_IS_TRIVIAL 1]],
2084 [m4_if(b4_tag_seen_flag
, 0,
2085 [[typedef int YYSTYPE
;
2086 # define YYSTYPE_IS_TRIVIAL 1]])])[
2087 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2088 # define YYSTYPE_IS_DECLARED 1
2091 ]b4_pure_if([], [[extern YYSTYPE
]b4_prefix
[lval
;]])
2094 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
2095 typedef struct YYLTYPE
2102 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
2103 # define YYLTYPE_IS_DECLARED 1
2104 # define YYLTYPE_IS_TRIVIAL 1
2107 ]b4_pure_if([], [[extern YYLTYPE
]b4_prefix
[lloc
;]])
2108 )dnl b4_locations_if
2110 #ifndef YYPUSH_DECLS
2111 # define YYPUSH_DECLS
2112 struct ]b4_prefix
[pstate
;
2113 typedef struct ]b4_prefix
[pstate
]b4_prefix
[pstate
;
2114 enum { YYPUSH_MORE
= 4 };
2115 ]b4_pull_if([b4_c_function_decl([b4_prefix
[parse
]], [[int]], b4_parse_param
)
2116 ])b4_c_function_decl([b4_prefix
[push_parse
]], [[int]],
2117 [[b4_prefix
[pstate
*yyps
]], [[yyps]]]b4_pure_if([,
2118 [[[int yypushed_char]], [[yypushed_char]]],
2119 [[[YYSTYPE
const *yypushed_val
]], [[yypushed_val]]]b4_locations_if([,
2120 [[[YYLTYPE
const *yypushed_loc
]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param
], [,
2122 b4_pull_if([b4_c_function_decl([b4_prefix
[pull_parse
]], [[int]],
2123 [[b4_prefix
[pstate
*yyps
]], [[yyps]]]m4_ifset([b4_parse_param
], [,
2125 b4_c_function_decl([b4_prefix
[pstate_new
]], [b4_prefix
[pstate
*]],
2127 b4_c_function_decl([b4_prefix
[pstate_delete
]], [[void]],
2128 [[b4_prefix
[pstate
*yyps
]], [[yyps]]])[
2131 b4_percent_code_get([[provides]])[]dnl