]> git.saurik.com Git - bison.git/blobdiff - data/lalr1.cc
build: fix VPATH issue
[bison.git] / data / lalr1.cc
index 8cf20430ea30ea5f185c5e42762eb5d3db261a8b..178b8fa992e8d7428e4939f50a54c16c96cab011 100644 (file)
@@ -20,16 +20,16 @@ m4_include(b4_pkgdatadir/[c++.m4])
 
 # b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
 # --------------------------------------------------------------
 
 # b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
 # --------------------------------------------------------------
-# Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT.
+# Declare "parser::yy<TABLE-NAME>_" whose contents is CONTENT.
 m4_define([b4_integral_parser_table_declare],
 m4_define([b4_integral_parser_table_declare],
-[m4_ifval([$3], [b4_c_comment([$3], [  ])
+[m4_ifval([$3], [b4_comment([$3], [  ])
 ])dnl
   static const b4_int_type_for([$2]) yy$1_[[]];dnl
 ])
 
 # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
 # -------------------------------------------------------------
 ])dnl
   static const b4_int_type_for([$2]) yy$1_[[]];dnl
 ])
 
 # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
 # -------------------------------------------------------------
-# Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
+# Define "parser::yy<TABLE-NAME>_" whose contents is CONTENT.
 m4_define([b4_integral_parser_table_define],
 [  const b4_int_type_for([$2])
   b4_parser_class_name::yy$1_[[]] =
 m4_define([b4_integral_parser_table_define],
 [  const b4_int_type_for([$2])
   b4_parser_class_name::yy$1_[[]] =
@@ -114,16 +114,28 @@ b4_dollar_popdef[]dnl
 ])])
 
 
 ])])
 
 
+# b4_lex
+# ------
+# Call yylex.
+m4_define([b4_lex],
+[b4_token_ctor_if(
+[b4_function_call([yylex],
+                  [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))],
+[b4_function_call([yylex], [int],
+                  [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl
+b4_locations_if([, [[location*], [&yyla.location]]])dnl
+m4_ifdef([b4_lex_param], [, ]b4_lex_param))])])
+
+
 m4_pushdef([b4_copyright_years],
            [2002-2012])
 
 m4_define([b4_parser_class_name],
           [b4_percent_define_get([[parser_class_name]])])
 
 m4_pushdef([b4_copyright_years],
            [2002-2012])
 
 m4_define([b4_parser_class_name],
           [b4_percent_define_get([[parser_class_name]])])
 
-b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
-  [# Backward compatibility.
+b4_bison_locations_if([# Backward compatibility.
    m4_define([b4_location_constructors])
    m4_define([b4_location_constructors])
-   m4_include(b4_pkgdatadir/[location.cc])])])
+   m4_include(b4_pkgdatadir/[location.cc])])
 m4_include(b4_pkgdatadir/[stack.hh])
 b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])
 
 m4_include(b4_pkgdatadir/[stack.hh])
 b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])
 
@@ -134,13 +146,14 @@ 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 <deque>
+# include <cstdlib>  // abort
+# include <vector>
 # include <iostream>
 # include <stdexcept>
 # include <string>]b4_defines_if([[
 # include "stack.hh"
 # include <iostream>
 # include <stdexcept>
 # include <string>]b4_defines_if([[
 # include "stack.hh"
-]b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
-                                          [[# include "location.hh"]])])])[
+]b4_bison_locations_if([[# include "location.hh"]])])[
+]b4_variant_if([b4_variant_includes])[
 
 ]b4_YYDEBUG_define[
 
 
 ]b4_YYDEBUG_define[
 
@@ -148,9 +161,8 @@ m4_define([b4_shared_declarations],
 
 ]b4_defines_if([],
 [b4_stack_define
 
 ]b4_defines_if([],
 [b4_stack_define
-b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
-                                         [b4_position_define
-b4_location_define])])])[
+b4_bison_locations_if([b4_position_define
+b4_location_define])])[
 
 ]b4_variant_if([b4_variant_define])[
 
 
 ]b4_variant_if([b4_variant_define])[
 
@@ -216,6 +228,9 @@ b4_location_define])])])[
     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_;
 
     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);
