bench.pl -d, --directive.

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 34bcc278df616404059c80c88bcbc5bc532d7116..dc39780013d8981fe03885a4468905808db20245 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -99,8 +99,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([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;


@@ -394,23 +394,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 +458,17 @@ 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.
+    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 the type of this symbol.
+      virtual int type_get () const = 0;

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


@@ -505,8 +477,55 @@ 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.
+    void yy_print_ (std::ostream& yyo, const symbol_base_type& 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.
+    inline void yy_destroy_ (const char* yymsg, symbol_base_type& yysym) const;
+
+    /// Element of the stack: a state and its attributes.
+    struct symbol_type : symbol_base_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.
+      virtual inline int type_get () const;
+    };
+
+    /// Element of the stack: a state and its attributes.
+    struct stack_symbol_type : symbol_base_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.
+      virtual 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_;


@@ -514,12 +533,17 @@ m4_ifdef([b4_stype],
     /// Push a new state on the stack.
     /// \param m    a debug message to display
     ///             if null, no trace is output.
     /// Push a new state on the stack.
     /// \param m    a debug message to display
     ///             if null, no trace is output.

-    /// \param s    the state entered
-    /// \param v    semantic value
-    /// \param l    location
-    /// \warning the contents of \a v is stolen.
-    inline void yypush_ (const char* m, state_type s,
-                         semantic_type& v, const location_type& l);
+    /// \param s    the symbol
+    /// \warning the contents of \a s.value is stolen.
+    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);


@@ -538,6 +562,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]],


@@ -591,14 +616,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)         \


@@ -616,9 +641,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 */
 


@@ -686,48 +711,73 @@ 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.
+  ]b4_parser_class_name[::symbol_base_type::symbol_base_type ()
+    : value()
+    , location()

   {
   {

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

   }
 
   }
 

+  ]b4_parser_class_name[::symbol_base_type::symbol_base_type (const semantic_type& v, const location_type& l)

 
 

-  void
-  ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
-                          const semantic_type& yyvalue, const location_type& yylocation)
+    : value(v)
+    , location(l)

   {
   {

-    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
-              << ' ' << yytname_[yytype] << " ("
-              << yylocation << ": ";
-    yy_symbol_value_print_ (yytype, yyvalue, yylocation);
-    *yycdebug_ << ')';

   }
   }

-#endif
+
+  // symbol_type.
+  ]b4_parser_class_name[::symbol_type::symbol_type ()
+    : type()
+    , symbol_base_type()
+  {
+  }
+
+  ]b4_parser_class_name[::symbol_type::symbol_type (int t,
+                           const semantic_type& v, const location_type& l)
+    : type(t)
+    , symbol_base_type(v, l)
+  {
+  }
+
+  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 ()
+    : state()
+    , symbol_base_type()
+  {
+  }
+
+  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s,
+                           const semantic_type& v, const location_type& l)
+    : state(s)
+    , symbol_base_type(v, l)
+  {
+  }
+
+  int
+  ]b4_parser_class_name[::stack_symbol_type::type_get () const
+  {
+    return yystos_[state];
+  }
+

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


@@ -738,34 +788,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]], [[destroy]])])[

   }
 
   }
 

-  ]b4_parser_class_name[::data_type::data_type ()
-    : state()
-    , value()
-    , location()
+#if YYDEBUG
+  void
+  ]b4_parser_class_name[::yy_print_ (std::ostream& yyo, const symbol_base_type& 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, state_type s,
-                           semantic_type& v, const location_type& l)
+  ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)

   {
     if (m)
   {
     if (m)

-      YY_SYMBOL_PRINT (m, yystos_[s], v, l);
+      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]], [build], [v])],
-[    yystack_.push (data_type (s, v, l));])[
+[[    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);])[

   }
 
   void
   }
 
   void


@@ -804,9 +870,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;


@@ -817,15 +882,14 @@ b4_percent_code_get[]dnl
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 

-    /// Semantic value of the lookahead.
-    semantic_type yylval;
-    /// Location of the lookahead.
-    location_type yylloc;
+    /// The lookahead symbol.
+    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;


