m4_divert(-1)
# C++ skeleton for Bison
-# Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003, 2004 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
m4_define([b4_cc_var_decl],
[ $1;])
+
+# b4_yysymprint_generate(FUNCTION-DECLARATOR)
+# -------------------------------------------
+# Generate the "symprint_" member function.
+m4_define([b4_yysymprint_generate],
+[[/*--------------------------------.
+| 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] << " (";
+ switch (yytype)
+ {
+]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
+[ default:
+ break;
+ }
+ cdebug_ << ')';
+}
+]])
+
+
+# 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()
m4_divert(0)dnl
m4_if(b4_defines_flag, 0, [],
[@output @output_header_name@
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
- [2002, 2003])[
+ [2002, 2003, 2004])[
/* FIXME: This is wrong, we want computed header guards.
I don't know why the macros are missing now. :( */
#ifndef PARSER_HEADER_H
# 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;
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_;
static const ]b4_int_type_for([b4_table])[ table_[];
static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ table_ninf_;
static const ]b4_int_type_for([b4_check])[ check_[];
+ static const ]b4_int_type_for([b4_stos])[ stos_[];
static const ]b4_int_type_for([b4_r1])[ r1_[];
static const ]b4_int_type_for([b4_r2])[ r2_[];
static const RhsNumberType rhs_[];
static const ]b4_int_type_for([b4_prhs])[ prhs_[];
static const ]b4_int_type_for([b4_rline])[ rline_[];
- static const ]b4_int_type_for([b4_stos])[ stos_[];
static const ]b4_int_type_for([b4_toknum])[ token_number_[];
virtual void reduce_print_ (int yyrule);
virtual void stack_print_ ();
/* Even more tables. */
static inline TokenNumberType translate_ (int token);
+ static inline void destruct_ (int yytype, SemanticType *yyvaluep,
+ LocationType *yylocationp);
/* Constants. */
static const int eof_;
static const int terror_;
static const int errcode_;
static const int ntokens_;
- static const unsigned user_token_number_max_;
+ static const unsigned int user_token_number_max_;
static const TokenNumberType undef_token_;
/* State. */
int debug_;
std::ostream &cdebug_;
- /* Lookahead and lookahead in internal form. */
+ /* Look-ahead and look-ahead in internal form. */
int looka_;
int ilooka_;
/* Message. */
std::string message;
- /* Semantic value and location of lookahead token. */
+ /* Semantic value and location of look-ahead token. */
SemanticType value;
LocationType location;
+ /* Beginning of the last erroneous token popped off. */
+ Position error_start_;
/* @@$ and $$. */
SemanticType yyval;
])dnl
@output @output_parser_name@
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
- [2002, 2003])
+ [2002, 2003, 2004])
m4_if(b4_defines_flag, 0, [], [#include @output_header_name@])[
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
+#if YYDEBUG
+]b4_yysymprint_generate([b4_cxx_symprint_def])[
+#endif /* ! YYDEBUG */
+]b4_yydestruct_generate([b4_cxx_destruct_def])[
int
yy::]b4_parser_class_name[::parse ()
/* Backup. */
yybackup:
- /* Try to take a decision without lookahead. */
+ /* Try to take a decision without look-ahead. */
n_ = pact_[state_];
if (n_ == pact_ninf_)
goto yydefault;
- /* Read a lookahead token. */
+ /* Read a look-ahead token. */
if (looka_ == empty_)
{
YYCDEBUG << "Reading a token: ";
#if YYDEBUG
if (debug_)
{
- YYCDEBUG << "Next token is " << looka_
- << " (" << name_[ilooka_];
- print_ ();
- YYCDEBUG << ')' << std::endl;
+ cdebug_ << "Next token is ";
+ symprint_ (ilooka_, &value, &location);
+ cdebug_ << std::endl;
}
#endif
}
- /* 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_)
if (n_ == final_)
goto yyacceptlab;
- /* Shift the lookahead token. */
+ /* Shift the look-ahead token. */
#if YYDEBUG
YYCDEBUG << "Shifting token " << looka_
<< " (" << name_[ilooka_] << "), ";
/* If not already recovering from an error, report this error. */
report_syntax_error_ ();
+ error_start_ = location.begin;
if (errstatus_ == 3)
{
- /* If just tried and failed to reuse lookahead token after an
+ /* If just tried and failed to reuse look-ahead token after an
error, discard it. */
/* Return failure if at end of input. */
if (looka_ == eof_)
for (;;)
{
+ error_start_ = location_stack_[0].begin;
state_stack_.pop ();
semantic_stack_.pop ();
location_stack_.pop ();
if (state_stack_.height () == 1)
YYABORT;
-// YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-// FIXME: yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
+#if YYDEBUG
+ if (debug_)
+ {
+ cdebug_ << "Error: popping ";
+ symprint_ (stos_[state_stack_[0]],
+ &semantic_stack_[0],
+ &location_stack_[0]);
+ cdebug_ << std::endl;
+ }
+#endif // YYDEBUG
+ destruct_ (stos_[state_stack_[0]],
+ &semantic_stack_[0],
+ &location_stack_[0]);
}
}
else
{
#if YYDEBUG
- YYCDEBUG << "Discarding token " << looka_
- << " (" << name_[ilooka_] << ")." << std::endl;
-// yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
+ if (debug_)
+ {
+ cdebug_ << "Error: discarding ";
+ symprint_ (ilooka_, &value, &location);
+ cdebug_ << std::endl;
+ }
#endif
- looka_ = empty_;
+ destruct_ (ilooka_, &value, &location);
+ looka_ = empty_;
}
}
- /* Else will try to reuse lookahead token after shifting the error
+ /* Else will try to reuse look-ahead token after shifting the error
token. */
goto yyerrlab1;
state_stack_.pop (len_);
semantic_stack_.pop (len_);
+ error_start_ = location_stack_[len_ - 1].begin;
location_stack_.pop (len_);
state_ = state_stack_[0];
goto yyerrlab1;
#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;
- }
+ cdebug_ << "Error: popping ";
+ symprint_ (stos_[state_], &semantic_stack_[0], &location_stack_[0]);
+ cdebug_ << std::endl;
}
#endif
+ destruct_ (stos_[state_], &semantic_stack_[0], &location_stack_[0]);
+ error_start_ = location_stack_[0].begin;
state_stack_.pop ();
semantic_stack_.pop ();
YYCDEBUG << "Shifting error token, ";
- semantic_stack_.push (value);
- location_stack_.push (location);
+ {
+ Location errloc;
+ errloc.begin = error_start_;
+ errloc.end = location.end;
+ semantic_stack_.push (value);
+ location_stack_.push (errloc);
+ }
state_ = n_;
goto yynewstate;
]b4_check[
};
-#if YYDEBUG
/* STOS_[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
const ]b4_int_type_for([b4_stos])[
]b4_stos[
};
+#if YYDEBUG
/* TOKEN_NUMBER_[YYLEX-NUM] -- Internal token number corresponding
to YYLEX-NUM. */
const ]b4_int_type_for([b4_toknum])[
#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_[] =
{
{
]b4_translate[
};
- if ((unsigned) token <= user_token_number_max_)
+ if ((unsigned int) token <= user_token_number_max_)
return translate_table[token];
else
return undef_token_;
const int yy::]b4_parser_class_name[::errcode_ = 256;
const int yy::]b4_parser_class_name[::ntokens_ = ]b4_tokens_number[;
-const unsigned yy::]b4_parser_class_name[::user_token_number_max_ = ]b4_user_token_number_max[;
+const unsigned int yy::]b4_parser_class_name[::user_token_number_max_ = ]b4_user_token_number_max[;
const yy::]b4_parser_class_name[::TokenNumberType yy::]b4_parser_class_name[::undef_token_ = ]b4_undef_token_number[;
]b4_epilogue
dnl
@output stack.hh
-b4_copyright([Stack handling for Bison C++ parsers], [2002, 2003])[
+b4_copyright([Stack handling for Bison C++ parsers], [2002, 2003, 2004])[
#ifndef BISON_STACK_HH
# define BISON_STACK_HH
{
}
- Stack (unsigned n) : seq_ (n)
+ Stack (unsigned int n) : seq_ (n)
{
}
inline
T&
- operator [] (unsigned i)
+ operator [] (unsigned int i)
{
return seq_[i];
}
inline
const T&
- operator [] (unsigned i) const
+ operator [] (unsigned int i) const
{
return seq_[i];
}
inline
void
- pop (unsigned n = 1)
+ pop (unsigned int n = 1)
{
for (; n; --n)
seq_.pop_front ();
}
inline
- unsigned
+ unsigned int
height () const
{
return seq_.size ();
public:
Slice (const S& stack,
- unsigned range) : stack_ (stack),
- range_ (range)
+ unsigned int range) : stack_ (stack),
+ range_ (range)
{
}
inline
const T&
- operator [] (unsigned i) const
+ operator [] (unsigned int i) const
{
return stack_[range_ - i];
}
private:
const S& stack_;
- unsigned range_;
+ unsigned int range_;
};
}
#endif // not BISON_STACK_HH]
dnl
@output position.hh
-b4_copyright([Position class for Bison C++ parsers], [2002, 2003])[
+b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004])[
/**
** \file position.hh
}
#endif // not BISON_POSITION_HH]
@output location.hh
-b4_copyright([Location class for Bison C++ parsers], [2002, 2003])[
+b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004])[
/**
** \file location.hh
}
/** \brief Add two Location objects */
- inline const Location operator+ (const Location& begin, unsigned width)
+ inline const Location operator+ (const Location& begin, unsigned int width)
{
Location res = begin;
res.columns (width);
}
/** \brief Add and assign a Location */
- inline Location &operator+= (Location& res, unsigned width)
+ inline Location &operator+= (Location& res, unsigned int width)
{
res.columns (width);
return res;
projects / bison.git / blobdiff