+
     // Tables.
 ]b4_parser_tables_declare[]b4_error_verbose_if([
 
     // Tables.
 ]b4_parser_tables_declare[]b4_error_verbose_if([
 
@@ -227,7 +242,7 @@ b4_location_define])])])[
     static const char* const yytname_[];
 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
 ]b4_integral_parser_table_declare([rline], [b4_rline],
     static const char* const yytname_[];
 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
 ]b4_integral_parser_table_declare([rline], [b4_rline],
-     [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
+     [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[
     /// Report on the debug stream that the rule \a r is going to be reduced.
     virtual void yy_reduce_print_ (int r);
     /// Print the state stack on the debug stream.
     /// Report on the debug stream that the rule \a r is going to be reduced.
     virtual void yy_reduce_print_ (int r);
     /// Print the state stack on the debug stream.
@@ -236,50 +251,48 @@ b4_location_define])])])[
     // Debugging.
     int yydebug_;
     std::ostream* yycdebug_;
     // Debugging.
     int yydebug_;
     std::ostream* yycdebug_;
-#endif // ]b4_api_PREFIX[DEBUG
 
 
-    /// Convert a scanner token number \a t to a symbol number.
-    static inline token_number_type yytranslate_ (]b4_lex_symbol_if([token_type], [int])[ t);
-
-#if ]b4_api_PREFIX[DEBUG
     /// \brief Display a symbol type, value and location.
     /// \param yyo    The output stream.
     /// \param yysym  The symbol.
     /// \brief Display a symbol type, value and location.
     /// \param yyo    The output stream.
     /// \param yysym  The symbol.
-    template <typename Exact>
+    template <typename Base>
     void yy_print_ (std::ostream& yyo,
     void yy_print_ (std::ostream& yyo,
-                    const symbol_base_type<Exact>& yysym) const;
+                    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.
     /// \param s         The symbol.
 #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>
+    template <typename Base>
     inline void yy_destroy_ (const char* yymsg,
     inline void yy_destroy_ (const char* yymsg,
-                             symbol_base_type<Exact>& yysym) const;
+                             basic_symbol<Base>& yysym) const;
 
   private:
 
   private:
-    /// Element of the stack: a state and its attributes.
-    struct stack_symbol_type : symbol_base_type<stack_symbol_type>
+    /// Type access provider for state based symbols.
+    struct by_state
     {
     {
-      /// The parent class.
-      typedef symbol_base_type<stack_symbol_type> super_type;
-
       /// Default constructor.
       /// Default constructor.
-      inline stack_symbol_type ();
+      inline by_state ();
 
       /// Constructor.
 
       /// Constructor.
-      inline stack_symbol_type (]b4_args([state_type s],
-                                         [const semantic_type& v],
-                                         b4_locations_if([const location_type& l]))[);
+      inline by_state (state_type s);
+
+      /// Copy constructor.
+      inline by_state (const by_state& other);
 
       /// The state.
       state_type state;
 
       /// The type (corresponding to \a state).
 
       /// The state.
       state_type state;
 
       /// The type (corresponding to \a state).
-      inline int type_get_ () const;
+      inline int type_get () const;
+
+      typedef state_type value_type;
     };
 
     };
 
+    /// "Internal" symbol: element of the stack.
+    typedef basic_symbol<by_state> stack_symbol_type;
+
     /// Stack type.
     typedef stack<stack_symbol_type> stack_type;
 
     /// Stack type.
     typedef stack<stack_symbol_type> stack_type;
 
@@ -304,7 +317,7 @@ b4_location_define])])])[
     /// 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);
 
-    /* Constants.  */
+    // Constants.
     enum
     {
       yyeof_ = 0,
     enum
     {
       yyeof_ = 0,
@@ -320,7 +333,7 @@ b4_location_define])])])[
 ]b4_parse_param_vars[
   };
 
 ]b4_parse_param_vars[
   };
 
-]b4_lex_symbol_if([b4_yytranslate_define
+]b4_token_ctor_if([b4_yytranslate_define
 b4_public_types_define])[
 ]b4_namespace_close[
 
 b4_public_types_define])[
 ]b4_namespace_close[
 
@@ -328,18 +341,15 @@ b4_public_types_define])[
 [b4_token_defines
 
 #ifndef ]b4_api_PREFIX[STYPE
 [b4_token_defines
 
 #ifndef ]b4_api_PREFIX[STYPE
- /* Redirection for backward compatibility.  */
+ // Redirection for backward compatibility.
 # define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type
 #endif
 ])[
 ]b4_percent_code_get([[provides]])[
 ]])
 
 # define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type
 #endif
 ])[
 ]b4_percent_code_get([[provides]])[
 ]])
 
