m4_divert(-1)
# C++ skeleton for Bison
-# Copyright (C) 2002 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003 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
## Default values. ##
## ---------------- ##
-# Stack parameters.
-m4_define_default([b4_stack_depth_init], [200])
-
# Default Parser class name.
m4_define_default([b4_parser_class_name], [Parser])
[])])
+# b4_parse_param_decl
+# -------------------
+# Constructor's extra arguments.
+m4_define([b4_parse_param_decl],
+ [m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])
+
+# b4_parse_param_cons
+# -------------------
+# constructor's extra initialisations.
+m4_define([b4_parse_param_cons],
+ [m4_ifset([b4_parse_param],
+ [,
+ b4_cc_constructor_calls(b4_parse_param)])])
+m4_define([b4_cc_constructor_calls],
+ [m4_map_sep([b4_cc_constructor_call], [,
+ ], [$@])])
+m4_define([b4_cc_constructor_call],
+ [$2($2)])
+
+# b4_parse_param_vars
+# -------------------
+# Extra instance variables.
+m4_define([b4_parse_param_vars],
+ [m4_ifset([b4_parse_param],
+ [
+ /* User arguments. */
+b4_cc_var_decls(b4_parse_param)])])
+m4_define([b4_cc_var_decls],
+ [m4_map_sep([b4_cc_var_decl], [
+], [$@])])
+m4_define([b4_cc_var_decl],
+ [ $1;])
+
# We do want M4 expansion after # for CPP macros.
m4_changecom()
m4_divert(0)dnl
-@output @output_header_name@
+m4_if(b4_defines_flag, 0, [],
+[@output @output_header_name@
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
- [2002])[
+ [2002, 2003])[
/* FIXME: This is wrong, we want computed header guards.
I don't know why the macros are missing now. :( */
#ifndef PARSER_HEADER_H
b4_syncline([@oline@], [@ofile@])[
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
- Current.last_line = Rhs[N].last_line; \
- Current.last_column = Rhs[N].last_column;
+ ((Current).end = Rhs[N].end)
#endif
namespace yy
#if YYLSP_NEEDED
]b4_parser_class_name[ (bool debug,
- LocationType initlocation][]b4_param[) :
+ LocationType initlocation][]b4_param[]b4_parse_param_decl[) :
]b4_constructor[][debug_ (debug),
cdebug_ (std::cerr),
- initlocation_ (initlocation)
+ initlocation_ (initlocation)]b4_parse_param_cons[
#else
- ]b4_parser_class_name[ (bool debug][]b4_param[) :
+ ]b4_parser_class_name[ (bool debug][]b4_param[]b4_parse_param_decl[) :
]b4_constructor[][debug_ (debug),
- cdebug_ (std::cerr)
+ cdebug_ (std::cerr)]b4_parse_param_cons[
#endif
{
}
/* Tables. */
static const ]b4_int_type_for([b4_pact])[ pact_[];
- static const ]b4_int_type_for([b4_pact])[ pact_ninf_;
+ static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ pact_ninf_;
static const ]b4_int_type_for([b4_defact])[ defact_[];
static const ]b4_int_type_for([b4_pgoto])[ pgoto_[];
static const ]b4_int_type_for([b4_defgoto])[ defgoto_[];
static const ]b4_int_type_for([b4_table])[ table_[];
- static const ]b4_int_type_for([b4_table])[ table_ninf_;
+ 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_r1])[ r1_[];
static const ]b4_int_type_for([b4_r2])[ r2_[];
static const int terror_;
static const int errcode_;
static const int ntokens_;
- static const int initdepth_;
static const unsigned user_token_number_max_;
static const TokenNumberType undef_token_;
/* Initial location. */
LocationType initlocation_;
+]b4_parse_param_vars[
};
}
#endif /* ! defined PARSER_HEADER_H */]
-dnl
+])dnl
@output @output_parser_name@
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
- [2002])[
+ [2002, 2003])
-#include @output_header_name@
+m4_if(b4_defines_flag, 0, [], [#include @output_header_name@])[
/* Enable debugging if requested. */
#if YYDEBUG
# define YYCDEBUG if (0) cdebug_
#endif /* !YYDEBUG */
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrorlab
+
+
int
yy::]b4_parser_class_name[::parse ()
{
#endif
}
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
n_ += ilooka_;
if (n_ < 0 || last_ < n_ || check_[n_] != ilooka_)
goto yydefault;
goto yyacceptlab;
/* Shift the lookahead token. */
+#if YYDEBUG
YYCDEBUG << "Shifting token " << looka_
- << " (" << name_[ilooka_] << "), ";
+ << " (" << name_[ilooka_] << "), ";
+#endif
/* Discard the token being shifted unless it is eof. */
if (looka_ != eof_)
state_ = n_;
goto yynewstate;
- /* Default action. */
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
yydefault:
n_ = defact_[state_];
if (n_ == 0)
goto yyerrlab;
goto yyreduce;
- /* Reduce. */
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
yyreduce:
len_ = r2_[n_];
+ /* If LEN_ is nonzero, implement the default value of the action:
+ `$$ = $1'. Otherwise, use the top of the stack.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. */
if (len_)
{
yyval = semantic_stack_[len_ - 1];
#if YYDEBUG
if (debug_)
{
+ // Short files will use "unsigned char" for line numbers,
+ // in which case they will be output as character litterals
+ // by "<<".
+ unsigned yylno = rline_[n_];
YYCDEBUG << "Reducing via rule " << n_ - 1
- << " (line " << rline_[n_] << "), ";
+ << " (line " << yylno << "), ";
for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
0 <= rhs_[i]; ++i)
YYCDEBUG << name_[rhs_[i]] << ' ';
state_ = defgoto_[n_ - ntokens_];
goto yynewstate;
- /* Report and recover from errors. This is very incomplete. */
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
yyerrlab:
/* If not already recovering from an error, report this error. */
if (!errstatus)
message += name_[ilooka_];
{
int count = 0;
- for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ int xbegin = n_ < 0 ? -n_ : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int checklim = last_ - n_;
+ int xend = checklim < ntokens_ ? checklim : ntokens_;
+ for (int x = xbegin; x < xend; ++x)
if (check_[x + n_] == x && x != terror_)
++count;
if (count < 5)
{
count = 0;
- for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
- if (check_[x + n_] == x && x != terror_)
+ for (int x1 = xbegin; x1 < xend; ++x1)
+ if (check_[x1 + n_] == x1 && x1 != terror_)
{
message += (!count++) ? ", expecting " : " or ";
- message += name_[x];
+ message += name_[x1];
}
}
}
message = "syntax error";
error_ ();
}
- goto yyerrlab1;
- /* Error raised explicitly by an action. */
- yyerrlab1:
if (errstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
/* Return failure if at end of input. */
- if (looka_ == eof_)
- goto yyabortlab;
- YYCDEBUG << "Discarding token " << looka_
- << " (" << name_[ilooka_] << ")." << std::endl;
- looka_ = empty_;
+ if (looka_ <= eof_)
+ {
+ /* If at end of input, pop the error token,
+ then the rest of the stack, then return failure. */
+ if (looka_ == eof_)
+ for (;;)
+ {
+ 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])[);
+ }
+ }
+ else
+ {
+#if YYDEBUG
+ YYCDEBUG << "Discarding token " << looka_
+ << " (" << name_[ilooka_] << ")." << std::endl;
+// yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
+#endif
+ looka_ = empty_;
+ }
}
/* Else will try to reuse lookahead token after shifting the error
token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+
+ state_stack_.pop (len_);
+ semantic_stack_.pop (len_);
+ location_stack_.pop (len_);
+ state_ = state_stack_[0];
+ goto yyerrlab1;
- errstatus = 3;
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ errstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
/* Pop the current state because it cannot handle the error token. */
if (state_stack_.height () == 1)
- goto yyabortlab;
+ YYABORT;
#if YYDEBUG
if (debug_)
}
#endif
- state_ = (state_stack_.pop (), state_stack_[0]);
+ state_stack_.pop ();
semantic_stack_.pop ();
- location_stack_.pop ();;
+ location_stack_.pop ();
+ state_ = state_stack_[0];
#if YYDEBUG
if (debug_)
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
-const ]b4_int_type_for([b4_pact]) yy::b4_parser_class_name::pact_ninf_ = b4_pact_ninf[;
+const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::pact_ninf_ = b4_pact_ninf[;
const ]b4_int_type_for([b4_pact])[
yy::]b4_parser_class_name[::pact_[] =
{
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says. */
-const ]b4_int_type_for([b4_table]) yy::b4_parser_class_name::table_ninf_ = b4_table_ninf[;
+const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::table_ninf_ = b4_table_ninf[;
const ]b4_int_type_for([b4_table])[
yy::]b4_parser_class_name[::table_[] =
{
{
static
const TokenNumberType
- translate_[] =
+ translate_table[] =
{
]b4_translate[
};
if ((unsigned) token <= user_token_number_max_)
- return translate_[token];
+ return translate_table[token];
else
return undef_token_;
}
const int yy::]b4_parser_class_name[::terror_ = 1;
const int yy::]b4_parser_class_name[::errcode_ = 256;
const int yy::]b4_parser_class_name[::ntokens_ = ]b4_tokens_number[;
-const int yy::]b4_parser_class_name[::initdepth_ = ]b4_stack_depth_init[;
const unsigned 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([2002])[
+b4_copyright([Stack handling for Bison C++ parsers], [2002, 2003])[
#ifndef BISON_STACK_HH
# define BISON_STACK_HH
inline
T&
- operator [] (unsigned index)
+ operator [] (unsigned i)
{
- return seq_[index];
+ return seq_[i];
}
inline
const T&
- operator [] (unsigned index) const
+ operator [] (unsigned i) const
{
- return seq_[index];
+ return seq_[i];
}
inline
inline
const T&
- operator [] (unsigned index) const
+ operator [] (unsigned i) const
{
- return stack_[range_ - index];
+ return stack_[range_ - i];
}
private:
#endif // not BISON_STACK_HH]
dnl
+@output position.hh
+b4_copyright([Position class for Bison C++ parsers], [2002, 2003])[
+
+/**
+ ** \file position.hh
+ ** Define the Location class.
+ */
+
+#ifndef BISON_POSITION_HH
+# define BISON_POSITION_HH
+
+# include <iostream>
+# include <string>
+
+namespace yy
+{
+ /** \brief Abstract a Position. */
+ class Position
+ {
+ public:
+ /** \brief Initial column number. */
+ static const unsigned int initial_column = 0;
+ /** \brief Initial line number. */
+ static const unsigned int initial_line = 1;
+
+ /** \name Ctor & dtor.
+ ** \{ */
+ public:
+ /** \brief Construct a Position. */
+ Position () :
+ filename (),
+ line (initial_line),
+ column (initial_column)
+ {
+ }
+ /** \} */
+
+
+ /** \name Line and Column related manipulators
+ ** \{ */
+ public:
+ /** \brief (line related) Advance to the COUNT next lines. */
+ inline void lines (int count = 1)
+ {
+ column = initial_column;
+ line += count;
+ }
+
+ /** \brief (column related) Advance to the COUNT next columns. */
+ inline void columns (int count = 1)
+ {
+ int leftmost = initial_column;
+ int current = column;
+ if (leftmost <= current + count)
+ column += count;
+ else
+ column = initial_column;
+ }
+ /** \} */
+
+ public:
+ /** \brief File name to which this position refers. */
+ std::string filename;
+ /** \brief Current line number. */
+ unsigned int line;
+ /** \brief Current column number. */
+ unsigned int column;
+ };
+
+ /** \brief Add and assign a Position. */
+ inline const Position&
+ operator+= (Position& res, const int width)
+ {
+ res.columns (width);
+ return res;
+ }
+
+ /** \brief Add two Position objects. */
+ inline const Position
+ operator+ (const Position& begin, const int width)
+ {
+ Position res = begin;
+ return res += width;
+ }
+
+ /** \brief Add and assign a Position. */
+ inline const Position&
+ operator-= (Position& res, const int width)
+ {
+ return res += -width;
+ }
+
+ /** \brief Add two Position objects. */
+ inline const Position
+ operator- (const Position& begin, const int width)
+ {
+ return begin + -width;
+ }
+
+ /** \brief Intercept output stream redirection.
+ ** \param ostr the destination output stream
+ ** \param pos a reference to the Position to redirect
+ */
+ inline std::ostream&
+ operator<< (std::ostream& ostr, const Position& pos)
+ {
+ if (!pos.filename.empty ())
+ ostr << pos.filename << ':';
+ return ostr << pos.line << '.' << pos.column;
+ }
+
+}
+#endif // not BISON_POSITION_HH]
@output location.hh
-b4_copyright([2002])[
+b4_copyright([Location class for Bison C++ parsers], [2002, 2003])[
+
+/**
+ ** \file location.hh
+ ** Define the Location class.
+ */
#ifndef BISON_LOCATION_HH
# define BISON_LOCATION_HH
+# include <iostream>
+# include <string>
+# include "position.hh"
+
namespace yy
{
- struct Position
+
+ /** \brief Abstract a Location. */
+ class Location
{
- int line;
- int column;
+ /** \name Ctor & dtor.
+ ** \{ */
+ public:
+ /** \brief Construct a Location. */
+ Location (void) :
+ begin (),
+ end ()
+ {
+ }
+ /** \} */
+
+
+ /** \name Line and Column related manipulators
+ ** \{ */
+ public:
+ /** \brief Reset initial location to final location. */
+ inline void step (void)
+ {
+ begin = end;
+ }
+
+ /** \brief Extend the current location to the COUNT next columns. */
+ inline void columns (unsigned int count = 1)
+ {
+ end += count;
+ }
+
+ /** \brief Extend the current location to the COUNT next lines. */
+ inline void lines (unsigned int count = 1)
+ {
+ end.lines (count);
+ }
+ /** \} */
+
+
+ public:
+ /** \brief Beginning of the located region. */
+ Position begin;
+ /** \brief End of the located region. */
+ Position end;
};
- struct Location
+ /** \brief Join two Location objects to create a Location. */
+ inline const Location operator+ (const Location& begin, const Location& end)
{
- Position first;
- Position last;
- };
+ Location res = begin;
+ res.end = end.end;
+ return res;
+ }
+
+ /** \brief Add two Location objects */
+ inline const Location operator+ (const Location& begin, unsigned width)
+ {
+ Location res = begin;
+ res.columns (width);
+ return res;
+ }
+
+ /** \brief Add and assign a Location */
+ inline Location &operator+= (Location& res, unsigned width)
+ {
+ res.columns (width);
+ return res;
+ }
+
+ /** \brief Intercept output stream redirection.
+ ** \param ostr the destination output stream
+ ** \param loc a reference to the Location to redirect
+ **
+ ** Avoid duplicate information.
+ */
+ inline std::ostream& operator<< (std::ostream& ostr, const Location& loc)
+ {
+ Position last = loc.end - 1;
+ ostr << loc.begin;
+ if (loc.begin.filename != last.filename)
+ ostr << '-' << last;
+ else if (loc.begin.line != last.line)
+ ostr << '-' << last.line << '.' << last.column;
+ else if (loc.begin.column != last.column)
+ ostr << '-' << last.column;
+ return ostr;
+ }
+
}
#endif // not BISON_LOCATION_HH]
projects / bison.git / blobdiff