Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-19 09:13:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introduce a hierarchy for symbols.

Browse Source 
* data/lalr1.cc (symbol_base_type, symbol_type): New.
	(data_type): Rename as...
	(stack_symbol_type): this.
	Derive from symbol_base_type.
	(yy_symbol_value_print_): Merge into...
	(yy_symbol_print_): this.
	Rename as...
	(yy_print_): this.
	(yydestruct_): Rename as...
	(yy_destroy_): this.
	(b4_symbols_actions, YY_SYMBOL_PRINT): Adjust.
	(parser::parse): yyla is now of symbol_type.
	Use its type member instead of yytoken.
This commit is contained in:
Akim Demaille
2008-08-02 21:42:48 +02:00
parent bc0b0477e2
commit 1f7d007bf6
2 changed files with 192 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
ChangeLog
View File

@@ -1,3 +1,20 @@
2008-11-09 Akim Demaille <demaille@gostai.com>
Introduce a hierarchy for symbols.
* data/lalr1.cc (symbol_base_type, symbol_type): New.
(data_type): Rename as...
(stack_symbol_type): this.
Derive from symbol_base_type.
(yy_symbol_value_print_): Merge into...
(yy_symbol_print_): this.
Rename as...
(yy_print_): this.
(yydestruct_): Rename as...
(yy_destroy_): this.
(b4_symbols_actions, YY_SYMBOL_PRINT): Adjust.
(parser::parse): yyla is now of symbol_type.
Use its type member instead of yytoken.
2008-11-09 Akim Demaille <demaille@gostai.com> 2008-11-09 Akim Demaille <demaille@gostai.com>
Rename data_type and stack_symbol_type. Rename data_type and stack_symbol_type.

286
data/lalr1.cc
View File

