mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-11 13:23:04 +00:00
3ae831b413
Robert Anisko <anisko_r@lrde.epita.fr> * data/lalr1.cc (parse::yyerrlab1): When popping the stack, stop when the stacks contain one element, as the loop would otherwise free the last state, and then use the top state (the one we just popped). This means that the initial elements will not be freed explicitly, as is the case in yacc.c; it is not a problem, as these elements have fake values.
887 lines
19 KiB
C++
887 lines
19 KiB
C++
m4_divert(-1)
|
|
# C++ skeleton for Bison
|
|
# Copyright (C) 2002 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
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
# 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
|
|
|
|
## ---------------- ##
|
|
## Default values. ##
|
|
## ---------------- ##
|
|
|
|
# Stack parameters.
|
|
m4_define_default([b4_stack_depth_init], [200])
|
|
|
|
# Default Parser class name.
|
|
m4_define_default([b4_parser_class_name], [Parser])
|
|
|
|
|
|
|
|
## ----------------- ##
|
|
## Semantic Values. ##
|
|
## ----------------- ##
|
|
|
|
|
|
# b4_lhs_value([TYPE])
|
|
# --------------------
|
|
# Expansion of $<TYPE>$.
|
|
m4_define([b4_lhs_value],
|
|
[yyval[]m4_ifval([$1], [.$1])])
|
|
|
|
|
|
# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
|
|
# --------------------------------------
|
|
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
|
|
# symbols on RHS.
|
|
m4_define([b4_rhs_value],
|
|
[semantic_stack_@{m4_eval([$1 - $2])@}m4_ifval([$3], [.$3])])
|
|
|
|
m4_define_default([b4_location_type], [Location])
|
|
|
|
# b4_lhs_location()
|
|
# -----------------
|
|
# Expansion of @$.
|
|
m4_define([b4_lhs_location],
|
|
[yyloc])
|
|
|
|
|
|
# b4_rhs_location(RULE-LENGTH, NUM)
|
|
# ---------------------------------
|
|
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
|
|
# on RHS.
|
|
m4_define([b4_rhs_location],
|
|
[location_stack_@{m4_eval([$1 - $2])@}])
|
|
|
|
|
|
m4_define([b4_inherit],
|
|
[m4_ifdef([b4_root],
|
|
[: public b4_root
|
|
],
|
|
[])])
|
|
|
|
m4_define([b4_param],
|
|
[m4_ifdef([b4_root],
|
|
[,
|
|
const Param& param],
|
|
[])])
|
|
|
|
m4_define([b4_constructor],
|
|
[m4_ifdef([b4_root],
|
|
[b4_root (param),
|
|
],
|
|
[])])
|
|
|
|
|
|
# We do want M4 expansion after # for CPP macros.
|
|
m4_changecom()
|
|
m4_divert(0)dnl
|
|
@output @output_header_name@
|
|
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
|
|
[2002])[
|
|
/* FIXME: This is wrong, we want computed header guards.
|
|
I don't know why the macros are missing now. :( */
|
|
#ifndef PARSER_HEADER_H
|
|
# define PARSER_HEADER_H
|
|
|
|
#include "stack.hh"
|
|
#include "location.hh"
|
|
|
|
#include <string>
|
|
#include <iostream>
|
|
|
|
/* Using locations. */
|
|
#define YYLSP_NEEDED ]b4_locations_flag[
|
|
|
|
]b4_token_defines(b4_tokens)[
|
|
|
|
/* Copy the first part of user declarations. */
|
|
]b4_pre_prologue[
|
|
|
|
]/* Line __line__ of lalr1.cc. */
|
|
b4_syncline([@oline@], [@ofile@])[
|
|
|
|
/* Enabling traces. */
|
|
#ifndef YYDEBUG
|
|
# define YYDEBUG ]b4_debug[
|
|
#endif
|
|
|
|
/* Enabling verbose error message. */
|
|
#ifndef YYERROR_VERBOSE
|
|
# define YYERROR_VERBOSE ]b4_error_verbose[
|
|
#endif
|
|
|
|
#ifndef YYSTYPE
|
|
]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@])],
|
|
[typedef int yystype;])[
|
|
# define YYSTYPE yystype
|
|
#endif
|
|
|
|
/* Copy the second part of user declarations. */
|
|
]b4_post_prologue[
|
|
|
|
]/* Line __line__ of lalr1.cc. */
|
|
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;
|
|
#endif
|
|
|
|
namespace yy
|
|
{
|
|
class ]b4_parser_class_name[;
|
|
|
|
template < typename P >
|
|
struct Traits
|
|
{
|
|
};
|
|
|
|
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 ]b4_location_type[ LocationType;
|
|
};
|
|
}
|
|
|
|
namespace yy
|
|
{
|
|
class ]b4_parser_class_name b4_inherit[
|
|
{
|
|
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 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_constructor[][debug_ (debug),
|
|
cdebug_ (std::cerr),
|
|
initlocation_ (initlocation)
|
|
#else
|
|
]b4_parser_class_name[ (bool debug][]b4_param[) :
|
|
]b4_constructor[][debug_ (debug),
|
|
cdebug_ (std::cerr)
|
|
#endif
|
|
{
|
|
}
|
|
|
|
virtual ~]b4_parser_class_name[ ()
|
|
{
|
|
}
|
|
|
|
virtual int parse ();
|
|
|
|
private:
|
|
|
|
virtual void lex_ ();
|
|
virtual void error_ ();
|
|
virtual void print_ ();
|
|
|
|
/* Stacks. */
|
|
StateStack state_stack_;
|
|
SemanticStack semantic_stack_;
|
|
LocationStack location_stack_;
|
|
|
|
/* 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_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_for([b4_check])[ check_[];
|
|
static const ]b4_int_type_for([b4_r1])[ r1_[];
|
|
static const ]b4_int_type_for([b4_r2])[ r2_[];
|
|
|
|
#if YYDEBUG || YYERROR_VERBOSE
|
|
static const char* const name_[];
|
|
#endif
|
|
|
|
/* More tables, for debugging. */
|
|
#if YYDEBUG
|
|
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_[];
|
|
#endif
|
|
|
|
/* Even more tables. */
|
|
static inline TokenNumberType translate_ (int token);
|
|
|
|
/* Constants. */
|
|
static const int eof_;
|
|
/* LAST_ -- Last index in TABLE_. */
|
|
static const int last_;
|
|
static const int nnts_;
|
|
static const int empty_;
|
|
static const int final_;
|
|
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_;
|
|
|
|
/* State. */
|
|
int n_;
|
|
int len_;
|
|
int state_;
|
|
|
|
/* Debugging. */
|
|
int debug_;
|
|
std::ostream &cdebug_;
|
|
|
|
/* Lookahead and lookahead in internal form. */
|
|
int looka_;
|
|
int ilooka_;
|
|
|
|
/* Message. */
|
|
std::string message;
|
|
|
|
/* Semantic value and location of lookahead token. */
|
|
SemanticType value;
|
|
LocationType location;
|
|
|
|
/* @@$ and $$. */
|
|
SemanticType yyval;
|
|
LocationType yyloc;
|
|
|
|
/* Initial location. */
|
|
LocationType initlocation_;
|
|
};
|
|
}
|
|
|
|
#endif /* ! defined PARSER_HEADER_H */]
|
|
dnl
|
|
@output @output_parser_name@
|
|
b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
|
|
[2002])[
|
|
|
|
#include @output_header_name@
|
|
|
|
/* Enable debugging if requested. */
|
|
#if YYDEBUG
|
|
# define YYCDEBUG if (debug_) cdebug_
|
|
#else /* !YYDEBUG */
|
|
# define YYCDEBUG if (0) cdebug_
|
|
#endif /* !YYDEBUG */
|
|
|
|
int
|
|
yy::]b4_parser_class_name[::parse ()
|
|
{
|
|
int nerrs = 0;
|
|
int errstatus = 0;
|
|
|
|
/* 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;
|
|
|
|
/* New state. */
|
|
yynewstate:
|
|
state_stack_.push (state_);
|
|
YYCDEBUG << "Entering state " << state_ << std::endl;
|
|
goto yybackup;
|
|
|
|
/* Backup. */
|
|
yybackup:
|
|
|
|
/* Try to take a decision without lookahead. */
|
|
n_ = pact_[state_];
|
|
if (n_ == pact_ninf_)
|
|
goto yydefault;
|
|
|
|
/* Read a lookahead token. */
|
|
if (looka_ == empty_)
|
|
{
|
|
YYCDEBUG << "Reading a token: ";
|
|
lex_ ();
|
|
}
|
|
|
|
/* Convert token to internal form. */
|
|
if (looka_ <= 0)
|
|
{
|
|
looka_ = eof_;
|
|
ilooka_ = 0;
|
|
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
|
|
}
|
|
|
|
n_ += ilooka_;
|
|
if (n_ < 0 || last_ < n_ || check_[n_] != ilooka_)
|
|
goto yydefault;
|
|
|
|
/* Reduce or error. */
|
|
n_ = table_[n_];
|
|
if (n_ < 0)
|
|
{
|
|
if (n_ == table_ninf_)
|
|
goto yyerrlab;
|
|
else
|
|
{
|
|
n_ = -n_;
|
|
goto yyreduce;
|
|
}
|
|
}
|
|
else if (n_ == 0)
|
|
goto yyerrlab;
|
|
|
|
/* Accept? */
|
|
if (n_ == final_)
|
|
goto yyacceptlab;
|
|
|
|
/* Shift the lookahead token. */
|
|
YYCDEBUG << "Shifting token " << looka_
|
|
<< " (" << name_[ilooka_] << "), ";
|
|
|
|
/* Discard the token being shifted unless it is eof. */
|
|
if (looka_ != eof_)
|
|
looka_ = empty_;
|
|
|
|
semantic_stack_.push (value);
|
|
location_stack_.push (location);
|
|
|
|
/* Count tokens shifted since error; after three, turn off error
|
|
status. */
|
|
if (errstatus)
|
|
--errstatus;
|
|
|
|
state_ = n_;
|
|
goto yynewstate;
|
|
|
|
/* Default action. */
|
|
yydefault:
|
|
n_ = defact_[state_];
|
|
if (n_ == 0)
|
|
goto yyerrlab;
|
|
goto yyreduce;
|
|
|
|
/* Reduce. */
|
|
yyreduce:
|
|
len_ = r2_[n_];
|
|
if (len_)
|
|
{
|
|
yyval = semantic_stack_[len_ - 1];
|
|
yyloc = location_stack_[len_ - 1];
|
|
}
|
|
else
|
|
{
|
|
yyval = semantic_stack_[0];
|
|
yyloc = location_stack_[0];
|
|
}
|
|
|
|
#if YYDEBUG
|
|
if (debug_)
|
|
{
|
|
YYCDEBUG << "Reducing via rule " << n_ - 1
|
|
<< " (line " << rline_[n_] << "), ";
|
|
for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
|
|
0 <= rhs_[i]; ++i)
|
|
YYCDEBUG << name_[rhs_[i]] << ' ';
|
|
YYCDEBUG << "-> " << name_[r1_[n_]] << std::endl;
|
|
}
|
|
#endif
|
|
|
|
if (len_)
|
|
{
|
|
Slice< LocationType, LocationStack > slice (location_stack_, len_);
|
|
YYLLOC_DEFAULT (yyloc, slice, len_);
|
|
}
|
|
|
|
switch (n_)
|
|
{
|
|
]b4_actions[
|
|
}
|
|
|
|
]/* Line __line__ of lalr1.cc. */
|
|
b4_syncline([@oline@], [@ofile@])[
|
|
|
|
state_stack_.pop (len_);
|
|
semantic_stack_.pop (len_);
|
|
location_stack_.pop (len_);
|
|
|
|
#if YYDEBUG
|
|
if (debug_)
|
|
{
|
|
YYCDEBUG << "state stack now";
|
|
for (StateStack::ConstIterator i = state_stack_.begin ();
|
|
i != state_stack_.end (); ++i)
|
|
YYCDEBUG << ' ' << *i;
|
|
YYCDEBUG << std::endl;
|
|
}
|
|
#endif
|
|
|
|
semantic_stack_.push (yyval);
|
|
location_stack_.push (yyloc);
|
|
|
|
/* Shift the result of the reduction. */
|
|
n_ = r1_[n_];
|
|
state_ = pgoto_[n_ - ntokens_] + state_stack_[0];
|
|
if (0 <= state_ && state_ <= last_ && check_[state_] == state_stack_[0])
|
|
state_ = table_[state_];
|
|
else
|
|
state_ = defgoto_[n_ - ntokens_];
|
|
goto yynewstate;
|
|
|
|
/* Report and recover from errors. This is very incomplete. */
|
|
yyerrlab:
|
|
/* If not already recovering from an error, report this error. */
|
|
if (!errstatus)
|
|
{
|
|
++nerrs;
|
|
|
|
#if YYERROR_VERBOSE
|
|
n_ = pact_[state_];
|
|
if (pact_ninf_ < n_ && n_ < last_)
|
|
{
|
|
message = "syntax error, unexpected ";
|
|
message += name_[ilooka_];
|
|
{
|
|
int count = 0;
|
|
for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++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_)
|
|
{
|
|
message += (!count++) ? ", expecting " : " or ";
|
|
message += name_[x];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
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_;
|
|
}
|
|
|
|
/* Else will try to reuse lookahead token after shifting the error
|
|
token. */
|
|
|
|
errstatus = 3;
|
|
|
|
for (;;)
|
|
{
|
|
n_ = pact_[state_];
|
|
if (n_ != pact_ninf_)
|
|
{
|
|
n_ += terror_;
|
|
if (0 <= n_ && n_ <= last_ && check_[n_] == terror_)
|
|
{
|
|
n_ = table_[n_];
|
|
if (0 < n_)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Pop the current state because it cannot handle the error token. */
|
|
if (state_stack_.height () == 1)
|
|
goto yyabortlab;
|
|
|
|
#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
|
|
|
|
state_ = (state_stack_.pop (), state_stack_[0]);
|
|
semantic_stack_.pop ();
|
|
location_stack_.pop ();;
|
|
|
|
#if YYDEBUG
|
|
if (debug_)
|
|
{
|
|
YYCDEBUG << "Error: state stack now";
|
|
for (StateStack::ConstIterator i = state_stack_.begin ();
|
|
i != state_stack_.end (); ++i)
|
|
YYCDEBUG << ' ' << *i;
|
|
YYCDEBUG << std::endl;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (n_ == final_)
|
|
goto yyacceptlab;
|
|
|
|
YYCDEBUG << "Shifting error token, ";
|
|
|
|
semantic_stack_.push (value);
|
|
location_stack_.push (location);
|
|
|
|
state_ = n_;
|
|
goto yynewstate;
|
|
|
|
/* Accept. */
|
|
yyacceptlab:
|
|
return 0;
|
|
|
|
/* Abort. */
|
|
yyabortlab:
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
yy::]b4_parser_class_name[::lex_ ()
|
|
{
|
|
#if YYLSP_NEEDED
|
|
looka_ = yylex (&value, &location);
|
|
#else
|
|
looka_ = yylex (&value);
|
|
#endif
|
|
}
|
|
|
|
/* 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_for([b4_pact])[
|
|
yy::]b4_parser_class_name[::pact_[] =
|
|
{
|
|
]b4_pact[
|
|
};
|
|
|
|
/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
|
|
doesn't specify something else to do. Zero means the default is an
|
|
error. */
|
|
const ]b4_int_type_for([b4_defact])[
|
|
yy::]b4_parser_class_name[::defact_[] =
|
|
{
|
|
]b4_defact[
|
|
};
|
|
|
|
/* YYPGOTO[NTERM-NUM]. */
|
|
const ]b4_int_type_for([b4_pgoto])[
|
|
yy::]b4_parser_class_name[::pgoto_[] =
|
|
{
|
|
]b4_pgoto[
|
|
};
|
|
|
|
/* YYDEFGOTO[NTERM-NUM]. */
|
|
const ]b4_int_type_for([b4_defgoto])[
|
|
yy::]b4_parser_class_name[::defgoto_[] =
|
|
{
|
|
]b4_defgoto[
|
|
};
|
|
|
|
/* 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_for([b4_table])[
|
|
yy::]b4_parser_class_name[::table_[] =
|
|
{
|
|
]b4_table[
|
|
};
|
|
|
|
/* YYCHECK. */
|
|
const ]b4_int_type_for([b4_check])[
|
|
yy::]b4_parser_class_name[::check_[] =
|
|
{
|
|
]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])[
|
|
yy::]b4_parser_class_name[::stos_[] =
|
|
{
|
|
]b4_stos[
|
|
};
|
|
|
|
/* TOKEN_NUMBER_[YYLEX-NUM] -- Internal token number corresponding
|
|
to YYLEX-NUM. */
|
|
const ]b4_int_type_for([b4_toknum])[
|
|
yy::]b4_parser_class_name[::token_number_[] =
|
|
{
|
|
]b4_toknum[
|
|
};
|
|
#endif
|
|
|
|
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
|
|
const ]b4_int_type_for([b4_r1])[
|
|
yy::]b4_parser_class_name[::r1_[] =
|
|
{
|
|
]b4_r1[
|
|
};
|
|
|
|
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
|
|
const ]b4_int_type_for([b4_r2])[
|
|
yy::]b4_parser_class_name[::r2_[] =
|
|
{
|
|
]b4_r2[
|
|
};
|
|
|
|
#if YYDEBUG || YYERROR_VERBOSE
|
|
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
|
|
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
|
|
const char*
|
|
const yy::]b4_parser_class_name[::name_[] =
|
|
{
|
|
]b4_tname[
|
|
};
|
|
#endif
|
|
|
|
#if YYDEBUG
|
|
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
|
|
const yy::]b4_parser_class_name[::RhsNumberType
|
|
yy::]b4_parser_class_name[::rhs_[] =
|
|
{
|
|
]b4_rhs[
|
|
};
|
|
|
|
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
|
|
YYRHS. */
|
|
const ]b4_int_type_for([b4_prhs])[
|
|
yy::]b4_parser_class_name[::prhs_[] =
|
|
{
|
|
]b4_prhs[
|
|
};
|
|
|
|
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
|
|
const ]b4_int_type_for([b4_rline])[
|
|
yy::]b4_parser_class_name[::rline_[] =
|
|
{
|
|
]b4_rline[
|
|
};
|
|
#endif
|
|
|
|
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
|
|
yy::]b4_parser_class_name[::TokenNumberType
|
|
yy::]b4_parser_class_name[::translate_ (int token)
|
|
{
|
|
static
|
|
const TokenNumberType
|
|
translate_[] =
|
|
{
|
|
]b4_translate[
|
|
};
|
|
if ((unsigned) token <= user_token_number_max_)
|
|
return translate_[token];
|
|
else
|
|
return undef_token_;
|
|
}
|
|
|
|
const int yy::]b4_parser_class_name[::eof_ = 0;
|
|
const int yy::]b4_parser_class_name[::last_ = ]b4_last[;
|
|
const int yy::]b4_parser_class_name[::nnts_ = ]b4_nterms_number[;
|
|
const int yy::]b4_parser_class_name[::empty_ = -2;
|
|
const int yy::]b4_parser_class_name[::final_ = ]b4_final_state_number[;
|
|
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])[
|
|
|
|
#ifndef BISON_STACK_HH
|
|
# define BISON_STACK_HH
|
|
|
|
#include <deque>
|
|
|
|
namespace yy
|
|
{
|
|
template < class T, class S = std::deque< T > >
|
|
class Stack
|
|
{
|
|
public:
|
|
|
|
typedef typename S::iterator Iterator;
|
|
typedef typename S::const_iterator ConstIterator;
|
|
|
|
Stack () : seq_ ()
|
|
{
|
|
}
|
|
|
|
Stack (unsigned n) : seq_ (n)
|
|
{
|
|
}
|
|
|
|
inline
|
|
T&
|
|
operator [] (unsigned index)
|
|
{
|
|
return seq_[index];
|
|
}
|
|
|
|
inline
|
|
const T&
|
|
operator [] (unsigned index) const
|
|
{
|
|
return seq_[index];
|
|
}
|
|
|
|
inline
|
|
void
|
|
push (const T& t)
|
|
{
|
|
seq_.push_front (t);
|
|
}
|
|
|
|
inline
|
|
void
|
|
pop (unsigned n = 1)
|
|
{
|
|
for (; n; --n)
|
|
seq_.pop_front ();
|
|
}
|
|
|
|
inline
|
|
unsigned
|
|
height () const
|
|
{
|
|
return seq_.size ();
|
|
}
|
|
|
|
inline ConstIterator begin () const { return seq_.begin (); }
|
|
inline ConstIterator end () const { return seq_.end (); }
|
|
|
|
private:
|
|
|
|
S seq_;
|
|
};
|
|
|
|
template < class T, class S = Stack< T > >
|
|
class Slice
|
|
{
|
|
public:
|
|
|
|
Slice (const S& stack,
|
|
unsigned range) : stack_ (stack),
|
|
range_ (range)
|
|
{
|
|
}
|
|
|
|
inline
|
|
const T&
|
|
operator [] (unsigned index) const
|
|
{
|
|
return stack_[range_ - index];
|
|
}
|
|
|
|
private:
|
|
|
|
const S& stack_;
|
|
unsigned range_;
|
|
};
|
|
}
|
|
|
|
#endif // not BISON_STACK_HH]
|
|
dnl
|
|
@output location.hh
|
|
b4_copyright([2002])[
|
|
|
|
#ifndef BISON_LOCATION_HH
|
|
# define BISON_LOCATION_HH
|
|
|
|
namespace yy
|
|
{
|
|
struct Position
|
|
{
|
|
int line;
|
|
int column;
|
|
};
|
|
|
|
struct Location
|
|
{
|
|
Position first;
|
|
Position last;
|
|
};
|
|
}
|
|
|
|
#endif // not BISON_LOCATION_HH]
|