1 # C++ skeleton for Bison
3 # Copyright (C) 2002-2013 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>_" whose contents is CONTENT.
24 m4_define([b4_integral_parser_table_declare
],
25 [m4_ifval([$
3], [b4_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>_" whose 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_symbol_value
], m4_defn([b4_symbol_value_template
]))[]dnl
102 b4_dollar_pushdef([yysym
.value
],
103 b4_symbol_if([$
1], [has_type
],
104 [m4_dquote(b4_symbol([$
1], [type
]))]),
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_symbol_value
])[]dnl
113 b4_dollar_popdef
[]dnl
122 [b4_function_call([yylex
],
123 [symbol_type
], m4_ifdef([b4_lex_param
], b4_lex_param
))],
124 [b4_function_call([yylex
], [int],
125 [b4_api_PREFIX
[STYPE
*], [&yyla
.value
]][]dnl
126 b4_locations_if([, [[location
*], [&yyla
.location
]]])dnl
127 m4_ifdef([b4_lex_param
], [, ]b4_lex_param
))])])
130 m4_pushdef([b4_copyright_years
],
133 m4_define([b4_parser_class_name
],
134 [b4_percent_define_get([[parser_class_name]])])
136 b4_bison_locations_if([# Backward compatibility.
137 m4_define([b4_location_constructors
])
138 m4_include(b4_pkgdatadir
/[location
.cc
])])
139 m4_include(b4_pkgdatadir
/[stack
.hh
])
140 b4_variant_if([m4_include(b4_pkgdatadir
/[variant
.hh
])])
142 # b4_shared_declarations
143 # ----------------------
144 # Declaration that might either go into the header (if --defines)
145 # or open coded in the parser body.
146 m4_define([b4_shared_declarations
],
147 [b4_percent_code_get([[requires]])[
148 ]b4_parse_assert_if([# include <cassert>])[
149 # include <cstdlib> // abort
152 # include <stdexcept>
153 # include <string>]b4_defines_if([[
155 ]b4_bison_locations_if([[# include "location.hh"]])])[
156 ]b4_variant_if([b4_variant_includes
])[
164 b4_bison_locations_if([b4_position_define
165 b4_location_define
])])[
167 ]b4_variant_if([b4_variant_define
])[
170 class ]b4_parser_class_name
[
173 ]b4_public_types_declare
[
174 /// Build a parser object.
175 ]b4_parser_class_name
[ (]b4_parse_param_decl
[);
176 virtual ~]b4_parser_class_name
[ ();
179 /// \returns 0 iff parsing succeeded.
180 virtual int parse ();
182 #if ]b4_api_PREFIX[DEBUG
183 /// The current debugging stream.
184 std::ostream
& debug_stream () const;
185 /// Set the current debugging stream.
186 void set_debug_stream (std::ostream
&);
188 /// Type for debugging levels.
189 typedef int debug_level_type
;
190 /// The current debugging level.
191 debug_level_type
debug_level () const;
192 /// Set the current debugging level.
193 void set_debug_level (debug_level_type l
);
196 /// Report a syntax error.]b4_locations_if([[
197 /// \param loc where the syntax error is found.]])[
198 /// \param msg a description of the syntax error.
199 virtual void error (]b4_locations_if([[const location_type
& loc
, ]])[const std::string
& msg
);
201 /// Report a syntax error.
202 void error (const syntax_error
& err
);
206 typedef int state_type
;
208 /// Generate an error message.
209 /// \param yystate the state where the error occurred.
210 /// \param yytoken the lookahead token.
211 virtual std::string
yysyntax_error_ (state_type yystate
, int yytoken
);
213 /// Compute post-reduction state.
214 /// \param yystate the current state
215 /// \param yylhs the nonterminal to push on the stack
216 state_type
yy_lr_goto_state_ (state_type yystate
, int yylhs
);
218 /// Whether the given \c yypact_ value indicates a defaulted state.
219 /// \param yyvalue the value to check
220 static bool yy_pact_value_is_default_ (int yyvalue
);
222 /// Whether the given \c yytable_ value indicates a syntax error.
223 /// \param yyvalue the value to check
224 static bool yy_table_value_is_error_ (int yyvalue
);
226 /// Internal symbol numbers.
227 typedef ]b4_int_type_for([b4_translate
])[ token_number_type
;
228 static const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
)[ yypact_ninf_
;
229 static const ]b4_int_type(b4_table_ninf
, b4_table_ninf
)[ yytable_ninf_
;
231 /// Convert a scanner token number \a t to a symbol number.
232 static inline token_number_type
yytranslate_ (]b4_token_ctor_if([token_type
], [int])[ t
);
235 ]b4_parser_tables_declare
[]b4_error_verbose_if([
237 /// Convert the symbol name \a n to a form suitable for a diagnostic.
238 static std::string
yytnamerr_ (const char *n
);])[
240 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
241 /// For a symbol, its name in clear.
242 static const char* const yytname_
[];
243 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
244 ]b4_integral_parser_table_declare([rline
], [b4_rline
],
245 [[YYRLINE
[YYN
] -- Source line where rule number YYN was defined
.]])[
246 /// Report on the debug stream that the rule \a r is going to be reduced.
247 virtual void yy_reduce_print_ (int r
);
248 /// Print the state stack on the debug stream.
249 virtual void yystack_print_ ();
253 std::ostream
* yycdebug_
;
255 /// \brief Display a symbol type, value and location.
256 /// \param yyo The output stream.
257 /// \param yysym The symbol.
258 template <typename Base
>
259 void yy_print_ (std::ostream
& yyo
,
260 const basic_symbol
<Base
>& yysym
) const;
263 /// \brief Reclaim the memory associated to a symbol.
264 /// \param yymsg Why this token is reclaimed.
265 /// If null, print nothing.
266 /// \param s The symbol.
267 template <typename Base
>
268 inline void yy_destroy_ (const char* yymsg
,
269 basic_symbol
<Base
>& yysym
) const;
272 /// Type access provider for state based symbols.
275 /// Default constructor.
279 inline by_state (state_type s
);
281 /// Copy constructor.
282 inline by_state (const by_state
& other
);
287 /// The type (corresponding to \a state).
288 inline int type_get () const;
290 /// The type used to store the symbol type.
291 typedef state_type value_type
;
294 /// "Internal" symbol: element of the stack.
295 typedef basic_symbol
<by_state
> stack_symbol_type
;
298 typedef stack
<stack_symbol_type
> stack_type
;
303 /// Push a new state on the stack.
304 /// \param m a debug message to display
305 /// if null, no trace is output.
306 /// \param s the symbol
307 /// \warning the contents of \a s.value is stolen.
308 inline void yypush_ (const char* m
, stack_symbol_type
& s
);
310 /// Push a new look ahead token on the state on the stack.
311 /// \param m a debug message to display
312 /// if null, no trace is output.
313 /// \param s the state
314 /// \param sym the symbol (for its value and location).
315 /// \warning the contents of \a s.value is stolen.
316 inline void yypush_ (const char* m
, state_type s
, symbol_type
& sym
);
318 /// Pop \a n symbols the three stacks.
319 inline void yypop_ (unsigned int n
= 1);
325 yylast_
= ]b4_last
[, //< Last index in yytable_.
326 yynnts_
= ]b4_nterms_number
[, //< Number of nonterminal symbols.
328 yyfinal_
= ]b4_final_state_number
[, //< Termination state number.
331 yyntokens_
= ]b4_tokens_number
[ //< Number of tokens.
334 ]b4_parse_param_vars
[
337 ]b4_token_ctor_if([b4_yytranslate_define
338 b4_public_types_define
])[
341 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
344 #ifndef ]b4_api_PREFIX[STYPE
345 // Redirection for backward compatibility.
346 # define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type
349 ]b4_percent_code_get([[provides]])[
353 [b4_output_begin([b4_spec_defines_file
])
354 b4_copyright([Skeleton interface
for Bison
LALR(1) parsers in C
++])
357 ** \file ]b4_spec_defines_file[
358 ** Define the ]b4_namespace_ref[::parser class.
361 // C++ LALR(1) parser skeleton written by Akim Demaille.
363 ]b4_cpp_guard_open([b4_spec_defines_file
])[
364 ]b4_shared_declarations
[
365 ]b4_cpp_guard_close([b4_spec_defines_file
])
370 b4_output_begin([b4_parser_file_name
])
371 b4_copyright([Skeleton implementation
for Bison
LALR(1) parsers in C
++])
372 b4_percent_code_get([[top]])[]dnl
373 m4_if(b4_prefix
, [yy
], [],
375 // Take the name prefix into account.
376 #define yylex b4_prefix[]lex])[
378 // First part of user declarations.
379 ]b4_user_pre_prologue
[
383 ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
384 [b4_shared_declarations
])[
386 // User implementation prologue.
387 ]b4_user_post_prologue
[
388 ]b4_percent_code_get
[
391 # if defined YYENABLE_NLS && YYENABLE_NLS
393 # include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
394 # define YY_(msgid) dgettext ("bison-runtime", msgid)
398 # define YY_(msgid) msgid
402 ]b4_locations_if([dnl
403 [#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
404 ]b4_yylloc_default_define
])[
406 // Suppress unused-variable warnings by "using" E.
407 #define YYUSE(E) ((void) (E))
409 // Enable debugging if requested.
410 #if ]b4_api_PREFIX[DEBUG
412 // A pseudo ostream that takes yydebug_ into account.
413 # define YYCDEBUG if (yydebug_) (*yycdebug_)
415 # define YY_SYMBOL_PRINT(Title, Symbol) \
419 *yycdebug_ << Title << ' '; \
420 yy_print_ (*yycdebug_, Symbol); \
421 *yycdebug_ << std::endl; \
425 # define YY_REDUCE_PRINT(Rule) \
428 yy_reduce_print_ (Rule); \
431 # define YY_STACK_PRINT() \
437 #else // !]b4_api_PREFIX[DEBUG
439 # define YYCDEBUG if (false) std::cerr
440 # define YY_SYMBOL_PRINT(Title, Symbol) YYUSE(Symbol)
441 # define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
442 # define YY_STACK_PRINT() static_cast<void>(0)
444 #endif // !]b4_api_PREFIX[DEBUG
446 #define yyerrok (yyerrstatus_ = 0)
447 #define yyclearin (yyempty = true)
449 #define YYACCEPT goto yyacceptlab
450 #define YYABORT goto yyabortlab
451 #define YYERROR goto yyerrorlab
452 #define YYRECOVERING() (!!yyerrstatus_)
454 ]b4_namespace_open
[]b4_error_verbose_if([[
456 /* Return YYSTR after stripping away unnecessary quotes and
457 backslashes, so that it's suitable for yyerror. The heuristic is
458 that double-quoting is unnecessary unless the string contains an
459 apostrophe, a comma, or backslash (other than backslash-backslash).
460 YYSTR is taken from yytname. */
462 ]b4_parser_class_name
[::yytnamerr_ (const char *yystr
)
466 std::string yyr
= "";
467 char const *yyp
= yystr
;
474 goto do_not_strip_quotes
;
478 goto do_not_strip_quotes
;
487 do_not_strip_quotes
: ;
494 /// Build a parser object.
495 ]b4_parser_class_name::b4_parser_class_name
[ (]b4_parse_param_decl
[)]m4_ifset([b4_parse_param
], [
497 #if ]b4_api_PREFIX[DEBUG
498 ]m4_ifset([b4_parse_param
], [ ], [ :])[yydebug_ (false),
499 yycdebug_ (&std::cerr
)]m4_ifset([b4_parse_param
], [,])[
500 #endif]b4_parse_param_cons[
503 ]b4_parser_class_name::~b4_parser_class_name
[ ()
511 ]b4_token_ctor_if([], [b4_public_types_define
])[
514 ]b4_parser_class_name
[::by_state::by_state ()
518 ]b4_parser_class_name
[::by_state::by_state (const by_state
& other
)
519 : state (other
.state
)
522 ]b4_parser_class_name
[::by_state::by_state (state_type s
)
527 ]b4_parser_class_name
[::by_state::type_get () const
529 return yystos_
[state
];
533 template <typename Base
>
535 ]b4_parser_class_name
[::yy_destroy_ (const char* yymsg
, basic_symbol
<Base
>& yysym
) const
538 YY_SYMBOL_PRINT (yymsg
, yysym
);
541 int yytype
= yysym
.type_get ();
544 ]b4_symbol_foreach([b4_symbol_destructor
])dnl
550 b4_symbol_variant([[yytype]], [[yysym
.value
]], [[template destroy]])])[
553 #if ]b4_api_PREFIX[DEBUG
554 template <typename Base
>
556 ]b4_parser_class_name
[::yy_print_ (std::ostream
& yyo
,
557 const basic_symbol
<Base
>& yysym
) const
559 std::ostream
& yyoutput
= yyo
;
561 int yytype
= yysym
.type_get ();
562 yyo
<< (yytype
< yyntokens_
? "token" : "nterm")
563 << ' ' << yytname_
[yytype
] << " ("]b4_locations_if([
564 << yysym
.location
<< ": "])[;
567 ]b4_symbol_foreach([b4_symbol_printer
])dnl
576 ]b4_parser_class_name
[::yypush_ (const char* m
, state_type s
, symbol_type
& sym
)
579 YY_SYMBOL_PRINT (m
, sym
);
582 stack_symbol_type
ss (]b4_join([s
],
583 [sym
.value
], b4_locations_if([sym
.location
]))[);
584 ]b4_symbol_variant([sym
.type_get ()], [sym
.value
], [destroy
], [])[;
587 [[ yystack_
.push (stack_symbol_type (]b4_join([s
],
588 [sym
.value
], b4_locations_if([sym
.location
]))[));]])[
592 ]b4_parser_class_name
[::yypush_ (const char* m
, stack_symbol_type
& s
)
595 YY_SYMBOL_PRINT (m
, s
);
598 stack_symbol_type
ss (]b4_join([s
.state
],
599 [s
.value
], b4_locations_if([s
.location
]))[);
600 ]b4_symbol_variant([s
.type_get ()], [s
.value
], [destroy
], [])[;
603 [ yystack_
.push (s
);])[
607 ]b4_parser_class_name
[::yypop_ (unsigned int n
)
612 #if ]b4_api_PREFIX[DEBUG
614 ]b4_parser_class_name
[::debug_stream () const
620 ]b4_parser_class_name
[::set_debug_stream (std::ostream
& o
)
626 ]b4_parser_class_name
[::debug_level_type
627 ]b4_parser_class_name
[::debug_level () const
633 ]b4_parser_class_name
[::set_debug_level (debug_level_type l
)
637 #endif // ]b4_api_PREFIX[DEBUG
639 inline ]b4_parser_class_name
[::state_type
640 ]b4_parser_class_name
[::yy_lr_goto_state_ (state_type yystate
, int yylhs
)
642 int yyr
= yypgoto_
[yylhs
- yyntokens_
] + yystate
;
643 if (0 <= yyr
&& yyr
<= yylast_
&& yycheck_
[yyr
] == yystate
)
644 return yytable_
[yyr
];
646 return yydefgoto_
[yylhs
- yyntokens_
];
650 ]b4_parser_class_name
[::yy_pact_value_is_default_ (int yyvalue
)
652 return yyvalue
== yypact_ninf_
;
656 ]b4_parser_class_name
[::yy_table_value_is_error_ (int yyvalue
)
658 return yyvalue
== yytable_ninf_
;
662 ]b4_parser_class_name
[::parse ()
664 /// Whether yyla contains a lookahead.
673 int yyerrstatus_
= 0;
675 /// The lookahead symbol.
676 symbol_type yyla
;]b4_locations_if([[
678 /// The locations where the error started and ended.
679 stack_symbol_type yyerror_range
[3];]])[
682 stack_symbol_type yylhs
;
684 /// The return value of parse ().
687 // FIXME: This shoud be completely indented. It is not yet to
688 // avoid gratuitous conflicts when merging into the master branch.
691 YYCDEBUG
<< "Starting parse" << std::endl
;
693 ]m4_ifdef([b4_initial_action
], [
694 b4_dollar_pushdef([yyla
.value
], [], [yyla
.location
])dnl
695 // User initialization code.
696 b4_user_initial_action
697 b4_dollar_popdef
])[]dnl
699 [ /* Initialize the stack. The initial state will be set in
700 yynewstate, since the latter expects the semantical and the
701 location values to have been already stored, initialize these
702 stacks with a primary value. */
703 yystack_
= stack_type (0);
704 yypush_ (YY_NULL
, 0, yyla
);
706 // A new symbol was pushed on the stack.
708 YYCDEBUG
<< "Entering state " << yystack_
[0].state
<< std::endl
;
711 if (yystack_
[0].state
== yyfinal_
)
719 // Try to take a decision without lookahead.
720 yyn
= yypact_
[yystack_
[0].state
];
721 if (yy_pact_value_is_default_ (yyn
))
724 // Read a lookahead token.
727 YYCDEBUG
<< "Reading a token: ";
729 {]b4_token_ctor_if([[
730 symbol_type
yylookahead (]b4_lex
[);
731 yyla
.move (yylookahead
);]], [[
732 yyla
.type
= yytranslate_ (]b4_lex
[);]])[
734 catch (const syntax_error
& yyexc
)
741 YY_SYMBOL_PRINT ("Next token is", yyla
);
743 /* If the proper action on seeing token YYLA.TYPE is to reduce or
744 to detect an error, take that action. */
746 if (yyn
< 0 || yylast_
< yyn
|| yycheck_
[yyn
] != yyla
.type
)
753 if (yy_table_value_is_error_ (yyn
))
759 // Discard the token being shifted.
762 // Count tokens shifted since error; after three, turn off error status.
766 // Shift the lookahead token.
767 yypush_ ("Shifting", yyn
, yyla
);
770 /*-----------------------------------------------------------.
771 | yydefault -- do the default action for the current state. |
772 `-----------------------------------------------------------*/
774 yyn
= yydefact_
[yystack_
[0].state
];
779 /*-----------------------------.
780 | yyreduce -- Do a reduction. |
781 `-----------------------------*/
784 yylhs
.state
= yy_lr_goto_state_(yystack_
[yylen
].state
, yyr1_
[yyn
]);]b4_variant_if([
785 /* Variants are always initialized to an empty instance of the
786 correct type. The default $$=$1 action is NOT applied when using
788 b4_symbol_variant([[yyr1_@
{yyn@
}]], [yylhs
.value
], [build
])],[
789 /* If YYLEN is nonzero, implement the default value of the action:
790 `$$ = $1'. Otherwise, use the top of the stack.
792 Otherwise, the following line sets YYLHS.VALUE to garbage.
793 This behavior is undocumented and Bison
794 users should not rely upon it. */
796 yylhs
.value
= yystack_@
{yylen
- 1@
}.value
;
798 yylhs
.value
= yystack_@
{0@
}.value
;])[
799 ]b4_locations_if([dnl
801 // Compute the default @@$.
803 slice
<stack_symbol_type
, stack_type
> slice (yystack_
, yylen
);
804 YYLLOC_DEFAULT (yylhs
.location
, slice
, yylen
);
807 // Perform the reduction.
808 YY_REDUCE_PRINT (yyn
);
818 catch (const syntax_error
& yyexc
)
823 YY_SYMBOL_PRINT ("-> $$ =", yylhs
);
825 // Destroy the rhs symbols.
826 for (int i
= 0; i
< yylen
; ++i
)
827 // Destroy a variant whose value may have been swapped with
828 // yylhs.value (for instance if the action was "std::swap($$,
829 // $1)"). The value of yylhs.value (hence possibly one of these
830 // rhs symbols) depends on the default construction for this
831 // type. In the case of pointers for instance, no
832 // initialization is done, so the value is junk. Therefore do
833 // not try to report the value of symbols about to be destroyed
834 // in the debug trace, it's possibly junk. Hence yymsg = 0.
835 // Besides, that keeps exactly the same traces as with the other
837 yy_destroy_ (YY_NULL
, yystack_
[i
]);]])[
843 // Shift the result of the reduction.
844 yypush_ (YY_NULL
, yylhs
);
847 /*--------------------------------------.
848 | yyerrlab -- here on detecting error. |
849 `--------------------------------------*/
851 // If not already recovering from an error, report this error.
855 error (]b4_join(b4_locations_if([yyla
.location
]),
856 [[yysyntax_error_ (yystack_
[0].state
,
857 yyempty
? yyempty_
: yyla
.type
)]])[);
861 yyerror_range
[1].location
= yyla
.location
;]])[
862 if (yyerrstatus_
== 3)
864 /* If just tried and failed to reuse lookahead token after an
865 error, discard it. */
867 // Return failure if at end of input.
868 if (yyla
.type
== yyeof_
)
872 yy_destroy_ ("Error: discarding", yyla
);
877 // Else will try to reuse lookahead token after shifting the error token.
881 /*---------------------------------------------------.
882 | yyerrorlab -- error raised explicitly by YYERROR. |
883 `---------------------------------------------------*/
886 /* Pacify compilers like GCC when the user code never invokes
887 YYERROR and the label yyerrorlab therefore never appears in user
890 goto yyerrorlab
;]b4_locations_if([[
891 yyerror_range
[1].location
= yystack_
[yylen
- 1].location
;]])b4_variant_if([[
892 /* $$ was initialized before running the user action. */
893 yy_destroy_ ("Error: discarding", yylhs
);]])[
894 /* Do not reclaim the symbols of the rule whose action triggered
900 /*-------------------------------------------------------------.
901 | yyerrlab1 -- common code for both syntax error and YYERROR. |
902 `-------------------------------------------------------------*/
904 yyerrstatus_
= 3; // Each real token shifted decrements this.
906 stack_symbol_type error_token
;
909 yyn
= yypact_
[yystack_
[0].state
];
910 if (!yy_pact_value_is_default_ (yyn
))
913 if (0 <= yyn
&& yyn
<= yylast_
&& yycheck_
[yyn
] == yyterror_
)
921 // Pop the current state because it cannot handle the error token.
922 if (yystack_
.size () == 1)
925 yyerror_range
[1].location
= yystack_
[0].location
;]])[
926 yy_destroy_ ("Error: popping", yystack_
[0]);
931 yyerror_range
[2].location
= yyla
.location
;
932 YYLLOC_DEFAULT (error_token
.location
, yyerror_range
, 2);]])[
934 // Shift the error token.
935 error_token
.state
= yyn
;
936 yypush_ ("Shifting", error_token
);
952 yy_destroy_ ("Cleanup: discarding lookahead", yyla
);
954 /* Do not reclaim the symbols of the rule whose action triggered
955 this YYABORT or YYACCEPT. */
957 while (1 < yystack_
.size ())
959 yy_destroy_ ("Cleanup: popping", yystack_
[0]);
967 YYCDEBUG
<< "Exception caught: cleaning lookahead and stack"
969 // Do not try to display the values of the reclaimed symbols,
970 // as their printer might throw an exception.
972 yy_destroy_ (YY_NULL
, yyla
);
974 while (1 < yystack_
.size ())
976 yy_destroy_ (YY_NULL
, yystack_
[0]);
984 ]b4_parser_class_name
[::error (const syntax_error
& yyexc
)
986 error (]b4_join(b4_locations_if([yyexc
.location
]),
990 // Generate an error message.
992 ]b4_parser_class_name
[::yysyntax_error_ (]dnl
993 b4_error_verbose_if([state_type yystate
, int yytoken
],
995 {]b4_error_verbose_if([[
997 // Number of reported tokens (one for the "unexpected", one per
1001 enum { YYERROR_VERBOSE_ARGS_MAXIMUM
= 5 };
1002 // Arguments of yyformat.
1003 char const *yyarg
[YYERROR_VERBOSE_ARGS_MAXIMUM
];
1005 /* There are many possibilities here to consider:
1006 - If this state is a consistent state with a default action, then
1007 the only way this function was invoked is if the default action
1008 is an error action. In that case, don't check for expected
1009 tokens because there are none.
1010 - The only way there can be no lookahead present (in yytoken) is
1011 if this state is a consistent state with a default action.
1012 Thus, detecting the absence of a lookahead is sufficient to
1013 determine that there is no unexpected or expected token to
1014 report. In that case, just report a simple "syntax error".
1015 - Don't assume there isn't a lookahead just because this state is
1016 a consistent state with a default action. There might have
1017 been a previous inconsistent state, consistent state with a
1018 non-default action, or user semantic action that manipulated
1019 yyla. (However, yyla is currently not documented for users.)
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
1024 merging (from LALR or IELR) and default reductions corrupt the
1025 expected token list. However, the list is correct for
1026 canonical LR with one exception: it will still contain any
1027 token that will not be accepted due to an error action in a
1030 if (yytoken
!= yyempty_
)
1032 yyarg
[yycount
++] = yytname_
[yytoken
];
1033 int yyn
= yypact_
[yystate
];
1034 if (!yy_pact_value_is_default_ (yyn
))
1036 /* Start YYX at -YYN if negative to avoid negative indexes in
1037 YYCHECK. In other words, skip the first -YYN actions for
1038 this state because they are default actions. */
1039 int yyxbegin
= yyn
< 0 ? -yyn
: 0;
1040 // Stay within bounds of both yycheck and yytname.
1041 int yychecklim
= yylast_
- yyn
+ 1;
1042 int yyxend
= yychecklim
< yyntokens_
? yychecklim
: yyntokens_
;
1043 for (int yyx
= yyxbegin
; yyx
< yyxend
; ++yyx
)
1044 if (yycheck_
[yyx
+ yyn
] == yyx
&& yyx
!= yyterror_
1045 && !yy_table_value_is_error_ (yytable_
[yyx
+ yyn
]))
1047 if (yycount
== YYERROR_VERBOSE_ARGS_MAXIMUM
)
1053 yyarg
[yycount
++] = yytname_
[yyx
];
1058 char const* yyformat
= YY_NULL
;
1061 #define YYCASE_(N, S) \
1065 YYCASE_(0, YY_("syntax error"));
1066 YYCASE_(1, YY_("syntax error, unexpected %s"));
1067 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1068 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1069 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1070 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1076 for (char const* yyp
= yyformat
; *yyp
; ++yyp
)
1077 if (yyp
[0] == '%' && yyp
[1] == 's' && yyi
< yycount
)
1079 yyres
+= yytnamerr_ (yyarg
[yyi
++]);
1085 return YY_("syntax error");]])[
1089 const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
) b4_parser_class_name::yypact_ninf_
= b4_pact_ninf
[;
1091 const ]b4_int_type(b4_table_ninf
, b4_table_ninf
) b4_parser_class_name::yytable_ninf_
= b4_table_ninf
[;
1093 ]b4_parser_tables_define
[
1095 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
1096 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1097 // First, the terminals, then, starting at \a yyntokens_, nonterminals.
1099 const ]b4_parser_class_name
[::yytname_
[] =
1104 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
1105 ]b4_integral_parser_table_define([rline
], [b4_rline
])[
1107 // Print the state stack on the debug stream.
1109 ]b4_parser_class_name
[::yystack_print_ ()
1111 *yycdebug_
<< "Stack now";
1112 for (stack_type::const_iterator
1113 i
= yystack_
.begin (),
1114 i_end
= yystack_
.end ();
1116 *yycdebug_
<< ' ' << i
->state
;
1117 *yycdebug_
<< std::endl
;
1120 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1122 ]b4_parser_class_name
[::yy_reduce_print_ (int yyrule
)
1124 unsigned int yylno
= yyrline_
[yyrule
];
1125 int yynrhs
= yyr2_
[yyrule
];
1126 // Print the symbols being reduced, and their result.
1127 *yycdebug_
<< "Reducing stack by rule " << yyrule
- 1
1128 << " (line " << yylno
<< "):" << std::endl
;
1129 // The symbols being reduced.
1130 for (int yyi
= 0; yyi
< yynrhs
; yyi
++)
1131 YY_SYMBOL_PRINT (" $" << yyi
+ 1 << " =",
1132 ]b4_rhs_data(yynrhs
, yyi
+ 1)[);
1134 #endif // ]b4_api_PREFIX[DEBUG
1136 ]b4_token_ctor_if([], [b4_yytranslate_define
])[
1137 ]b4_namespace_close
[
1142 m4_popdef([b4_copyright_years
])dnl