@@ -99,8 +99,8 @@ m4_define([b4_rhs_location],
# Same as in C, but using references instead of pointers. # Same as in C, but using references instead of pointers.
m4_define([b4_symbol_actions], m4_define([b4_symbol_actions],
[m4_pushdef([b4_dollar_dollar], [m4_pushdef([b4_dollar_dollar],
[b4_symbol_value([yydata.value], [$6])])dnl [b4_symbol_value([yysym.value], [$6])])dnl
m4_pushdef([b4_at_dollar], [yydata.location])dnl m4_pushdef([b4_at_dollar], [yysym.location])dnl
case $4: // $3 case $4: // $3
b4_syncline([$2], [$1]) b4_syncline([$2], [$1])
$5; $5;
@@ -458,8 +458,57 @@ m4_ifdef([b4_stype],
/// Convert a scanner token number \a t to a symbol number. /// Convert a scanner token number \a t to a symbol number.
token_number_type yytranslate_ (int t); token_number_type yytranslate_ (int t);
/// A complete symbol, with its type.
struct symbol_base_type
{
/// Default constructor.
symbol_base_type ();
/// Constructor.
symbol_base_type (const semantic_type& v, const location_type& l);
/// Return the type of this symbol.
virtual int type_get () const = 0;
/// The semantic value.
semantic_type value;
/// The location.
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.
void yy_destroy_ (const char* yymsg, symbol_base_type& yysym) const;
/// Element of the stack: a state and its attributes. /// Element of the stack: a state and its attributes.
struct stack_symbol_type struct symbol_type : symbol_base_type
{
/// Default constructor.
symbol_type ();
/// Constructor.
symbol_type (state_type s,
const semantic_type& v, const location_type& l);
/// The symbol type.
int type;
/// Return the type corresponding to this state.
virtual int type_get () const;
};
/// Element of the stack: a state and its attributes.
struct stack_symbol_type : symbol_base_type
{ {
/// Default constructor. /// Default constructor.
stack_symbol_type (); stack_symbol_type ();
@@ -471,40 +520,10 @@ m4_ifdef([b4_stype],
/// The state. /// The state.
state_type state; state_type state;
/// The semantic value. /// Return the type corresponding to this state.
semantic_type value; virtual int type_get () const;
/// The location.
location_type location;
}; };
#if YYDEBUG
/// \brief Report a symbol value on the debug stream as per %printer.
/// \param yytype The token type.
/// \param yydata Its semantic value and location.
virtual void yy_symbol_value_print_ (int yytype,
const stack_symbol_type& yydata);
/// \brief Report a symbol on the debug stream.
/// \param yytype The token type.
/// \param yydata Its semantic value and location.
virtual void yy_symbol_print_ (int yytype,
const stack_symbol_type& yydata);
#endif
/// \brief Reclaim the memory associated to a lookahead symbol.
/// \param yymsg Why this token is reclaimed.
/// If null, print nothing.
/// \param yytype The symbol type.
/// \param yydata Its semantic value and location.
inline void yydestruct_ (const char* yymsg,
int yytype, stack_symbol_type& yydata);
/// \brief Reclaim the memory associated to a stack symbol.
/// \param yymsg Why this token is reclaimed.
/// If null, print nothing.
/// \param yysym Its kind, semantic value and location.
inline void yydestruct_ (const char* yymsg, stack_symbol_type& yysym);
/// Stack type. /// Stack type.
typedef stack<stack_symbol_type> stack_type; typedef stack<stack_symbol_type> stack_type;
@@ -518,6 +537,14 @@ m4_ifdef([b4_stype],
/// \warning the contents of \a s.value is stolen. /// \warning the contents of \a s.value is stolen.
inline void yypush_ (const char* m, stack_symbol_type& s); 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. /// Pop \a n symbols the three stacks.
inline void yypop_ (unsigned int n = 1); inline void yypop_ (unsigned int n = 1);
@@ -535,6 +562,7 @@ m4_ifdef([b4_stype],
static const token_number_type yyundef_token_; static const token_number_type yyundef_token_;
]b4_parse_param_vars[ ]b4_parse_param_vars[
}; };
]b4_namespace_close[ ]b4_namespace_close[
]b4_percent_define_flag_if([[global_tokens_and_yystype]], ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
@@ -588,12 +616,12 @@ b4_percent_code_get[]dnl
/* A pseudo ostream that takes yydebug_ into account. */ /* A pseudo ostream that takes yydebug_ into account. */
# define YYCDEBUG if (yydebug_) (*yycdebug_) # define YYCDEBUG if (yydebug_) (*yycdebug_)
# define YY_SYMBOL_PRINT(Title, Type, Data) \ # define YY_SYMBOL_PRINT(Title, Symbol) \
do { \ do { \
if (yydebug_) \ if (yydebug_) \
{ \ { \
*yycdebug_ << Title << ' '; \ *yycdebug_ << Title << ' '; \
yy_symbol_print_ ((Type), (Data)); \ yy_print_ (*yycdebug_, Symbol); \
*yycdebug_ << std::endl; \ *yycdebug_ << std::endl; \
} \ } \
} while (false) } while (false)
@@ -613,9 +641,9 @@ b4_percent_code_get[]dnl
#else /* !YYDEBUG */ #else /* !YYDEBUG */
# define YYCDEBUG if (false) std::cerr # define YYCDEBUG if (false) std::cerr
# define YY_SYMBOL_PRINT(Title, Type, Data) 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_REDUCE_PRINT(Rule) static_cast<void>(0)
# define YY_STACK_PRINT() static_cast<void>(0) # define YY_STACK_PRINT() static_cast<void>(0)
#endif /* !YYDEBUG */ #endif /* !YYDEBUG */
@@ -683,51 +711,73 @@ b4_percent_code_get[]dnl
{ {
} }
#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
inline void /*---------------.
]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, | Symbol types. |
const stack_symbol_type& yydata) `---------------*/
// symbol_base_type.
]b4_parser_class_name[::symbol_base_type::symbol_base_type ()
: value()
, location()
{ {
switch (yytype) }
{
]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl ]b4_parser_class_name[::symbol_base_type::symbol_base_type (const semantic_type& v, const location_type& l)
[ default:
break; : value(v)
} , location(l)
{
}
// 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 void
]b4_parser_class_name[::yy_symbol_print_ (int yytype, ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, symbol_base_type& yysym) const
const stack_symbol_type& yydata)
{
*yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
<< ' ' << yytname_[yytype] << " ("
<< yydata.location << ": ";
yy_symbol_value_print_ (yytype, yydata);
*yycdebug_ << ')';
}
#endif
void
]b4_parser_class_name[::yydestruct_ (const char* yymsg,
stack_symbol_type& yysym)
{
yydestruct_ (yymsg, yystos_[yysym.state], yysym);
}
void
]b4_parser_class_name[::yydestruct_ (const char* yymsg,
int yytype, stack_symbol_type& yydata)
{ {
int yytype = yysym.type_get ();
YYUSE (yymsg); YYUSE (yymsg);
if (yymsg) if (yymsg)
YY_SYMBOL_PRINT (yymsg, yytype, yydata); YY_SYMBOL_PRINT (yymsg, yysym);
// User destructor. // User destructor.
switch (yytype) switch (yytype)
@@ -738,32 +788,48 @@ b4_percent_code_get[]dnl
}]b4_variant_if([ }]b4_variant_if([
// Type destructor. // Type destructor.
b4_symbol_variant([[yytype]], [[yydata.value]], [[destroy]])])[ b4_symbol_variant([[yytype]], [[yysym.value]], [[destroy]])])[
} }
]b4_parser_class_name[::stack_symbol_type::stack_symbol_type () #if YYDEBUG
: state() void
, value() ]b4_parser_class_name[::yy_print_ (std::ostream& yyo, const symbol_base_type& yysym) const
, location()
{ {
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[::stack_symbol_type::stack_symbol_type (state_type s, void
const semantic_type& v, const location_type& l) ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
: state(s) symbol_type& sym)
, value(v)
, location(l)
{ {
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 void
]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s) ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
{ {
if (m) if (m)
YY_SYMBOL_PRINT (m, yystos_[s.state], s); YY_SYMBOL_PRINT (m, s);
]b4_variant_if( ]b4_variant_if(
[[ yystack_.push (stack_symbol_type (s, semantic_type(), l)); [[ yystack_.push (stack_symbol_type (s.state, semantic_type(), s.location));
]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]], ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
[build], [s.value])], [build], [s.value])],
[ yystack_.push (s);])[ [ yystack_.push (s);])[
} }
@@ -804,9 +870,8 @@ b4_percent_code_get[]dnl
int int
]b4_parser_class_name[::parse () ]b4_parser_class_name[::parse ()
{ {
/// Lookahead and lookahead in internal form. /// Coded type of the lookahead.
int yychar = yyempty_; int yychar = yyempty_;
int yytoken = 0;
/* State. */ /* State. */
int yyn; int yyn;
@@ -818,7 +883,7 @@ b4_percent_code_get[]dnl
int yyerrstatus_ = 0; int yyerrstatus_ = 0;
/// The lookahead symbol. /// The lookahead symbol.
stack_symbol_type yyla; symbol_type yyla;
/// The locations where the error started and ended. /// The locations where the error started and ended.
stack_symbol_type yyerror_range[2]; stack_symbol_type yyerror_range[2];
@@ -844,7 +909,7 @@ m4_popdef([b4_at_dollar])])dnl
location values to have been already stored, initialize these location values to have been already stored, initialize these
stacks with a primary value. */ stacks with a primary value. */
yystack_ = stack_type (0); yystack_ = stack_type (0);
yypush_ (0, yyla); yypush_ (0, 0, yyla);
// A new state was pushed on the stack. // A new state was pushed on the stack.
// Invariant: yystate == yystack_[0].state, i.e., // Invariant: yystate == yystack_[0].state, i.e.,
@@ -880,19 +945,19 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
/* Convert token to internal form. */ /* Convert token to internal form. */
if (yychar <= yyeof_) if (yychar <= yyeof_)
{ {
yychar = yytoken = yyeof_; yychar = yyla.type = yyeof_;
YYCDEBUG << "Now at end of input." << std::endl; YYCDEBUG << "Now at end of input." << std::endl;
} }
else else
{ {
yytoken = yytranslate_ (yychar); yyla.type = yytranslate_ (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, yyla); YY_SYMBOL_PRINT ("Next token is", yyla);
} }
/* If the proper action on seeing token YYTOKEN is to reduce or to /* If the proper action on seeing token YYLA.TYPE is to reduce or
detect an error, take that action. */ to detect an error, take that action. */
yyn += yytoken; yyn += yyla.type;
if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
goto yydefault; goto yydefault;
/* Reduce or error. */ /* Reduce or error. */
@@ -914,8 +979,8 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
--yyerrstatus_; --yyerrstatus_;
/* Shift the lookahead token. */ /* Shift the lookahead token. */
yyla.state = yystate = yyn; yystate = yyn;
yypush_ ("Shifting", yyla); yypush_ ("Shifting", yystate, yyla);
goto yynewstate; goto yynewstate;
/*-----------------------------------------------------------. /*-----------------------------------------------------------.
@@ -970,7 +1035,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
else else
yystate = yydefgoto_[yyn - yyntokens_]; yystate = yydefgoto_[yyn - yyntokens_];
yylhs.state = yystate; yylhs.state = yystate;
YY_SYMBOL_PRINT ("-> $$ =", yyn, yylhs); YY_SYMBOL_PRINT ("-> $$ =", yylhs);
]b4_variant_if([[ ]b4_variant_if([[
// Destroy the lhs symbols. // Destroy the lhs symbols.
for (int i = 0; i < yylen; ++i) for (int i = 0; i < yylen; ++i)
@@ -982,7 +1047,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
// do not try to report the content in the debug trace, it's // do not try to report the content in the debug trace, it's
// junk. Hence yymsg = 0. Besides, that keeps exactly the same // junk. Hence yymsg = 0. Besides, that keeps exactly the same
// traces as with the other Bison skeletons. // traces as with the other Bison skeletons.
yydestruct_ (0, yystack_[i]);]])[ yy_destroy_ (0, yystack_[i]);]])[
yypop_ (yylen); yypop_ (yylen);
yylen = 0; yylen = 0;
@@ -1000,7 +1065,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
if (!yyerrstatus_) if (!yyerrstatus_)
{ {
++yynerrs_; ++yynerrs_;
error (yyla.location, yysyntax_error_ (yystate, yytoken)); error (yyla.location, yysyntax_error_ (yystate, yyla.type));
} }
yyerror_range[0].location = yyla.location; yyerror_range[0].location = yyla.location;
@@ -1017,7 +1082,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
} }
else else
{ {
yydestruct_ ("Error: discarding", yytoken, yyla); yy_destroy_ ("Error: discarding", yyla);
yychar = yyempty_; yychar = yyempty_;
} }
} }
@@ -1072,7 +1137,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
YYABORT; YYABORT;
yyerror_range[0].location = yystack_[0].location; yyerror_range[0].location = yystack_[0].location;
yydestruct_ ("Error: popping", yystack_[0]); yy_destroy_ ("Error: popping", yystack_[0]);
yypop_ (); yypop_ ();
yystate = yystack_[0].state; yystate = yystack_[0].state;
YY_STACK_PRINT (); YY_STACK_PRINT ();
@@ -1099,14 +1164,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
yyreturn: yyreturn:
if (yychar != yyempty_) if (yychar != yyempty_)
yydestruct_ ("Cleanup: discarding lookahead", yytoken, yyla); yy_destroy_ ("Cleanup: discarding lookahead", yyla);
/* Do not reclaim the symbols of the rule which action triggered /* Do not reclaim the symbols of the rule which action triggered
this YYABORT or YYACCEPT. */ this YYABORT or YYACCEPT. */
yypop_ (yylen); yypop_ (yylen);
while (yystack_.size () != 1) while (yystack_.size () != 1)
{ {
yydestruct_ ("Cleanup: popping", yystack_[0]); yy_destroy_ ("Cleanup: popping", yystack_[0]);
yypop_ (); yypop_ ();
} }
@@ -1244,8 +1309,7 @@ b4_error_verbose_if([ tok])[)
/* The symbols being reduced. */ /* The symbols being reduced. */
for (int yyi = 0; yyi < yynrhs; yyi++) for (int yyi = 0; yyi < yynrhs; yyi++)
YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
]yystos_@{b4_rhs_state(yynrhs, yyi + 1)@}[, ]b4_rhs_data(yynrhs, yyi + 1)[);
]b4_rhs_data(yynrhs, yyi + 1)[);
} }
#endif // YYDEBUG #endif // YYDEBUG