From: Akim Demaille <akim@lrde.epita.fr>
Date: Wed, 4 Jul 2012 15:14:35 +0000 (+0200)
Subject: Merge remote-tracking branch 'origin/maint'
X-Git-Tag: v2.7.90~404
X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/ccdc1577ef7fb32a5e30cb655337e7cd42b98987?hp=-c

Merge remote-tracking branch 'origin/maint'

* origin/maint:
  tests: headers.at: strengthen.
  glr.cc: do not override C++ definitions by C macros.
  YYLLOC_DEFAULT: factor, and don't export it in headers.
  api.prefix: do not use #define to handle YYSTYPE_IS_TRIVIAL etc.
  tests: portability fixes.
  c++: fewer #includes in the headers.
  glr.cc: formatting changes.
  tests: more logs.
  api.prefix: also rename YYDEBUG.

Conflicts:
	data/c.m4
	data/glr.c
	data/glr.cc
	data/lalr1.cc
	data/yacc.c
---

ccdc1577ef7fb32a5e30cb655337e7cd42b98987
diff --combined NEWS
index 541404b4,ec4e33a5..eddfa8ee
--- a/NEWS
+++ b/NEWS
@@@ -2,125 -2,6 +2,125 @@@ GNU Bison NEW
  
  * Noteworthy changes in release ?.? (????-??-??) [?]
  
 +** Warnings
 +
 +*** Warning categories are now displayed in warnings
 +
 +  For instance:
 +
 +  foo.y:4.6: warning: type clash on default action: <foo> != <bar> [-Wother]
 +
 +*** Useless semantic types
 +
 +  Bison now warns about useless (uninhabited) semantic types.  Since
 +  semantic types are not declared to Bison (they are defined in the opaque
 +  %union structure), it is %printer/%destructor directives about useless
 +  types that trigger the warning:
 +
 +    %token <type1> term
 +    %type  <type2> nterm
 +    %printer    {} <type1> <type3>
 +    %destructor {} <type2> <type4>
 +    %%
 +    nterm: term { $$ = $1; };
 +
 +    3.28-34: warning: type <type3> is used, but is not associated to any symbol
 +    4.28-34: warning: type <type4> is used, but is not associated to any symbol
 +
 +*** Undeclared symbols
 +
 +  Bison used to raise an error for %printer and %destructor directives for
 +  undefined symbols.
 +
 +    %printer    {} symbol1
 +    %destructor {} symbol2
 +    %%
 +    exp: "a";
 +
 +  This is now only a warning.
 +
 +*** Useless destructors or printers
 +
 +  Bison now warns about useless destructors or printers.  In the following
 +  example, the printer for <type1>, and the destructor for <type2> are
 +  useless: all symbols of <type1> (token1) already have a printer, and all
 +  symbols of type <type2> (token2) already have a destructor.
 +
 +    %token <type1> token1
 +           <type2> token2
 +           <type3> token3
 +           <type4> token4
 +    %printer    {} token1 <type1> <type3>
 +    %destructor {} token2 <type2> <type4>
 +
 +** Additional yylex/yyparse arguments
 +
 +  The new directive %param declares additional arguments to both yylex and
 +  yyparse.  The %lex-param, %parse-param, and %param directives support one
 +  or more arguments.  Instead of
 +
 +    %lex-param   {arg1_type *arg1}
 +    %lex-param   {arg2_type *arg2}
 +    %parse-param {arg1_type *arg1}
 +    %parse-param {arg2_type *arg2}
 +
 +  one may now declare
 +
 +    %param {arg1_type *arg1} {arg2_type *arg2}
 +
 +** Java skeleton improvements
 +
 +  The constants for token names were moved to the Lexer interface.
 +  Also, it is possible to add code to the parser's constructors using
 +  "%code init" and "%define init_throws".
 +
 +** C++ skeleton improvements
 +
 +  The C++ parser features a syntax_error exception, which can be
 +  thrown from the scanner or from user rules to raise syntax errors.
 +  This facilitates reporting errors caught in sub-functions (e.g.,
 +  rejecting too large integral literals from a conversion function
 +  used by the scanner, or rejecting invalid combinations from a
 +  factory invoked by the user actions).
 +
 +** Variable api.tokens.prefix
 +
 +  The variable api.tokens.prefix changes the way tokens are identified in
 +  the generated files.  This is especially useful to avoid collisions
 +  with identifiers in the target language.  For instance
 +
 +    %token FILE for ERROR
 +    %define api.tokens.prefix "TOK_"
 +    %%
 +    start: FILE for ERROR;
 +
 +  will generate the definition of the symbols TOK_FILE, TOK_for, and
 +  TOK_ERROR in the generated sources.  In particular, the scanner must
 +  use these prefixed token names, although the grammar itself still
 +  uses the short names (as in the sample rule given above).
 +
 +** Variable api.namespace
 +
 +  The "namespace" variable is renamed "api.namespace".  Backward
 +  compatibility is ensured, but upgrading is recommended.
 +
 +** Variable parse.error
 +
 +  The variable error controls the verbosity of error messages.  The
 +  use of the %error-verbose directive is deprecated in favor of
 +  %define parse.error "verbose".
 +
 +** Semantic predicates
 +
 +  The new, experimental, semantic-predicate feature allows actions of
 +  the form %?{ BOOLEAN-EXPRESSION }, which cause syntax errors (as for
 +  YYERROR) if the expression evaluates to 0, and are evaluated immediately
 +  in GLR parsers, rather than being deferred.  The result is that they
 +  allow the programmer to prune possible parses based on the values of
 +  run-time expressions.
 +
 +* Noteworthy changes in release ?.? (????-??-??) [?]
 +
  ** Future changes
  
    The next major release of Bison will drop support for the following
@@@ -213,10 -94,19 +213,19 @@@
      # define BAR_FOO_H                  # define BAR_FOO_H
  
      /* Enabling traces.  */             /* Enabling traces.  */
-     # ifndef YYDEBUG                    # ifndef YYDEBUG
-     #  define YYDEBUG 0                 #  define YYDEBUG 0
-     # endif                             # endif
-     # if YYDEBUG                        # if YYDEBUG
+     # ifndef YYDEBUG                  | # ifndef BAR_DEBUG
+                                       > #  if defined YYDEBUG
+                                       > #   if YYDEBUG
+                                       > #    define BAR_DEBUG 1
+                                       > #   else
+                                       > #    define BAR_DEBUG 0
+                                       > #   endif
+                                       > #  else
+     #  define YYDEBUG 0               | #   define BAR_DEBUG 0
+                                       > #  endif
+     # endif                           | # endif
+ 
+     # if YYDEBUG                      | # if BAR_DEBUG
      extern int bar_debug;               extern int bar_debug;
      # endif                             # endif
  
@@@ -1913,8 -1803,7 +1922,8 @@@ along with this program.  If not, see <
   LocalWords:  namespaces strerror const autoconfiguration Dconst Autoconf's FDL
   LocalWords:  Automake TMPDIR LESSEQ ylwrap endif yydebug YYTOKEN YYLSP ival hh
   LocalWords:  extern YYTOKENTYPE TOKENTYPE yytokentype tokentype STYPE lval pdf
 - LocalWords:  lang yyoutput dvi html ps POSIX lvalp llocp
 + LocalWords:  lang yyoutput dvi html ps POSIX lvalp llocp Wother nterm arg init
 + LocalWords:  TOK
  
  Local Variables:
  mode: outline
diff --combined data/c++.m4
index 4bc6c4c7,45c4ddaf..a64777c3
--- a/data/c++.m4
+++ b/data/c++.m4
@@@ -23,6 -23,7 +23,6 @@@ m4_include(b4_pkgdatadir/[c.m4]
  ## Default values.  ##
  ## ---------------- ##
  
 -# Default parser class name.
  b4_percent_define_default([[parser_class_name]], [[parser]])
  
  # Don't do that so that we remember whether we're using a user
@@@ -31,21 -32,18 +31,21 @@@
  # b4_percent_define_default([[location_type]], [[location]])
  
  b4_percent_define_default([[filename_type]], [[std::string]])
 -b4_percent_define_default([[namespace]], m4_defn([b4_prefix]))
 +b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
 +
  b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
  b4_percent_define_default([[define_location_comparison]],
                            [m4_if(b4_percent_define_get([[filename_type]]),
                                   [std::string], [[true]], [[false]])])
  
  
 +
  ## ----------- ##
  ## Namespace.  ##
  ## ----------- ##
  
 -m4_define([b4_namespace_ref], [b4_percent_define_get([[namespace]])])
 +m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])])
 +
  
  # Don't permit an empty b4_namespace_ref.  Any `::parser::foo' appended to it
  # would compile as an absolute reference with `parser' in the global namespace.
@@@ -55,7 -53,7 +55,7 @@@
  # include the header, which is always generated.  If we ever need to permit
  # internal linkage somehow, surely we can find a cleaner approach.
  m4_if(m4_bregexp(b4_namespace_ref, [^[	 ]*$]), [-1], [],
 -[b4_complain_at(b4_percent_define_get_loc([[namespace]]),
 +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
                  [[namespace reference is empty]])])
  
  # Instead of assuming the C++ compiler will do it, Bison should reject any
@@@ -66,20 -64,20 +66,20 @@@
  # Specifically, don't allow empty names as b4_namespace_open would just convert
  # those into anonymous namespaces, and that might tempt some users.
  m4_if(m4_bregexp(b4_namespace_ref, [::[	 ]*::]), [-1], [],
 -[b4_complain_at(b4_percent_define_get_loc([[namespace]]),
 +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
                  [[namespace reference has consecutive "::"]])])
  m4_if(m4_bregexp(b4_namespace_ref, [::[	 ]*$]), [-1], [],
 -[b4_complain_at(b4_percent_define_get_loc([[namespace]]),
 +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
                  [[namespace reference has a trailing "::"]])])
  
  m4_define([b4_namespace_open],
 -[b4_user_code([b4_percent_define_get_syncline([[namespace]])
 +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
  [namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref),
                                                  [^\(.\)[	 ]*::], [\1])),
                           [::], [ { namespace ])[ {]])])
  
  m4_define([b4_namespace_close],
 -[b4_user_code([b4_percent_define_get_syncline([[namespace]])
 +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
  m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]),
                                      [^\(.\)[	 ]*\(::\)?\([^][:]\|:[^:]\)*],
                                      [\1])),
@@@ -105,263 -103,12 +105,263 @@@ m4_map_sep([     b4_token_enum], [
  ## Semantic Values.  ##
  ## ----------------- ##
  
 +# b4_semantic_type_declare
 +# ------------------------
 +# Declare semantic_type.
 +m4_define([b4_semantic_type_declare],
 +[    /// Symbol semantic values.
 +m4_ifdef([b4_stype],
 +[    union semantic_type
 +    {b4_user_stype
 +    };],
 +[m4_if(b4_tag_seen_flag, 0,
 +[[    typedef int semantic_type;]],
 +[[    typedef ]b4_api_PREFIX[STYPE semantic_type;]])])])
 +
 +
 +# b4_public_types_declare
 +# -----------------------
 +# Define the public types: token, semantic value, location, and so forth.
 +# Depending on %define token_lex, may be output in the header or source file.
 +m4_define([b4_public_types_declare],
 +[[#ifndef ]b4_api_PREFIX[STYPE
 +]b4_semantic_type_declare[
 +#else
 +    typedef ]b4_api_PREFIX[STYPE semantic_type;
 +#endif]b4_locations_if([
 +    /// Symbol locations.
 +    typedef b4_percent_define_get([[location_type]],
 +                                  [[location]]) location_type;])[
 +
 +    /// Syntax errors thrown from user actions.
 +    struct syntax_error : std::runtime_error
 +    {
 +      syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([
 +      location_type location;])[
 +    };
 +
 +    /// Tokens.
 +    struct token
 +    {
 +      ]b4_token_enums(b4_tokens)[
 +    };
 +
 +    /// Token type.
 +    typedef token::yytokentype token_type;
 +
 +    /// A complete symbol, with its type.
 +    template <typename Exact>
 +    struct symbol_base_type
 +    {
 +      /// Default constructor.
 +      inline symbol_base_type ();
 +
 +      /// Constructor.]b4_locations_if([
 +      inline symbol_base_type (const location_type& l)])[;
 +      inline symbol_base_type (]b4_args(
 +        [const semantic_type& v],
 +        b4_locations_if([const location_type& l]))[);
 +
 +      /// Return this with its exact type.
 +      const Exact& self () const;
 +      Exact& self ();
 +
 +      /// Return the type of this symbol.
 +      int type_get () const;
 +
 +      /// The semantic value.
 +      semantic_type value;]b4_locations_if([
 +
 +      /// The location.
 +      location_type location;])[
 +    };
 +
 +    /// External form of a symbol: its type and attributes.
 +    struct symbol_type : symbol_base_type<symbol_type>
 +    {
 +      /// The parent class.
 +      typedef symbol_base_type<symbol_type> super_type;
 +
 +      /// Default constructor.
 +      inline symbol_type ();
 +
 +      /// Constructor for tokens with semantic value.
 +      inline symbol_type (]b4_args([token_type t],
 +                                   [const semantic_type& v],
 +                                   b4_locations_if([const location_type& l]))[);
 +
 +      /// Constructor for valueless tokens.
 +      inline symbol_type (]b4_args([token_type t],
 +                                   b4_locations_if([const location_type& l]))[);
 +
 +      /// The symbol type.
 +      int type;
 +
 +      /// The symbol type.
 +      inline int type_get_ () const;
 +
 +      /// The token.
 +      inline token_type token () const;
 +    };
 +]b4_symbol_constructor_declare])
 +
 +
 +# b4_public_types_define
 +# ----------------------
 +# Provide the implementation needed by the public types.
 +m4_define([b4_public_types_define],
 +[[  inline
 +  ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
 +    : std::runtime_error (m)]b4_locations_if([
 +    , location (l)])[
 +  {}
 +
 +  // symbol_base_type.
 +  template <typename Exact>
 +  inline
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
 +    : value()]b4_locations_if([
 +    , location()])[
 +  {
 +  }]b4_locations_if([[
 +
 +  template <typename Exact>
 +  inline
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const location_type& l)
 +    : value()
 +    , location(l)
 +  {
 +  }]])[
 +
 +  template <typename Exact>
 +  inline
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (]b4_args(
 +          [const semantic_type& v],
 +          b4_locations_if([const location_type& l]))[)
 +    : value(v)]b4_locations_if([
 +    , location(l)])[
 +  {
 +  }
 +
 +  template <typename Exact>
 +  inline
 +  const Exact&
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::self () const
 +  {
 +    return static_cast<const Exact&>(*this);
 +  }
 +
 +  template <typename Exact>
 +  inline
 +  Exact&
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
 +  {
 +    return static_cast<Exact&>(*this);
 +  }
 +
 +  template <typename Exact>
 +  inline
 +  int
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
 +  {
 +    return self ().type_get_ ();
 +  }
 +
 +  // symbol_type.
 +  inline
 +  ]b4_parser_class_name[::symbol_type::symbol_type ()
 +    : super_type ()
 +    , type ()
 +  {
 +  }
 +
 +  inline
 +  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
 +                [token_type t],
 +                b4_locations_if([const location_type& l]))[)
 +    : super_type (]b4_locations_if([l])[)
 +    , type (yytranslate_ (t))
 +  {
 +  }
 +
 +  inline
 +  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
 +                 [token_type t],
 +                 [const semantic_type& v],
 +                 b4_locations_if([const location_type& l]))[)
 +    : super_type (v]b4_locations_if([, l])[)
 +    , type (yytranslate_ (t))
 +  {
 +  }
 +
 +  inline
 +  int
 +  ]b4_parser_class_name[::symbol_type::type_get_ () const
 +  {
 +    return type;
 +  }
 +]b4_lex_symbol_if([[
 +  inline
 +  ]b4_parser_class_name[::token_type
 +  ]b4_parser_class_name[::symbol_type::token () const
 +  {
 +    // YYTOKNUM[NUM] -- (External) token number corresponding to the
 +    // (internal) symbol number NUM (which must be that of a token).  */
 +    static
 +    const ]b4_int_type_for([b4_toknum])[
 +    yytoken_number_[] =
 +    {
 +  ]b4_toknum[
 +    };
 +    return static_cast<token_type> (yytoken_number_[type]);
 +  }
 +]])[]dnl
 +b4_symbol_constructor_define])
 +
 +
 +# b4_symbol_constructor_declare
 +# b4_symbol_constructor_define
 +# -----------------------------
 +# Declare/define symbol constructors for all the value types.
 +# Use at class-level.  Redefined in variant.hh.
 +m4_define([b4_symbol_constructor_declare], [])
 +m4_define([b4_symbol_constructor_define], [])
 +
 +
 +# b4_yytranslate_define
 +# ---------------------
 +# Define yytranslate_.  Sometimes used in the header file,
 +# sometimes in the cc file.
 +m4_define([b4_yytranslate_define],
 +[[  // Symbol number corresponding to token number t.
 +  ]b4_parser_class_name[::token_number_type
 +  ]b4_parser_class_name[::yytranslate_ (]b4_lex_symbol_if([token_type],
 +                                                          [int])[ t)
 +  {
 +    static
 +    const token_number_type
 +    translate_table[] =
 +    {
 +]b4_translate[
 +    };
 +    const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
 +    const token_number_type undef_token_ = ]b4_undef_token_number[;
 +
 +    if (static_cast<int>(t) <= yyeof_)
 +      return yyeof_;
 +    else if (static_cast<unsigned int> (t) <= user_token_number_max_)
 +      return translate_table[t];
 +    else
 +      return undef_token_;
 +  }
 +]])
 +
  
  # b4_lhs_value([TYPE])
  # --------------------
  # Expansion of $<TYPE>$.
  m4_define([b4_lhs_value],
 -[(yyval[]m4_ifval([$1], [.$1]))])
 +[b4_symbol_value([yyval], [$1])])
  
  
  # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
@@@ -369,8 -116,7 +369,8 @@@
  # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  # symbols on RHS.
  m4_define([b4_rhs_value],
 -[(yysemantic_stack_@{($1) - ($2)@}m4_ifval([$3], [.$3]))])
 +[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])])
 +
  
  # b4_lhs_location()
  # -----------------
@@@ -407,24 -153,53 +407,53 @@@ m4_define([b4_parse_param_decl_1]
  # Extra initialisations of the constructor.
  m4_define([b4_parse_param_cons],
            [m4_ifset([b4_parse_param],
 -		    [
 +                    [
        b4_cc_constructor_calls(b4_parse_param)])])
  m4_define([b4_cc_constructor_calls],
 -	  [m4_map_sep([b4_cc_constructor_call], [,
 +          [m4_map_sep([b4_cc_constructor_call], [,
        ], [$@])])
  m4_define([b4_cc_constructor_call],
 -	  [$2 ($2_yyarg)])
 +          [$2 ($2_yyarg)])
  
  # b4_parse_param_vars
  # -------------------
  # Extra instance variables.
  m4_define([b4_parse_param_vars],
            [m4_ifset([b4_parse_param],
 -		    [
 +                    [
      /* User arguments.  */
  b4_cc_var_decls(b4_parse_param)])])
  m4_define([b4_cc_var_decls],
 -	  [m4_map_sep([b4_cc_var_decl], [
 +          [m4_map_sep([b4_cc_var_decl], [
  ], [$@])])
  m4_define([b4_cc_var_decl],
 -	  [    $1;])
 +          [    $1;])
+ 
+ 
+ ## ---------##
+ ## Values.  ##
+ ## ---------##
+ 
+ # b4_yylloc_default_define
+ # ------------------------
+ # Define YYLLOC_DEFAULT.
+ m4_define([b4_yylloc_default_define],
+ [[/* 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).  */
+ 
+ # 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 (/*CONSTCOND*/ false)
+ # endif
+ ]])
diff --combined data/c.m4
index 831274cb,08296c65..adf5d4f1
--- a/data/c.m4
+++ b/data/c.m4
@@@ -48,34 -48,11 +48,34 @@@ m4_define([b4_cpp_guard_close]
  ## Identification.  ##
  ## ---------------- ##
  
 -# b4_comment(TEXT)
 -# ----------------
 -m4_define([b4_comment], [/* m4_bpatsubst([$1], [
 -], [
 -   ])  */])
 +# b4_comment_(TEXT, OPEN, CONTINUE, END)
 +# -------------------------------------
 +# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
 +# Avoid adding indentation to the first line, as the indentation comes
 +# from OPEN.  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
 +#
 +# Prefix all the output lines with PREFIX.
 +m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [
 +\(.\)], [
 +$3\1])$4])
 +
 +
 +# b4_c_comment(TEXT, [PREFIX])
 +# ----------------------------
 +# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
 +# Avoid adding indentation to the first line, as the indentation comes
 +# from "/*".  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
 +#
 +# Prefix all the output lines with PREFIX.
 +m4_define([b4_c_comment],
 +[b4_comment_([$1], [$2/* ], [$2   ], [$2  */])])
 +
 +
 +# b4_comment(TEXT, [PREFIX])
 +# --------------------------
 +# By default, C comments.
 +m4_define([b4_comment], [b4_c_comment($@)])
 +
  
  # b4_identification
  # -----------------
@@@ -157,13 -134,11 +157,13 @@@ m4_popdef([$2])dn
  m4_popdef([$1])dnl
  ])])
  
 -# b4_parse_param_use
 -# ------------------
 -# `YYUSE' all the parse-params.
 +# b4_parse_param_use([VAL], [LOC])
 +# --------------------------------
 +# `YYUSE' VAL, LOC if locations are enabled, and all the parse-params.
  m4_define([b4_parse_param_use],
 -[b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
 +[m4_ifvaln([$1], [  YYUSE([$1]);])dnl
 +b4_locations_if([m4_ifvaln([$2], [  YYUSE ([$2]);])])dnl
 +b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
  ])dnl
  ])
  
@@@ -185,7 -160,7 +185,7 @@@ m4_define([b4_int_type]
  
         m4_eval([0 <= $1]),                [1], [unsigned int],
  
 -					       [int])])
 +                                               [int])])
  
  
  # b4_int_type_for(NAME)
@@@ -234,16 -209,6 +234,16 @@@ m4_define([b4_null_define]
  # Return a null pointer constant.
  m4_define([b4_null], [YY_NULL])
  
 +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
 +# -------------------------------------------------------------
 +# Define "yy<TABLE-NAME>" which contents is CONTENT.
 +m4_define([b4_integral_parser_table_define],
 +[m4_ifvaln([$3], [b4_c_comment([$3], [  ])])dnl
 +static const b4_int_type_for([$2]) yy$1[[]] =
 +{
 +  $2
 +};dnl
 +])
  
  
  ## ------------------------- ##
@@@ -254,7 -219,7 +254,7 @@@
  # -----------------------------------------
  # Output the definition of this token as #define.
  m4_define([b4_token_define],
 -[#define $1 $2
 +[#define b4_percent_define_get([api.tokens.prefix])$1 $2
  ])
  
  
@@@ -272,7 -237,7 +272,7 @@@ m4_map([b4_token_define], [$@])]
  # ---------------------------------------
  # Output the definition of this token as an enum.
  m4_define([b4_token_enum],
 -[$1 = $2])
 +[b4_percent_define_get([api.tokens.prefix])$1 = $2])
  
  
  # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
@@@ -288,8 -253,8 +288,8 @@@ m4_define([b4_token_enums]
     enum ]b4_api_prefix[tokentype {
  ]m4_map_sep([     b4_token_enum], [,
  ],
 -	   [$@])[
 -   };
 +           [$@])
 +   };[
  #endif
  ]])])
  
@@@ -303,21 -268,6 +303,21 @@@ m4_define([b4_token_enums_defines]
  ])
  
  
 +## ----------------- ##
 +## Semantic Values.  ##
 +## ----------------- ##
 +
 +
 +# b4_symbol_value(VAL, [TYPE])
 +# ----------------------------
 +# Given a semantic value VAL ($$, $1 etc.), extract its value of type
 +# TYPE if TYPE is given, otherwise just return VAL.  The result can be
 +# used safetly, it is put in parens to avoid nasty precedence issues.
 +# TYPE is *not* put in braces, provide some if needed.
 +m4_define([b4_symbol_value],
 +[($1[]m4_ifval([$2], [.$2]))])
 +
 +
  
  ## --------------------------------------------- ##
  ## Defining C functions in both K&R and ANSI-C.  ##