-# We do want M4 expansion after # for CPP macros.
-m4_changecom()
 b4_defines_if(
 b4_defines_if(
-[m4_divert_push(0)dnl
-@output(b4_spec_defines_file@)@
+[b4_output_begin([b4_spec_defines_file])
 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
 [
 /**
 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
 [
 /**
@@ -347,17 +357,16 @@ b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
  ** Define the ]b4_namespace_ref[::parser class.
  */
 
  ** Define the ]b4_namespace_ref[::parser class.
  */
 
-/* C++ LALR(1) parser skeleton written by Akim Demaille.  */
+// C++ LALR(1) parser skeleton written by Akim Demaille.
 
 ]b4_cpp_guard_open([b4_spec_defines_file])[
 ]b4_shared_declarations[
 ]b4_cpp_guard_close([b4_spec_defines_file])
 
 ]b4_cpp_guard_open([b4_spec_defines_file])[
 ]b4_shared_declarations[
 ]b4_cpp_guard_close([b4_spec_defines_file])
-m4_divert_pop(0)dnl
+b4_output_end()
 ])
 
 
 ])
 
 
-m4_divert_push(0)dnl
-@output(b4_parser_file_name@)@
+b4_output_begin([b4_parser_file_name])
 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
 b4_percent_code_get([[top]])[]dnl
 m4_if(b4_prefix, [yy], [],
 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
 b4_percent_code_get([[top]])[]dnl
 m4_if(b4_prefix, [yy], [],
@@ -373,14 +382,14 @@ m4_if(b4_prefix, [yy], [],
 ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
                [b4_shared_declarations])[
 
 ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
                [b4_shared_declarations])[
 
-/* User implementation prologue.  */
+// User implementation prologue.
 ]b4_user_post_prologue[
 ]b4_percent_code_get[
 
 #ifndef YY_
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 ]b4_user_post_prologue[
 ]b4_percent_code_get[
 
 #ifndef YY_
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
-#   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
+#   include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 #  endif
 # endif
 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 #  endif
 # endif
@@ -393,13 +402,13 @@ m4_if(b4_prefix, [yy], [],
 [#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
 ]b4_yylloc_default_define])[
 
 [#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
 ]b4_yylloc_default_define])[
 
-/* Suppress unused-variable warnings by "using" E.  */
-#define YYUSE(e) ((void) (e))
+// Suppress unused-variable warnings by "using" E.
+#define YYUSE(E) ((void) (E))
 
 
-/* Enable debugging if requested.  */
+// Enable debugging if requested.
 #if ]b4_api_PREFIX[DEBUG
 
 #if ]b4_api_PREFIX[DEBUG
 
-/* A pseudo ostream that takes yydebug_ into account.  */
+// A pseudo ostream that takes yydebug_ into account.
 # define YYCDEBUG if (yydebug_) (*yycdebug_)
 
 # define YY_SYMBOL_PRINT(Title, Symbol)         \
 # define YYCDEBUG if (yydebug_) (*yycdebug_)
 
 # define YY_SYMBOL_PRINT(Title, Symbol)         \
@@ -424,14 +433,14 @@ m4_if(b4_prefix, [yy], [],
       yystack_print_ ();                \
   } while (false)
 
       yystack_print_ ();                \
   } while (false)
 
-#else /* !]b4_api_PREFIX[DEBUG */
+#else // !]b4_api_PREFIX[DEBUG
 
 # define YYCDEBUG if (false) std::cerr
 # define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE(Symbol)
 # define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)
 # define YY_STACK_PRINT()                static_cast<void>(0)
 
 
 # define YYCDEBUG if (false) std::cerr
 # define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE(Symbol)
 # define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)
 # define YY_STACK_PRINT()                static_cast<void>(0)
 
-#endif /* !]b4_api_PREFIX[DEBUG */
+#endif // !]b4_api_PREFIX[DEBUG
 
 #define yyerrok         (yyerrstatus_ = 0)
 #define yyclearin       (yyempty = true)
 
 #define yyerrok         (yyerrstatus_ = 0)
 #define yyclearin       (yyempty = true)
@@ -466,7 +475,7 @@ m4_if(b4_prefix, [yy], [],
             case '\\':
               if (*++yyp != '\\')
                 goto do_not_strip_quotes;
             case '\\':
               if (*++yyp != '\\')
                 goto do_not_strip_quotes;
-              /* Fall through.  */
+              // Fall through.
             default:
               yyr += *yyp;
               break;
             default:
               yyr += *yyp;
               break;
@@ -500,35 +509,31 @@ m4_if(b4_prefix, [yy], [],
   | Symbol types.  |
   `---------------*/
 
   | Symbol types.  |
   `---------------*/
 
-]b4_lex_symbol_if([], [b4_public_types_define])[
+]b4_token_ctor_if([], [b4_public_types_define])[
 
 
-  // stack_symbol_type.
-  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
-    : super_type ()
-    , state ()
-  {
-  }
+  // by_state.
+  ]b4_parser_class_name[::by_state::by_state ()
+    : state ()
+  {}
 
 
-  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (]b4_args(
-                 [state_type s],
-                 [const semantic_type& v],
-                 b4_locations_if([const location_type& l]))[)
-    : super_type (v]b4_locations_if([, l])[)
-    , state (s)
-  {
-  }
+  ]b4_parser_class_name[::by_state::by_state (const by_state& other)
+    : state (other.state)
+  {}
+
+  ]b4_parser_class_name[::by_state::by_state (state_type s)
+    : state (s)
+  {}
 
   int
 
   int
-  ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
+  ]b4_parser_class_name[::by_state::type_get () const
   {
     return yystos_[state];
   }
 
   {
     return yystos_[state];
   }
 
-
-  template <typename Exact>
+  template <typename Base>
   void
   ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
   void
   ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
-                                       symbol_base_type<Exact>& yysym) const
+                                       basic_symbol<Base>& yysym) const
   {
     if (yymsg)
       YY_SYMBOL_PRINT (yymsg, yysym);
   {
     if (yymsg)
       YY_SYMBOL_PRINT (yymsg, yysym);
@@ -547,10 +552,10 @@ m4_if(b4_prefix, [yy], [],
   }
 
 #if ]b4_api_PREFIX[DEBUG
   }
 
 #if ]b4_api_PREFIX[DEBUG
-  template <typename Exact>
+  template <typename Base>
   void
   ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
   void
   ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
-                                     const symbol_base_type<Exact>& yysym) const
+                                     const basic_symbol<Base>& yysym) const
   {
     std::ostream& yyoutput = yyo;
     YYUSE (yyoutput);
   {
     std::ostream& yyoutput = yyo;
     YYUSE (yyoutput);
@@ -575,16 +580,14 @@ m4_if(b4_prefix, [yy], [],
     if (m)
       YY_SYMBOL_PRINT (m, sym);
 ]b4_variant_if(
     if (m)
       YY_SYMBOL_PRINT (m, sym);
 ]b4_variant_if(
-[[    yystack_.push (stack_symbol_type (]b4_args(
-                    [s],
-                    [semantic_type()],
-                    b4_locations_if([sym.location]))[));
-    ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
-                       [build], [sym.value])],
-[[    yystack_.push (stack_symbol_type (]b4_args(
-                      [s],
-                      [sym.value],
-                      b4_locations_if([sym.location]))[));]])[
+[[
+  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]))[));]])[
   }
 
   void
   }
 
   void
