Support constructor with an argument.

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 93c300571c58b5b18f6f70b8c6ecc361d8414406..5854390e2956370ab63005ed3cb7c2aab2be3c1e 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -29,6 +29,11 @@ m4_define([b4_table_define],
   }dnl
 ])
 
   }dnl
 ])
 

+# b4_symbol_value_template(VAL, [TYPE])
+# -------------------------------------
+# Same as b4_symbol_value, but used in a template method.
+m4_copy([b4_symbol_value], [b4_symbol_value_template])
+

 # How the semantic value is extracted when using variants.
 b4_variant_if([
   # b4_symbol_value(VAL, [TYPE])
 # How the semantic value is extracted when using variants.
 b4_variant_if([
   # b4_symbol_value(VAL, [TYPE])


@@ -37,11 +42,19 @@ b4_variant_if([
   [m4_ifval([$2],
             [$1.as<$2>()],
             [$1])])
   [m4_ifval([$2],
             [$1.as<$2>()],
             [$1])])

+
+  # b4_symbol_value_template(VAL, [TYPE])
+  # -------------------------------------
+  # Same as b4_symbol_value, but used in a template method.
+  m4_define([b4_symbol_value_template],
+  [m4_ifval([$2],
+            [$1.template as<$2>()],
+            [$1])])

 ]) # b4_variant_if
 
 
 # b4_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])
 ]) # b4_variant_if
 
 
 # b4_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])

-# ----------------------------------------------------
+# ------------------------------------------------

 m4_define([b4_assert_if],
 [b4_percent_define_ifdef([[assert]], [$1], [$2])])
 
 m4_define([b4_assert_if],
 [b4_percent_define_ifdef([[assert]], [$1], [$2])])
 