@@@ -367,7 -317,7 +367,7 @@@ $1 (b4_c_ansi_formals(m4_shift2($@)))[]
  m4_define([b4_c_ansi_formals],
  [m4_if([$#], [0], [void],
         [$#$1], [1], [void],
 -	       [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
 +               [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
  
  m4_define([b4_c_ansi_formal],
  [$1])
@@@ -388,9 -338,9 +388,9 @@@ m4_define([b4_c_knr_formal_name]
  # Output the K&R argument declarations.
  m4_define([b4_c_knr_formal_decls],
  [m4_map_sep([b4_c_knr_formal_decl],
 -	    [
 +            [
  ],
 -	    [$@])])
 +            [$@])])
  
  m4_define([b4_c_knr_formal_decl],
  [    $1;])
@@@ -406,7 -356,7 +406,7 @@@
  # -----------------------------------------------------------
  # Declare the function NAME.
  m4_define([b4_c_function_decl],
 -[#if defined __STDC__ || defined __cplusplus
 +[#if b4_c_modern
  b4_c_ansi_function_decl($@)
  #else
  $2 $1 ();
@@@ -465,17 -415,24 +465,17 @@@ m4_define([b4_sync_start], [[#]line $1 
  m4_define([b4_case],
  [  case $1:
  $2
 +b4_syncline([@oline@], [@ofile@])
      break;])
  
 -# b4_symbol_actions(FILENAME, LINENO,
 -#                   SYMBOL-TAG, SYMBOL-NUM,
 -#                   SYMBOL-ACTION, SYMBOL-TYPENAME)
 -# -------------------------------------------------
 -m4_define([b4_symbol_actions],
 -[m4_pushdef([b4_dollar_dollar],
 -   [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl
 -m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
 -      case $4: /* $3 */
 -b4_syncline([$2], [$1])
 -	$5;
 +
 +# b4_predicate_case(LABEL, CONDITIONS)
 +# ------------------------------------
 +m4_define([b4_predicate_case],
 +[  case $1:
 +    if (! ($2)) YYERROR;
  b4_syncline([@oline@], [@ofile@])
 -	break;
 -m4_popdef([b4_at_dollar])dnl
 -m4_popdef([b4_dollar_dollar])dnl
 -])
 +    break;])
  
  
  # b4_yydestruct_generate(FUNCTION-DECLARATOR)
@@@ -497,16 -454,20 +497,16 @@@ m4_define_default([b4_yydestruct_genera
  b4_locations_if(            [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
  m4_ifset([b4_parse_param], [, b4_parse_param]))[
  {
 -  YYUSE (yyvaluep);
 -]b4_locations_if([  YYUSE (yylocationp);
 -])dnl
 -b4_parse_param_use[]dnl
 -[
 -  if (!yymsg)
 +]b4_parse_param_use([yyvaluep], [yylocationp])dnl
 +[  if (!yymsg)
      yymsg = "Deleting";
    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
  
    switch (yytype)
      {
 -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 -      default:
 -	break;
 +]b4_symbol_foreach([b4_symbol_destructor])dnl
 +[      default:
 +        break;
      }
  }]dnl
  ])
@@@ -526,28 -487,30 +526,28 @@@ m4_define_default([b4_yy_symbol_print_g
  /*ARGSUSED*/
  ]$1([yy_symbol_value_print],
      [static void],
 -	       [[FILE *yyoutput],                       [yyoutput]],
 -	       [[int yytype],                           [yytype]],
 -	       [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 +               [[FILE *yyoutput],                       [yyoutput]],
 +               [[int yytype],                           [yytype]],
 +               [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
  b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
  m4_ifset([b4_parse_param], [, b4_parse_param]))[
  {
    FILE *yyo = yyoutput;
 -  YYUSE (yyo);
 -  if (!yyvaluep)
 -    return;
 -]b4_locations_if([  YYUSE (yylocationp);
 -])dnl
 -b4_parse_param_use[]dnl
 -[# ifdef YYPRINT
 +]b4_parse_param_use([yyo], [yylocationp])dnl
 +[  if (!yyvaluep)
 +    return;]
 +dnl glr.c does not feature yytoknum.
 +m4_if(b4_skeleton, ["yacc.c"],
 +[[# ifdef YYPRINT
    if (yytype < YYNTOKENS)
      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 -# else
 -  YYUSE (yyoutput);
  # endif
 -  switch (yytype)
 +]])dnl
 +[  switch (yytype)
      {
 -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 +]b4_symbol_foreach([b4_symbol_printer])dnl
  [      default:
 -	break;
 +        break;
      }
  }
  
@@@ -558,9 -521,9 +558,9 @@@
  
  ]$1([yy_symbol_print],
      [static void],
 -	       [[FILE *yyoutput],                       [yyoutput]],
 -	       [[int yytype],                           [yytype]],
 -	       [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 +               [[FILE *yyoutput],                       [yyoutput]],
 +               [[int yytype],                           [yytype]],
 +               [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
  b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
  m4_ifset([b4_parse_param], [, b4_parse_param]))[
  {
@@@ -618,14 -581,61 +618,61 @@@ b4_pure_if([], [[extern ]b4_api_PREFIX[
  ]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl
  ])
  
- # b4_declare_yydebug
+ # b4_YYDEBUG_define
  # ------------------
- m4_define([b4_declare_yydebug],
+ m4_define([b4_YYDEBUG_define],
  [[/* Enabling traces.  */
- #ifndef YYDEBUG
+ ]m4_if(b4_api_prefix, [yy],
+ [[#ifndef YYDEBUG
 -# define YYDEBUG ]b4_debug_flag[
 +# define YYDEBUG ]b4_parse_trace_if([1], [0])[
- #endif
+ #endif]],
+ [[#ifndef ]b4_api_PREFIX[DEBUG
+ # if defined YYDEBUG
 -#  if YYDEBUG
 +#if YYDEBUG
+ #   define ]b4_api_PREFIX[DEBUG 1
+ #  else
+ #   define ]b4_api_PREFIX[DEBUG 0
+ #  endif
+ # else /* ! defined YYDEBUG */
 -#  define ]b4_api_PREFIX[DEBUG ]b4_debug_flag[
++#  define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[
+ # endif /* ! defined ]b4_api_PREFIX[DEBUG */
+ #endif  /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl
+ ])
+ 
+ # b4_declare_yydebug
+ # ------------------
+ m4_define([b4_declare_yydebug],
+ [b4_YYDEBUG_define[
+ #if ]b4_api_PREFIX[DEBUG
  extern int ]b4_prefix[debug;
  #endif][]dnl
  ])
+ 
+ # b4_yylloc_default_define
+ # ------------------------
+ # Define YYLLOC_DEFAULT.
+ m4_define([b4_yylloc_default_define],
+ [[/* 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).  */
+ 
+ #ifndef YYLLOC_DEFAULT
+ # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+     do                                                                  \
+       if (YYID (N))                                                     \
+         {                                                               \
+           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+         }                                                               \
+       else                                                              \
+         {                                                               \
+           (Current).first_line   = (Current).last_line   =              \
+             YYRHSLOC (Rhs, 0).last_line;                                \
+           (Current).first_column = (Current).last_column =              \
+             YYRHSLOC (Rhs, 0).last_column;                              \
+         }                                                               \
+     while (YYID (0))
+ #endif
+ ]])
diff --combined data/glr.c
index 32932bac,ebef9694..37cf1a4a
--- a/data/glr.c
+++ b/data/glr.c
@@@ -18,7 -18,10 +18,10 @@@
  # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  
  
- m4_include(b4_pkgdatadir/[c.m4])
+ # If we are loaded by glr.cc, do not override c++.m4 definitions by
+ # those of c.m4.
+ m4_if(b4_skeleton, ["glr.c"],
+       [m4_include(b4_pkgdatadir/[c.m4])])
  
  ## ---------------- ##
  ## Default values.  ##
@@@ -123,15 -126,7 +126,15 @@@ m4_define([b4_locuser_args]
  # --------------------
  # Expansion of $<TYPE>$.
  m4_define([b4_lhs_value],
 -[((*yyvalp)[]m4_ifval([$1], [.$1]))])
 +[b4_symbol_value([(*yyvalp)], [$1])])
 +
 +
 +# b4_rhs_data(RULE-LENGTH, NUM)
 +# -----------------------------
 +# Expand to the semantic stack place that contains value and location
 +# of symbol number NUM in a rule of length RULE-LENGTH.
 +m4_define([b4_rhs_data],
 +[((yyGLRStackItem const *)yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate])
  
  
  # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
@@@ -139,7 -134,7 +142,7 @@@
  # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  # symbols on RHS.
  m4_define([b4_rhs_value],
 -[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))])
 +[b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yysval], [$3])])
  
  
  
@@@ -159,7 -154,7 +162,7 @@@ m4_define([b4_lhs_location]
  # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  # on RHS.
  m4_define([b4_rhs_location],
 -[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)])
 +[(b4_rhs_data([$1], [$2]).yyloc)])
  
  
  ## -------------- ##
@@@ -198,12 -193,8 +201,8 @@@ b4_copyright([Skeleton implementation f
  b4_percent_code_get([[top]])[
  ]m4_if(b4_api_prefix, [yy], [],
  [[/* Substitute the type names.  */
- #define YYSTYPE              ]b4_api_PREFIX[STYPE
- #define YYSTYPE_IS_TRIVIAL   ]b4_api_PREFIX[STYPE_IS_TRIVIAL
- #define YYSTYPE_IS_DECLARED  ]b4_api_PREFIX[STYPE_IS_DECLARED]b4_locations_if([[
- #define YYLTYPE              ]b4_api_PREFIX[LTYPE
- #define YYLTYPE_IS_TRIVIAL   ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
- #define YYLTYPE_IS_DECLARED  ]b4_api_PREFIX[LTYPE_IS_DECLARED]])])[
+ #define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[
+ #define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[
  ]m4_if(b4_prefix, [yy], [],
  [[/* Substitute the variable and function names.  */
  #define yyparse ]b4_prefix[parse
@@@ -221,14 -212,14 +220,14 @@@
  ]b4_null_define[
  
  ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
 -               [b4_shared_declarations])[
 +              [b4_shared_declarations])[
  
  /* Enabling verbose error messages.  */
  #ifdef YYERROR_VERBOSE
  # undef YYERROR_VERBOSE
  # define YYERROR_VERBOSE 1
  #else
 -# define YYERROR_VERBOSE ]b4_error_verbose_flag[
 +# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
  #endif
  
  /* Default (constant) value used for initialization for null
@@@ -357,7 -348,20 +356,7 @@@ static const ]b4_int_type_for([b4_trans
    ]b4_translate[
  };
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
 -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 -   YYRHS.  */
 -static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
 -{
 -  ]b4_prhs[
 -};
 -
 -/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 -static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
 -{
 -  ]b4_rhs[
 -};
 -
  /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
  static const ]b4_int_type_for([b4_rline])[ yyrline[] =
  {
@@@ -365,7 -369,7 +364,7 @@@
  };
  #endif
  
- #if YYDEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
+ #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
  static const char *const yytname[] =
@@@ -374,10 -378,17 +373,10 @@@
  };
  #endif
  
 -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 -static const ]b4_int_type_for([b4_r1])[ yyr1[] =
 -{
 -  ]b4_r1[
 -};
 +#define YYPACT_NINF ]b4_pact_ninf[
 +#define YYTABLE_NINF ]b4_table_ninf[
  
 -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 -static const ]b4_int_type_for([b4_r2])[ yyr2[] =
 -{
 -  ]b4_r2[
 -};
 +]b4_parser_tables_define[
  
  /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none).  */
  static const ]b4_int_type_for([b4_dprec])[ yydprec[] =
@@@ -391,11 -402,41 +390,11 @@@ static const ]b4_int_type_for([b4_merge
    ]b4_merger[
  };
  
 -/* YYDEFACT[S] -- default reduction number in state S.  Performed when
 -   YYTABLE doesn't specify something else to do.  Zero means the default
 -   is an error.  */
 -static const ]b4_int_type_for([b4_defact])[ yydefact[] =
 +/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as
 +   in the case of predicates.  */
 +static const yybool yyimmediate[] =
  {
 -  ]b4_defact[
 -};
 -
 -/* YYPDEFGOTO[NTERM-NUM].  */
 -static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
 -{
 -  ]b4_defgoto[
 -};
 -
 -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 -   STATE-NUM.  */
 -#define YYPACT_NINF ]b4_pact_ninf[
 -static const ]b4_int_type_for([b4_pact])[ yypact[] =
 -{
 -  ]b4_pact[
 -};
 -
 -/* YYPGOTO[NTERM-NUM].  */
 -static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
 -{
 -  ]b4_pgoto[
 -};
 -
 -/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 -   positive, shift that token.  If negative, reduce the rule which
 -   number is the opposite.  If YYTABLE_NINF, syntax error.  */
 -#define YYTABLE_NINF ]b4_table_ninf[
 -static const ]b4_int_type_for([b4_table])[ yytable[] =
 -{
 -  ]b4_table[
 +  ]b4_immediate[
  };
  
  /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
@@@ -416,34 -457,26 +415,14 @@@ dnl We probably ought to introduce a ty
  {
    ]b4_conflicting_rules[
  };
 -
 -static const ]b4_int_type_for([b4_check])[ yycheck[] =
 -{
 -  ]b4_check[
 -};
 -
 -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 -   symbol of state STATE-NUM.  */
 -static const ]b4_int_type_for([b4_stos])[ yystos[] =
 -{
 -  ]b4_stos[
 -};
 -
 +
  /* Error token number */
  #define YYTERROR 1
  
- /* 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).  */
- 
  ]b4_locations_if([[
- #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
  #ifndef YYLLOC_DEFAULT
- # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
-     do                                                                  \
-       if (YYID (N))                                                     \
-         {                                                               \
-           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
-           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
-           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
-           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
-         }                                                               \
-       else                                                              \
-         {                                                               \
-           (Current).first_line   = (Current).last_line   =              \
-             YYRHSLOC (Rhs, 0).last_line;                                \
-           (Current).first_column = (Current).last_column =              \
-             YYRHSLOC (Rhs, 0).last_column;                              \
-         }                                                               \
-     while (YYID (0))
+ ]b4_yylloc_default_define[
+ # define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
  
  /* YY_LOCATION_PRINT -- Print the location on the stream.
     This macro was not mandated originally: define only if we know
@@@ -464,7 -497,6 +443,6 @@@
  # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
  #endif
  
- 
  /* YYLEX -- calling `yylex' with the right arguments.  */
  #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
  
@@@ -494,47 -526,44 +472,47 @@@ static const int YYEMPTY = -2
  
  typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
  
 -#define YYCHK(YYE)                                                           \
 -   do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; }       \
 -   while (YYID (0))
 +#define YYCHK(YYE)                              \
 +  do {                                          \
 +    YYRESULTTAG yychk_flag = YYE;               \
 +    if (yychk_flag != yyok)                     \
 +      return yychk_flag;                        \
 +  } while (YYID (0))
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
  
  # ifndef YYFPRINTF
  #  define YYFPRINTF fprintf
  # endif
  
  # define YYDPRINTF(Args)                        \
 -do {                                            \
 -  if (yydebug)                                  \
 -    YYFPRINTF Args;                             \
 -} while (YYID (0))
 +  do {                                          \
 +    if (yydebug)                                \
 +      YYFPRINTF Args;                           \
 +  } while (YYID (0))
  
  ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[
  
 -# define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
 -do {                                                            \
 -  if (yydebug)                                                  \
 -    {                                                           \
 -      YYFPRINTF (stderr, "%s ", Title);                         \
 -      yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[);        \
 -      YYFPRINTF (stderr, "\n");                                 \
 -    }                                                           \
 -} while (YYID (0))
 +# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                  \
 +  do {                                                                  \
 +    if (yydebug)                                                        \
 +      {                                                                 \
 +        YYFPRINTF (stderr, "%s ", Title);                               \
 +        yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[);        \
 +        YYFPRINTF (stderr, "\n");                                       \
 +      }                                                                 \
 +  } while (YYID (0))
  
  /* Nonzero means print parse trace.  It is left uninitialized so that
     multiple parsers can coexist.  */
  int yydebug;
  
- #else /* !YYDEBUG */
+ #else /* !]b4_api_PREFIX[DEBUG */
  
  # define YYDPRINTF(Args)
  # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
  
- #endif /* !YYDEBUG */
+ #endif /* !]b4_api_PREFIX[DEBUG */
  
  /* YYINITDEPTH -- initial size of the parser's stacks.  */
  #ifndef YYINITDEPTH
@@@ -560,7 -589,13 +538,7 @@@
  #define YYHEADROOM 2
  
  #ifndef YYSTACKEXPANDABLE
 -# if (! defined __cplusplus \
 -      || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \
 -          && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL))
  #  define YYSTACKEXPANDABLE 1
 -# else
 -#  define YYSTACKEXPANDABLE 0
 -# endif
  #endif
  
  #if YYSTACKEXPANDABLE
@@@ -657,7 -692,7 +635,7 @@@ typedef int yyStateNum
  typedef int yyRuleNum;
  
  /** Grammar symbol */
 -typedef short int yySymbol;
 +typedef int yySymbol;
  
  /** Item references, as in LALR(1) machine */
  typedef short int yyItemNum;
@@@ -678,7 -713,7 +656,7 @@@ struct yyGLRState 
    yyStateNum yylrState;
    /** Preceding state in this stack */
    yyGLRState* yypred;
 -  /** Source position of the first token produced by my symbol */
 +  /** Source position of the last token produced by my symbol */
    size_t yyposn;
    union {
      /** First in a chain of alternative reductions producing the
@@@ -767,7 -802,7 +745,7 @@@ yyMemoryExhausted (yyGLRStack* yystackp
    YYLONGJMP (yystackp->yyexception_buffer, 2);
  }
  
- #if YYDEBUG || YYERROR_VERBOSE
+ #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE
  /** A printable representation of TOKEN.  */
  static inline const char*
  yytokenName (yySymbol yytoken)
@@@ -790,16 -825,9 +768,16 @@@ yyfillin (yyGLRStackItem *yyvsp, int yy
    yyGLRState *s = yyvsp[yylow0].yystate.yypred;
    for (i = yylow0-1; i >= yylow1; i -= 1)
      {
- #if YYDEBUG
 -      YYASSERT (s->yyresolved);
 -      yyvsp[i].yystate.yyresolved = yytrue;
 -      yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;]b4_locations_if([[
++#if ]b4_api_PREFIX[DEBUG
 +      yyvsp[i].yystate.yylrState = s->yylrState;
 +#endif
 +      yyvsp[i].yystate.yyresolved = s->yyresolved;
 +      if (s->yyresolved)
 +        yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;
 +      else
 +        /* The effect of using yysval or yyloc (in an immediate rule) is
 +         * undefined.  */
 +        yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULL;]b4_locations_if([[
        yyvsp[i].yystate.yyloc = s->yyloc;]])[
        s = yyvsp[i].yystate.yypred = s->yypred;
      }
@@@ -834,7 -862,7 +812,7 @@@ yyuserAction (yyRuleNum yyn, int yyrhsl
    yybool yynormal __attribute__ ((__unused__)) =
      (yystackp->yysplitPoint == YY_NULL);
    int yylow;
 -]b4_parse_param_use[]dnl
 +]b4_parse_param_use([yyvalp], [yylocp])dnl
  [# undef yyerrok
  # define yyerrok (yystackp->yyerrState = 0)
  # undef YYACCEPT
@@@ -911,7 -939,7 +889,7 @@@ yydestroyGLRState (char const *yymsg, y
                  &yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[);
    else
      {
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
        if (yydebug)
          {
            if (yys->yysemantics.yyfirstVal)
@@@ -937,7 -965,7 +915,7 @@@
      }
  }
  
 -/** Left-hand-side symbol for rule #RULE.  */
 +/** Left-hand-side symbol for rule #YYRULE.  */
  static inline yySymbol
  yylhsNonterm (yyRuleNum yyrule)
  {
@@@ -947,7 -975,7 +925,7 @@@
  #define yypact_value_is_default(yystate) \
    ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
  
 -/** True iff LR state STATE has only a default reduction (regardless
 +/** True iff LR state YYSTATE has only a default reduction (regardless
   *  of token).  */
  static inline yybool
  yyisDefaultedState (yyStateNum yystate)
@@@ -955,7 -983,7 +933,7 @@@
    return yypact_value_is_default (yypact[yystate]);
  }
  
 -/** The default reduction for STATE, assuming it has one.  */
 +/** The default reduction for YYSTATE, assuming it has one.  */
  static inline yyRuleNum
  yydefaultAction (yyStateNum yystate)
  {
@@@ -970,8 -998,8 +948,8 @@@
   *    R < 0:  Reduce on rule -R.
   *    R = 0:  Error.
   *    R > 0:  Shift to state R.
 - *  Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of
 - *  conflicting reductions.
 + *  Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list
 + *  of conflicting reductions.
   */
  static inline void
  yygetLRActions (yyStateNum yystate, int yytoken,
@@@ -999,7 -1027,8 +977,7 @@@
  static inline yyStateNum
  yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
  {
 -  int yyr;
 -  yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
 +  int yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
    if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)
      return yytable[yyr];
    else
@@@ -1020,10 -1049,9 +998,10 @@@ yyisErrorAction (int yyaction
  
                                  /* GLRStates */
  
 -/** Return a fresh GLRStackItem.  Callers should call
 - * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
 - * headroom.  */
 +/** Return a fresh GLRStackItem in YYSTACKP.  The item is an LR state
 + *  if YYISSTATE, and otherwise a semantic option.  Callers should call
 + *  YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
 + *  headroom.  */
  
  static inline yyGLRStackItem*
  yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
@@@ -1036,16 -1064,16 +1014,16 @@@
  }
  
  /** Add a new semantic action that will execute the action for rule
 - *  RULENUM on the semantic values in RHS to the list of
 - *  alternative actions for STATE.  Assumes that RHS comes from
 - *  stack #K of *STACKP. */
 + *  YYRULE on the semantic values in YYRHS to the list of
 + *  alternative actions for YYSTATE.  Assumes that YYRHS comes from
 + *  stack #YYK of *YYSTACKP. */
  static void
  yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
 -                     yyGLRState* rhs, yyRuleNum yyrule)
 +                     yyGLRState* yyrhs, yyRuleNum yyrule)
  {
    yySemanticOption* yynewOption =
      &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
 -  yynewOption->yystate = rhs;
 +  yynewOption->yystate = yyrhs;
    yynewOption->yyrule = yyrule;
    if (yystackp->yytops.yylookaheadNeeds[yyk])
      {
@@@ -1063,7 -1091,7 +1041,7 @@@
  
                                  /* GLRStacks */
  
 -/** Initialize SET to a singleton set containing an empty stack.  */
 +/** Initialize YYSET to a singleton set containing an empty stack.  */
  static yybool
  yyinitStateSet (yyGLRStateSet* yyset)
  {
@@@ -1089,8 -1117,8 +1067,8 @@@ static void yyfreeStateSet (yyGLRStateS
    YYFREE (yyset->yylookaheadNeeds);
  }
  
 -/** Initialize STACK to a single empty stack, with total maximum
 - *  capacity for all stacks of SIZE.  */
 +/** Initialize *YYSTACKP to a single empty stack, with total maximum
 + *  capacity for all stacks of YYSIZE.  */
  static yybool
  yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
  {
@@@ -1112,7 -1140,7 +1090,7 @@@
  # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
    &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
  
 -/** If STACK is expandable, extend it.  WARNING: Pointers into the
 +/** If *YYSTACKP is expandable, extend it.  WARNING: Pointers into the
      stack from outside should be considered invalid after this call.
      We always expand when there are 1 or fewer items left AFTER an
      allocation, so that we can avoid having external pointers exist
@@@ -1182,9 -1210,9 +1160,9 @@@ yyfreeGLRStack (yyGLRStack* yystackp
    yyfreeStateSet (&yystackp->yytops);
  }
  
 -/** Assuming that S is a GLRState somewhere on STACK, update the
 - *  splitpoint of STACK, if needed, so that it is at least as deep as
 - *  S.  */
 +/** Assuming that YYS is a GLRState somewhere on *YYSTACKP, update the
 + *  splitpoint of *YYSTACKP, if needed, so that it is at least as deep as
 + *  YYS.  */
  static inline void
  yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
  {
@@@ -1192,7 -1220,7 +1170,7 @@@
      yystackp->yysplitPoint = yys;
  }
  
 -/** Invalidate stack #K in STACK.  */
 +/** Invalidate stack #YYK in *YYSTACKP.  */
  static inline void
  yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
  {
@@@ -1201,8 -1229,8 +1179,8 @@@
    yystackp->yytops.yystates[yyk] = YY_NULL;
  }
  
 -/** Undelete the last stack that was marked as deleted.  Can only be
 -    done once after a deletion, and only when all other stacks have
 +/** Undelete the last stack in *YYSTACKP that was marked as deleted.  Can
 +    only be done once after a deletion, and only when all other stacks have
      been deleted.  */
  static void
  yyundeleteLastStack (yyGLRStack* yystackp)
@@@ -1251,9 -1279,8 +1229,9 @@@ yyremoveDeletes (yyGLRStack* yystackp
      }
  }
  
 -/** Shift to a new state on stack #K of STACK, corresponding to LR state
 - * LRSTATE, at input position POSN, with (resolved) semantic value SVAL.  */
 +/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR
 + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic
 + * value *YYVALP and source location *YYLOCP.  */
  static inline void
  yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
              size_t yyposn,
@@@ -1272,12 -1299,12 +1250,12 @@@
    YY_RESERVE_GLRSTACK (yystackp);
  }
  
 -/** Shift stack #K of YYSTACK, to a new state corresponding to LR
 +/** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR
   *  state YYLRSTATE, at input position YYPOSN, with the (unresolved)
   *  semantic value of YYRHS under the action for YYRULE.  */
  static inline void
  yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
 -                 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule)
 +                 size_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule)
  {
    yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
  
@@@ -1289,55 -1316,14 +1267,55 @@@
    yystackp->yytops.yystates[yyk] = yynewState;
  
    /* Invokes YY_RESERVE_GLRSTACK.  */
 -  yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
 +  yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule);
 +}
 +
- #if !YYDEBUG
++#if !]b4_api_PREFIX[DEBUG
 +# define YY_REDUCE_PRINT(Args)
 +#else
 +# define YY_REDUCE_PRINT(Args)          \
 +do {                                    \
 +  if (yydebug)                          \
 +    yy_reduce_print Args;               \
 +} while (YYID (0))
 +
 +/*----------------------------------------------------------------------.
 +| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
 +`----------------------------------------------------------------------*/
 +
 +/*ARGSUSED*/ static inline void
 +yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk,
 +                 yyRuleNum yyrule]b4_user_formals[)
 +{
 +  int yynrhs = yyrhsLength (yyrule);]b4_locations_if([
 +  int yylow = 1;])[
 +  int yyi;
 +  YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
 +             (unsigned long int) yyk, yyrule - 1,
 +             (unsigned long int) yyrline[yyrule]);
 +  if (! yynormal)
 +    yyfillin (yyvsp, 1, -yynrhs);
 +  /* The symbols being reduced.  */
 +  for (yyi = 0; yyi < yynrhs; yyi++)
 +    {
 +      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 +      yy_symbol_print (stderr,
 +                       yystos[yyvsp[yyi - yynrhs + 1].yystate.yylrState],
 +                       &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval
 +                       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
 +                       b4_user_args[);
 +      if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved)
 +        YYFPRINTF (stderr, " (unresolved)");
 +      YYFPRINTF (stderr, "\n");
 +    }
  }
 +#endif
  
 -/** Pop the symbols consumed by reduction #RULE from the top of stack
 - *  #K of STACK, and perform the appropriate semantic action on their
 +/** Pop the symbols consumed by reduction #YYRULE from the top of stack
 + *  #YYK of *YYSTACKP, and perform the appropriate semantic action on their
   *  semantic values.  Assumes that all ambiguities in semantic values
 - *  have been previously resolved.  Set *VALP to the resulting value,
 - *  and *LOCP to the computed location (if any).  Return value is as
 + *  have been previously resolved.  Set *YYVALP to the resulting value,
 + *  and *YYLOCP to the computed location (if any).  Return value is as
   *  for userAction.  */
  static inline YYRESULTTAG
  yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
@@@ -1348,17 -1334,20 +1326,17 @@@
    if (yystackp->yysplitPoint == YY_NULL)
      {
        /* Standard special case: single stack.  */
 -      yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
 +      yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
        YYASSERT (yyk == 0);
        yystackp->yynextFree -= yynrhs;
        yystackp->yyspaceLeft += yynrhs;
        yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
 -      return yyuserAction (yyrule, yynrhs, rhs, yystackp,
 +      YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[));
 +      return yyuserAction (yyrule, yynrhs, yyrhs, yystackp,
                             yyvalp]b4_locuser_args[);
      }
    else
      {
 -      /* At present, doAction is never called in nondeterministic
 -       * mode, so this branch is never taken.  It is here in
 -       * anticipation of a future feature that will allow immediate
 -       * evaluation of selected actions in nondeterministic mode.  */
        int yyi;
        yyGLRState* yys;
        yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
@@@ -1374,21 -1363,62 +1352,21 @@@
          }
        yyupdateSplit (yystackp, yys);
        yystackp->yytops.yystates[yyk] = yys;
 +      YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[));
        return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
                             yystackp, yyvalp]b4_locuser_args[);
      }
  }
  
 -#if !]b4_api_PREFIX[DEBUG
 -# define YY_REDUCE_PRINT(Args)
 -#else
 -# define YY_REDUCE_PRINT(Args)          \
 -do {                                    \
 -  if (yydebug)                          \
 -    yy_reduce_print Args;               \
 -} while (YYID (0))
 -
 -/*----------------------------------------------------------.
 -| Report that the RULE is going to be reduced on stack #K.  |
 -`----------------------------------------------------------*/
 -
 -/*ARGSUSED*/ static inline void
 -yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
 -                 YYSTYPE* yyvalp]b4_locuser_formals[)
 -{
 -  int yynrhs = yyrhsLength (yyrule);
 -  yybool yynormal __attribute__ ((__unused__)) =
 -    (yystackp->yysplitPoint == YY_NULL);
 -  yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
 -  int yylow = 1;
 -  int yyi;
 -  YYUSE (yyvalp);]b4_locations_if([
 -  YYUSE (yylocp);])[
 -]b4_parse_param_use[]dnl
 -[  YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
 -             (unsigned long int) yyk, yyrule - 1,
 -             (unsigned long int) yyrline[yyrule]);
 -  /* The symbols being reduced.  */
 -  for (yyi = 0; yyi < yynrhs; yyi++)
 -    {
 -      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 -      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 -                       &]b4_rhs_value(yynrhs, yyi + 1)[
 -                       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
 -                       b4_user_args[);
 -      YYFPRINTF (stderr, "\n");
 -    }
 -}
 -#endif
 -
 -/** Pop items off stack #K of STACK according to grammar rule RULE,
 +/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE,
   *  and push back on the resulting nonterminal symbol.  Perform the
 - *  semantic action associated with RULE and store its value with the
 - *  newly pushed state, if FORCEEVAL or if STACK is currently
 + *  semantic action associated with YYRULE and store its value with the
 + *  newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently
   *  unambiguous.  Otherwise, store the deferred semantic action with
   *  the new state.  If the new state would have an identical input
   *  position, LR state, and predecessor to an existing state on the stack,
 - *  it is identified with that existing state, eliminating stack #K from
 - *  the STACK.  In this case, the (necessarily deferred) semantic value is
 + *  it is identified with that existing state, eliminating stack #YYK from
 + *  *YYSTACKP.  In this case, the semantic value is
   *  added to the options for the existing state's semantic value.
   */
  static inline YYRESULTTAG
@@@ -1399,18 -1429,11 +1377,18 @@@ yyglrReduce (yyGLRStack* yystackp, size
  
    if (yyforceEval || yystackp->yysplitPoint == YY_NULL)
      {
 +      YYRESULTTAG yyflag;
        YYSTYPE yysval;]b4_locations_if([
        YYLTYPE yyloc;])[
  
 -      YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[));
 -      YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[));
 +      yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[);
 +      if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULL)
 +        {
 +          YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n",
 +                     (unsigned long int) yyk, yyrule - 1));
 +        }
 +      if (yyflag != yyok)
 +        return yyflag;
        YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
        yyglrShift (yystackp, yyk,
                    yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
@@@ -1433,8 -1456,7 +1411,8 @@@
        yyupdateSplit (yystackp, yys);
        yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
        YYDPRINTF ((stderr,
 -                  "Reduced stack %lu by rule #%d; action deferred.  Now in state %d.\n",
 +                  "Reduced stack %lu by rule #%d; action deferred.  "
 +                  "Now in state %d.\n",
                    (unsigned long int) yyk, yyrule - 1, yynewLRState));
        for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
          if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULL)
@@@ -1505,7 -1527,7 +1483,7 @@@ yysplitStack (yyGLRStack* yystackp, siz
    return yystackp->yytops.yysize-1;
  }
  
 -/** True iff Y0 and Y1 represent identical options at the top level.
 +/** True iff YYY0 and YYY1 represent identical options at the top level.
   *  That is, they represent the same rule applied to RHS symbols
   *  that produce the same terminal symbols.  */
  static yybool
@@@ -1527,8 -1549,8 +1505,8 @@@ yyidenticalOptions (yySemanticOption* y
      return yyfalse;
  }
  
 -/** Assuming identicalOptions (Y0,Y1), destructively merge the
 - *  alternative semantic values for the RHS-symbols of Y1 and Y0.  */
 +/** Assuming identicalOptions (YYY0,YYY1), destructively merge the
 + *  alternative semantic values for the RHS-symbols of YYY1 and YYY0.  */
  static void
  yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
  {
@@@ -1607,11 -1629,11 +1585,11 @@@ static YYRESULTTAG yyresolveValue (yyGL
                                     yyGLRStack* yystackp]b4_user_formals[);
  
  
 -/** Resolve the previous N states starting at and including state S.  If result
 - *  != yyok, some states may have been left unresolved possibly with empty
 - *  semantic option chains.  Regardless of whether result = yyok, each state
 - *  has been left with consistent data so that yydestroyGLRState can be invoked
 - *  if necessary.  */
 +/** Resolve the previous YYN states starting at and including state YYS
 + *  on *YYSTACKP. If result != yyok, some states may have been left
 + *  unresolved possibly with empty semantic option chains.  Regardless
 + *  of whether result = yyok, each state has been left with consistent
 + *  data so that yydestroyGLRState can be invoked if necessary.  */
  static YYRESULTTAG
  yyresolveStates (yyGLRState* yys, int yyn,
                   yyGLRStack* yystackp]b4_user_formals[)
@@@ -1626,10 -1648,9 +1604,10 @@@
    return yyok;
  }
  
 -/** Resolve the states for the RHS of OPT, perform its user action, and return
 - *  the semantic value and location.  Regardless of whether result = yyok, all
 - *  RHS states have been destroyed (assuming the user action destroys all RHS
 +/** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its
 + *  user action, and return the semantic value and location in *YYVALP
 + *  and *YYLOCP.  Regardless of whether result = yyok, all RHS states
 + *  have been destroyed (assuming the user action destroys all RHS
   *  semantic values if invoked).  */
  static YYRESULTTAG
  yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
@@@ -1668,7 -1689,7 +1646,7 @@@
    return yyflag;
  }
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
  static void
  yyreportTree (yySemanticOption* yyx, int yyindent)
  {
@@@ -1703,11 -1724,11 +1681,11 @@@
          {
            if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
              YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
 -                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
 +                       yytokenName (yystos[yystates[yyi]->yylrState]));
            else
              YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
 -                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
 -                       (unsigned long int) (yystates[yyi - 1]->yyposn + 1),
 +                       yytokenName (yystos[yystates[yyi]->yylrState]),
 +                       (unsigned long int) (yystates[yyi-1]->yyposn + 1),
                         (unsigned long int) yystates[yyi]->yyposn);
          }
        else
@@@ -1723,7 -1744,7 +1701,7 @@@ yyreportAmbiguity (yySemanticOption* yy
    YYUSE (yyx0);
    YYUSE (yyx1);
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
    YYFPRINTF (stderr, "Ambiguity detected.\n");
    YYFPRINTF (stderr, "Option 1,\n");
    yyreportTree (yyx0, 2);
@@@ -1736,9 -1757,9 +1714,9 @@@
    return yyabort;
  }]b4_locations_if([[
  
 -/** Starting at and including state S1, resolve the location for each of the
 - *  previous N1 states that is unresolved.  The first semantic option of a state
 - *  is always chosen.  */
 +/** Resolve the locations for each of the YYN1 states in *YYSTACKP,
 + *  ending at YYS1.  Has no effect on previously resolved states.
 + *  The first semantic option of a state is always chosen.  */
  static void
  yyresolveLocations (yyGLRState* yys1, int yyn1,
                      yyGLRStack *yystackp]b4_user_formals[)
@@@ -1792,12 -1813,11 +1770,12 @@@
      }
  }]])[
  
 -/** Resolve the ambiguity represented in state S, perform the indicated
 - *  actions, and set the semantic value of S.  If result != yyok, the chain of
 - *  semantic options in S has been cleared instead or it has been left
 - *  unmodified except that redundant options may have been removed.  Regardless
 - *  of whether result = yyok, S has been left with consistent data so that
 +/** Resolve the ambiguity represented in state YYS in *YYSTACKP,
 + *  perform the indicated actions, and set the semantic value of YYS.
 + *  If result != yyok, the chain of semantic options in YYS has been
 + *  cleared instead or it has been left unmodified except that
 + *  redundant options may have been removed.  Regardless of whether
 + *  result = yyok, YYS has been left with consistent data so that
   *  yydestroyGLRState can be invoked if necessary.  */
  static YYRESULTTAG
  yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
@@@ -1935,6 -1955,10 +1913,6 @@@ static YYRESULTTA
  yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
                     size_t yyposn]b4_pure_formals[)
  {
 -  int yyaction;
 -  const short int* yyconflicts;
 -  yyRuleNum yyrule;
 -
    while (yystackp->yytops.yystates[yyk] != YY_NULL)
      {
        yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
@@@ -1945,8 -1969,7 +1923,8 @@@
  
        if (yyisDefaultedState (yystate))
          {
 -          yyrule = yydefaultAction (yystate);
 +          YYRESULTTAG yyflag;
 +          yyRuleNum yyrule = yydefaultAction (yystate);
            if (yyrule == 0)
              {
                YYDPRINTF ((stderr, "Stack %lu dies.\n",
@@@ -1954,25 -1977,11 +1932,25 @@@
                yymarkStackDeleted (yystackp, yyk);
                return yyok;
              }
 -          YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
 +          yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[);
 +          if (yyflag == yyerr)
 +            {
 +              YYDPRINTF ((stderr,
 +                          "Stack %lu dies "
 +                          "(predicate failure or explicit user error).\n",
 +                          (unsigned long int) yyk));
 +              yymarkStackDeleted (yystackp, yyk);
 +              return yyok;
 +            }
 +          if (yyflag != yyok)
 +            return yyflag;
          }
        else
          {
            yySymbol yytoken;
 +          int yyaction;
 +          const short int* yyconflicts;
 +
            yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
            if (yychar == YYEMPTY)
              {
@@@ -1995,25 -2004,14 +1973,25 @@@
  
            while (*yyconflicts != 0)
              {
 +              YYRESULTTAG yyflag;
                size_t yynewStack = yysplitStack (yystackp, yyk);
                YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
                            (unsigned long int) yynewStack,
                            (unsigned long int) yyk));
 -              YYCHK (yyglrReduce (yystackp, yynewStack,
 -                                  *yyconflicts, yyfalse]b4_user_args[));
 -              YYCHK (yyprocessOneStack (yystackp, yynewStack,
 -                                        yyposn]b4_pure_args[));
 +              yyflag = yyglrReduce (yystackp, yynewStack,
 +                                    *yyconflicts,
 +                                    yyimmediate[*yyconflicts]]b4_user_args[);
 +              if (yyflag == yyok)
 +                YYCHK (yyprocessOneStack (yystackp, yynewStack,
 +                                          yyposn]b4_pure_args[));
 +              else if (yyflag == yyerr)
 +                {
 +                  YYDPRINTF ((stderr, "Stack %lu dies.\n",
 +                              (unsigned long int) yynewStack));
 +                  yymarkStackDeleted (yystackp, yynewStack);
 +                }
 +              else
 +                return yyflag;
                yyconflicts += 1;
              }
  
@@@ -2027,21 -2025,8 +2005,21 @@@
                break;
              }
            else
 -            YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
 -                                yyfalse]b4_user_args[));
 +            {
 +              YYRESULTTAG yyflag = yyglrReduce (yystackp, yyk, -yyaction,
 +                                                yyimmediate[-yyaction]]b4_user_args[);
 +              if (yyflag == yyerr)
 +                {
 +                  YYDPRINTF ((stderr,
 +                              "Stack %lu dies "
 +                              "(predicate failure or explicit user error).\n",
 +                              (unsigned long int) yyk));
 +                  yymarkStackDeleted (yystackp, yyk);
 +                  break;
 +                }
 +              else if (yyflag != yyok)
 +                return yyflag;
 +            }
          }
      }
    return yyok;
@@@ -2294,6 -2279,7 +2272,6 @@@ yyrecoverSyntaxError (yyGLRStack* yysta
      }                                                                        \
    } while (YYID (0))
  
 -
  /*----------.
  | yyparse.  |
  `----------*/
@@@ -2310,7 -2296,7 +2288,7 @@@
    yychar = YYEMPTY;
    yylval = yyval_default;
  ]b4_locations_if([
- #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+ #if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
    yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
    yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
  #endif
@@@ -2542,7 -2528,7 +2520,7 @@@ m4_popdef([b4_at_dollar])])dn
  }
  
  /* DEBUGGING ONLY */
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
  static void yypstack (yyGLRStack* yystackp, size_t yyk)
    __attribute__ ((__unused__));
  static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
@@@ -2615,7 -2601,9 +2593,7 @@@ yypdumpstack (yyGLRStack* yystackp
    YYFPRINTF (stderr, "\n");
  }
  #endif
 -]
 -
 -b4_epilogue
 +]b4_epilogue[]dnl
  dnl
  dnl glr.cc produces its own header.
  dnl
diff --combined data/glr.cc
index a1652a10,ba6ceac0..2f986da2
--- a/data/glr.cc
+++ b/data/glr.cc
@@@ -1,3 -1,5 +1,3 @@@
 -                                                                    -*- C -*-
 -
  # C++ GLR skeleton for Bison
  
  # Copyright (C) 2002-2012 Free Software Foundation, Inc.
@@@ -27,7 -29,7 +27,7 @@@
  #
  #   The additional arguments are stored as members of the parser
  #   object, yyparser.  The C routines need to carry yyparser
 -#   throughout the C parser; that easy: just let yyparser become an
 +#   throughout the C parser; that's easy: make yyparser an
  #   additional parse-param.  But because the C++ skeleton needs to
  #   know the "real" original parse-param, we save them
  #   (b4_parse_param_orig).  Note that b4_parse_param is overquoted
@@@ -37,14 -39,14 +37,14 @@@
  # The locations
  #
  #   We use location.cc just like lalr1.cc, but because glr.c stores
 -#   the locations in a (C++) union, the position and location classes
 +#   the locations in a union, the position and location classes
  #   must not have a constructor.  Therefore, contrary to lalr1.cc, we
  #   must not define "b4_location_constructors".  As a consequence the
  #   user must initialize the first positions (in particular the
  #   filename member).
  
  # We require a pure interface using locations.
 -m4_define([b4_locations_flag], [1])
 +m4_define([b4_percent_define(locations)], [])
  m4_define([b4_pure_flag],      [1])
  
  # The header is mandatory.
@@@ -76,9 -78,9 +76,9 @@@ m4_define([b4_yy_symbol_print_generate]
      [static void],
      [[FILE *],               []],
      [[int yytype],           [yytype]],
-     [[const b4_namespace_ref::b4_parser_class_name::semantic_type *yyvaluep],
+     [[const ]b4_namespace_ref::b4_parser_class_name[::semantic_type *yyvaluep],
                               [yyvaluep]],
-     [[const b4_namespace_ref::b4_parser_class_name::location_type *yylocationp],
+     [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
                               [yylocationp]],
      b4_parse_param)[
  {
@@@ -88,19 -90,22 +88,22 @@@
  ]])
  
  
- # Declare yyerror.
+ # Hijack the post prologue to insert early definition of YYLLOC_DEFAULT
+ # and declaration of yyerror.
  m4_append([b4_post_prologue],
- [b4_syncline([@oline@], [@ofile@])
- 
- b4_c_ansi_function_decl([yyerror],
+ [b4_syncline([@oline@], [@ofile@])[
+ ]b4_yylloc_default_define[
+ #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
+ ]b4_c_ansi_function_decl([yyerror],
      [static void],
-     [[const b4_namespace_ref::b4_parser_class_name::location_type *yylocationp],
+     [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
                          [yylocationp]],
      b4_parse_param,
      [[const char* msg], [msg]])])
  
  
- # Define yyerror.
+ # Hijack the epilogue to define implementations (yyerror, parser member
+ # functions etc.).
  m4_append([b4_epilogue],
  [b4_syncline([@oline@], [@ofile@])[
  /*------------------.
@@@ -109,7 -114,7 +112,7 @@@
  
  ]b4_c_ansi_function_def([yyerror],
      [static void],
-     [[const b4_namespace_ref::b4_parser_class_name::location_type *yylocationp],
+     [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
                          [yylocationp]],
      b4_parse_param,
      [[const char* msg], [msg]])[
@@@ -125,8 -130,9 +128,8 @@@ m4_pushdef([b4_parse_param], m4_defn([b
  [  /// 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], [,])[
 +    ]m4_ifset([b4_parse_param], [  ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
  #endif]b4_parse_param_cons[
    {
    }
@@@ -141,7 -147,7 +144,7 @@@
      return ::yyparse (*this]b4_user_args[);
    }
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
    /*--------------------.
    | Print this symbol.  |
    `--------------------*/
@@@ -158,7 -164,7 +161,7 @@@
      YYUSE (yyo);
      switch (yytype)
        {
 -  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 +]b4_symbol_foreach([b4_symbol_printer])dnl
  [        default:
            break;
        }
@@@ -193,28 -199,29 +196,28 @@@
    ]b4_parser_class_name[::debug_level_type
    ]b4_parser_class_name[::debug_level () const
    {
 -    return yydebug_;
 +    return yydebug;
    }
  
    void
    ]b4_parser_class_name[::set_debug_level (debug_level_type l)
    {
 -    yydebug_ = l;
 +    yydebug = l;
    }
  
  #endif
  ]m4_popdef([b4_parse_param])dnl
  b4_namespace_close[
 -
  ]])
  
  
  # Let glr.c believe that the user arguments include the parser itself.
  m4_ifset([b4_parse_param],
  [m4_pushdef([b4_parse_param],
-             m4_dquote([[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]],]
- m4_defn([b4_parse_param])))],
+             [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]],]
+ m4_defn([b4_parse_param]))],
  [m4_pushdef([b4_parse_param],
-             [[[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]]]])
+             [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]]])
  ])
  m4_include(b4_pkgdatadir/[glr.c])
  m4_popdef([b4_parse_param])
@@@ -222,7 -229,7 +225,7 @@@
  m4_divert_push(0)
  @output(b4_spec_defines_file@)@
  b4_copyright([Skeleton interface for Bison GLR parsers in C++],
 -             [2002-2006, 2009-2012])[
 +             [2002-2012])[
  
  /* C++ GLR parser skeleton written by Akim Demaille.  */
  
@@@ -230,42 -237,41 +233,20 @@@
  
  ]b4_percent_code_get([[requires]])[
  
 -# include <string>
 -# include <iostream>
 +#include <stdexcept>
 +#include <string>
 +#include <iostream>
  ]b4_percent_define_ifdef([[location_type]], [],
 -                         [[# include "location.hh"]])[
 +                         [[#include "location.hh"]])[
  
- /* Enabling traces.  */
- #ifndef YYDEBUG
- # define YYDEBUG ]b4_parse_trace_if([1], [0])[
- #endif
- 
- /* 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).  */
- 
- #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 (/*CONSTCOND*/ 0)
- #endif
+ ]b4_YYDEBUG_define[
  
  ]b4_namespace_open[
    /// A Bison parser.
    class ]b4_parser_class_name[
    {
    public:
 -    /// Symbol semantic values.
 -# ifndef ]b4_api_PREFIX[STYPE
 -]m4_ifdef([b4_stype],
 -[    union semantic_type
 -    {
 -b4_user_stype
 -    };],
 -[m4_if(b4_tag_seen_flag, 0,
 -[[    typedef int semantic_type;]],
 -[[    typedef ]b4_api_PREFIX[STYPE semantic_type;]])])[
 -# else
 -    typedef ]b4_api_PREFIX[STYPE semantic_type;
 -# endif
 -    /// Symbol locations.
 -    typedef ]b4_percent_define_get([[location_type]],
 -                                   [[location]])[ location_type;
 -    /// Tokens.
 -    struct token
 -    {
 -      ]b4_token_enums(b4_tokens)[
 -    };
 -    /// Token type.
 -    typedef token::yytokentype token_type;
 +]b4_public_types_declare[
  
      /// Build a parser object.
      ]b4_parser_class_name[ (]b4_parse_param_decl[);
@@@ -287,13 -293,16 +268,13 @@@
      /// Set the current debugging level.
      void set_debug_level (debug_level_type l);
  
 -  private:
 -
    public:
      /// Report a syntax error.
      /// \param loc    where the syntax error is found.
      /// \param msg    a description of the syntax error.
      virtual void error (const location_type& loc, const std::string& msg);
 -  private:
  
- #if YYDEBUG
+ # if ]b4_api_PREFIX[DEBUG
    public:
      /// \brief Report a symbol value on the debug stream.
      /// \param yytype       The token type.
@@@ -311,8 -320,9 +292,8 @@@
                                     const location_type* yylocationp);
    private:
      /* Debugging.  */
 -    int yydebug_;
      std::ostream* yycdebug_;
 -# endif
 +#endif
  
  ]b4_parse_param_vars[
    };
diff --combined data/lalr1.cc
index dbcc7349,17a8f22c..59b30964
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@@ -17,106 -17,6 +17,106 @@@
  
  m4_include(b4_pkgdatadir/[c++.m4])
  
 +
 +# b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
 +# --------------------------------------------------------------
 +# Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT.
 +m4_define([b4_integral_parser_table_declare],
 +[m4_ifval([$3], [b4_c_comment([$3], [  ])
 +])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.
 +m4_define([b4_integral_parser_table_define],
 +[  const b4_int_type_for([$2])
 +  b4_parser_class_name::yy$1_[[]] =
 +  {
 +  $2
 +  };dnl
 +])
 +
 +
 +# b4_symbol_value_template(VAL, [TYPE])
 +# -------------------------------------
 +# Same as b4_symbol_value, but used in a template method.  It makes
 +# a difference when using variants.
 +m4_copy([b4_symbol_value], [b4_symbol_value_template])
 +
 +
 +# b4_lhs_value([TYPE])
 +# --------------------
 +# Expansion of $<TYPE>$.
 +m4_define([b4_lhs_value],
 +          [b4_symbol_value([yylhs.value], [$1])])
 +
 +
 +# b4_lhs_location()
 +# -----------------
 +# Expansion of @$.
 +m4_define([b4_lhs_location],
 +          [yylhs.location])
 +
 +
 +# b4_rhs_data(RULE-LENGTH, NUM)
 +# -----------------------------
 +# Return the data corresponding to the symbol #NUM, where the current
 +# rule has RULE-LENGTH symbols on RHS.
 +m4_define([b4_rhs_data],
 +          [yystack_@{b4_subtract($@)@}])
 +
 +
 +# b4_rhs_state(RULE-LENGTH, NUM)
 +# ------------------------------
 +# The state corresponding to the symbol #NUM, where the current
 +# rule has RULE-LENGTH symbols on RHS.
 +m4_define([b4_rhs_state],
 +          [b4_rhs_data([$1], [$2]).state])
 +
 +
 +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
 +# --------------------------------------
 +# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 +# symbols on RHS.
 +m4_define([b4_rhs_value],
 +          [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])])
 +
 +
 +# b4_rhs_location(RULE-LENGTH, NUM)
 +# ---------------------------------
 +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 +# on RHS.
 +m4_define([b4_rhs_location],
 +          [b4_rhs_data([$1], [$2]).location])
 +
 +
 +# b4_symbol_action(SYMBOL-NUM, KIND)
 +# ----------------------------------
 +# Run the action KIND (destructor or printer) for SYMBOL-NUM.
 +# 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
 +      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_pushdef([b4_copyright_years],
 +           [2002-2012])
 +
  m4_define([b4_parser_class_name],
            [b4_percent_define_get([[parser_class_name]])])
  
@@@ -124,18 -24,19 +124,18 @@@
  b4_defines_if([],
                [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
  
 -b4_percent_define_ifdef([[location_type]], [],
 +b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
    [# Backward compatibility.
 -  m4_define([b4_location_constructors])
 -  m4_include(b4_pkgdatadir/[location.cc])])
 +   m4_define([b4_location_constructors])
 +   m4_include(b4_pkgdatadir/[location.cc])])])
  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
 -b4_defines_if(
 -[@output(b4_spec_defines_file@)@
 -b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++],
 -             [2002-2012])
 +@output(b4_spec_defines_file@)@
 +b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
  [
  /**
   ** \file ]b4_spec_defines_file[
@@@ -145,25 -46,16 +145,20 @@@
  /* C++ LALR(1) parser skeleton written by Akim Demaille.  */
  
  ]b4_cpp_guard_open([b4_spec_defines_file])[
 -
  ]b4_percent_code_get([[requires]])[
 -
 -#include <string>
 -#include <iostream>
 -#include "stack.hh"
 -]b4_percent_define_ifdef([[location_type]], [],
 -                         [[#include "location.hh"]])[
 +]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[
- 
- /* Enabling traces.  */
- #ifndef YYDEBUG
- # define YYDEBUG ]b4_parse_trace_if([1], [0])[
- #endif
+ ]b4_YYDEBUG_define[
  
  ]b4_namespace_open[
  
@@@ -171,7 -63,30 +166,7 @@@
    class ]b4_parser_class_name[
    {
    public:
 -    /// Symbol semantic values.
 -#ifndef ]b4_api_PREFIX[STYPE
 -]m4_ifdef([b4_stype],
 -[    union semantic_type
 -    {
 -b4_user_stype
 -    };],
 -[m4_if(b4_tag_seen_flag, 0,
 -[[    typedef int semantic_type;]],
 -[[    typedef ]b4_api_PREFIX[STYPE semantic_type;]])])[
 -#else
 -    typedef ]b4_api_PREFIX[STYPE semantic_type;
 -#endif
 -    /// Symbol locations.
 -    typedef ]b4_percent_define_get([[location_type]],
 -                                   [[location]])[ location_type;
 -    /// Tokens.
 -    struct token
 -    {
 -      ]b4_token_enums(b4_tokens)[
 -    };
 -    /// Token type.
 -    typedef token::yytokentype token_type;
 -
 +]b4_public_types_declare[
      /// Build a parser object.
      ]b4_parser_class_name[ (]b4_parse_param_decl[);
      virtual ~]b4_parser_class_name[ ();
@@@ -180,7 -95,7 +175,7 @@@
      /// \returns  0 iff parsing succeeded.
      virtual int parse ();
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
      /// The current debugging stream.
      std::ostream& debug_stream () const;
      /// Set the current debugging stream.
@@@ -194,27 -109,50 +189,27 @@@
      void set_debug_level (debug_level_type l);
  #endif
  
 -  private:
 -    /// Report a syntax error.
 -    /// \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.
 -    virtual void error (const location_type& loc, const std::string& msg);
 -
 -    /// Generate an error message.
 -    /// \param state   the state where the error occurred.
 -    /// \param tok     the lookahead token.
 -    virtual std::string yysyntax_error_ (int yystate, int tok);
 -
 -#if ]b4_api_PREFIX[DEBUG
 -    /// \brief Report a symbol value on the debug stream.
 -    /// \param yytype       The token type.
 -    /// \param yyvaluep     Its semantic value.
 -    /// \param yylocationp  Its location.
 -    virtual void yy_symbol_value_print_ (int yytype,
 -					 const semantic_type* yyvaluep,
 -					 const location_type* yylocationp);
 -    /// \brief Report a symbol on the debug stream.
 -    /// \param yytype       The token type.
 -    /// \param yyvaluep     Its semantic value.
 -    /// \param yylocationp  Its location.
 -    virtual void yy_symbol_print_ (int yytype,
 -				   const semantic_type* yyvaluep,
 -				   const location_type* yylocationp);
 -#endif
 +    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:
      /// State numbers.
      typedef int state_type;
 -    /// State stack type.
 -    typedef stack<state_type>    state_stack_type;
 -    /// Semantic value stack type.
 -    typedef stack<semantic_type> semantic_stack_type;
 -    /// location stack type.
 -    typedef stack<location_type> location_stack_type;
 -
 -    /// The state stack.
 -    state_stack_type yystate_stack_;
 -    /// The semantic value stack.
 -    semantic_stack_type yysemantic_stack_;
 -    /// The location stack.
 -    location_stack_type yylocation_stack_;
 +
 +    /// 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);
 +
 +    /// 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);
  
      /// Whether the given \c yypact_ value indicates a defaulted state.
      /// \param yyvalue   the value to check
@@@ -226,115 -164,94 +221,115 @@@
  
      /// Internal symbol numbers.
      typedef ]b4_int_type_for([b4_translate])[ token_number_type;
 -    /* Tables.  */
 -    /// For a state, the index in \a yytable_ of its portion.
 -    static const ]b4_int_type_for([b4_pact])[ yypact_[];
      static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
 -
 -    /// For a state, default reduction number.
 -    /// Unless\a  yytable_ specifies something else to do.
 -    /// Zero means the default is an error.
 -    static const ]b4_int_type_for([b4_defact])[ yydefact_[];
 -
 -    static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
 -    static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
 -
 -    /// What to do in a state.
 -    /// \a yytable_[yypact_[s]]: what to do in state \a s.
 -    /// - if positive, shift that token.
 -    /// - if negative, reduce the rule which number is the opposite.
 -    /// - if zero, do what YYDEFACT says.
 -    static const ]b4_int_type_for([b4_table])[ yytable_[];
      static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
  
 -    static const ]b4_int_type_for([b4_check])[ yycheck_[];
 -
 -    /// For a state, its accessing symbol.
 -    static const ]b4_int_type_for([b4_stos])[ yystos_[];
 -
 -    /// For a rule, its LHS.
 -    static const ]b4_int_type_for([b4_r1])[ yyr1_[];
 -    /// For a rule, its RHS length.
 -    static const ]b4_int_type_for([b4_r2])[ yyr2_[]; ]b4_error_verbose_if([
 +    // 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_[];
- ]b4_token_table_if([[#if YYDEBUG]])[
+ ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
 -    /// A type to store symbol numbers and -1.
 -    typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type;
 -    /// A `-1'-separated list of the rules' RHS.
 -    static const rhs_number_type yyrhs_[];
 -    /// For each rule, the index of the first RHS symbol in \a yyrhs_.
 -    static const ]b4_int_type_for([b4_prhs])[ yyprhs_[];
 -    /// For each rule, its source line number.
 -    static const ]b4_int_type_for([b4_rline])[ yyrline_[];
 -    /// For each scanner token number, its symbol number.
 -    static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
 +]b4_integral_parser_table_declare([rline], [b4_rline],
 +     [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.
      virtual void yystack_print_ ();
  
 -    /* Debugging.  */
 +    // Debugging.
      int yydebug_;
      std::ostream* yycdebug_;
- #endif // YYDEBUG
 -#endif
++#endif // ]b4_api_PREFIX[DEBUG
  
      /// Convert a scanner token number \a t to a symbol number.
 -    token_number_type yytranslate_ (int t);
 +    static inline token_number_type yytranslate_ (]b4_lex_symbol_if([token_type], [int])[ t);
 +
- #if YYDEBUG
++#if ]b4_api_PREFIX[DEBUG
 +    /// \brief Display a symbol type, value and location.
 +    /// \param yyo    The output stream.
 +    /// \param yysym  The symbol.
 +    template <typename Exact>
 +    void yy_print_ (std::ostream& yyo,
 +                    const symbol_base_type<Exact>& yysym) const;
 +#endif
  
      /// \brief Reclaim the memory associated to a symbol.
 -    /// \param yymsg        Why this token is reclaimed.
 -    /// \param yytype       The symbol type.
 -    /// \param yyvaluep     Its semantic value.
 -    /// \param yylocationp  Its location.
 -    inline void yydestruct_ (const char* yymsg,
 -			     int yytype,
 -			     semantic_type* yyvaluep,
 -			     location_type* yylocationp);
 +    /// \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;
 +
 +  private:
 +    /// Element of the stack: a state and its attributes.
 +    struct stack_symbol_type : symbol_base_type<stack_symbol_type>
 +    {
 +      /// The parent class.
 +      typedef symbol_base_type<stack_symbol_type> super_type;
 +
 +      /// Default constructor.
 +      inline stack_symbol_type ();
 +
 +      /// Constructor.
 +      inline stack_symbol_type (]b4_args([state_type s],
 +                                         [const semantic_type& v],
 +                                         b4_locations_if([const location_type& l]))[);
 +
 +      /// The state.
 +      state_type state;
 +
 +      /// The type (corresponding to \a state).
 +      inline int type_get_ () const;
 +    };
 +
 +    /// Stack type.
 +    typedef stack<stack_symbol_type> stack_type;
 +
 +    /// The stack.
 +    stack_type yystack_;
 +
 +    /// Push a new state on the stack.
 +    /// \param m    a debug message to display
 +    ///             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);
 +
 +    /// 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);
  
      /* Constants.  */
 -    static const int yyeof_;
 -    /* LAST_ -- Last index in TABLE_.  */
 -    static const int yylast_;
 -    static const int yynnts_;
 -    static const int yyempty_;
 -    static const int yyfinal_;
 -    static const int yyterror_;
 -    static const int yyerrcode_;
 -    static const int yyntokens_;
 -    static const unsigned int yyuser_token_number_max_;
 -    static const token_number_type yyundef_token_;
 +    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.
 +      yyterror_ = 1,
 +      yyerrcode_ = 256,
 +      yyntokens_ = ]b4_tokens_number[    //< Number of tokens.
 +    };
 +
  ]b4_parse_param_vars[
    };
 +
 +]b4_lex_symbol_if([b4_yytranslate_define
 +b4_public_types_define])[
  ]b4_namespace_close[
  
  ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
@@@ -347,8 -264,10 +342,8 @@@
  ])[
  ]b4_percent_code_get([[provides]])[
  ]b4_cpp_guard_close([b4_spec_defines_file])
 -])dnl
  @output(b4_parser_file_name@)@
 -b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++],
 -             [2002-2012])
 +b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
  b4_percent_code_get([[top]])[]dnl
  m4_if(b4_prefix, [yy], [],
  [
@@@ -358,13 -277,16 +353,15 @@@
  /* First part of user declarations.  */
  ]b4_user_pre_prologue[
  
 -]b4_defines_if([[
 -#include "@basename(]b4_spec_defines_file[@)"]])[
 +#include "@basename(]b4_spec_defines_file[@)"
  
  /* User implementation prologue.  */
- ]b4_user_post_prologue
- b4_percent_code_get[]dnl
+ ]b4_user_post_prologue[
+ ]b4_percent_code_get[
+ 
+ ]b4_null_define[
  
- [#ifndef YY_
+ #ifndef YY_
  # if defined YYENABLE_NLS && YYENABLE_NLS
  #  if ENABLE_NLS
  #   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
@@@ -376,73 -298,55 +373,56 @@@
  # endif
  #endif
  
 -#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 -]b4_yylloc_default_define[
 +]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]])[
++[#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 YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
  
  /* 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;				\
 -    }							\
 -} while (false)
 -
 -# define YY_REDUCE_PRINT(Rule)		\
 -do {					\
 -  if (yydebug_)				\
 -    yy_reduce_print_ (Rule);		\
 -} while (false)
 -
 -# define YY_STACK_PRINT()		\
 -do {					\
 -  if (yydebug_)				\
 -    yystack_print_ ();			\
 -} while (false)
 +# 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)          \
 +  do {                                  \
 +    if (yydebug_)                       \
 +      yy_reduce_print_ (Rule);          \
 +  } while (false)
 +
 +# define YY_STACK_PRINT()               \
 +  do {                                  \
 +    if (yydebug_)                       \
 +      yystack_print_ ();                \
 +  } while (false)
  
- #else /* !YYDEBUG */
+ #else /* !]b4_api_PREFIX[DEBUG */
  
  # define YYCDEBUG if (false) std::cerr
 -# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 -# define YY_REDUCE_PRINT(Rule)
 -# define YY_STACK_PRINT()
 +# 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 yyclearin	(yychar = yyempty_)
 +#define yyerrok         (yyerrstatus_ = 0)
 +#define yyclearin       (yyempty = true)
  
 -#define YYACCEPT	goto yyacceptlab
 -#define YYABORT		goto yyabortlab
 -#define YYERROR		goto yyerrorlab
 +#define YYACCEPT        goto yyacceptlab
 +#define YYABORT         goto yyabortlab
 +#define YYERROR         goto yyerrorlab
  #define YYRECOVERING()  (!!yyerrstatus_)
  
  ]b4_namespace_open[]b4_error_verbose_if([[
@@@ -488,7 -392,7 +468,7 @@@
    /// 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[
@@@ -499,120 -403,68 +479,120 @@@
    {
    }
  
 -#if ]b4_api_PREFIX[DEBUG
 -  /*--------------------------------.
 -  | Print this symbol on YYOUTPUT.  |
 -  `--------------------------------*/
  
 -  inline void
 -  ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
 -			   const semantic_type* yyvaluep, const location_type* yylocationp)
 +  /*---------------.
 +  | Symbol types.  |
 +  `---------------*/
 +
 +]b4_lex_symbol_if([], [b4_public_types_define])[
 +
 +  // stack_symbol_type.
 +  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
 +    : super_type ()
 +    , state ()
 +  {
 +  }
 +
 +  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (]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)
 +  {
 +  }
 +
 +  int
 +  ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
 +  {
 +    return yystos_[state];
 +  }
 +
 +
 +  template <typename Exact>
 +  void
 +  ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
 +                                       symbol_base_type<Exact>& yysym) const
 +  {
 +    if (yymsg)
 +      YY_SYMBOL_PRINT (yymsg, yysym);
 +
 +    // 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]])])[
 +  }
 +
- #if YYDEBUG
++#if ]b4_api_PREFIX[DEBUG
 +  template <typename Exact>
 +  void
 +  ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
 +                                     const symbol_base_type<Exact>& yysym) const
    {
 -    YYUSE (yylocationp);
 -    YYUSE (yyvaluep);
 -    std::ostream& yyo = debug_stream ();
      std::ostream& yyoutput = yyo;
      YYUSE (yyoutput);
 +    int yytype = yysym.type_get ();
 +    yyo << (yytype < yyntokens_ ? "token" : "nterm")
 +        << ' ' << yytname_[yytype] << " ("]b4_locations_if([
 +        << yysym.location << ": "])[;
      switch (yytype)
        {
 -  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 +]b4_symbol_foreach([b4_symbol_printer])dnl
  [       default:
 -	  break;
 +          break;
        }
 +    yyo << ')';
    }
 -
 +#endif
  
    void
 -  ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
 -			   const semantic_type* yyvaluep, const location_type* yylocationp)
 +  ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
 +                                   symbol_type& sym)
    {
 -    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
 -	       << ' ' << yytname_[yytype] << " ("
 -	       << *yylocationp << ": ";
 -    yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
 -    *yycdebug_ << ')';
 +    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]))[));]])[
    }
 -#endif
  
    void
 -  ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
 -			   int yytype, semantic_type* yyvaluep, location_type* yylocationp)
 +  ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
    {
 -    YYUSE (yylocationp);
 -    YYUSE (yymsg);
 -    YYUSE (yyvaluep);
 -
 -    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 -
 -    switch (yytype)
 -      {
 -  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 -	default:
 -	  break;
 -      }
 +    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);])[
    }
  
    void
    ]b4_parser_class_name[::yypop_ (unsigned int n)
    {
 -    yystate_stack_.pop (n);
 -    yysemantic_stack_.pop (n);
 -    yylocation_stack_.pop (n);
 +    yystack_.pop (n);
    }
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
    std::ostream&
    ]b4_parser_class_name[::debug_stream () const
    {
@@@ -637,17 -489,7 +617,17 @@@
    {
      yydebug_ = l;
    }
- #endif // YYDEBUG
 -#endif
++#endif // ]b4_api_PREFIX[DEBUG
 +
 +  inline ]b4_parser_class_name[::state_type
 +  ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs)
 +  {
 +    int yyr = yypgoto_[yylhs - yyntokens_] + yystate;
 +    if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
 +      return yytable_[yyr];
 +    else
 +      return yydefgoto_[yylhs - yyntokens_];
 +  }
  
    inline bool
    ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue)
