diff options
Diffstat (limited to 'gnuwin32/bin/data/lalr1.cc')
| -rw-r--r-- | gnuwin32/bin/data/lalr1.cc | 1161 |
1 files changed, 0 insertions, 1161 deletions
diff --git a/gnuwin32/bin/data/lalr1.cc b/gnuwin32/bin/data/lalr1.cc deleted file mode 100644 index 3294f591..00000000 --- a/gnuwin32/bin/data/lalr1.cc +++ /dev/null @@ -1,1161 +0,0 @@ -# C++ skeleton for Bison - -# Copyright (C) 2002-2013 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]) - -# api.value.type=variant is valid. -m4_define([b4_value_type_setup_variant]) - -# b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT) -# -------------------------------------------------------------- -# Declare "parser::yy<TABLE-NAME>_" whose contents is CONTENT. -m4_define([b4_integral_parser_table_declare], -[m4_ifval([$3], [b4_comment([$3], [ ]) -])dnl - static const b4_int_type_for([$2]) yy$1_[[]];dnl -]) - -# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) -# ------------------------------------------------------------- -# Define "parser::yy<TABLE-NAME>_" whose contents is CONTENT. -m4_define([b4_integral_parser_table_define], -[ const b4_int_type_for([$2]) - b4_parser_class_name::yy$1_[[]] = - { - $2 - };dnl -]) - -# b4_symbol_value_template(VAL, [TYPE]) -# ------------------------------------- -# Same as b4_symbol_value, but used in a template method. It makes -# a difference when using variants. Note that b4_value_type_setup_union -# overrides b4_symbol_value, so we must override it again. -m4_copy([b4_symbol_value], [b4_symbol_value_template]) -m4_append([b4_value_type_setup_union], - [m4_copy_force([b4_symbol_value_union], [b4_symbol_value_template])]) - -# b4_lhs_value([TYPE]) -# -------------------- -# Expansion of $<TYPE>$. -m4_define([b4_lhs_value], - [b4_symbol_value([yylhs.value], [$1])]) - - -# b4_lhs_location() -# ----------------- -# Expansion of @$. -m4_define([b4_lhs_location], - [yylhs.location]) - - -# b4_rhs_data(RULE-LENGTH, NUM) -# ----------------------------- -# Return the data corresponding to the symbol #NUM, where the current -# rule has RULE-LENGTH symbols on RHS. -m4_define([b4_rhs_data], - [yystack_@{b4_subtract($@)@}]) - - -# b4_rhs_state(RULE-LENGTH, NUM) -# ------------------------------ -# The state corresponding to the symbol #NUM, where the current -# rule has RULE-LENGTH symbols on RHS. -m4_define([b4_rhs_state], - [b4_rhs_data([$1], [$2]).state]) - - -# 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], - [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])]) - - -# b4_rhs_location(RULE-LENGTH, NUM) -# --------------------------------- -# Expansion of @NUM, where the current rule has RULE-LENGTH symbols -# on RHS. -m4_define([b4_rhs_location], - [b4_rhs_data([$1], [$2]).location]) - - -# b4_symbol_action(SYMBOL-NUM, KIND) -# ---------------------------------- -# Run the action KIND (destructor or printer) for SYMBOL-NUM. -# Same as in C, but using references instead of pointers. -m4_define([b4_symbol_action], -[b4_symbol_if([$1], [has_$2], -[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl -b4_dollar_pushdef([yysym.value], - b4_symbol_if([$1], [has_type], - [m4_dquote(b4_symbol([$1], [type]))]), - [yysym.location])dnl - b4_symbol_case_([$1]) -b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"]) - b4_symbol([$1], [$2]) -b4_syncline([@oline@], [@ofile@]) - break; - -m4_popdef([b4_symbol_value])[]dnl -b4_dollar_popdef[]dnl -])]) - - -# b4_lex -# ------ -# Call yylex. -m4_define([b4_lex], -[b4_token_ctor_if( -[b4_function_call([yylex], - [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))], -[b4_function_call([yylex], [int], - [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl -b4_locations_if([, [[location*], [&yyla.location]]])dnl -m4_ifdef([b4_lex_param], [, ]b4_lex_param))])]) - - -m4_pushdef([b4_copyright_years], - [2002-2013]) - -m4_define([b4_parser_class_name], - [b4_percent_define_get([[parser_class_name]])]) - -b4_bison_locations_if([# Backward compatibility. - m4_define([b4_location_constructors]) - m4_include(b4_pkgdatadir/[location.cc])]) -m4_include(b4_pkgdatadir/[stack.hh]) -b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])]) - -# b4_shared_declarations -# ---------------------- -# Declaration that might either go into the header (if --defines) -# or open coded in the parser body. -m4_define([b4_shared_declarations], -[b4_percent_code_get([[requires]])[ -]b4_parse_assert_if([# include <cassert>])[ -# include <vector> -# include <iostream> -# include <stdexcept> -# include <string>]b4_defines_if([[ -# include "stack.hh" -]b4_bison_locations_if([[# include "location.hh"]])])[ -]b4_variant_if([b4_variant_includes])[ - -]b4_YYDEBUG_define[ - -]b4_namespace_open[ - -]b4_defines_if([], -[b4_stack_define -b4_bison_locations_if([b4_position_define -b4_location_define])])[ - -]b4_variant_if([b4_variant_define])[ - - /// A Bison parser. - class ]b4_parser_class_name[ - { - public: -]b4_public_types_declare[ - /// 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 ]b4_api_PREFIX[DEBUG - /// 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 - - /// Report a syntax error.]b4_locations_if([[ - /// \param loc where the syntax error is found.]])[ - /// \param msg a description of the syntax error. - virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); - - /// Report a syntax error. - void error (const syntax_error& err); - - private: - /// This class is not copyable. - ]b4_parser_class_name[ (const ]b4_parser_class_name[&); - ]b4_parser_class_name[& operator= (const ]b4_parser_class_name[&); - - /// State numbers. - typedef int state_type; - - /// Generate an error message. - /// \param yystate the state where the error occurred. - /// \param yytoken the lookahead token type, or yyempty_. - virtual std::string yysyntax_error_ (state_type yystate, - symbol_number_type yytoken) const; - - /// Compute post-reduction state. - /// \param yystate the current state - /// \param yylhs the nonterminal to push on the stack - state_type yy_lr_goto_state_ (state_type yystate, int yylhs); - - /// Whether the given \c yypact_ value indicates a defaulted state. - /// \param yyvalue the value to check - static bool yy_pact_value_is_default_ (int yyvalue); - - /// Whether the given \c yytable_ value indicates a syntax error. - /// \param yyvalue the value to check - static bool yy_table_value_is_error_ (int yyvalue); - - static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; - static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; - - /// Convert a scanner token number \a t to a symbol number. - static token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t); - - // Tables. -]b4_parser_tables_declare[]b4_error_verbose_if([ - - /// Convert the symbol name \a n to a form suitable for a diagnostic. - static std::string yytnamerr_ (const char *n);])[ - -]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ - /// For a symbol, its name in clear. - static const char* const yytname_[]; -]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ -]b4_integral_parser_table_declare([rline], [b4_rline], - [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ - /// 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_; - - /// \brief Display a symbol type, value and location. - /// \param yyo The output stream. - /// \param yysym The symbol. - template <typename Base> - void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const; -#endif - - /// \brief Reclaim the memory associated to a symbol. - /// \param yymsg Why this token is reclaimed. - /// If null, print nothing. - /// \param s The symbol. - template <typename Base> - void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const; - - private: - /// Type access provider for state based symbols. - struct by_state - { - /// Default constructor. - by_state (); - - /// The symbol type as needed by the constructor. - typedef state_type kind_type; - - /// Constructor. - by_state (kind_type s); - - /// Copy constructor. - by_state (const by_state& other); - - /// Steal the symbol type from \a that. - void move (by_state& that); - - /// The (internal) type number (corresponding to \a state). - /// "empty" when empty. - symbol_number_type type_get () const; - - enum { empty = 0 }; - - /// The state. - state_type state; - }; - - /// "Internal" symbol: element of the stack. - struct stack_symbol_type : basic_symbol<by_state> - { - /// Superclass. - typedef basic_symbol<by_state> super_type; - /// Construct an empty symbol. - stack_symbol_type (); - /// Steal the contents from \a sym to build this. - stack_symbol_type (state_type s, symbol_type& sym); - /// Assignment, needed by push_back. - stack_symbol_type& operator= (const stack_symbol_type& that); - }; - - /// Stack type. - typedef stack<stack_symbol_type> stack_type; - - /// The stack. - stack_type yystack_; - - /// Push a new state on the stack. - /// \param m a debug message to display - /// if null, no trace is output. - /// \param s the symbol - /// \warning the contents of \a s.value is stolen. - void yypush_ (const char* m, stack_symbol_type& s); - - /// Push a new look ahead token on the state on the stack. - /// \param m a debug message to display - /// if null, no trace is output. - /// \param s the state - /// \param sym the symbol (for its value and location). - /// \warning the contents of \a s.value is stolen. - void yypush_ (const char* m, state_type s, symbol_type& sym); - - /// Pop \a n symbols the three stacks. - void yypop_ (unsigned int n = 1); - - // Constants. - enum - { - yyeof_ = 0, - yylast_ = ]b4_last[, //< Last index in yytable_. - yynnts_ = ]b4_nterms_number[, //< Number of nonterminal symbols. - yyempty_ = -2, - yyfinal_ = ]b4_final_state_number[, //< Termination state number. - yyterror_ = 1, - yyerrcode_ = 256, - yyntokens_ = ]b4_tokens_number[ //< Number of tokens. - }; - -]b4_parse_param_vars[ - }; - -]b4_token_ctor_if([b4_yytranslate_define -b4_public_types_define])[ -]b4_namespace_close[ - -]b4_percent_define_flag_if([[global_tokens_and_yystype]], -[b4_token_defines - -#ifndef ]b4_api_PREFIX[STYPE - // Redirection for backward compatibility. -# define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type -#endif -])[ -]b4_percent_code_get([[provides]])[ -]]) - -b4_defines_if( -[b4_output_begin([b4_spec_defines_file]) -b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++]) -[ -/** - ** \file ]b4_spec_defines_file[ - ** Define the ]b4_namespace_ref[::parser class. - */ - -// C++ LALR(1) parser skeleton written by Akim Demaille. - -]b4_cpp_guard_open([b4_spec_defines_file])[ -]b4_shared_declarations[ -]b4_cpp_guard_close([b4_spec_defines_file]) -b4_output_end() -]) - - -b4_output_begin([b4_parser_file_name]) -b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++]) -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_null_define[ - -]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], - [b4_shared_declarations])[ - -// User implementation prologue. -]b4_user_post_prologue[ -]b4_percent_code_get[ - -#ifndef YY_ -# if defined YYENABLE_NLS && 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 - -]b4_locations_if([dnl -[#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) -]b4_yylloc_default_define])[ - -// Suppress unused-variable warnings by "using" E. -#define YYUSE(E) ((void) (E)) - -// Enable debugging if requested. -#if ]b4_api_PREFIX[DEBUG - -// A pseudo ostream that takes yydebug_ into account. -# define YYCDEBUG if (yydebug_) (*yycdebug_) - -# define YY_SYMBOL_PRINT(Title, Symbol) \ - do { \ - if (yydebug_) \ - { \ - *yycdebug_ << Title << ' '; \ - yy_print_ (*yycdebug_, Symbol); \ - *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 // !]b4_api_PREFIX[DEBUG - -# define YYCDEBUG if (false) std::cerr -# define YY_SYMBOL_PRINT(Title, Symbol) YYUSE(Symbol) -# define YY_REDUCE_PRINT(Rule) static_cast<void>(0) -# define YY_STACK_PRINT() static_cast<void>(0) - -#endif // !]b4_api_PREFIX[DEBUG - -#define yyerrok (yyerrstatus_ = 0) -#define yyclearin (yyempty = true) - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab -#define YYRECOVERING() (!!yyerrstatus_) - -]b4_namespace_open[]b4_error_verbose_if([[ - - /* 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; - } -]])[ - - /// Build a parser object. - ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ - :])[ -#if ]b4_api_PREFIX[DEBUG - ]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[ () - {} - - - /*---------------. - | Symbol types. | - `---------------*/ - -]b4_token_ctor_if([], [b4_public_types_define])[ - - // by_state. - inline - ]b4_parser_class_name[::by_state::by_state () - : state (empty) - {} - - inline - ]b4_parser_class_name[::by_state::by_state (const by_state& other) - : state (other.state) - {} - - inline - void - ]b4_parser_class_name[::by_state::move (by_state& that) - { - state = that.state; - that.state = empty; - } - - inline - ]b4_parser_class_name[::by_state::by_state (state_type s) - : state (s) - {} - - inline - ]b4_parser_class_name[::symbol_number_type - ]b4_parser_class_name[::by_state::type_get () const - { - return state == empty ? 0 : yystos_[state]; - } - - inline - ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type () - {} - - - inline - ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& that) - : super_type (s]b4_locations_if([, that.location])[) - { - ]b4_variant_if([b4_symbol_variant([that.type_get ()], - [value], [move], [that.value])], - [[value = that.value;]])[ - // that is emptied. - that.type = empty; - } - - inline - ]b4_parser_class_name[::stack_symbol_type& - ]b4_parser_class_name[::stack_symbol_type::operator= (const stack_symbol_type& that) - { - state = that.state; - ]b4_variant_if([b4_symbol_variant([that.type_get ()], - [value], [copy], [that.value])], - [[value = that.value;]])[]b4_locations_if([ - location = that.location;])[ - return *this; - } - - - template <typename Base> - inline - void - ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const - { - if (yymsg) - YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [ - - // User destructor. - b4_symbol_actions([destructor], [yysym.type_get ()])])[ - } - -#if ]b4_api_PREFIX[DEBUG - template <typename Base> - void - ]b4_parser_class_name[::yy_print_ (std::ostream& yyo, - const basic_symbol<Base>& yysym) const - { - std::ostream& yyoutput = yyo; - YYUSE (yyoutput); - symbol_number_type yytype = yysym.type_get (); - yyo << (yytype < yyntokens_ ? "token" : "nterm") - << ' ' << yytname_[yytype] << " ("]b4_locations_if([ - << yysym.location << ": "])[; - ]b4_symbol_actions([printer])[ - yyo << ')'; - } -#endif - - inline - void - ]b4_parser_class_name[::yypush_ (const char* m, state_type s, symbol_type& sym) - { - stack_symbol_type t (s, sym); - yypush_ (m, t); - } - - inline - void - ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s) - { - if (m) - YY_SYMBOL_PRINT (m, s); - yystack_.push (s); - } - - inline - void - ]b4_parser_class_name[::yypop_ (unsigned int n) - { - yystack_.pop (n); - } - -#if ]b4_api_PREFIX[DEBUG - 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 // ]b4_api_PREFIX[DEBUG - - inline ]b4_parser_class_name[::state_type - ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs) - { - int yyr = yypgoto_[yylhs - yyntokens_] + yystate; - if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) - return yytable_[yyr]; - else - return yydefgoto_[yylhs - yyntokens_]; - } - - inline bool - ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue) - { - return yyvalue == yypact_ninf_; - } - - inline bool - ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue) - { - return yyvalue == yytable_ninf_; - } - - int - ]b4_parser_class_name[::parse () - { - /// Whether yyla contains a lookahead. - bool yyempty = true; - - // State. - int yyn; - int yylen = 0; - - // Error handling. - int yynerrs_ = 0; - int yyerrstatus_ = 0; - - /// The lookahead symbol. - symbol_type yyla;]b4_locations_if([[ - - /// The locations where the error started and ended. - stack_symbol_type yyerror_range[3];]])[ - - /// $$ and @@$. - stack_symbol_type yylhs; - - /// The return value of parse (). - int yyresult; - - // FIXME: This shoud be completely indented. It is not yet to - // avoid gratuitous conflicts when merging into the master branch. - try - { - YYCDEBUG << "Starting parse" << std::endl; - -]m4_ifdef([b4_initial_action], [ -b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl - // User initialization code. - b4_user_initial_action -b4_dollar_popdef])[]dnl - - [ /* Initialize the stack. The initial state will be set in - yynewstate, since the latter expects the semantical and the - location values to have been already stored, initialize these - stacks with a primary value. */ - yystack_.clear (); - yypush_ (YY_NULL, 0, yyla); - - // A new symbol was pushed on the stack. - yynewstate: - YYCDEBUG << "Entering state " << yystack_[0].state << std::endl; - - // Accept? - if (yystack_[0].state == yyfinal_) - goto yyacceptlab; - - goto yybackup; - - // Backup. - yybackup: - - // Try to take a decision without lookahead. - yyn = yypact_[yystack_[0].state]; - if (yy_pact_value_is_default_ (yyn)) - goto yydefault; - - // Read a lookahead token. - if (yyempty) - { - YYCDEBUG << "Reading a token: "; - try - {]b4_token_ctor_if([[ - symbol_type yylookahead (]b4_lex[); - yyla.move (yylookahead);]], [[ - yyla.type = yytranslate_ (]b4_lex[);]])[ - } - catch (const syntax_error& yyexc) - { - error (yyexc); - goto yyerrlab1; - } - yyempty = false; - } - YY_SYMBOL_PRINT ("Next token is", yyla); - - /* If the proper action on seeing token YYLA.TYPE is to reduce or - to detect an error, take that action. */ - yyn += yyla.type_get (); - if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ()) - goto yydefault; - - // Reduce or error. - yyn = yytable_[yyn]; - if (yyn <= 0) - { - if (yy_table_value_is_error_ (yyn)) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - - // Discard the token being shifted. - yyempty = true; - - // Count tokens shifted since error; after three, turn off error status. - if (yyerrstatus_) - --yyerrstatus_; - - // Shift the lookahead token. - yypush_ ("Shifting", yyn, yyla); - goto yynewstate; - - /*-----------------------------------------------------------. - | yydefault -- do the default action for the current state. | - `-----------------------------------------------------------*/ - yydefault: - yyn = yydefact_[yystack_[0].state]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - - /*-----------------------------. - | yyreduce -- Do a reduction. | - `-----------------------------*/ - yyreduce: - yylen = yyr2_[yyn]; - yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([ - /* Variants are always initialized to an empty instance of the - correct type. The default $$=$1 action is NOT applied when using - variants. */ - b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[ - /* If YYLEN is nonzero, implement the default value of the action: - '$$ = $1'. Otherwise, use the top of the stack. - - Otherwise, the following line sets YYLHS.VALUE to garbage. - This behavior is undocumented and Bison - users should not rely upon it. */ - if (yylen) - yylhs.value = yystack_@{yylen - 1@}.value; - else - yylhs.value = yystack_@{0@}.value;])[ -]b4_locations_if([dnl -[ - // Compute the default @@$. - { - slice<stack_symbol_type, stack_type> slice (yystack_, yylen); - YYLLOC_DEFAULT (yylhs.location, slice, yylen); - }]])[ - - // Perform the reduction. - YY_REDUCE_PRINT (yyn); - try - { - switch (yyn) - { -]b4_user_actions[ - default: - break; - } - } - catch (const syntax_error& yyexc) - { - error (yyexc); - YYERROR; - } - YY_SYMBOL_PRINT ("-> $$ =", yylhs); - yypop_ (yylen); - yylen = 0; - YY_STACK_PRINT (); - - // Shift the result of the reduction. - yypush_ (YY_NULL, yylhs); - goto yynewstate; - - /*--------------------------------------. - | yyerrlab -- here on detecting error. | - `--------------------------------------*/ - yyerrlab: - // If not already recovering from an error, report this error. - if (!yyerrstatus_) - { - ++yynerrs_; - error (]b4_join(b4_locations_if([yyla.location]), - [[yysyntax_error_ (yystack_[0].state, - yyempty ? yyempty_ : yyla.type_get ())]])[); - } - -]b4_locations_if([[ - yyerror_range[1].location = yyla.location;]])[ - if (yyerrstatus_ == 3) - { - /* If just tried and failed to reuse lookahead token after an - error, discard it. */ - - // Return failure if at end of input. - if (yyla.type_get () == yyeof_) - YYABORT; - else if (!yyempty) - { - yy_destroy_ ("Error: discarding", yyla); - yyempty = true; - } - } - - // 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;]b4_locations_if([[ - yyerror_range[1].location = yystack_[yylen - 1].location;]])b4_variant_if([[ - /* $$ was initialized before running the user action. */ - YY_SYMBOL_PRINT ("Error: discarding", yylhs); - yylhs.~stack_symbol_type();]])[ - /* Do not reclaim the symbols of the rule whose action triggered - this YYERROR. */ - yypop_ (yylen); - yylen = 0; - goto yyerrlab1; - - /*-------------------------------------------------------------. - | yyerrlab1 -- common code for both syntax error and YYERROR. | - `-------------------------------------------------------------*/ - yyerrlab1: - yyerrstatus_ = 3; // Each real token shifted decrements this. - { - stack_symbol_type error_token; - for (;;) - { - yyn = yypact_[yystack_[0].state]; - if (!yy_pact_value_is_default_ (yyn)) - { - 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 (yystack_.size () == 1) - YYABORT; -]b4_locations_if([[ - yyerror_range[1].location = yystack_[0].location;]])[ - yy_destroy_ ("Error: popping", yystack_[0]); - yypop_ (); - YY_STACK_PRINT (); - } -]b4_locations_if([[ - yyerror_range[2].location = yyla.location; - YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[ - - // Shift the error token. - error_token.state = yyn; - yypush_ ("Shifting", error_token); - } - goto yynewstate; - - // Accept. - yyacceptlab: - yyresult = 0; - goto yyreturn; - - // Abort. - yyabortlab: - yyresult = 1; - goto yyreturn; - - yyreturn: - if (!yyempty) - yy_destroy_ ("Cleanup: discarding lookahead", yyla); - - /* Do not reclaim the symbols of the rule whose action triggered - this YYABORT or YYACCEPT. */ - yypop_ (yylen); - while (1 < yystack_.size ()) - { - yy_destroy_ ("Cleanup: popping", yystack_[0]); - yypop_ (); - } - - return yyresult; - } - catch (...) - { - YYCDEBUG << "Exception caught: cleaning lookahead and stack" - << std::endl; - // Do not try to display the values of the reclaimed symbols, - // as their printer might throw an exception. - if (!yyempty) - yy_destroy_ (YY_NULL, yyla); - - while (1 < yystack_.size ()) - { - yy_destroy_ (YY_NULL, yystack_[0]); - yypop_ (); - } - throw; - } - } - - void - ]b4_parser_class_name[::error (const syntax_error& yyexc) - { - error (]b4_join(b4_locations_if([yyexc.location]), - [[yyexc.what()]])[); - } - - // Generate an error message. - std::string - ]b4_parser_class_name[::yysyntax_error_ (]dnl -b4_error_verbose_if([state_type yystate, symbol_number_type yytoken], - [state_type, symbol_number_type])[) const - {]b4_error_verbose_if([[ - std::string yyres; - // Number of reported tokens (one for the "unexpected", one per - // "expected"). - size_t yycount = 0; - // Its maximum. - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - // Arguments of yyformat. - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - - /* There are many possibilities here to consider: - - If this state is a consistent state with a default action, then - the only way this function was invoked is if the default action - is an error action. In that case, don't check for expected - tokens because there are none. - - The only way there can be no lookahead present (in yytoken) is - if this state is a consistent state with a default action. - Thus, detecting the absence of a lookahead is sufficient to - determine that there is no unexpected or expected token to - report. In that case, just report a simple "syntax error". - - Don't assume there isn't a lookahead just because this state is - a consistent state with a default action. There might have - been a previous inconsistent state, consistent state with a - non-default action, or user semantic action that manipulated - yyla. (However, yyla is currently not documented for users.) - - Of course, the expected token list depends on states to have - correct lookahead information, and it depends on the parser not - to perform extra reductions after fetching a lookahead from the - scanner and before detecting a syntax error. Thus, state - merging (from LALR or IELR) and default reductions corrupt the - expected token list. However, the list is correct for - canonical LR with one exception: it will still contain any - token that will not be accepted due to an error action in a - later state. - */ - if (yytoken != yyempty_) - { - yyarg[yycount++] = yytname_[yytoken]; - int yyn = yypact_[yystate]; - if (!yy_pact_value_is_default_ (yyn)) - { - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. In other words, skip the first -YYN actions for - this state because they are default actions. */ - 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_; - for (int yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_ - && !yy_table_value_is_error_ (yytable_[yyx + yyn])) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - break; - } - else - yyarg[yycount++] = yytname_[yyx]; - } - } - } - - char const* yyformat = YY_NULL; - switch (yycount) - { -#define YYCASE_(N, S) \ - case N: \ - yyformat = S; \ - break - YYCASE_(0, YY_("syntax error")); - YYCASE_(1, YY_("syntax error, unexpected %s")); - YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); - YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); - YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); - YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); -#undef YYCASE_ - } - - // Argument number. - size_t yyi = 0; - for (char const* yyp = yyformat; *yyp; ++yyp) - if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) - { - yyres += yytnamerr_ (yyarg[yyi++]); - ++yyp; - } - else - yyres += *yyp; - return yyres;]], [[ - return YY_("syntax error");]])[ - } - - - const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; - - const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; - -]b4_parser_tables_define[ - -]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ - // 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[ - }; - -]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ -]b4_integral_parser_table_define([rline], [b4_rline])[ - - // Print the state stack on the debug stream. - void - ]b4_parser_class_name[::yystack_print_ () - { - *yycdebug_ << "Stack now"; - for (stack_type::const_iterator - i = yystack_.begin (), - i_end = yystack_.end (); - i != i_end; ++i) - *yycdebug_ << ' ' << i->state; - *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 << " =", - ]b4_rhs_data(yynrhs, yyi + 1)[); - } -#endif // ]b4_api_PREFIX[DEBUG - -]b4_token_ctor_if([], [b4_yytranslate_define])[ -]b4_namespace_close[ -]b4_epilogue[]dnl -b4_output_end() - - -m4_popdef([b4_copyright_years])dnl |