@@ -99,8 +112,8 @@ m4_define([b4_rhs_location],
 # Same as in C, but using references instead of pointers.
 m4_define([b4_symbol_actions],
 [m4_pushdef([b4_dollar_dollar],
 # Same as in C, but using references instead of pointers.
 m4_define([b4_symbol_actions],
 [m4_pushdef([b4_dollar_dollar],

-            [b4_symbol_value([yyvalue], [$6])])dnl
-m4_pushdef([b4_at_dollar], [yylocation])dnl
+            [b4_symbol_value_template([yysym.value], [$6])])dnl
+m4_pushdef([b4_at_dollar], [yysym.location])dnl

       case $4: // $3
 b4_syncline([$2], [$1])
         $5;
       case $4: // $3
 b4_syncline([$2], [$1])
         $5;


@@ -234,6 +247,16 @@ dnl FIXME: This is wrong, we want computed header guards.
       return *new (buffer) T;
     }
 
       return *new (buffer) T;
     }
 

+    /// Instantiate a \a T in here from \a t.
+    template <typename T>
+    inline T&
+    build(const T& t)
+    {]b4_assert_if([
+      assert(!built);
+      built = true;])[
+      return *new (buffer) T(t);
+    }
+

     /// Accessor to a built \a T.
     template <typename T>
     inline T&
     /// Accessor to a built \a T.
     template <typename T>
     inline T&


@@ -394,23 +417,6 @@ m4_ifdef([b4_stype],
     /// \param tok     the lookahead token.
     virtual std::string yysyntax_error_ (int yystate, int tok);
 
     /// \param tok     the lookahead token.
     virtual std::string yysyntax_error_ (int yystate, int tok);
 

-#if YYDEBUG
-    /// \brief Report a symbol value on the debug stream.
-    /// \param yytype       The token type.
-    /// \param yyvalue      Its semantic value.
-    /// \param yylocation   Its location.
-    virtual void yy_symbol_value_print_ (int yytype,
-                                        const semantic_type& yyvalue,
-                                        const location_type& yylocation);
-    /// \brief Report a symbol on the debug stream.
-    /// \param yytype       The token type.
-    /// \param yyvalue      Its semantic value.
-    /// \param yylocation   Its location.
-    virtual void yy_symbol_print_ (int yytype,
-                                  const semantic_type& yyvalue,
-                                  const location_type& yylocation);
-#endif
-

     /// State numbers.
     typedef int state_type;
 
     /// State numbers.
     typedef int state_type;
 


@@ -475,28 +481,22 @@ m4_ifdef([b4_stype],
     /// Convert a scanner token number \a t to a symbol number.
     token_number_type yytranslate_ (int t);
 
     /// Convert a scanner token number \a t to a symbol number.
     token_number_type yytranslate_ (int t);
 

-    /// \brief Reclaim the memory associated to a symbol.
-    /// \param yymsg        Why this token is reclaimed.
-    ///                     If null, nothing is printed at all.
-    /// \param yytype       The symbol type.
-    /// \param yyvalue      Its semantic value.
-    /// \param yylocation   Its location.
-    inline void yydestruct_ (const char* yymsg,
-                            int yytype,
-                            semantic_type& yyvalue,
-                            location_type& yylocation);
-
-    /// Element of the stack: a state and its attributes.
-    struct data_type
+    /// A complete symbol, with its type.
+    template <typename Exact>
+    struct symbol_base_type

     {
       /// Default constructor.
     {
       /// Default constructor.

-      data_type ();
+      inline symbol_base_type ();

 
       /// Constructor.
 
       /// Constructor.

-      data_type (state_type s, const semantic_type& v, const location_type& l);
+      inline symbol_base_type (const semantic_type& v, const location_type& l);

 
 

-      /// The state.
-      state_type state;
+      /// Return this with its exact type.
+      const Exact& self () const;
+      Exact& self ();
+
+      /// Return the type of this symbol.
+      int type_get () const;

 
       /// The semantic value.
       semantic_type value;
 
       /// The semantic value.
       semantic_type value;


@@ -505,8 +505,65 @@ m4_ifdef([b4_stype],
       location_type location;
     };
 
       location_type location;
     };
 

+#if YYDEBUG
+    /// \brief Display a symbol type, value and location.
+    /// \param yyo    The output stream.
+    /// \param yysym  The symbol.
+    template <typename Exact>
+    void yy_print_ (std::ostream& yyo,
+                    const symbol_base_type<Exact>& 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 Exact>
+    inline void yy_destroy_ (const char* yymsg,
+                             symbol_base_type<Exact>& yysym) const;
+
+    /// Element of the stack: a state and its attributes.
+    struct symbol_type : symbol_base_type<symbol_type>
+    {
+      /// The parent class.
+      typedef symbol_base_type<symbol_type> super_type;
+
+      /// Default constructor.
+      inline symbol_type ();
+
+      /// Constructor.
+      inline symbol_type (int t,
+                          const semantic_type& v, const location_type& l);
+
+      /// The symbol type.
+      int type;
+
+      /// Return the type corresponding to this state.
+      inline int type_get_ () const;
+    };
+
+    /// Element of the stack: a state and its attributes.
+    struct stack_symbol_type : symbol_base_type<stack_symbol_type>
+    {
+      /// The parent class.
+      typedef symbol_base_type<stack_symbol_type> super_type;
+
+      /// Default constructor.
+      inline stack_symbol_type ();
+
+      /// Constructor.
+      inline stack_symbol_type (state_type s,
+                                const semantic_type& v, const location_type& l);
+
+      /// The state.
+      state_type state;
+
+      /// Return the type corresponding to this state.
+      inline int type_get_ () const;
+    };
+

     /// Stack type.
     /// Stack type.

-    typedef stack<data_type> stack_type;
+    typedef stack<stack_symbol_type> stack_type;

 
     /// The stack.
     stack_type yystack_;
 
     /// The stack.
     stack_type yystack_;


@@ -516,7 +573,15 @@ m4_ifdef([b4_stype],
     ///             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, data_type& s);
+    inline 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.
+    inline 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);
 
     /// Pop \a n symbols the three stacks.
     inline void yypop_ (unsigned int n = 1);


@@ -535,6 +600,7 @@ m4_ifdef([b4_stype],
     static const token_number_type yyundef_token_;
 ]b4_parse_param_vars[
   };
     static const token_number_type yyundef_token_;
 ]b4_parse_param_vars[
   };

+

 ]b4_namespace_close[
 
 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
 ]b4_namespace_close[
 
 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],


@@ -588,14 +654,14 @@ b4_percent_code_get[]dnl
 /* A pseudo ostream that takes yydebug_ into account.  */
 # define YYCDEBUG if (yydebug_) (*yycdebug_)
 
 /* A pseudo ostream that takes yydebug_ into account.  */
 # define YYCDEBUG if (yydebug_) (*yycdebug_)
 

-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
-  do {                                                 \
-    if (yydebug_)                                       \
-    {                                                  \
-      *yycdebug_ << Title << ' ';                      \
-      yy_symbol_print_ ((Type), (Value), (Location));  \
-      *yycdebug_ << std::endl;                         \
-    }                                                  \
+# 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)         \
   } while (false)
 
 # define YY_REDUCE_PRINT(Rule)         \


@@ -613,9 +679,9 @@ b4_percent_code_get[]dnl
 #else /* !YYDEBUG */
 
 # define YYCDEBUG if (false) std::cerr
 #else /* !YYDEBUG */
 
 # define YYCDEBUG if (false) std::cerr

-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)  static_cast<void>(0)
-# define YY_REDUCE_PRINT(Rule)                          static_cast<void>(0)
-# define YY_STACK_PRINT()                               static_cast<void>(0)
+# define YY_SYMBOL_PRINT(Title, Symbol)  static_cast<void>(0)
+# define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)
+# define YY_STACK_PRINT()                static_cast<void>(0)

 
 #endif /* !YYDEBUG */
 
 
 #endif /* !YYDEBUG */
 


@@ -683,48 +749,97 @@ b4_percent_code_get[]dnl
   {
   }
 
   {
   }
 

-#if YYDEBUG
-  /*--------------------------------.
-  | Print this symbol on YYOUTPUT.  |
-  `--------------------------------*/

 
 

-  inline void
-  ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
-                          const semantic_type& yyvalue, const location_type& yylocation)
+  /*---------------.
+  | Symbol types.  |
+  `---------------*/
+
+  // symbol_base_type.
+  template <typename Exact>
+  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
+    : value()
+    , location()

   {
   {

-    YYUSE (yylocation);
-    YYUSE (yyvalue);
-    switch (yytype)
-      {
-  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
-[       default:
-         break;
-      }

   }
 
   }
 

+  template <typename Exact>
+  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const semantic_type& v, const location_type& l)
+    : value(v)
+    , location(l)
+  {
+  }

 
 

-  void
-  ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
-                          const semantic_type& yyvalue, const location_type& yylocation)
+  template <typename Exact>
+  const Exact&
+  ]b4_parser_class_name[::symbol_base_type<Exact>::self () const

   {
   {

-    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
-              << ' ' << yytname_[yytype] << " ("
-              << yylocation << ": ";
-    yy_symbol_value_print_ (yytype, yyvalue, yylocation);
-    *yycdebug_ << ')';
+    return static_cast<const Exact&>(*this);
+  }
+
+  template <typename Exact>
+  Exact&
+  ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
+  {
+    return static_cast<Exact&>(*this);

   }
   }

-#endif

 
 

+  template <typename Exact>
+  int
+  ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
+  {
+    return self ().type_get_ ();
+  }
+
+  // symbol_type.
+  ]b4_parser_class_name[::symbol_type::symbol_type ()
+    : super_type ()
+    , type ()
+  {
+  }
+
+  ]b4_parser_class_name[::symbol_type::symbol_type (int t,
+                           const semantic_type& v, const location_type& l)
+    : super_type (v, l)
+    , type (t)
+  {
+  }
+
+  int
+  ]b4_parser_class_name[::symbol_type::type_get_ () const
+  {
+    return type;
+  }
+
+  // stack_symbol_type.
+  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
+    : super_type ()
+    , state ()
+  {
+  }
+
+  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s,
+                           const semantic_type& v, const location_type& l)
+    : super_type (v, l)
+    , state (s)
+  {
+  }
+
+  int
+  ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
+  {
+    return yystos_[state];
+  }
+
+
+  template <typename Exact>

   void
   void

-  ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
-                          int yytype, semantic_type& yyvalue, location_type& yylocation)
+  ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
+                                       symbol_base_type<Exact>& yysym) const

   {
   {

+    int yytype = yysym.type_get ();

     YYUSE (yymsg);
     YYUSE (yymsg);

-    YYUSE (yyvalue);
-    YYUSE (yylocation);
-

     if (yymsg)
     if (yymsg)

-      YY_SYMBOL_PRINT (yymsg, yytype, yyvalue, yylocation);
+      YY_SYMBOL_PRINT (yymsg, yysym);

 
     // User destructor.
     switch (yytype)
 
     // User destructor.
     switch (yytype)


@@ -735,32 +850,50 @@ b4_percent_code_get[]dnl
       }]b4_variant_if([
 
     // Type destructor.
       }]b4_variant_if([
 
     // Type destructor.

-  b4_symbol_variant([[yytype]], [[yyvalue]], [[destroy]])])[
+    b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[

   }
 
   }
 

