X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7d6bad195977b0204fc8406cac57cf5a4f1c769b..c4e686a1abd817b4d4da5bdd5b3a5540566fd4a0:/data/lalr1.cc diff --git a/data/lalr1.cc b/data/lalr1.cc index 2b1949e4..3773257c 100644 --- a/data/lalr1.cc +++ b/data/lalr1.cc @@ -1,6 +1,6 @@ # C++ skeleton for Bison -# Copyright (C) 2002-2013 Free Software Foundation, Inc. +# Copyright (C) 2002-2015 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 @@ -17,6 +17,8 @@ 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) # -------------------------------------------------------------- @@ -38,13 +40,14 @@ m4_define([b4_integral_parser_table_define], };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. +# 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]) # -------------------- @@ -128,7 +131,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))])]) m4_pushdef([b4_copyright_years], - [2002-2013]) + [2002-2015]) m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) @@ -146,15 +149,16 @@ b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])]) m4_define([b4_shared_declarations], [b4_percent_code_get([[requires]])[ ]b4_parse_assert_if([# include ])[ -# include // abort -# include +# include // std::abort # include # include -# include ]b4_defines_if([[ +# include +# include ]b4_defines_if([[ # include "stack.hh" ]b4_bison_locations_if([[# include "location.hh"]])])[ ]b4_variant_if([b4_variant_includes])[ +]b4_attribute_define[ ]b4_YYDEBUG_define[ ]b4_namespace_open[ @@ -181,14 +185,14 @@ b4_location_define])])[ #if ]b4_api_PREFIX[DEBUG /// The current debugging stream. - std::ostream& debug_stream () const; + std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; /// 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; + debug_level_type debug_level () const YY_ATTRIBUTE_PURE; /// Set the current debugging level. void set_debug_level (debug_level_type l); #endif @@ -202,18 +206,23 @@ b4_location_define])])[ 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. - virtual std::string yysyntax_error_ (state_type yystate, int yytoken); + /// \param yyla the lookahead token. + virtual std::string yysyntax_error_ (state_type yystate, + const symbol_type& yyla) 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); + /// \param yysym the nonterminal to push on the stack + state_type yy_lr_goto_state_ (state_type yystate, int yysym); /// Whether the given \c yypact_ value indicates a defaulted state. /// \param yyvalue the value to check @@ -223,13 +232,11 @@ b4_location_define])])[ /// \param yyvalue the value to check static bool yy_table_value_is_error_ (int yyvalue); - /// Internal symbol numbers. - typedef ]b4_int_type_for([b4_translate])[ token_number_type; 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 inline token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t); + static token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t); // Tables. ]b4_parser_tables_declare[]b4_error_verbose_if([ @@ -256,42 +263,62 @@ b4_location_define])])[ /// \param yyo The output stream. /// \param yysym The symbol. template - void yy_print_ (std::ostream& yyo, - const basic_symbol& yysym) const; + void yy_print_ (std::ostream& yyo, const basic_symbol& 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. + /// \param yysym The symbol. template - inline void yy_destroy_ (const char* yymsg, - basic_symbol& yysym) const; + void yy_destroy_ (const char* yymsg, basic_symbol& yysym) const; private: /// Type access provider for state based symbols. struct by_state { /// Default constructor. - inline by_state (); + by_state (); + + /// The symbol type as needed by the constructor. + typedef state_type kind_type; /// Constructor. - inline by_state (state_type s); + by_state (kind_type s); /// Copy constructor. - inline by_state (const by_state& other); + by_state (const by_state& other); - /// The state. - state_type state; + /// Record that this symbol is empty. + void clear (); + + /// Steal the symbol type from \a that. + void move (by_state& that); - /// The type (corresponding to \a state). - inline int type_get () const; + /// The (internal) type number (corresponding to \a state). + /// \a empty_symbol when empty. + symbol_number_type type_get () const; - typedef state_type value_type; + /// The state number used to denote an empty symbol. + enum { empty_state = -1 }; + + /// The state. + /// \a empty when empty. + state_type state; }; /// "Internal" symbol: element of the stack. - typedef basic_symbol stack_symbol_type; + struct stack_symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol 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_type; @@ -304,7 +331,7 @@ b4_location_define])])[ /// if null, no trace is output. /// \param s the symbol /// \warning the contents of \a s.value is stolen. - inline void yypush_ (const char* m, stack_symbol_type& s); + 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 @@ -312,22 +339,21 @@ b4_location_define])])[ /// \param s the state /// \param sym the symbol (for its value and location). /// \warning the contents of \a s.value is stolen. - inline void yypush_ (const char* m, state_type s, symbol_type& sym); + void yypush_ (const char* m, state_type s, symbol_type& sym); /// Pop \a n symbols the three stacks. - inline void yypop_ (unsigned int n = 1); + void yypop_ (unsigned int n = 1); - // Constants. + /// 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. + yylast_ = ]b4_last[, ///< Last index in yytable_. + yynnts_ = ]b4_nterms_number[, ///< Number of nonterminal symbols. + yyfinal_ = ]b4_final_state_number[, ///< Termination state number. yyterror_ = 1, yyerrcode_ = 256, - yyntokens_ = ]b4_tokens_number[ //< Number of tokens. + yyntokens_ = ]b4_tokens_number[ ///< Number of tokens. }; ]b4_parse_param_vars[ @@ -443,7 +469,7 @@ m4_if(b4_prefix, [yy], [], #endif // !]b4_api_PREFIX[DEBUG #define yyerrok (yyerrstatus_ = 0) -#define yyclearin (yyempty = true) +#define yyclearin (yyla.clear ()) #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab @@ -497,12 +523,10 @@ m4_if(b4_prefix, [yy], [], ]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[ () - { - } + {} /*---------------. @@ -512,43 +536,85 @@ m4_if(b4_prefix, [yy], [], ]b4_token_ctor_if([], [b4_public_types_define])[ // by_state. + inline ]b4_parser_class_name[::by_state::by_state () - : state () + : state (empty_state) {} + inline ]b4_parser_class_name[::by_state::by_state (const by_state& other) : state (other.state) {} + inline + void + ]b4_parser_class_name[::by_state::clear () + { + state = empty_state; + } + + inline + void + ]b4_parser_class_name[::by_state::move (by_state& that) + { + state = that.state; + that.clear (); + } + + inline ]b4_parser_class_name[::by_state::by_state (state_type s) : state (s) {} - int + inline + ]b4_parser_class_name[::symbol_number_type ]b4_parser_class_name[::by_state::type_get () const { - return yystos_[state]; + if (state == empty_state) + return empty_symbol; + else + return 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_symbol; + } + + 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 + inline void - ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, - basic_symbol& yysym) const + ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol& yysym) const { if (yymsg) - YY_SYMBOL_PRINT (yymsg, yysym); + YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [ // User destructor. - int yytype = yysym.type_get (); - switch (yytype) - { -]b4_symbol_foreach([b4_symbol_destructor])dnl -[ default: - break; - }]b4_variant_if([ - - // Type destructor. - b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[ + b4_symbol_actions([destructor], [yysym.type_get ()])])[ } #if ]b4_api_PREFIX[DEBUG @@ -559,52 +625,37 @@ m4_if(b4_prefix, [yy], [], { std::ostream& yyoutput = yyo; YYUSE (yyoutput); - int yytype = yysym.type_get (); + symbol_number_type yytype = yysym.type_get (); + // Avoid a (spurious) G++ 4.8 warning about "array subscript is + // below array bounds". + if (yysym.empty ()) + std::abort (); yyo << (yytype < yyntokens_ ? "token" : "nterm") << ' ' << yytname_[yytype] << " ("]b4_locations_if([ << yysym.location << ": "])[; - switch (yytype) - { -]b4_symbol_foreach([b4_symbol_printer])dnl -[ default: - break; - } + ]b4_symbol_actions([printer])[ yyo << ')'; } #endif + inline void - ]b4_parser_class_name[::yypush_ (const char* m, state_type s, - symbol_type& sym) + ]b4_parser_class_name[::yypush_ (const char* m, state_type s, symbol_type& sym) { - if (m) - YY_SYMBOL_PRINT (m, sym); -]b4_variant_if( -[[ - stack_symbol_type ss (]b4_join([s], - [sym.value], b4_locations_if([sym.location]))[); - ]b4_symbol_variant([sym.type_get ()], [sym.value], [destroy], [])[; - yystack_.push (ss); -]], -[[ yystack_.push (stack_symbol_type (]b4_join([s], - [sym.value], b4_locations_if([sym.location]))[));]])[ + 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); -]b4_variant_if( -[[ - stack_symbol_type ss (]b4_join([s.state], - [s.value], b4_locations_if([s.location]))[); - ]b4_symbol_variant([s.type_get ()], [s.value], [destroy], [])[; - yystack_.push (ss); -]], -[ yystack_.push (s);])[ + yystack_.push (s); } + inline void ]b4_parser_class_name[::yypop_ (unsigned int n) { @@ -639,13 +690,13 @@ m4_if(b4_prefix, [yy], [], #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) + ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yysym) { - int yyr = yypgoto_[yylhs - yyntokens_] + yystate; + int yyr = yypgoto_[yysym - yyntokens_] + yystate; if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) return yytable_[yyr]; else - return yydefgoto_[yylhs - yyntokens_]; + return yydefgoto_[yysym - yyntokens_]; } inline bool @@ -663,11 +714,9 @@ m4_if(b4_prefix, [yy], [], int ]b4_parser_class_name[::parse () { - /// Whether yyla contains a lookahead. - bool yyempty = true; - // State. int yyn; + /// Length of the RHS of the rule being reduced. int yylen = 0; // Error handling. @@ -680,9 +729,6 @@ m4_if(b4_prefix, [yy], [], /// 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; @@ -702,8 +748,8 @@ b4_dollar_popdef])[]dnl yynewstate, since the latter expects the semantical and the location values to have been already stored, initialize these stacks with a primary value. */ - yystack_ = stack_type (0); - yypush_ (YY_NULL, 0, yyla); + yystack_.clear (); + yypush_ (YY_NULLPTR, 0, yyla); // A new symbol was pushed on the stack. yynewstate: @@ -724,7 +770,7 @@ b4_dollar_popdef])[]dnl goto yydefault; // Read a lookahead token. - if (yyempty) + if (yyla.empty ()) { YYCDEBUG << "Reading a token: "; try @@ -738,14 +784,13 @@ b4_dollar_popdef])[]dnl 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; - if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type) + yyn += yyla.type_get (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ()) goto yydefault; // Reduce or error. @@ -758,9 +803,6 @@ b4_dollar_popdef])[]dnl goto yyreduce; } - // Discard the token being shifted. - yyempty = true; - // Count tokens shifted since error; after three, turn off error status. if (yyerrstatus_) --yyerrstatus_; @@ -783,67 +825,55 @@ b4_dollar_popdef])[]dnl `-----------------------------*/ 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;])[ + { + stack_symbol_type yylhs; + 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 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) + // Compute the default @@$. { - error (yyexc); - YYERROR; - } - YY_SYMBOL_PRINT ("-> $$ =", yylhs); -]b4_variant_if([[ - // Destroy the rhs symbols. - for (int i = 0; i < yylen; ++i) - // Destroy a variant whose value may have been swapped with - // yylhs.value (for instance if the action was "std::swap($$, - // $1)"). The value of yylhs.value (hence possibly one of these - // rhs symbols) depends on the default construction for this - // type. In the case of pointers for instance, no - // initialization is done, so the value is junk. Therefore do - // not try to report the value of symbols about to be destroyed - // in the debug trace, it's possibly junk. Hence yymsg = 0. - // Besides, that keeps exactly the same traces as with the other - // Bison skeletons. - yy_destroy_ (YY_NULL, yystack_[i]);]])[ + slice slice (yystack_, yylen); + YYLLOC_DEFAULT (yylhs.location, slice, yylen); + }]])[ - yypop_ (yylen); - yylen = 0; - YY_STACK_PRINT (); + // 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); + // Shift the result of the reduction. + yypush_ (YY_NULLPTR, yylhs); + } goto yynewstate; /*--------------------------------------. @@ -855,8 +885,7 @@ b4_dollar_popdef])[]dnl { ++yynerrs_; error (]b4_join(b4_locations_if([yyla.location]), - [[yysyntax_error_ (yystack_[0].state, - yyempty ? yyempty_ : yyla.type)]])[); + [[yysyntax_error_ (yystack_[0].state, yyla)]])[); } ]b4_locations_if([[ @@ -867,12 +896,12 @@ b4_dollar_popdef])[]dnl error, discard it. */ // Return failure if at end of input. - if (yyla.type == yyeof_) + if (yyla.type_get () == yyeof_) YYABORT; - else if (!yyempty) + else if (!yyla.empty ()) { yy_destroy_ ("Error: discarding", yyla); - yyempty = true; + yyla.clear (); } } @@ -890,9 +919,7 @@ b4_dollar_popdef])[]dnl 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_destroy_ ("Error: discarding", yylhs);]])[ + yyerror_range[1].location = yystack_[yylen - 1].location;]])[ /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ yypop_ (yylen); @@ -950,7 +977,7 @@ b4_dollar_popdef])[]dnl goto yyreturn; yyreturn: - if (!yyempty) + if (!yyla.empty ()) yy_destroy_ ("Cleanup: discarding lookahead", yyla); /* Do not reclaim the symbols of the rule whose action triggered @@ -970,12 +997,12 @@ b4_dollar_popdef])[]dnl << 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); + if (!yyla.empty ()) + yy_destroy_ (YY_NULLPTR, yyla); while (1 < yystack_.size ()) { - yy_destroy_ (YY_NULL, yystack_[0]); + yy_destroy_ (YY_NULLPTR, yystack_[0]); yypop_ (); } throw; @@ -992,10 +1019,9 @@ b4_dollar_popdef])[]dnl // Generate an error message. std::string ]b4_parser_class_name[::yysyntax_error_ (]dnl -b4_error_verbose_if([state_type yystate, int yytoken], - [int, int])[) +b4_error_verbose_if([state_type yystate, const symbol_type& yyla], + [state_type, const symbol_type&])[) const {]b4_error_verbose_if([[ - std::string yyres; // Number of reported tokens (one for the "unexpected", one per // "expected"). size_t yycount = 0; @@ -1009,7 +1035,7 @@ b4_error_verbose_if([state_type yystate, int yytoken], 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 + - The only way there can be no lookahead present (in yyla) 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 @@ -1029,8 +1055,9 @@ b4_error_verbose_if([state_type yystate, int yytoken], token that will not be accepted due to an error action in a later state. */ - if (yytoken != yyempty_) + if (!yyla.empty ()) { + int yytoken = yyla.type_get (); yyarg[yycount++] = yytname_[yytoken]; int yyn = yypact_[yystate]; if (!yy_pact_value_is_default_ (yyn)) @@ -1057,7 +1084,7 @@ b4_error_verbose_if([state_type yystate, int yytoken], } } - char const* yyformat = YY_NULL; + char const* yyformat = YY_NULLPTR; switch (yycount) { #define YYCASE_(N, S) \ @@ -1073,6 +1100,7 @@ b4_error_verbose_if([state_type yystate, int yytoken], #undef YYCASE_ } + std::string yyres; // Argument number. size_t yyi = 0; for (char const* yyp = yyformat; *yyp; ++yyp)