style: variant: remove empty line

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 40446b7198ca46727ba90d32d90379902c395690..3294f591106d6cbe53c80c32241e1632990861b9 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -1,6 +1,6 @@
 # C++ skeleton for Bison
 
 # 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
 
 # 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])
 
 
 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)
 # --------------------------------------------------------------
 
 # b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
 # --------------------------------------------------------------


@@ -38,13 +40,14 @@ m4_define([b4_integral_parser_table_define],
   };dnl
 ])
 
   };dnl
 ])
 

-

 # b4_symbol_value_template(VAL, [TYPE])
 # -------------------------------------
 # Same as b4_symbol_value, but used in a template method.  It makes
 # 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_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])
 # --------------------
 
 # b4_lhs_value([TYPE])
 # --------------------


@@ -128,7 +131,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))])])
 
 
 m4_pushdef([b4_copyright_years],
 
 
 m4_pushdef([b4_copyright_years],

-           [2002-2012])
+           [2002-2013])

 
 m4_define([b4_parser_class_name],
           [b4_percent_define_get([[parser_class_name]])])
 
 m4_define([b4_parser_class_name],
           [b4_percent_define_get([[parser_class_name]])])


@@ -201,13 +204,18 @@ b4_location_define])])[
     void error (const syntax_error& err);
 
   private:
     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.
     /// 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
 
     /// 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);
 
     /// \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 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([
 
     // 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 <typename Base>
     /// \param yyo    The output stream.
     /// \param yysym  The symbol.
     template <typename Base>

-    void yy_print_ (std::ostream& yyo,
-                    const basic_symbol<Base>& yysym) const;
+    void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;

 #endif
 
     /// \brief Reclaim the memory associated to a symbol.
 #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 <typename Base>
     ///                  If null, print nothing.
     /// \param s         The symbol.
     template <typename Base>

-    inline void yy_destroy_ (const char* yymsg,
-                             basic_symbol<Base>& yysym) const;
+    void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;

 
   private:
     /// Type access provider for state based symbols.
     struct by_state
     {
       /// Default constructor.
 
   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.
 
       /// Constructor.

-      inline by_state (state_type s);
+      by_state (kind_type s);

 
       /// Copy constructor.
 
       /// 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.
     };
 
     /// "Internal" symbol: element of the stack.

-    typedef basic_symbol<by_state> stack_symbol_type;
+    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;
 
     /// Stack type.
     typedef stack<stack_symbol_type> 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.
     ///             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
 
     /// 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.
     /// \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.
 
     /// Pop \a n symbols the three stacks.

-    inline void yypop_ (unsigned int n = 1);
+    void yypop_ (unsigned int n = 1);

 
     // Constants.
     enum
 
     // 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[
     ]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[ ()
 
   ]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.
 ]b4_token_ctor_if([], [b4_public_types_define])[
 
   // by_state.

+  inline

   ]b4_parser_class_name[::by_state::by_state ()
   ]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)
   {}
 
   ]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)
   {}
 
   ]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
   {
   ]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 <typename Base>
   template <typename Base>

+  inline

   void
   void

-  ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
-                                       basic_symbol<Base>& yysym) const
+  ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const

   {
     if (yymsg)
   {
     if (yymsg)

-      YY_SYMBOL_PRINT (yymsg, yysym);
+      YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [

 
     // User destructor.
 
     // 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
   }
 
 #if ]b4_api_PREFIX[DEBUG


@@ -558,52 +609,33 @@ m4_if(b4_prefix, [yy], [],
   {
     std::ostream& yyoutput = yyo;
     YYUSE (yyoutput);
   {
     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 << ": "])[;
     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
 
     yyo << ')';
   }
 #endif
 

+  inline

   void
   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);
   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)
   {
   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.  */
        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.
     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.  */
 
     /* 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.
       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:
        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
 
        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);
         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 ();
     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,
         ++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([[
       }
 
 ]b4_locations_if([[


@@ -866,7 +883,7 @@ b4_dollar_popdef])[]dnl
            error, discard it.  */
 
         // Return failure if at end of input.
            error, discard it.  */
 
         // Return failure if at end of input.

-        if (yyla.type == yyeof_)
+        if (yyla.type_get () == yyeof_)

           YYABORT;
         else if (!yyempty)
           {
           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.  */
       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);
     /* 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
   // 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
   {]b4_error_verbose_if([[
     std::string yyres;
     // Number of reported tokens (one for the "unexpected", one per