-  ]b4_parser_class_name[::data_type::data_type ()
-    : state()
-    , value()
-    , location()
+#if YYDEBUG
+  template <typename Exact>
+  void
+  ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
+                                     const symbol_base_type<Exact>& yysym) const

   {
   {

+    int yytype = yysym.type_get ();
+    yyo << (yytype < yyntokens_ ? "token" : "nterm")
+        << ' ' << yytname_[yytype] << " ("
+        << yysym.location << ": ";
+    switch (yytype)
+      {
+  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
+[       default:
+         break;
+      }
+    yyo << ')';

   }
   }

+#endif

 
 

-  ]b4_parser_class_name[::data_type::data_type (state_type s,
-                           const semantic_type& v, const location_type& l)
-    : state(s)
-    , value(v)
-    , location(l)
+  void
+  ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
+                                   symbol_type& sym)

   {
   {

+    if (m)
+      YY_SYMBOL_PRINT (m, sym);
+]b4_variant_if(
+[[    yystack_.push (stack_symbol_type (s, semantic_type(), sym.location));
+    ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
+                       [build], [sym.value])],
+[    yystack_.push (stack_symbol_type (s, sym.value, sym.location));])[

   }
 
   void
   }
 
   void

-  ]b4_parser_class_name[::yypush_ (const char* m, data_type& s)
+  ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)

   {
     if (m)
   {
     if (m)

-      YY_SYMBOL_PRINT (m, yystos_[s.state], s.value, s.location);
+      YY_SYMBOL_PRINT (m, s);

 ]b4_variant_if(
 ]b4_variant_if(

-[[    yystack_.push (data_type (s, semantic_type(), l));
-    ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
+[[    yystack_.push (stack_symbol_type (s.state, semantic_type(), s.location));
+    ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],

                        [build], [s.value])],
 [    yystack_.push (s);])[
   }
                        [build], [s.value])],
 [    yystack_.push (s);])[
   }


