1 # C++ skeleton for Bison
3 # Copyright (C) 2002-2012 Free Software Foundation, Inc.
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, either version 3 of the License, or
8 # (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18 m4_include(b4_pkgdatadir
/[c
++.m4
])
21 # b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
22 # --------------------------------------------------------------
23 # Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT.
24 m4_define([b4_integral_parser_table_declare
],
25 [m4_ifval([$
3], [b4_c_comment([$
3], [ ])
27 static const b4_int_type_for([$
2]) yy$
1_
[[]];dnl
30 # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
31 # -------------------------------------------------------------
32 # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
33 m4_define([b4_integral_parser_table_define
],
34 [ const b4_int_type_for([$
2])
35 b4_parser_class_name::yy$
1_
[[]] =
42 # b4_symbol_value_template(VAL, [TYPE])
43 # -------------------------------------
44 # Same as b4_symbol_value, but used in a template method. It makes
45 # a difference when using variants.
46 m4_copy([b4_symbol_value
], [b4_symbol_value_template
])
49 # b4_lhs_value([TYPE])
50 # --------------------
51 # Expansion of $<TYPE>$.
52 m4_define([b4_lhs_value
],
53 [b4_symbol_value([yylhs
.value
], [$
1])])
59 m4_define([b4_lhs_location
],
63 # b4_rhs_data(RULE-LENGTH, NUM)
64 # -----------------------------
65 # Return the data corresponding to the symbol #NUM, where the current
66 # rule has RULE-LENGTH symbols on RHS.
67 m4_define([b4_rhs_data
],
68 [yystack_@
{b4_subtract($@
)@
}])
71 # b4_rhs_state(RULE-LENGTH, NUM)
72 # ------------------------------
73 # The state corresponding to the symbol #NUM, where the current
74 # rule has RULE-LENGTH symbols on RHS.
75 m4_define([b4_rhs_state
],
76 [b4_rhs_data([$
1], [$
2]).state
])
79 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
80 # --------------------------------------
81 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
83 m4_define([b4_rhs_value
],
84 [b4_symbol_value([b4_rhs_data([$
1], [$
2]).value
], [$
3])])
87 # b4_rhs_location(RULE-LENGTH, NUM)
88 # ---------------------------------
89 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
91 m4_define([b4_rhs_location
],
92 [b4_rhs_data([$
1], [$
2]).location
])
95 # b4_symbol_action(SYMBOL-NUM, KIND)
96 # ----------------------------------
97 # Run the action KIND (destructor or printer) for SYMBOL-NUM.
98 # Same as in C, but using references instead of pointers.
99 m4_define([b4_symbol_action
],
100 [b4_symbol_if([$
1], [has_$
2],
101 [m4_pushdef([b4_dollar_dollar
],
102 [b4_symbol_value_template([yysym
.value
],
103 b4_symbol_if([$
1], [has_type
],
104 [b4_symbol([$
1], [type
])]))])dnl
105 m4_pushdef([b4_at_dollar
], [yysym
.location
])dnl
106 b4_symbol_case_([$
1])
107 b4_syncline([b4_symbol([$
1], [$
2_line
])], ["b4_symbol([$1], [$2_file])"])
108 b4_symbol([$
1], [$
2])
109 b4_syncline([@oline@
], [@ofile@
])
112 m4_popdef([b4_at_dollar
])dnl
113 m4_popdef([b4_dollar_dollar
])dnl
117 m4_pushdef([b4_copyright_years
],
120 m4_define([b4_parser_class_name
],
121 [b4_percent_define_get([[parser_class_name]])])
123 # The header is mandatory.
125 [b4_fatal([b4_skeleton
[: using %%defines is mandatory
]])])
127 b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
128 [# Backward compatibility.
129 m4_define([b4_location_constructors
])
130 m4_include(b4_pkgdatadir
/[location
.cc
])])])
131 m4_include(b4_pkgdatadir
/[stack
.hh
])
132 b4_variant_if([m4_include(b4_pkgdatadir
/[variant
.hh
])])
134 # We do want M4 expansion after # for CPP macros.
137 @
output(b4_spec_defines_file@
)@
138 b4_copyright([Skeleton interface
for Bison
LALR(1) parsers in C
++])
139 dnl FIXME
: This is wrong
, we want computed header guards
.
141 /* C++ LALR(1) parser skeleton written by Akim Demaille. */
143 #ifndef PARSER_HEADER_H
144 # define PARSER_HEADER_H
146 ]b4_percent_code_get([[requires]])[
148 ]b4_parse_assert_if([#include <cassert>])[
153 ]b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
154 [[#include "location.hh"]])])[
156 ]b4_variant_if([b4_namespace_open
158 b4_namespace_close
])[
160 /* Enabling traces. */
162 # define YYDEBUG ]b4_parse_trace_if([1], [0])[
165 /* Enabling verbose error messages. */
166 #ifdef YYERROR_VERBOSE
167 # undef YYERROR_VERBOSE
168 # define YYERROR_VERBOSE 1
170 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
173 /* Enabling the token table. */
174 #ifndef YYTOKEN_TABLE
175 # define YYTOKEN_TABLE ]b4_token_table[
181 class ]b4_parser_class_name
[
184 ]b4_public_types_declare
[
185 /// Build a parser object.
186 ]b4_parser_class_name
[ (]b4_parse_param_decl
[);
187 virtual ~]b4_parser_class_name
[ ();
190 /// \returns 0 iff parsing succeeded.
191 virtual int parse ();
194 /// The current debugging stream.
195 std::ostream
& debug_stream () const;
196 /// Set the current debugging stream.
197 void set_debug_stream (std::ostream
&);
199 /// Type for debugging levels.
200 typedef int debug_level_type
;
201 /// The current debugging level.
202 debug_level_type
debug_level () const;
203 /// Set the current debugging level.
204 void set_debug_level (debug_level_type l
);
207 /// Report a syntax error.]b4_locations_if([
208 /// \param loc where the syntax error is found.])[
209 /// \param msg a description of the syntax error.
210 virtual void error (]b4_locations_if([const location_type
& loc
, ])[const std::string
& msg
);
214 typedef int state_type
;
216 /// Generate an error message.
217 /// \param yystate the state where the error occurred.
218 /// \param yytoken the lookahead token.
219 virtual std::string
yysyntax_error_ (state_type yystate
, int yytoken
);
221 /// Compute post-reduction state.
222 /// \param yystate the current state
223 /// \param yylhs the nonterminal to push on the stack
224 state_type
yy_lr_goto_state_ (state_type yystate
, int yylhs
);
226 /// Whether the given \c yypact_ value indicates a defaulted state.
227 /// \param yyvalue the value to check
228 static bool yy_pact_value_is_default_ (int yyvalue
);
230 /// Whether the given \c yytable_ value indicates a syntax error.
231 /// \param yyvalue the value to check
232 static bool yy_table_value_is_error_ (int yyvalue
);
234 /// Internal symbol numbers.
235 typedef ]b4_int_type_for([b4_translate
])[ token_number_type
;
236 static const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
)[ yypact_ninf_
;
237 static const ]b4_int_type(b4_table_ninf
, b4_table_ninf
)[ yytable_ninf_
;
240 ]b4_parser_tables_declare
[
242 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
243 /// For a symbol, its name in clear.
244 static const char* const yytname_
[];
245 #endif]b4_error_verbose_if([
247 /// Convert the symbol name \a n to a form suitable for a diagnostic.
248 static std::string
yytnamerr_ (const char *n
);])[
251 ]b4_integral_parser_table_declare([rline
], [b4_rline
],
252 [YYRLINE
[YYN
] -- Source line where rule number YYN was defined
.])[
253 /// Report on the debug stream that the rule \a r is going to be reduced.
254 virtual void yy_reduce_print_ (int r
);
255 /// Print the state stack on the debug stream.
256 virtual void yystack_print_ ();
260 std::ostream
* yycdebug_
;
263 /// Convert a scanner token number \a t to a symbol number.
264 static inline token_number_type
yytranslate_ (]b4_lex_symbol_if([token_type
], [int])[ t
);
267 /// \brief Display a symbol type, value and location.
268 /// \param yyo The output stream.
269 /// \param yysym The symbol.
270 template <typename Exact
>
271 void yy_print_ (std::ostream
& yyo
,
272 const symbol_base_type
<Exact
>& yysym
) const;
275 /// \brief Reclaim the memory associated to a symbol.
276 /// \param yymsg Why this token is reclaimed.
277 /// If null, print nothing.
278 /// \param s The symbol.
279 template <typename Exact
>
280 inline void yy_destroy_ (const char* yymsg
,
281 symbol_base_type
<Exact
>& yysym
) const;
284 /// Element of the stack: a state and its attributes.
285 struct stack_symbol_type
: symbol_base_type
<stack_symbol_type
>
287 /// The parent class.
288 typedef symbol_base_type
<stack_symbol_type
> super_type
;
290 /// Default constructor.
291 inline stack_symbol_type ();
294 inline stack_symbol_type (]b4_args([state_type s
],
295 [const semantic_type
& v
],
296 b4_locations_if([const location_type
& l
]))[);
301 /// The type (corresponding to \a state).
302 inline int type_get_ () const;
306 typedef stack
<stack_symbol_type
> stack_type
;
311 /// Push a new state on the stack.
312 /// \param m a debug message to display
313 /// if null, no trace is output.
314 /// \param s the symbol
315 /// \warning the contents of \a s.value is stolen.
316 inline void yypush_ (const char* m
, stack_symbol_type
& s
);
318 /// Push a new look ahead token on the state on the stack.
319 /// \param m a debug message to display
320 /// if null, no trace is output.
321 /// \param s the state
322 /// \param sym the symbol (for its value and location).
323 /// \warning the contents of \a s.value is stolen.
324 inline void yypush_ (const char* m
, state_type s
, symbol_type
& sym
);
326 /// Pop \a n symbols the three stacks.
327 inline void yypop_ (unsigned int n
= 1);
333 yylast_
= ]b4_last
[, //< Last index in yytable_.
334 yynnts_
= ]b4_nterms_number
[, //< Number of nonterminal symbols.
336 yyfinal_
= ]b4_final_state_number
[, //< Termination state number.
339 yyntokens_
= ]b4_tokens_number
[ //< Number of tokens.
342 ]b4_parse_param_vars
[
345 ]b4_lex_symbol_if([b4_yytranslate_define
346 b4_public_types_define
])[
349 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
350 [b4_token_defines(b4_tokens
)
353 /* Redirection for backward compatibility. */
354 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
357 b4_percent_code_get([[provides]])[]dnl
359 [#endif /* ! defined PARSER_HEADER_H */]
360 @
output(b4_parser_file_name@
)@
361 b4_copyright([Skeleton implementation
for Bison
LALR(1) parsers in C
++])
362 b4_percent_code_get([[top]])[]dnl
363 m4_if(b4_prefix
, [yy
], [],
365 // Take the name prefix into account.
366 #define yylex b4_prefix[]lex])[
368 /* First part of user declarations. */
369 ]b4_user_pre_prologue
[
371 #include "@basename(]b4_spec_defines_file[@)"
373 /* User implementation prologue. */
374 ]b4_user_post_prologue
375 b4_percent_code_get
[]dnl
378 # if defined YYENABLE_NLS && YYENABLE_NLS
380 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
381 # define YY_(msgid) dgettext ("bison-runtime", msgid)
385 # define YY_(msgid) msgid
389 ]b4_locations_if([dnl
390 [/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
391 If N is 0, then set CURRENT to the empty location which ends
392 the previous symbol: RHS[0] (always defined). */
394 #define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
395 #ifndef YYLLOC_DEFAULT
396 # define YYLLOC_DEFAULT(Current, Rhs, N) \
400 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
401 (Current).end = YYRHSLOC (Rhs, N).end; \
405 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
410 /* Suppress unused-variable warnings by "using" E. */
411 #define YYUSE(e) ((void) (e))
413 /* Enable debugging if requested. */
416 /* A pseudo ostream that takes yydebug_ into account. */
417 # define YYCDEBUG if (yydebug_) (*yycdebug_)
419 # define YY_SYMBOL_PRINT(Title, Symbol) \
423 *yycdebug_ << Title << ' '; \
424 yy_print_ (*yycdebug_, Symbol); \
425 *yycdebug_ << std::endl; \
429 # define YY_REDUCE_PRINT(Rule) \
432 yy_reduce_print_ (Rule); \
435 # define YY_STACK_PRINT() \
443 # define YYCDEBUG if (false) std::cerr
444 # define YY_SYMBOL_PRINT(Title, Symbol) YYUSE(Symbol)
445 # define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
446 # define YY_STACK_PRINT() static_cast<void>(0)
448 #endif /* !YYDEBUG */
450 #define yyerrok (yyerrstatus_ = 0)
451 #define yyclearin (yyempty = true)
453 #define YYACCEPT goto yyacceptlab
454 #define YYABORT goto yyabortlab
455 #define YYERROR goto yyerrorlab
456 #define YYRECOVERING() (!!yyerrstatus_)
458 ]b4_namespace_open
[]b4_error_verbose_if([[
460 /* Return YYSTR after stripping away unnecessary quotes and
461 backslashes, so that it's suitable for yyerror. The heuristic is
462 that double-quoting is unnecessary unless the string contains an
463 apostrophe, a comma, or backslash (other than backslash-backslash).
464 YYSTR is taken from yytname. */
466 ]b4_parser_class_name
[::yytnamerr_ (const char *yystr
)
470 std::string yyr
= "";
471 char const *yyp
= yystr
;
478 goto do_not_strip_quotes
;
482 goto do_not_strip_quotes
;
491 do_not_strip_quotes
: ;
498 /// Build a parser object.
499 ]b4_parser_class_name::b4_parser_class_name
[ (]b4_parse_param_decl
[)]m4_ifset([b4_parse_param
], [
502 ]m4_ifset([b4_parse_param
], [ ], [ :])[yydebug_ (false),
503 yycdebug_ (&std::cerr
)]m4_ifset([b4_parse_param
], [,])[
504 #endif]b4_parse_param_cons[
508 ]b4_parser_class_name::~b4_parser_class_name
[ ()
517 ]b4_lex_symbol_if([], [b4_public_types_define
])[
519 // stack_symbol_type.
520 ]b4_parser_class_name
[::stack_symbol_type::stack_symbol_type ()
526 ]b4_parser_class_name
[::stack_symbol_type::stack_symbol_type (]b4_args(
528 [const semantic_type
& v
],
529 b4_locations_if([const location_type
& l
]))[)
530 : super_type (v
]b4_locations_if([, l
])[)
536 ]b4_parser_class_name
[::stack_symbol_type::type_get_ () const
538 return yystos_
[state
];
542 template <typename Exact
>
544 ]b4_parser_class_name
[::yy_destroy_ (const char* yymsg
,
545 symbol_base_type
<Exact
>& yysym
) const
547 int yytype
= yysym
.type_get ();
549 YY_SYMBOL_PRINT (yymsg
, yysym
);
554 ]b4_symbol_foreach([b4_symbol_destructor
])dnl
560 b4_symbol_variant([[yytype]], [[yysym
.value
]], [[template destroy]])])[
564 template <typename Exact
>
566 ]b4_parser_class_name
[::yy_print_ (std::ostream
& yyo
,
567 const symbol_base_type
<Exact
>& yysym
) const
569 int yytype
= yysym
.type_get ();
570 yyo
<< (yytype
< yyntokens_
? "token" : "nterm")
571 << ' ' << yytname_
[yytype
] << " ("]b4_locations_if([
572 << yysym
.location
<< ": "])[;
575 ]b4_symbol_foreach([b4_symbol_printer
])dnl
584 ]b4_parser_class_name
[::yypush_ (const char* m
, state_type s
,
588 YY_SYMBOL_PRINT (m
, sym
);
590 [[ yystack_
.push (stack_symbol_type (]b4_args(
593 b4_locations_if([sym
.location
]))[));
594 ]b4_symbol_variant([[yystos_
[s
]]], [[yystack_
[0].value
]],
595 [build
], [sym
.value
])],
596 [[ yystack_
.push (stack_symbol_type (]b4_args(
599 b4_locations_if([sym
.location
]))[));]])[
603 ]b4_parser_class_name
[::yypush_ (const char* m
, stack_symbol_type
& s
)
606 YY_SYMBOL_PRINT (m
, s
);
608 [[ yystack_
.push (stack_symbol_type (]b4_args(
611 b4_locations_if([s
.location
]))[));
612 ]b4_symbol_variant([[yystos_
[s
.state
]]], [[yystack_
[0].value
]],
613 [build
], [s
.value
])],
614 [ yystack_
.push (s
);])[
618 ]b4_parser_class_name
[::yypop_ (unsigned int n
)
625 ]b4_parser_class_name
[::debug_stream () const
631 ]b4_parser_class_name
[::set_debug_stream (std::ostream
& o
)
637 ]b4_parser_class_name
[::debug_level_type
638 ]b4_parser_class_name
[::debug_level () const
644 ]b4_parser_class_name
[::set_debug_level (debug_level_type l
)
650 inline ]b4_parser_class_name
[::state_type
651 ]b4_parser_class_name
[::yy_lr_goto_state_ (state_type yystate
, int yylhs
)
653 int yyr
= yypgoto_
[yylhs
- yyntokens_
] + yystate
;
654 if (0 <= yyr
&& yyr
<= yylast_
&& yycheck_
[yyr
] == yystate
)
655 return yytable_
[yyr
];
657 return yydefgoto_
[yylhs
- yyntokens_
];
661 ]b4_parser_class_name
[::yy_pact_value_is_default_ (int yyvalue
)
663 return yyvalue
== yypact_ninf_
;
667 ]b4_parser_class_name
[::yy_table_value_is_error_ (int yyvalue
)
669 return yyvalue
== yytable_ninf_
;
673 ]b4_parser_class_name
[::parse ()
675 /// Whether yyla contains a lookahead.
682 /* Error handling. */
684 int yyerrstatus_
= 0;
686 /// The lookahead symbol.
687 symbol_type yyla
;]b4_locations_if([[
689 /// The locations where the error started and ended.
690 stack_symbol_type yyerror_range
[3];]])[
693 stack_symbol_type yylhs
;
695 /// The return value of parse().
698 YYCDEBUG
<< "Starting parse" << std::endl
;
700 ]m4_ifdef([b4_initial_action
], [
701 m4_pushdef([b4_at_dollar
], [yyla
.location
])dnl
702 m4_pushdef([b4_dollar_dollar
], [yyla
.value
])dnl
703 /* User initialization code. */
704 b4_user_initial_action
705 m4_popdef([b4_dollar_dollar
])dnl
706 m4_popdef([b4_at_dollar
])])dnl
708 [ /* Initialize the stack. The initial state will be set in
709 yynewstate, since the latter expects the semantical and the
710 location values to have been already stored, initialize these
711 stacks with a primary value. */
712 yystack_
= stack_type (0);
713 yypush_ (0, 0, yyla
);
715 // A new symbol was pushed on the stack.
717 YYCDEBUG
<< "Entering state " << yystack_
[0].state
<< std::endl
;
720 if (yystack_
[0].state
== yyfinal_
)
728 /* Try to take a decision without lookahead. */
729 yyn
= yypact_
[yystack_
[0].state
];
730 if (yy_pact_value_is_default_ (yyn
))
733 /* Read a lookahead token. */
736 YYCDEBUG
<< "Reading a token: ";
738 [ yyla
= b4_c_function_call([yylex
], [symbol_type
],
739 m4_ifdef([b4_lex_param
], b4_lex_param
));],
740 [ yyla
.type
= yytranslate_ (b4_c_function_call([yylex
], [int],
741 [[YYSTYPE
*], [&yyla
.value
]][]dnl
742 b4_locations_if([, [[location
*], [&yyla
.location
]]])dnl
743 m4_ifdef([b4_lex_param
], [, ]b4_lex_param
)));])[
746 YY_SYMBOL_PRINT ("Next token is", yyla
);
748 /* If the proper action on seeing token YYLA.TYPE is to reduce or
749 to detect an error, take that action. */
751 if (yyn
< 0 || yylast_
< yyn
|| yycheck_
[yyn
] != yyla
.type
)
754 /* Reduce or error. */
758 if (yy_table_value_is_error_ (yyn
))
764 /* Discard the token being shifted. */
767 /* Count tokens shifted since error; after three, turn off error
772 /* Shift the lookahead token. */
773 yypush_ ("Shifting", yyn
, yyla
);
776 /*-----------------------------------------------------------.
777 | yydefault -- do the default action for the current state. |
778 `-----------------------------------------------------------*/
780 yyn
= yydefact_
[yystack_
[0].state
];
785 /*-----------------------------.
786 | yyreduce -- Do a reduction. |
787 `-----------------------------*/
790 yylhs
.state
= yy_lr_goto_state_(yystack_
[yylen
].state
, yyr1_
[yyn
]);]b4_variant_if([
791 /* Variants are always initialized to an empty instance of the
792 correct type. The default $$=$1 action is NOT applied when using
794 b4_symbol_variant([[yyr1_@
{yyn@
}]], [yylhs
.value
], [build
])],[
795 /* If YYLEN is nonzero, implement the default value of the action:
796 `$$ = $1'. Otherwise, use the top of the stack.
798 Otherwise, the following line sets YYLHS.VALUE to garbage.
799 This behavior is undocumented and Bison
800 users should not rely upon it. */
802 yylhs
.value
= yystack_@
{yylen
- 1@
}.value
;
804 yylhs
.value
= yystack_@
{0@
}.value
;])[
805 ]b4_locations_if([dnl
807 // Compute the default @@$.
809 slice
<stack_symbol_type
, stack_type
> slice (yystack_
, yylen
);
810 YYLLOC_DEFAULT (yylhs
.location
, slice
, yylen
);
813 // Perform the reduction.
814 YY_REDUCE_PRINT (yyn
);
824 catch (const syntax_error
& yyexc
)
826 error (]b4_args(b4_locations_if([yyexc
.location
]),
830 YY_SYMBOL_PRINT ("-> $$ =", yylhs
);
832 // Destroy the rhs symbols.
833 for (int i
= 0; i
< yylen
; ++i
)
834 // Destroy a variant which value may have been swapped with
835 // yylhs.value (for instance if the action was "std::swap($$,
836 // $1)"). The value of yylhs.value (hence possibly one of these
837 // rhs symbols) depends on the default contruction for this
838 // type. In the case of pointers for instance, no
839 // initialization is done, so the value is junk. Therefore do
840 // not try to report the value of symbols about to be destroyed
841 // in the debug trace, it's possibly junk. Hence yymsg = 0.
842 // Besides, that keeps exactly the same traces as with the other
844 yy_destroy_ (0, yystack_
[i
]);]])[
850 /* Shift the result of the reduction. */
854 /*--------------------------------------.
855 | yyerrlab -- here on detecting error. |
856 `--------------------------------------*/
858 /* If not already recovering from an error, report this error. */
862 error (]b4_args(b4_locations_if([yyla
.location
]),
863 [[yysyntax_error_ (yystack_
[0].state
,
864 yyempty
? yyempty_
: yyla
.type
)]])[);
868 yyerror_range
[1].location
= yyla
.location
;]])[
869 if (yyerrstatus_
== 3)
871 /* If just tried and failed to reuse lookahead token after an
872 error, discard it. */
874 /* Return failure if at end of input. */
875 if (yyla
.type
== yyeof_
)
879 yy_destroy_ ("Error: discarding", yyla
);
884 /* Else will try to reuse lookahead token after shifting the error
889 /*---------------------------------------------------.
890 | yyerrorlab -- error raised explicitly by YYERROR. |
891 `---------------------------------------------------*/
894 /* Pacify compilers like GCC when the user code never invokes
895 YYERROR and the label yyerrorlab therefore never appears in user
898 goto yyerrorlab
;]b4_locations_if([[
899 yyerror_range
[1].location
= yystack_
[yylen
- 1].location
;]])b4_variant_if([[
900 /* $$ was initialized before running the user action. */
901 yy_destroy_ ("Error: discarding", yylhs
);]])[
902 /* Do not reclaim the symbols of the rule which action triggered
908 /*-------------------------------------------------------------.
909 | yyerrlab1 -- common code for both syntax error and YYERROR. |
910 `-------------------------------------------------------------*/
912 yyerrstatus_
= 3; /* Each real token shifted decrements this. */
914 stack_symbol_type error_token
;
917 yyn
= yypact_
[yystack_
[0].state
];
918 if (!yy_pact_value_is_default_ (yyn
))
921 if (0 <= yyn
&& yyn
<= yylast_
&& yycheck_
[yyn
] == yyterror_
)
929 // Pop the current state because it cannot handle the error token.
930 if (yystack_
.size () == 1)
933 yyerror_range
[1].location
= yystack_
[0].location
;]])[
934 yy_destroy_ ("Error: popping", yystack_
[0]);
939 yyerror_range
[2].location
= yyla
.location
;
940 YYLLOC_DEFAULT (error_token
.location
, yyerror_range
, 2);]])[
942 /* Shift the error token. */
943 error_token
.state
= yyn
;
944 yypush_ ("Shifting", error_token
);
960 yy_destroy_ ("Cleanup: discarding lookahead", yyla
);
962 /* Do not reclaim the symbols of the rule which action triggered
963 this YYABORT or YYACCEPT. */
965 while (yystack_
.size () != 1)
967 yy_destroy_ ("Cleanup: popping", yystack_
[0]);
974 // Generate an error message.
976 ]b4_parser_class_name
[::yysyntax_error_ (]dnl
977 b4_error_verbose_if([state_type yystate
, int yytoken
],
979 {]b4_error_verbose_if([[
981 // Number of reported tokens (one for the "unexpected", one per
985 enum { YYERROR_VERBOSE_ARGS_MAXIMUM
= 5 };
986 // Arguments of yyformat.
987 char const *yyarg
[YYERROR_VERBOSE_ARGS_MAXIMUM
];
989 /* There are many possibilities here to consider:
990 - If this state is a consistent state with a default action, then
991 the only way this function was invoked is if the default action
992 is an error action. In that case, don't check for expected
993 tokens because there are none.
994 - The only way there can be no lookahead present (in yytoken) is
995 if this state is a consistent state with a default action.
996 Thus, detecting the absence of a lookahead is sufficient to
997 determine that there is no unexpected or expected token to
998 report. In that case, just report a simple "syntax error".
999 - Don't assume there isn't a lookahead just because this state is
1000 a consistent state with a default action. There might have
1001 been a previous inconsistent state, consistent state with a
1002 non-default action, or user semantic action that manipulated
1003 yyla. (However, yyla is currently not documented for users.)
1004 - Of course, the expected token list depends on states to have
1005 correct lookahead information, and it depends on the parser not
1006 to perform extra reductions after fetching a lookahead from the
1007 scanner and before detecting a syntax error. Thus, state
1008 merging (from LALR or IELR) and default reductions corrupt the
1009 expected token list. However, the list is correct for
1010 canonical LR with one exception: it will still contain any
1011 token that will not be accepted due to an error action in a
1014 if (yytoken
!= yyempty_
)
1016 yyarg
[yycount
++] = yytname_
[yytoken
];
1017 int yyn
= yypact_
[yystate
];
1018 if (!yy_pact_value_is_default_ (yyn
))
1020 /* Start YYX at -YYN if negative to avoid negative indexes in
1021 YYCHECK. In other words, skip the first -YYN actions for
1022 this state because they are default actions. */
1023 int yyxbegin
= yyn
< 0 ? -yyn
: 0;
1024 /* Stay within bounds of both yycheck and yytname. */
1025 int yychecklim
= yylast_
- yyn
+ 1;
1026 int yyxend
= yychecklim
< yyntokens_
? yychecklim
: yyntokens_
;
1027 for (int yyx
= yyxbegin
; yyx
< yyxend
; ++yyx
)
1028 if (yycheck_
[yyx
+ yyn
] == yyx
&& yyx
!= yyterror_
1029 && !yy_table_value_is_error_ (yytable_
[yyx
+ yyn
]))
1031 if (yycount
== YYERROR_VERBOSE_ARGS_MAXIMUM
)
1037 yyarg
[yycount
++] = yytname_
[yyx
];
1042 char const* yyformat
= 0;
1045 #define YYCASE_(N, S) \
1049 YYCASE_(0, YY_("syntax error"));
1050 YYCASE_(1, YY_("syntax error, unexpected %s"));
1051 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1052 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1053 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1054 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1060 for (char const* yyp
= yyformat
; *yyp
; ++yyp
)
1061 if (yyp
[0] == '%' && yyp
[1] == 's' && yyi
< yycount
)
1063 yyres
+= yytnamerr_ (yyarg
[yyi
++]);
1069 return YY_("syntax error");]])[
1073 const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
) b4_parser_class_name::yypact_ninf_
= b4_pact_ninf
[;
1075 const ]b4_int_type(b4_table_ninf
, b4_table_ninf
) b4_parser_class_name::yytable_ninf_
= b4_table_ninf
[;
1077 ]b4_parser_tables_define
[
1079 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1080 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1081 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1083 const ]b4_parser_class_name
[::yytname_
[] =
1090 ]b4_integral_parser_table_define([rline
], [b4_rline
])[
1092 // Print the state stack on the debug stream.
1094 ]b4_parser_class_name
[::yystack_print_ ()
1096 *yycdebug_
<< "Stack now";
1097 for (stack_type::const_iterator
1098 i
= yystack_
.begin (),
1099 i_end
= yystack_
.end ();
1101 *yycdebug_
<< ' ' << i
->state
;
1102 *yycdebug_
<< std::endl
;
1105 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1107 ]b4_parser_class_name
[::yy_reduce_print_ (int yyrule
)
1109 unsigned int yylno
= yyrline_
[yyrule
];
1110 int yynrhs
= yyr2_
[yyrule
];
1111 /* Print the symbols being reduced, and their result. */
1112 *yycdebug_
<< "Reducing stack by rule " << yyrule
- 1
1113 << " (line " << yylno
<< "):" << std::endl
;
1114 /* The symbols being reduced. */
1115 for (int yyi
= 0; yyi
< yynrhs
; yyi
++)
1116 YY_SYMBOL_PRINT (" $" << yyi
+ 1 << " =",
1117 ]b4_rhs_data(yynrhs
, yyi
+ 1)[);
1121 ]b4_lex_symbol_if([], [b4_yytranslate_define
])[
1122 ]b4_namespace_close
[
1125 m4_popdef([b4_copyright_years
])dnl