X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/4bb2bc3f61feb703947d4919396ccc6cdc9f61b5..ec3bc39:/data/bison.c%20%20/bison.git/blobdiff_plain/4bb2bc3f61feb703947d4919396ccc6cdc9f61b5..ec3bc39:/data/bison.c++ diff --git a/data/bison.c++ b/data/bison.c++ index 2d2e2ed9..c418bad3 100644 --- a/data/bison.c++ +++ b/data/bison.c++ @@ -1,11 +1,111 @@ -#output "b4_output_prefix[]b4_output_infix[]-class.hh" -/* -*- C++ -*- */ +m4_divert(-1) -/* A Bison parser, made from %%filename, - by GNU bison %%version. */ +# 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 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc. + 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 @@ -25,15 +125,68 @@ /* 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. */ + 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" -b4_prologue +#include + +/* Using locations. */ +#define YYLSP_NEEDED b4_locations_flag + +/* Copy the first part of user declarations. */ +b4_pre_prologue + +/* Tokens. */ +b4_token_defines(b4_tokens) -// FIXME: This should be defined in traits, not here. -typedef b4_stype yystype; +/* 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], +[#line b4_stype_line "b4_filename" +])dnl +typedef b4_stype +yystype; +# define YYSTYPE yystype +#endif + +/* Copy the second part of user declarations. */ +b4_post_prologue + +#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 { @@ -47,6 +200,8 @@ namespace yy 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; @@ -55,21 +210,30 @@ namespace yy namespace yy { - class b4_name + class b4_name b4_inherit { public: - typedef Traits< b4_name >::StateType StateType; - typedef Traits< b4_name >::SemanticType SemanticType; - typedef Traits< b4_name >::LocationType LocationType; + 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; - b4_name (bool debug) : debug_ (debug) +#if YYLSP_NEEDED + b4_name (bool debug, + LocationType initlocation[]b4_param) : + b4_constructor[]debug_ (debug), + initlocation_ (initlocation) +#else + b4_name (bool debug[]b4_param) : + b4_constructor[]debug_ (debug) +#endif { - looka = empty_; } virtual ~b4_name () @@ -80,20 +244,14 @@ namespace yy private: + virtual void lex_ (); virtual void error_ (); - - /* Call to lexical analyser. */ - virtual - void - lex () - { - looka = yylex (&value, &location); - } + virtual void print_ (); /* Stacks. */ - StateStack state_stack; - SemanticStack semantic_stack; - LocationStack location_stack; + StateStack state_stack_; + SemanticStack semantic_stack_; + LocationStack location_stack_; /* Tables. */ static const short pact_[[]]; @@ -102,75 +260,84 @@ namespace yy static const short defgoto_[[]]; static const short table_[[]]; static const short check_[[]]; - static const short r1_[[]]; - static const short r2_[[]]; + 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. */ - /* FIXME: These tables should not be printed when not in debug - mode. %%ifdef? */ - static const short rhs_[[]]; - static const short prhs_[[]]; - static const short rline_[[]]; +#if YYDEBUG + static const RhsNumberType rhs_[[]]; + static const b4_uint_type(b4_prhs_max) prhs_[[]]; + static const b4_uint_type(b4_rline_max) rline_[[]]; +#endif /* Even more tables. */ - static inline char translate (int token); + static inline TokenNumberType translate_ (int token); - /* Eof and empty. */ + /* 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 n_; + int len_; int debug_; - int state; + int state_; - /* Lookahead. */ - int looka; - int ilooka; + /* Lookahead and lookahead in internal form. */ + int looka_; + int ilooka_; /* Message. */ std::string message; - /* @$ and $$. */ + /* 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" -#include "b4_output_prefix[]b4_output_infix-class.hh" +b4_copyright -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG b4_debug -#endif +#include "b4_output_header_name" /* Enable debugging if requested. */ #if YYDEBUG - # include # define YYFPRINTF std::fprintf - # define YYDPRINTF(Args) \ do { \ if (debug_) \ YYFPRINTF Args; \ } while (0) -/* Nonzero means print parse trace. [The following comment makes no - sense to me. Could someone clarify it? --akim] Since this is - uninitialized, it does not stop multiple parsers from coexisting. - */ -int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) #endif /* !YYDEBUG */ -/* Tokens. */ -b4_tokendef - int yy::b4_name::parse () { @@ -178,165 +345,171 @@ yy::b4_name::parse () int errstatus = 0; /* Initialize stack. */ - state_stack = StateStack (0); - semantic_stack = SemanticStack (1); - location_stack = LocationStack (1); - - /* Reserve initial space. The C parser needed that, but is it really - useful here? */ - state_stack.reserve (b4_initdepth); - semantic_stack.reserve (b4_initdepth); - location_stack.reserve (b4_initdepth); + state_stack_ = StateStack (0); + semantic_stack_ = SemanticStack (1); + location_stack_ = LocationStack (1); /* Start. */ - state = 0; + state_ = 0; + looka_ = empty_; +#if YYLSP_NEEDED + location = initlocation_; +#endif YYDPRINTF ((stderr, "Starting parse\n")); /* New state. */ yynewstate: - state_stack.push (state); - YYDPRINTF ((stderr, "Entering state %d\n", state)); + state_stack_.push (state_); + YYDPRINTF ((stderr, "Entering state %d\n", state_)); goto yybackup; /* Backup. */ yybackup: /* Try to take a decision without lookahead. */ - n = pact_[[state]]; - if (n == b4_flag) + n_ = pact_[[state_]]; + if (n_ == flag_) goto yydefault; /* Read a lookahead token. */ - if (looka == empty_) + if (looka_ == empty_) { YYDPRINTF ((stderr, "Reading a token: ")); - lex (); + lex_ (); } /* Convert token to internal form. */ - if (looka <= 0) + if (looka_ <= 0) { - looka = eof_; - ilooka = 0; + looka_ = eof_; + ilooka_ = 0; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { - ilooka = translate (looka); + ilooka_ = translate_ (looka_); #if YYDEBUG if (debug_) { - YYFPRINTF (stderr, "Next token is %d (%s", looka, name_[[ilooka]]); + YYFPRINTF (stderr, "Next token is %d (%s", looka_, name_[[ilooka_]]); + print_ (); YYFPRINTF (stderr, ")\n"); } #endif } - n += ilooka; - if (n < 0 || n > b4_last || check_[[n]] != ilooka) + n_ += ilooka_; + if (n_ < 0 || n_ > last_ || check_[[n_]] != ilooka_) goto yydefault; /* Reduce or error. */ - n = table_[[n]]; - if (n < 0) + n_ = table_[[n_]]; + if (n_ < 0) { - if (n == b4_flag) + if (n_ == flag_) goto yyerrlab; else { - n = -n; + n_ = -n_; goto yyreduce; } } - else if (n == 0) + else if (n_ == 0) goto yyerrlab; - + /* Accept? */ - if (n == b4_final) + if (n_ == final_) goto yyacceptlab; /* Shift the lookahead token. */ - YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka, name_[[ilooka]])); + YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka_, name_[[ilooka_]])); /* Discard the token being shifted unless it is eof. */ - if (looka != eof_) - looka = empty_; + 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; - semantic_stack.push (value); - location_stack.push (location); - state = n; + state_ = n_; goto yynewstate; /* Default action. */ yydefault: - n = defact_[[state]]; - if (n == 0) + n_ = defact_[[state_]]; + if (n_ == 0) goto yyerrlab; goto yyreduce; /* Reduce. */ yyreduce: - len = r2_[[n]]; - if (len) + len_ = r2_[[n_]]; + if (len_) { - value = semantic_stack[[1 - len]]; - location = location_stack[[1 - len]]; + yyval = semantic_stack_[[len_ - 1]]; + yyloc = location_stack_[[len_ - 1]]; } else - { - // FIXME: This is truly ugly. - value = semantic_stack[[0]]; - location = location_stack[[0]]; + { + yyval = semantic_stack_[[0]]; + yyloc = location_stack_[[0]]; } #if YYDEBUG if (debug_) { - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n - 1, rline_[[n]]); - for (unsigned i = prhs_[[n]]; + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n_ - 1, rline_[[n_]]); + for (b4_uint_type(b4_prhs_max) i = prhs_[[n_]]; rhs_[[i]] >= 0; ++i) YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]); - YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n]]]); + YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n_]]]); } #endif - - { - SemanticType& yyval (value); - LocationType& yyloc (location); - SemanticStack& yyvsp (semantic_stack); - LocationStack& yylsp (location_stack); - - switch (n) - { - b4_actions - } - } - - state_stack.pop (len); - semantic_stack.pop (len); - location_stack.pop (len); + + 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_) { YYFPRINTF (stderr, "state stack now"); - for (StateStack::ConstIterator i = state_stack.begin (); - i != state_stack.end (); ++i) + for (StateStack::ConstIterator i = state_stack_.begin (); + i != state_stack_.end (); ++i) YYFPRINTF (stderr, " %d", *i); YYFPRINTF (stderr, "\n"); } #endif - - semantic_stack.push (value); - location_stack.push (location); + + 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 <= b4_last && check_[[state]] == state_stack[[0]]) - state = table_[[state]]; + 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_]]; + state_ = defgoto_[[n_ - ntokens_]]; goto yynewstate; /* Report and recover from errors. This is very incomplete. */ @@ -345,45 +518,130 @@ yy::b4_name::parse () if (!errstatus) { ++nerrs; - - // FIXME: Should be #if YYERROR_VERBOSE from here... - n = pact_[[state]]; - if (n > b4_flag && n < b4_last) + +#if YYERROR_VERBOSE + n_ = pact_[[state_]]; + if (n_ > flag_ && n_ < last_) { message = "parse error, unexpected "; - message += name_[[ilooka]]; + message += name_[[ilooka_]]; { int count = 0; - for (int x = (n < 0 ? -n : 0); x < b4_ntokens + b4_nnts; ++x) - if (check_[[x + n]] == x) + 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 < b4_ntokens + b4_nnts; ++x) - if (check_[[x + n]] == x) + for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x) + if (check_[[x + n_]] == x) { - message += (!count++) ? ", expecting " : " or "; + message += (!count++) ? ", expecting " : " or "; message += name_[[x]]; } } } } else - // FIXME: to there... +#endif message = "parse error"; + error_ (); } - error_ (); - return 1; - + 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; + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", looka_, name_[[ilooka_]])); + looka_ = empty_; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + errstatus = 3; + goto yyerrhandle; + + /* Pop the current state because it cannot handle the error token. */ + yyerrdefault: + yyerrpop: + if (!state_stack_.height ()) + goto yyabortlab; + state_ = (state_stack_.pop (), state_stack_[[0]]); + semantic_stack_.pop (); + location_stack_.pop ();; + +#if YYDEBUG + if (debug_) + { + YYFPRINTF (stderr, "Error: state stack now"); + for (StateStack::ConstIterator i = state_stack_.begin (); + i != state_stack_.end (); ++i) + YYFPRINTF (stderr, " %d", *i); + YYFPRINTF (stderr, "\n"); + } +#endif + + yyerrhandle: + n_ = pact_[[state_]]; + if (n_ == flag_) + goto yyerrdefault; + + n_ += terror_; + if (n_ < 0 || n_ > last_ || check_[[n_]] != terror_) + goto yyerrdefault; + + n_ = table_[[n_]]; + if (n_ < 0) + { + if (n_ == flag_) + goto yyerrpop; + n_ = -n_; + goto yyreduce; + } + else if (!n_) + goto yyerrpop; + + if (n_ == final_) + goto yyacceptlab; + + YYDPRINTF ((stderr, "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 +const short yy::b4_name::pact_[[]] = { b4_pact @@ -392,21 +650,21 @@ yy::b4_name::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 +const short yy::b4_name::defact_[[]] = { b4_defact }; /* YYPGOTO[[NTERM-NUM]]. */ -const short +const short yy::b4_name::pgoto_[[]] = { b4_pgoto }; /* YYDEFGOTO[[NTERM-NUM]]. */ -const short +const short yy::b4_name::defgoto_[[]] = { b4_defgoto @@ -415,40 +673,34 @@ yy::b4_name::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 +const short yy::b4_name::table_[[]] = { b4_table }; /* YYCHECK. */ -const short +const short yy::b4_name::check_[[]] = { b4_check }; -/* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ -const short -yy::b4_name::rline_[[]] = -{ - b4_rline -}; - /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */ -const short +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 short +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* @@ -456,9 +708,11 @@ const yy::b4_name::name_[[]] = { b4_tname }; +#endif +#if YYDEBUG /* YYRHS -- A `-1'-separated list of the rules' RHS. */ -const short +const yy::b4_name::RhsNumberType yy::b4_name::rhs_[[]] = { b4_rhs @@ -466,40 +720,64 @@ yy::b4_name::rhs_[[]] = /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ -const short +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. */ -char -yy::b4_name::translate (int token) +yy::b4_name::TokenNumberType +yy::b4_name::translate_ (int token) { - static - const char + static + const TokenNumberType translate_[[]] = { b4_translate }; - return ((unsigned)(token) <= b4_maxtok ? translate_[[token]] : b4_nsym); + 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 +#include namespace yy { - template < class T, class S = std::vector< T > > + template < class T, class S = std::deque< T > > class Stack { public: @@ -517,23 +795,23 @@ namespace yy inline T& - operator [[]] (int index) + operator [[]] (unsigned index) { - return seq_[[seq_.size () - 1 + index]]; + return seq_[[index]]; } inline const T& - operator [[]] (int index) const + operator [[]] (unsigned index) const { - return seq_[[seq_.size () - 1 + index]]; + return seq_[[index]]; } inline void push (const T& t) { - seq_.push_back (t); + seq_.push_front (t); } inline @@ -541,14 +819,14 @@ namespace yy pop (unsigned n = 1) { for (; n; --n) - seq_.pop_back (); + seq_.pop_front (); } - + inline - void - reserve (unsigned n) + unsigned + height () const { - seq_.reserve (n); + return seq_.size (); } inline ConstIterator begin () const { return seq_.begin (); } @@ -558,11 +836,37 @@ namespace yy 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 @@ -582,37 +886,3 @@ namespace yy } #endif // not BISON_LOCATION_HH - -m4_if(b4_defines_flag, 0, [], -[#output "b4_output_header_name" -#ifndef b4_header_guard -# define b4_header_guard - -b4_tokendef - -#ifndef YYSTYPE -typedef b4_stype -yystype; -# define YYSTYPE yystype -#endif - -m4_if(b4_pure, [0], -[extern YYSTYPE b4_prefix[]lval;]) - -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 - -m4_if(b4_pure, [0], -[extern YYLTYPE b4_prefix[]lloc;]) -]) -#endif /* not b4_header_guard */ -])