@@ -801,9 +934,8 @@ b4_percent_code_get[]dnl
   int
   ]b4_parser_class_name[::parse ()
   {
   int
   ]b4_parser_class_name[::parse ()
   {

-    /// Lookahead and lookahead in internal form.
+    /// Coded type of the lookahead.

     int yychar = yyempty_;
     int yychar = yyempty_;

-    int yytoken = 0;

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


@@ -815,13 +947,13 @@ b4_percent_code_get[]dnl
     int yyerrstatus_ = 0;
 
     /// The lookahead symbol.
     int yyerrstatus_ = 0;
 
     /// The lookahead symbol.

-    data_type yyla;
+    symbol_type yyla;

 
     /// The locations where the error started and ended.
 
     /// The locations where the error started and ended.

-    data_type yyerror_range[2];
+    stack_symbol_type yyerror_range[2];

 
     /// $$ and @@$.
 
     /// $$ and @@$.

-    data_type yylhs;
+    stack_symbol_type yylhs;

 
     /// The return value of parse().
     int yyresult;
 
     /// The return value of parse().
     int yyresult;


@@ -841,7 +973,7 @@ m4_popdef([b4_at_dollar])])dnl
        location values to have been already stored, initialize these
        stacks with a primary value.  */
     yystack_ = stack_type (0);
        location values to have been already stored, initialize these
        stacks with a primary value.  */
     yystack_ = stack_type (0);

-    yypush_ (0, yyla);
+    yypush_ (0, 0, yyla);

 
     // A new state was pushed on the stack.
     // Invariant: yystate == yystack_[0].state, i.e.,
 
     // A new state was pushed on the stack.
     // Invariant: yystate == yystack_[0].state, i.e.,


@@ -877,19 +1009,19 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     /* Convert token to internal form.  */
     if (yychar <= yyeof_)
       {
     /* Convert token to internal form.  */
     if (yychar <= yyeof_)
       {

-       yychar = yytoken = yyeof_;
+       yychar = yyla.type = yyeof_;

        YYCDEBUG << "Now at end of input." << std::endl;
       }
     else
       {
        YYCDEBUG << "Now at end of input." << std::endl;
       }
     else
       {

-       yytoken = yytranslate_ (yychar);
-       YY_SYMBOL_PRINT ("Next token is", yytoken, yyla.value, yyla.location);
+       yyla.type = yytranslate_ (yychar);
+       YY_SYMBOL_PRINT ("Next token is", yyla);

       }
 
       }
 

-    /* If the proper action on seeing token YYTOKEN is to reduce or to
-       detect an error, take that action.  */
-    yyn += yytoken;
-    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
+    /* 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)

       goto yydefault;
 
     /* Reduce or error.  */
       goto yydefault;
 
     /* Reduce or error.  */


@@ -911,8 +1043,8 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       --yyerrstatus_;
 
     /* Shift the lookahead token.  */
       --yyerrstatus_;
 
     /* Shift the lookahead token.  */

-    yyla.state = yystate = yyn;
-    yypush_ ("Shifting", yyla);
+    yystate = yyn;
+    yypush_ ("Shifting", yystate, yyla);

     goto yynewstate;
 
   /*-----------------------------------------------------------.
     goto yynewstate;
 
   /*-----------------------------------------------------------.


@@ -946,7 +1078,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 
     // Compute the default @@$.
     {
 
     // Compute the default @@$.
     {

-      slice<data_type, stack_type> slice (yystack_, yylen);
+      slice<stack_symbol_type, stack_type> slice (yystack_, yylen);

       YYLLOC_DEFAULT (yylhs.location, slice, yylen);
     }
 
       YYLLOC_DEFAULT (yylhs.location, slice, yylen);
     }
 


@@ -967,7 +1099,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     else
       yystate = yydefgoto_[yyn - yyntokens_];
     yylhs.state = yystate;
     else
       yystate = yydefgoto_[yyn - yyntokens_];
     yylhs.state = yystate;

-    YY_SYMBOL_PRINT ("-> $$ =", yyn, yylhs.value, yylhs.location);
+    YY_SYMBOL_PRINT ("-> $$ =", yylhs);

 ]b4_variant_if([[
     // Destroy the lhs symbols.
     for (int i = 0; i < yylen; ++i)
 ]b4_variant_if([[
     // Destroy the lhs symbols.
     for (int i = 0; i < yylen; ++i)


@@ -979,9 +1111,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       // do not try to report the content in the debug trace, it's
       // junk.  Hence yymsg = 0.  Besides, that keeps exactly the same
       // traces as with the other Bison skeletons.
       // do not try to report the content in the debug trace, it's
       // junk.  Hence yymsg = 0.  Besides, that keeps exactly the same
       // traces as with the other Bison skeletons.

-      yydestruct_ (0,
-                   yystos_[yystack_[i].state],
-                   yystack_[i].value, yystack_[i].location);]])[
+      yy_destroy_ (0, yystack_[i]);]])[

 
     yypop_ (yylen);
     yylen = 0;
 
     yypop_ (yylen);
     yylen = 0;


@@ -999,7 +1129,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     if (!yyerrstatus_)
       {
        ++yynerrs_;
     if (!yyerrstatus_)
       {
        ++yynerrs_;

-       error (yyla.location, yysyntax_error_ (yystate, yytoken));
+       error (yyla.location, yysyntax_error_ (yystate, yyla.type));

       }
 
     yyerror_range[0].location = yyla.location;
       }
 
     yyerror_range[0].location = yyla.location;


@@ -1016,8 +1146,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
          }
        else
          {
          }
        else
          {

-           yydestruct_ ("Error: discarding",
-                         yytoken, yyla.value, yyla.location);
+           yy_destroy_ ("Error: discarding", yyla);

            yychar = yyempty_;
          }
       }
            yychar = yyempty_;
          }
       }


@@ -1052,7 +1181,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
   yyerrlab1:
     yyerrstatus_ = 3;  /* Each real token shifted decrements this.  */
     {
   yyerrlab1:
     yyerrstatus_ = 3;  /* Each real token shifted decrements this.  */
     {

-      data_type error_token;
+      stack_symbol_type error_token;

       for (;;)
         {
           yyn = yypact_[yystate];
       for (;;)
         {
           yyn = yypact_[yystate];


@@ -1072,9 +1201,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
             YYABORT;
 
           yyerror_range[0].location = yystack_[0].location;
             YYABORT;
 
           yyerror_range[0].location = yystack_[0].location;

-          yydestruct_ ("Error: popping",
-                       yystos_[yystate],
-                       yystack_[0].value, yystack_[0].location);
+          yy_destroy_ ("Error: popping", yystack_[0]);

           yypop_ ();
           yystate = yystack_[0].state;
           YY_STACK_PRINT ();
           yypop_ ();
           yystate = yystack_[0].state;
           YY_STACK_PRINT ();


@@ -1101,17 +1228,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 
   yyreturn:
     if (yychar != yyempty_)
 
   yyreturn:
     if (yychar != yyempty_)

-      yydestruct_ ("Cleanup: discarding lookahead",
-                   yytoken, yyla.value, yyla.location);
+      yy_destroy_ ("Cleanup: discarding lookahead", yyla);

 
     /* Do not reclaim the symbols of the rule which action triggered
        this YYABORT or YYACCEPT.  */
     yypop_ (yylen);
     while (yystack_.size () != 1)
       {
 
     /* Do not reclaim the symbols of the rule which action triggered
        this YYABORT or YYACCEPT.  */
     yypop_ (yylen);
     while (yystack_.size () != 1)
       {

-       yydestruct_ ("Cleanup: popping",
-                  yystos_[yystack_[0].state],
-                  yystack_[0].value, yystack_[0].location);
+       yy_destroy_ ("Cleanup: popping", yystack_[0]);

        yypop_ ();
       }
 
        yypop_ ();
       }
 


@@ -1249,9 +1373,7 @@ b4_error_verbose_if([ tok])[)
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",

-                       ]yystos_@{b4_rhs_state(yynrhs, yyi + 1)@}[,
-                      ]b4_rhs_value(yynrhs, yyi + 1)[,
-                      ]b4_rhs_location(yynrhs, yyi + 1)[);
+                       ]b4_rhs_data(yynrhs, yyi + 1)[);

   }
 #endif // YYDEBUG
 
   }
 #endif // YYDEBUG