# 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],
[
m4_define([b4_cc_var_decl],
[ $1;])
-# b4_cxx_destruct_def(IGNORED-ARGUMENTS)
-# --------------------------------------
-# Declare the destruct_ method.
-m4_define([b4_cxx_destruct_def],
-[void
-yy::b4_parser_class_name::destruct_ (int yytype, SemanticType *yyvaluep, LocationType *yylocationp)[]dnl
-])
+
# We do want M4 expansion after # for CPP macros.
m4_changecom()
# define YYERROR_VERBOSE ]b4_error_verbose[
#endif
-#ifndef YYSTYPE
+#ifdef YYSTYPE
+typedef YYSTYPE yystype;
+#else
]m4_ifdef([b4_stype],
[b4_syncline([b4_stype_line], [b4_filename])
typedef union b4_stype yystype;
]/* 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
{
class ]b4_parser_class_name[;
- template < typename P >
+ template <typename P>
struct Traits
{
};
- template < >
- struct Traits< ]b4_parser_class_name[ >
+ template <>
+ struct Traits<]b4_parser_class_name[>
{
typedef ]b4_int_type_for([b4_translate])[ TokenNumberType;
typedef ]b4_int_type_for([b4_rhs])[ RhsNumberType;
- typedef int StateType;
- typedef yystype SemanticType;
+ typedef int StateType;
+ typedef yystype SemanticType;
typedef ]b4_location_type[ LocationType;
};
}
{
public:
- typedef Traits< ]b4_parser_class_name[ >::TokenNumberType TokenNumberType;
- typedef Traits< ]b4_parser_class_name[ >::RhsNumberType RhsNumberType;
- typedef Traits< ]b4_parser_class_name[ >::StateType StateType;
- typedef Traits< ]b4_parser_class_name[ >::SemanticType SemanticType;
- typedef Traits< ]b4_parser_class_name[ >::LocationType LocationType;
+ typedef Traits<]b4_parser_class_name[>::TokenNumberType TokenNumberType;
+ typedef Traits<]b4_parser_class_name[>::RhsNumberType RhsNumberType;
+ typedef Traits<]b4_parser_class_name[>::StateType StateType;
+ typedef Traits<]b4_parser_class_name[>::SemanticType SemanticType;
+ typedef Traits<]b4_parser_class_name[>::LocationType LocationType;
- typedef Stack< StateType > StateStack;
- typedef Stack< SemanticType > SemanticStack;
- typedef Stack< LocationType > LocationStack;
+ typedef Stack<StateType> StateStack;
+ 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
{
}
+ ]b4_parser_class_name[ (bool debug,
+ LocationType][]b4_param[]b4_parse_param_decl[) :
+ ]b4_constructor[][debug_ (debug),
+ cdebug_ (std::cerr)]b4_parse_param_cons[
+ {
+ cdebug_ << __FILE__ << ':' << __LINE__
+ << ": this constructor is provided by backward compatibility"
+ << ", but will be removed in the near future."
+ << std::endl;
+ }
+
virtual ~]b4_parser_class_name[ ()
{
}
virtual void error_ ();
virtual void print_ ();
virtual void report_syntax_error_ ();
+#if YYDEBUG
+ virtual void symprint_ (int yytype,
+ const SemanticType* yyvaluep,
+ const LocationType* yylocationp);
+#endif /* ! YYDEBUG */
+
/* Stacks. */
StateStack state_stack_;
#endif
/* Even more tables. */
- static inline TokenNumberType translate_ (int token);
- static inline void destruct_ (int yytype, SemanticType *yyvaluep,
- LocationType *yylocationp);
+ inline TokenNumberType translate_ (int token);
+ inline void destruct_ (const char* yymsg,
+ 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_;
/* Debugging. */
int debug_;
- std::ostream &cdebug_;
+ std::ostream& cdebug_;
/* Look-ahead and look-ahead in internal form. */
int looka_;
/* 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[
};
}
/* Enable debugging if requested. */
#if YYDEBUG
-# define YYCDEBUG if (debug_) cdebug_
+
+# define YYCDEBUG \
+ if (debug_) \
+ cdebug_
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (debug_) \
+ { \
+ cdebug_ << (Title) << ' '; \
+ symprint_ ((Type), (Value), (Location)); \
+ cdebug_ << std::endl; \
+ } \
+} while (0)
+
# define YY_REDUCE_PRINT(Rule) \
do { \
if (debug_) \
reduce_print_ (Rule); \
} while (0)
+
# define YY_STACK_PRINT() \
do { \
if (debug_) \
stack_print_ (); \
} while (0)
+
#else /* !YYDEBUG */
+
# define YYCDEBUG if (0) cdebug_
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_REDUCE_PRINT(Rule)
# define YY_STACK_PRINT()
+
#endif /* !YYDEBUG */
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
-]b4_yydestruct_generate([b4_cxx_destruct_def])[
+#if YYDEBUG
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+void
+yy::]b4_parser_class_name[::symprint_ (int yytype,
+ const SemanticType* yyvaluep, const LocationType* yylocationp)
+{
+ /* Pacify ``unused variable'' warnings. */
+ (void) yyvaluep;
+ (void) yylocationp;
+
+ cdebug_ << (yytype < ntokens_ ? "token" : "nterm")
+ << ' ' << name_[yytype] << " ("
+ << *yylocationp << ": ";
+ switch (yytype)
+ {
+]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
+[ default:
+ break;
+ }
+ cdebug_ << ')';
+}
+#endif /* ! YYDEBUG */
+
+void
+yy::]b4_parser_class_name[::destruct_ (const char* yymsg,
+ int yytype, SemanticType* yyvaluep, LocationType* yylocationp)
+{
+ /* Pacify ``unused variable'' warnings. */
+ (void) yyvaluep;
+ (void) yylocationp;
+
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+ switch (yytype)
+ {
+]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
+ default:
+ break;
+ }
+}
+
+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_];
}
/* Convert token to internal form. */
- if (looka_ <= 0)
+ if (looka_ <= eof_)
{
- looka_ = eof_;
- ilooka_ = 0;
+ looka_ = ilooka_ = eof_;
YYCDEBUG << "Now at end of input." << std::endl;
}
else
{
ilooka_ = translate_ (looka_);
-#if YYDEBUG
- if (debug_)
- {
- YYCDEBUG << "Next token is " << looka_
- << " (" << name_[ilooka_];
- print_ ();
- YYCDEBUG << ')' << std::endl;
- }
-#endif
+ YY_SYMBOL_PRINT ("Next token is", ilooka_, &value, &location);
}
- /* If the proper action on seeing token YYTOKEN is to reduce or to
+ /* If the proper action on seeing token ILOOKA_ is to reduce or to
detect an error, take that action. */
n_ += ilooka_;
if (n_ < 0 || last_ < n_ || check_[n_] != ilooka_)
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.
if (len_)
{
- Slice< LocationType, LocationStack > slice (location_stack_, len_);
+ Slice<LocationType, LocationStack> slice (location_stack_, len_);
YYLLOC_DEFAULT (yyloc, slice, len_);
}
YY_REDUCE_PRINT (n_);
]/* 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 ();
/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
- yyerrlab:
+yyerrlab:
/* 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;
-// YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
- destruct_ (stos_[state_stack_[0]],
+ destruct_ ("Error: popping",
+ stos_[state_stack_[0]],
&semantic_stack_[0],
&location_stack_[0]);
}
}
else
{
-#if YYDEBUG
- YYCDEBUG << "Discarding token " << looka_
- << " (" << name_[ilooka_] << ")." << std::endl;
-#endif
- destruct_ (ilooka_, &value, &location);
+ destruct_ ("Error: discarding", ilooka_, &value, &location);
looka_ = empty_;
}
}
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;
-#if YYDEBUG
- if (debug_)
- {
- if (stos_[state_] < ntokens_)
- {
- YYCDEBUG << "Error: popping token "
- << token_number_[stos_[state_]]
- << " (" << name_[stos_[state_]];
-# ifdef YYPRINT
- YYPRINT (stderr, token_number_[stos_[state_]],
- semantic_stack_.top ());
-# endif
- YYCDEBUG << ')' << std::endl;
- }
- else
- {
- YYCDEBUG << "Error: popping nonterminal ("
- << name_[stos_[state_]] << ')' << std::endl;
- }
- }
-#endif
- destruct_ (stos_[state_], &semantic_stack_[0], &location_stack_[0]);
- error_start_ = location_stack_[0].begin;
-
- state_stack_.pop ();
- semantic_stack_.pop ();
- location_stack_.pop ();
+ error_range_[0] = location_stack_[0];
+ destruct_ ("Error: popping",
+ stos_[state_], &semantic_stack_[0], &location_stack_[0]);
+ 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;
/* Accept. */
- yyacceptlab:
+yyacceptlab:
return 0;
/* Abort. */
- yyabortlab:
+yyabortlab:
+ /* Free the lookahead. */
+ destruct_ ("Error: discarding lookahead", ilooka_, &value, &location);
+ looka_ = empty_;
return 1;
}
#if YYDEBUG || YYERROR_VERBOSE
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
- First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+ First, the terminals, then, starting at NTOKENS_, nonterminals. */
const char*
const yy::]b4_parser_class_name[::name_[] =
{
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]] << ' ';
namespace yy
{
- template < class T, class S = std::deque< T > >
+ template <class T, class S = std::deque<T> >
class Stack
{
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:
S seq_;
};
- template < class T, class S = Stack< T > >
+ template <class T, class S = Stack<T> >
class Slice
{
public:
}
/** \brief Add and assign a Location */
- inline Location &operator+= (Location& res, unsigned int width)
+ inline Location& operator+= (Location& res, unsigned int width)
{
res.columns (width);
return res;
projects / bison.git / blobdiff