# Same as in C, but using references instead of pointers.
m4_define([b4_symbol_actions],
[m4_pushdef([b4_dollar_dollar],
- [b4_symbol_value([yyvalue], [$6])])dnl
-m4_pushdef([b4_at_dollar], [yylocation])dnl
+ [b4_symbol_value([yysym.value], [$6])])dnl
+m4_pushdef([b4_at_dollar], [yysym.location])dnl
case $4: // $3
b4_syncline([$2], [$1])
$5;
/// \param tok the lookahead token.
virtual std::string yysyntax_error_ (int yystate, int tok);
-#if YYDEBUG
- /// \brief Report a symbol value on the debug stream.
- /// \param yytype The token type.
- /// \param yyvalue Its semantic value.
- /// \param yylocation Its location.
- virtual void yy_symbol_value_print_ (int yytype,
- const semantic_type& yyvalue,
- const location_type& yylocation);
- /// \brief Report a symbol on the debug stream.
- /// \param yytype The token type.
- /// \param yyvalue Its semantic value.
- /// \param yylocation Its location.
- virtual void yy_symbol_print_ (int yytype,
- const semantic_type& yyvalue,
- const location_type& yylocation);
-#endif
-
/// State numbers.
typedef int state_type;
/// Convert a scanner token number \a t to a symbol number.
token_number_type yytranslate_ (int t);
- /// \brief Reclaim the memory associated to a symbol.
- /// \param yymsg Why this token is reclaimed.
- /// If null, nothing is printed at all.
- /// \param yytype The symbol type.
- /// \param yyvalue Its semantic value.
- /// \param yylocation Its location.
- inline void yydestruct_ (const char* yymsg,
- int yytype,
- semantic_type& yyvalue,
- location_type& yylocation);
-
- /// Element of the stack: a state and its attributes.
- struct data_type
+ /// A complete symbol, with its type.
+ struct symbol_base_type
{
/// Default constructor.
- data_type ();
+ inline symbol_base_type ();
/// Constructor.
- data_type (state_type s, const semantic_type& v, const location_type& l);
+ inline symbol_base_type (const semantic_type& v, const location_type& l);
- /// The state.
- state_type state;
+ /// Return the type of this symbol.
+ virtual int type_get () const = 0;
/// The semantic value.
semantic_type value;
location_type location;
};
+#if YYDEBUG
+ /// \brief Display a symbol type, value and location.
+ /// \param yyo The output stream.
+ /// \param yysym The symbol.
+ void yy_print_ (std::ostream& yyo, const symbol_base_type& yysym) const;
+#endif
+
+ /// \brief Reclaim the memory associated to a symbol.
+ /// \param yymsg Why this token is reclaimed.
+ /// If null, print nothing.
+ /// \param s The symbol.
+ inline void yy_destroy_ (const char* yymsg, symbol_base_type& yysym) const;
+
+ /// Element of the stack: a state and its attributes.
+ struct symbol_type : symbol_base_type
+ {
+ /// Default constructor.
+ inline symbol_type ();
+
+ /// Constructor.
+ inline symbol_type (int t,
+ const semantic_type& v, const location_type& l);
+
+ /// The symbol type.
+ int type;
+
+ /// Return the type corresponding to this state.
+ virtual inline int type_get () const;
+ };
+
+ /// Element of the stack: a state and its attributes.
+ struct stack_symbol_type : symbol_base_type
+ {
+ /// Default constructor.
+ inline stack_symbol_type ();
+
+ /// Constructor.
+ inline stack_symbol_type (state_type s,
+ const semantic_type& v, const location_type& l);
+
+ /// The state.
+ state_type state;
+
+ /// Return the type corresponding to this state.
+ virtual inline int type_get () const;
+ };
+
/// Stack type.
- typedef stack<data_type> stack_type;
+ typedef stack<stack_symbol_type> stack_type;
/// The stack.
stack_type yystack_;
/// Push a new state on the stack.
/// \param m a debug message to display
/// if null, no trace is output.
- /// \param s the state entered
- /// \param v semantic value
- /// \param l location
- /// \warning the contents of \a v is stolen.
- inline void yypush_ (const char* m, state_type s,
- semantic_type& v, const location_type& l);
+ /// \param s the symbol
+ /// \warning the contents of \a s.value is stolen.
+ inline void yypush_ (const char* m, stack_symbol_type& s);
+
+ /// Push a new look ahead token on the state on the stack.
+ /// \param m a debug message to display
+ /// if null, no trace is output.
+ /// \param s the state
+ /// \param sym the symbol (for its value and location).
+ /// \warning the contents of \a s.value is stolen.
+ inline void yypush_ (const char* m, state_type s, symbol_type& sym);
/// Pop \a n symbols the three stacks.
inline void yypop_ (unsigned int n = 1);
static const token_number_type yyundef_token_;
]b4_parse_param_vars[
};
+
]b4_namespace_close[
]b4_percent_define_flag_if([[global_tokens_and_yystype]],
/* A pseudo ostream that takes yydebug_ into account. */
# define YYCDEBUG if (yydebug_) (*yycdebug_)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
- do { \
- if (yydebug_) \
- { \
- *yycdebug_ << Title << ' '; \
- yy_symbol_print_ ((Type), (Value), (Location)); \
- *yycdebug_ << std::endl; \
- } \
+# define YY_SYMBOL_PRINT(Title, Symbol) \
+ do { \
+ if (yydebug_) \
+ { \
+ *yycdebug_ << Title << ' '; \
+ yy_print_ (*yycdebug_, Symbol); \
+ *yycdebug_ << std::endl; \
+ } \
} while (false)
# define YY_REDUCE_PRINT(Rule) \
#else /* !YYDEBUG */
# define YYCDEBUG if (false) std::cerr
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) static_cast<void>(0)
-# define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
-# define YY_STACK_PRINT() static_cast<void>(0)
+# define YY_SYMBOL_PRINT(Title, Symbol) static_cast<void>(0)
+# define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
+# define YY_STACK_PRINT() static_cast<void>(0)
#endif /* !YYDEBUG */
{
}
-#if YYDEBUG
- /*--------------------------------.
- | Print this symbol on YYOUTPUT. |
- `--------------------------------*/
- inline void
- ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
- const semantic_type& yyvalue, const location_type& yylocation)
+ /*---------------.
+ | Symbol types. |
+ `---------------*/
+
+ // symbol_base_type.
+ ]b4_parser_class_name[::symbol_base_type::symbol_base_type ()
+ : value()
+ , location()
{
- YYUSE (yylocation);
- YYUSE (yyvalue);
- switch (yytype)
- {
- ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
-[ default:
- break;
- }
}
+ ]b4_parser_class_name[::symbol_base_type::symbol_base_type (const semantic_type& v, const location_type& l)
- void
- ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
- const semantic_type& yyvalue, const location_type& yylocation)
+ : value(v)
+ , location(l)
{
- *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
- << ' ' << yytname_[yytype] << " ("
- << yylocation << ": ";
- yy_symbol_value_print_ (yytype, yyvalue, yylocation);
- *yycdebug_ << ')';
}
-#endif
+
+ // symbol_type.
+ ]b4_parser_class_name[::symbol_type::symbol_type ()
+ : type()
+ , symbol_base_type()
+ {
+ }
+
+ ]b4_parser_class_name[::symbol_type::symbol_type (int t,
+ const semantic_type& v, const location_type& l)
+ : type(t)
+ , symbol_base_type(v, l)
+ {
+ }
+
+ int
+ ]b4_parser_class_name[::symbol_type::type_get () const
+ {
+ return type;
+ }
+
+ // stack_symbol_type.
+ ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
+ : state()
+ , symbol_base_type()
+ {
+ }
+
+ ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s,
+ const semantic_type& v, const location_type& l)
+ : state(s)
+ , symbol_base_type(v, l)
+ {
+ }
+
+ int
+ ]b4_parser_class_name[::stack_symbol_type::type_get () const
+ {
+ return yystos_[state];
+ }
+
void
- ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
- int yytype, semantic_type& yyvalue, location_type& yylocation)
+ ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, symbol_base_type& yysym) const
{
+ int yytype = yysym.type_get ();
YYUSE (yymsg);
- YYUSE (yyvalue);
- YYUSE (yylocation);
-
if (yymsg)
- YY_SYMBOL_PRINT (yymsg, yytype, yyvalue, yylocation);
+ YY_SYMBOL_PRINT (yymsg, yysym);
// User destructor.
switch (yytype)
}]b4_variant_if([
// Type destructor.
- b4_symbol_variant([[yytype]], [[yyvalue]], [[destroy]])])[
+ b4_symbol_variant([[yytype]], [[yysym.value]], [[destroy]])])[
}
- ]b4_parser_class_name[::data_type::data_type ()
- : state()
- , value()
- , location()
+#if YYDEBUG
+ void
+ ]b4_parser_class_name[::yy_print_ (std::ostream& yyo, const symbol_base_type& yysym) const
{
+ int yytype = yysym.type_get ();
+ yyo << (yytype < yyntokens_ ? "token" : "nterm")
+ << ' ' << yytname_[yytype] << " ("
+ << yysym.location << ": ";
+ switch (yytype)
+ {
+ ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
+[ default:
+ break;
+ }
+ yyo << ')';
}
+#endif
- ]b4_parser_class_name[::data_type::data_type (state_type s,
- const semantic_type& v, const location_type& l)
- : state(s)
- , value(v)
- , location(l)
+ void
+ ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
+ symbol_type& sym)
{
+ if (m)
+ YY_SYMBOL_PRINT (m, sym);
+]b4_variant_if(
+[[ yystack_.push (stack_symbol_type (s, semantic_type(), sym.location));
+ ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
+ [build], [sym.value])],
+[ yystack_.push (stack_symbol_type (s, sym.value, sym.location));])[
}
void
- ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
- semantic_type& v, const location_type& l)
+ ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
{
if (m)
- YY_SYMBOL_PRINT (m, yystos_[s], v, l);
+ YY_SYMBOL_PRINT (m, s);
]b4_variant_if(
-[[ yystack_.push (data_type (s, semantic_type(), l));
- ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]], [build], [v])],
-[ yystack_.push (data_type (s, v, l));])[
+[[ yystack_.push (stack_symbol_type (s.state, semantic_type(), s.location));
+ ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
+ [build], [s.value])],
+[ yystack_.push (s);])[
}
void
int
]b4_parser_class_name[::parse ()
{
- /// Lookahead and lookahead in internal form.
+ /// Coded type of the lookahead.
int yychar = yyempty_;
- int yytoken = 0;
/* State. */
int yyn;
int yynerrs_ = 0;
int yyerrstatus_ = 0;
- /// Semantic value of the lookahead.
- semantic_type yylval;
- /// Location of the lookahead.
- location_type yylloc;
+ /// The lookahead symbol.
+ symbol_type yyla;
+
/// The locations where the error started and ended.
- data_type yyerror_range[2];
+ stack_symbol_type yyerror_range[2];
/// $$ and @@$.
- data_type yylhs;
+ stack_symbol_type yylhs;
/// The return value of parse().
int yyresult;
YYCDEBUG << "Starting parse" << std::endl;
]m4_ifdef([b4_initial_action], [
-m4_pushdef([b4_at_dollar], [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
+m4_pushdef([b4_at_dollar], [yyla.location])dnl
+m4_pushdef([b4_dollar_dollar], [yyla.value])dnl
/* User initialization code. */
b4_user_initial_action
m4_popdef([b4_dollar_dollar])dnl
location values to have been already stored, initialize these
stacks with a primary value. */
yystack_ = stack_type (0);
- yypush_ (0, yystate, yylval, yylloc);
+ yypush_ (0, 0, yyla);
// A new state was pushed on the stack.
// Invariant: yystate == yystack_[0].state, i.e.,
{
YYCDEBUG << "Reading a token: ";
yychar = ]b4_c_function_call([yylex], [int],
- [[YYSTYPE*], [&yylval]][]dnl
-b4_locations_if([, [[location*], [&yylloc]]])dnl
+ [[YYSTYPE*], [&yyla.value]][]dnl
+b4_locations_if([, [[location*], [&yyla.location]]])dnl
m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
}
/* Convert token to internal form. */
if (yychar <= yyeof_)
{
- yychar = yytoken = yyeof_;
+ yychar = yyla.type = yyeof_;
YYCDEBUG << "Now at end of input." << std::endl;
}
else
{
- yytoken = yytranslate_ (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, yylval, yylloc);
+ yyla.type = yytranslate_ (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yyla);
}
- /* If the proper action on seeing token YYTOKEN is to reduce or to
- detect an error, take that action. */
- yyn += yytoken;
- if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
+ /* If the proper action on seeing token YYLA.TYPE is to reduce or
+ to detect an error, take that action. */
+ yyn += yyla.type;
+ if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
goto yydefault;
/* Reduce or error. */
if (yyn <= 0)
{
if (yyn == 0 || yyn == yytable_ninf_)
- goto yyerrlab;
+ goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
/* Shift the lookahead token. */
yystate = yyn;
- yypush_ ("Shifting", yystate, yylval, yylloc);
+ yypush_ ("Shifting", yystate, yyla);
goto yynewstate;
/*-----------------------------------------------------------.
// Compute the default @@$.
{
- slice<data_type, stack_type> slice (yystack_, yylen);
+ slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
YYLLOC_DEFAULT (yylhs.location, slice, yylen);
}
else
yystate = yydefgoto_[yyn - yyntokens_];
yylhs.state = yystate;
- YY_SYMBOL_PRINT ("-> $$ =", yyn, yylhs.value, yylhs.location);
+ YY_SYMBOL_PRINT ("-> $$ =", yylhs);
]b4_variant_if([[
// Destroy the lhs symbols.
for (int i = 0; i < yylen; ++i)
// do not try to report the content in the debug trace, it's
// junk. Hence yymsg = 0. Besides, that keeps exactly the same
// traces as with the other Bison skeletons.
- yydestruct_ (0,
- yystos_[yystack_[i].state],
- yystack_[i].value, yystack_[i].location);]])[
+ yy_destroy_ (0, yystack_[i]);]])[
yypop_ (yylen);
yylen = 0;
YY_STACK_PRINT ();
/* Shift the result of the reduction. */
- yypush_ (0, yylhs.state, yylhs.value, yylhs.location);
+ yypush_ (0, yylhs);
goto yynewstate;
/*------------------------------------.
if (!yyerrstatus_)
{
++yynerrs_;
- error (yylloc, yysyntax_error_ (yystate, yytoken));
+ error (yyla.location, yysyntax_error_ (yystate, yyla.type));
}
- yyerror_range[0].location = yylloc;
+ yyerror_range[0].location = yyla.location;
if (yyerrstatus_ == 3)
{
/* If just tried and failed to reuse lookahead token after an
}
else
{
- yydestruct_ ("Error: discarding", yytoken, yylval, yylloc);
+ yy_destroy_ ("Error: discarding", yyla);
yychar = yyempty_;
}
}
yyerrlab1:
yyerrstatus_ = 3; /* Each real token shifted decrements this. */
{
- data_type error_token;
+ stack_symbol_type error_token;
for (;;)
{
yyn = yypact_[yystate];
YYABORT;
yyerror_range[0].location = yystack_[0].location;
- yydestruct_ ("Error: popping",
- yystos_[yystate],
- yystack_[0].value, yystack_[0].location);
+ yy_destroy_ ("Error: popping", yystack_[0]);
yypop_ ();
yystate = yystack_[0].state;
YY_STACK_PRINT ();
}
- yyerror_range[1].location = yylloc;
+ yyerror_range[1].location = yyla.location;
YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);
/* Shift the error token. */
- yystate = yyn;
- yypush_ ("Shifting", yystate, error_token.value, error_token.location);
+ error_token.state = yystate = yyn;
+ yypush_ ("Shifting", error_token);
}
goto yynewstate;
yyreturn:
if (yychar != yyempty_)
- yydestruct_ ("Cleanup: discarding lookahead", yytoken, yylval, yylloc);
+ yy_destroy_ ("Cleanup: discarding lookahead", yyla);
/* Do not reclaim the symbols of the rule which action triggered
this YYABORT or YYACCEPT. */
yypop_ (yylen);
while (yystack_.size () != 1)
{
- yydestruct_ ("Cleanup: popping",
- yystos_[yystack_[0].state],
- yystack_[0].value, yystack_[0].location);
+ yy_destroy_ ("Cleanup: popping", yystack_[0]);
yypop_ ();
}
/* The symbols being reduced. */
for (int yyi = 0; yyi < yynrhs; yyi++)
YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
- ]yystos_@{b4_rhs_state(yynrhs, yyi + 1)@}[,
- ]b4_rhs_value(yynrhs, yyi + 1)[,
- ]b4_rhs_location(yynrhs, yyi + 1)[);
+ ]b4_rhs_data(yynrhs, yyi + 1)[);
}
#endif // YYDEBUG
projects / bison.git / blobdiff