1 # C++ skeleton for Bison
3 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 # Free Software Foundation, Inc.
6 # This program is free software: you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation, either version 3 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
19 m4_include(b4_pkgdatadir
/[c
++.m4
])
25 # Join with comma, skipping empty arguments.
26 # b4_args calls itself recursively until it sees the first non-empty
27 # argument, then calls _b4_args which prepends each non-empty argument
33 [$
1[]_$
0(m4_shift($@
))],
34 [$
0(m4_shift($@
))])])])
36 # _b4_args(ARGS1, ...)
37 # --------------------
41 [m4_ifval([$
1], [, $
1])[]$
0(m4_shift($@
))])])
44 # b4_table_define(TABLE-NAME, CONTENT)
45 # ------------------------------------
46 # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
47 m4_define([b4_table_define
],
48 [const b4_int_type_for([$
2])
49 b4_parser_class_name::yy$
1_
[[]] =
55 # b4_symbol_value_template(VAL, [TYPE])
56 # -------------------------------------
57 # Same as b4_symbol_value, but used in a template method.
58 m4_copy([b4_symbol_value
], [b4_symbol_value_template
])
60 # How the semantic value is extracted when using variants.
62 # b4_symbol_value(VAL, [TYPE])
63 # ----------------------------
64 m4_define([b4_symbol_value
],
69 # b4_symbol_value_template(VAL, [TYPE])
70 # -------------------------------------
71 # Same as b4_symbol_value, but used in a template method.
72 m4_define([b4_symbol_value_template
],
74 [$
1.template as
<$
2>()],
79 # b4_lex_symbol_if([IF-YYLEX-RETURNS-A-COMPLETE-SYMBOL], [IF-NOT])
80 # ----------------------------------------------------------------
81 m4_define([b4_lex_symbol_if
],
82 [b4_percent_define_ifdef([[lex_symbol]], [$
1], [$
2])])
85 # b4_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])
86 # ------------------------------------------------
87 m4_define([b4_assert_if
],
88 [b4_percent_define_ifdef([[assert]], [$
1], [$
2])])
91 # b4_lhs_value([TYPE])
92 # --------------------
93 # Expansion of $<TYPE>$.
94 m4_define([b4_lhs_value
],
95 [b4_symbol_value([yylhs
.value
], [$
1])])
101 m4_define([b4_lhs_location
],
105 # b4_rhs_data(RULE-LENGTH, NUM)
106 # -----------------------------
107 # Return the data corresponding to the symbol #NUM, where the current
108 # rule has RULE-LENGTH symbols on RHS.
109 m4_define([b4_rhs_data
],
110 [yystack_@
{($
1) - ($
2)@
}])
113 # b4_rhs_state(RULE-LENGTH, NUM)
114 # -----------------------------
115 # The state corresponding to the symbol #NUM, where the current
116 # rule has RULE-LENGTH symbols on RHS.
117 m4_define([b4_rhs_state
],
118 [b4_rhs_data([$
1], [$
2]).state
])
121 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
122 # --------------------------------------
123 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
125 m4_define([b4_rhs_value
],
126 [b4_symbol_value([b4_rhs_data([$
1], [$
2]).value
], [$
3])])
129 # b4_rhs_location(RULE-LENGTH, NUM)
130 # ---------------------------------
131 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
133 m4_define([b4_rhs_location
],
134 [b4_rhs_data([$
1], [$
2]).location
])
137 # b4_symbol(NUM, FIELD)
138 # ---------------------
139 # Recover a FIELD about symbol #NUM. Thanks to m4_indir, fails if
141 m4_define([b4_symbol
],
142 [m4_indir([b4_symbol($
1, $
2)])])
145 # b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE)
146 # -------------------------------------------
147 # If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE.
148 # Otherwise an error.
149 m4_define([b4_symbol_if
],
150 [m4_case(b4_symbol([$
1], [$
2]),
153 [m4_fatal([$
0: field $
2 of $
1 is
not a Boolean
:] b4_symbol([$
1], [$
2]))])])
156 # b4_symbol_actions(FILENAME, LINENO,
157 # SYMBOL-TAG, SYMBOL-NUM,
158 # SYMBOL-ACTION, SYMBOL-TYPENAME)
159 # -------------------------------------------------
160 # Same as in C, but using references instead of pointers.
161 m4_define([b4_symbol_actions
],
162 [m4_pushdef([b4_dollar_dollar
],
163 [b4_symbol_value_template([yysym
.value
], [$
6])])dnl
164 m4_pushdef([b4_at_dollar
], [yysym
.location
])dnl
166 b4_syncline([$
2], [$
1])
168 b4_syncline([@oline@
], [@ofile@
])
170 m4_popdef([b4_at_dollar
])dnl
171 m4_popdef([b4_dollar_dollar
])dnl
175 # b4_symbol_case_(SYMBOL-NUM)
176 # ---------------------------
177 # Issue a "case NUM" for SYMBOL-NUM.
178 m4_define([b4_symbol_case_
],
179 [ case b4_symbol([$
1], [number
]): // b4_symbol([$1], [tag])
183 # b4_type_action_(NUMS)
184 # ---------------------
185 # Run actions for the symbol NUMS that all have the same type-name.
186 # Skip NUMS that have no type-name.
187 m4_define([b4_type_action_
],
188 [b4_symbol_if([$
1], [has_type
],
189 [m4_map([b4_symbol_case_
], [$@
])[]dnl
190 b4_dollar_dollar([b4_symbol([$
1], [number
])],
191 [b4_symbol([$
1], [tag
])],
192 [b4_symbol([$
1], [type
])]);
198 # b4_symbol_constructor_declaration_(SYMBOL-NUMBERS)
199 # ----------------------------------------------------
200 # Declare the overloaded version of make_symbol for the (common) type of
201 # these SYMBOL-NUMBERS. Use at class-level.
202 m4_define([b4_symbol_constructor_declaration_
],
203 [ template <token_type
>
204 static inline symbol_type
205 make_symbol (b4_args(b4_symbol_if([$
1], [has_type
],
206 [const b4_symbol([$
1], [type
])& v
]),
207 b4_locations_if([const location_type
& l
])));
211 # b4_symbol_constructor_declarations
212 # ----------------------------------
213 # Declare the overloaded versions of make_symbol for all the value types.
214 # Use at class-level.
215 m4_define([b4_symbol_constructor_declarations
],
217 // Declaration of make_symbol for each value type.
218 m4_map([b4_symbol_constructor_declaration_
], m4_defn([b4_type_names
]))])])
222 # b4_symbol_constructor_specialization_(SYMBOL-NUMBER)
223 # ----------------------------------------------------
224 # Declare the specialization of make_symbol for this each SYMBOL-NUMBER.
225 # Specializations cannot be declared at class-level, this must be done
226 # at namespace-level.
227 m4_define([b4_symbol_constructor_specialization_
],
228 [b4_symbol_if([$
1], [is_token
], [b4_symbol_if([$
1], [has_id
],
231 b4_parser_class_name::symbol_type
232 b4_parser_class_name::make_symbol
<b4_parser_class_name::token::b4_symbol([$
1], [id
])> (dnl
233 b4_args(b4_symbol_if([$
1], [has_type
],
234 [const b4_symbol([$
1], [type
])& v
]),
235 b4_locations_if([const location_type
& l
])));
239 # b4_symbol_constructor_specializations
240 # -------------------------------------
241 # Declare specializations of make_symbol.
242 m4_define([b4_symbol_constructor_specializations
],
244 // Specializations of make_symbol for each symbol type.
245 m4_map([b4_symbol_constructor_specialization_
],
246 m4_defn([b4_symbol_numbers
]))])dnl
251 # b4_symbol_constructor_definition_(SYMBOL-NUMBER)
252 # ------------------------------------------------
253 # Define make_symbol for this SYMBOL-NUMBER.
254 m4_define([b4_symbol_constructor_definition_
],
255 [b4_symbol_if([$
1], [is_token
], [b4_symbol_if([$
1], [has_id
],
257 b4_parser_class_name::symbol_type
258 b4_parser_class_name::make_symbol
<b4_parser_class_name::token::b4_symbol([$
1], [id
])> (dnl
259 b4_args(b4_symbol_if([$
1], [has_type
],
260 [const b4_symbol([$
1], [type
])& v
]),
261 b4_locations_if([const location_type
& l
])))
263 return symbol_type (b4_args([yytranslate_ (token::b4_symbol([$
1], [id
]))],
264 b4_symbol_if([$
1], [has_type
], [v
]),
265 b4_locations_if([l
])));
271 # b4_symbol_constructor_definitions
272 # ----------------------------------
273 # Define the overloaded versions of make_symbol for all the value types.
274 m4_define([b4_symbol_constructor_definitions
],
275 [[ // symbol_base_type.
276 template <typename Exact
>
277 ]b4_parser_class_name
[::symbol_base_type
<Exact
>::symbol_base_type ()
278 : value()]b4_locations_if([
283 template <typename Exact
>
284 ]b4_parser_class_name
[::symbol_base_type
<Exact
>::symbol_base_type (const location_type
& l
)
290 template <typename Exact
>
291 ]b4_parser_class_name
[::symbol_base_type
<Exact
>::symbol_base_type (]b4_args(
292 [const semantic_type
& v
],
293 b4_locations_if([const location_type
& l
]))[)
294 : value(v
)]b4_locations_if([
299 template <typename Exact
>
301 ]b4_parser_class_name
[::symbol_base_type
<Exact
>::self () const
303 return static_cast<const Exact
&>(*this);
306 template <typename Exact
>
308 ]b4_parser_class_name
[::symbol_base_type
<Exact
>::self ()
310 return static_cast<Exact
&>(*this);
313 template <typename Exact
>
315 ]b4_parser_class_name
[::symbol_base_type
<Exact
>::type_get () const
317 return self ().type_get_ ();
321 ]b4_parser_class_name
[::symbol_type::symbol_type ()
327 ]b4_parser_class_name
[::symbol_type::symbol_type (]b4_args(
329 b4_locations_if([const location_type
& l
]))[)
330 : super_type (]b4_locations_if([l
])[)
335 ]b4_parser_class_name
[::symbol_type::symbol_type (]b4_args(
337 [const semantic_type
& v
],
338 b4_locations_if([const location_type
& l
]))[)
339 : super_type (v
]b4_locations_if([, l
])[)
345 ]b4_parser_class_name
[::symbol_type::type_get_ () const
350 ]b4_parser_class_name
[::token_type
351 ]b4_parser_class_name
[::symbol_type::token () const
353 // YYTOKNUM[NUM] -- (External) token number corresponding to the
354 // (internal) symbol number NUM (which must be that of a token). */
356 const ]b4_int_type_for([b4_toknum
])[
361 return static_cast<token_type
> (yytoken_number_
[type
]);
366 [ // Implementation of make_symbol for each symbol type.
367 m4_map([b4_symbol_constructor_definition_
], m4_defn([b4_symbol_numbers
]))])])
370 # b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
371 # ------------------------------------------------
372 # Run some ACTION ("build", or "destroy") on YYVAL of symbol type
374 m4_define([b4_symbol_variant
],
375 [m4_pushdef([b4_dollar_dollar
],
376 [$
2.$
3<$
][3>(m4_shift3($@
))])dnl
379 m4_map([b4_type_action_
], m4_defn([b4_type_names
]))[]dnl
383 m4_popdef([b4_dollar_dollar
])dnl
387 # _b4_char_sizeof_counter
388 # -----------------------
389 # A counter used by _b4_char_sizeof_dummy to create fresh symbols.
390 m4_define([_b4_char_sizeof_counter
],
393 # _b4_char_sizeof_dummy
394 # ---------------------
395 # At each call return a new C++ identifier.
396 m4_define([_b4_char_sizeof_dummy
],
397 [m4_define([_b4_char_sizeof_counter
], m4_incr(_b4_char_sizeof_counter
))dnl
398 dummy
[]_b4_char_sizeof_counter
])
401 # b4_char_sizeof_(SYMBOL-NUM)
402 # ---------------------------
403 # A comment describing this symbol.
404 m4_define([b4_char_sizeof_
],
405 [ // b4_symbol([$1], [tag])
408 # b4_char_sizeof(SYMBOL-NUMS)
409 # --------------------------
410 # To be mapped on the list of type names to produce:
412 # char dummy1[sizeof(type_name_1)];
413 # char dummy2[sizeof(type_name_2)];
415 # for defined type names.
416 m4_define([b4_char_sizeof
],
417 [b4_symbol_if([$
1], [has_type
],
419 m4_map([b4_char_sizeof_
], [$@
])dnl
420 char _b4_char_sizeof_dummy@
{sizeof([b4_symbol([$
1], [type
])])@
};
424 # b4_yytranslate_definition
425 # -------------------------
426 # Define yytranslate_. Sometimes we want it in the header file,
427 # sometimes the cc file suffices.
428 m4_define([b4_yytranslate_definition
],
429 [[ // Symbol number corresponding to token number t.
430 ]b4_parser_class_name
[::token_number_type
431 ]b4_parser_class_name
[::yytranslate_ (]b4_lex_symbol_if([token_type
],
435 const token_number_type
440 const unsigned int user_token_number_max_
= ]b4_user_token_number_max
[;
441 const token_number_type undef_token_
= ]b4_undef_token_number
[;
443 if (static_cast<int>(t
) <= yyeof_
)
445 else if (static_cast<unsigned int> (t
) <= user_token_number_max_
)
446 return translate_table
[t
];
453 m4_pushdef([b4_copyright_years
],
454 [2002, 2003, 2004, 2005, 2006, 2007, 2008])
456 m4_define([b4_parser_class_name
],
457 [b4_percent_define_get([[parser_class_name]])])
459 # The header is mandatory.
461 [b4_fatal([b4_skeleton
[: using %%defines is mandatory
]])])
464 [# Backward compatibility.
465 m4_define([b4_location_constructors
])
466 m4_include(b4_pkgdatadir
/[location
.cc
])])
468 # We do want M4 expansion after # for CPP macros.
471 @
output(b4_spec_defines_file@
)@
472 b4_copyright([Skeleton interface
for Bison
LALR(1) parsers in C
++])
473 dnl FIXME
: This is wrong
, we want computed header guards
.
475 /* C++ LALR(1) parser skeleton written by Akim Demaille. */
477 #ifndef PARSER_HEADER_H
478 # define PARSER_HEADER_H
480 ]b4_percent_code_get([[requires]])[
482 ]b4_assert_if([#include <cassert>])[
488 ]b4_locations_if([ class position
;
492 /// A char[S] buffer to store and retrieve objects.
494 /// Sort of a variant, but does not keep track of the nature
495 /// of the stored data, since that knowledge is available
496 /// via the current state.
500 /// Whether something is contained.
503 /// Empty construction.
505 variant ()]b4_assert_if([
509 /// Instantiate a \a T in here.
510 template <typename T
>
516 return *new (buffer
) T
;
519 /// Instantiate a \a T in here from \a t.
520 template <typename T
>
526 return *new (buffer
) T(t
);
529 /// Construct and fill.
530 template <typename T
>
532 variant (const T
& t
)]b4_assert_if([
538 /// Accessor to a built \a T.
539 template <typename T
>
544 return reinterpret_cast<T
&>(buffer
);
547 /// Const accessor to a built \a T (for %printer).
548 template <typename T
>
553 return reinterpret_cast<const T
&>(buffer
);
556 /// Swap the content with \a other.
557 template <typename T
>
559 swap(variant
<S
>& other
)
561 std::swap(as
<T
>(), other
.as
<T
>());
564 /// Assign the content of \a other to this.
565 /// Destroys \a other.
566 template <typename T
>
568 build(variant
<S
>& other
)
575 /// Destroy the stored \a T.
576 template <typename T
>
580 as
<T
>().~T();]b4_assert_if([
584 /// A buffer large enough to store any of the semantic values.
590 ]b4_locations_if([#include "location.hh"])[
592 /* Enabling traces. */
594 # define YYDEBUG ]b4_debug_flag[
597 /* Enabling verbose error messages. */
598 #ifdef YYERROR_VERBOSE
599 # undef YYERROR_VERBOSE
600 # define YYERROR_VERBOSE 1
602 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
605 /* Enabling the token table. */
606 #ifndef YYTOKEN_TABLE
607 # define YYTOKEN_TABLE ]b4_token_table[
610 ]b4_locations_if([dnl
611 [/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
612 If N is 0, then set CURRENT to the empty location which ends
613 the previous symbol: RHS[0] (always defined). */
615 #ifndef YYLLOC_DEFAULT
616 # define YYLLOC_DEFAULT(Current, Rhs, N) \
620 (Current).begin = (Rhs)[1].location.begin; \
621 (Current).end = (Rhs)[N].location.end; \
625 (Current).begin = (Current).end = (Rhs)[0].location.end; \
633 class ]b4_parser_class_name
[
638 [ /// An auxiliary type to compute the largest semantic type.
640 {]m4_map([b4_char_sizeof
], m4_defn([b4_type_names
]))[};
642 /// Symbol semantic values.
643 typedef variant
<sizeof(union_type
)> semantic_type
;],
644 [ /// Symbol semantic values.
646 [ union semantic_type
649 [m4_if(b4_tag_seen_flag
, 0,
650 [[ typedef int semantic_type
;]],
651 [[ typedef YYSTYPE semantic_type
;]])])])[
653 typedef YYSTYPE semantic_type
;
654 #endif]b4_locations_if([
655 /// Symbol locations.
656 typedef b4_percent_define_get([[location_type]]) location_type
;])[
660 ]b4_token_enums(b4_tokens
)[
663 typedef token::yytokentype token_type
;
665 /// Build a parser object.
666 ]b4_parser_class_name
[ (]b4_parse_param_decl
[);
667 virtual ~]b4_parser_class_name
[ ();
670 /// \returns 0 iff parsing succeeded.
671 virtual int parse ();
674 /// The current debugging stream.
675 std::ostream
& debug_stream () const;
676 /// Set the current debugging stream.
677 void set_debug_stream (std::ostream
&);
679 /// Type for debugging levels.
680 typedef int debug_level_type
;
681 /// The current debugging level.
682 debug_level_type
debug_level () const;
683 /// Set the current debugging level.
684 void set_debug_level (debug_level_type l
);
688 /// Report a syntax error.]b4_locations_if([
689 /// \param loc where the syntax error is found.])[
690 /// \param msg a description of the syntax error.
691 virtual void error (]b4_locations_if([const location_type
& loc
, ])[const std::string
& msg
);
693 /// Generate an error message.
694 /// \param state the state where the error occurred.
695 /// \param tok the lookahead token.
696 virtual std::string
yysyntax_error_ (int yystate
, int tok
);
699 typedef int state_type
;
701 /// Internal symbol numbers.
702 typedef ]b4_int_type_for([b4_translate
])[ token_number_type
;
704 /// For a state, the index in \a yytable_ of its portion.
705 static const ]b4_int_type_for([b4_pact
])[ yypact_
[];
706 static const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
)[ yypact_ninf_
;
708 /// For a state, default rule to reduce.
709 /// Unless\a yytable_ specifies something else to do.
710 /// Zero means the default is an error.
711 static const ]b4_int_type_for([b4_defact
])[ yydefact_
[];
713 static const ]b4_int_type_for([b4_pgoto
])[ yypgoto_
[];
714 static const ]b4_int_type_for([b4_defgoto
])[ yydefgoto_
[];
716 /// What to do in a state.
717 /// \a yytable_[yypact_[s]]: what to do in state \a s.
718 /// - if positive, shift that token.
719 /// - if negative, reduce the rule which number is the opposite.
720 /// - if zero, do what YYDEFACT says.
721 static const ]b4_int_type_for([b4_table
])[ yytable_
[];
722 static const ]b4_int_type(b4_table_ninf
, b4_table_ninf
)[ yytable_ninf_
;
724 static const ]b4_int_type_for([b4_check
])[ yycheck_
[];
726 /// For a state, its accessing symbol.
727 static const ]b4_int_type_for([b4_stos
])[ yystos_
[];
729 /// For a rule, its LHS.
730 static const ]b4_int_type_for([b4_r1
])[ yyr1_
[];
731 /// For a rule, its RHS length.
732 static const ]b4_int_type_for([b4_r2
])[ yyr2_
[];
734 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
735 /// For a symbol, its name in clear.
736 static const char* const yytname_
[];
737 #endif]b4_error_verbose_if([
739 /// Convert the symbol name \a n to a form suitable for a diagnostic.
740 static std::string
yytnamerr_ (const char *n
);])[
743 /// For each rule, its source line number.
744 static const ]b4_int_type_for([b4_rline
])[ yyrline_
[];
745 /// Report on the debug stream that the rule \a r is going to be reduced.
746 virtual void yy_reduce_print_ (int r
);
747 /// Print the state stack on the debug stream.
748 virtual void yystack_print_ ();
752 std::ostream
* yycdebug_
;
755 /// Convert a scanner token number \a t to a symbol number.
756 static inline token_number_type
yytranslate_ (]b4_lex_symbol_if([token_type
], [int])[ t
);
758 /// A complete symbol, with its type.
759 template <typename Exact
>
760 struct symbol_base_type
762 /// Default constructor.
763 inline symbol_base_type ();
765 /// Constructor.]b4_locations_if([
766 inline symbol_base_type (const location_type
& l
)])[;
767 inline symbol_base_type (]b4_args(
768 [const semantic_type
& v
],
769 b4_locations_if([const location_type
& l
]))[);
771 /// Return this with its exact type.
772 const Exact
& self () const;
775 /// Return the type of this symbol.
776 int type_get () const;
778 /// The semantic value.
779 semantic_type value
;]b4_locations_if([
782 location_type location
;])[
786 /// \brief Display a symbol type, value and location.
787 /// \param yyo The output stream.
788 /// \param yysym The symbol.
789 template <typename Exact
>
790 void yy_print_ (std::ostream
& yyo
,
791 const symbol_base_type
<Exact
>& yysym
) const;
794 /// \brief Reclaim the memory associated to a symbol.
795 /// \param yymsg Why this token is reclaimed.
796 /// If null, print nothing.
797 /// \param s The symbol.
798 template <typename Exact
>
799 inline void yy_destroy_ (const char* yymsg
,
800 symbol_base_type
<Exact
>& yysym
) const;
803 /// Element of the stack: a state and its attributes.
804 struct symbol_type
: symbol_base_type
<symbol_type
>
806 /// The parent class.
807 typedef symbol_base_type
<symbol_type
> super_type
;
809 /// Default constructor.
810 inline symbol_type ();
813 inline symbol_type (]b4_args([int t
],
814 [const semantic_type
& v
],
815 b4_locations_if([const location_type
& l
]))[);
817 inline symbol_type (]b4_args([int t
],
818 b4_locations_if([const location_type
& l
]))[);
823 /// Return the type corresponding to this state.
824 inline int type_get_ () const;
827 inline token_type
token () const;
830 ]b4_symbol_constructor_declarations
[
833 /// Element of the stack: a state and its attributes.
834 struct stack_symbol_type
: symbol_base_type
<stack_symbol_type
>
836 /// The parent class.
837 typedef symbol_base_type
<stack_symbol_type
> super_type
;
839 /// Default constructor.
840 inline stack_symbol_type ();
843 inline stack_symbol_type (]b4_args([state_type s
],
844 [const semantic_type
& v
],
845 b4_locations_if([const location_type
& l
]))[);
850 /// Return the type corresponding to this state.
851 inline int type_get_ () const;
855 typedef stack
<stack_symbol_type
> stack_type
;
860 /// Push a new state on the stack.
861 /// \param m a debug message to display
862 /// if null, no trace is output.
863 /// \param s the symbol
864 /// \warning the contents of \a s.value is stolen.
865 inline void yypush_ (const char* m
, stack_symbol_type
& s
);
867 /// Push a new look ahead token on the state on the stack.
868 /// \param m a debug message to display
869 /// if null, no trace is output.
870 /// \param s the state
871 /// \param sym the symbol (for its value and location).
872 /// \warning the contents of \a s.value is stolen.
873 inline void yypush_ (const char* m
, state_type s
, symbol_type
& sym
);
875 /// Pop \a n symbols the three stacks.
876 inline void yypop_ (unsigned int n
= 1);
882 yylast_
= ]b4_last
[, //< Last index in yytable_.
883 yynnts_
= ]b4_nterms_number
[, //< Number of nonterminal symbols.
885 yyfinal_
= ]b4_final_state_number
[, //< Termination state number.
888 yyntokens_
= ]b4_tokens_number
[, //< Number of tokens.
891 ]b4_parse_param_vars
[
894 ]b4_lex_symbol_if([b4_yytranslate_definition
])[
895 ]b4_symbol_constructor_specializations
[
896 ]b4_lex_symbol_if([b4_symbol_constructor_definitions
])[
899 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
900 [b4_token_defines(b4_tokens
)
903 /* Redirection for backward compatibility. */
904 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
907 b4_percent_code_get([[provides]])[]dnl
909 [#endif /* ! defined PARSER_HEADER_H */]
910 @
output(b4_parser_file_name@
)@
911 b4_copyright([Skeleton implementation
for Bison
LALR(1) parsers in C
++])
912 b4_percent_code_get([[top]])[]dnl
913 m4_if(b4_prefix
, [yy
], [],
915 // Take the name prefix into account.
916 #define yylex b4_prefix[]lex])[
918 /* First part of user declarations. */
919 ]b4_user_pre_prologue
[
921 #include "@basename(]b4_spec_defines_file[@)"
923 /* User implementation prologue. */
924 ]b4_user_post_prologue
925 b4_percent_code_get
[]dnl
930 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
931 # define YY_(msgid) dgettext ("bison-runtime", msgid)
935 # define YY_(msgid) msgid
939 /* Suppress unused-variable warnings by "using" E. */
940 #define YYUSE(e) ((void) (e))
942 /* Enable debugging if requested. */
945 /* A pseudo ostream that takes yydebug_ into account. */
946 # define YYCDEBUG if (yydebug_) (*yycdebug_)
948 # define YY_SYMBOL_PRINT(Title, Symbol) \
952 *yycdebug_ << Title << ' '; \
953 yy_print_ (*yycdebug_, Symbol); \
954 *yycdebug_ << std::endl; \
958 # define YY_REDUCE_PRINT(Rule) \
961 yy_reduce_print_ (Rule); \
964 # define YY_STACK_PRINT() \
972 # define YYCDEBUG if (false) std::cerr
973 # define YY_SYMBOL_PRINT(Title, Symbol) static_cast<void>(0)
974 # define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
975 # define YY_STACK_PRINT() static_cast<void>(0)
977 #endif /* !YYDEBUG */
979 #define yyerrok (yyerrstatus_ = 0)
980 #define yyclearin (yyempty = true)
982 #define YYACCEPT goto yyacceptlab
983 #define YYABORT goto yyabortlab
984 #define YYERROR goto yyerrorlab
985 #define YYRECOVERING() (!!yyerrstatus_)
987 ]b4_namespace_open
[]b4_error_verbose_if([[
989 /* Return YYSTR after stripping away unnecessary quotes and
990 backslashes, so that it's suitable for yyerror. The heuristic is
991 that double-quoting is unnecessary unless the string contains an
992 apostrophe, a comma, or backslash (other than backslash-backslash).
993 YYSTR is taken from yytname. */
995 ]b4_parser_class_name
[::yytnamerr_ (const char *yystr
)
999 std::string yyr
= "";
1000 char const *yyp
= yystr
;
1007 goto do_not_strip_quotes
;
1011 goto do_not_strip_quotes
;
1020 do_not_strip_quotes
: ;
1027 /// Build a parser object.
1028 ]b4_parser_class_name::b4_parser_class_name
[ (]b4_parse_param_decl
[)]m4_ifset([b4_parse_param
], [
1031 ]m4_ifset([b4_parse_param
], [ ], [ :])[yydebug_ (false),
1032 yycdebug_ (&std::cerr
)]m4_ifset([b4_parse_param
], [,])[
1033 #endif]b4_parse_param_cons[
1037 ]b4_parser_class_name::~b4_parser_class_name
[ ()
1046 ]b4_lex_symbol_if([], [b4_symbol_constructor_definitions
])[
1048 // stack_symbol_type.
1049 ]b4_parser_class_name
[::stack_symbol_type::stack_symbol_type ()
1055 ]b4_parser_class_name
[::stack_symbol_type::stack_symbol_type (]b4_args(
1057 [const semantic_type
& v
],
1058 b4_locations_if([const location_type
& l
]))[)
1059 : super_type (v
]b4_locations_if([, l
])[)
1065 ]b4_parser_class_name
[::stack_symbol_type::type_get_ () const
1067 return yystos_
[state
];
1071 template <typename Exact
>
1073 ]b4_parser_class_name
[::yy_destroy_ (const char* yymsg
,
1074 symbol_base_type
<Exact
>& yysym
) const
1076 int yytype
= yysym
.type_get ();
1079 YY_SYMBOL_PRINT (yymsg
, yysym
);
1084 ]m4_map([b4_symbol_actions
], m4_defn([b4_symbol_destructors
]))[
1090 b4_symbol_variant([[yytype]], [[yysym
.value
]], [[template destroy]])])[
1094 template <typename Exact
>
1096 ]b4_parser_class_name
[::yy_print_ (std::ostream
& yyo
,
1097 const symbol_base_type
<Exact
>& yysym
) const
1099 int yytype
= yysym
.type_get ();
1100 yyo
<< (yytype
< yyntokens_
? "token" : "nterm")
1101 << ' ' << yytname_
[yytype
] << " ("]b4_locations_if([
1102 << yysym
.location
<< ": "])[;
1105 ]m4_map([b4_symbol_actions
], m4_defn([b4_symbol_printers
]))[
1114 ]b4_parser_class_name
[::yypush_ (const char* m
, state_type s
,
1118 YY_SYMBOL_PRINT (m
, sym
);
1120 [[ yystack_
.push (stack_symbol_type (]b4_args(
1123 b4_locations_if([sym
.location
]))[));
1124 ]b4_symbol_variant([[yystos_
[s
]]], [[yystack_
[0].value
]],
1125 [build
], [sym
.value
])],
1126 [[ yystack_
.push (stack_symbol_type (]b4_args(
1129 b4_locations_if([sym
.location
]))[));]])[
1133 ]b4_parser_class_name
[::yypush_ (const char* m
, stack_symbol_type
& s
)
1136 YY_SYMBOL_PRINT (m
, s
);
1138 [[ yystack_
.push (stack_symbol_type (]b4_args(
1141 b4_locations_if([s
.location
]))[));
1142 ]b4_symbol_variant([[yystos_
[s
.state
]]], [[yystack_
[0].value
]],
1143 [build
], [s
.value
])],
1144 [ yystack_
.push (s
);])[
1148 ]b4_parser_class_name
[::yypop_ (unsigned int n
)
1155 ]b4_parser_class_name
[::debug_stream () const
1161 ]b4_parser_class_name
[::set_debug_stream (std::ostream
& o
)
1167 ]b4_parser_class_name
[::debug_level_type
1168 ]b4_parser_class_name
[::debug_level () const
1174 ]b4_parser_class_name
[::set_debug_level (debug_level_type l
)
1181 ]b4_parser_class_name
[::parse ()
1183 /// Whether yyla contains a lookahead.
1184 bool yyempty
= true;
1191 /* Error handling. */
1193 int yyerrstatus_
= 0;
1195 /// The lookahead symbol.
1196 symbol_type yyla
;]b4_locations_if([[
1198 /// The locations where the error started and ended.
1199 stack_symbol_type yyerror_range
[2];]])[
1202 stack_symbol_type yylhs
;
1204 /// The return value of parse().
1207 YYCDEBUG
<< "Starting parse" << std::endl
;
1209 ]m4_ifdef([b4_initial_action
], [
1210 m4_pushdef([b4_at_dollar
], [yyla
.location
])dnl
1211 m4_pushdef([b4_dollar_dollar
], [yyla
.value
])dnl
1212 /* User initialization code. */
1213 b4_user_initial_action
1214 m4_popdef([b4_dollar_dollar
])dnl
1215 m4_popdef([b4_at_dollar
])])dnl
1217 [ /* Initialize the stack. The initial state will be set in
1218 yynewstate, since the latter expects the semantical and the
1219 location values to have been already stored, initialize these
1220 stacks with a primary value. */
1221 yystack_
= stack_type (0);
1222 yypush_ (0, 0, yyla
);
1224 // A new state was pushed on the stack.
1225 // Invariant: yystate == yystack_[0].state, i.e.,
1226 // yystate was just pushed onto the state stack.
1228 YYCDEBUG
<< "Entering state " << yystate
<< std::endl
;
1231 if (yystate
== yyfinal_
)
1239 /* Try to take a decision without lookahead. */
1240 yyn
= yypact_
[yystate
];
1241 if (yyn
== yypact_ninf_
)
1244 /* Read a lookahead token. */
1247 YYCDEBUG
<< "Reading a token: ";
1249 [ yyla
= b4_c_function_call([yylex
], [symbol_type
],
1250 m4_ifdef([b4_lex_param
], b4_lex_param
));],
1251 [ yyla
.type
= yytranslate_ (b4_c_function_call([yylex
], [int],
1252 [[YYSTYPE
*], [&yyla
.value
]][]dnl
1253 b4_locations_if([, [[location
*], [&yyla
.location
]]])dnl
1254 m4_ifdef([b4_lex_param
], [, ]b4_lex_param
)));])[
1257 YY_SYMBOL_PRINT ("Next token is", yyla
);
1259 /* If the proper action on seeing token YYLA.TYPE is to reduce or
1260 to detect an error, take that action. */
1262 if (yyn
< 0 || yylast_
< yyn
|| yycheck_
[yyn
] != yyla
.type
)
1265 /* Reduce or error. */
1266 yyn
= yytable_
[yyn
];
1269 if (yyn
== 0 || yyn
== yytable_ninf_
)
1275 /* Discard the token being shifted. */
1278 /* Count tokens shifted since error; after three, turn off error
1283 /* Shift the lookahead token. */
1285 yypush_ ("Shifting", yystate
, yyla
);
1288 /*-----------------------------------------------------------.
1289 | yydefault -- do the default action for the current state. |
1290 `-----------------------------------------------------------*/
1292 yyn
= yydefact_
[yystate
];
1297 /*-----------------------------.
1298 | yyreduce -- Do a reduction. |
1299 `-----------------------------*/
1301 yylen
= yyr2_
[yyn
];]b4_variant_if([
1302 /* Variants are always initialized to an empty instance of the
1303 correct type. The default $$=$1 rule is NOT applied when using
1305 ]b4_symbol_variant([[yyr1_@
{yyn@
}]], [yylhs
.value
], [build
])[],[
1306 /* If YYLEN is nonzero, implement the default value of the action:
1307 `$$ = $1'. Otherwise, use the top of the stack.
1309 Otherwise, the following line sets YYLHS.VALUE to garbage.
1310 This behavior is undocumented and Bison
1311 users should not rely upon it. */
1313 yylhs
.value
= yystack_@
{yylen
- 1@
}.value
;
1315 yylhs
.value
= yystack_@
{0@
}.value
;])[
1316 ]b4_locations_if([dnl
1318 // Compute the default @@$.
1320 slice
<stack_symbol_type
, stack_type
> slice (yystack_
, yylen
);
1321 YYLLOC_DEFAULT (yylhs
.location
, slice
, yylen
);
1324 // Perform the reduction.
1325 YY_REDUCE_PRINT (yyn
);
1332 // Compute post-reduction state.
1334 yystate
= yypgoto_
[yyn
- yyntokens_
] + yystack_
[yylen
].state
;
1335 if (0 <= yystate
&& yystate
<= yylast_
1336 && yycheck_
[yystate
] == yystack_
[yylen
].state
)
1337 yystate
= yytable_
[yystate
];
1339 yystate
= yydefgoto_
[yyn
- yyntokens_
];
1340 yylhs
.state
= yystate
;
1341 YY_SYMBOL_PRINT ("-> $$ =", yylhs
);
1343 // Destroy the lhs symbols.
1344 for (int i
= 0; i
< yylen
; ++i
)
1345 // Destroy a variant which value may have be swapped with
1346 // yylhs.value. The value of yylhs.value (hence maybe one of
1347 // these lhs symbols) depends on what does the default
1348 // contruction for this type. In the case of pointers for
1349 // instance, nothing is done, so the value is junk. Therefore
1350 // do not try to report the content in the debug trace, it's
1351 // junk. Hence yymsg = 0. Besides, that keeps exactly the same
1352 // traces as with the other Bison skeletons.
1353 yy_destroy_ (0, yystack_
[i
]);]])[
1359 /* Shift the result of the reduction. */
1363 /*------------------------------------.
1364 | yyerrlab -- here on detecting error |
1365 `------------------------------------*/
1367 /* If not already recovering from an error, report this error. */
1371 error (]b4_args(b4_locations_if([yyla
.location
]),
1372 [yysyntax_error_ (yystate
, yyla
.type
)])[);
1376 yyerror_range
[0].location
= yyla
.location
;]])[
1377 if (yyerrstatus_
== 3)
1379 /* If just tried and failed to reuse lookahead token after an
1380 error, discard it. */
1382 /* Return failure if at end of input. */
1383 if (yyla
.type
== yyeof_
)
1387 yy_destroy_ ("Error: discarding", yyla
);
1392 /* Else will try to reuse lookahead token after shifting the error
1397 /*---------------------------------------------------.
1398 | yyerrorlab -- error raised explicitly by YYERROR. |
1399 `---------------------------------------------------*/
1402 /* Pacify compilers like GCC when the user code never invokes
1403 YYERROR and the label yyerrorlab therefore never appears in user
1409 yyerror_range
[0].location
= yystack_
[yylen
- 1].location
;]])[
1410 /* Do not reclaim the symbols of the rule which action triggered
1414 yystate
= yystack_
[0].state
;
1417 /*-------------------------------------------------------------.
1418 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1419 `-------------------------------------------------------------*/
1421 yyerrstatus_
= 3; /* Each real token shifted decrements this. */
1423 stack_symbol_type error_token
;
1426 yyn
= yypact_
[yystate
];
1427 if (yyn
!= yypact_ninf_
)
1430 if (0 <= yyn
&& yyn
<= yylast_
&& yycheck_
[yyn
] == yyterror_
)
1432 yyn
= yytable_
[yyn
];
1438 // Pop the current state because it cannot handle the error token.
1439 if (yystack_
.size () == 1)
1442 yyerror_range
[0].location
= yystack_
[0].location
;]])[
1443 yy_destroy_ ("Error: popping", yystack_
[0]);
1445 yystate
= yystack_
[0].state
;
1449 yyerror_range
[1].location
= yyla
.location
;
1450 YYLLOC_DEFAULT (error_token
.location
, (yyerror_range
- 1), 2);]])[
1452 /* Shift the error token. */
1453 error_token
.state
= yystate
= yyn
;
1454 yypush_ ("Shifting", error_token
);
1470 yy_destroy_ ("Cleanup: discarding lookahead", yyla
);
1472 /* Do not reclaim the symbols of the rule which action triggered
1473 this YYABORT or YYACCEPT. */
1475 while (yystack_
.size () != 1)
1477 yy_destroy_ ("Cleanup: popping", yystack_
[0]);
1484 // Generate an error message.
1486 ]b4_parser_class_name
[::yysyntax_error_ (]dnl
1487 b4_error_verbose_if([int yystate
, int yytoken
],
1490 std::string yyres
;]b4_error_verbose_if([[
1491 int yyn
= yypact_
[yystate
];
1492 if (yypact_ninf_
< yyn
&& yyn
<= yylast_
)
1494 /* Start YYX at -YYN if negative to avoid negative indexes in
1496 int yyxbegin
= yyn
< 0 ? -yyn
: 0;
1498 /* Stay within bounds of both yycheck and yytname. */
1499 int yychecklim
= yylast_
- yyn
+ 1;
1500 int yyxend
= yychecklim
< yyntokens_
? yychecklim
: yyntokens_
;
1502 // Number of "expected" tokens.
1505 enum { YYERROR_VERBOSE_ARGS_MAXIMUM
= 5 };
1506 // Arguments of yyformat.
1507 char const *yyarg
[YYERROR_VERBOSE_ARGS_MAXIMUM
];
1508 yyarg
[yycount
++] = yytname_
[yytoken
];
1509 for (int yyx
= yyxbegin
; yyx
< yyxend
; ++yyx
)
1510 if (yycheck_
[yyx
+ yyn
] == yyx
&& yyx
!= yyterror_
)
1512 if (yycount
== YYERROR_VERBOSE_ARGS_MAXIMUM
)
1518 yyarg
[yycount
++] = yytname_
[yyx
];
1521 char const* yyformat
= 0;
1524 #define YYCASE_(N, S) \
1528 YYCASE_(1, YY_("syntax error, unexpected %s"));
1529 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1530 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1531 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1532 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1537 for (char const* yyp
= yyformat
; *yyp
; ++yyp
)
1538 if (yyp
[0] == '%' && yyp
[1] == 's' && yyi
< yycount
)
1540 yyres
+= yytnamerr_ (yyarg
[yyi
++]);
1548 [ yyres
= YY_("syntax error");
1553 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1555 const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
) b4_parser_class_name::yypact_ninf_
= b4_pact_ninf
[;
1556 ]b4_table_define([pact
], [b4_pact
])[;
1558 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
1559 doesn't specify something else to do. Zero means the default is an
1561 ]b4_table_define([defact
], [b4_defact
])[;
1563 /* YYPGOTO[NTERM-NUM]. */
1564 ]b4_table_define([pgoto
], [b4_pgoto
])[;
1566 /* YYDEFGOTO[NTERM-NUM]. */
1567 ]b4_table_define([defgoto
], [b4_defgoto
])[;
1569 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1570 positive, shift that token. If negative, reduce the rule which
1571 number is the opposite. If zero, do what YYDEFACT says. */
1572 const ]b4_int_type(b4_table_ninf
, b4_table_ninf
) b4_parser_class_name::yytable_ninf_
= b4_table_ninf
[;
1573 ]b4_table_define([table
], [b4_table
])[;
1576 ]b4_table_define([check
], [b4_check
])[;
1578 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1579 symbol of state STATE-NUM. */
1580 ]b4_table_define([stos
], [b4_stos
])[;
1582 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1583 ]b4_table_define([r1
], [b4_r1
])[;
1585 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1586 ]b4_table_define([r2
], [b4_r2
])[;
1588 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1589 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1590 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1592 const ]b4_parser_class_name
[::yytname_
[] =
1599 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1600 ]b4_table_define([rline
], [b4_rline
])[;
1602 // Print the state stack on the debug stream.
1604 ]b4_parser_class_name
[::yystack_print_ ()
1606 *yycdebug_
<< "Stack now";
1607 for (stack_type::const_iterator
1608 i
= yystack_
.begin (),
1609 i_end
= yystack_
.end ();
1611 *yycdebug_
<< ' ' << i
->state
;
1612 *yycdebug_
<< std::endl
;
1615 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1617 ]b4_parser_class_name
[::yy_reduce_print_ (int yyrule
)
1619 unsigned int yylno
= yyrline_
[yyrule
];
1620 int yynrhs
= yyr2_
[yyrule
];
1621 /* Print the symbols being reduced, and their result. */
1622 *yycdebug_
<< "Reducing stack by rule " << yyrule
- 1
1623 << " (line " << yylno
<< "):" << std::endl
;
1624 /* The symbols being reduced. */
1625 for (int yyi
= 0; yyi
< yynrhs
; yyi
++)
1626 YY_SYMBOL_PRINT (" $" << yyi
+ 1 << " =",
1627 ]b4_rhs_data(yynrhs
, yyi
+ 1)[);
1631 ]b4_lex_symbol_if([], [b4_yytranslate_definition
])[
1632 ]b4_namespace_close
[
1635 @
output(b4_dir_prefix
[]stack
.hh@
)@
1636 b4_copyright([Stack handling
for Bison parsers in C
++])[
1638 #ifndef BISON_STACK_HH
1639 # define BISON_STACK_HH
1644 template <class T
, class S
= std::deque
<T
> >
1649 // Hide our reversed order.
1650 typedef typename
S::reverse_iterator iterator
;
1651 typedef typename
S::const_reverse_iterator const_iterator
;
1657 stack (unsigned int n
) : seq_ (n
)
1663 operator [] (unsigned int i
)
1670 operator [] (unsigned int i
) const
1679 seq_
.push_front (t
);
1684 pop (unsigned int n
= 1)
1691 typename
S::size_type
1694 return seq_
.size ();
1697 inline const_iterator
begin () const { return seq_
.rbegin (); }
1698 inline const_iterator
end () const { return seq_
.rend (); }
1701 /// The wrapped container.
1705 /// Present a slice of the top of a stack.
1706 template <class T
, class S
= stack
<T
> >
1711 slice (const S
& stack
,
1712 unsigned int range
) : stack_ (stack
),
1719 operator [] (unsigned int i
) const
1721 return stack_
[range_
- i
];
1727 unsigned int range_
;
1729 ]b4_namespace_close
[
1731 #endif // not BISON_STACK_HH[]dnl
1734 m4_popdef([b4_copyright_years
])dnl