@@ -593,12 +596,12 @@ m4_if(b4_prefix, [yy], [],
     if (m)
       YY_SYMBOL_PRINT (m, s);
 ]b4_variant_if(
     if (m)
       YY_SYMBOL_PRINT (m, s);
 ]b4_variant_if(
-[[    yystack_.push (stack_symbol_type (]b4_args(
-                       [s.state],
-                       [semantic_type()],
-                       b4_locations_if([s.location]))[));
-    ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
-                       [build], [s.value])],
+[[
+  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);])[
   }
 
@@ -663,11 +666,11 @@ m4_if(b4_prefix, [yy], [],
     /// Whether yyla contains a lookahead.
     bool yyempty = true;
 
     /// Whether yyla contains a lookahead.
     bool yyempty = true;
 
-    /* State.  */
+    // State.
     int yyn;
     int yylen = 0;
 
     int yyn;
     int yylen = 0;
 
-    /* Error handling.  */
+    // Error handling.
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 
@@ -683,11 +686,15 @@ m4_if(b4_prefix, [yy], [],
     /// The return value of parse ().
     int yyresult;
 
     /// The return value of parse ().
     int yyresult;
 
+    // FIXME: This shoud be completely indented.  It is not yet to
+    // avoid gratuitous conflicts when merging into the master branch.
+    try
+      {
     YYCDEBUG << "Starting parse" << std::endl;
 
 ]m4_ifdef([b4_initial_action], [
 b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl
     YYCDEBUG << "Starting parse" << std::endl;
 
 ]m4_ifdef([b4_initial_action], [
 b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl
-    /* User initialization code.  */
+    // User initialization code.
     b4_user_initial_action
 b4_dollar_popdef])[]dnl
 
     b4_user_initial_action
 b4_dollar_popdef])[]dnl
 
@@ -702,39 +709,35 @@ b4_dollar_popdef])[]dnl
   yynewstate:
     YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
 
   yynewstate:
     YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
 
