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 # b4_sint_type(MAX) # ----------------- # Return the smallest signed int type able to handle the number MAX. m4_define([b4_sint_type], [m4_if(m4_eval([$1 <= 127]), [1], [signed char], m4_eval([$1 <= 32767]), [1], [signed short], [signed int])]) # b4_uint_type(MAX) # ----------------- # Return the smallest unsigned int type able to handle the number MAX. m4_define([b4_uint_type], [m4_if(m4_eval([$1 <= 255]), [1], [unsigned char], m4_eval([$1 <= 65535]), [1], [unsigned short], [unsigned int])]) # b4_lhs_value([TYPE]) # -------------------- # Expansion of $$. m4_define([b4_lhs_value], [yyval[]m4_ifval([$1], [.$1])]) # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) # -------------------------------------- # Expansion of $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])]) # 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])@:>@]) # b4_token_define(TOKEN-NAME, TOKEN-NUMBER) # ----------------------------------------- # Output the definition of this token as #define. m4_define([b4_token_define], [#define $1 $2 ]) # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) # ------------------------------------------------------- # Output the definition of the tokens as #define. m4_define([b4_token_defines], [m4_map([b4_token_define], [$@])]) m4_define_default([b4_input_suffix], [.y]) m4_define_default([b4_output_parser_suffix], [m4_translit(b4_input_suffix, [yY], [cC])]) m4_define_default([b4_output_parser_name], [b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]]) m4_define_default([b4_output_header_suffix], [m4_translit(b4_input_suffix, [yY], [hH])]) m4_define_default([b4_output_header_name], [b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]]) m4_define_default([b4_header_guard], [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name), [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])]) 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), ], [])]) m4_define([b4_copyright], [/* -*- C++ -*- */ /* A Bison parser, made from b4_filename, by GNU bison b4_version. */ /* Skeleton output parser for bison, Copyright 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, 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. */ /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */]) m4_divert(0)dnl #output "b4_output_header_name" b4_copyright #ifndef b4_header_guard # define b4_header_guard #include "stack.hh" #include "location.hh" #include #include /* Using locations. */ #define YYLSP_NEEDED b4_locations_flag /* Copy the first part of user declarations. */ b4_pre_prologue /* Line __line__ of __file__. */ #line __oline__ "__ofile__" /* Tokens. */ b4_token_defines(b4_tokens) /* 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], [#line b4_stype_line "b4_filename" typedef union b4_stype yystype; /* Line __line__ of __file__. */ #line __oline__ "__ofile__"], [typedef int yystype;]) # define YYSTYPE yystype #endif /* Copy the second part of user declarations. */ b4_post_prologue /* Line __line__ of __file__. */ #line __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 m4_if(b4_locations_flag, [0], [], [#ifndef YYLTYPE typedef struct yyltype { int first_line; int first_column; int last_line; int last_column; } yyltype; # define YYLTYPE yyltype #endif]) namespace yy { class b4_name; template < typename P > struct Traits { }; template < > struct Traits< b4_name > { typedef b4_uint_type(b4_translate_max) TokenNumberType; typedef b4_sint_type(b4_rhs_max) RhsNumberType; typedef int StateType; typedef yystype SemanticType; typedef b4_ltype LocationType; }; } namespace yy { class b4_name b4_inherit { public: typedef Traits< b4_name >::TokenNumberType TokenNumberType; typedef Traits< b4_name >::RhsNumberType RhsNumberType; typedef Traits< b4_name >::StateType StateType; typedef Traits< b4_name >::SemanticType SemanticType; typedef Traits< b4_name >::LocationType LocationType; typedef Stack< StateType > StateStack; typedef Stack< SemanticType > SemanticStack; typedef Stack< LocationType > LocationStack; #if YYLSP_NEEDED b4_name (bool debug, LocationType initlocation[]b4_param) : b4_constructor[]debug_ (debug), cdebug_ (std::cerr), initlocation_ (initlocation) #else b4_name (bool debug[]b4_param) : b4_constructor[]debug_ (debug), cdebug_ (std::cerr) #endif { } virtual ~b4_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 short pact_[[]]; static const short defact_[[]]; static const short pgoto_[[]]; static const short defgoto_[[]]; static const short table_[[]]; static const short check_[[]]; static const b4_uint_type(b4_r1_max) r1_[[]]; static const b4_uint_type(b4_r2_max) r2_[[]]; #if YYDEBUG || YYERROR_VERBOSE static const char* const name_[[]]; #endif /* More tables, for debugging. */ #if YYDEBUG static const RhsNumberType rhs_[[]]; static const b4_uint_type(b4_prhs_max) prhs_[[]]; static const b4_uint_type(b4_rline_max) rline_[[]]; static const b4_uint_type(b4_stos_max) stos_[[]]; static const short token_number_[[]]; #endif /* Even more tables. */ static inline TokenNumberType translate_ (int token); /* Constants. */ static const int eof_; static const int last_; static const int flag_; static const int nnts_; static const int nsym_; 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 /* not b4_header_guard */ #output "b4_output_prefix[]b4_output_infix[].cc" b4_copyright #include "b4_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_name::parse () { int nerrs = 0; int errstatus = 0; /* Initialize stack. */ 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_ == flag_) 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 || n_ > last_ || check_[[n_]] != ilooka_) goto yydefault; /* Reduce or error. */ n_ = table_[[n_]]; if (n_ < 0) { if (n_ == flag_) 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_uint_type(b4_prhs_max) i = prhs_[[n_]]; rhs_[[i]] >= 0; ++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 __file__. */ #line __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 (state_ >= 0 && 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 (n_ > flag_ && n_ < last_) { message = "parse error, unexpected "; message += name_[[ilooka_]]; { int count = 0; for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x) if (check_[[x + n_]] == x) ++count; if (count < 5) { count = 0; for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x) if (check_[[x + n_]] == x) { message += (!count++) ? ", expecting " : " or "; message += name_[[x]]; } } } } else #endif message = "parse 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_ != flag_) { 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 ()) 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_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 short yy::b4_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 short yy::b4_name::defact_[[]] = { b4_defact }; /* YYPGOTO[[NTERM-NUM]]. */ const short yy::b4_name::pgoto_[[]] = { b4_pgoto }; /* YYDEFGOTO[[NTERM-NUM]]. */ const short yy::b4_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 short yy::b4_name::table_[[]] = { b4_table }; /* YYCHECK. */ const short yy::b4_name::check_[[]] = { b4_check }; #if YYDEBUG /* STOS_[[STATE-NUM]] -- The (internal number of the) accessing symbol of state STATE-NUM. */ const b4_uint_type(b4_stos_max) yy::b4_name::stos_[[]] = { b4_stos }; /* TOKEN_NUMBER_[[YYLEX-NUM]] -- Internal token number corresponding to YYLEX-NUM. */ const short yy::b4_name::token_number_[[]] = { b4_toknum }; #endif /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */ const b4_uint_type(b4_r1_max) yy::b4_name::r1_[[]] = { b4_r1 }; /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */ const b4_uint_type(b4_r2_max) yy::b4_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_name::name_[[]] = { b4_tname }; #endif #if YYDEBUG /* YYRHS -- A `-1'-separated list of the rules' RHS. */ const yy::b4_name::RhsNumberType yy::b4_name::rhs_[[]] = { b4_rhs }; /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ const b4_uint_type(b4_prhs_max) yy::b4_name::prhs_[[]] = { b4_prhs }; /* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ const b4_uint_type(b4_rline_max) yy::b4_name::rline_[[]] = { b4_rline }; #endif /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ yy::b4_name::TokenNumberType yy::b4_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_name::eof_ = 0; const int yy::b4_name::last_ = b4_last; const int yy::b4_name::flag_ = b4_flag; const int yy::b4_name::nnts_ = b4_nnts; const int yy::b4_name::nsym_ = b4_nsym; const int yy::b4_name::empty_ = -2; const int yy::b4_name::final_ = b4_final; const int yy::b4_name::terror_ = 1; const int yy::b4_name::errcode_ = 256; const int yy::b4_name::ntokens_ = b4_ntokens; const int yy::b4_name::initdepth_ = b4_initdepth; const unsigned yy::b4_name::user_token_number_max_ = b4_user_token_number_max; const yy::b4_name::TokenNumberType yy::b4_name::undef_token_ = b4_undef_token_number; b4_epilogue #output "stack.hh" b4_copyright #ifndef BISON_STACK_HH # define BISON_STACK_HH #include 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 #output "location.hh" b4_copyright #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