# b4_parse_param_decl
# -------------------
-# Constructor's extra arguments.
+# Extra formal arguments of the constructor.
+# Change the parameter names from "foo" into "foo_yyarg", so that
+# there is no collision bw the user chosen attribute name, and the
+# argument name in the constructor.
m4_define([b4_parse_param_decl],
- [m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])
+[m4_ifset([b4_parse_param],
+ [, m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
+
+m4_define([b4_parse_param_decl_1],
+[$1_yyarg])
+
+
# b4_parse_param_cons
# -------------------
-# constructor's extra initialisations.
+# Extra initialisations of the constructor.
m4_define([b4_parse_param_cons],
[m4_ifset([b4_parse_param],
[,
[m4_map_sep([b4_cc_constructor_call], [,
], [$@])])
m4_define([b4_cc_constructor_call],
- [$2($2)])
+ [$2 ($2_yyarg)])
# b4_parse_param_vars
# -------------------
-# Extra instance variables.
+# Extra instance variables.
m4_define([b4_parse_param_vars],
[m4_ifset([b4_parse_param],
[
]/* Line __line__ of lalr1.cc. */
b4_syncline([@oline@], [@ofile@])[
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. */
+
#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N) \
- ((Current).end = Rhs[N].end)
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+do { \
+ ((Current).begin = (Rhs)[1].begin); \
+ ((Current).end = (Rhs)[N].end); \
+} while (0)
#endif
namespace yy
typedef Stack< SemanticType > SemanticStack;
typedef Stack< LocationType > LocationStack;
-#if YYLSP_NEEDED
- ]b4_parser_class_name[ (bool debug,
- LocationType initlocation][]b4_param[]b4_parse_param_decl[) :
- ]b4_constructor[][debug_ (debug),
- cdebug_ (std::cerr),
- initlocation_ (initlocation)]b4_parse_param_cons[
-#else
]b4_parser_class_name[ (bool debug][]b4_param[]b4_parse_param_decl[) :
]b4_constructor[][debug_ (debug),
cdebug_ (std::cerr)]b4_parse_param_cons[
-#endif
{
}
int yytype,
SemanticType *yyvaluep, LocationType *yylocationp);
+ /// Pop \a n symbols the three stacks.
+ inline void pop (unsigned int n = 1);
+
/* Constants. */
static const int eof_;
/* LAST_ -- Last index in TABLE_. */
/* Message. */
std::string message;
- /* Semantic value and location of look-ahead token. */
+ /// Semantic value of the look-ahead.
SemanticType value;
+ /// Location of the look-ahead.
LocationType location;
- /* Beginning of the last erroneous token popped off. */
- Position error_start_;
+ /// The locations where the error started and ended.
+ Location error_range_[2];
- /* @@$ and $$. */
+ /// $$.
SemanticType yyval;
+ /// @@$.
LocationType yyloc;
-
- /* Initial location. */
- LocationType initlocation_;
]b4_parse_param_vars[
};
}
(void) yylocationp;
cdebug_ << (yytype < ntokens_ ? "token" : "nterm")
- << ' ' << name_[yytype] << " (";
+ << ' ' << name_[yytype] << " ("
+ << *yylocationp << ": ";
switch (yytype)
{
]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
(void) yyvaluep;
(void) yylocationp;
- if (!yymsg)
- yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
switch (yytype)
}
}
+void
+yy::]b4_parser_class_name[::pop (unsigned int n)
+{
+ state_stack_.pop (n);
+ semantic_stack_.pop (n);
+ location_stack_.pop (n);
+}
+
int
yy::]b4_parser_class_name[::parse ()
{
+ YYCDEBUG << "Starting parse" << std::endl;
+
nerrs_ = 0;
errstatus_ = 0;
- /* Initialize the stacks. The initial state will be pushed in
+ /* Start. */
+ state_ = 0;
+ looka_ = empty_;
+
+]m4_ifdef([b4_initial_action], [
+m4_pushdef([b4_at_dollar], [location])dnl
+m4_pushdef([b4_dollar_dollar], [value])dnl
+ /* User initialization code. */
+ b4_initial_action
+m4_popdef([b4_dollar_dollar])dnl
+m4_popdef([b4_at_dollar])dnl
+/* Line __line__ of yacc.c. */
+b4_syncline([@oline@], [@ofile@])])dnl
+
+[ /* Initialize the stacks. The initial state will be pushed in
yynewstate, since the latter expects the semantical and the
location values to have been already stored, initialize these
stacks with a primary value. */
state_stack_ = StateStack (0);
- semantic_stack_ = SemanticStack (1);
- location_stack_ = LocationStack (1);
-
- /* Start. */
- state_ = 0;
- looka_ = empty_;
-#if YYLSP_NEEDED
- location = initlocation_;
-#endif
- YYCDEBUG << "Starting parse" << std::endl;
+ semantic_stack_ = SemanticStack (0);
+ location_stack_ = LocationStack (0);
+ semantic_stack_.push (value);
+ location_stack_.push (location);
/* New state. */
- yynewstate:
+yynewstate:
state_stack_.push (state_);
YYCDEBUG << "Entering state " << state_ << std::endl;
goto yybackup;
/* Backup. */
- yybackup:
+yybackup:
/* Try to take a decision without look-ahead. */
n_ = pact_[state_];
goto yyacceptlab;
/* Shift the look-ahead token. */
-#if YYDEBUG
- YYCDEBUG << "Shifting token " << looka_
- << " (" << name_[ilooka_] << "), ";
-#endif
+ YY_SYMBOL_PRINT ("Shifting", ilooka_, &value, &location);
/* Discard the token being shifted unless it is eof. */
if (looka_ != eof_)
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
- yydefault:
+yydefault:
n_ = defact_[state_];
if (n_ == 0)
goto yyerrlab;
/*-----------------------------.
| yyreduce -- Do a reduction. |
`-----------------------------*/
- yyreduce:
+yyreduce:
len_ = r2_[n_];
/* If LEN_ is nonzero, implement the default value of the action:
`$$ = $1'. Otherwise, use the top of the stack.
]/* Line __line__ of lalr1.cc. */
b4_syncline([@oline@], [@ofile@])[
- state_stack_.pop (len_);
- semantic_stack_.pop (len_);
- location_stack_.pop (len_);
+ pop (len_);
YY_STACK_PRINT ();
/* If not already recovering from an error, report this error. */
report_syntax_error_ ();
- error_start_ = location.begin;
+ error_range_[0] = location;
if (errstatus_ == 3)
{
/* If just tried and failed to reuse look-ahead token after an
if (looka_ == eof_)
for (;;)
{
- error_start_ = location_stack_[0].begin;
- state_stack_.pop ();
- semantic_stack_.pop ();
- location_stack_.pop ();
+ error_range_[0] = location_stack_[0];
+ pop ();
if (state_stack_.height () == 1)
YYABORT;
destruct_ ("Error: popping",
goto yyerrorlab;
#endif
- state_stack_.pop (len_);
- semantic_stack_.pop (len_);
- error_start_ = location_stack_[len_ - 1].begin;
- location_stack_.pop (len_);
+ error_range_[0] = location_stack_[len_ - 1];
+ pop (len_);
state_ = state_stack_[0];
goto yyerrlab1;
if (state_stack_.height () == 1)
YYABORT;
+ error_range_[0] = location_stack_[0];
destruct_ ("Error: popping",
stos_[state_], &semantic_stack_[0], &location_stack_[0]);
- error_start_ = location_stack_[0].begin;
-
- state_stack_.pop ();
- semantic_stack_.pop ();
- location_stack_.pop ();
+ pop ();
state_ = state_stack_[0];
YY_STACK_PRINT ();
}
if (n_ == final_)
goto yyacceptlab;
- YYCDEBUG << "Shifting error token, ";
+ error_range_[1] = location;
+ // Using LOCATION is tempting, but would change the location of
+ // the look-ahead. YYLOC is available though.
+ YYLLOC_DEFAULT (yyloc, error_range_ - 1, 2);
+ semantic_stack_.push (value);
+ location_stack_.push (yyloc);
- {
- Location errloc;
- errloc.begin = error_start_;
- errloc.end = location.end;
- semantic_stack_.push (value);
- location_stack_.push (errloc);
- }
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", stos_[n_],
+ &semantic_stack_[0], &location_stack_[0]);
state_ = n_;
goto yynewstate;
void
yy::]b4_parser_class_name[::stack_print_ ()
{
- cdebug_ << "state stack now";
- for (StateStack::ConstIterator i = state_stack_.begin ();
+ cdebug_ << "Stack now";
+ for (StateStack::const_iterator i = state_stack_.begin ();
i != state_stack_.end (); ++i)
cdebug_ << ' ' << *i;
cdebug_ << std::endl;
{
unsigned int yylno = rline_[yyrule];
/* Print the symbols being reduced, and their result. */
- cdebug_ << "Reducing via rule " << n_ - 1 << " (line " << yylno << "), ";
+ cdebug_ << "Reducing stack by rule " << n_ - 1 << " (line " << yylno << "), ";
for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
0 <= rhs_[i]; ++i)
cdebug_ << name_[rhs_[i]] << ' ';
{
public:
- typedef typename S::iterator Iterator;
- typedef typename S::const_iterator ConstIterator;
+ // Hide our reversed order.
+ typedef typename S::reverse_iterator iterator;
+ typedef typename S::const_reverse_iterator const_iterator;
Stack () : seq_ ()
{
return seq_.size ();
}
- inline ConstIterator begin () const { return seq_.begin (); }
- inline ConstIterator end () const { return seq_.end (); }
+ inline const_iterator begin () const { return seq_.rbegin (); }
+ inline const_iterator end () const { return seq_.rend (); }
private:
projects / bison.git / blobdiff