]> git.saurik.com Git - bison.git/blame - data/lalr1.cc
diagnostics: improve -fcaret for list of accepted values
[bison.git] / data / lalr1.cc
CommitLineData
60491a94 1# C++ skeleton for Bison
b4721715 2
34136e65 3# Copyright (C) 2002-2012 Free Software Foundation, Inc.
60491a94 4
f16b0819 5# This program is free software: you can redistribute it and/or modify
60491a94 6# it under the terms of the GNU General Public License as published by
f16b0819 7# the Free Software Foundation, either version 3 of the License, or
60491a94 8# (at your option) any later version.
f16b0819 9#
60491a94
AD
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.
f16b0819 14#
60491a94 15# You should have received a copy of the GNU General Public License
f16b0819 16# along with this program. If not, see <http://www.gnu.org/licenses/>.
60491a94 17
cf147260 18m4_include(b4_pkgdatadir/[c++.m4])
7eb8a0bc 19
2ea7730c 20
ba206cf4
AD
21# b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
22# --------------------------------------------------------------
0fddb3d5 23# Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT.
ba206cf4 24m4_define([b4_integral_parser_table_declare],
15f66669 25[m4_ifval([$3], [b4_comment([$3], [ ])
6ab1adbe
AD
26])dnl
27 static const b4_int_type_for([$2]) yy$1_[[]];dnl
0fddb3d5
AD
28])
29
ba206cf4 30# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
2b08bceb 31# -------------------------------------------------------------
8901f32e 32# Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
ba206cf4 33m4_define([b4_integral_parser_table_define],
6ab1adbe 34[ const b4_int_type_for([$2])
8901f32e
AD
35 b4_parser_class_name::yy$1_[[]] =
36 {
37 $2
6ab1adbe
AD
38 };dnl
39])
40
a9ce3f54 41
5de9c593
AD
42# b4_symbol_value_template(VAL, [TYPE])
43# -------------------------------------
507aa0e2
AD
44# Same as b4_symbol_value, but used in a template method. It makes
45# a difference when using variants.
5de9c593
AD
46m4_copy([b4_symbol_value], [b4_symbol_value_template])
47
5ab8c47b 48
e1f93869
AD
49# b4_lhs_value([TYPE])
50# --------------------
51# Expansion of $<TYPE>$.
52m4_define([b4_lhs_value],
507aa0e2 53 [b4_symbol_value([yylhs.value], [$1])])
e1f93869
AD
54
55
56# b4_lhs_location()
57# -----------------
58# Expansion of @$.
59m4_define([b4_lhs_location],
507aa0e2 60 [yylhs.location])
e1f93869
AD
61
62
33c195cc
AD
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.
67m4_define([b4_rhs_data],
3204049e 68 [yystack_@{b4_subtract($@)@}])
33c195cc
AD
69
70
71# b4_rhs_state(RULE-LENGTH, NUM)
51bacae6 72# ------------------------------
33c195cc
AD
73# The state corresponding to the symbol #NUM, where the current
74# rule has RULE-LENGTH symbols on RHS.
75m4_define([b4_rhs_state],
76 [b4_rhs_data([$1], [$2]).state])
77
78
8901f32e
AD
79# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
80# --------------------------------------
81# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
82# symbols on RHS.
83m4_define([b4_rhs_value],
33c195cc
AD
84 [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])])
85
8901f32e
AD
86
87# b4_rhs_location(RULE-LENGTH, NUM)
88# ---------------------------------
89# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
90# on RHS.
91m4_define([b4_rhs_location],
33c195cc 92 [b4_rhs_data([$1], [$2]).location])
8901f32e 93
507aa0e2 94
2bde9113
AD
95# b4_symbol_action(SYMBOL-NUM, KIND)
96# ----------------------------------
97# Run the action KIND (destructor or printer) for SYMBOL-NUM.
c4585f1e 98# Same as in C, but using references instead of pointers.
2bde9113
AD
99m4_define([b4_symbol_action],
100[b4_symbol_if([$1], [has_$2],
4323e0da
AD
101[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl
102b4_dollar_pushdef([yysym.value],
103 b4_symbol_if([$1], [has_type],
104 [m4_dquote(b4_symbol([$1], [type]))]),
105 [yysym.location])dnl
fb7c5b1f 106 b4_symbol_case_([$1])
2bde9113
AD
107b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
108 b4_symbol([$1], [$2])
c4585f1e
AD
109b4_syncline([@oline@], [@ofile@])
110 break;
2bde9113 111
4323e0da
AD
112m4_popdef([b4_symbol_value])[]dnl
113b4_dollar_popdef[]dnl
2bde9113
AD
114])])
115
2873fdf8 116
8901f32e 117m4_pushdef([b4_copyright_years],
34136e65 118 [2002-2012])
8901f32e 119
6afc30cc 120m4_define([b4_parser_class_name],
a4e25e1d 121 [b4_percent_define_get([[parser_class_name]])])
34376418 122
bcd80897 123b4_bison_locations_if([# Backward compatibility.
c547693a 124 m4_define([b4_location_constructors])
bcd80897 125 m4_include(b4_pkgdatadir/[location.cc])])
51bacae6 126m4_include(b4_pkgdatadir/[stack.hh])
507aa0e2 127b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])
a5eb1ed2 128
d27c5e65
AD
129# b4_shared_declarations
130# ----------------------
131# Declaration that might either go into the header (if --defines)
132# or open coded in the parser body.
133m4_define([b4_shared_declarations],
134[b4_percent_code_get([[requires]])[
ff348970 135]b4_parse_assert_if([# include <cassert>])[
5de5b987 136# include <deque>
ff348970 137# include <iostream>
5de5b987
AD
138# include <stdexcept>
139# include <string>]b4_defines_if([[
ff348970 140# include "stack.hh"
bcd80897 141]b4_bison_locations_if([[# include "location.hh"]])])[
5de5b987
AD
142
143]b4_YYDEBUG_define[
50997c6e 144
93549bcd 145]b4_namespace_open[
4162fa07 146
5de5b987
AD
147]b4_defines_if([],
148[b4_stack_define
bcd80897
AD
149b4_bison_locations_if([b4_position_define
150b4_location_define])])[
69e2658b 151
93549bcd 152]b4_variant_if([b4_variant_define])[
3f3eed27 153
efeed023 154 /// A Bison parser.
07fed891 155 class ]b4_parser_class_name[
2b548aa6 156 {
fb9712a9 157 public:
4f84717d 158]b4_public_types_declare[
efeed023 159 /// Build a parser object.
98ae9643
AD
160 ]b4_parser_class_name[ (]b4_parse_param_decl[);
161 virtual ~]b4_parser_class_name[ ();
2b548aa6 162
f69a4142
AD
163 /// Parse.
164 /// \returns 0 iff parsing succeeded.
e019c247 165 virtual int parse ();
2b548aa6 166
5f108727 167#if ]b4_api_PREFIX[DEBUG
f69a4142 168 /// The current debugging stream.
9a1e9989
AD
169 std::ostream& debug_stream () const;
170 /// Set the current debugging stream.
171 void set_debug_stream (std::ostream &);
172
a3cb6248
AD
173 /// Type for debugging levels.
174 typedef int debug_level_type;
175 /// The current debugging level.
176 debug_level_type debug_level () const;
177 /// Set the current debugging level.
178 void set_debug_level (debug_level_type l);
52cbbe84 179#endif
a3cb6248 180
34904c57
AD
181 /// Report a syntax error.]b4_locations_if([[
182 /// \param loc where the syntax error is found.]])[
efeed023 183 /// \param msg a description of the syntax error.
34904c57 184 virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg);
efeed023 185
a6552c5d
AD
186 /// Report a syntax error.
187 void error (const syntax_error& err);
188
49572920 189 private:
e019c247 190 /// State numbers.
f479c6c6 191 typedef int state_type;
2b548aa6 192
ceb8b8e6
AD
193 /// Generate an error message.
194 /// \param yystate the state where the error occurred.
195 /// \param yytoken the lookahead token.
196 virtual std::string yysyntax_error_ (state_type yystate, int yytoken);
197
7580c379
AD
198 /// Compute post-reduction state.
199 /// \param yystate the current state
200 /// \param yylhs the nonterminal to push on the stack
201 state_type yy_lr_goto_state_ (state_type yystate, int yylhs);
202
f2b30bdf
JD
203 /// Whether the given \c yypact_ value indicates a defaulted state.
204 /// \param yyvalue the value to check
205 static bool yy_pact_value_is_default_ (int yyvalue);
206
207 /// Whether the given \c yytable_ value indicates a syntax error.
208 /// \param yyvalue the value to check
209 static bool yy_table_value_is_error_ (int yyvalue);
210
e019c247 211 /// Internal symbol numbers.
f479c6c6 212 typedef ]b4_int_type_for([b4_translate])[ token_number_type;
617a8f12 213 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
617a8f12 214 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
efeed023 215
7aaaad6c
AD
216 // Tables.
217]b4_parser_tables_declare[]b4_error_verbose_if([
9e0876fb 218
9e0876fb 219 /// Convert the symbol name \a n to a form suitable for a diagnostic.
422c18f4 220 static std::string yytnamerr_ (const char *n);])[
2b548aa6 221
5f108727 222]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
258cddbc
AD
223 /// For a symbol, its name in clear.
224 static const char* const yytname_[];
5f108727 225]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
ba206cf4
AD
226]b4_integral_parser_table_declare([rline], [b4_rline],
227 [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
efeed023 228 /// Report on the debug stream that the rule \a r is going to be reduced.
d1ff7a7c 229 virtual void yy_reduce_print_ (int r);
efeed023 230 /// Print the state stack on the debug stream.
f69a4142 231 virtual void yystack_print_ ();
fa7b79c0 232
7aaaad6c 233 // Debugging.
fa7b79c0
PE
234 int yydebug_;
235 std::ostream* yycdebug_;
ccdc1577 236#endif // ]b4_api_PREFIX[DEBUG
2b548aa6 237
32c96bd7 238 /// Convert a scanner token number \a t to a symbol number.
e36ec1f4 239 static inline token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t);
f69a4142 240
ccdc1577 241#if ]b4_api_PREFIX[DEBUG
1f7d007b
AD
242 /// \brief Display a symbol type, value and location.
243 /// \param yyo The output stream.
244 /// \param yysym The symbol.
5de9c593
AD
245 template <typename Exact>
246 void yy_print_ (std::ostream& yyo,
247 const symbol_base_type<Exact>& yysym) const;
57295d14
AD
248#endif
249
1f7d007b
AD
250 /// \brief Reclaim the memory associated to a symbol.
251 /// \param yymsg Why this token is reclaimed.
252 /// If null, print nothing.
253 /// \param s The symbol.
5de9c593
AD
254 template <typename Exact>
255 inline void yy_destroy_ (const char* yymsg,
256 symbol_base_type<Exact>& yysym) const;
1f7d007b 257
2873fdf8 258 private:
1f7d007b 259 /// Element of the stack: a state and its attributes.
5de9c593 260 struct stack_symbol_type : symbol_base_type<stack_symbol_type>
1f7d007b 261 {
5de9c593
AD
262 /// The parent class.
263 typedef symbol_base_type<stack_symbol_type> super_type;
264
1f7d007b 265 /// Default constructor.
d3be4f6d 266 inline stack_symbol_type ();
1f7d007b
AD
267
268 /// Constructor.
710c4a65 269 inline stack_symbol_type (]b4_join([state_type s],
2ea7730c
AD
270 [const semantic_type& v],
271 b4_locations_if([const location_type& l]))[);
1f7d007b
AD
272
273 /// The state.
274 state_type state;
57295d14 275
2b08bceb 276 /// The type (corresponding to \a state).
5de9c593 277 inline int type_get_ () const;
1f7d007b 278 };
57295d14 279
8901f32e 280 /// Stack type.
bc0b0477 281 typedef stack<stack_symbol_type> stack_type;
8901f32e
AD
282
283 /// The stack.
284 stack_type yystack_;
285
7dedf26e 286 /// Push a new state on the stack.
9380cfd0
AD
287 /// \param m a debug message to display
288 /// if null, no trace is output.
e9b0834e
AD
289 /// \param s the symbol
290 /// \warning the contents of \a s.value is stolen.
bc0b0477 291 inline void yypush_ (const char* m, stack_symbol_type& s);
7dedf26e 292
1f7d007b
AD
293 /// Push a new look ahead token on the state on the stack.
294 /// \param m a debug message to display
295 /// if null, no trace is output.
296 /// \param s the state
297 /// \param sym the symbol (for its value and location).
298 /// \warning the contents of \a s.value is stolen.
299 inline void yypush_ (const char* m, state_type s, symbol_type& sym);
300
52d5733f 301 /// Pop \a n symbols the three stacks.
f69a4142 302 inline void yypop_ (unsigned int n = 1);
52d5733f 303
762a801e 304 /* Constants. */
914202bd
AD
305 enum
306 {
307 yyeof_ = 0,
308 yylast_ = ]b4_last[, //< Last index in yytable_.
309 yynnts_ = ]b4_nterms_number[, //< Number of nonterminal symbols.
310 yyempty_ = -2,
311 yyfinal_ = ]b4_final_state_number[, //< Termination state number.
312 yyterror_ = 1,
313 yyerrcode_ = 256,
f3bd3f78 314 yyntokens_ = ]b4_tokens_number[ //< Number of tokens.
914202bd
AD
315 };
316
caf37a36 317]b4_parse_param_vars[
2b548aa6 318 };
1c4af381 319
e36ec1f4 320]b4_token_ctor_if([b4_yytranslate_define
0623bacc 321b4_public_types_define])[
793fbca5 322]b4_namespace_close[
2b548aa6 323
592d0b1e 324]b4_percent_define_flag_if([[global_tokens_and_yystype]],
6687da34 325[b4_token_defines
fb9712a9 326
4b3847c3 327#ifndef ]b4_api_PREFIX[STYPE
9d9b8b70 328 /* Redirection for backward compatibility. */
4b3847c3 329# define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type
fb9712a9 330#endif
22172d47
AD
331])[
332]b4_percent_code_get([[provides]])[
d27c5e65
AD
333]])
334
335# We do want M4 expansion after # for CPP macros.
336m4_changecom()
85f0b29e
AD
337b4_defines_if(
338[m4_divert_push(0)dnl
d27c5e65
AD
339@output(b4_spec_defines_file@)@
340b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
341[
342/**
343 ** \file ]b4_spec_defines_file[
344 ** Define the ]b4_namespace_ref[::parser class.
345 */
346
347/* C++ LALR(1) parser skeleton written by Akim Demaille. */
348
349]b4_cpp_guard_open([b4_spec_defines_file])[
350]b4_shared_declarations[
22172d47 351]b4_cpp_guard_close([b4_spec_defines_file])
1c7ec959 352b4_output_end()
85f0b29e
AD
353])
354
355
1c7ec959 356b4_output_begin([b4_parser_file_name])
a9ce3f54 357b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
a4e25e1d 358b4_percent_code_get([[top]])[]dnl
aa08666d 359m4_if(b4_prefix, [yy], [],
c5b95ccf
AD
360[
361// Take the name prefix into account.
9bc0dd67
JD
362#define yylex b4_prefix[]lex])[
363
28427f57 364// First part of user declarations.
c944f7f2 365]b4_user_pre_prologue[
9bc0dd67 366
28427f57
AD
367]b4_null_define[
368
85f0b29e
AD
369]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
370 [b4_shared_declarations])[
50997c6e 371
fb9712a9 372/* User implementation prologue. */
771dc643
AD
373]b4_user_post_prologue[
374]b4_percent_code_get[
375
771dc643 376#ifndef YY_
ae93128c 377# if defined YYENABLE_NLS && YYENABLE_NLS
30757c8c
PE
378# if ENABLE_NLS
379# include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
380# define YY_(msgid) dgettext ("bison-runtime", msgid)
381# endif
382# endif
383# ifndef YY_
384# define YY_(msgid) msgid
385# endif
989b5b8e
AD
386#endif
387
38435078 388]b4_locations_if([dnl
ccdc1577
AD
389[#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
390]b4_yylloc_default_define])[
38435078 391
2a4647a3 392/* Suppress unused-variable warnings by "using" E. */
12ce2df6 393#define YYUSE(e) ((void) (e))
2a4647a3 394
2b548aa6 395/* Enable debugging if requested. */
5f108727 396#if ]b4_api_PREFIX[DEBUG
284acc8b 397
fa7b79c0
PE
398/* A pseudo ostream that takes yydebug_ into account. */
399# define YYCDEBUG if (yydebug_) (*yycdebug_)
400
1f7d007b 401# define YY_SYMBOL_PRINT(Title, Symbol) \
57295d14
AD
402 do { \
403 if (yydebug_) \
404 { \
405 *yycdebug_ << Title << ' '; \
1f7d007b 406 yy_print_ (*yycdebug_, Symbol); \
57295d14
AD
407 *yycdebug_ << std::endl; \
408 } \
8901f32e 409 } while (false)
284acc8b 410
e9690142
JD
411# define YY_REDUCE_PRINT(Rule) \
412 do { \
8901f32e 413 if (yydebug_) \
e9690142 414 yy_reduce_print_ (Rule); \
8901f32e 415 } while (false)
284acc8b 416
e9690142
JD
417# define YY_STACK_PRINT() \
418 do { \
8901f32e
AD
419 if (yydebug_) \
420 yystack_print_ (); \
421 } while (false)
284acc8b 422
5f108727 423#else /* !]b4_api_PREFIX[DEBUG */
284acc8b 424
a36b333c 425# define YYCDEBUG if (false) std::cerr
beadb220 426# define YY_SYMBOL_PRINT(Title, Symbol) YYUSE(Symbol)
1f7d007b
AD
427# define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
428# define YY_STACK_PRINT() static_cast<void>(0)
284acc8b 429
5f108727 430#endif /* !]b4_api_PREFIX[DEBUG */
2b548aa6 431
39be9022
AD
432#define yyerrok (yyerrstatus_ = 0)
433#define yyclearin (yyempty = true)
98e26a92 434
39be9022
AD
435#define YYACCEPT goto yyacceptlab
436#define YYABORT goto yyabortlab
437#define YYERROR goto yyerrorlab
98e26a92 438#define YYRECOVERING() (!!yyerrstatus_)
60a777aa 439
422c18f4 440]b4_namespace_open[]b4_error_verbose_if([[
9e0876fb 441
aa08666d
AD
442 /* Return YYSTR after stripping away unnecessary quotes and
443 backslashes, so that it's suitable for yyerror. The heuristic is
444 that double-quoting is unnecessary unless the string contains an
445 apostrophe, a comma, or backslash (other than backslash-backslash).
446 YYSTR is taken from yytname. */
447 std::string
448 ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
449 {
450 if (*yystr == '"')
451 {
452 std::string yyr = "";
453 char const *yyp = yystr;
193d7c70 454
aa08666d
AD
455 for (;;)
456 switch (*++yyp)
457 {
458 case '\'':
459 case ',':
460 goto do_not_strip_quotes;
193d7c70 461
aa08666d
AD
462 case '\\':
463 if (*++yyp != '\\')
464 goto do_not_strip_quotes;
465 /* Fall through. */
466 default:
467 yyr += *yyp;
468 break;
193d7c70 469
aa08666d
AD
470 case '"':
471 return yyr;
472 }
473 do_not_strip_quotes: ;
474 }
193d7c70 475
aa08666d
AD
476 return yystr;
477 }
422c18f4 478]])[
9e0876fb 479
98ae9643 480 /// Build a parser object.
fa7b79c0
PE
481 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
482 :])[
5f108727 483#if ]b4_api_PREFIX[DEBUG
fa7b79c0
PE
484 ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false),
485 yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
486#endif]b4_parse_param_cons[
98ae9643
AD
487 {
488 }
a0e68930 489
98ae9643
AD
490 ]b4_parser_class_name::~b4_parser_class_name[ ()
491 {
492 }
a0e68930 493
a0e68930 494
1f7d007b
AD
495 /*---------------.
496 | Symbol types. |
497 `---------------*/
498
e36ec1f4 499]b4_token_ctor_if([], [b4_public_types_define])[
2873fdf8 500
1f7d007b
AD
501 // stack_symbol_type.
502 ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
5de9c593
AD
503 : super_type ()
504 , state ()
1f7d007b
AD
505 {
506 }
507
710c4a65 508 ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (]b4_join(
2ea7730c
AD
509 [state_type s],
510 [const semantic_type& v],
511 b4_locations_if([const location_type& l]))[)
512 : super_type (v]b4_locations_if([, l])[)
5de9c593 513 , state (s)
1f7d007b
AD
514 {
515 }
516
517 int
5de9c593 518 ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
1f7d007b
AD
519 {
520 return yystos_[state];
521 }
522
523
5de9c593 524 template <typename Exact>
98ae9643 525 void
5de9c593
AD
526 ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
527 symbol_base_type<Exact>& yysym) const
98ae9643 528 {
8901f32e 529 if (yymsg)
1f7d007b 530 YY_SYMBOL_PRINT (yymsg, yysym);
98ae9643 531
8901f32e 532 // User destructor.
c5026327 533 int yytype = yysym.type_get ();
98ae9643
AD
534 switch (yytype)
535 {
e3c52a63 536]b4_symbol_foreach([b4_symbol_destructor])dnl
2bde9113
AD
537[ default:
538 break;
8901f32e
AD
539 }]b4_variant_if([
540
541 // Type destructor.
4c3cc7da 542 b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[
8901f32e
AD
543 }
544
ccdc1577 545#if ]b4_api_PREFIX[DEBUG
5de9c593 546 template <typename Exact>
1f7d007b 547 void
5de9c593
AD
548 ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
549 const symbol_base_type<Exact>& yysym) const
8901f32e 550 {
c5026327
AD
551 std::ostream& yyoutput = yyo;
552 YYUSE (yyoutput);
1f7d007b
AD
553 int yytype = yysym.type_get ();
554 yyo << (yytype < yyntokens_ ? "token" : "nterm")
2ea7730c
AD
555 << ' ' << yytname_[yytype] << " ("]b4_locations_if([
556 << yysym.location << ": "])[;
1f7d007b
AD
557 switch (yytype)
558 {
e3c52a63 559]b4_symbol_foreach([b4_symbol_printer])dnl
2bde9113 560[ default:
e9690142 561 break;
1f7d007b
AD
562 }
563 yyo << ')';
8901f32e 564 }
1f7d007b 565#endif
8901f32e 566
1f7d007b
AD
567 void
568 ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
569 symbol_type& sym)
8901f32e 570 {
1f7d007b
AD
571 if (m)
572 YY_SYMBOL_PRINT (m, sym);
573]b4_variant_if(
710c4a65 574[[ yystack_.push (stack_symbol_type (]b4_join(
2ea7730c
AD
575 [s],
576 [semantic_type()],
577 b4_locations_if([sym.location]))[));
1f7d007b
AD
578 ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
579 [build], [sym.value])],
710c4a65 580[[ yystack_.push (stack_symbol_type (]b4_join(
2ea7730c
AD
581 [s],
582 [sym.value],
583 b4_locations_if([sym.location]))[));]])[
98ae9643 584 }
60a777aa 585
7dedf26e 586 void
bc0b0477 587 ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
7dedf26e 588 {
9380cfd0 589 if (m)
1f7d007b 590 YY_SYMBOL_PRINT (m, s);
8901f32e 591]b4_variant_if(
710c4a65 592[[ yystack_.push (stack_symbol_type (]b4_join(
2ea7730c
AD
593 [s.state],
594 [semantic_type()],
595 b4_locations_if([s.location]))[));
1f7d007b 596 ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
e9b0834e
AD
597 [build], [s.value])],
598[ yystack_.push (s);])[
7dedf26e
AD
599 }
600
98ae9643
AD
601 void
602 ]b4_parser_class_name[::yypop_ (unsigned int n)
603 {
8901f32e 604 yystack_.pop (n);
98ae9643 605 }
52d5733f 606
5f108727 607#if ]b4_api_PREFIX[DEBUG
98ae9643
AD
608 std::ostream&
609 ]b4_parser_class_name[::debug_stream () const
610 {
611 return *yycdebug_;
612 }
9a1e9989 613
98ae9643
AD
614 void
615 ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
616 {
617 yycdebug_ = &o;
618 }
9a1e9989
AD
619
620
98ae9643
AD
621 ]b4_parser_class_name[::debug_level_type
622 ]b4_parser_class_name[::debug_level () const
623 {
624 return yydebug_;
625 }
a3cb6248 626
98ae9643
AD
627 void
628 ]b4_parser_class_name[::set_debug_level (debug_level_type l)
629 {
630 yydebug_ = l;
631 }
ccdc1577 632#endif // ]b4_api_PREFIX[DEBUG
a3cb6248 633
7580c379
AD
634 inline ]b4_parser_class_name[::state_type
635 ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs)
636 {
637 int yyr = yypgoto_[yylhs - yyntokens_] + yystate;
638 if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
639 return yytable_[yyr];
640 else
641 return yydefgoto_[yylhs - yyntokens_];
642 }
643
f2b30bdf
JD
644 inline bool
645 ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue)
646 {
647 return yyvalue == yypact_ninf_;
648 }
649
650 inline bool
651 ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue)
652 {
aa0cb40d 653 return yyvalue == yytable_ninf_;
f2b30bdf
JD
654 }
655
98ae9643
AD
656 int
657 ]b4_parser_class_name[::parse ()
658 {
39be9022
AD
659 /// Whether yyla contains a lookahead.
660 bool yyempty = true;
d4fb5e3c 661
b720fedf 662 // State.
98ae9643 663 int yyn;
a85284cf 664 int yylen = 0;
d4fb5e3c 665
b720fedf 666 // Error handling.
98ae9643
AD
667 int yynerrs_ = 0;
668 int yyerrstatus_ = 0;
dbcdae2d 669
6082531a 670 /// The lookahead symbol.
2ea7730c 671 symbol_type yyla;]b4_locations_if([[
6082531a 672
98ae9643 673 /// The locations where the error started and ended.
44c2b42d 674 stack_symbol_type yyerror_range[3];]])[
dbcdae2d 675
e1f93869 676 /// $$ and @@$.
bc0b0477 677 stack_symbol_type yylhs;
dbcdae2d 678
ff348970 679 /// The return value of parse ().
98ae9643 680 int yyresult;
ad745863 681
7e1fabbe
AD
682 // FIXME: This shoud be completely indented. It is not yet to
683 // avoid gratuitous conflicts when merging into the master branch.
684 try
685 {
98ae9643 686 YYCDEBUG << "Starting parse" << std::endl;
451364ed 687
451364ed 688]m4_ifdef([b4_initial_action], [
4323e0da 689b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl
9d9b8b70 690 /* User initialization code. */
8ec0a172 691 b4_user_initial_action
cd735a8c 692b4_dollar_popdef])[]dnl
451364ed 693
8901f32e 694 [ /* Initialize the stack. The initial state will be set in
98ae9643
AD
695 yynewstate, since the latter expects the semantical and the
696 location values to have been already stored, initialize these
697 stacks with a primary value. */
8901f32e 698 yystack_ = stack_type (0);
eeaf1dc6 699 yypush_ (YY_NULL, 0, yyla);
98ae9643 700
7580c379 701 // A new symbol was pushed on the stack.
98ae9643 702 yynewstate:
7580c379 703 YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
868d2d96
JD
704
705 /* Accept? */
7580c379 706 if (yystack_[0].state == yyfinal_)
868d2d96
JD
707 goto yyacceptlab;
708
98ae9643
AD
709 goto yybackup;
710
711 /* Backup. */
712 yybackup:
713
742e4900 714 /* Try to take a decision without lookahead. */
7580c379 715 yyn = yypact_[yystack_[0].state];
f2b30bdf 716 if (yy_pact_value_is_default_ (yyn))
98ae9643
AD
717 goto yydefault;
718
742e4900 719 /* Read a lookahead token. */
39be9022 720 if (yyempty)
98ae9643 721 {
09277875 722 YYCDEBUG << "Reading a token: ";
a6552c5d 723 try
77a1a208 724 {
e36ec1f4 725]b4_token_ctor_if(
77a1a208 726[ yyla = b4_function_call([yylex], [symbol_type],
a6552c5d 727 m4_ifdef([b4_lex_param], b4_lex_param));],
77a1a208 728[ yyla.type = yytranslate_ (b4_function_call([yylex], [int],
5458913a 729 [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl
6082531a 730b4_locations_if([, [[location*], [&yyla.location]]])dnl
09277875 731m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
77a1a208 732 }
a6552c5d 733 catch (const syntax_error& yyexc)
77a1a208
AD
734 {
735 error (yyexc);
736 goto yyerrlab1;
737 }
39be9022 738 yyempty = false;
98ae9643 739 }
aba12ad1 740 YY_SYMBOL_PRINT ("Next token is", yyla);
98ae9643 741
1f7d007b
AD
742 /* If the proper action on seeing token YYLA.TYPE is to reduce or
743 to detect an error, take that action. */
744 yyn += yyla.type;
745 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
98ae9643
AD
746 goto yydefault;
747
748 /* Reduce or error. */
749 yyn = yytable_[yyn];
750 if (yyn <= 0)
751 {
e9690142
JD
752 if (yy_table_value_is_error_ (yyn))
753 goto yyerrlab;
754 yyn = -yyn;
755 goto yyreduce;
98ae9643
AD
756 }
757
868d2d96 758 /* Discard the token being shifted. */
39be9022 759 yyempty = true;
98ae9643
AD
760
761 /* Count tokens shifted since error; after three, turn off error
762 status. */
763 if (yyerrstatus_)
764 --yyerrstatus_;
765
9380cfd0 766 /* Shift the lookahead token. */
7580c379 767 yypush_ ("Shifting", yyn, yyla);
98ae9643
AD
768 goto yynewstate;
769
770 /*-----------------------------------------------------------.
771 | yydefault -- do the default action for the current state. |
772 `-----------------------------------------------------------*/
773 yydefault:
7580c379 774 yyn = yydefact_[yystack_[0].state];
98ae9643
AD
775 if (yyn == 0)
776 goto yyerrlab;
777 goto yyreduce;
778
779 /*-----------------------------.
780 | yyreduce -- Do a reduction. |
781 `-----------------------------*/
782 yyreduce:
c4dc4c46 783 yylen = yyr2_[yyn];
7580c379 784 yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([
5ab8c47b 785 /* Variants are always initialized to an empty instance of the
3eead995
AD
786 correct type. The default $$=$1 action is NOT applied when using
787 variants. */
c4dc4c46 788 b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[
a85284cf 789 /* If YYLEN is nonzero, implement the default value of the action:
98ae9643
AD
790 `$$ = $1'. Otherwise, use the top of the stack.
791
e1f93869 792 Otherwise, the following line sets YYLHS.VALUE to garbage.
98ae9643
AD
793 This behavior is undocumented and Bison
794 users should not rely upon it. */
795 if (yylen)
e1f93869 796 yylhs.value = yystack_@{yylen - 1@}.value;
98ae9643 797 else
e1f93869 798 yylhs.value = yystack_@{0@}.value;])[
2ea7730c
AD
799]b4_locations_if([dnl
800[
8901f32e 801 // Compute the default @@$.
2b548aa6 802 {
bc0b0477 803 slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
e1f93869 804 YYLLOC_DEFAULT (yylhs.location, slice, yylen);
2ea7730c 805 }]])[
8901f32e
AD
806
807 // Perform the reduction.
98ae9643 808 YY_REDUCE_PRINT (yyn);
ff601366 809 try
98ae9643 810 {
77a1a208
AD
811 switch (yyn)
812 {
30bb2edc 813]b4_user_actions[
77a1a208
AD
814 default:
815 break;
816 }
98ae9643 817 }
ff601366 818 catch (const syntax_error& yyexc)
77a1a208
AD
819 {
820 error (yyexc);
821 YYERROR;
822 }
1f7d007b 823 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
8901f32e 824]b4_variant_if([[
9c6a8966 825 // Destroy the rhs symbols.
8901f32e 826 for (int i = 0; i < yylen; ++i)
9c6a8966
AD
827 // Destroy a variant which 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
5237cd1a 830 // rhs symbols) depends on the default construction for this
9c6a8966
AD
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
836 // Bison skeletons.
eeaf1dc6 837 yy_destroy_ (YY_NULL, yystack_[i]);]])[
98ae9643
AD
838
839 yypop_ (yylen);
a85284cf 840 yylen = 0;
98ae9643 841 YY_STACK_PRINT ();
98ae9643
AD
842
843 /* Shift the result of the reduction. */
eeaf1dc6 844 yypush_ (YY_NULL, yylhs);
98ae9643
AD
845 goto yynewstate;
846
9c6a8966
AD
847 /*--------------------------------------.
848 | yyerrlab -- here on detecting error. |
849 `--------------------------------------*/
98ae9643
AD
850 yyerrlab:
851 /* If not already recovering from an error, report this error. */
852 if (!yyerrstatus_)
853 {
e9690142 854 ++yynerrs_;
710c4a65 855 error (]b4_join(b4_locations_if([yyla.location]),
d2060f06
JD
856 [[yysyntax_error_ (yystack_[0].state,
857 yyempty ? yyempty_ : yyla.type)]])[);
98ae9643
AD
858 }
859
2ea7730c 860]b4_locations_if([[
44c2b42d 861 yyerror_range[1].location = yyla.location;]])[
98ae9643
AD
862 if (yyerrstatus_ == 3)
863 {
e9690142 864 /* If just tried and failed to reuse lookahead token after an
27cb5b59
AD
865 error, discard it. */
866
867 /* Return failure if at end of input. */
aba12ad1 868 if (yyla.type == yyeof_)
27cb5b59 869 YYABORT;
d59beda0 870 else if (!yyempty)
39be9022 871 {
27cb5b59 872 yy_destroy_ ("Error: discarding", yyla);
39be9022 873 yyempty = true;
e9690142 874 }
98ae9643
AD
875 }
876
742e4900 877 /* Else will try to reuse lookahead token after shifting the error
98ae9643
AD
878 token. */
879 goto yyerrlab1;
880
881
882 /*---------------------------------------------------.
883 | yyerrorlab -- error raised explicitly by YYERROR. |
884 `---------------------------------------------------*/
885 yyerrorlab:
886
887 /* Pacify compilers like GCC when the user code never invokes
888 YYERROR and the label yyerrorlab therefore never appears in user
889 code. */
890 if (false)
c4dc4c46 891 goto yyerrorlab;]b4_locations_if([[
44c2b42d 892 yyerror_range[1].location = yystack_[yylen - 1].location;]])b4_variant_if([[
c4dc4c46
AD
893 /* $$ was initialized before running the user action. */
894 yy_destroy_ ("Error: discarding", yylhs);]])[
a85284cf 895 /* Do not reclaim the symbols of the rule which action triggered
9d9b8b70 896 this YYERROR. */
98ae9643 897 yypop_ (yylen);
a85284cf 898 yylen = 0;
98ae9643
AD
899 goto yyerrlab1;
900
901 /*-------------------------------------------------------------.
902 | yyerrlab1 -- common code for both syntax error and YYERROR. |
903 `-------------------------------------------------------------*/
904 yyerrlab1:
e9690142 905 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
e1f93869 906 {
bc0b0477 907 stack_symbol_type error_token;
e1f93869
AD
908 for (;;)
909 {
7580c379 910 yyn = yypact_[yystack_[0].state];
f2b30bdf 911 if (!yy_pact_value_is_default_ (yyn))
e1f93869
AD
912 {
913 yyn += yyterror_;
914 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
915 {
916 yyn = yytable_[yyn];
917 if (0 < yyn)
918 break;
919 }
920 }
98ae9643 921
e1f93869
AD
922 // Pop the current state because it cannot handle the error token.
923 if (yystack_.size () == 1)
924 YYABORT;
2ea7730c 925]b4_locations_if([[
44c2b42d 926 yyerror_range[1].location = yystack_[0].location;]])[
1f7d007b 927 yy_destroy_ ("Error: popping", yystack_[0]);
e1f93869 928 yypop_ ();
e1f93869
AD
929 YY_STACK_PRINT ();
930 }
2ea7730c 931]b4_locations_if([[
44c2b42d
JD
932 yyerror_range[2].location = yyla.location;
933 YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[
e1f93869
AD
934
935 /* Shift the error token. */
7580c379 936 error_token.state = yyn;
e9b0834e 937 yypush_ ("Shifting", error_token);
e1f93869 938 }
98ae9643
AD
939 goto yynewstate;
940
941 /* Accept. */
942 yyacceptlab:
943 yyresult = 0;
944 goto yyreturn;
945
946 /* Abort. */
947 yyabortlab:
948 yyresult = 1;
949 goto yyreturn;
950
951 yyreturn:
39be9022 952 if (!yyempty)
1f7d007b 953 yy_destroy_ ("Cleanup: discarding lookahead", yyla);
98ae9643 954
a85284cf 955 /* Do not reclaim the symbols of the rule which action triggered
9d9b8b70 956 this YYABORT or YYACCEPT. */
a85284cf 957 yypop_ (yylen);
23d13411 958 while (1 < yystack_.size ())
98ae9643 959 {
e9690142
JD
960 yy_destroy_ ("Cleanup: popping", yystack_[0]);
961 yypop_ ();
98ae9643
AD
962 }
963
964 return yyresult;
965 }
7e1fabbe
AD
966 catch (...)
967 {
25a6ad2f
AD
968 YYCDEBUG << "Exception caught: cleaning lookahead and stack"
969 << std::endl;
970 // Do not try to display the values of the reclaimed symbols,
971 // as their printer might throw an exception.
23d13411
AD
972 if (!yyempty)
973 yy_destroy_ (YY_NULL, yyla);
7e1fabbe 974
23d13411 975 while (1 < yystack_.size ())
7e1fabbe 976 {
23d13411 977 yy_destroy_ (YY_NULL, yystack_[0]);
7e1fabbe
AD
978 yypop_ ();
979 }
980 throw;
981 }
98ae9643 982 }
2b548aa6 983
a6552c5d
AD
984 void
985 ]b4_parser_class_name[::error (const syntax_error& yyexc)
986 {
710c4a65 987 error (]b4_join(b4_locations_if([yyexc.location]),
a6552c5d
AD
988 [[yyexc.what()]])[);
989 }
990
98ae9643
AD
991 // Generate an error message.
992 std::string
422c18f4 993 ]b4_parser_class_name[::yysyntax_error_ (]dnl
ceb8b8e6 994b4_error_verbose_if([state_type yystate, int yytoken],
422c18f4 995 [int, int])[)
25a648d8
JD
996 {]b4_error_verbose_if([[
997 std::string yyres;
d2060f06
JD
998 // Number of reported tokens (one for the "unexpected", one per
999 // "expected").
1000 size_t yycount = 0;
1001 // Its maximum.
1002 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1003 // Arguments of yyformat.
1004 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1005
1006 /* There are many possibilities here to consider:
1007 - If this state is a consistent state with a default action, then
1008 the only way this function was invoked is if the default action
1009 is an error action. In that case, don't check for expected
1010 tokens because there are none.
1011 - The only way there can be no lookahead present (in yytoken) is
1012 if this state is a consistent state with a default action.
1013 Thus, detecting the absence of a lookahead is sufficient to
1014 determine that there is no unexpected or expected token to
1015 report. In that case, just report a simple "syntax error".
1016 - Don't assume there isn't a lookahead just because this state is
1017 a consistent state with a default action. There might have
1018 been a previous inconsistent state, consistent state with a
1019 non-default action, or user semantic action that manipulated
1020 yyla. (However, yyla is currently not documented for users.)
1021 - Of course, the expected token list depends on states to have
1022 correct lookahead information, and it depends on the parser not
1023 to perform extra reductions after fetching a lookahead from the
1024 scanner and before detecting a syntax error. Thus, state
1025 merging (from LALR or IELR) and default reductions corrupt the
1026 expected token list. However, the list is correct for
1027 canonical LR with one exception: it will still contain any
1028 token that will not be accepted due to an error action in a
1029 later state.
1030 */
1031 if (yytoken != yyempty_)
98ae9643 1032 {
d2060f06
JD
1033 yyarg[yycount++] = yytname_[yytoken];
1034 int yyn = yypact_[yystate];
1035 if (!yy_pact_value_is_default_ (yyn))
1036 {
b4bbc4a0
JD
1037 /* Start YYX at -YYN if negative to avoid negative indexes in
1038 YYCHECK. In other words, skip the first -YYN actions for
1039 this state because they are default actions. */
1040 int yyxbegin = yyn < 0 ? -yyn : 0;
b4bbc4a0
JD
1041 /* Stay within bounds of both yycheck and yytname. */
1042 int yychecklim = yylast_ - yyn + 1;
1043 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
b4bbc4a0
JD
1044 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1045 if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
1046 && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
1047 {
1048 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1049 {
1050 yycount = 1;
1051 break;
1052 }
1053 else
1054 yyarg[yycount++] = yytname_[yyx];
1055 }
d2060f06
JD
1056 }
1057 }
a0ffc175 1058
ef51bfa7 1059 char const* yyformat = YY_NULL;
b4bbc4a0
JD
1060 switch (yycount)
1061 {
1062#define YYCASE_(N, S) \
1063 case N: \
1064 yyformat = S; \
1065 break
d2060f06 1066 YYCASE_(0, YY_("syntax error"));
b4bbc4a0
JD
1067 YYCASE_(1, YY_("syntax error, unexpected %s"));
1068 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1069 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1070 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1071 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
a0ffc175 1072#undef YYCASE_
98ae9643 1073 }
d2060f06 1074
b4bbc4a0
JD
1075 // Argument number.
1076 size_t yyi = 0;
1077 for (char const* yyp = yyformat; *yyp; ++yyp)
1078 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1079 {
1080 yyres += yytnamerr_ (yyarg[yyi++]);
1081 ++yyp;
1082 }
1083 else
1084 yyres += *yyp;
25a648d8
JD
1085 return yyres;]], [[
1086 return YY_("syntax error");]])[
98ae9643 1087 }
a08460b0 1088
5348bfbe 1089
98ae9643 1090 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
2b548aa6 1091
0fddb3d5
AD
1092 const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1093
ba206cf4 1094]b4_parser_tables_define[
2b548aa6 1095
5f108727 1096]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
98ae9643 1097 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
9d9b8b70 1098 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
98ae9643
AD
1099 const char*
1100 const ]b4_parser_class_name[::yytname_[] =
1101 {
8901f32e 1102 ]b4_tname[
98ae9643 1103 };
2b548aa6 1104
5f108727 1105]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
ba206cf4 1106]b4_integral_parser_table_define([rline], [b4_rline])[
5348bfbe 1107
98ae9643
AD
1108 // Print the state stack on the debug stream.
1109 void
1110 ]b4_parser_class_name[::yystack_print_ ()
1111 {
1112 *yycdebug_ << "Stack now";
8901f32e
AD
1113 for (stack_type::const_iterator
1114 i = yystack_.begin (),
1115 i_end = yystack_.end ();
e9690142 1116 i != i_end; ++i)
8901f32e 1117 *yycdebug_ << ' ' << i->state;
98ae9643
AD
1118 *yycdebug_ << std::endl;
1119 }
25f66e1a 1120
98ae9643
AD
1121 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1122 void
d1ff7a7c 1123 ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
98ae9643
AD
1124 {
1125 unsigned int yylno = yyrline_[yyrule];
d1ff7a7c 1126 int yynrhs = yyr2_[yyrule];
98ae9643
AD
1127 /* Print the symbols being reduced, and their result. */
1128 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
e9690142 1129 << " (line " << yylno << "):" << std::endl;
d1ff7a7c
AD
1130 /* The symbols being reduced. */
1131 for (int yyi = 0; yyi < yynrhs; yyi++)
1132 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1f7d007b 1133 ]b4_rhs_data(yynrhs, yyi + 1)[);
98ae9643 1134 }
5f108727 1135#endif // ]b4_api_PREFIX[DEBUG
69e2658b 1136
e36ec1f4 1137]b4_token_ctor_if([], [b4_yytranslate_define])[
793fbca5 1138]b4_namespace_close[
8901f32e 1139]b4_epilogue[]dnl
1c7ec959 1140b4_output_end()
064e42b0
AD
1141
1142
a9ce3f54 1143m4_popdef([b4_copyright_years])dnl