X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/1dbaf37f5cd0bc0e7c6a91b8996ae974c8d2cdc1..cc8962bdde81b04aa728aef21e53b4a08a0debfe:/data/lalr1.cc diff --git a/data/lalr1.cc b/data/lalr1.cc index 930119f1..3294f591 100644 --- a/data/lalr1.cc +++ b/data/lalr1.cc @@ -1,6 +1,6 @@ # C++ skeleton for Bison -# Copyright (C) 2002-2012 Free Software Foundation, Inc. +# 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 @@ -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-2012]) + [2002-2013]) m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) @@ -146,7 +149,7 @@ 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 +# include # include # include # include ]b4_defines_if([[ @@ -201,13 +204,18 @@ 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 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 @@ -222,13 +230,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([ @@ -255,8 +261,7 @@ 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. @@ -264,33 +269,49 @@ b4_location_define])])[ /// If null, print nothing. /// \param s 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; + /// 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; - /// The type (corresponding to \a state). - inline int type_get () const; + enum { empty = 0 }; - typedef state_type value_type; + /// The state. + 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; @@ -303,7 +324,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 @@ -311,10 +332,10 @@ 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. enum @@ -496,12 +517,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[ () - { - } + {} /*---------------. @@ -511,43 +530,75 @@ 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) {} + 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) {} - int + inline + ]b4_parser_class_name[::symbol_number_type ]b4_parser_class_name[::by_state::type_get () const { - return yystos_[state]; + 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 + 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 @@ -558,52 +609,33 @@ m4_if(b4_prefix, [yy], [], { std::ostream& yyoutput = yyo; YYUSE (yyoutput); - int yytype = yysym.type_get (); + symbol_number_type yytype = yysym.type_get (); 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) { @@ -701,7 +733,7 @@ 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); + yystack_.clear (); yypush_ (YY_NULL, 0, yyla); // A new symbol was pushed on the stack. @@ -743,8 +775,8 @@ b4_dollar_popdef])[]dnl /* 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. @@ -788,7 +820,7 @@ b4_dollar_popdef])[]dnl 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. + '$$ = $1'. Otherwise, use the top of the stack. Otherwise, the following line sets YYLHS.VALUE to garbage. This behavior is undocumented and Bison @@ -822,21 +854,6 @@ b4_dollar_popdef])[]dnl 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]);]])[ - yypop_ (yylen); yylen = 0; YY_STACK_PRINT (); @@ -855,7 +872,7 @@ b4_dollar_popdef])[]dnl ++yynerrs_; error (]b4_join(b4_locations_if([yyla.location]), [[yysyntax_error_ (yystack_[0].state, - yyempty ? yyempty_ : yyla.type)]])[); + yyempty ? yyempty_ : yyla.type_get ())]])[); } ]b4_locations_if([[ @@ -866,7 +883,7 @@ 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) { @@ -891,7 +908,8 @@ b4_dollar_popdef])[]dnl 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);]])[ + 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); @@ -991,8 +1009,8 @@ 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, 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