lalr1, yacc: use the default location as initial error location

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 76104de8e503c125edf97e3d8ee543fb02f71bef..4c823409adea9827e67fb8d0dfd103ed803b4b7b 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -1,6 +1,6 @@
 # C++ skeleton for Bison
 
 # C++ skeleton for Bison
 

-# Copyright (C) 2002-2012 Free Software Foundation, Inc.
+# Copyright (C) 2002-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,19 +17,21 @@
 
 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)
 # --------------------------------------------------------------

-# 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_[[]] =


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


@@ -98,76 +101,74 @@ m4_define([b4_rhs_location],
 # Same as in C, but using references instead of pointers.
 m4_define([b4_symbol_action],
 [b4_symbol_if([$1], [has_$2],
 # Same as in C, but using references instead of pointers.
 m4_define([b4_symbol_action],
 [b4_symbol_if([$1], [has_$2],

-[m4_pushdef([b4_dollar_dollar],
-    [b4_symbol_value_template([yysym.value],
-                              b4_symbol_if([$1], [has_type],
-                                           [b4_symbol([$1], [type])]))])dnl
-m4_pushdef([b4_at_dollar], [yysym.location])dnl
+[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl
+b4_dollar_pushdef([yysym.value],
+                   b4_symbol_if([$1], [has_type],
+                                [m4_dquote(b4_symbol([$1], [type]))]),
+                   [yysym.location])dnl

       b4_symbol_case_([$1])
 b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
         b4_symbol([$1], [$2])
 b4_syncline([@oline@], [@ofile@])
         break;
 
       b4_symbol_case_([$1])
 b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
         b4_symbol([$1], [$2])
 b4_syncline([@oline@], [@ofile@])
         break;
 

-m4_popdef([b4_at_dollar])dnl
-m4_popdef([b4_dollar_dollar])dnl
+m4_popdef([b4_symbol_value])[]dnl
+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],
 m4_pushdef([b4_copyright_years],

-           [2002-2012])
+           [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]])])
 

-# The header is mandatory.
-b4_defines_if([],
-              [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
-
-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])])
 

-# We do want M4 expansion after # for CPP macros.
-m4_changecom()
-m4_divert_push(0)dnl
-@output(b4_spec_defines_file@)@
-b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
-[
-/**
- ** \file ]b4_spec_defines_file[
- ** Define the ]b4_namespace_ref[::parser class.
- */
-
-/* C++ LALR(1) parser skeleton written by Akim Demaille.  */
-
-]b4_cpp_guard_open([b4_spec_defines_file])[
-
-]b4_percent_code_get([[requires]])[
+# b4_shared_declarations
+# ----------------------
+# Declaration that might either go into the header (if --defines)
+# or open coded in the parser body.
+m4_define([b4_shared_declarations],
+[b4_percent_code_get([[requires]])[
+]b4_parse_assert_if([# include <cassert>])[
+# include <cstdlib> // std::abort
+# include <iostream>
+# include <stdexcept>
+# include <string>
+# include <vector>]b4_defines_if([[
+# include "stack.hh"
+]b4_bison_locations_if([[# include "location.hh"]])])[
+]b4_variant_if([b4_variant_includes])[
+
+]b4_attribute_define[
+]b4_YYDEBUG_define[

 
 

-]b4_parse_assert_if([#include <cassert>])[
-#include <stdexcept>
-#include <string>
-#include <iostream>
-#include "stack.hh"
-]b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
-                                          [[#include "location.hh"]])])[
-
-]b4_variant_if([b4_namespace_open
-b4_variant_define
-b4_namespace_close])[
-
-]b4_null_define[
+]b4_namespace_open[

 
 

-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG ]b4_parse_trace_if([1], [0])[
-#endif
+]b4_defines_if([],
+[b4_stack_define
+b4_bison_locations_if([b4_position_define
+b4_location_define])])[

 
 

-]b4_namespace_open[
+]b4_variant_if([b4_variant_define])[

 
   /// A Bison parser.
   class ]b4_parser_class_name[
 
   /// A Bison parser.
   class ]b4_parser_class_name[


@@ -182,41 +183,46 @@ b4_namespace_close])[
     /// \returns  0 iff parsing succeeded.
     virtual int parse ();
 
     /// \returns  0 iff parsing succeeded.
     virtual int parse ();
 

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

     /// The current debugging stream.
     /// 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
 

-    /// Report a syntax error.]b4_locations_if([
-    /// \param loc    where the syntax error is found.])[
+    /// Report a syntax error.]b4_locations_if([[
+    /// \param loc    where the syntax error is found.]])[

     /// \param msg    a description of the syntax error.
     /// \param msg    a description of the syntax error.

-    virtual void error (]b4_locations_if([const location_type& loc, ])[const std::string& msg);
+    virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg);

 
     /// Report a syntax error.
     void error (const syntax_error& err);
 
   private:
 
     /// Report a syntax error.
     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


@@ -226,23 +232,24 @@ b4_namespace_close])[
     /// \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_;
 
     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 token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t);
+

     // Tables.
 ]b4_parser_tables_declare[]b4_error_verbose_if([
 
     /// Convert the symbol name \a n to a form suitable for a diagnostic.
     static std::string yytnamerr_ (const char *n);])[
 
     // Tables.
 ]b4_parser_tables_declare[]b4_error_verbose_if([
 
     /// Convert the symbol name \a n to a form suitable for a diagnostic.
     static std::string yytnamerr_ (const char *n);])[
 

-]b4_token_table_if([], [[#if YYDEBUG]])[
+]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[

     /// For a symbol, its name in clear.
     static const char* const yytname_[];
     /// For a symbol, its name in clear.
     static const char* const yytname_[];

-]b4_token_table_if([[#if YYDEBUG]])[
+]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[

 ]b4_integral_parser_table_declare([rline], [b4_rline],
 ]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.


@@ -251,48 +258,66 @@ b4_namespace_close])[
     // Debugging.
     int yydebug_;
     std::ostream* yycdebug_;
     // Debugging.
     int yydebug_;
     std::ostream* yycdebug_;

-#endif // YYDEBUG
-
-    /// 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 YYDEBUG

     /// \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>
-    void yy_print_ (std::ostream& yyo,
-                    const symbol_base_type<Exact>& yysym) const;
+    template <typename Base>
+    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.
-    template <typename Exact>
-    inline void yy_destroy_ (const char* yymsg,
-                             symbol_base_type<Exact>& yysym) const;
+    /// \param yysym     The symbol.
+    template <typename Base>
+    void yy_destroy_ (const char* yymsg, 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 ();
+      by_state ();
+
+      /// The symbol type as needed by the constructor.
+      typedef state_type kind_type;

 
       /// Constructor.
 
       /// Constructor.

-      inline stack_symbol_type (]b4_args([state_type s],
-                                         [const semantic_type& v],
-                                         b4_locations_if([const location_type& l]))[);
+      by_state (kind_type s);
+
+      /// Copy constructor.
+      by_state (const by_state& other);
+
+      /// Record that this symbol is empty.
+      void clear ();
+
+      /// Steal the symbol type from \a that.
+      void move (by_state& that);
+
+      /// The (internal) type number (corresponding to \a state).
+      /// \a empty_symbol when empty.
+      symbol_number_type type_get () const;
+
+      /// The state number used to denote an empty symbol.
+      enum { empty_state = -1 };

 
       /// The state.
 
       /// The state.

+      /// \a empty when empty.

       state_type state;
       state_type state;

+    };

 
 

-      /// The type (corresponding to \a state).
-      inline int type_get_ () const;
+    /// "Internal" symbol: element of the stack.
+    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.
     };
 
     /// Stack type.


@@ -306,7 +331,7 @@ b4_namespace_close])[
     ///             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


@@ -314,42 +339,60 @@ b4_namespace_close])[
     /// \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 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[
   };
 

-]b4_lex_symbol_if([b4_yytranslate_define
+]b4_token_ctor_if([b4_yytranslate_define

 b4_public_types_define])[
 ]b4_namespace_close[
 
 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
 b4_public_types_define])[
 ]b4_namespace_close[
 
 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],

-[b4_token_defines(b4_tokens)
+[b4_token_defines

 
 #ifndef ]b4_api_PREFIX[STYPE
 
 #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]])[

+]])
+
+b4_defines_if(
+[b4_output_begin([b4_spec_defines_file])
+b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
+[
+/**
+ ** \file ]b4_spec_defines_file[
+ ** Define the ]b4_namespace_ref[::parser class.
+ */
+
+// 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_close([b4_spec_defines_file])

-@output(b4_parser_file_name@)@
+b4_output_end()
+])
+
+
+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], [],


@@ -357,19 +400,22 @@ m4_if(b4_prefix, [yy], [],
 // Take the name prefix into account.
 #define yylex   b4_prefix[]lex])[
 
 // Take the name prefix into account.
 #define yylex   b4_prefix[]lex])[
 

-/* First part of user declarations.  */
+// First part of user declarations.

 ]b4_user_pre_prologue[
 
 ]b4_user_pre_prologue[
 

-#include "@basename(]b4_spec_defines_file[@)"
+]b4_null_define[
+
+]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
+               [b4_shared_declarations])[

 
 

-/* User implementation prologue.  */
-]b4_user_post_prologue
-b4_percent_code_get[]dnl
+// User implementation prologue.
+]b4_user_post_prologue[
+]b4_percent_code_get[

 
 

-[#ifndef YY_
+#ifndef YY_

 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 # 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


@@ -379,33 +425,16 @@ b4_percent_code_get[]dnl
 #endif
 
 ]b4_locations_if([dnl
 #endif
 
 ]b4_locations_if([dnl

-[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-   If N is 0, then set CURRENT to the empty location which ends
-   the previous symbol: RHS[0] (always defined).  */
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)                               \
- do                                                                    \
-   if (N)                                                              \
-     {                                                                 \
-       (Current).begin = YYRHSLOC (Rhs, 1).begin;                      \
-       (Current).end   = YYRHSLOC (Rhs, N).end;                        \
-     }                                                                 \
-   else                                                                \
-     {                                                                 \
-       (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end;        \
-     }                                                                 \
- while (false)
-#endif]])[
-
-/* Suppress unused-variable warnings by "using" E.  */
-#define YYUSE(e) ((void) (e))
-
-/* Enable debugging if requested.  */
-#if YYDEBUG
-
-/* A pseudo ostream that takes yydebug_ into account.  */
+[#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
+]b4_yylloc_default_define])[
+
+// Suppress unused-variable warnings by "using" E.
+#define YYUSE(E) ((void) (E))
+
+// Enable debugging if requested.
+#if ]b4_api_PREFIX[DEBUG
+
+// 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)         \


@@ -430,17 +459,17 @@ b4_percent_code_get[]dnl
       yystack_print_ ();                \
   } while (false)
 
       yystack_print_ ();                \
   } while (false)
 

-#else /* !YYDEBUG */
+#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 /* !YYDEBUG */
+#endif // !]b4_api_PREFIX[DEBUG

 
 #define yyerrok         (yyerrstatus_ = 0)
 
 #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


@@ -472,7 +501,7 @@ b4_percent_code_get[]dnl
             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;


@@ -490,131 +519,150 @@ b4_percent_code_get[]dnl
   /// Build a parser object.
   ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
     :])[
   /// Build a parser object.
   ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
     :])[

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

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

-  {
-  }
+  {}

 
 
   /*---------------.
   | 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.
+  inline
+  ]b4_parser_class_name[::by_state::by_state ()
+    : state (empty_state)
+  {}
+
+  inline
+  ]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;

   }
 
   }
 

-  ]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)
+  inline
+  void
+  ]b4_parser_class_name[::by_state::move (by_state& that)

   {
   {

+    state = that.state;
+    that.clear ();

   }
 
   }
 

-  int
-  ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
+  inline
+  ]b4_parser_class_name[::by_state::by_state (state_type s)
+    : state (s)
+  {}
+
+  inline
+  ]b4_parser_class_name[::symbol_number_type
+  ]b4_parser_class_name[::by_state::type_get () const
+  {
+    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])[)

   {
   {

-    return yystos_[state];
+    ]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 Exact>
+
+  template <typename Base>
+  inline

   void
   void

-  ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
-                                       symbol_base_type<Exact>& 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 YYDEBUG
-  template <typename Exact>
+#if ]b4_api_PREFIX[DEBUG
+  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);

-    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(
-[[    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 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(
-[[    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])],
-[    yystack_.push (s);])[
+    yystack_.push (s);

   }
 
   }
 

+  inline

   void
   void

-  ]b4_parser_class_name[::yypop_ (unsigned int n)
+  ]b4_parser_class_name[::yypop_ (unsigned n)

   {
     yystack_.pop (n);
   }
 
   {
     yystack_.pop (n);
   }
 

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

   std::ostream&
   ]b4_parser_class_name[::debug_stream () const
   {
   std::ostream&
   ]b4_parser_class_name[::debug_stream () const
   {


@@ -639,16 +687,16 @@ b4_percent_code_get[]dnl
   {
     yydebug_ = l;
   }
   {
     yydebug_ = l;
   }

-#endif // YYDEBUG
+#endif // ]b4_api_PREFIX[DEBUG

 
   inline ]b4_parser_class_name[::state_type
 
   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


@@ -666,14 +714,12 @@ b4_percent_code_get[]dnl
   int
   ]b4_parser_class_name[::parse ()
   {
   int
   ]b4_parser_class_name[::parse ()
   {

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

     int yyn;
     int yyn;

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

     int yylen = 0;
 
     int yylen = 0;
 

-    /* Error handling.  */
+    // Error handling.

     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 


@@ -683,77 +729,71 @@ b4_percent_code_get[]dnl
     /// 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().
+    /// The return value of parse ().

     int yyresult;
 
     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], [
     YYCDEBUG << "Starting parse" << std::endl;
 
 ]m4_ifdef([b4_initial_action], [

-m4_pushdef([b4_at_dollar],     [yyla.location])dnl
-m4_pushdef([b4_dollar_dollar], [yyla.value])dnl
-    /* User initialization code.  */
+b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl
+    // User initialization code.

     b4_user_initial_action
     b4_user_initial_action

-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
+b4_dollar_popdef])[]dnl

 
   [  /* Initialize the stack.  The initial state will be set in
        yynewstate, since the latter expects the semantical and the
        location values to have been already stored, initialize these
        stacks with a primary value.  */
 
   [  /* Initialize the stack.  The initial state will be set in
        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:
     YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
 
 
     // A new symbol was pushed on the stack.
   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.  */
-    if (yyempty)
+    // Read a lookahead token.
+    if (yyla.empty ())

       {
         YYCDEBUG << "Reading a token: ";
         try
       {
         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;
-        }
-        yyempty = false;
+          {
+            error (yyexc);
+            goto yyerrlab1;
+          }

       }
     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;
 
       goto yydefault;
 

-    /* Reduce or error.  */
+    // Reduce or error.

     yyn = yytable_[yyn];
     if (yyn <= 0)
       {
     yyn = yytable_[yyn];
     if (yyn <= 0)
       {


@@ -763,15 +803,11 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
         goto yyreduce;
       }
 
         goto yyreduce;
       }
 

-    /* Discard the token being shifted.  */
-    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;
 


@@ -789,80 +825,68 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
   `-----------------------------*/
   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)
+      // Default location.

       {
       {

+        slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
+        YYLLOC_DEFAULT (yylhs.location, slice, yylen);
+        yyerror_range[1].location = yylhs.location;
+      }]])[
+
+      // Perform the reduction.
+      YY_REDUCE_PRINT (yyn);
+      try
+        {
+          switch (yyn)
+            {

 ]b4_user_actions[
 ]b4_user_actions[

-        default:
-          break;
-      }
-    }
-    catch (const syntax_error& yyexc)
-    {
-      error (yyexc);
-      YYERROR;
-    }
-    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
-      // yylhs.value (for instance if the action was "std::swap($$,
-      // $1)").  The value of yylhs.value (hence possibly one of these
-      // rhs symbols) depends on the default construction for this
-      // type.  In the case of pointers for instance, no
-      // initialization is done, so the value is junk.  Therefore do
-      // not try to report the value of symbols about to be destroyed
-      // in the debug trace, it's possibly junk.  Hence yymsg = 0.
-      // Besides, that keeps exactly the same traces as with the other
-      // Bison skeletons.
-      yy_destroy_ (YY_NULL, yystack_[i]);]])[
-
-    yypop_ (yylen);
-    yylen = 0;
-    YY_STACK_PRINT ();
+            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;
 
   /*--------------------------------------.
   | yyerrlab -- here on detecting error.  |
   `--------------------------------------*/
   yyerrlab:
     goto yynewstate;
 
   /*--------------------------------------.
   | 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]),
-                        [[yysyntax_error_ (yystack_[0].state,
-                                           yyempty ? yyempty_ : yyla.type)]])[);
+        error (]b4_join(b4_locations_if([yyla.location]),
+                        [[yysyntax_error_ (yystack_[0].state, yyla)]])[);

       }
 
 ]b4_locations_if([[
       }
 
 ]b4_locations_if([[


@@ -872,18 +896,17 @@ 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.  */
-        if (yyla.type == yyeof_)
+        // Return failure if at end of input.
+        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 ();

           }
       }
 
           }
       }
 

-    /* 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;
 
 


@@ -896,11 +919,8 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
        YYERROR and the label yyerrorlab therefore never appears in user
        code.  */
     if (false)
        YYERROR and the label yyerrorlab therefore never appears in user
        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);]])[
-    /* Do not reclaim the symbols of the rule which action triggered
+      goto yyerrorlab;
+    /* Do not reclaim the symbols of the rule whose action triggered

        this YYERROR.  */
     yypop_ (yylen);
     yylen = 0;
        this YYERROR.  */
     yypop_ (yylen);
     yylen = 0;


@@ -910,7 +930,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 (;;)


@@ -940,30 +960,30 @@ 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;
 
   yyreturn:
   yyabortlab:
     yyresult = 1;
     goto yyreturn;
 
   yyreturn:

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

       yy_destroy_ ("Cleanup: discarding lookahead", yyla);
 
       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_ ();


@@ -971,21 +991,37 @@ 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 (!yyla.empty ())
+          yy_destroy_ (YY_NULLPTR, yyla);
+
+        while (1 < yystack_.size ())
+          {
+            yy_destroy_ (YY_NULLPTR, 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()]])[);
   }
 
   // Generate an error message.
   std::string
   ]b4_parser_class_name[::yysyntax_error_ (]dnl
                     [[yyexc.what()]])[);
   }
 
   // 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;


