Index: bison/src/bison/2.4.1/bison-2.4.1-src/data/lalr1.cc |
=================================================================== |
--- bison/src/bison/2.4.1/bison-2.4.1-src/data/lalr1.cc (revision 0) |
+++ bison/src/bison/2.4.1/bison-2.4.1-src/data/lalr1.cc (revision 0) |
@@ -0,0 +1,1157 @@ |
+# C++ skeleton for Bison |
+ |
+# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 |
+# 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 3 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, see <http://www.gnu.org/licenses/>. |
+ |
+m4_include(b4_pkgdatadir/[c++.m4]) |
+ |
+m4_define([b4_parser_class_name], |
+ [b4_percent_define_get([[parser_class_name]])]) |
+ |
+# The header is mandatory. |
+b4_defines_if([], |
+ [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) |
+ |
+# Backward compatibility. |
+m4_define([b4_location_constructors]) |
+m4_include(b4_pkgdatadir/[location.cc]) |
+ |
+# We do want M4 expansion after # for CPP macros. |
+m4_changecom() |
+m4_divert_push(0)dnl |
+b4_defines_if( |
+[@output(b4_spec_defines_file@) |
+b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++], |
+ [2002, 2003, 2004, 2005, 2006, 2007, 2008]) |
+dnl FIXME: This is wrong, we want computed header guards. |
+[ |
+/* C++ LALR(1) parser skeleton written by Akim Demaille. */ |
+ |
+#ifndef PARSER_HEADER_H |
+# define PARSER_HEADER_H |
+ |
+]b4_percent_code_get([[requires]])[ |
+ |
+#include <string> |
+#include <iostream> |
+#include "stack.hh" |
+ |
+]b4_namespace_open[ |
+ class position; |
+ class location; |
+]b4_namespace_close[ |
+ |
+#include "location.hh" |
+ |
+/* Enabling traces. */ |
+#ifndef YYDEBUG |
+# define YYDEBUG ]b4_debug_flag[ |
+#endif |
+ |
+/* Enabling verbose error messages. */ |
+#ifdef YYERROR_VERBOSE |
+# undef YYERROR_VERBOSE |
+# define YYERROR_VERBOSE 1 |
+#else |
+# define YYERROR_VERBOSE ]b4_error_verbose_flag[ |
+#endif |
+ |
+/* Enabling the token table. */ |
+#ifndef YYTOKEN_TABLE |
+# define YYTOKEN_TABLE ]b4_token_table[ |
+#endif |
+ |
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
+ If N is 0, then set CURRENT to the empty location which ends |
+ the previous symbol: RHS[0] (always defined). */ |
+ |
+#ifndef YYLLOC_DEFAULT |
+# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
+do { \ |
+ if (N) \ |
+ { \ |
+ (Current).begin = (Rhs)[1].begin; \ |
+ (Current).end = (Rhs)[N].end; \ |
+ } \ |
+ else \ |
+ { \ |
+ (Current).begin = (Current).end = (Rhs)[0].end; \ |
+ } \ |
+} while (false) |
+#endif |
+ |
+]b4_namespace_open[ |
+ |
+ /// A Bison parser. |
+ class ]b4_parser_class_name[ |
+ { |
+ public: |
+ /// Symbol semantic values. |
+#ifndef YYSTYPE |
+]m4_ifdef([b4_stype], |
+[ union semantic_type |
+ { |
+b4_user_stype |
+ };], |
+[m4_if(b4_tag_seen_flag, 0, |
+[[ typedef int semantic_type;]], |
+[[ typedef YYSTYPE semantic_type;]])])[ |
+#else |
+ typedef YYSTYPE semantic_type; |
+#endif |
+ /// Symbol locations. |
+ typedef ]b4_percent_define_get([[location_type]])[ location_type; |
+ /// Tokens. |
+ struct token |
+ { |
+ ]b4_token_enums(b4_tokens)[ |
+ }; |
+ /// Token type. |
+ typedef token::yytokentype token_type; |
+ |
+ /// Build a parser object. |
+ ]b4_parser_class_name[ (]b4_parse_param_decl[); |
+ virtual ~]b4_parser_class_name[ (); |
+ |
+ /// Parse. |
+ /// \returns 0 iff parsing succeeded. |
+ virtual int parse (); |
+ |
+#if YYDEBUG |
+ /// The current debugging stream. |
+ std::ostream& debug_stream () const; |
+ /// Set the current debugging stream. |
+ void set_debug_stream (std::ostream &); |
+ |
+ /// Type for debugging levels. |
+ typedef int debug_level_type; |
+ /// The current debugging level. |
+ debug_level_type debug_level () const; |
+ /// Set the current debugging level. |
+ void set_debug_level (debug_level_type l); |
+#endif |
+ |
+ private: |
+ /// Report a syntax error. |
+ /// \param loc where the syntax error is found. |
+ /// \param msg a description of the syntax error. |
+ virtual void error (const location_type& loc, const std::string& msg); |
+ |
+ /// Generate an error message. |
+ /// \param state the state where the error occurred. |
+ /// \param tok the lookahead token. |
+ virtual std::string yysyntax_error_ (int yystate]dnl |
+b4_error_verbose_if([, int tok])[); |
+ |
+#if YYDEBUG |
+ /// \brief Report a symbol value on the debug stream. |
+ /// \param yytype The token type. |
+ /// \param yyvaluep Its semantic value. |
+ /// \param yylocationp Its location. |
+ virtual void yy_symbol_value_print_ (int yytype, |
+ const semantic_type* yyvaluep, |
+ const location_type* yylocationp); |
+ /// \brief Report a symbol on the debug stream. |
+ /// \param yytype The token type. |
+ /// \param yyvaluep Its semantic value. |
+ /// \param yylocationp Its location. |
+ virtual void yy_symbol_print_ (int yytype, |
+ const semantic_type* yyvaluep, |
+ const location_type* yylocationp); |
+#endif |
+ |
+ |
+ /// State numbers. |
+ typedef int state_type; |
+ /// State stack type. |
+ typedef stack<state_type> state_stack_type; |
+ /// Semantic value stack type. |
+ typedef stack<semantic_type> semantic_stack_type; |
+ /// location stack type. |
+ typedef stack<location_type> location_stack_type; |
+ |
+ /// The state stack. |
+ state_stack_type yystate_stack_; |
+ /// The semantic value stack. |
+ semantic_stack_type yysemantic_stack_; |
+ /// The location stack. |
+ location_stack_type yylocation_stack_; |
+ |
+ /// Internal symbol numbers. |
+ typedef ]b4_int_type_for([b4_translate])[ token_number_type; |
+ /* Tables. */ |
+ /// For a state, the index in \a yytable_ of its portion. |
+ static const ]b4_int_type_for([b4_pact])[ yypact_[]; |
+ static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; |
+ |
+ /// For a state, default rule to reduce. |
+ /// Unless\a yytable_ specifies something else to do. |
+ /// Zero means the default is an error. |
+ static const ]b4_int_type_for([b4_defact])[ yydefact_[]; |
+ |
+ static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[]; |
+ static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[]; |
+ |
+ /// What to do in a state. |
+ /// \a yytable_[yypact_[s]]: what to do in state \a s. |
+ /// - if positive, shift that token. |
+ /// - if negative, reduce the rule which number is the opposite. |
+ /// - if zero, do what YYDEFACT says. |
+ static const ]b4_int_type_for([b4_table])[ yytable_[]; |
+ static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; |
+ |
+ static const ]b4_int_type_for([b4_check])[ yycheck_[]; |
+ |
+ /// For a state, its accessing symbol. |
+ static const ]b4_int_type_for([b4_stos])[ yystos_[]; |
+ |
+ /// For a rule, its LHS. |
+ static const ]b4_int_type_for([b4_r1])[ yyr1_[]; |
+ /// For a rule, its RHS length. |
+ static const ]b4_int_type_for([b4_r2])[ yyr2_[]; |
+ |
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
+ /// For a symbol, its name in clear. |
+ static const char* const yytname_[]; |
+#endif |
+ |
+#if YYERROR_VERBOSE |
+ /// Convert the symbol name \a n to a form suitable for a diagnostic. |
+ virtual std::string yytnamerr_ (const char *n); |
+#endif |
+ |
+#if YYDEBUG |
+ /// A type to store symbol numbers and -1. |
+ typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type; |
+ /// A `-1'-separated list of the rules' RHS. |
+ static const rhs_number_type yyrhs_[]; |
+ /// For each rule, the index of the first RHS symbol in \a yyrhs_. |
+ static const ]b4_int_type_for([b4_prhs])[ yyprhs_[]; |
+ /// For each rule, its source line number. |
+ static const ]b4_int_type_for([b4_rline])[ yyrline_[]; |
+ /// For each scanner token number, its symbol number. |
+ static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[]; |
+ /// Report on the debug stream that the rule \a r is going to be reduced. |
+ virtual void yy_reduce_print_ (int r); |
+ /// Print the state stack on the debug stream. |
+ virtual void yystack_print_ (); |
+ |
+ /* Debugging. */ |
+ int yydebug_; |
+ std::ostream* yycdebug_; |
+#endif |
+ |
+ /// Convert a scanner token number \a t to a symbol number. |
+ token_number_type yytranslate_ (int t); |
+ |
+ /// \brief Reclaim the memory associated to a symbol. |
+ /// \param yymsg Why this token is reclaimed. |
+ /// \param yytype The symbol type. |
+ /// \param yyvaluep Its semantic value. |
+ /// \param yylocationp Its location. |
+ inline void yydestruct_ (const char* yymsg, |
+ int yytype, |
+ semantic_type* yyvaluep, |
+ location_type* yylocationp); |
+ |
+ /// Pop \a n symbols the three stacks. |
+ inline void yypop_ (unsigned int n = 1); |
+ |
+ /* Constants. */ |
+ static const int yyeof_; |
+ /* LAST_ -- Last index in TABLE_. */ |
+ static const int yylast_; |
+ static const int yynnts_; |
+ static const int yyempty_; |
+ static const int yyfinal_; |
+ static const int yyterror_; |
+ static const int yyerrcode_; |
+ static const int yyntokens_; |
+ static const unsigned int yyuser_token_number_max_; |
+ static const token_number_type yyundef_token_; |
+]b4_parse_param_vars[ |
+ }; |
+]b4_namespace_close[ |
+ |
+]b4_percent_define_flag_if([[global_tokens_and_yystype]], |
+[b4_token_defines(b4_tokens) |
+ |
+#ifndef YYSTYPE |
+ /* Redirection for backward compatibility. */ |
+# define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type |
+#endif |
+]) |
+b4_percent_code_get([[provides]])[]dnl |
+ |
+[#endif /* ! defined PARSER_HEADER_H */] |
+])dnl |
+@output(b4_parser_file_name@) |
+b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++], |
+ [2002, 2003, 2004, 2005, 2006, 2007, 2008]) |
+b4_percent_code_get([[top]])[]dnl |
+m4_if(b4_prefix, [yy], [], |
+[ |
+// Take the name prefix into account. |
+#define yylex b4_prefix[]lex])[ |
+ |
+/* First part of user declarations. */ |
+]b4_user_pre_prologue |
+ |
+b4_defines_if([[ |
+#include "@basename(]b4_spec_defines_file[@)"]])[ |
+ |
+/* User implementation prologue. */ |
+]b4_user_post_prologue |
+b4_percent_code_get[]dnl |
+ |
+[#ifndef YY_ |
+# if YYENABLE_NLS |
+# if ENABLE_NLS |
+# include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */ |
+# define YY_(msgid) dgettext ("bison-runtime", msgid) |
+# endif |
+# endif |
+# ifndef YY_ |
+# define YY_(msgid) msgid |
+# endif |
+#endif |
+ |
+/* Suppress unused-variable warnings by "using" E. */ |
+#define YYUSE(e) ((void) (e)) |
+ |
+/* Enable debugging if requested. */ |
+#if YYDEBUG |
+ |
+/* A pseudo ostream that takes yydebug_ into account. */ |
+# define YYCDEBUG if (yydebug_) (*yycdebug_) |
+ |
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
+do { \ |
+ if (yydebug_) \ |
+ { \ |
+ *yycdebug_ << Title << ' '; \ |
+ yy_symbol_print_ ((Type), (Value), (Location)); \ |
+ *yycdebug_ << std::endl; \ |
+ } \ |
+} while (false) |
+ |
+# define YY_REDUCE_PRINT(Rule) \ |
+do { \ |
+ if (yydebug_) \ |
+ yy_reduce_print_ (Rule); \ |
+} while (false) |
+ |
+# define YY_STACK_PRINT() \ |
+do { \ |
+ if (yydebug_) \ |
+ yystack_print_ (); \ |
+} while (false) |
+ |
+#else /* !YYDEBUG */ |
+ |
+# define YYCDEBUG if (false) std::cerr |
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) |
+# define YY_REDUCE_PRINT(Rule) |
+# define YY_STACK_PRINT() |
+ |
+#endif /* !YYDEBUG */ |
+ |
+#define yyerrok (yyerrstatus_ = 0) |
+#define yyclearin (yychar = yyempty_) |
+ |
+#define YYACCEPT goto yyacceptlab |
+#define YYABORT goto yyabortlab |
+#define YYERROR goto yyerrorlab |
+#define YYRECOVERING() (!!yyerrstatus_) |
+ |
+]b4_namespace_open[ |
+#if YYERROR_VERBOSE |
+ |
+ /* Return YYSTR after stripping away unnecessary quotes and |
+ backslashes, so that it's suitable for yyerror. The heuristic is |
+ that double-quoting is unnecessary unless the string contains an |
+ apostrophe, a comma, or backslash (other than backslash-backslash). |
+ YYSTR is taken from yytname. */ |
+ std::string |
+ ]b4_parser_class_name[::yytnamerr_ (const char *yystr) |
+ { |
+ if (*yystr == '"') |
+ { |
+ std::string yyr = ""; |
+ char const *yyp = yystr; |
+ |
+ for (;;) |
+ switch (*++yyp) |
+ { |
+ case '\'': |
+ case ',': |
+ goto do_not_strip_quotes; |
+ |
+ case '\\': |
+ if (*++yyp != '\\') |
+ goto do_not_strip_quotes; |
+ /* Fall through. */ |
+ default: |
+ yyr += *yyp; |
+ break; |
+ |
+ case '"': |
+ return yyr; |
+ } |
+ do_not_strip_quotes: ; |
+ } |
+ |
+ return yystr; |
+ } |
+ |
+#endif |
+ |
+ /// Build a parser object. |
+ ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ |
+ :])[ |
+#if YYDEBUG |
+ ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false), |
+ yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ |
+#endif]b4_parse_param_cons[ |
+ { |
+ } |
+ |
+ ]b4_parser_class_name::~b4_parser_class_name[ () |
+ { |
+ } |
+ |
+#if YYDEBUG |
+ /*--------------------------------. |
+ | Print this symbol on YYOUTPUT. | |
+ `--------------------------------*/ |
+ |
+ inline void |
+ ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, |
+ const semantic_type* yyvaluep, const location_type* yylocationp) |
+ { |
+ YYUSE (yylocationp); |
+ YYUSE (yyvaluep); |
+ switch (yytype) |
+ { |
+ ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl |
+[ default: |
+ break; |
+ } |
+ } |
+ |
+ |
+ void |
+ ]b4_parser_class_name[::yy_symbol_print_ (int yytype, |
+ const semantic_type* yyvaluep, const location_type* yylocationp) |
+ { |
+ *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") |
+ << ' ' << yytname_[yytype] << " (" |
+ << *yylocationp << ": "; |
+ yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); |
+ *yycdebug_ << ')'; |
+ } |
+#endif |
+ |
+ void |
+ ]b4_parser_class_name[::yydestruct_ (const char* yymsg, |
+ int yytype, semantic_type* yyvaluep, location_type* yylocationp) |
+ { |
+ YYUSE (yylocationp); |
+ YYUSE (yymsg); |
+ YYUSE (yyvaluep); |
+ |
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); |
+ |
+ switch (yytype) |
+ { |
+ ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ |
+ default: |
+ break; |
+ } |
+ } |
+ |
+ void |
+ ]b4_parser_class_name[::yypop_ (unsigned int n) |
+ { |
+ yystate_stack_.pop (n); |
+ yysemantic_stack_.pop (n); |
+ yylocation_stack_.pop (n); |
+ } |
+ |
+#if YYDEBUG |
+ std::ostream& |
+ ]b4_parser_class_name[::debug_stream () const |
+ { |
+ return *yycdebug_; |
+ } |
+ |
+ void |
+ ]b4_parser_class_name[::set_debug_stream (std::ostream& o) |
+ { |
+ yycdebug_ = &o; |
+ } |
+ |
+ |
+ ]b4_parser_class_name[::debug_level_type |
+ ]b4_parser_class_name[::debug_level () const |
+ { |
+ return yydebug_; |
+ } |
+ |
+ void |
+ ]b4_parser_class_name[::set_debug_level (debug_level_type l) |
+ { |
+ yydebug_ = l; |
+ } |
+#endif |
+ |
+ int |
+ ]b4_parser_class_name[::parse () |
+ { |
+ /// Lookahead and lookahead in internal form. |
+ int yychar = yyempty_; |
+ int yytoken = 0; |
+ |
+ /* State. */ |
+ int yyn; |
+ int yylen = 0; |
+ int yystate = 0; |
+ |
+ /* Error handling. */ |
+ int yynerrs_ = 0; |
+ int yyerrstatus_ = 0; |
+ |
+ /// Semantic value of the lookahead. |
+ semantic_type yylval; |
+ /// Location of the lookahead. |
+ location_type yylloc; |
+ /// The locations where the error started and ended. |
+ location_type yyerror_range[2]; |
+ |
+ /// $$. |
+ semantic_type yyval; |
+ /// @@$. |
+ location_type yyloc; |
+ |
+ int yyresult; |
+ |
+ YYCDEBUG << "Starting parse" << std::endl; |
+ |
+]m4_ifdef([b4_initial_action], [ |
+m4_pushdef([b4_at_dollar], [yylloc])dnl |
+m4_pushdef([b4_dollar_dollar], [yylval])dnl |
+ /* User initialization code. */ |
+ b4_user_initial_action |
+m4_popdef([b4_dollar_dollar])dnl |
+m4_popdef([b4_at_dollar])])dnl |
+ |
+ [ /* 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. */ |
+ yystate_stack_ = state_stack_type (0); |
+ yysemantic_stack_ = semantic_stack_type (0); |
+ yylocation_stack_ = location_stack_type (0); |
+ yysemantic_stack_.push (yylval); |
+ yylocation_stack_.push (yylloc); |
+ |
+ /* New state. */ |
+ yynewstate: |
+ yystate_stack_.push (yystate); |
+ YYCDEBUG << "Entering state " << yystate << std::endl; |
+ |
+ /* Accept? */ |
+ if (yystate == yyfinal_) |
+ goto yyacceptlab; |
+ |
+ goto yybackup; |
+ |
+ /* Backup. */ |
+ yybackup: |
+ |
+ /* Try to take a decision without lookahead. */ |
+ yyn = yypact_[yystate]; |
+ if (yyn == yypact_ninf_) |
+ goto yydefault; |
+ |
+ /* Read a lookahead token. */ |
+ if (yychar == yyempty_) |
+ { |
+ YYCDEBUG << "Reading a token: "; |
+ yychar = ]b4_c_function_call([yylex], [int], |
+ [[YYSTYPE*], [&yylval]][]dnl |
+b4_locations_if([, [[location*], [&yylloc]]])dnl |
+m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; |
+ } |
+ |
+ |
+ /* Convert token to internal form. */ |
+ if (yychar <= yyeof_) |
+ { |
+ yychar = yytoken = yyeof_; |
+ YYCDEBUG << "Now at end of input." << std::endl; |
+ } |
+ else |
+ { |
+ yytoken = yytranslate_ (yychar); |
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
+ } |
+ |
+ /* If the proper action on seeing token YYTOKEN is to reduce or to |
+ detect an error, take that action. */ |
+ yyn += yytoken; |
+ if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) |
+ goto yydefault; |
+ |
+ /* Reduce or error. */ |
+ yyn = yytable_[yyn]; |
+ if (yyn <= 0) |
+ { |
+ if (yyn == 0 || yyn == yytable_ninf_) |
+ goto yyerrlab; |
+ yyn = -yyn; |
+ goto yyreduce; |
+ } |
+ |
+ /* Shift the lookahead token. */ |
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
+ |
+ /* Discard the token being shifted. */ |
+ yychar = yyempty_; |
+ |
+ yysemantic_stack_.push (yylval); |
+ yylocation_stack_.push (yylloc); |
+ |
+ /* Count tokens shifted since error; after three, turn off error |
+ status. */ |
+ if (yyerrstatus_) |
+ --yyerrstatus_; |
+ |
+ yystate = yyn; |
+ goto yynewstate; |
+ |
+ /*-----------------------------------------------------------. |
+ | yydefault -- do the default action for the current state. | |
+ `-----------------------------------------------------------*/ |
+ yydefault: |
+ yyn = yydefact_[yystate]; |
+ if (yyn == 0) |
+ goto yyerrlab; |
+ goto yyreduce; |
+ |
+ /*-----------------------------. |
+ | yyreduce -- Do a reduction. | |
+ `-----------------------------*/ |
+ yyreduce: |
+ yylen = yyr2_[yyn]; |
+ /* If YYLEN 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 (yylen) |
+ yyval = yysemantic_stack_[yylen - 1]; |
+ else |
+ yyval = yysemantic_stack_[0]; |
+ |
+ { |
+ slice<location_type, location_stack_type> slice (yylocation_stack_, yylen); |
+ YYLLOC_DEFAULT (yyloc, slice, yylen); |
+ } |
+ YY_REDUCE_PRINT (yyn); |
+ switch (yyn) |
+ { |
+ ]b4_user_actions[ |
+ default: |
+ break; |
+ } |
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc); |
+ |
+ yypop_ (yylen); |
+ yylen = 0; |
+ YY_STACK_PRINT (); |
+ |
+ yysemantic_stack_.push (yyval); |
+ yylocation_stack_.push (yyloc); |
+ |
+ /* Shift the result of the reduction. */ |
+ yyn = yyr1_[yyn]; |
+ yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0]; |
+ if (0 <= yystate && yystate <= yylast_ |
+ && yycheck_[yystate] == yystate_stack_[0]) |
+ yystate = yytable_[yystate]; |
+ else |
+ yystate = yydefgoto_[yyn - yyntokens_]; |
+ goto yynewstate; |
+ |
+ /*------------------------------------. |
+ | yyerrlab -- here on detecting error | |
+ `------------------------------------*/ |
+ yyerrlab: |
+ /* If not already recovering from an error, report this error. */ |
+ if (!yyerrstatus_) |
+ { |
+ ++yynerrs_; |
+ error (yylloc, yysyntax_error_ (yystate]dnl |
+b4_error_verbose_if([, yytoken])[)); |
+ } |
+ |
+ yyerror_range[0] = yylloc; |
+ if (yyerrstatus_ == 3) |
+ { |
+ /* If just tried and failed to reuse lookahead token after an |
+ error, discard it. */ |
+ |
+ if (yychar <= yyeof_) |
+ { |
+ /* Return failure if at end of input. */ |
+ if (yychar == yyeof_) |
+ YYABORT; |
+ } |
+ else |
+ { |
+ yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc); |
+ yychar = yyempty_; |
+ } |
+ } |
+ |
+ /* Else will try to reuse lookahead token after shifting the error |
+ token. */ |
+ goto yyerrlab1; |
+ |
+ |
+ /*---------------------------------------------------. |
+ | yyerrorlab -- error raised explicitly by YYERROR. | |
+ `---------------------------------------------------*/ |
+ yyerrorlab: |
+ |
+ /* Pacify compilers like GCC when the user code never invokes |
+ YYERROR and the label yyerrorlab therefore never appears in user |
+ code. */ |
+ if (false) |
+ goto yyerrorlab; |
+ |
+ yyerror_range[0] = yylocation_stack_[yylen - 1]; |
+ /* Do not reclaim the symbols of the rule which action triggered |
+ this YYERROR. */ |
+ yypop_ (yylen); |
+ yylen = 0; |
+ yystate = yystate_stack_[0]; |
+ goto yyerrlab1; |
+ |
+ /*-------------------------------------------------------------. |
+ | yyerrlab1 -- common code for both syntax error and YYERROR. | |
+ `-------------------------------------------------------------*/ |
+ yyerrlab1: |
+ yyerrstatus_ = 3; /* Each real token shifted decrements this. */ |
+ |
+ for (;;) |
+ { |
+ yyn = yypact_[yystate]; |
+ if (yyn != yypact_ninf_) |
+ { |
+ yyn += yyterror_; |
+ if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) |
+ { |
+ yyn = yytable_[yyn]; |
+ if (0 < yyn) |
+ break; |
+ } |
+ } |
+ |
+ /* Pop the current state because it cannot handle the error token. */ |
+ if (yystate_stack_.height () == 1) |
+ YYABORT; |
+ |
+ yyerror_range[0] = yylocation_stack_[0]; |
+ yydestruct_ ("Error: popping", |
+ yystos_[yystate], |
+ &yysemantic_stack_[0], &yylocation_stack_[0]); |
+ yypop_ (); |
+ yystate = yystate_stack_[0]; |
+ YY_STACK_PRINT (); |
+ } |
+ |
+ yyerror_range[1] = yylloc; |
+ // Using YYLLOC is tempting, but would change the location of |
+ // the lookahead. YYLOC is available though. |
+ YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); |
+ yysemantic_stack_.push (yylval); |
+ yylocation_stack_.push (yyloc); |
+ |
+ /* Shift the error token. */ |
+ YY_SYMBOL_PRINT ("Shifting", yystos_[yyn], |
+ &yysemantic_stack_[0], &yylocation_stack_[0]); |
+ |
+ yystate = yyn; |
+ goto yynewstate; |
+ |
+ /* Accept. */ |
+ yyacceptlab: |
+ yyresult = 0; |
+ goto yyreturn; |
+ |
+ /* Abort. */ |
+ yyabortlab: |
+ yyresult = 1; |
+ goto yyreturn; |
+ |
+ yyreturn: |
+ if (yychar != yyempty_) |
+ yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc); |
+ |
+ /* Do not reclaim the symbols of the rule which action triggered |
+ this YYABORT or YYACCEPT. */ |
+ yypop_ (yylen); |
+ while (yystate_stack_.height () != 1) |
+ { |
+ yydestruct_ ("Cleanup: popping", |
+ yystos_[yystate_stack_[0]], |
+ &yysemantic_stack_[0], |
+ &yylocation_stack_[0]); |
+ yypop_ (); |
+ } |
+ |
+ return yyresult; |
+ } |
+ |
+ // Generate an error message. |
+ std::string |
+ ]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl |
+b4_error_verbose_if([, int tok])[) |
+ { |
+ std::string res; |
+ YYUSE (yystate); |
+#if YYERROR_VERBOSE |
+ int yyn = yypact_[yystate]; |
+ if (yypact_ninf_ < yyn && yyn <= yylast_) |
+ { |
+ /* Start YYX at -YYN if negative to avoid negative indexes in |
+ YYCHECK. */ |
+ int yyxbegin = yyn < 0 ? -yyn : 0; |
+ |
+ /* Stay within bounds of both yycheck and yytname. */ |
+ int yychecklim = yylast_ - yyn + 1; |
+ int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; |
+ int count = 0; |
+ for (int x = yyxbegin; x < yyxend; ++x) |
+ if (yycheck_[x + yyn] == x && x != yyterror_) |
+ ++count; |
+ |
+ // FIXME: This method of building the message is not compatible |
+ // with internationalization. It should work like yacc.c does it. |
+ // That is, first build a string that looks like this: |
+ // "syntax error, unexpected %s or %s or %s" |
+ // Then, invoke YY_ on this string. |
+ // Finally, use the string as a format to output |
+ // yytname_[tok], etc. |
+ // Until this gets fixed, this message appears in English only. |
+ res = "syntax error, unexpected "; |
+ res += yytnamerr_ (yytname_[tok]); |
+ if (count < 5) |
+ { |
+ count = 0; |
+ for (int x = yyxbegin; x < yyxend; ++x) |
+ if (yycheck_[x + yyn] == x && x != yyterror_) |
+ { |
+ res += (!count++) ? ", expecting " : " or "; |
+ res += yytnamerr_ (yytname_[x]); |
+ } |
+ } |
+ } |
+ else |
+#endif |
+ res = YY_("syntax error"); |
+ return res; |
+ } |
+ |
+ |
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
+ STATE-NUM. */ |
+ const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; |
+ const ]b4_int_type_for([b4_pact])[ |
+ ]b4_parser_class_name[::yypact_[] = |
+ { |
+ ]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])[ |
+ ]b4_parser_class_name[::yydefact_[] = |
+ { |
+ ]b4_defact[ |
+ }; |
+ |
+ /* YYPGOTO[NTERM-NUM]. */ |
+ const ]b4_int_type_for([b4_pgoto])[ |
+ ]b4_parser_class_name[::yypgoto_[] = |
+ { |
+ ]b4_pgoto[ |
+ }; |
+ |
+ /* YYDEFGOTO[NTERM-NUM]. */ |
+ const ]b4_int_type_for([b4_defgoto])[ |
+ ]b4_parser_class_name[::yydefgoto_[] = |
+ { |
+ ]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(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; |
+ const ]b4_int_type_for([b4_table])[ |
+ ]b4_parser_class_name[::yytable_[] = |
+ { |
+ ]b4_table[ |
+ }; |
+ |
+ /* YYCHECK. */ |
+ const ]b4_int_type_for([b4_check])[ |
+ ]b4_parser_class_name[::yycheck_[] = |
+ { |
+ ]b4_check[ |
+ }; |
+ |
+ /* STOS_[STATE-NUM] -- The (internal number of the) accessing |
+ symbol of state STATE-NUM. */ |
+ const ]b4_int_type_for([b4_stos])[ |
+ ]b4_parser_class_name[::yystos_[] = |
+ { |
+ ]b4_stos[ |
+ }; |
+ |
+#if YYDEBUG |
+ /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding |
+ to YYLEX-NUM. */ |
+ const ]b4_int_type_for([b4_toknum])[ |
+ ]b4_parser_class_name[::yytoken_number_[] = |
+ { |
+ ]b4_toknum[ |
+ }; |
+#endif |
+ |
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
+ const ]b4_int_type_for([b4_r1])[ |
+ ]b4_parser_class_name[::yyr1_[] = |
+ { |
+ ]b4_r1[ |
+ }; |
+ |
+ /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
+ const ]b4_int_type_for([b4_r2])[ |
+ ]b4_parser_class_name[::yyr2_[] = |
+ { |
+ ]b4_r2[ |
+ }; |
+ |
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
+ /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
+ First, the terminals, then, starting at \a yyntokens_, nonterminals. */ |
+ const char* |
+ const ]b4_parser_class_name[::yytname_[] = |
+ { |
+ ]b4_tname[ |
+ }; |
+#endif |
+ |
+#if YYDEBUG |
+ /* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
+ const ]b4_parser_class_name[::rhs_number_type |
+ ]b4_parser_class_name[::yyrhs_[] = |
+ { |
+ ]b4_rhs[ |
+ }; |
+ |
+ /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
+ YYRHS. */ |
+ const ]b4_int_type_for([b4_prhs])[ |
+ ]b4_parser_class_name[::yyprhs_[] = |
+ { |
+ ]b4_prhs[ |
+ }; |
+ |
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ |
+ const ]b4_int_type_for([b4_rline])[ |
+ ]b4_parser_class_name[::yyrline_[] = |
+ { |
+ ]b4_rline[ |
+ }; |
+ |
+ // Print the state stack on the debug stream. |
+ void |
+ ]b4_parser_class_name[::yystack_print_ () |
+ { |
+ *yycdebug_ << "Stack now"; |
+ for (state_stack_type::const_iterator i = yystate_stack_.begin (); |
+ i != yystate_stack_.end (); ++i) |
+ *yycdebug_ << ' ' << *i; |
+ *yycdebug_ << std::endl; |
+ } |
+ |
+ // Report on the debug stream that the rule \a yyrule is going to be reduced. |
+ void |
+ ]b4_parser_class_name[::yy_reduce_print_ (int yyrule) |
+ { |
+ unsigned int yylno = yyrline_[yyrule]; |
+ int yynrhs = yyr2_[yyrule]; |
+ /* Print the symbols being reduced, and their result. */ |
+ *yycdebug_ << "Reducing stack by rule " << yyrule - 1 |
+ << " (line " << yylno << "):" << std::endl; |
+ /* The symbols being reduced. */ |
+ for (int yyi = 0; yyi < yynrhs; yyi++) |
+ YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", |
+ yyrhs_[yyprhs_[yyrule] + yyi], |
+ &]b4_rhs_value(yynrhs, yyi + 1)[, |
+ &]b4_rhs_location(yynrhs, yyi + 1)[); |
+ } |
+#endif // YYDEBUG |
+ |
+ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
+ ]b4_parser_class_name[::token_number_type |
+ ]b4_parser_class_name[::yytranslate_ (int t) |
+ { |
+ static |
+ const token_number_type |
+ translate_table[] = |
+ { |
+ ]b4_translate[ |
+ }; |
+ if ((unsigned int) t <= yyuser_token_number_max_) |
+ return translate_table[t]; |
+ else |
+ return yyundef_token_; |
+ } |
+ |
+ const int ]b4_parser_class_name[::yyeof_ = 0; |
+ const int ]b4_parser_class_name[::yylast_ = ]b4_last[; |
+ const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[; |
+ const int ]b4_parser_class_name[::yyempty_ = -2; |
+ const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[; |
+ const int ]b4_parser_class_name[::yyterror_ = 1; |
+ const int ]b4_parser_class_name[::yyerrcode_ = 256; |
+ const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[; |
+ |
+ const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[; |
+ const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[; |
+ |
+]b4_namespace_close[ |
+ |
+]b4_epilogue |
+dnl |
+@output(b4_dir_prefix[]stack.hh@) |
+b4_copyright([Stack handling for Bison parsers in C++], |
+ [2002, 2003, 2004, 2005, 2006, 2007, 2008])[ |
+ |
+#ifndef BISON_STACK_HH |
+# define BISON_STACK_HH |
+ |
+#include <deque> |
+ |
+]b4_namespace_open[ |
+ template <class T, class S = std::deque<T> > |
+ class stack |
+ { |
+ public: |
+ |
+ // Hide our reversed order. |
+ typedef typename S::reverse_iterator iterator; |
+ typedef typename S::const_reverse_iterator const_iterator; |
+ |
+ stack () : seq_ () |
+ { |
+ } |
+ |
+ stack (unsigned int n) : seq_ (n) |
+ { |
+ } |
+ |
+ inline |
+ T& |
+ operator [] (unsigned int i) |
+ { |
+ return seq_[i]; |
+ } |
+ |
+ inline |
+ const T& |
+ operator [] (unsigned int i) const |
+ { |
+ return seq_[i]; |
+ } |
+ |
+ inline |
+ void |
+ push (const T& t) |
+ { |
+ seq_.push_front (t); |
+ } |
+ |
+ inline |
+ void |
+ pop (unsigned int n = 1) |
+ { |
+ for (; n; --n) |
+ seq_.pop_front (); |
+ } |
+ |
+ inline |
+ unsigned int |
+ height () const |
+ { |
+ return seq_.size (); |
+ } |
+ |
+ inline const_iterator begin () const { return seq_.rbegin (); } |
+ inline const_iterator end () const { return seq_.rend (); } |
+ |
+ private: |
+ |
+ S seq_; |
+ }; |
+ |
+ /// Present a slice of the top of a stack. |
+ template <class T, class S = stack<T> > |
+ class slice |
+ { |
+ public: |
+ |
+ slice (const S& stack, |
+ unsigned int range) : stack_ (stack), |
+ range_ (range) |
+ { |
+ } |
+ |
+ inline |
+ const T& |
+ operator [] (unsigned int i) const |
+ { |
+ return stack_[range_ - i]; |
+ } |
+ |
+ private: |
+ |
+ const S& stack_; |
+ unsigned int range_; |
+ }; |
+]b4_namespace_close[ |
+ |
+#endif // not BISON_STACK_HH[]dnl |
+] |
+m4_divert_pop(0) |
Property changes on: bison\src\bison\2.4.1\bison-2.4.1-src\data\lalr1.cc |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |