version 3.0.4

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 2b1949e480f81158da2cf8b7192f3c4643659ff3..3773257cb735f0646d14b74060abb93a802e0cd2 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-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
 
 # 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-2013])
+           [2002-2015])

 
 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]])])


@@ -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 <cassert>])[
 m4_define([b4_shared_declarations],
 [b4_percent_code_get([[requires]])[
 ]b4_parse_assert_if([# include <cassert>])[

-# include <cstdlib>  // abort
-# include <vector>
+# include <cstdlib> // std::abort

 # include <iostream>
 # include <stdexcept>
 # include <iostream>
 # include <stdexcept>

-# include <string>]b4_defines_if([[
+# include <string>
+# include <vector>]b4_defines_if([[

 # include "stack.hh"
 ]b4_bison_locations_if([[# include "location.hh"]])])[
 ]b4_variant_if([b4_variant_includes])[
 
 # 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[
 ]b4_YYDEBUG_define[
 
 ]b4_namespace_open[


@@ -181,14 +185,14 @@ b4_location_define])])[
 
 #if ]b4_api_PREFIX[DEBUG
     /// The current debugging stream.
 
 #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.
     /// 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
     /// 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:
     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 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
 
     /// 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
 
     /// 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);
 
     /// \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([


@@ -256,42 +263,62 @@ 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.
     /// \param yymsg     Why this token is reclaimed.
     ///                  If null, print nothing.
 #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 <typename Base>
     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;
+      /// 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.
     };
 
     /// "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;


@@ -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.
     ///             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


@@ -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.
     /// \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.
+    /// Constants.

     enum
     {
       yyeof_ = 0,
     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,
       yyterror_ = 1,
       yyerrcode_ = 256,

-      yyntokens_ = ]b4_tokens_number[    //< Number of tokens.
+      yyntokens_ = ]b4_tokens_number[  ///< Number of tokens.

     };
 
 ]b4_parse_param_vars[
     };
 
 ]b4_parse_param_vars[


@@ -443,7 +469,7 @@ m4_if(b4_prefix, [yy], [],
 #endif // !]b4_api_PREFIX[DEBUG
 
 #define yyerrok         (yyerrstatus_ = 0)
 #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
 
 #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[
     ]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[ ()

-  {
-  }
+  {}

 
 
   /*---------------.
 
 
   /*---------------.


@@ -512,43 +536,85 @@ 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_state)

   {}
 
   {}
 

+  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::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)
   {}
 
   ]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];
+    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 <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


@@ -559,52 +625,37 @@ 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 ();
+    // 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 << ": "])[;
     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)
   {


@@ -639,13 +690,13 @@ m4_if(b4_prefix, [yy], [],
 #endif // ]b4_api_PREFIX[DEBUG
 
   inline ]b4_parser_class_name[::state_type
 #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
     if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
       return yytable_[yyr];
     else

-      return yydefgoto_[yylhs - yyntokens_];
+      return yydefgoto_[yysym - yyntokens_];

   }
 
   inline bool
   }
 
   inline bool


@@ -663,11 +714,9 @@ m4_if(b4_prefix, [yy], [],
   int
   ]b4_parser_class_name[::parse ()
   {
   int
   ]b4_parser_class_name[::parse ()
   {

-    /// Whether yyla contains a lookahead.
-    bool yyempty = true;
-

     // State.
     int yyn;
     // State.
     int yyn;

+    /// Length of the RHS of the rule being reduced.

     int yylen = 0;
 
     // Error handling.
     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];]])[
 
     /// 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;
 
     /// 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.  */
        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:
 
     // A new symbol was pushed on the stack.
   yynewstate:


@@ -724,7 +770,7 @@ b4_dollar_popdef])[]dnl
       goto yydefault;
 
     // Read a lookahead token.
       goto yydefault;
 
     // Read a lookahead token.

-    if (yyempty)
+    if (yyla.empty ())

       {
         YYCDEBUG << "Reading a token: ";
         try
       {
         YYCDEBUG << "Reading a token: ";
         try


@@ -738,14 +784,13 @@ b4_dollar_popdef])[]dnl
             error (yyexc);
             goto yyerrlab1;
           }
             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.  */
       }
     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.
       goto yydefault;
 
     // Reduce or error.


@@ -758,9 +803,6 @@ b4_dollar_popdef])[]dnl
         goto yyreduce;
       }
 
         goto yyreduce;
       }
 

-    // Discard the token being shifted.
-    yyempty = true;
-

     // Count tokens shifted since error; after three, turn off error status.
     if (yyerrstatus_)
       --yyerrstatus_;
     // 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];
   `-----------------------------*/
   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
 [
 ]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)
+      // 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<stack_symbol_type, stack_type> 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;
 
   /*--------------------------------------.
     goto yynewstate;
 
   /*--------------------------------------.


@@ -855,8 +885,7 @@ b4_dollar_popdef])[]dnl
       {
         ++yynerrs_;
         error (]b4_join(b4_locations_if([yyla.location]),
       {
         ++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([[
       }
 
 ]b4_locations_if([[


@@ -867,12 +896,12 @@ 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;
           YYABORT;

-        else if (!yyempty)
+        else if (!yyla.empty ())

           {
             yy_destroy_ ("Error: discarding", yyla);
           {
             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([[
        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);
     /* 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:
     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
       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.
                  << 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 ())
           {
 
         while (1 < yystack_.size ())
           {

-            yy_destroy_ (YY_NULL, yystack_[0]);
+            yy_destroy_ (YY_NULLPTR, yystack_[0]);

             yypop_ ();
           }
         throw;
             yypop_ ();
           }
         throw;


@@ -992,10 +1019,9 @@ 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, const symbol_type& yyla],
+                    [state_type, const symbol_type&])[) const

   {]b4_error_verbose_if([[
   {]b4_error_verbose_if([[

-    std::string yyres;

     // Number of reported tokens (one for the "unexpected", one per
     // "expected").
     size_t yycount = 0;
     // 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 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
          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.
     */
          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))
         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)                         \
     switch (yycount)
       {
 #define YYCASE_(N, S)                         \


@@ -1073,6 +1100,7 @@ b4_error_verbose_if([state_type yystate, int yytoken],
 #undef YYCASE_
       }
 
 #undef YYCASE_
       }
 

+    std::string yyres;

     // Argument number.
     size_t yyi = 0;
     for (char const* yyp = yyformat; *yyp; ++yyp)
     // Argument number.
     size_t yyi = 0;
     for (char const* yyp = yyformat; *yyp; ++yyp)