-    /* Accept?  */
+    // Accept?
     if (yystack_[0].state == yyfinal_)
       goto yyacceptlab;
 
     goto yybackup;
 
     if (yystack_[0].state == yyfinal_)
       goto yyacceptlab;
 
     goto yybackup;
 
-    /* Backup.  */
+    // Backup.
   yybackup:
 
   yybackup:
 
-    /* Try to take a decision without lookahead.  */
+    // Try to take a decision without lookahead.
     yyn = yypact_[yystack_[0].state];
     if (yy_pact_value_is_default_ (yyn))
       goto yydefault;
 
     yyn = yypact_[yystack_[0].state];
     if (yy_pact_value_is_default_ (yyn))
       goto yydefault;
 
-    /* Read a lookahead token.  */
+    // Read a lookahead token.
     if (yyempty)
       {
         YYCDEBUG << "Reading a token: ";
         try
     if (yyempty)
       {
         YYCDEBUG << "Reading a token: ";
         try
-        {
-]b4_lex_symbol_if(
-[          yyla = b4_c_function_call([yylex], [symbol_type],
-                                     m4_ifdef([b4_lex_param], b4_lex_param));],
-[          yyla.type = yytranslate_ (b4_c_function_call([yylex], [int],
-                                     [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl
-b4_locations_if([, [[location*], [&yyla.location]]])dnl
-m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
-        }
+          {]b4_token_ctor_if([[
+            symbol_type yylookahead (]b4_lex[);
+            yyla.move (yylookahead);]], [[
+            yyla.type = yytranslate_ (]b4_lex[);]])[
+          }
         catch (const syntax_error& yyexc)
         catch (const syntax_error& yyexc)
-        {
-          error (yyexc);
-          goto yyerrlab1;
-        }
+          {
+            error (yyexc);
+            goto yyerrlab1;
+          }
         yyempty = false;
       }
     YY_SYMBOL_PRINT ("Next token is", yyla);
         yyempty = false;
       }
     YY_SYMBOL_PRINT ("Next token is", yyla);
@@ -745,7 +748,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
       goto yydefault;
 
     if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
       goto yydefault;
 
-    /* Reduce or error.  */
+    // Reduce or error.
     yyn = yytable_[yyn];
     if (yyn <= 0)
       {
     yyn = yytable_[yyn];
     if (yyn <= 0)
       {
@@ -755,15 +758,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
         goto yyreduce;
       }
 
         goto yyreduce;
       }
 
-    /* Discard the token being shifted.  */
+    // Discard the token being shifted.
     yyempty = true;
 
     yyempty = true;
 
-    /* Count tokens shifted since error; after three, turn off error
-       status.  */
+    // Count tokens shifted since error; after three, turn off error status.
     if (yyerrstatus_)
       --yyerrstatus_;
 
     if (yyerrstatus_)
       --yyerrstatus_;
 
-    /* Shift the lookahead token.  */
+    // Shift the lookahead token.
     yypush_ ("Shifting", yyn, yyla);
     goto yynewstate;
 
     yypush_ ("Shifting", yyn, yyla);
     goto yynewstate;
 
@@ -807,24 +809,24 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     // Perform the reduction.
     YY_REDUCE_PRINT (yyn);
     try
     // Perform the reduction.
     YY_REDUCE_PRINT (yyn);
     try
-    {
-      switch (yyn)
       {
       {
+        switch (yyn)
+          {
 ]b4_user_actions[
 ]b4_user_actions[
-        default:
-          break;
+          default:
+            break;
+          }
       }
       }
-    }
     catch (const syntax_error& yyexc)
     catch (const syntax_error& yyexc)
-    {
-      error (yyexc);
-      YYERROR;
-    }
+      {
+        error (yyexc);
+        YYERROR;
+      }
     YY_SYMBOL_PRINT ("-> $$ =", yylhs);
 ]b4_variant_if([[
     // Destroy the rhs symbols.
     for (int i = 0; i < yylen; ++i)
     YY_SYMBOL_PRINT ("-> $$ =", yylhs);
 ]b4_variant_if([[
     // Destroy the rhs symbols.
     for (int i = 0; i < yylen; ++i)
-      // Destroy a variant which value may have been swapped with
+      // 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
       // 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
@@ -840,7 +842,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     yylen = 0;
     YY_STACK_PRINT ();
 
     yylen = 0;
     YY_STACK_PRINT ();
 
-    /* Shift the result of the reduction.  */
+    // Shift the result of the reduction.
     yypush_ (YY_NULL, yylhs);
     goto yynewstate;
 
     yypush_ (YY_NULL, yylhs);
     goto yynewstate;
 
@@ -848,11 +850,11 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
   | yyerrlab -- here on detecting error.  |
   `--------------------------------------*/
   yyerrlab:
   | yyerrlab -- here on detecting error.  |
   `--------------------------------------*/
   yyerrlab:
-    /* If not already recovering from an error, report this error.  */
+    // If not already recovering from an error, report this error.
     if (!yyerrstatus_)
       {
         ++yynerrs_;
     if (!yyerrstatus_)
       {
         ++yynerrs_;
-        error (]b4_args(b4_locations_if([yyla.location]),
+        error (]b4_join(b4_locations_if([yyla.location]),
                         [[yysyntax_error_ (yystack_[0].state,
                                            yyempty ? yyempty_ : yyla.type)]])[);
       }
                         [[yysyntax_error_ (yystack_[0].state,
                                            yyempty ? yyempty_ : yyla.type)]])[);
       }
@@ -864,7 +866,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
         /* If just tried and failed to reuse lookahead token after an
            error, discard it.  */
 
         /* If just tried and failed to reuse lookahead token after an
            error, discard it.  */
 
-        /* Return failure if at end of input.  */
+        // Return failure if at end of input.
         if (yyla.type == yyeof_)
           YYABORT;
         else if (!yyempty)
         if (yyla.type == yyeof_)
           YYABORT;
         else if (!yyempty)
@@ -874,8 +876,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
           }
       }
 
           }
       }
 
-    /* Else will try to reuse lookahead token after shifting the error
-       token.  */
+    // Else will try to reuse lookahead token after shifting the error token.
     goto yyerrlab1;
 
 
     goto yyerrlab1;
 
 
@@ -892,7 +893,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     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;]])b4_variant_if([[
     /* $$ was initialized before running the user action.  */
     yy_destroy_ ("Error: discarding", yylhs);]])[
-    /* Do not reclaim the symbols of the rule which action triggered
+    /* Do not reclaim the symbols of the rule whose action triggered
        this YYERROR.  */
     yypop_ (yylen);
     yylen = 0;
        this YYERROR.  */
     yypop_ (yylen);
     yylen = 0;
@@ -902,7 +903,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
   | yyerrlab1 -- common code for both syntax error and YYERROR.  |
   `-------------------------------------------------------------*/
   yyerrlab1:
   | yyerrlab1 -- common code for both syntax error and YYERROR.  |
   `-------------------------------------------------------------*/
   yyerrlab1:
-    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
+    yyerrstatus_ = 3;   // Each real token shifted decrements this.
     {
       stack_symbol_type error_token;
       for (;;)
     {
       stack_symbol_type error_token;
       for (;;)
@@ -932,18 +933,18 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
       yyerror_range[2].location = yyla.location;
       YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[
 
       yyerror_range[2].location = yyla.location;
       YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[
 
-      /* Shift the error token.  */
+      // Shift the error token.
       error_token.state = yyn;
       yypush_ ("Shifting", error_token);
     }
     goto yynewstate;
 
       error_token.state = yyn;
       yypush_ ("Shifting", error_token);
     }
     goto yynewstate;
 
-    /* Accept.  */
+    // Accept.
   yyacceptlab:
     yyresult = 0;
     goto yyreturn;
 
   yyacceptlab:
     yyresult = 0;
     goto yyreturn;
 
-    /* Abort.  */
+    // Abort.
   yyabortlab:
     yyresult = 1;
     goto yyreturn;
   yyabortlab:
     yyresult = 1;
     goto yyreturn;
@@ -952,10 +953,10 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     if (!yyempty)
       yy_destroy_ ("Cleanup: discarding lookahead", yyla);
 
     if (!yyempty)
       yy_destroy_ ("Cleanup: discarding lookahead", yyla);
 
-    /* Do not reclaim the symbols of the rule which action triggered
+    /* Do not reclaim the symbols of the rule whose action triggered
        this YYABORT or YYACCEPT.  */
     yypop_ (yylen);
        this YYABORT or YYACCEPT.  */
     yypop_ (yylen);
-    while (yystack_.size () != 1)
+    while (1 < yystack_.size ())
       {
         yy_destroy_ ("Cleanup: popping", yystack_[0]);
         yypop_ ();
       {
         yy_destroy_ ("Cleanup: popping", yystack_[0]);
         yypop_ ();
@@ -963,11 +964,28 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
 
     return yyresult;
   }
 
     return yyresult;
   }
+    catch (...)
+      {
+        YYCDEBUG << "Exception caught: cleaning lookahead and stack"
+                 << 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);
+
+        while (1 < yystack_.size ())
+          {
+            yy_destroy_ (YY_NULL, yystack_[0]);
+            yypop_ ();
+          }
+        throw;
+      }
+  }
 
   void
   ]b4_parser_class_name[::error (const syntax_error& yyexc)
   {
 
   void
   ]b4_parser_class_name[::error (const syntax_error& yyexc)
   {
-    error (]b4_args(b4_locations_if([yyexc.location]),
+    error (]b4_join(b4_locations_if([yyexc.location]),
                     [[yyexc.what()]])[);
   }
 
                     [[yyexc.what()]])[);
   }
 
@@ -1021,7 +1039,7 @@ b4_error_verbose_if([state_type yystate, int yytoken],
                YYCHECK.  In other words, skip the first -YYN actions for
                this state because they are default actions.  */
             int yyxbegin = yyn < 0 ? -yyn : 0;
                YYCHECK.  In other words, skip the first -YYN actions for
                this state because they are default actions.  */
             int yyxbegin = yyn < 0 ? -yyn : 0;
-            /* Stay within bounds of both yycheck and yytname.  */
+            // Stay within bounds of both yycheck and yytname.
             int yychecklim = yylast_ - yyn + 1;
             int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
             for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
             int yychecklim = yylast_ - yyn + 1;
             int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
             for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
@@ -1077,8 +1095,8 @@ b4_error_verbose_if([state_type yystate, int yytoken],
 ]b4_parser_tables_define[
 
 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
 ]b4_parser_tables_define[
 
 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
-  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
+  // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+  // First, the terminals, then, starting at \a yyntokens_, nonterminals.
   const char*
   const ]b4_parser_class_name[::yytname_[] =
   {
   const char*
   const ]b4_parser_class_name[::yytname_[] =
   {
@@ -1107,18 +1125,20 @@ b4_error_verbose_if([state_type yystate, int yytoken],
   {
     unsigned int yylno = yyrline_[yyrule];
     int yynrhs = yyr2_[yyrule];
   {
     unsigned int yylno = yyrline_[yyrule];
     int yynrhs = yyr2_[yyrule];
-    /* Print the symbols being reduced, and their result.  */
+    // Print the symbols being reduced, and their result.
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
                << " (line " << yylno << "):" << std::endl;
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
                << " (line " << yylno << "):" << std::endl;
-    /* The symbols being reduced.  */
+    // The symbols being reduced.
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
                        ]b4_rhs_data(yynrhs, yyi + 1)[);
   }
 #endif // ]b4_api_PREFIX[DEBUG
 
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
                        ]b4_rhs_data(yynrhs, yyi + 1)[);
   }
 #endif // ]b4_api_PREFIX[DEBUG
 
-]b4_lex_symbol_if([], [b4_yytranslate_define])[
+]b4_token_ctor_if([], [b4_yytranslate_define])[
 ]b4_namespace_close[
 ]b4_epilogue[]dnl
 ]b4_namespace_close[
 ]b4_epilogue[]dnl
-m4_divert_pop(0)
+b4_output_end()
+
+
 m4_popdef([b4_copyright_years])dnl
 m4_popdef([b4_copyright_years])dnl