@@@ -664,52 -506,60 +644,52 @@@
    int
    ]b4_parser_class_name[::parse ()
    {
 -    /// Lookahead and lookahead in internal form.
 -    int yychar = yyempty_;
 -    int yytoken = 0;
 +    /// Whether yyla contains a lookahead.
 +    bool yyempty = true;
  
      /* State.  */
      int yyn;
      int yylen = 0;
 -    int yystate = 0;
  
      /* Error handling.  */
      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;]b4_locations_if([[
 +
      /// The locations where the error started and ended.
 -    location_type yyerror_range[3];
 +    stack_symbol_type yyerror_range[3];]])[
  
 -    /// $$.
 -    semantic_type yyval;
 -    /// @@$.
 -    location_type yyloc;
 +    /// $$ and @@$.
 +    stack_symbol_type yylhs;
  
 +    /// The return value of parse ().
      int yyresult;
  
      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
  m4_popdef([b4_at_dollar])])dnl
  
 -  [  /* Initialize the stacks.  The initial state will be pushed in
 +  [  /* 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.  */
 -    yystate_stack_ = state_stack_type (0);
 -    yysemantic_stack_ = semantic_stack_type (0);
 -    yylocation_stack_ = location_stack_type (0);
 -    yysemantic_stack_.push (yylval);
 -    yylocation_stack_.push (yylloc);
 +    yystack_ = stack_type (0);
 +    yypush_ (YY_NULL, 0, yyla);
  
 -    /* New state.  */
 +    // A new symbol was pushed on the stack.
    yynewstate:
 -    yystate_stack_.push (yystate);
 -    YYCDEBUG << "Entering state " << yystate << std::endl;
 +    YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
  
      /* Accept?  */
 -    if (yystate == yyfinal_)
 +    if (yystack_[0].state == yyfinal_)
        goto yyacceptlab;
  
      goto yybackup;
@@@ -718,66 -568,71 +698,66 @@@
    yybackup:
  
      /* Try to take a decision without lookahead.  */
 -    yyn = yypact_[yystate];
 +    yyn = yypact_[yystack_[0].state];
      if (yy_pact_value_is_default_ (yyn))
        goto yydefault;
  
      /* Read a lookahead token.  */
 -    if (yychar == yyempty_)
 -      {
 -	YYCDEBUG << "Reading a token: ";
 -	yychar = ]b4_c_function_call([yylex], [int],
 -				     [b4_api_PREFIX[STYPE*], [&yylval]][]dnl
 -b4_locations_if([, [[location*], [&yylloc]]])dnl
 -m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 -      }
 -
 -
 -    /* Convert token to internal form.  */
 -    if (yychar <= yyeof_)
 -      {
 -	yychar = yytoken = yyeof_;
 -	YYCDEBUG << "Now at end of input." << std::endl;
 -      }
 -    else
 +    if (yyempty)
        {
 -	yytoken = yytranslate_ (yychar);
 -	YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 +        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)));])[
 +        }
 +        catch (const syntax_error& yyexc)
 +        {
 +          error (yyexc);
 +          goto yyerrlab1;
 +        }
 +        yyempty = false;
        }
 +    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.  */
      yyn = yytable_[yyn];
      if (yyn <= 0)
        {
 -	if (yy_table_value_is_error_ (yyn))
 -	  goto yyerrlab;
 -	yyn = -yyn;
 -	goto yyreduce;
 +        if (yy_table_value_is_error_ (yyn))
 +          goto yyerrlab;
 +        yyn = -yyn;
 +        goto yyreduce;
        }
  
 -    /* Shift the lookahead token.  */
 -    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 -
      /* Discard the token being shifted.  */
 -    yychar = yyempty_;
 -
 -    yysemantic_stack_.push (yylval);
 -    yylocation_stack_.push (yylloc);
 +    yyempty = true;
  
      /* Count tokens shifted since error; after three, turn off error
         status.  */
      if (yyerrstatus_)
        --yyerrstatus_;
  
 -    yystate = yyn;
 +    /* Shift the lookahead token.  */
 +    yypush_ ("Shifting", yyn, yyla);
      goto yynewstate;
  
    /*-----------------------------------------------------------.
    | yydefault -- do the default action for the current state.  |
    `-----------------------------------------------------------*/
    yydefault:
 -    yyn = yydefact_[yystate];
 +    yyn = yydefact_[yystack_[0].state];
      if (yyn == 0)
        goto yyerrlab;
      goto yyreduce;