@@ -999,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


@@ -1019,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))


@@ -1029,7 +1066,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)


@@ -1047,22 +1084,23 @@ 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)                         \
         case N:                               \
           yyformat = S;                       \
         break
     switch (yycount)
       {
 #define YYCASE_(N, S)                         \
         case N:                               \
           yyformat = S;                       \
         break

-        YYCASE_(0, YY_("syntax error"));
-        YYCASE_(1, YY_("syntax error, unexpected %s"));
-        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
-        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
-        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
-        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+        YYCASE_ (0, YY_("syntax error"));
+        YYCASE_ (1, YY_("syntax error, unexpected %s"));
+        YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
+        YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+        YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+        YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));

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


@@ -1084,16 +1122,16 @@ b4_error_verbose_if([state_type yystate, int yytoken],
 
 ]b4_parser_tables_define[
 
 
 ]b4_parser_tables_define[
 

-]b4_token_table_if([], [[#if YYDEBUG]])[
-  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
+]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.

   const char*
   const ]b4_parser_class_name[::yytname_[] =
   {
   ]b4_tname[
   };
 
   const char*
   const ]b4_parser_class_name[::yytname_[] =
   {
   ]b4_tname[
   };
 

-]b4_token_table_if([[#if YYDEBUG]])[
+]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[

 ]b4_integral_parser_table_define([rline], [b4_rline])[
 
   // Print the state stack on the debug stream.
 ]b4_integral_parser_table_define([rline], [b4_rline])[
 
   // Print the state stack on the debug stream.


@@ -1113,20 +1151,22 @@ b4_error_verbose_if([state_type yystate, int yytoken],
   void
   ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
   {
   void
   ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
   {

-    unsigned int yylno = yyrline_[yyrule];
+    unsigned yylno = yyrline_[yyrule];

     int yynrhs = yyr2_[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)[);
   }
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
                        ]b4_rhs_data(yynrhs, yyi + 1)[);
   }

-#endif // YYDEBUG
+#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