@@ -833,8 +897,8 @@ b4_percent_code_get[]dnl
     YYCDEBUG << "Starting parse" << std::endl;
 
 ]m4_ifdef([b4_initial_action], [
     YYCDEBUG << "Starting parse" << std::endl;
 
 ]m4_ifdef([b4_initial_action], [

-m4_pushdef([b4_at_dollar],     [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
+m4_pushdef([b4_at_dollar],     [yyla.location])dnl
+m4_pushdef([b4_dollar_dollar], [yyla.value])dnl

     /* User initialization code.  */
     b4_user_initial_action
 m4_popdef([b4_dollar_dollar])dnl
     /* User initialization code.  */
     b4_user_initial_action
 m4_popdef([b4_dollar_dollar])dnl


@@ -845,7 +909,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, yystate, yylval, yylloc);
+    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.,


@@ -872,8 +936,8 @@ m4_popdef([b4_at_dollar])])dnl
       {
        YYCDEBUG << "Reading a token: ";
        yychar = ]b4_c_function_call([yylex], [int],
       {
        YYCDEBUG << "Reading a token: ";
        yychar = ]b4_c_function_call([yylex], [int],

-                                    [[YYSTYPE*], [&yylval]][]dnl
-b4_locations_if([, [[location*], [&yylloc]]])dnl
+                                    [[YYSTYPE*], [&yyla.value]][]dnl
+b4_locations_if([, [[location*], [&yyla.location]]])dnl

 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       }
 
 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       }
 


@@ -881,19 +945,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, yylval, yylloc);
+       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.  */


@@ -901,7 +965,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     if (yyn <= 0)
       {
        if (yyn == 0 || yyn == yytable_ninf_)
     if (yyn <= 0)
       {
        if (yyn == 0 || yyn == yytable_ninf_)

-       goto yyerrlab;
+         goto yyerrlab;

        yyn = -yyn;
        goto yyreduce;
       }
        yyn = -yyn;
        goto yyreduce;
       }


@@ -916,7 +980,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 
     /* Shift the lookahead token.  */
     yystate = yyn;
 
     /* Shift the lookahead token.  */
     yystate = yyn;

-    yypush_ ("Shifting", yystate, yylval, yylloc);
+    yypush_ ("Shifting", yystate, yyla);

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


@@ -950,7 +1014,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);
     }
 


@@ -971,7 +1035,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)


@@ -983,16 +1047,14 @@ 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;
     YY_STACK_PRINT ();
 
     /* Shift the result of the reduction.  */
 
     yypop_ (yylen);
     yylen = 0;
     YY_STACK_PRINT ();
 
     /* Shift the result of the reduction.  */

-    yypush_ (0, yylhs.state, yylhs.value, yylhs.location);
+    yypush_ (0, yylhs);

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


@@ -1003,10 +1065,10 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     if (!yyerrstatus_)
       {
        ++yynerrs_;
     if (!yyerrstatus_)
       {
        ++yynerrs_;

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

       }
 
       }
 

-    yyerror_range[0].location = yylloc;
+    yyerror_range[0].location = yyla.location;

     if (yyerrstatus_ == 3)
       {
        /* If just tried and failed to reuse lookahead token after an
     if (yyerrstatus_ == 3)
       {
        /* If just tried and failed to reuse lookahead token after an


@@ -1020,7 +1082,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
          }
        else
          {
          }
        else
          {

-           yydestruct_ ("Error: discarding", yytoken, yylval, yylloc);
+           yy_destroy_ ("Error: discarding", yyla);

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


@@ -1055,7 +1117,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];


@@ -1075,20 +1137,18 @@ 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 ();
         }
 

-      yyerror_range[1].location = yylloc;
+      yyerror_range[1].location = yyla.location;

       YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);
 
       /* Shift the error token.  */
       YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);
 
       /* Shift the error token.  */

-      yystate = yyn;
-      yypush_ ("Shifting", yystate, error_token.value, error_token.location);
+      error_token.state = yystate = yyn;
+      yypush_ ("Shifting", error_token);

     }
     goto yynewstate;
 
     }
     goto yynewstate;
 


@@ -1104,16 +1164,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 
   yyreturn:
     if (yychar != yyempty_)
 
   yyreturn:
     if (yychar != yyempty_)

-      yydestruct_ ("Cleanup: discarding lookahead", yytoken, yylval, yylloc);
+      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_ ();
       }
 


@@ -1251,9 +1309,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