@@@ -787,97 -642,92 +767,97 @@@
    `-----------------------------*/
    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 YYVAL to garbage.
 +       Otherwise, the following line sets YYLHS.VALUE to garbage.
         This behavior is undocumented and Bison
         users should not rely upon it.  */
      if (yylen)
 -      yyval = yysemantic_stack_[yylen - 1];
 +      yylhs.value = yystack_@{yylen - 1@}.value;
      else
 -      yyval = yysemantic_stack_[0];
 -
 +      yylhs.value = yystack_@{0@}.value;])[
 +]b4_locations_if([dnl
 +[
 +    // Compute the default @@$.
      {
 -      slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
 -      YYLLOC_DEFAULT (yyloc, slice, yylen);
 -    }
 +      slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
 +      YYLLOC_DEFAULT (yylhs.location, slice, yylen);
 +    }]])[
 +
 +    // Perform the reduction.
      YY_REDUCE_PRINT (yyn);
 -    switch (yyn)
 +    try
 +    {
 +      switch (yyn)
        {
 -	]b4_user_actions[
 -	default:
 +]b4_user_actions[
 +        default:
            break;
        }
 -    /* User semantic actions sometimes alter yychar, and that requires
 -       that yytoken be updated with the new translation.  We take the
 -       approach of translating immediately before every use of yytoken.
 -       One alternative is translating here after every semantic action,
 -       but that translation would be missed if the semantic action
 -       invokes YYABORT, YYACCEPT, or YYERROR immediately after altering
 -       yychar.  In the case of YYABORT or YYACCEPT, an incorrect
 -       destructor might then be invoked immediately.  In the case of
 -       YYERROR, subsequent parser actions might lead to an incorrect
 -       destructor call or verbose syntax error message before the
 -       lookahead is translated.  */
 -    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
 +    }
 +    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 ();
  
 -    yysemantic_stack_.push (yyval);
 -    yylocation_stack_.push (yyloc);
 -
      /* Shift the result of the reduction.  */
 -    yyn = yyr1_[yyn];
 -    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
 -    if (0 <= yystate && yystate <= yylast_
 -	&& yycheck_[yystate] == yystate_stack_[0])
 -      yystate = yytable_[yystate];
 -    else
 -      yystate = yydefgoto_[yyn - yyntokens_];
 +    yypush_ (YY_NULL, yylhs);
      goto yynewstate;
  
 -  /*------------------------------------.
 -  | yyerrlab -- here on detecting error |
 -  `------------------------------------*/
 +  /*--------------------------------------.
 +  | yyerrlab -- here on detecting error.  |
 +  `--------------------------------------*/
    yyerrlab:
 -    /* Make sure we have latest lookahead translation.  See comments at
 -       user semantic actions for why this is necessary.  */
 -    yytoken = yytranslate_ (yychar);
 -
      /* If not already recovering from an error, report this error.  */
      if (!yyerrstatus_)
        {
 -	++yynerrs_;
 -	if (yychar == yyempty_)
 -	  yytoken = yyempty_;
 -	error (yylloc, yysyntax_error_ (yystate, yytoken));
 +        ++yynerrs_;
 +        error (]b4_args(b4_locations_if([yyla.location]),
 +                        [[yysyntax_error_ (yystack_[0].state,
 +                                           yyempty ? yyempty_ : yyla.type)]])[);
        }
  
 -    yyerror_range[1] = yylloc;
 +]b4_locations_if([[
 +    yyerror_range[1].location = yyla.location;]])[
      if (yyerrstatus_ == 3)
        {
 -	/* If just tried and failed to reuse lookahead token after an
 -	 error, discard it.  */
 -
 -	if (yychar <= yyeof_)
 -	  {
 -	  /* Return failure if at end of input.  */
 -	  if (yychar == yyeof_)
 -	    YYABORT;
 -	  }
 -	else
 -	  {
 -	    yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
 -	    yychar = yyempty_;
 -	  }
 +        /* 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_)
 +          YYABORT;
 +        else if (!yyempty)
 +          {
 +            yy_destroy_ ("Error: discarding", yyla);
 +            yyempty = true;
 +          }
        }
  
      /* Else will try to reuse lookahead token after shifting the error
@@@ -894,54 -744,61 +874,54 @@@
         YYERROR and the label yyerrorlab therefore never appears in user
         code.  */
      if (false)
 -      goto yyerrorlab;
 -
 -    yyerror_range[1] = yylocation_stack_[yylen - 1];
 +      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
         this YYERROR.  */
      yypop_ (yylen);
      yylen = 0;
 -    yystate = yystate_stack_[0];
      goto yyerrlab1;
  
    /*-------------------------------------------------------------.
    | yyerrlab1 -- common code for both syntax error and YYERROR.  |
    `-------------------------------------------------------------*/
    yyerrlab1:
 -    yyerrstatus_ = 3;	/* Each real token shifted decrements this.  */
 -
 -    for (;;)
 -      {
 -	yyn = yypact_[yystate];
 -	if (!yy_pact_value_is_default_ (yyn))
 -	{
 -	  yyn += yyterror_;
 -	  if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
 -	    {
 -	      yyn = yytable_[yyn];
 -	      if (0 < yyn)
 -		break;
 -	    }
 -	}
 -
 -	/* Pop the current state because it cannot handle the error token.  */
 -	if (yystate_stack_.height () == 1)
 -	YYABORT;
 -
 -	yyerror_range[1] = yylocation_stack_[0];
 -	yydestruct_ ("Error: popping",
 -		     yystos_[yystate],
 -		     &yysemantic_stack_[0], &yylocation_stack_[0]);
 -	yypop_ ();
 -	yystate = yystate_stack_[0];
 -	YY_STACK_PRINT ();
 -      }
 -
 -    yyerror_range[2] = yylloc;
 -    // Using YYLLOC is tempting, but would change the location of
 -    // the lookahead.  YYLOC is available though.
 -    YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
 -    yysemantic_stack_.push (yylval);
 -    yylocation_stack_.push (yyloc);
 +    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
 +    {
 +      stack_symbol_type error_token;
 +      for (;;)
 +        {
 +          yyn = yypact_[yystack_[0].state];
 +          if (!yy_pact_value_is_default_ (yyn))
 +            {
 +              yyn += yyterror_;
 +              if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
 +                {
 +                  yyn = yytable_[yyn];
 +                  if (0 < yyn)
 +                    break;
 +                }
 +            }
  
 -    /* Shift the error token.  */
 -    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
 -		     &yysemantic_stack_[0], &yylocation_stack_[0]);
 +          // Pop the current state because it cannot handle the error token.
 +          if (yystack_.size () == 1)
 +            YYABORT;
 +]b4_locations_if([[
 +          yyerror_range[1].location = yystack_[0].location;]])[
 +          yy_destroy_ ("Error: popping", yystack_[0]);
 +          yypop_ ();
 +          YY_STACK_PRINT ();
 +        }
 +]b4_locations_if([[
 +      yyerror_range[2].location = yyla.location;
 +      YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[
  
 -    yystate = yyn;
 +      /* Shift the error token.  */
 +      error_token.state = yyn;
 +      yypush_ ("Shifting", error_token);
 +    }
      goto yynewstate;
  
      /* Accept.  */
@@@ -955,32 -812,34 +935,32 @@@
      goto yyreturn;
  
    yyreturn:
 -    if (yychar != yyempty_)
 -      {
 -        /* Make sure we have latest lookahead translation.  See comments
 -           at user semantic actions for why this is necessary.  */
 -        yytoken = yytranslate_ (yychar);
 -        yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
 -                     &yylloc);
 -      }
 +    if (!yyempty)
 +      yy_destroy_ ("Cleanup: discarding lookahead", yyla);
  
      /* Do not reclaim the symbols of the rule which action triggered
         this YYABORT or YYACCEPT.  */
      yypop_ (yylen);
 -    while (yystate_stack_.height () != 1)
 +    while (yystack_.size () != 1)
        {
 -	yydestruct_ ("Cleanup: popping",
 -		   yystos_[yystate_stack_[0]],
 -		   &yysemantic_stack_[0],
 -		   &yylocation_stack_[0]);
 -	yypop_ ();
 +        yy_destroy_ ("Cleanup: popping", yystack_[0]);
 +        yypop_ ();
        }
  
      return yyresult;
    }
  
 +  void
 +  ]b4_parser_class_name[::error (const syntax_error& yyexc)
 +  {
 +    error (]b4_args(b4_locations_if([yyexc.location]),
 +                    [[yyexc.what()]])[);
 +  }
 +
    // Generate an error message.
    std::string
    ]b4_parser_class_name[::yysyntax_error_ (]dnl
 -b4_error_verbose_if([int yystate, int yytoken],
 +b4_error_verbose_if([state_type yystate, int yytoken],
                      [int, int])[)
    {]b4_error_verbose_if([[
      std::string yyres;
@@@ -1006,7 -865,7 +986,7 @@@
           a consistent state with a default action.  There might have
           been a previous inconsistent state, consistent state with a
           non-default action, or user semantic action that manipulated
 -         yychar.
 +         yyla.  (However, yyla is currently not documented for users.)
         - Of course, the expected token list depends on states to have
           correct lookahead information, and it depends on the parser not
           to perform extra reductions after fetching a lookahead from the
@@@ -1076,34 -935,127 +1056,34 @@@
    }
  
  
 -  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 -     STATE-NUM.  */
    const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
 -  const ]b4_int_type_for([b4_pact])[
 -  ]b4_parser_class_name[::yypact_[] =
 -  {
 -    ]b4_pact[
 -  };
 -
 -  /* YYDEFACT[S] -- default reduction number in state S.  Performed when
 -     YYTABLE doesn't specify something else to do.  Zero means the
 -     default is an error.  */
 -  const ]b4_int_type_for([b4_defact])[
 -  ]b4_parser_class_name[::yydefact_[] =
 -  {
 -    ]b4_defact[
 -  };
 -
 -  /* YYPGOTO[NTERM-NUM].  */
 -  const ]b4_int_type_for([b4_pgoto])[
 -  ]b4_parser_class_name[::yypgoto_[] =
 -  {
 -    ]b4_pgoto[
 -  };
 -
 -  /* YYDEFGOTO[NTERM-NUM].  */
 -  const ]b4_int_type_for([b4_defgoto])[
 -  ]b4_parser_class_name[::yydefgoto_[] =
 -  {
 -    ]b4_defgoto[
 -  };
  
 -  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 -     positive, shift that token.  If negative, reduce the rule which
 -     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
    const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
 -  const ]b4_int_type_for([b4_table])[
 -  ]b4_parser_class_name[::yytable_[] =
 -  {
 -    ]b4_table[
 -  };
 -
 -  /* YYCHECK.  */
 -  const ]b4_int_type_for([b4_check])[
 -  ]b4_parser_class_name[::yycheck_[] =
 -  {
 -    ]b4_check[
 -  };
  
 -  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
 -     symbol of state STATE-NUM.  */
 -  const ]b4_int_type_for([b4_stos])[
 -  ]b4_parser_class_name[::yystos_[] =
 -  {
 -    ]b4_stos[
 -  };
 -
 -#if ]b4_api_PREFIX[DEBUG
 -  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
 -     to YYLEX-NUM.  */
 -  const ]b4_int_type_for([b4_toknum])[
 -  ]b4_parser_class_name[::yytoken_number_[] =
 -  {
 -    ]b4_toknum[
 -  };
 -#endif
 -
 -  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 -  const ]b4_int_type_for([b4_r1])[
 -  ]b4_parser_class_name[::yyr1_[] =
 -  {
 -    ]b4_r1[
 -  };
 -
 -  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 -  const ]b4_int_type_for([b4_r2])[
 -  ]b4_parser_class_name[::yyr2_[] =
 -  {
 -    ]b4_r2[
 -  };
 +]b4_parser_tables_define[
  
- ]b4_token_table_if([], [[#if YYDEBUG]])[
+ ]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[
 +  ]b4_tname[
    };
  
- ]b4_token_table_if([[#if YYDEBUG]])[
+ ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
 -  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 -  const ]b4_parser_class_name[::rhs_number_type
 -  ]b4_parser_class_name[::yyrhs_[] =
 -  {
 -    ]b4_rhs[
 -  };
 -
 -  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 -     YYRHS.  */
 -  const ]b4_int_type_for([b4_prhs])[
 -  ]b4_parser_class_name[::yyprhs_[] =
 -  {
 -    ]b4_prhs[
 -  };
 -
 -  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 -  const ]b4_int_type_for([b4_rline])[
 -  ]b4_parser_class_name[::yyrline_[] =
 -  {
 -    ]b4_rline[
 -  };
 +]b4_integral_parser_table_define([rline], [b4_rline])[
  
    // Print the state stack on the debug stream.
    void
    ]b4_parser_class_name[::yystack_print_ ()
    {
      *yycdebug_ << "Stack now";
 -    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
 -	 i != yystate_stack_.end (); ++i)
 -      *yycdebug_ << ' ' << *i;
 +    for (stack_type::const_iterator
 +           i = yystack_.begin (),
 +           i_end = yystack_.end ();
 +         i != i_end; ++i)
 +      *yycdebug_ << ' ' << i->state;
      *yycdebug_ << std::endl;
    }
  
@@@ -1115,16 -1067,44 +1095,16 @@@
      int yynrhs = yyr2_[yyrule];
      /* Print the symbols being reduced, and their result.  */
      *yycdebug_ << "Reducing stack by rule " << yyrule - 1
 -	       << " (line " << yylno << "):" << std::endl;
 +               << " (line " << yylno << "):" << std::endl;
      /* The symbols being reduced.  */
      for (int yyi = 0; yyi < yynrhs; yyi++)
        YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
 -		       yyrhs_[yyprhs_[yyrule] + yyi],
 -		       &]b4_rhs_value(yynrhs, yyi + 1)[,
 -		       &]b4_rhs_location(yynrhs, yyi + 1)[);
 +                       ]b4_rhs_data(yynrhs, yyi + 1)[);
    }
- #endif // YYDEBUG
+ #endif // ]b4_api_PREFIX[DEBUG
  
 -  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 -  ]b4_parser_class_name[::token_number_type
 -  ]b4_parser_class_name[::yytranslate_ (int t)
 -  {
 -    static
 -    const token_number_type
 -    translate_table[] =
 -    {
 -      ]b4_translate[
 -    };
 -    if ((unsigned int) t <= yyuser_token_number_max_)
 -      return translate_table[t];
 -    else
 -      return yyundef_token_;
 -  }
 -
 -  const int ]b4_parser_class_name[::yyeof_ = 0;
 -  const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
 -  const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
 -  const int ]b4_parser_class_name[::yyempty_ = -2;
 -  const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
 -  const int ]b4_parser_class_name[::yyterror_ = 1;
 -  const int ]b4_parser_class_name[::yyerrcode_ = 256;
 -  const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
 -
 -  const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
 -  const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
 -
 +]b4_lex_symbol_if([], [b4_yytranslate_define])[
  ]b4_namespace_close[
 -]b4_epilogue
 +]b4_epilogue[]dnl
  m4_divert_pop(0)
 +m4_popdef([b4_copyright_years])dnl
diff --combined data/location.cc
index 976fc34b,b7383d65..cfbfd76b
--- a/data/location.cc
+++ b/data/location.cc
@@@ -1,6 -1,6 +1,6 @@@
  # C++ skeleton for Bison
  
 -# Copyright (C) 2002-2007, 2009-2012 Free Software Foundation, Inc.
 +# Copyright (C) 2002-2012 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
@@@ -15,14 -15,12 +15,14 @@@
  # You should have received a copy of the GNU General Public License
  # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  
 +m4_pushdef([b4_copyright_years],
 +           [2002-2012])
 +
  # We do want M4 expansion after # for CPP macros.
  m4_changecom()
  m4_divert_push(0)dnl
  @output(b4_dir_prefix[]position.hh@)@
 -b4_copyright([Positions for Bison parsers in C++],
 -             [2002-2007, 2009-2012])[
 +b4_copyright([Positions for Bison parsers in C++])[
  
  /**
   ** \file ]b4_dir_prefix[position.hh
@@@ -31,9 -29,9 +31,9 @@@
  
  ]b4_cpp_guard_open([b4_dir_prefix[]position.hh])[
  
- # include <iostream>
+ # include <algorithm> // std::max
+ # include <iosfwd>
  # include <string>
- # include <algorithm>
  
  ]b4_null_define[
  
@@@ -151,7 -149,8 +151,7 @@@
  ]b4_namespace_close[
  ]b4_cpp_guard_close([b4_dir_prefix[]position.hh])
  @output(b4_dir_prefix[]location.hh@)@
 -b4_copyright([Locations for Bison parsers in C++],
 -             [2002-2007, 2009-2012])[
 +b4_copyright([Locations for Bison parsers in C++])[
  
  /**
   ** \file ]b4_dir_prefix[location.hh
@@@ -282,8 -281,8 +282,8 @@@
      position last = loc.end - 1;
      ostr << loc.begin;
      if (last.filename
 -	&& (!loc.begin.filename
 -	    || *loc.begin.filename != *last.filename))
 +        && (!loc.begin.filename
 +            || *loc.begin.filename != *last.filename))
        ostr << '-' << last;
      else if (loc.begin.line != last.line)
        ostr << '-' << last.line  << '.' << last.column;
@@@ -296,5 -295,4 +296,5 @@@
  
  ]b4_cpp_guard_close([b4_dir_prefix[]location.hh])
  m4_divert_pop(0)
 +m4_popdef([b4_copyright_years])dnl
  m4_changecom([#])
diff --combined data/yacc.c
index 7e51b56f,2e46a1e2..a98c4ed9
--- a/data/yacc.c
+++ b/data/yacc.c
@@@ -1,12 -1,10 +1,12 @@@
                                                               -*- C -*-
 -
  # Yacc compatible skeleton for Bison
  
  # Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation,
  # Inc.
  
 +m4_pushdef([b4_copyright_years],
 +           [1984, 1989-1990, 2000-2012])
 +
  # 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
  # the Free Software Foundation, either version 3 of the License, or
@@@ -76,8 -74,8 +76,8 @@@ m4_define([b4_pure_flag]
  # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
  m4_define([b4_yacc_pure_if],
  [b4_pure_if([m4_ifset([b4_parse_param],
 -		      [$1], [$2])],
 -	    [$2])])
 +                      [$1], [$2])],
 +            [$2])])
  
  
  # b4_yyerror_args
@@@ -117,7 -115,7 +117,7 @@@ m4_define([b4_int_type]
  
         m4_eval([0 <= $1]),                [1], [unsigned int],
  
 -					       [int])])
 +                                               [int])])
  
  
  ## ----------------- ##
@@@ -129,7 -127,7 +129,7 @@@
  # --------------------
  # Expansion of $<TYPE>$.
  m4_define([b4_lhs_value],
 -[(yyval[]m4_ifval([$1], [.$1]))])
 +[b4_symbol_value(yyval, [$1])])
  
  
  # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
@@@ -137,7 -135,7 +137,7 @@@
  # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  # symbols on RHS.
  m4_define([b4_rhs_value],
 -[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
 +          [b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3])])
  
  
  
@@@ -157,7 -155,7 +157,7 @@@ m4_define([b4_lhs_location]
  # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  # on RHS.
  m4_define([b4_rhs_location],
 -[(yylsp@{($2) - ($1)@})])
 +          [(yylsp@{b4_subtract([$2], [$1])@})])
  
  
  ## -------------- ##
@@@ -294,7 -292,8 +294,7 @@@ m4_define([b4_shared_declarations]
  m4_changecom()
  m4_divert_push(0)dnl
  @output(b4_parser_file_name@)@
 -b4_copyright([Bison implementation for Yacc-like parsers in C],
 -             [1984, 1989-1990, 2000-2012])[
 +b4_copyright([Bison implementation for Yacc-like parsers in C])[
  
  /* C LALR(1) parser skeleton written by Richard Stallman, by
     simplifying the original so-called "semantic" parser.  */
@@@ -310,12 -309,8 +310,8 @@@
  b4_percent_code_get([[top]])[]dnl
  m4_if(b4_api_prefix, [yy], [],
  [[/* Substitute the type names.  */
- #define YYSTYPE              ]b4_api_PREFIX[STYPE
- #define YYSTYPE_IS_TRIVIAL   ]b4_api_PREFIX[STYPE_IS_TRIVIAL
- #define YYSTYPE_IS_DECLARED  ]b4_api_PREFIX[STYPE_IS_DECLARED]b4_locations_if([[
- #define YYLTYPE              ]b4_api_PREFIX[LTYPE
- #define YYLTYPE_IS_TRIVIAL   ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
- #define YYLTYPE_IS_DECLARED  ]b4_api_PREFIX[LTYPE_IS_DECLARED]])])[
+ #define YYSTYPE         ]b4_api_PREFIX[STYPE]b4_locations_if([[
+ #define YYLTYPE         ]b4_api_PREFIX[LTYPE]])])[
  ]m4_if(b4_prefix, [yy], [],
  [[/* Substitute the variable and function names.  */]b4_pull_if([[
  #define yyparse         ]b4_prefix[parse]])b4_push_if([[
@@@ -342,7 -337,7 +338,7 @@@
  # undef YYERROR_VERBOSE
  # define YYERROR_VERBOSE 1
  #else
 -# define YYERROR_VERBOSE ]b4_error_verbose_flag[
 +# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
  #endif
  
  /* In a future release of Bison, this section will be replaced
@@@ -474,7 -469,7 +470,7 @@@ b4_push_if([], [b4_lac_if([], [
  #  endif
  #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
         && ! ((defined YYMALLOC || defined malloc) \
 -	     && (defined YYFREE || defined free)))
 +             && (defined YYFREE || defined free)))
  #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
  #   ifndef EXIT_SUCCESS
  #    define EXIT_SUCCESS 0
@@@ -499,8 -494,8 +495,8 @@@ void free (void *); /* INFRINGES ON USE
  
  #if (! defined yyoverflow \
       && (! defined __cplusplus \
-          || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
-              && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 -	 || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \
 -	     && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL)))
++         || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \
++             && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL)))
  
  /* A type that is properly aligned for any stack member.  */
  union yyalloc
@@@ -530,15 -525,15 +526,15 @@@
     elements in the stack, and YYPTR gives the new location of the
     stack.  Advance YYPTR to a properly aligned location for the next
     stack.  */
 -# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
 -    do									\
 -      {									\
 -	YYSIZE_T yynewbytes;						\
 -	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
 -	Stack = &yyptr->Stack_alloc;					\
 -	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 -	yyptr += yynewbytes / sizeof (*yyptr);				\
 -      }									\
 +# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 +    do                                                                  \
 +      {                                                                 \
 +        YYSIZE_T yynewbytes;                                            \
 +        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 +        Stack = &yyptr->Stack_alloc;                                    \
 +        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 +        yyptr += yynewbytes / sizeof (*yyptr);                          \
 +      }                                                                 \
      while (YYID (0))
  
  #endif
@@@ -574,30 -569,44 +570,30 @@@
  #define YYNNTS  ]b4_nterms_number[
  /* YYNRULES -- Number of rules.  */
  #define YYNRULES  ]b4_rules_number[
 -/* YYNRULES -- Number of states.  */
 +/* YYNSTATES -- Number of states.  */
  #define YYNSTATES  ]b4_states_number[
  
 -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 +/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
 +   by yylex, with out-of-bounds checking.  */
  #define YYUNDEFTOK  ]b4_undef_token_number[
  #define YYMAXUTOK   ]b4_user_token_number_max[
  
 -#define YYTRANSLATE(YYX)						\
 +#define YYTRANSLATE(YYX)                                                \
    ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
  
 -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
 +   as returned by yylex, without out-of-bounds checking.  */
  static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
  {
    ]b4_translate[
  };
  
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
 -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 -   YYRHS.  */
 -static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
 -{
 -  ]b4_prhs[
 -};
 -
 -/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 -static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
 -{
 -  ]b4_rhs[
 -};
 -
 -/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 -static const ]b4_int_type_for([b4_rline])[ yyrline[] =
 -{
 -  ]b4_rline[
 -};
 +]b4_integral_parser_table_define([rline], [b4_rline],
 +     [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
  #endif
  
- #if YYDEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
+ #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
  static const char *const yytname[] =
@@@ -607,34 -616,89 +603,34 @@@
  #endif
  
  # ifdef YYPRINT
 -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 -   token YYLEX-NUM.  */
 +/* YYTOKNUM[NUM] -- (External) token number corresponding to the
 +   (internal) symbol number NUM (which must be that of a token).  */
  static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
  {
    ]b4_toknum[
  };
  # endif
  
 -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 -static const ]b4_int_type_for([b4_r1])[ yyr1[] =
 -{
 -  ]b4_r1[
 -};
 -
 -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 -static const ]b4_int_type_for([b4_r2])[ yyr2[] =
 -{
 -  ]b4_r2[
 -};
 -
 -/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
 -   Performed when YYTABLE doesn't specify something else to do.  Zero
 -   means the default is an error.  */
 -static const ]b4_int_type_for([b4_defact])[ yydefact[] =
 -{
 -  ]b4_defact[
 -};
 -
 -/* YYDEFGOTO[NTERM-NUM].  */
 -static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
 -{
 -  ]b4_defgoto[
 -};
 -
 -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 -   STATE-NUM.  */
  #define YYPACT_NINF ]b4_pact_ninf[
 -static const ]b4_int_type_for([b4_pact])[ yypact[] =
 -{
 -  ]b4_pact[
 -};
 -
 -/* YYPGOTO[NTERM-NUM].  */
 -static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
 -{
 -  ]b4_pgoto[
 -};
 -
 -/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 -   positive, shift that token.  If negative, reduce the rule which
 -   number is the opposite.  If YYTABLE_NINF, syntax error.  */
 -#define YYTABLE_NINF ]b4_table_ninf[
 -static const ]b4_int_type_for([b4_table])[ yytable[] =
 -{
 -  ]b4_table[
 -};
  
  #define yypact_value_is_default(yystate) \
    ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
  
 +#define YYTABLE_NINF ]b4_table_ninf[
 +
  #define yytable_value_is_error(yytable_value) \
    ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
  
 -static const ]b4_int_type_for([b4_check])[ yycheck[] =
 -{
 -  ]b4_check[
 -};
 -
 -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 -   symbol of state STATE-NUM.  */
 -static const ]b4_int_type_for([b4_stos])[ yystos[] =
 -{
 -  ]b4_stos[
 -};
 +]b4_parser_tables_define[
  
 -#define yyerrok		(yyerrstatus = 0)
 -#define yyclearin	(yychar = YYEMPTY)
 -#define YYEMPTY		(-2)
 -#define YYEOF		0
 +#define yyerrok         (yyerrstatus = 0)
 +#define yyclearin       (yychar = YYEMPTY)
 +#define YYEMPTY         (-2)
 +#define YYEOF           0
  
 -#define YYACCEPT	goto yyacceptlab
 -#define YYABORT		goto yyabortlab
 -#define YYERROR		goto yyerrorlab
 +#define YYACCEPT        goto yyacceptlab
 +#define YYABORT         goto yyabortlab
 +#define YYERROR         goto yyerrorlab
  
  
  /* Like YYERROR except do call yyerror.  This remains here temporarily
@@@ -644,7 -708,7 +640,7 @@@
     in Bison 2.4.2's NEWS entry, where a plan to phase it out is
     discussed.  */
  
 -#define YYFAIL		goto yyerrlab
 +#define YYFAIL          goto yyerrlab
  #if defined YYFAIL
    /* This is here to suppress warnings from the GCC cpp's
       -Wunused-macros.  Normally we don't worry about that warning, but
@@@ -668,51 -732,29 +664,28 @@@ d
    else                                                          \
      {                                                           \
        yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
 -      YYERROR;							\
 -    }								\
 +      YYERROR;                                                  \
 +    }                                                           \
  while (YYID (0))
  
  
 -#define YYTERROR	1
 -#define YYERRCODE	256
 +#define YYTERROR        1
 +#define YYERRCODE       256
  
- 
- /* 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).  */
- 
++]b4_locations_if([[
+ ]b4_yylloc_default_define[
  #define YYRHSLOC(Rhs, K) ((Rhs)[K])
- #ifndef YYLLOC_DEFAULT
- # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
-     do                                                                  \
-       if (YYID (N))                                                    \
-         {                                                               \
-           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
-           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
-           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
-           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
-         }                                                               \
-       else                                                              \
-         {                                                               \
-           (Current).first_line   = (Current).last_line   =              \
-             YYRHSLOC (Rhs, 0).last_line;                                \
-           (Current).first_column = (Current).last_column =              \
-             YYRHSLOC (Rhs, 0).last_column;                              \
-         }                                                               \
-     while (YYID (0))
- #endif]b4_locations_if([[
 -]b4_locations_if([[
--
  
  /* YY_LOCATION_PRINT -- Print the location on the stream.
     This macro was not mandated originally: define only if we know
     we won't break user code: when these are the locations we know.  */
  
  #ifndef YY_LOCATION_PRINT
- # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+ # if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
 -#  define YY_LOCATION_PRINT(File, Loc)			\
 -     fprintf (File, "%d.%d-%d.%d",			\
 -	      (Loc).first_line, (Loc).first_column,	\
 -	      (Loc).last_line,  (Loc).last_column)
 +#  define YY_LOCATION_PRINT(File, Loc)                  \
 +     fprintf (File, "%d.%d-%d.%d",                      \
 +              (Loc).first_line, (Loc).first_column,     \
 +              (Loc).last_line,  (Loc).last_column)
  # else
  #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
  # endif
@@@ -735,28 -777,28 +708,28 @@@
  #endif
  
  /* Enable debugging if requested.  */
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
  
  # ifndef YYFPRINTF
  #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
  #  define YYFPRINTF fprintf
  # endif
  
 -# define YYDPRINTF(Args)			\
 -do {						\
 -  if (yydebug)					\
 -    YYFPRINTF Args;				\
 +# define YYDPRINTF(Args)                        \
 +do {                                            \
 +  if (yydebug)                                  \
 +    YYFPRINTF Args;                             \
  } while (YYID (0))
  
 -# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
 -do {									  \
 -  if (yydebug)								  \
 -    {									  \
 -      YYFPRINTF (stderr, "%s ", Title);					  \
 -      yy_symbol_print (stderr,						  \
 -		  Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
 -      YYFPRINTF (stderr, "\n");						  \
 -    }									  \
 +# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 +do {                                                                      \
 +  if (yydebug)                                                            \
 +    {                                                                     \
 +      YYFPRINTF (stderr, "%s ", Title);                                   \
 +      yy_symbol_print (stderr,                                            \
 +                  Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
 +      YYFPRINTF (stderr, "\n");                                           \
 +    }                                                                     \
  } while (YYID (0))
  
  ]b4_yy_symbol_print_generate([b4_c_function_def])[
@@@ -767,8 -809,8 +740,8 @@@
  `------------------------------------------------------------------*/
  
  ]b4_c_function_def([yy_stack_print], [static void],
 -		   [[yytype_int16 *yybottom], [yybottom]],
 -		   [[yytype_int16 *yytop],    [yytop]])[
 +                   [[yytype_int16 *yybottom], [yybottom]],
 +                   [[yytype_int16 *yytop],    [yytop]])[
  {
    YYFPRINTF (stderr, "Stack now");
    for (; yybottom <= yytop; yybottom++)
@@@ -779,10 -821,10 +752,10 @@@
    YYFPRINTF (stderr, "\n");
  }
  
 -# define YY_STACK_PRINT(Bottom, Top)				\
 -do {								\
 -  if (yydebug)							\
 -    yy_stack_print ((Bottom), (Top));				\
 +# define YY_STACK_PRINT(Bottom, Top)                            \
 +do {                                                            \
 +  if (yydebug)                                                  \
 +    yy_stack_print ((Bottom), (Top));                           \
  } while (YYID (0))
  
  
@@@ -791,49 -833,47 +764,49 @@@
  `------------------------------------------------*/
  
  ]b4_c_function_def([yy_reduce_print], [static void],
 -		   [[YYSTYPE *yyvsp], [yyvsp]],
 +                   [[yytype_int16 *yyssp], [yyssp]],
 +                   [[YYSTYPE *yyvsp], [yyvsp]],
      b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
 -		   ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
 -		   b4_parse_param]))[
 +                   ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
 +                   b4_parse_param]))[
  {
 +  unsigned long int yylno = yyrline[yyrule];
    int yynrhs = yyr2[yyrule];
    int yyi;
 -  unsigned long int yylno = yyrline[yyrule];
    YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 -	     yyrule - 1, yylno);
 +             yyrule - 1, yylno);
    /* The symbols being reduced.  */
    for (yyi = 0; yyi < yynrhs; yyi++)
      {
        YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 -      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 -		       &]b4_rhs_value(yynrhs, yyi + 1)[
 -		       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
 -		       b4_user_args[);
 +      yy_symbol_print (stderr,
 +                       yystos[yyssp[yyi + 1 - yynrhs]],
 +                       &]b4_rhs_value(yynrhs, yyi + 1)[
 +                       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
 +                       b4_user_args[);
        YYFPRINTF (stderr, "\n");
      }
  }
  
 -# define YY_REDUCE_PRINT(Rule)		\
 -do {					\
 -  if (yydebug)				\
 -    yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
 +# define YY_REDUCE_PRINT(Rule)          \
 +do {                                    \
 +  if (yydebug)                          \
 +    yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
  } while (YYID (0))
  
  /* Nonzero means print parse trace.  It is left uninitialized so that
     multiple parsers can coexist.  */
  int yydebug;
- #else /* !YYDEBUG */
+ #else /* !]b4_api_PREFIX[DEBUG */
  # define YYDPRINTF(Args)
  # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
  # define YY_STACK_PRINT(Bottom, Top)
  # define YY_REDUCE_PRINT(Rule)
- #endif /* !YYDEBUG */
+ #endif /* !]b4_api_PREFIX[DEBUG */
  
  
  /* YYINITDEPTH -- initial size of the parser's stacks.  */
 -#ifndef	YYINITDEPTH
 +#ifndef YYINITDEPTH
  # define YYINITDEPTH ]b4_stack_depth_init[
  #endif
  
@@@ -860,7 -900,7 +833,7 @@@
     required.  Return 1 if memory is exhausted.  */
  static int
  yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd,
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
                        char const *yydebug_prefix,
                        char const *yydebug_suffix,
  #endif
@@@ -966,7 -1006,7 +939,7 @@@ do 
     the parser stacks to try to find a new initial context in which the
     current lookahead is syntactically acceptable.  If it fails to find
     such a context, it discards the lookahead.  */
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
  # define YY_LAC_DISCARD(Event)                                           \
  do {                                                                     \
    if (yy_lac_established)                                                \
@@@ -1069,7 -1109,7 +1042,7 @@@ yy_lac (yytype_int16 *yyesa, yytype_int
          else
            {
              if (yy_lac_stack_realloc (yyes_capacity, 1,
- #if YYDEBUG
+ #if ]b4_api_PREFIX[DEBUG
                                        " (", ")",
  #endif
                                        yyes, yyesa, &yyesp, yyes_prev))
@@@ -1140,27 -1180,27 +1113,27 @@@ yytnamerr (char *yyres, const char *yys
        char const *yyp = yystr;
  
        for (;;)
 -	switch (*++yyp)
 -	  {
 -	  case '\'':
 -	  case ',':
 -	    goto do_not_strip_quotes;
 -
 -	  case '\\':
 -	    if (*++yyp != '\\')
 -	      goto do_not_strip_quotes;
 -	    /* Fall through.  */
 -	  default:
 -	    if (yyres)
 -	      yyres[yyn] = *yyp;
 -	    yyn++;
 -	    break;
 -
 -	  case '"':
 -	    if (yyres)
 -	      yyres[yyn] = '\0';
 -	    return yyn;
 -	  }
 +        switch (*++yyp)
 +          {
 +          case '\'':
 +          case ',':
 +            goto do_not_strip_quotes;
 +
 +          case '\\':
 +            if (*++yyp != '\\')
 +              goto do_not_strip_quotes;
 +            /* Fall through.  */
 +          default:
 +            if (yyres)
 +              yyres[yyn] = *yyp;
 +            yyn++;
 +            break;
 +
 +          case '"':
 +            if (yyres)
 +              yyres[yyn] = '\0';
 +            return yyn;
 +          }
      do_not_strip_quotes: ;
      }
  
@@@ -1276,7 -1316,7 +1249,7 @@@ yysyntax_error (YYSIZE_T *yymsg_alloc, 
                  yysize = yysize1;
                }
          }]b4_lac_if([[
- # if YYDEBUG
+ # if ]b4_api_PREFIX[DEBUG
        else if (yydebug)
          YYFPRINTF (stderr, "No expected tokens.\n");
  # endif]])[
@@@ -1519,7 -1559,7 +1492,7 @@@ b4_c_function_def([[yyparse]], [[int]]
    yyvsp = yyvs;]b4_locations_if([[
    yylsp = yyls;
  
- #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+ #if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
    /* Initialize the default location before parsing starts.  */
    yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
    yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
@@@ -1555,26 -1595,26 +1528,26 @@@ m4_ifdef([b4_at_dollar_used], [[  yylsp
  
  #ifdef yyoverflow
        {
 -	/* Give user a chance to reallocate the stack.  Use copies of
 -	   these so that the &'s don't force the real ones into
 -	   memory.  */
 -	YYSTYPE *yyvs1 = yyvs;
 -	yytype_int16 *yyss1 = yyss;]b4_locations_if([
 -	YYLTYPE *yyls1 = yyls;])[
 -
 -	/* Each stack pointer address is followed by the size of the
 -	   data in use in that stack, in bytes.  This used to be a
 -	   conditional around just the two extra args, but that might
 -	   be undefined if yyoverflow is a macro.  */
 -	yyoverflow (YY_("memory exhausted"),
 -		    &yyss1, yysize * sizeof (*yyssp),
 -		    &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
 -		    &yyls1, yysize * sizeof (*yylsp),])[
 -		    &yystacksize);
 +        /* Give user a chance to reallocate the stack.  Use copies of
 +           these so that the &'s don't force the real ones into
 +           memory.  */
 +        YYSTYPE *yyvs1 = yyvs;
 +        yytype_int16 *yyss1 = yyss;]b4_locations_if([
 +        YYLTYPE *yyls1 = yyls;])[
 +
 +        /* Each stack pointer address is followed by the size of the
 +           data in use in that stack, in bytes.  This used to be a
 +           conditional around just the two extra args, but that might
 +           be undefined if yyoverflow is a macro.  */
 +        yyoverflow (YY_("memory exhausted"),
 +                    &yyss1, yysize * sizeof (*yyssp),
 +                    &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
 +                    &yyls1, yysize * sizeof (*yylsp),])[
 +                    &yystacksize);
  ]b4_locations_if([
 -	yyls = yyls1;])[
 -	yyss = yyss1;
 -	yyvs = yyvs1;
 +        yyls = yyls1;])[
 +        yyss = yyss1;
 +        yyvs = yyvs1;
        }
  #else /* no yyoverflow */
  # ifndef YYSTACK_RELOCATE
@@@ -1582,23 -1622,23 +1555,23 @@@
  # else
        /* Extend the stack our own way.  */
        if (YYMAXDEPTH <= yystacksize)
 -	goto yyexhaustedlab;
 +        goto yyexhaustedlab;
        yystacksize *= 2;
        if (YYMAXDEPTH < yystacksize)
 -	yystacksize = YYMAXDEPTH;
 +        yystacksize = YYMAXDEPTH;
  
        {
 -	yytype_int16 *yyss1 = yyss;
 -	union yyalloc *yyptr =
 -	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 -	if (! yyptr)
 -	  goto yyexhaustedlab;
 -	YYSTACK_RELOCATE (yyss_alloc, yyss);
 -	YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
 -	YYSTACK_RELOCATE (yyls_alloc, yyls);])[
 +        yytype_int16 *yyss1 = yyss;
 +        union yyalloc *yyptr =
 +          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 +        if (! yyptr)
 +          goto yyexhaustedlab;
 +        YYSTACK_RELOCATE (yyss_alloc, yyss);
 +        YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
 +        YYSTACK_RELOCATE (yyls_alloc, yyls);])[
  #  undef YYSTACK_RELOCATE
 -	if (yyss1 != yyssa)
 -	  YYSTACK_FREE (yyss1);
 +        if (yyss1 != yyssa)
 +          YYSTACK_FREE (yyss1);
        }
  # endif
  #endif /* no yyoverflow */
@@@ -1608,10 -1648,10 +1581,10 @@@
        yylsp = yyls + yysize - 1;])[
  
        YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 -		  (unsigned long int) yystacksize));
 +                  (unsigned long int) yystacksize));
  
        if (yyss + yystacksize - 1 <= yyssp)
 -	YYABORT;
 +        YYABORT;
      }
  
    YYDPRINTF ((stderr, "Entering state %d\n", yystate));
@@@ -1847,20 -1887,20 +1820,20 @@@ yyerrlab
    if (yyerrstatus == 3)
      {
        /* If just tried and failed to reuse lookahead token after an
 -	 error, discard it.  */
 +         error, discard it.  */
  
        if (yychar <= YYEOF)
 -	{
 -	  /* Return failure if at end of input.  */
 -	  if (yychar == YYEOF)
 -	    YYABORT;
 -	}
 +        {
 +          /* Return failure if at end of input.  */
 +          if (yychar == YYEOF)
 +            YYABORT;
 +        }
        else
 -	{
 -	  yydestruct ("Error: discarding",
 -		      yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
 -	  yychar = YYEMPTY;
 -	}
 +        {
 +          yydestruct ("Error: discarding",
 +                      yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
 +          yychar = YYEMPTY;
 +        }
      }
  
    /* Else will try to reuse lookahead token after shifting the error
@@@ -1893,29 -1933,29 +1866,29 @@@ yyerrorlab
  | 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.  */
  
    for (;;)
      {
        yyn = yypact[yystate];
        if (!yypact_value_is_default (yyn))
 -	{
 -	  yyn += YYTERROR;
 -	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
 -	    {
 -	      yyn = yytable[yyn];
 -	      if (0 < yyn)
 -		break;
 -	    }
 -	}
 +        {
 +          yyn += YYTERROR;
 +          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
 +            {
 +              yyn = yytable[yyn];
 +              if (0 < yyn)
 +                break;
 +            }
 +        }
  
        /* Pop the current state because it cannot handle the error token.  */
        if (yyssp == yyss)
 -	YYABORT;
 +        YYABORT;
  
  ]b4_locations_if([[      yyerror_range[1] = *yylsp;]])[
        yydestruct ("Error: popping",
 -		  yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
 +                  yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
        YYPOPSTACK (1);
        yystate = *yyssp;
        YY_STACK_PRINT (yyss, yyssp);
@@@ -1980,7 -2020,7 +1953,7 @@@ yyreturn
    while (yyssp != yyss)
      {
        yydestruct ("Cleanup: popping",
 -		  yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
 +                  yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
        YYPOPSTACK (1);
      }
  #ifndef yyoverflow
@@@ -2000,12 -2040,13 +1973,12 @@@ yypushreturn:]])
    return YYID (yyresult);
  }
  
 -
 -]b4_epilogue
 +]b4_epilogue[]dnl
  b4_defines_if(
  [@output(b4_spec_defines_file@)@
 -b4_copyright([Bison interface for Yacc-like parsers in C],
 -             [1984, 1989-1990, 2000-2012])[
 +b4_copyright([Bison interface for Yacc-like parsers in C])[
  
  ]b4_shared_declarations[
  ]])dnl b4_defines_if
  m4_divert_pop(0)
 +m4_popdef([b4_copyright_years])
diff --combined tests/atlocal.in
index ef31d9fc,7302209f..315e98ed
--- a/tests/atlocal.in
+++ b/tests/atlocal.in
@@@ -1,4 -1,4 +1,4 @@@
 -# @configure_input@					-*- shell-script -*-
 +# @configure_input@                                     -*- shell-script -*-
  # Configurable variable values for Bison test suite.
  
  # Copyright (C) 2000-2012 Free Software Foundation, Inc.
@@@ -75,16 -75,9 +75,17 @@@ CONF_JAVA='@CONF_JAVA@
  # Empty if no xsltproc was found
  : ${XSLTPROC='@XSLTPROC@'}
  
--# We need egrep.
++# We need egrep and perl.
  : ${EGREP='@EGREP@'}
++: ${PERL='@PERL@'}
  
  # Use simple quotes (lib/quote.c).
  LC_CTYPE=C
  export LC_CTYPE
 +
 +
 +# Handle --compile-c-with-cxx here, once CXX and CXXFLAGS are known.
 +if "$at_arg_compile_c_with_cxx"; then
 +  CC=$CXX
 +  CFLAGS=$CXXFLAGS
 +fi
diff --combined tests/headers.at
index 970d3f1b,70891292..36142cc9
--- a/tests/headers.at
+++ b/tests/headers.at
@@@ -130,7 -130,7 +130,7 @@@ AT_SETUP([Several parsers]
  # the header (but YYDEBUG and YYPARSE_PARAM).
  m4_define([AT_DATA_GRAMMAR_SEVERAL],
  [AT_BISON_OPTION_PUSHDEFS([%define api.prefix "$1_" $2])
- AT_DATA_GRAMMAR([AT_SKEL_CC_IF([$1.yy], [$1.y])],
+ AT_DATA_GRAMMAR([$1.AT_SKEL_CC_IF([yy], [y])],
  [[%define api.prefix "$1_"
  $2
  %union
@@@ -160,13 -160,21 +160,22 @@@ exp
  AT_BISON_CHECK([-d -o AT_SKEL_CC_IF([$1.cc $1.yy], [$1.c $1.y])])
  # C++ output relies on namespaces and still uses yy a lot.
  AT_SKEL_CC_IF([],
-   [AT_CHECK([$EGREP -i yy $1.h | $EGREP -v 'YY(DEBUG|PARSE_PARAM)'], [1])])
+   [AT_CHECK([$EGREP yy $1.h], [1])])
+ 
+ # Ignore comments. Ignore YYPARSE_PARAM.  YYDEBUG (not renamed) can be
+ # read, but not changed.
 -AT_CHECK([[sed -ne 's,/\*[^*]*\*/,,g;s,//.*,,' \
 -                -e '/YY/p' ]$1.AT_SKEL_CC_IF([hh], [h])[ |
++AT_CHECK([[$PERL -0777 -e 's{/\*.*?\*/}{}sg;s,//.*,,;' \
++            ]$1.AT_SKEL_CC_IF([hh], [h])[ |
++         grep 'YY' |
+          $EGREP -wv '(YYPARSE_PARAM|defined YYDEBUG|if YYDEBUG)']],
+          [1])
  AT_LANG_COMPILE([$1.o])
  AT_BISON_OPTION_POPDEFS
  ])
  
  AT_DATA([main.cc],
- [[extern "C"
+ [AT_DATA_SOURCE_PROLOGUE
+ [extern "C"
  {
    #include "x1.h"
    #include "x2.h"
@@@ -175,18 -183,21 +184,21 @@@
  }
  #include "x5.hh"
  //#include "x6.hh"
+ 
+ #define ECHO(S) std::cerr << #S": " << S << std::endl;
+ 
  int
  main (void)
  {
-   int errs = 0;
-   errs += x1_parse();
-   errs += x2_parse();
-   errs += x3_parse();
-   errs += x4_parse();
+   ECHO(x1_parse());
+   ECHO(x2_parse());
+   ECHO(x3_parse());
+   ECHO(x4_parse());
    x5_::parser p5;
-   errs += p5.parse();
- //  errs += x6_parse();
-   return !!errs;
+   ECHO(p5.parse());
+ //  x6_::parser p6;
+ //  ECHO(p6.parse());
+   return 0;
  }
  ]])
  
@@@ -195,7 -206,7 +207,7 @@@ AT_DATA_GRAMMAR_SEVERAL([x2], [%locatio
  AT_DATA_GRAMMAR_SEVERAL([x3], [%glr-parser])
  AT_DATA_GRAMMAR_SEVERAL([x4], [%locations %debug %glr-parser])
  AT_DATA_GRAMMAR_SEVERAL([x5], [%locations %debug %language "c++"])
- #AT_DATA_GRAMMAR_SEVERAL([x6], [%locations %language "c++"])
+ #AT_DATA_GRAMMAR_SEVERAL([x5], [%locations %language "c++" %glr-parser])
  
  AT_COMPILE_CXX([parser], [x1.o x2.o x3.o x4.o x5.o main.cc])
  AT_CHECK([./parser], [0],
@@@ -204,6 -215,12 +216,12 @@@ x
  x3
  x4
  x5
+ ]],
+ [[x1_parse(): 0
+ x2_parse(): 0
+ x3_parse(): 0
+ x4_parse(): 0
+ p5.parse(): 0
  ]])
  
  AT_CLEANUP