m4_divert(-1)
+
# C++ skeleton for Bison
-# Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+
+# Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-# 02111-1307 USA
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301 USA
## ---------------- ##
## Default values. ##
m4_if(b4_defines_flag, 0, [],
[@output @output_header_name@
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
- [2002, 2003, 2004])[
+ [2002, 2003, 2004, 2005])[
/* FIXME: This is wrong, we want computed header guards.
I don't know why the macros are missing now. :( */
#ifndef PARSER_HEADER_H
/// A Bison parser.
class ]b4_parser_class_name[
{
- public:
- /// Internal symbol numbers.
- typedef traits<]b4_parser_class_name[>::token_number_type token_number_type;
- /// A type to store symbol numbers and -1.
- typedef traits<]b4_parser_class_name[>::rhs_number_type rhs_number_type;
- /// State numbers.
- typedef traits<]b4_parser_class_name[>::state_type state_type;
/// Symbol semantic values.
- typedef traits<]b4_parser_class_name[>::semantic_type semantic_type;
+ typedef traits<]b4_parser_class_name[>::semantic_type semantic_type;
/// Symbol locations.
- typedef traits<]b4_parser_class_name[>::location_type location_type;
-
- /// State stack type.
- typedef stack<state_type> state_stack;
- /// Semantic value stack type.
- typedef stack<semantic_type> semantic_stack;
- /// location stack type.
- typedef stack<location_type> location_stack;
+ typedef traits<]b4_parser_class_name[>::location_type location_type;
+ public:
/// Build a parser object.
]b4_parser_class_name[ (]b4_parse_param_decl[) :
yydebug_ (false),
#endif /* ! YYDEBUG */
+ /// State numbers.
+ typedef traits<]b4_parser_class_name[>::state_type state_type;
+ /// State stack type.
+ typedef stack<state_type> state_stack_type;
+ /// Semantic value stack type.
+ typedef stack<semantic_type> semantic_stack_type;
+ /// location stack type.
+ typedef stack<location_type> location_stack_type;
+
/// The state stack.
- state_stack yystate_stack_;
+ state_stack_type yystate_stack_;
/// The semantic value stack.
- semantic_stack yysemantic_stack_;
+ semantic_stack_type yysemantic_stack_;
/// The location stack.
- location_stack yylocation_stack_;
+ location_stack_type yylocation_stack_;
+ /// Internal symbol numbers.
+ typedef traits<]b4_parser_class_name[>::token_number_type token_number_type;
/* Tables. */
/// For a state, the index in \a yytable_ of its portion.
static const ]b4_int_type_for([b4_pact])[ yypact_[];
#endif
#if YYDEBUG
+ /// A type to store symbol numbers and -1.
+ typedef traits<]b4_parser_class_name[>::rhs_number_type rhs_number_type;
/// A `-1'-separated list of the rules' RHS.
static const rhs_number_type yyrhs_[];
/// For each rule, the index of the first RHS symbol in \a yyrhs_.
])dnl
@output @output_parser_name@
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
- [2002, 2003, 2004])
+ [2002, 2003, 2004, 2005])
m4_if(b4_prefix[], [yy], [],
[
// Take the name prefix into account.
[
#include @output_header_name@])[
+/* INFRINGES ON USER NAME SPACE */
+#ifndef _
+# define _(msgid) msgid
+#endif
+
/* A pseudo ostream that takes yydebug_ into account. */
# define YYCDEBUG \
for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false) \
int yytype, semantic_type* yyvaluep, location_type* yylocationp)
{
/* Pacify ``unused variable'' warnings. */
+ (void) yymsg;
(void) yyvaluep;
(void) yylocationp;
int
yy::]b4_parser_class_name[::parse ()
{
- YYCDEBUG << "Starting parse" << std::endl;
+ int yyresult_;
+
+ YYCDEBUG << _("Starting parse") << std::endl;
yynerrs_ = 0;
yyerrstatus_ = 0;
yynewstate, since the latter expects the semantical and the
location values to have been already stored, initialize these
stacks with a primary value. */
- yystate_stack_ = state_stack (0);
- yysemantic_stack_ = semantic_stack (0);
- yylocation_stack_ = location_stack (0);
+ yystate_stack_ = state_stack_type (0);
+ yysemantic_stack_ = semantic_stack_type (0);
+ yylocation_stack_ = location_stack_type (0);
yysemantic_stack_.push (yylval);
yylocation_stack_.push (yylloc);
/* New state. */
yynewstate:
yystate_stack_.push (yystate_);
- YYCDEBUG << "Entering state " << yystate_ << std::endl;
+ YYCDEBUG << _("Entering state ") << yystate_ << std::endl;
goto yybackup;
/* Backup. */
if (yylooka_ <= yyeof_)
{
yylooka_ = yyilooka_ = yyeof_;
- YYCDEBUG << "Now at end of input." << std::endl;
+ YYCDEBUG << _("Now at end of input.") << std::endl;
}
else
{
yyilooka_ = yytranslate_ (yylooka_);
- YY_SYMBOL_PRINT ("Next token is", yyilooka_, &yylval, &yylloc);
+ YY_SYMBOL_PRINT (_("Next token is"), yyilooka_, &yylval, &yylloc);
}
/* If the proper action on seeing token ILOOKA_ is to reduce or to
goto yyacceptlab;
/* Shift the look-ahead token. */
- YY_SYMBOL_PRINT ("Shifting", yyilooka_, &yylval, &yylloc);
+ YY_SYMBOL_PRINT (_("Shifting"), yyilooka_, &yylval, &yylloc);
/* Discard the token being shifted unless it is eof. */
if (yylooka_ != yyeof_)
yyval = yysemantic_stack_[0];
{
- slice<location_type, location_stack> slice (yylocation_stack_, yylen_);
+ slice<location_type, location_stack_type> slice (yylocation_stack_, yylen_);
YYLLOC_DEFAULT (yyloc, slice, yylen_);
}
YY_REDUCE_PRINT (yyn_);
switch (yyn_)
{
]b4_actions[
+ default: break;
}
]/* Line __line__ of lalr1.cc. */
yypop_ ();
if (yystate_stack_.height () == 1)
YYABORT;
- yydestruct_ ("Error: popping",
+ yydestruct_ (_("Error: popping"),
yystos_[yystate_stack_[0]],
&yysemantic_stack_[0],
&yylocation_stack_[0]);
}
else
{
- yydestruct_ ("Error: discarding", yyilooka_, &yylval, &yylloc);
+ yydestruct_ (_("Error: discarding"), yyilooka_, &yylval, &yylloc);
yylooka_ = yyempty_;
}
}
`---------------------------------------------------*/
yyerrorlab:
-#ifdef __GNUC__
- /* Pacify GCC when the user code never invokes YYERROR and the label
- yyerrorlab therefore never appears in user code. */
- if (0)
+ /* Pacify compilers like GCC when the user code never invokes
+ YYERROR and the label yyerrorlab therefore never appears in user
+ code. */
+ if (false)
goto yyerrorlab;
-#endif
yyerror_range_[0] = yylocation_stack_[yylen_ - 1];
yypop_ (yylen_);
YYABORT;
yyerror_range_[0] = yylocation_stack_[0];
- yydestruct_ ("Error: popping",
+ yydestruct_ (_("Error: popping"),
yystos_[yystate_],
&yysemantic_stack_[0], &yylocation_stack_[0]);
yypop_ ();
yylocation_stack_.push (yyloc);
/* Shift the error token. */
- YY_SYMBOL_PRINT ("Shifting", yystos_[yyn_],
+ YY_SYMBOL_PRINT (_("Shifting"), yystos_[yyn_],
&yysemantic_stack_[0], &yylocation_stack_[0]);
yystate_ = yyn_;
/* Accept. */
yyacceptlab:
- return 0;
+ yyresult_ = 0;
+ goto yyreturn;
/* Abort. */
yyabortlab:
- /* Free the lookahead. */
- yydestruct_ ("Error: discarding lookahead", yyilooka_, &yylval, &yylloc);
- yylooka_ = yyempty_;
- return 1;
+ yyresult_ = 1;
+ goto yyreturn;
+
+yyreturn:
+ if (yylooka_ != yyeof_ && yylooka_ != yyempty_)
+ yydestruct_ (_("Error: discarding lookahead"), yyilooka_, &yylval, &yylloc);
+ return yyresult_;
}
void
yy::]b4_parser_class_name[::yylex_ ()
{
- YYCDEBUG << "Reading a token: ";
+ YYCDEBUG << _("Reading a token: ");
#if YYLSP_NEEDED
yylooka_ = yylex (&yylval, &yylloc);
#else
if (yycheck_[x + yyn_] == x && x != yyterror_)
++count;
- message = "syntax error, unexpected ";
+ message = _("syntax error, unexpected ");
message += yyname_[yyilooka_];
if (count < 5)
{
for (int x = yyxbegin; x < yyxend; ++x)
if (yycheck_[x + yyn_] == x && x != yyterror_)
{
- message += (!count++) ? ", expecting " : " or ";
+ message += (!count++) ? _(", expecting ") : _(" or ");
message += yyname_[x];
}
}
}
else
#endif
- message = "syntax error";
+ message = _("syntax error");
error (yylloc, message);
}
}
void
yy::]b4_parser_class_name[::yystack_print_ ()
{
- *yycdebug_ << "Stack now";
- for (state_stack::const_iterator i = yystate_stack_.begin ();
+ *yycdebug_ << _("Stack now");
+ for (state_stack_type::const_iterator i = yystate_stack_.begin ();
i != yystate_stack_.end (); ++i)
*yycdebug_ << ' ' << *i;
*yycdebug_ << std::endl;
{
unsigned int yylno = yyrline_[yyrule];
/* Print the symbols being reduced, and their result. */
- *yycdebug_ << "Reducing stack by rule " << yyn_ - 1
- << " (line " << yylno << "), ";
+ *yycdebug_ << _("Reducing stack by rule ") << yyn_ - 1
+ << " (" << _("line") << ' ' << yylno << "), ";
for (]b4_int_type_for([b4_prhs])[ i = yyprhs_[yyn_];
0 <= yyrhs_[i]; ++i)
*yycdebug_ << yyname_[yyrhs_[i]] << ' ';
]b4_epilogue
dnl
@output stack.hh
-b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004])[
+b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004, 2005])[
#ifndef BISON_STACK_HH
# define BISON_STACK_HH
S seq_;
};
+ /// Present a slice of the top of a stack.
template <class T, class S = stack<T> >
class slice
{
#endif // not BISON_STACK_HH]
dnl
@output position.hh
-b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004])[
+b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
/**
** \file position.hh
}
#endif // not BISON_POSITION_HH]
@output location.hh
-b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004])[
+b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
/**
** \file location.hh
** \{ */
public:
/// Construct a location.
- location (void) :
+ location () :
begin (),
end ()
{
** \{ */
public:
/// Reset initial location to final location.
- inline void step (void)
+ inline void step ()
{
begin = end;
}
projects / bison.git / blobdiff