From: Akim Demaille <akim@lrde.epita.fr>
Date: Fri, 3 Aug 2012 08:52:55 +0000 (+0200)
Subject: Merge branch 'maint'
X-Git-Tag: v2.7.90~356
X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/c85541913b99f841de090aacf626bb8f52f7f727?hp=-c

Merge branch 'maint'

* origin/maint:
  maint: post-release administrivia
  version 2.6.2
  NEWS: update.
  yacc: remove trailing end of line at end of file
  thanks: fix a contributor name
  gnulib: update
  tests: synch line -> syncline, for consistency
  tests: synclines: style changes
  tests: synclines: fix perl invocation
  regen
  c++: trailing end-of-lines in %parse-param
  tests: simplify

Conflicts:
	cfg.mk
	data/glr.cc
	data/yacc.c
	src/parse-gram.c
	src/parse-gram.h
	src/parse-gram.y
---

c85541913b99f841de090aacf626bb8f52f7f727
diff --combined NEWS
index 9fb03bb3,7fdbc037..fd749368
--- a/NEWS
+++ b/NEWS
@@@ -2,147 -2,23 +2,163 @@@ GNU Bison NEW
  
  * Noteworthy changes in release ?.? (????-??-??) [?]
  
 +** Incompatible changes
 +
 +*** Obsolete features
 +
 +  Support for YYFAIL is removed (deprecated in Bison 2.4.2).
 +  Support for yystype and yyltype (instead of YYSTYPE and YYLTYPE)
 +  is removed (deprecated in Bison 1.875).
 +  Support for YYPARSE_PARAM is removed (deprecated in Bison 1.875).
 +
 +** Warnings
 +
 +*** Warning categories are now displayed
 +
 +  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++ skeletons improvements
 +
 +*** parser header (%defines) is no longer mandatory (lalr1.cc)
 +
 +  In which case, if needed, the support classes are defined in the generated
 +  parser, instead of additional files (location.hh, position.hh and
 +  stack.hh).
 +
 +*** locations are no longer mandatory (lalr1.cc, glr.cc)
 +
 +  Both lalr1.cc and glr.cc no longer require %location.
 +
 +*** syntax_error exception (lalr1.cc)
 +
 +  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 ?.? (????-??-??) [?]
 +
  
+ * Noteworthy changes in release 2.6.2 (2012-08-03) [stable]
+ 
+ ** Bug fixes
+ 
+   Buffer overruns, complaints from Flex, and portability issues in the test
+   suite have been fixed.
+ 
+ ** Spaces in %lex- and %parse-param (lalr1.cc, glr.cc)
+ 
+   Trailing end-of-lines in %parse-param or %lex-param would result in
+   invalid C++.  This is fixed.
+ 
+ ** Spurious spaces and end-of-lines
+ 
+   The generated files no longer end (nor start) with empty lines.
+ 
  * Noteworthy changes in release 2.6.1 (2012-07-30) [stable]
  
   Bison no longer executes user-specified M4 code when processing a grammar.
@@@ -183,7 -59,7 +199,7 @@@
  
  * Noteworthy changes in release 2.6 (2012-07-19) [stable]
  
 -** Future Changes
 +** Future changes:
  
    The next major release of Bison will drop support for the following
    deprecated features.  Please report disagreements to bug-bison@gnu.org.
@@@ -1984,8 -1860,7 +2000,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 THANKS
index 5e76b1d1,95acb1e2..4ed4256d
--- a/THANKS
+++ b/THANKS
@@@ -71,7 -71,6 +71,7 @@@ Matt Kraai                kraai@alumni.
  Matt Rosing               rosing@peakfive.com
  Michael Hayes             m.hayes@elec.canterbury.ac.nz
  Michael Raskin            7c6f434c@mail.ru
 +Michiel De Wilde          mdewilde.agilent@gmail.com
  Mickael Labau             labau_m@epita.fr
  Mike Castle               dalgoda@ix.netcom.com
  Neil Booth                NeilB@earthling.net
@@@ -89,7 -88,6 +89,7 @@@ Per Allansson             per@appgate.c
  Peter Fales               psfales@lucent.com
  Peter Hamorsky            hamo@upjs.sk
  Piotr Gackiewicz          gacek@intertel.com.pl
 +Quentin Hocquet           hocquet@gostai.com
  Quoc Peyrot               chojin@lrde.epita.fr
  R Blake                   blakers@mac.com
  Raja R Harinath           harinath@cs.umn.edu
@@@ -103,7 -101,7 +103,7 @@@ Sergei Steshenko          sergstesh@yah
  Shura                     debil_urod@ngs.ru
  Stefano Lattarini         stefano.lattarini@gmail.com
  Steve Murphy              murf@parsetree.com
- Summum Bonum              sum@geekhouse.org
+ Sum Wu                    sum@geekhouse.org
  Thiru Ramakrishnan        thiru.ramakrishnan@gmail.com
  Tim Josling               tej@melbpc.org.au
  Tim Landscheidt           tim@tim-landscheidt.de
diff --combined cfg.mk
index af1e09e8,3a70379c..e50c6293
--- a/cfg.mk
+++ b/cfg.mk
@@@ -36,9 -36,15 +36,9 @@@ url_dir_list = 
    ftp://$(gnu_rel_host)/gnu/bison
  
  # Tests not to run as part of "make distcheck".
 -# Exclude changelog-check here so that there's less churn in ChangeLog
 -# files -- otherwise, you'd need to have the upcoming version number
 -# at the top of the file for each `make distcheck' run.
 -local-checks-to-skip = \
 -  changelog-check \
 +local-checks-to-skip =			\
    sc_immutable_NEWS			\
 -  sc_prohibit_always_true_header_tests	\
 -  sc_prohibit_atoi_atof			\
 -  sc_prohibit_strcmp
 +  sc_prohibit_atoi_atof
  
  # The local directory containing the checked-out copy of gnulib used in
  # this release.  Used solely to get a date for the "announcement" target.
@@@ -64,11 -70,10 +64,10 @@@ $(call exclude,								
    prohibit_always-defined_macros+=?|^src/(parse-gram.c|system.h)$$	\
    prohibit_always-defined_macros+=?|^tests/regression.at$$		\
    prohibit_defined_have_decl_tests=?|^lib/timevar.c$$			\
-   prohibit_empty_lines_at_EOF=^src/parse-gram.h$$			\
    prohibit_magic_number_exit=^doc/bison.texi$$				\
    prohibit_magic_number_exit+=?|^tests/(conflicts|regression).at$$	\
 +  prohibit_strcmp=^doc/bison\.texi$$					\
    require_config_h_first=^(lib/yyerror|data/(glr|yacc))\.c$$		\
    space_tab=^tests/(input|c\+\+)\.at$$					\
 -  trailing_blank=^src/parse-gram.[ch]$$					\
    unmarked_diagnostics=^(djgpp/|doc/bison.texi$$)			\
  )
diff --combined data/glr.c
index 8b3c34c9,97efe894..7675ac33
--- a/data/glr.c
+++ b/data/glr.c
@@@ -52,7 -52,7 +52,7 @@@ m4_ifndef([b4_pure_flag]
  # This is not shared with yacc.c in c.m4 because  GLR relies on ISO C
  # formal argument declarations.
  m4_define([b4_user_formals],
 -[m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])
 +[m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])])
  
  
  # b4_lex_param
@@@ -71,7 -71,7 +71,7 @@@ m4_ifdef([b4_lex_param], [, ]b4_lex_par
  # a trailing comma.
  m4_define([b4_yyerror_args],
  [b4_pure_if([b4_locations_if([yylocp, ])])dnl
 -m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
  
  
  # b4_lyyerror_args
@@@ -79,7 -79,7 +79,7 @@@
  # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
  m4_define([b4_lyyerror_args],
  [b4_pure_if([b4_locations_if([&yylloc, ])])dnl
 -m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
  
  
  # b4_pure_args
@@@ -126,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])
@@@ -142,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])])
  
  
  
@@@ -162,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)])
  
  
  ## -------------- ##
@@@ -176,9 -168,9 +176,9 @@@
  m4_define([b4_shared_declarations],
  [b4_declare_yydebug[
  ]b4_percent_code_get([[requires]])[
 -]b4_token_enums(b4_tokens)[
 +]b4_token_enums[
  ]b4_declare_yylstype[
 -]b4_c_ansi_function_decl(b4_prefix[parse], [int], b4_parse_param)[
 +]b4_function_declare(b4_prefix[parse], [int], b4_parse_param)[
  ]b4_percent_code_get([[provides]])[]dnl
  ])
  
@@@ -214,7 -206,7 +214,7 @@@ b4_percent_code_get([[top]])
  #define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
  #define yylloc  ]b4_prefix[lloc]])])[
  
 -/* Copy the first part of user declarations.  */
 +/* First part of user declarations.  */
  ]b4_user_pre_prologue[
  
  ]b4_null_define[
@@@ -227,7 -219,7 +227,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
  
  /* Default (constant) value used for initialization for null
@@@ -258,12 -250,22 +258,12 @@@ b4_percent_code_get[]dn
  #endif
  
  /* Suppress unused-variable warnings by "using" E.  */
 -#if ! defined lint || defined __GNUC__
 +#ifdef __GNUC__
  # define YYUSE(e) ((void) (e))
  #else
  # define YYUSE(e) /* empty */
  #endif
  
 -/* Identity function, used to suppress warnings about constant conditions.  */
 -#ifndef lint
 -# define YYID(n) (n)
 -#else
 -]b4_c_function_def([YYID], [static int], [[int i], [i]])[
 -{
 -  return i;
 -}
 -#endif
 -
  #ifndef YYFREE
  # define YYFREE free
  #endif
@@@ -347,6 -349,19 +347,6 @@@ static const ]b4_int_type_for([b4_trans
  };
  
  #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[] =
  {
@@@ -363,10 -378,17 +363,10 @@@ static const char *const yytname[] 
  };
  #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[] =
@@@ -380,11 -402,41 +380,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[] =
 -{
 -  ]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[] =
 +/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as
 +   in the case of predicates.  */
 +static const yybool yyimmediate[] =
  {
 -  ]b4_table[
 +  ]b4_immediate[
  };
  
  /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
@@@ -405,7 -457,19 +405,7 @@@ 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
  
@@@ -434,7 -498,7 +434,7 @@@
  #endif
  
  /* YYLEX -- calling `yylex' with the right arguments.  */
 -#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
 +#define YYLEX ]b4_function_call([yylex], [int], b4_lex_param)[
  
  ]b4_pure_if(
  [
@@@ -462,12 -526,9 +462,12 @@@ 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 (0)
  
  #if ]b4_api_PREFIX[DEBUG
  
@@@ -476,22 -537,22 +476,22 @@@
  # endif
  
  # define YYDPRINTF(Args)                        \
 -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))
 +  do {                                          \
 +    if (yydebug)                                \
 +      YYFPRINTF Args;                           \
 +  } while (0)
 +
 +]b4_yy_symbol_print_define[
 +
 +# 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 (0)
  
  /* Nonzero means print parse trace.  It is left uninitialized so that
     multiple parsers can coexist.  */
@@@ -528,7 -589,13 +528,7 @@@ int yydebug
  #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
@@@ -536,13 -603,13 +536,13 @@@
    do {                                                  \
      if (Yystack->yyspaceLeft < YYHEADROOM)              \
        yyexpandGLRStack (Yystack);                       \
 -  } while (YYID (0))
 +  } while (0)
  #else
  # define YY_RESERVE_GLRSTACK(Yystack)                   \
    do {                                                  \
      if (Yystack->yyspaceLeft < YYHEADROOM)              \
        yyMemoryExhausted (Yystack);                      \
 -  } while (YYID (0))
 +  } while (0)
  #endif
  
  
@@@ -625,7 -692,7 +625,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;
@@@ -646,7 -713,7 +646,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
@@@ -758,16 -825,9 +758,16 @@@ yyfillin (yyGLRStackItem *yyvsp, int yy
    yyGLRState *s = yyvsp[yylow0].yystate.yypred;
    for (i = yylow0-1; i >= yylow1; i -= 1)
      {
 -      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;
      }
@@@ -794,7 -854,7 +794,7 @@@ yyfill (yyGLRStackItem *yyvsp, int *yyl
   *  value ($$), and yylocp points to place for location information
   *  (@@$).  Returns yyok for normal return, yyaccept for YYACCEPT,
   *  yyerr for YYERROR, yyabort for YYABORT.  */
 -/*ARGSUSED*/ static YYRESULTTAG
 +static YYRESULTTAG
  yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
                yyGLRStack* yystackp,
                YYSTYPE* yyvalp]b4_locuser_formals[)
@@@ -802,7 -862,7 +802,7 @@@
    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
@@@ -845,9 -905,9 +845,9 @@@
  # undef yyclearin
  # undef YYRECOVERING
  }
 -
  
 -/*ARGSUSED*/ static void
 +
 +static void
  yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
  {
    YYUSE (yy0);
@@@ -862,7 -922,7 +862,7 @@@
  
                                /* Bison grammar-table manipulation.  */
  
 -]b4_yydestruct_generate([b4_c_ansi_function_def])[
 +]b4_yydestruct_define[
  
  /** Number of symbols composing the right hand side of rule #RULE.  */
  static inline int
@@@ -905,7 -965,7 +905,7 @@@ yydestroyGLRState (char const *yymsg, y
      }
  }
  
 -/** Left-hand-side symbol for rule #RULE.  */
 +/** Left-hand-side symbol for rule #YYRULE.  */
  static inline yySymbol
  yylhsNonterm (yyRuleNum yyrule)
  {
@@@ -915,7 -975,7 +915,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)
@@@ -923,7 -983,7 +923,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)
  {
@@@ -938,8 -998,8 +938,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,
@@@ -967,7 -1027,8 +967,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
@@@ -988,10 -1049,9 +988,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)
@@@ -1004,16 -1064,16 +1004,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])
      {
@@@ -1031,7 -1091,7 +1031,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)
  {
@@@ -1057,8 -1117,8 +1057,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)
  {
@@@ -1080,7 -1140,7 +1080,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
@@@ -1150,9 -1210,9 +1150,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)
  {
@@@ -1160,7 -1220,7 +1160,7 @@@
      yystackp->yysplitPoint = yys;
  }
  
 -/** Invalidate stack #K in STACK.  */
 +/** Invalidate stack #YYK in *YYSTACKP.  */
  static inline void
  yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
  {
@@@ -1169,8 -1229,8 +1169,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)
@@@ -1219,9 -1279,8 +1219,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,
@@@ -1240,12 -1299,12 +1240,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;
  
@@@ -1257,55 -1316,14 +1257,55 @@@
    yystackp->yytops.yystates[yyk] = yynewState;
  
    /* Invokes YY_RESERVE_GLRSTACK.  */
 -  yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
 +  yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule);
  }
  
 -/** Pop the symbols consumed by reduction #RULE from the top of stack
 - *  #K of STACK, and perform the appropriate semantic action on their
 +#if !]b4_api_PREFIX[DEBUG
 +# define YY_REDUCE_PRINT(Args)
 +#else
 +# define YY_REDUCE_PRINT(Args)          \
 +do {                                    \
 +  if (yydebug)                          \
 +    yy_reduce_print Args;               \
 +} while (0)
 +
 +/*----------------------------------------------------------------------.
 +| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
 +`----------------------------------------------------------------------*/
 +
 +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 #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,
@@@ -1316,17 -1334,20 +1316,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];
@@@ -1342,21 -1363,62 +1342,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
@@@ -1367,18 -1429,11 +1367,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,
@@@ -1401,8 -1456,7 +1401,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)
@@@ -1473,7 -1527,7 +1473,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
@@@ -1495,8 -1549,8 +1495,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)
  {
@@@ -1523,7 -1577,7 +1523,7 @@@
          {
            yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal;
            yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal;
 -          while (YYID (yytrue))
 +          while (yytrue)
              {
                if (yyz1 == *yyz0p || yyz1 == YY_NULL)
                  break;
@@@ -1575,11 -1629,11 +1575,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[)
@@@ -1594,10 -1648,9 +1594,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,
@@@ -1671,11 -1724,11 +1671,11 @@@ yyreportTree (yySemanticOption* yyx, in
          {
            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
@@@ -1684,7 -1737,7 +1684,7 @@@
  }
  #endif
  
 -/*ARGSUSED*/ static YYRESULTTAG
 +static YYRESULTTAG
  yyreportAmbiguity (yySemanticOption* yyx0,
                     yySemanticOption* yyx1]b4_pure_formals[)
  {
@@@ -1704,9 -1757,9 +1704,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[)
@@@ -1760,12 -1813,11 +1760,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[)
@@@ -1903,6 -1955,10 +1903,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;
@@@ -1913,8 -1969,7 +1913,8 @@@
  
        if (yyisDefaultedState (yystate))
          {
 -          yyrule = yydefaultAction (yystate);
 +          YYRESULTTAG yyflag;
 +          yyRuleNum yyrule = yydefaultAction (yystate);
            if (yyrule == 0)
              {
                YYDPRINTF ((stderr, "Stack %lu dies.\n",
@@@ -1922,25 -1977,11 +1922,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)
              {
@@@ -1963,25 -2004,14 +1963,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;
              }
  
@@@ -1995,27 -2025,14 +1995,27 @@@
                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;
  }
  
 -/*ARGSUSED*/ static void
 +static void
  yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
  {
    if (yystackp->yyerrState != 0)
@@@ -2147,7 -2164,7 +2147,7 @@@
  /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
     yylval, and yylloc are the syntactic category, semantic value, and location
     of the lookahead.  */
 -/*ARGSUSED*/ static void
 +static void
  yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
  {
    size_t yyk;
@@@ -2156,7 -2173,7 +2156,7 @@@
    if (yystackp->yyerrState == 3)
      /* We just shifted the error token and (perhaps) took some
         reductions.  Skip tokens until we can proceed.  */
 -    while (YYID (yytrue))
 +    while (yytrue)
        {
          yySymbol yytoken;
          if (yychar == YYEOF)
@@@ -2260,13 -2277,14 +2260,13 @@@
      default:                                                                 \
        goto yybuglab;                                                         \
      }                                                                        \
 -  } while (YYID (0))
 -
 +  } while (0)
  
  /*----------.
  | yyparse.  |
  `----------*/
  
 -]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
 +]b4_function_define([yyparse], [int], b4_parse_param)[
  {
    int yyresult;
    yyGLRStack yystack;
@@@ -2285,8 -2303,8 +2285,8 @@@
  ])
  m4_ifdef([b4_initial_action], [
  b4_dollar_pushdef([yylval], [], [yylloc])dnl
 -/* User initialization code.  */
 -b4_user_initial_action
 +  /* User initialization code.  */
 +  b4_user_initial_action
  b4_dollar_popdef])[]dnl
  [
    if (! yyinitGLRStack (yystackp, YYINITDEPTH))
@@@ -2301,13 -2319,13 +2301,13 @@@
    yyglrShift (&yystack, 0, 0, 0, &yylval]b4_locations_if([, &yylloc])[);
    yyposn = 0;
  
 -  while (YYID (yytrue))
 +  while (yytrue)
      {
        /* For efficiency, we have two loops, the first of which is
           specialized to deterministic operation (single stack, no
           potential ambiguity).  */
        /* Standard mode */
 -      while (YYID (yytrue))
 +      while (yytrue)
          {
            yyRuleNum yyrule;
            int yyaction;
@@@ -2371,7 -2389,7 +2371,7 @@@
              }
          }
  
 -      while (YYID (yytrue))
 +      while (yytrue)
          {
            yySymbol yytoken_to_shift;
            size_t yys;
@@@ -2503,7 -2521,8 +2503,7 @@@
        yyfreeGLRStack (&yystack);
      }
  
 -  /* Make sure YYID is used.  */
 -  return YYID (yyresult);
 +  return yyresult;
  }
  
  /* DEBUGGING ONLY */
@@@ -2593,5 -2612,5 +2593,5 @@@ b4_copyright([Skeleton interface for Bi
  ]b4_cpp_guard_open([b4_spec_defines_file])[
  ]b4_shared_declarations[
  ]b4_cpp_guard_close([b4_spec_defines_file])[
- ]])])
+ ]])])dnl
  m4_divert_pop(0)
diff --combined data/glr.cc
index dae2f62f,826bc80e..69b328b6
--- 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,13 -39,14 +37,13 @@@
  # 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])
 +# We require a pure interface.
  m4_define([b4_pure_flag],      [1])
  
  # The header is mandatory.
@@@ -61,25 -64,24 +61,25 @@@ m4_define([b4_parser_class_name]
  m4_define([b4_parse_param_orig], m4_defn([b4_parse_param]))
  
  
 -# b4_yy_symbol_print_generate
 +# b4_yy_symbol_print_define
  # ---------------------------
  # Bypass the default implementation to generate the "yy_symbol_print"
  # and "yy_symbol_value_print" functions.
 -m4_define([b4_yy_symbol_print_generate],
 +m4_define([b4_yy_symbol_print_define],
  [[
  /*--------------------.
  | Print this symbol.  |
  `--------------------*/
  
 -]b4_c_ansi_function_def([yy_symbol_print],
 +]b4_function_define([yy_symbol_print],
      [static void],
 -    [[FILE *],               []],
 -    [[int yytype],           [yytype]],
 +    [[FILE *],      []],
 +    [[int yytype],  [yytype]],
      [[const ]b4_namespace_ref::b4_parser_class_name[::semantic_type *yyvaluep],
 -                             [yyvaluep]],
 +                    [yyvaluep]][]dnl
 +b4_locations_if([,
      [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
 -                             [yylocationp]],
 +                    [yylocationp]]]),
      b4_parse_param)[
  {
  ]b4_parse_param_use[]dnl
@@@ -94,10 -96,10 +94,10 @@@ m4_append([b4_post_prologue]
  [b4_syncline([@oline@], [@ofile@])[
  ]b4_yylloc_default_define[
  #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
 -]b4_c_ansi_function_decl([yyerror],
 -    [static void],
 +]b4_function_declare([yyerror],
 +    [static void],b4_locations_if([
      [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
 -                        [yylocationp]],
 +                        [yylocationp]],])
      b4_parse_param,
      [[const char* msg], [msg]])])
  
@@@ -110,15 -112,15 +110,15 @@@ m4_append([b4_epilogue]
  | Report an error.  |
  `------------------*/
  
 -]b4_c_ansi_function_def([yyerror],
 -    [static void],
 +]b4_function_define([yyerror],
 +    [static void],b4_locations_if([
      [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
 -                        [yylocationp]],
 +                        [yylocationp]],])
      b4_parse_param,
      [[const char* msg], [msg]])[
  {
  ]b4_parse_param_use[]dnl
 -[  yyparser.error (*yylocationp, msg);
 +[  yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg);
  }
  
  
@@@ -129,7 -131,8 +129,7 @@@ m4_pushdef([b4_parse_param], m4_defn([b
    ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
      :])[
  #if ]b4_api_PREFIX[DEBUG
 -    ]m4_ifset([b4_parse_param], [  ], [ :])[
 -      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[
    {
    }
@@@ -151,17 -154,17 +151,17 @@@
  
    inline void
    ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
 -                           const semantic_type* yyvaluep,
 -                           const location_type* yylocationp)
 -  {
 -    YYUSE (yylocationp);
 +                           const semantic_type* yyvaluep]b4_locations_if([[,
 +                           const location_type* yylocationp]])[)
 +  {]b4_locations_if([[
 +    YYUSE (yylocationp);]])[
      YYUSE (yyvaluep);
      std::ostream& yyoutput = debug_stream ();
      std::ostream& yyo = yyoutput;
      YYUSE (yyo);
      switch (yytype)
        {
 -  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 +]b4_symbol_foreach([b4_symbol_printer])dnl
  [        default:
            break;
        }
@@@ -170,13 -173,13 +170,13 @@@
  
    void
    ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
 -                           const semantic_type* yyvaluep,
 -                           const location_type* yylocationp)
 +                           const semantic_type* yyvaluep]b4_locations_if([[,
 +                           const location_type* yylocationp]])[)
    {
      *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm")
 -               << ' ' << yytname[yytype] << " ("
 -               << *yylocationp << ": ";
 -    yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
 +               << ' ' << yytname[yytype] << " ("]b4_locations_if([[
 +               << *yylocationp << ": "]])[;
 +    yy_symbol_value_print_ (yytype, yyvaluep]b4_locations_if([[, yylocationp]])[);
      *yycdebug_ << ')';
    }
  
@@@ -208,8 -211,7 +208,7 @@@
  
  #endif
  ]m4_popdef([b4_parse_param])dnl
- b4_namespace_close[
- ]])
+ b4_namespace_close])
  
  
  # Let glr.c believe that the user arguments include the parser itself.
@@@ -223,19 -225,21 +222,19 @@@ m4_defn([b4_parse_param]))]
  m4_include(b4_pkgdatadir/[glr.c])
  m4_popdef([b4_parse_param])
  
 -m4_divert_push(0)
 -@output(b4_spec_defines_file@)@
 -b4_copyright([Skeleton interface for Bison GLR parsers in C++],
 -             [2002-2006, 2009-2012])[
 -
 -/* C++ GLR parser skeleton written by Akim Demaille.  */
 -
 -]b4_cpp_guard_open([b4_spec_defines_file])[
  
 -]b4_percent_code_get([[requires]])[
 +# b4_shared_declarations
 +# ----------------------
 +# Declaration that might either go into the header (if --defines)
 +# or open coded in the parser body.
 +m4_define([b4_shared_declarations],
 +[b4_percent_code_get([[requires]])[
  
 -# include <string>
 -# include <iostream>
 +#include <stdexcept>
 +#include <string>
 +#include <iostream>
  ]b4_percent_define_ifdef([[location_type]], [],
 -                         [[# include "location.hh"]])[
 +                         [[#include "location.hh"]])[
  
  ]b4_YYDEBUG_define[
  
@@@ -244,7 -248,29 +243,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[);
@@@ -266,39 -292,42 +265,39 @@@
      /// 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.
 +    /// 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);
 -  private:
 +    virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg);
  
  # if ]b4_api_PREFIX[DEBUG
    public:
      /// \brief Report a symbol value on the debug stream.
      /// \param yytype       The token type.
 -    /// \param yyvaluep     Its semantic value.
 -    /// \param yylocationp  Its location.
 +    /// \param yyvaluep     Its semantic value.]b4_locations_if([[
 +    /// \param yylocationp  Its location.]])[
      virtual void yy_symbol_value_print_ (int yytype,
 -                                         const semantic_type* yyvaluep,
 -                                         const location_type* yylocationp);
 +                                         const semantic_type* yyvaluep]b4_locations_if([[,
 +                                         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.
 +    /// \param yyvaluep     Its semantic value.]b4_locations_if([[
 +    /// \param yylocationp  Its location.]])[
      virtual void yy_symbol_print_ (int yytype,
 -                                   const semantic_type* yyvaluep,
 -                                   const location_type* yylocationp);
 +                                   const semantic_type* yyvaluep]b4_locations_if([[,
 +                                   const location_type* yylocationp]])[);
    private:
      /* Debugging.  */
      std::ostream* yycdebug_;
 -# endif
 +#endif
  
  ]b4_parse_param_vars[
    };
  
  ]dnl Redirections for glr.c.
  b4_percent_define_flag_if([[global_tokens_and_yystype]],
 -[b4_token_defines(b4_tokens)])
 +[b4_token_defines])
  [
  #ifndef ]b4_api_PREFIX[STYPE
  # define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type
@@@ -309,16 -338,5 +308,16 @@@
  
  ]b4_namespace_close[
  ]b4_percent_code_get([[provides]])[
 +]])
 +
 +m4_divert_push(0)
 +@output(b4_spec_defines_file@)@
 +b4_copyright([Skeleton interface for Bison GLR parsers in C++],
 +             [2002-2012])[
 +
 +/* C++ GLR parser skeleton written by Akim Demaille.  */
 +
 +]b4_cpp_guard_open([b4_spec_defines_file])[
 +]b4_shared_declarations[
  ]b4_cpp_guard_close([b4_spec_defines_file])[
  ]m4_divert_pop(0)
diff --combined data/yacc.c
index 5b5b1bc4,01756884..da4e9e39
--- 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
@@@ -85,7 -83,7 +85,7 @@@
  # Arguments passed to yyerror: user args plus yylloc.
  m4_define([b4_yyerror_args],
  [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
 -m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
  
  
  # b4_lex_param
@@@ -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])@})])
  
  
  ## -------------- ##
@@@ -239,19 -237,19 +239,19 @@@ enum { YYPUSH_MORE = 4 }
  
  typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
  
 -]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
 -])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
 +]b4_pull_if([b4_function_declare([b4_prefix[parse]], [[int]], b4_parse_param)
 +])b4_function_declare([b4_prefix[push_parse]], [[int]],
    [[b4_prefix[pstate *ps]], [[ps]]]b4_pure_if([,
    [[[int pushed_char]], [[pushed_char]]],
    [[b4_api_PREFIX[STYPE const *pushed_val]], [[pushed_val]]]b4_locations_if([,
    [[b4_api_PREFIX[LTYPE const *pushed_loc]], [[pushed_loc]]]])])m4_ifset([b4_parse_param], [,
    b4_parse_param]))
 -b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
 +b4_pull_if([b4_function_declare([b4_prefix[pull_parse]], [[int]],
    [[b4_prefix[pstate *ps]], [[ps]]]m4_ifset([b4_parse_param], [,
    b4_parse_param]))])
 -b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
 +b4_function_declare([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
                      [[[void]], []])
 -b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
 +b4_function_declare([b4_prefix[pstate_delete]], [[void]],
                     [[b4_prefix[pstate *ps]], [[ps]]])dnl
  ])
  
@@@ -259,7 -257,13 +259,7 @@@
  # -------------------
  # When not the push parser.
  m4_define([b4_declare_yyparse_],
 -[[#ifdef YYPARSE_PARAM
 -]b4_c_function_decl(b4_prefix[parse], [int],
 -                    [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
 -#else /* ! YYPARSE_PARAM */
 -]b4_c_function_decl(b4_prefix[parse], [int], b4_parse_param)[
 -#endif /* ! YYPARSE_PARAM */]dnl
 -])
 +[b4_function_declare(b4_prefix[parse], [int], b4_parse_param)])
  
  
  # b4_declare_yyparse
@@@ -278,7 -282,7 +278,7 @@@ m4_define([b4_shared_declarations]
  [b4_cpp_guard_open([b4_spec_defines_file])[
  ]b4_declare_yydebug[
  ]b4_percent_code_get([[requires]])[
 -]b4_token_enums_defines(b4_tokens)[
 +]b4_token_enums_defines[
  ]b4_declare_yylstype[
  ]b4_declare_yyparse[
  ]b4_percent_code_get([[provides]])[
@@@ -293,7 -297,8 +293,7 @@@
  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.  */
@@@ -337,7 -342,7 +337,7 @@@ m4_if(b4_api_prefix, [yy], []
  # 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
@@@ -360,8 -365,10 +360,8 @@@ typedef unsigned char yytype_uint8
  
  #ifdef YYTYPE_INT8
  typedef YYTYPE_INT8 yytype_int8;
 -#elif ]b4_c_modern[
 -typedef signed char yytype_int8;
  #else
 -typedef short int yytype_int8;
 +typedef signed char yytype_int8;
  #endif
  
  #ifdef YYTYPE_UINT16
@@@ -381,7 -388,7 +381,7 @@@ typedef short int yytype_int16
  #  define YYSIZE_T __SIZE_TYPE__
  # elif defined size_t
  #  define YYSIZE_T size_t
 -# elif ! defined YYSIZE_T && ]b4_c_modern[
 +# elif ! defined YYSIZE_T
  #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
  #  define YYSIZE_T size_t
  # else
@@@ -404,12 -411,22 +404,12 @@@
  #endif
  
  /* Suppress unused-variable warnings by "using" E.  */
 -#if ! defined lint || defined __GNUC__
 +#ifdef __GNUC__
  # define YYUSE(e) ((void) (e))
  #else
  # define YYUSE(e) /* empty */
  #endif
  
 -/* Identity function, used to suppress warnings about constant conditions.  */
 -#ifndef lint
 -# define YYID(n) (n)
 -#else
 -]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
 -{
 -  return yyi;
 -}
 -#endif
 -
  #if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[
  
  /* The parser invokes alloca or malloc; define the necessary symbols.  */]dnl
@@@ -428,7 -445,7 +428,7 @@@ b4_push_if([], [b4_lac_if([], [
  #    define alloca _alloca
  #   else
  #    define YYSTACK_ALLOC alloca
 -#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && ]b4_c_modern[
 +#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
  #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
        /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
  #     ifndef EXIT_SUCCESS
@@@ -441,7 -458,7 +441,7 @@@
  
  # ifdef YYSTACK_ALLOC
     /* Pacify GCC's `empty if-body' warning.  */
 -#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 +#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  #  ifndef YYSTACK_ALLOC_MAXIMUM
      /* The OS might guarantee only one guard page at the bottom of the stack,
         and a page size can be as small as 4096 bytes.  So we cannot safely
@@@ -457,7 -474,7 +457,7 @@@
  #  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
@@@ -465,13 -482,13 +465,13 @@@
  #  endif
  #  ifndef YYMALLOC
  #   define YYMALLOC malloc
 -#   if ! defined malloc && ! defined EXIT_SUCCESS && ]b4_c_modern[
 +#   if ! defined malloc && ! defined EXIT_SUCCESS
  void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
  #   endif
  #  endif
  #  ifndef YYFREE
  #   define YYFREE free
 -#   if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[
 +#   if ! defined free && ! defined EXIT_SUCCESS
  void free (void *); /* INFRINGES ON USER NAME SPACE */
  #   endif
  #  endif
@@@ -482,8 -499,8 +482,8 @@@
  
  #if (! defined yyoverflow \
       && (! 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)))
 +         || (]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
@@@ -513,16 -530,16 +513,16 @@@
     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);				\
 -      }									\
 -    while (YYID (0))
 +# 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 (0)
  
  #endif
  
@@@ -541,7 -558,7 +541,7 @@@
            for (yyi = 0; yyi < (Count); yyi++)   \
              (Dst)[yyi] = (Src)[yyi];            \
          }                                       \
 -      while (YYID (0))
 +      while (0)
  #  endif
  # endif
  #endif /* !YYCOPY_NEEDED */
@@@ -557,27 -574,41 +557,27 @@@
  #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 ]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 ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
@@@ -590,35 -621,105 +590,35 @@@ static const char *const yytname[] 
  #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[
 -};
 +]b4_parser_tables_define[
  
 -/* 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[
 -};
 +#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 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
 -
 -
 -/* Like YYERROR except do call yyerror.  This remains here temporarily
 -   to ease the transition to the new meaning of YYERROR, for GCC.
 -   Once GCC version 2 has supplanted version 1, this can go.  However,
 -   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
 -   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
 -   discussed.  */
 -
 -#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
 -     some users do, and we want to make it easy for users to remove
 -     YYFAIL uses, which will produce warnings from Bison 2.5.  */
 -#endif
  
  #define YYRECOVERING()  (!!yyerrstatus)
  
@@@ -636,17 -737,18 +636,17 @@@ d
    else                                                          \
      {                                                           \
        yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
 -      YYERROR;							\
 -    }								\
 -while (YYID (0))
 +      YYERROR;                                                  \
 +    }                                                           \
 +while (0)
  
  
 -#define YYTERROR	1
 -#define YYERRCODE	256
 +#define YYTERROR        1
 +#define YYERRCODE       256
  
 +]b4_locations_if([[
  ]b4_yylloc_default_define[
  #define YYRHSLOC(Rhs, K) ((Rhs)[K])
 -]b4_locations_if([[
 -
  
  /* YY_LOCATION_PRINT -- Print the location on the stream.
     This macro was not mandated originally: define only if we know
@@@ -654,10 -756,10 +654,10 @@@
  
  #ifndef YY_LOCATION_PRINT
  # 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
@@@ -676,7 -778,7 +676,7 @@@
  #ifdef YYLEX_PARAM
  # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
  #else
 -# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
 +# define YYLEX ]b4_function_call([yylex], [int], b4_lex_param)[
  #endif
  
  /* Enable debugging if requested.  */
@@@ -687,33 -789,33 +687,33 @@@
  #  define YYFPRINTF fprintf
  # endif
  
 -# 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");						  \
 -    }									  \
 -} while (YYID (0))
 -
 -]b4_yy_symbol_print_generate([b4_c_function_def])[
 +# define YYDPRINTF(Args)                        \
 +do {                                            \
 +  if (yydebug)                                  \
 +    YYFPRINTF Args;                             \
 +} while (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");                                           \
 +    }                                                                     \
 +} while (0)
 +
 +]b4_yy_symbol_print_define[
  
  /*------------------------------------------------------------------.
  | yy_stack_print -- Print the state stack from its BOTTOM up to its |
  | TOP (included).                                                   |
  `------------------------------------------------------------------*/
  
 -]b4_c_function_def([yy_stack_print], [static void],
 -		   [[yytype_int16 *yybottom], [yybottom]],
 -		   [[yytype_int16 *yytop],    [yytop]])[
 +]b4_function_define([yy_stack_print], [static void],
 +                   [[yytype_int16 *yybottom], [yybottom]],
 +                   [[yytype_int16 *yytop],    [yytop]])[
  {
    YYFPRINTF (stderr, "Stack now");
    for (; yybottom <= yytop; yybottom++)
@@@ -724,47 -826,45 +724,47 @@@
    YYFPRINTF (stderr, "\n");
  }
  
 -# define YY_STACK_PRINT(Bottom, Top)				\
 -do {								\
 -  if (yydebug)							\
 -    yy_stack_print ((Bottom), (Top));				\
 -} while (YYID (0))
 +# define YY_STACK_PRINT(Bottom, Top)                            \
 +do {                                                            \
 +  if (yydebug)                                                  \
 +    yy_stack_print ((Bottom), (Top));                           \
 +} while (0)
  
  
  /*------------------------------------------------.
  | Report that the YYRULE is going to be reduced.  |
  `------------------------------------------------*/
  
 -]b4_c_function_def([yy_reduce_print], [static void],
 -		   [[YYSTYPE *yyvsp], [yyvsp]],
 +]b4_function_define([yy_reduce_print], [static void],
 +                   [[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[); \
 -} while (YYID (0))
 +# define YY_REDUCE_PRINT(Rule)          \
 +do {                                    \
 +  if (yydebug)                          \
 +    yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
 +} while (0)
  
  /* Nonzero means print parse trace.  It is left uninitialized so that
     multiple parsers can coexist.  */
@@@ -778,7 -878,7 +778,7 @@@ int yydebug
  
  
  /* YYINITDEPTH -- initial size of the parser's stacks.  */
 -#ifndef	YYINITDEPTH
 +#ifndef YYINITDEPTH
  # define YYINITDEPTH ]b4_stack_depth_init[
  #endif
  
@@@ -898,7 -998,7 +898,7 @@@ do 
            goto yyerrlab;                                         \
        }                                                          \
      }                                                            \
 -} while (YYID (0))
 +} while (0)
  
  /* Discard any previous initial lookahead context because of Event,
     which may be a lookahead change or an invalidation of the currently
@@@ -921,7 -1021,7 +921,7 @@@ do 
                     Event "\n");                                          \
        yy_lac_established = 0;                                            \
      }                                                                    \
 -} while (YYID (0))
 +} while (0)
  #else
  # define YY_LAC_DISCARD(Event) yy_lac_established = 0
  #endif
@@@ -1037,7 -1137,7 +1037,7 @@@ yy_lac (yytype_int16 *yyesa, yytype_int
  #   define yystrlen strlen
  #  else
  /* Return the length of YYSTR.  */
 -]b4_c_function_def([yystrlen], [static YYSIZE_T],
 +]b4_function_define([yystrlen], [static YYSIZE_T],
     [[const char *yystr], [yystr]])[
  {
    YYSIZE_T yylen;
@@@ -1054,7 -1154,7 +1054,7 @@@
  #  else
  /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
     YYDEST.  */
 -]b4_c_function_def([yystpcpy], [static char *],
 +]b4_function_define([yystpcpy], [static char *],
     [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
  {
    char *yyd = yydest;
@@@ -1085,27 -1185,27 +1085,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: ;
      }
  
@@@ -1144,6 -1244,10 +1144,6 @@@ yysyntax_error (YYSIZE_T *yymsg_alloc, 
    int yycount = 0;
  
    /* There are many possibilities here to consider:
 -     - Assume YYFAIL is not used.  It's too flawed to consider.  See
 -       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
 -       for details.  YYERROR is fine as it does not invoke this
 -       function.
       - If this state is a consistent state with a default action, then
         the only way this function was invoked is if the default action
         is an error action.  In that case, don't check for expected
@@@ -1274,7 -1378,7 +1274,7 @@@
  }
  #endif /* YYERROR_VERBOSE */
  
 -]b4_yydestruct_generate([b4_c_function_def])[
 +]b4_yydestruct_define[
  
  ]b4_pure_if([], [
  
@@@ -1289,13 -1393,13 +1289,13 @@@ struct yypstat
  
  static char yypstate_allocated = 0;]])b4_pull_if([
  
 -b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
 +b4_function_define([[yyparse]], [[int]], b4_parse_param)[
  {
    return yypull_parse (YY_NULL]m4_ifset([b4_parse_param],
 -                                  [[, ]b4_c_args(b4_parse_param)])[);
 +                                  [[, ]b4_args(b4_parse_param)])[);
  }
  
 -]b4_c_function_def([[yypull_parse]], [[int]],
 +]b4_function_define([[yypull_parse]], [[int]],
    [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
    b4_parse_param]))[
  {
@@@ -1320,7 -1424,7 +1320,7 @@@
    do {
      yychar = YYLEX;
      yystatus =
 -      yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
 +      yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])[);
    } while (yystatus == YYPUSH_MORE);
    if (!yyps)
      yypstate_delete (yyps_local);
@@@ -1328,7 -1432,7 +1328,7 @@@
  }]])[
  
  /* Initialize the parser data structure.  */
 -]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
 +]b4_function_define([[yypstate_new]], [[yypstate *]])[
  {
    yypstate *yyps;]b4_pure_if([], [[
    if (yypstate_allocated)
@@@ -1341,7 -1445,7 +1341,7 @@@
    return yyps;
  }
  
 -]b4_c_function_def([[yypstate_delete]], [[void]],
 +]b4_function_define([[yypstate_delete]], [[void]],
                     [[[yypstate *yyps]], [[yyps]]])[
  {
  #ifndef yyoverflow
@@@ -1379,7 -1483,7 +1379,7 @@@
  | yypush_parse.  |
  `---------------*/
  
 -]b4_c_function_def([[yypush_parse]], [[int]],
 +]b4_function_define([[yypush_parse]], [[int]],
    [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
    [[[int yypushed_char]], [[yypushed_char]]],
    [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
@@@ -1391,7 -1495,12 +1391,7 @@@
  | yyparse.  |
  `----------*/
  
 -#ifdef YYPARSE_PARAM
 -]b4_c_function_def([yyparse], [int],
 -                   [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
 -#else /* ! YYPARSE_PARAM */
 -]b4_c_function_def([yyparse], [int], b4_parse_param)[
 -#endif]])[
 +]b4_function_define([yyparse], [int], b4_parse_param)])[
  {]b4_pure_if([b4_declare_scanner_communication_variables
  ])b4_push_if([b4_pure_if([], [[
    int yypushed_char = yychar;
@@@ -1490,26 -1599,26 +1490,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
@@@ -1517,23 -1626,23 +1517,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 */
@@@ -1543,10 -1652,10 +1543,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));
@@@ -1726,9 -1835,9 +1726,9 @@@ yyreduce
    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.  */
@@@ -1782,20 -1891,20 +1782,20 @@@
    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
@@@ -1828,29 -1937,29 +1828,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);
@@@ -1915,7 -2024,7 +1915,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
@@@ -1931,15 -2040,17 +1931,14 @@@ yypushreturn:]])
    if (yymsg != yymsgbuf)
      YYSTACK_FREE (yymsg);
  #endif
 -  /* Make sure YYID is used.  */
 -  return YYID (yyresult);
 +  return yyresult;
  }
 -
--
  ]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 src/parse-gram.y
index 51896994,02af75e2..fbb9b546
--- a/src/parse-gram.y
+++ b/src/parse-gram.y
@@@ -30,7 -30,6 +30,7 @@@
  #include "quotearg.h"
  #include "reader.h"
  #include "symlist.h"
 +#include "symtab.h"
  #include "scan-gram.h"
  #include "scan-code.h"
  #include "xmemdup0.h"
@@@ -39,7 -38,7 +39,7 @@@
  static YYLTYPE lloc_default (YYLTYPE const *, int);
  
  #define YY_LOCATION_PRINT(File, Loc) \
 -	  location_print (File, Loc)
 +          location_print (File, Loc)
  
  static void version_check (location const *loc, char const *version);
  
@@@ -47,51 -46,58 +47,51 @@@
     FIXME: depends on the undocumented availability of YYLLOC.  */
  #undef  yyerror
  #define yyerror(Msg) \
 -	gram_error (&yylloc, Msg)
 +        gram_error (&yylloc, Msg)
  static void gram_error (location const *, char const *);
  
  static char const *char_name (char);
 +%}
  
 -/** Add a lex-param or a parse-param.
 - *
 - * \param type  \a lex_param or \a parse_param
 - * \param decl  the formal argument
 - * \param loc   the location in the source.
 - */
 -static void add_param (char const *type, char *decl, location loc);
 -
 -
 -static symbol_class current_class = unknown_sym;
 -static uniqstr current_type = NULL;
 -static symbol *current_lhs_symbol;
 -static location current_lhs_location;
 -static named_ref *current_lhs_named_ref;
 -static int current_prec = 0;
 -
 -/** Set the new current left-hand side symbol, possibly common
 - * to several right-hand side parts of rule.
 - */
 -static
 -void
 -current_lhs(symbol *sym, location loc, named_ref *ref)
 +%code
  {
 -  current_lhs_symbol = sym;
 -  current_lhs_location = loc;
 -  /* In order to simplify memory management, named references for lhs
 -     are always assigned by deep copy into the current symbol_list
 -     node.  This is because a single named-ref in the grammar may
 -     result in several uses when the user factors lhs between several
 -     rules using "|".  Therefore free the parser's original copy.  */
 -  free (current_lhs_named_ref);
 -  current_lhs_named_ref = ref;
 -}
 -
 +  static int current_prec = 0;
 +  static location current_lhs_location;
 +  static named_ref *current_lhs_named_ref;
 +  static symbol *current_lhs_symbol;
 +  static symbol_class current_class = unknown_sym;
 +  static uniqstr current_type = NULL;
 +
 +  /** Set the new current left-hand side symbol, possibly common
 +   * to several right-hand side parts of rule.
 +   */
 +  static
 +  void
 +  current_lhs(symbol *sym, location loc, named_ref *ref)
 +  {
 +    current_lhs_symbol = sym;
 +    current_lhs_location = loc;
 +    /* In order to simplify memory management, named references for lhs
 +       are always assigned by deep copy into the current symbol_list
 +       node.  This is because a single named-ref in the grammar may
 +       result in several uses when the user factors lhs between several
 +       rules using "|".  Therefore free the parser's original copy.  */
 +    free (current_lhs_named_ref);
 +    current_lhs_named_ref = ref;
 +  }
  
 -#define YYTYPE_INT16 int_fast16_t
 -#define YYTYPE_INT8 int_fast8_t
 -#define YYTYPE_UINT16 uint_fast16_t
 -#define YYTYPE_UINT8 uint_fast8_t
 -%}
 +  #define YYTYPE_INT16 int_fast16_t
 +  #define YYTYPE_INT8 int_fast8_t
 +  #define YYTYPE_UINT16 uint_fast16_t
 +  #define YYTYPE_UINT8 uint_fast8_t
 +}
  
  %debug
  %verbose
  %defines
  %locations
  %pure-parser
 -%error-verbose
 +%define parse.error "verbose"
  %define parse.lac full
  %name-prefix="gram_"
  %expect 0
@@@ -106,15 -112,15 +106,15 @@@
  
  %union
  {
 +  assoc assoc;
 +  char *code;
 +  char const *chars;
 +  int integer;
 +  named_ref *named_ref;
    symbol *symbol;
    symbol_list *list;
 -  int integer;
 -  char const *chars;
 -  char *code;
 -  assoc assoc;
    uniqstr uniqstr;
    unsigned char character;
 -  named_ref *named_ref;
  };
  
  /* Define the tokens together with their human representation.  */
@@@ -132,36 -138,40 +132,36 @@@
  %token PERCENT_LEFT        "%left"
  %token PERCENT_RIGHT       "%right"
  %token PERCENT_NONASSOC    "%nonassoc"
 +%token PERCENT_PRECEDENCE  "%precedence"
  
  %token PERCENT_PREC          "%prec"
  %token PERCENT_DPREC         "%dprec"
  %token PERCENT_MERGE         "%merge"
  
 -
  /*----------------------.
  | Global Declarations.  |
  `----------------------*/
  
  %token
    PERCENT_CODE            "%code"
 -  PERCENT_DEBUG           "%debug"
    PERCENT_DEFAULT_PREC    "%default-prec"
    PERCENT_DEFINE          "%define"
    PERCENT_DEFINES         "%defines"
    PERCENT_ERROR_VERBOSE   "%error-verbose"
    PERCENT_EXPECT          "%expect"
 -  PERCENT_EXPECT_RR	  "%expect-rr"
 +  PERCENT_EXPECT_RR       "%expect-rr"
 +  PERCENT_FLAG            "%<flag>"
    PERCENT_FILE_PREFIX     "%file-prefix"
    PERCENT_GLR_PARSER      "%glr-parser"
    PERCENT_INITIAL_ACTION  "%initial-action"
    PERCENT_LANGUAGE        "%language"
 -  PERCENT_LEX_PARAM       "%lex-param"
 -  PERCENT_LOCATIONS       "%locations"
    PERCENT_NAME_PREFIX     "%name-prefix"
    PERCENT_NO_DEFAULT_PREC "%no-default-prec"
    PERCENT_NO_LINES        "%no-lines"
    PERCENT_NONDETERMINISTIC_PARSER
 -			  "%nondeterministic-parser"
 +                          "%nondeterministic-parser"
    PERCENT_OUTPUT          "%output"
 -  PERCENT_PARSE_PARAM     "%parse-param"
 -  PERCENT_PURE_PARSER     "%pure-parser"
 -  PERCENT_REQUIRE	  "%require"
 +  PERCENT_REQUIRE         "%require"
    PERCENT_SKELETON        "%skeleton"
    PERCENT_START           "%start"
    PERCENT_TOKEN_TABLE     "%token-table"
@@@ -170,7 -180,6 +170,7 @@@
  ;
  
  %token BRACED_CODE     "{...}"
 +%token BRACED_PREDICATE "%?{...}"
  %token BRACKETED_ID    "[identifier]"
  %token CHAR            "char"
  %token EPILOGUE        "epilogue"
@@@ -181,90 -190,39 +181,90 @@@
  %token PIPE            "|"
  %token PROLOGUE        "%{...%}"
  %token SEMICOLON       ";"
 -%token TYPE            "type"
 -%token TYPE_TAG_ANY    "<*>"
 -%token TYPE_TAG_NONE   "<>"
 +%token TAG             "<tag>"
 +%token TAG_ANY         "<*>"
 +%token TAG_NONE        "<>"
  
  %type <character> CHAR
 -%printer { fputs (char_name ($$), stderr); } CHAR
 +%printer { fputs (char_name ($$), yyo); } CHAR
  
  /* braceless is not to be used for rule or symbol actions, as it
     calls code_props_plain_init.  */
  %type <chars> STRING "%{...%}" EPILOGUE braceless content.opt
 -%type <code> "{...}"
 -%printer { fputs (quotearg_style (c_quoting_style, $$), stderr); }
 -	 STRING
 -%printer { fprintf (stderr, "{\n%s\n}", $$); }
 -	 braceless content.opt "{...}" "%{...%}" EPILOGUE
 -
 -%type <uniqstr> BRACKETED_ID ID ID_COLON TYPE variable
 -%printer { fputs ($$, stderr); } <uniqstr>
 -%printer { fprintf (stderr, "[%s]", $$); } BRACKETED_ID
 -%printer { fprintf (stderr, "%s:", $$); } ID_COLON
 -%printer { fprintf (stderr, "<%s>", $$); } TYPE
 +%type <code> "{...}" "%?{...}"
 +%printer { fputs (quotearg_style (c_quoting_style, $$), yyo); }
 +         STRING
 +%printer { fprintf (yyo, "{\n%s\n}", $$); }
 +         braceless content.opt "{...}" "%{...%}" EPILOGUE
 +
 +%type <uniqstr> BRACKETED_ID ID ID_COLON PERCENT_FLAG TAG tag variable
 +%printer { fputs ($$, yyo); } <uniqstr>
 +%printer { fprintf (yyo, "[%s]", $$); } BRACKETED_ID
 +%printer { fprintf (yyo, "%s:", $$); } ID_COLON
 +%printer { fprintf (yyo, "%%%s", $$); } PERCENT_FLAG
 +%printer { fprintf (yyo, "<%s>", $$); } TAG tag
  
  %type <integer> INT
 -%printer { fprintf (stderr, "%d", $$); } <integer>
 +%printer { fprintf (yyo, "%d", $$); } <integer>
  
  %type <symbol> id id_colon string_as_id symbol symbol.prec
 -%printer { fprintf (stderr, "%s", $$->tag); } <symbol>
 -%printer { fprintf (stderr, "%s:", $$->tag); } id_colon
 +%printer { fprintf (yyo, "%s", $$->tag); } <symbol>
 +%printer { fprintf (yyo, "%s:", $$->tag); } id_colon
  
  %type <assoc> precedence_declarator
  %type <list>  symbols.1 symbols.prec generic_symlist generic_symlist_item
  %type <named_ref> named_ref.opt
  
 +/*---------.
 +| %param.  |
 +`---------*/
 +%code requires
 +{
 +# ifndef PARAM_TYPE
 +#  define PARAM_TYPE
 +  typedef enum
 +  {
 +    param_none   = 0,
 +    param_lex    = 1 << 0,
 +    param_parse  = 1 << 1,
 +    param_both   = param_lex | param_parse
 +  } param_type;
 +# endif
 +};
 +%code
 +{
 +  /** Add a lex-param and/or a parse-param.
 +   *
 +   * \param type  where to push this formal argument.
 +   * \param decl  the formal argument.  Destroyed.
 +   * \param loc   the location in the source.
 +   */
 +  static void add_param (param_type type, char *decl, location loc);
 +  static param_type current_param = param_none;
 +};
 +%union
 +{
 +  param_type param;
 +}
 +%token <param> PERCENT_PARAM "%param";
 +%printer
 +{
 +  switch ($$)
 +    {
 +#define CASE(In, Out)                                           \
 +      case param_ ## In: fputs ("%" #Out, stderr); break
 +      CASE(lex,   lex-param);
 +      CASE(parse, parse-param);
 +      CASE(both,  param);
 +#undef CASE
 +      case param_none: aver (false); break;
 +    }
 +} <param>;
 +
 +
 +                     /*==========\
 +                     | Grammar.  |
 +                     \==========*/
  %%
  
  input:
@@@ -272,9 -230,9 +272,9 @@@
  ;
  
  
 -	/*------------------------------------.
 -	| Declarations: before the first %%.  |
 -	`------------------------------------*/
 +        /*------------------------------------.
 +        | Declarations: before the first %%.  |
 +        `------------------------------------*/
  
  prologue_declarations:
    /* Nothing */
@@@ -293,10 -251,7 +293,10 @@@ prologue_declaration
                          plain_code.code, @1);
        code_scanner_last_string_free ();
      }
 -| "%debug"                         { debug_flag = true; }
 +| "%<flag>"
 +    {
 +      muscle_percent_define_ensure ($1, @1, true);
 +    }
  | "%define" variable content.opt
      {
        muscle_percent_define_insert ($2, @2, $3,
@@@ -308,13 -263,9 +308,13 @@@
        defines_flag = true;
        spec_defines_file = xstrdup ($2);
      }
 -| "%error-verbose"                 { error_verbose = true; }
 +| "%error-verbose"
 +    {
 +      muscle_percent_define_insert ("parse.error", @1, "verbose",
 +                                    MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
 +    }
  | "%expect" INT                    { expected_sr_conflicts = $2; }
 -| "%expect-rr" INT		   { expected_rr_conflicts = $2; }
 +| "%expect-rr" INT                 { expected_rr_conflicts = $2; }
  | "%file-prefix" STRING            { spec_file_prefix = $2; }
  | "%file-prefix" "=" STRING        { spec_file_prefix = $3; } /* deprecated */
  | "%glr-parser"
@@@ -331,19 -282,36 +331,19 @@@
        muscle_code_grow ("initial_action", action.code, @2);
        code_scanner_last_string_free ();
      }
 -| "%language" STRING		{ language_argmatch ($2, grammar_prio, @1); }
 -| "%lex-param" "{...}"		{ add_param ("lex_param", $2, @2); }
 -| "%locations"                  { locations_flag = true; }
 +| "%language" STRING            { language_argmatch ($2, grammar_prio, @1); }
  | "%name-prefix" STRING         { spec_name_prefix = $2; }
  | "%name-prefix" "=" STRING     { spec_name_prefix = $3; } /* deprecated */
  | "%no-lines"                   { no_lines_flag = true; }
 -| "%nondeterministic-parser"	{ nondeterministic_parser = true; }
 +| "%nondeterministic-parser"    { nondeterministic_parser = true; }
  | "%output" STRING              { spec_outfile = $2; }
  | "%output" "=" STRING          { spec_outfile = $3; }  /* deprecated */
 -| "%parse-param" "{...}"	{ add_param ("parse_param", $2, @2); }
 -| "%pure-parser"
 -    {
 -      /* %pure-parser is deprecated in favor of `%define api.pure', so use
 -         `%define api.pure' in a backward-compatible manner here.  First, don't
 -         complain if %pure-parser is specified multiple times.  */
 -      if (!muscle_find_const ("percent_define(api.pure)"))
 -        muscle_percent_define_insert ("api.pure", @1, "",
 -                                      MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
 -      /* In all cases, use api.pure now so that the backend doesn't complain if
 -         the skeleton ignores api.pure, but do warn now if there's a previous
 -         conflicting definition from an actual %define.  */
 -      if (!muscle_percent_define_flag_if ("api.pure"))
 -        muscle_percent_define_insert ("api.pure", @1, "",
 -                                      MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
 -    }
 +| "%param" { current_param = $1; } params { current_param = param_none; }
  | "%require" STRING             { version_check (&@2, $2); }
  | "%skeleton" STRING
      {
        char const *skeleton_user = $2;
 -      if (mbschr (skeleton_user, '/'))
 +      if (strchr (skeleton_user, '/'))
          {
            size_t dir_length = strlen (current_file);
            char *skeleton_build;
@@@ -370,16 -338,6 +370,16 @@@
  | /*FIXME: Err?  What is this horror doing here? */ ";"
  ;
  
 +params:
 +   params "{...}"  { add_param (current_param, $2, @2); }
 +| "{...}"          { add_param (current_param, $1, @1); }
 +;
 +
 +
 +/*----------------------.
 +| grammar_declaration.  |
 +`----------------------*/
 +
  grammar_declaration:
    precedence_declaration
  | symbol_declaration
@@@ -387,7 -345,19 +387,7 @@@
      {
        grammar_start_symbol_set ($2, @2);
      }
 -| "%destructor" "{...}" generic_symlist
 -    {
 -      code_props code;
 -      code_props_symbol_action_init (&code, $2, @2);
 -      code_props_translate_code (&code);
 -      {
 -        symbol_list *list;
 -        for (list = $3; list; list = list->next)
 -          symbol_list_destructor_set (list, &code);
 -        symbol_list_free ($3);
 -      }
 -    }
 -| "%printer" "{...}" generic_symlist
 +| code_props_type "{...}" generic_symlist
      {
        code_props code;
        code_props_symbol_action_init (&code, $2, @2);
@@@ -395,7 -365,7 +395,7 @@@
        {
          symbol_list *list;
          for (list = $3; list; list = list->next)
 -          symbol_list_printer_set (list, &code);
 +          symbol_list_code_props_set (list, $1, &code);
          symbol_list_free ($3);
        }
      }
@@@ -421,17 -391,10 +421,17 @@@
      }
  ;
  
 +%type <code_type> code_props_type;
 +%union {code_props_type code_type;};
 +%printer { fprintf (yyo, "%s", code_props_type_string ($$)); } <code_type>;
 +code_props_type:
 +  "%destructor"  { $$ = destructor; }
 +| "%printer"     { $$ = printer; }
 +;
  
 -/*----------*
 - | %union.  |
 - *----------*/
 +/*---------.
 +| %union.  |
 +`---------*/
  
  %token PERCENT_UNION "%union";
  
@@@ -463,41 -426,40 +463,41 @@@ symbol_declaration
        current_class = unknown_sym;
        current_type = NULL;
      }
 -| "%type" TYPE symbols.1
 +| "%type" TAG symbols.1
      {
        symbol_list *list;
        tag_seen = true;
        for (list = $3; list; list = list->next)
 -	symbol_type_set (list->content.sym, $2, @2);
 +        symbol_type_set (list->content.sym, $2, @2);
        symbol_list_free ($3);
      }
  ;
  
  precedence_declaration:
 -  precedence_declarator type.opt symbols.prec
 +  precedence_declarator tag.opt symbols.prec
      {
        symbol_list *list;
        ++current_prec;
        for (list = $3; list; list = list->next)
 -	{
 -	  symbol_type_set (list->content.sym, current_type, @2);
 -	  symbol_precedence_set (list->content.sym, current_prec, $1, @1);
 -	}
 +        {
 +          symbol_type_set (list->content.sym, current_type, @2);
 +          symbol_precedence_set (list->content.sym, current_prec, $1, @1);
 +        }
        symbol_list_free ($3);
        current_type = NULL;
      }
  ;
  
  precedence_declarator:
 -  "%left"     { $$ = left_assoc; }
 -| "%right"    { $$ = right_assoc; }
 -| "%nonassoc" { $$ = non_assoc; }
 +  "%left"       { $$ = left_assoc; }
 +| "%right"      { $$ = right_assoc; }
 +| "%nonassoc"   { $$ = non_assoc; }
 +| "%precedence" { $$ = precedence_assoc; }
  ;
  
 -type.opt:
 +tag.opt:
    /* Nothing. */ { current_type = NULL; }
 -| TYPE           { current_type = $1; tag_seen = true; }
 +| TAG            { current_type = $1; tag_seen = true; }
  ;
  
  /* Just like symbols.1 but accept INT for the sake of POSIX.  */
@@@ -509,9 -471,9 +509,9 @@@ symbols.prec
  ;
  
  symbol.prec:
 -    symbol { $$ = $1; }
 -  | symbol INT { $$ = $1; symbol_user_token_number_set ($1, $2, @2); }
 -  ;
 +  symbol     { $$ = $1; }
 +| symbol INT { $$ = $1; symbol_user_token_number_set ($1, $2, @2); }
 +;
  
  /* One or more symbols to be %typed. */
  symbols.1:
@@@ -527,19 -489,15 +527,19 @@@ generic_symlist
  ;
  
  generic_symlist_item:
 -  symbol            { $$ = symbol_list_sym_new ($1, @1); }
 -| TYPE              { $$ = symbol_list_type_new ($1, @1); }
 -| "<*>"             { $$ = symbol_list_default_tagged_new (@1); }
 -| "<>"             { $$ = symbol_list_default_tagless_new (@1); }
 +  symbol    { $$ = symbol_list_sym_new ($1, @1); }
 +| tag       { $$ = symbol_list_type_new ($1, @1); }
 +;
 +
 +tag:
 +  TAG
 +| "<*>" { $$ = uniqstr_new ("*"); }
 +| "<>"  { $$ = uniqstr_new (""); }
  ;
  
  /* One token definition.  */
  symbol_def:
 -  TYPE
 +  TAG
       {
         current_type = $1;
         tag_seen = true;
@@@ -577,9 -535,9 +577,9 @@@ symbol_defs.1
  ;
  
  
 -	/*------------------------------------------.
 -	| The grammar section: between the two %%.  |
 -	`------------------------------------------*/
 +        /*------------------------------------------.
 +        | The grammar section: between the two %%.  |
 +        `------------------------------------------*/
  
  grammar:
    rules_or_grammar_declaration
@@@ -614,18 -572,16 +614,18 @@@ rhses.1
  rhs:
    /* Nothing.  */
      { grammar_current_rule_begin (current_lhs_symbol, current_lhs_location,
 -				  current_lhs_named_ref); }
 +                                  current_lhs_named_ref); }
  | rhs symbol named_ref.opt
      { grammar_current_rule_symbol_append ($2, @2, $3); }
  | rhs "{...}" named_ref.opt
 -    { grammar_current_rule_action_append ($2, @2, $3); }
 +    { grammar_current_rule_action_append ($2, @2, $3, false); }
 +| rhs "%?{...}"
 +    { grammar_current_rule_action_append ($2, @2, NULL, true); }
  | rhs "%prec" symbol
      { grammar_current_rule_prec_set ($3, @3); }
  | rhs "%dprec" INT
      { grammar_current_rule_dprec_set ($3, @3); }
 -| rhs "%merge" TYPE
 +| rhs "%merge" TAG
      { grammar_current_rule_merge_set ($3, @3); }
  ;
  
@@@ -635,9 -591,10 +635,9 @@@ named_ref.opt
    BRACKETED_ID   { $$ = named_ref_new($1, @1); }
  ;
  
 -
 -/*----------------------------*
 - | variable and content.opt.  |
 - *---------------------------*/
 +/*---------------------------.
 +| variable and content.opt.  |
 +`---------------------------*/
  
  /* The STRING form of variable is deprecated and is not M4-friendly.
     For example, M4 fails for `%define "[" "value"'.  */
@@@ -654,9 -611,9 +654,9 @@@ content.opt
  ;
  
  
 -/*-------------*
 - | braceless.  |
 - *-------------*/
 +/*------------.
 +| braceless.  |
 +`------------*/
  
  braceless:
    "{...}"
@@@ -671,9 -628,9 +671,9 @@@
  ;
  
  
 -/*---------------*
 - | Identifiers.  |
 - *---------------*/
 +/*--------------.
 +| Identifiers.  |
 +`--------------*/
  
  /* Identifiers are returned as uniqstr values by the scanner.
     Depending on their use, we may need to make them genuine symbols.  */
@@@ -746,52 -703,51 +746,54 @@@ lloc_default (YYLTYPE const *rhs, int n
    for (i = 1; i <= n; i++)
      if (! equal_boundaries (rhs[i].start, rhs[i].end))
        {
 -	loc.start = rhs[i].start;
 -	break;
 +        loc.start = rhs[i].start;
 +        break;
        }
  
    return loc;
  }
  
  
 -/* Add a lex-param or a parse-param (depending on TYPE) with
 -   declaration DECL and location LOC.  */
 -
  static void
 -add_param (char const *type, char *decl, location loc)
 +add_param (param_type type, char *decl, location loc)
  {
    static char const alphanum[26 + 26 + 1 + 10] =
      "abcdefghijklmnopqrstuvwxyz"
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
      "_"
      "0123456789";
 +
    char const *name_start = NULL;
 -  char *p;
 -
 -  /* Stop on last actual character.  */
 -  for (p = decl; p[1]; p++)
 -    if ((p == decl
 -	 || ! memchr (alphanum, p[-1], sizeof alphanum))
 -	&& memchr (alphanum, p[0], sizeof alphanum - 10))
 -      name_start = p;
 -
 -  /* Strip the surrounding '{' and '}', and any blanks just inside
 -     the braces.  */
 -  --p;
 -  while (isspace ((unsigned char) *p))
 +  {
 +    char *p;
 +    /* Stop on last actual character.  */
 +    for (p = decl; p[1]; p++)
 +      if ((p == decl
 +           || ! memchr (alphanum, p[-1], sizeof alphanum))
 +          && memchr (alphanum, p[0], sizeof alphanum - 10))
 +        name_start = p;
 +
 +    /* Strip the surrounding '{' and '}', and any blanks just inside
 +       the braces.  */
-     while (*--p == ' ' || *p == '\t')
-       continue;
+     --p;
 -  p[1] = '\0';
 -  ++decl;
 -  while (isspace ((unsigned char) *decl))
++    while (isspace ((unsigned char) *p))
++      --p;
 +    p[1] = '\0';
-     while (*++decl == ' ' || *decl == '\t')
-       continue;
+     ++decl;
++    while (isspace ((unsigned char) *decl))
++      ++decl;
 +  }
  
    if (! name_start)
 -    complain_at (loc, _("missing identifier in parameter declaration"));
 +    complain_at (loc, complaint,
 +                 _("missing identifier in parameter declaration"));
    else
      {
        char *name = xmemdup0 (name_start, strspn (name_start, alphanum));
 -      muscle_pair_list_grow (type, decl, name);
 +      if (type & param_lex)
 +        muscle_pair_list_grow ("lex_param", decl, name);
 +      if (type & param_parse)
 +        muscle_pair_list_grow ("parse_param", decl, name);
        free (name);
      }
  
@@@ -804,7 -760,7 +806,7 @@@ version_check (location const *loc, cha
  {
    if (strverscmp (version, PACKAGE_VERSION) > 0)
      {
 -      complain_at (*loc, "require bison %s, but have %s",
 +      complain_at (*loc, complaint, "require bison %s, but have %s",
                     version, PACKAGE_VERSION);
        exit (EX_MISMATCH);
      }
@@@ -813,7 -769,7 +815,7 @@@
  static void
  gram_error (location const *loc, char const *msg)
  {
 -  complain_at (*loc, "%s", msg);
 +  complain_at (*loc, complaint, "%s", msg);
  }
  
  char const *
diff --combined tests/calc.at
index 8d0fcb39,3aab8681..89cc59ea
--- a/tests/calc.at
+++ b/tests/calc.at
@@@ -205,12 -205,12 +205,12 @@@ read_signed_integer (]AT_YYLEX_FORMALS[
      {
        unget_char (]AT_YYLEX_PRE_ARGS[ c);
        ]AT_VAL[.ival = read_signed_integer (]AT_YYLEX_ARGS[);
 -      return NUM;
 +      return ]AT_TOKEN_PREFIX[NUM;
      }
  
    /* Return end-of-file.  */
    if (c == EOF)
 -    return CALC_EOF;
 +    return ]AT_TOKEN_PREFIX[CALC_EOF;
  
    /* Return single chars. */
    return c;
@@@ -288,7 -288,7 +288,7 @@@ static int power (int base, int exponen
  ]AT_YYLEX_DECLARE_EXTERN[
  }
  
 -]AT_SKEL_CC_IF([AT_LOCATION_TYPE_IF([], [[
 +]AT_SKEL_CC_IF([AT_LOCATION_IF([AT_LOCATION_TYPE_IF([], [
  /* The lalr1.cc skeleton, for backward compatibility, defines
     a constructor for position that initializes the filename.  The
     glr.cc skeleton does not (and in fact cannot: location/position
@@@ -297,18 -297,18 +297,18 @@@
  %initial-action {
    @$.initialize ();
  }
 -]])])[
 +])])])[
  
  /* Bison Declarations */
  %token CALC_EOF 0 "end of input"
  %token <ival> NUM "number"
  %type  <ival> exp
  
 -%nonassoc '=' /* comparison            */
 +%nonassoc '='   /* comparison          */
  %left '-' '+'
  %left '*' '/'
 -%left NEG     /* negation--unary minus */
 -%right '^'    /* exponentiation        */
 +%precedence NEG /* negation--unary minus */
 +%right '^'      /* exponentiation        */
  
  /* Grammar follows */
  %%
@@@ -386,11 -386,9 +386,9 @@@ AT_YYERROR_SEES_LOC_IF(
    fprintf (stderr, ": ");])
    fprintf (stderr, "%s\n", s);
  }])[
- 
  ]AT_DEFINES_IF([],
  [AT_CALC_LEX
- AT_CALC_MAIN])[
- ]])
+ AT_CALC_MAIN])])
  
  AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
  [[#include "calc.h]AT_SKEL_CC_IF([[h]])["
@@@ -450,7 -448,7 +448,7 @@@ AT_PARSER_CHECK([./calc input], 0, [], 
  # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
  # is correctly output on stderr.
  #
 -# If BISON-OPTIONS contains `%error-verbose', then make sure the
 +# If BISON-OPTIONS contains `%define parse.error verbose', then make sure the
  # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
  # on STDERR.
  #
@@@ -492,7 -490,7 +490,7 @@@ AT_YYERROR_SEES_LOC_IF([]
  [[sed 's/^[-0-9.]*: //' expout >at-expout
  mv at-expout expout]])
  # 4. If error-verbose is not used, strip the`, unexpected....' part.
 -m4_bmatch([$1], [%error-verbose], [],
 +m4_bmatch([$1], [%define parse.error verbose], [],
  [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
  mv at-expout expout]])
  # 5. Check
@@@ -500,6 -498,20 +498,20 @@@ AT_CHECK([cat stderr], 0, [expout]
  ])
  
  
+ # AT_CHECK_SPACES([FILE])
+ # -----------------------
+ # Make sure we did not introduce bad spaces.  Checked here because all
+ # the skeletons are (or should be) exercized here.
+ m4_define([AT_CHECK_SPACES],
+ [# No initial empty lines.
+ AT_CHECK([sed -ne '/./q;=;p;' $1])
+ # No trailing spaces.
+ # FIXME: For 2.7: AT_CHECK([sed -ne '/[ ]$/{=;p;}' $1])
+ # No final empty lines.
+ AT_CHECK([sed -ne '${/^$/{=;p;};}' $1])
+ ])
+ 
+ 
  # AT_CHECK_CALC([BISON-OPTIONS])
  # ------------------------------
  # Start a testing chunk which compiles `calc' grammar with
@@@ -514,6 -526,8 +526,8 @@@ AT_BISON_OPTION_PUSHDEFS([$1]
  
  AT_DATA_CALC_Y([$1])
  AT_FULL_COMPILE([calc], AT_DEFINES_IF([[lex], [main]]))
+ AT_CHECK_SPACES([calc.AT_SKEL_CC_IF([cc], [c])])
+ AT_DEFINES_IF([AT_CHECK_SPACES([calc.AT_SKEL_CC_IF([hh], [h])])])
  
  # Test the priorities.
  _AT_CHECK_CALC([$1],
@@@ -621,23 -635,23 +635,23 @@@ AT_CHECK_CALC_LALR([%locations]
  AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
  AT_CHECK_CALC_LALR([%verbose])
  AT_CHECK_CALC_LALR([%yacc])
 -AT_CHECK_CALC_LALR([%error-verbose])
 +AT_CHECK_CALC_LALR([%define parse.error verbose])
  
  AT_CHECK_CALC_LALR([%define api.pure %locations])
  AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations])
 -AT_CHECK_CALC_LALR([%error-verbose %locations])
 +AT_CHECK_CALC_LALR([%define parse.error verbose %locations])
  
 -AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
 -AT_CHECK_CALC_LALR([%error-verbose %locations %defines %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
  
  AT_CHECK_CALC_LALR([%debug])
 -AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 -AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc])
  
 -AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 -AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %error-verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc])
  
 -AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 +AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
  
  
  # ----------------------- #
@@@ -662,21 -676,21 +676,21 @@@ AT_CHECK_CALC_GLR([%name-prefix "calc"]
  AT_CHECK_CALC_GLR([%define api.prefix "calc"])
  AT_CHECK_CALC_GLR([%verbose])
  AT_CHECK_CALC_GLR([%yacc])
 -AT_CHECK_CALC_GLR([%error-verbose])
 +AT_CHECK_CALC_GLR([%define parse.error verbose])
  
  AT_CHECK_CALC_GLR([%define api.pure %locations])
 -AT_CHECK_CALC_GLR([%error-verbose %locations])
 +AT_CHECK_CALC_GLR([%define parse.error verbose %locations])
  
 -AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
  
  AT_CHECK_CALC_GLR([%debug])
 -AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 -AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %define api.prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
  
 -AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
  
 -AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 -AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 +AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
 +AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
  
  
  # ----------------------------- #
@@@ -686,30 -700,25 +700,30 @@@
  AT_BANNER([[Simple LALR(1) C++ Calculator.]])
  
  # First let's try using %skeleton
 -AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
 +AT_CHECK_CALC([%skeleton "lalr1.cc" %defines])
  
  # AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
  # ---------------------------------------
  # Start a testing chunk which compiles `calc' grammar with
  # the C++ skeleton, and performs several tests over the parser.
  m4_define([AT_CHECK_CALC_LALR1_CC],
 -[AT_CHECK_CALC([%language "C++" %defines %locations] $@)])
 +[AT_CHECK_CALC([%language "C++"] $@)])
  
  AT_CHECK_CALC_LALR1_CC([])
 -AT_CHECK_CALC_LALR1_CC([%define location_type Span])
 -AT_CHECK_CALC_LALR1_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
 -AT_CHECK_CALC_LALR1_CC([%error-verbose %define api.prefix "calc" %verbose %yacc])
 -AT_CHECK_CALC_LALR1_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR1_CC([%locations])
 +AT_CHECK_CALC_LALR1_CC([%locations %define location_type Span])
 +AT_CHECK_CALC_LALR1_CC([%defines %locations %define parse.error verbose %name-prefix "calc" %verbose %yacc])
  
 -AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
  
 -AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 -AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 +AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
 +
 +AT_CHECK_CALC_LALR1_CC([%defines %locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
 +
 +AT_CHECK_CALC_LALR1_CC([%pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
 +AT_CHECK_CALC_LALR1_CC([%defines %locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
  
  
  
@@@ -720,7 -729,7 +734,7 @@@
  AT_BANNER([[Simple GLR C++ Calculator.]])
  
  # Again, we try also using %skeleton.
 -AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
 +AT_CHECK_CALC([%skeleton "glr.cc" %defines])
  
  # AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
  # -------------------------------------
@@@ -730,16 -739,14 +744,16 @@@ m4_define([AT_CHECK_CALC_GLR_CC]
  [AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
  
  AT_CHECK_CALC_GLR_CC([])
 -AT_CHECK_CALC_GLR_CC([%define location_type Span])
 -AT_CHECK_CALC_GLR_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
 -AT_CHECK_CALC_GLR_CC([%error-verbose %define api.prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR_CC([%locations])
 +AT_CHECK_CALC_GLR_CC([%locations %define location_type Span])
 +AT_CHECK_CALC_GLR_CC([%define parse.error verbose %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR_CC([%define parse.error verbose %define api.prefix "calc" %verbose %yacc])
  
  AT_CHECK_CALC_GLR_CC([%debug])
 -AT_CHECK_CALC_GLR_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR_CC([%define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
  
 -AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
 +AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
  
 -AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 -AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 +AT_CHECK_CALC_GLR_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
 +AT_CHECK_CALC_GLR_CC([%locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
diff --combined tests/regression.at
index 58988c81,2f029939..cdc15724
--- a/tests/regression.at
+++ b/tests/regression.at
@@@ -209,7 -209,7 +209,7 @@@ exp: '(' exp ')' | NUM 
  AT_BISON_OPTION_POPDEFS
  
  AT_BISON_CHECK([-v -o input.c input.y], 0, [],
 -[[input.y:6.8-14: warning: symbol "<=" used more than once as a literal string
 +[[input.y:6.8-14: warning: symbol "<=" used more than once as a literal string [-Wother]
  ]])
  
  AT_CLEANUP
@@@ -478,8 -478,8 +478,8 @@@ AT_BISON_OPTION_POPDEF
  # C-string literal.  Also notice that unnecessary escaping, such as "\?", from
  # the user specification is eliminated.
  AT_BISON_CHECK([-o input.c input.y], [[0]], [[]],
 -[[input.y:22.8-14: warning: symbol SPECIAL redeclared
 -input.y:22.8-63: warning: symbol "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!" used more than once as a literal string
 +[[input.y:22.8-14: warning: symbol SPECIAL redeclared [-Wother]
 +input.y:22.8-63: warning: symbol "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!" used more than once as a literal string [-Wother]
  ]])
  AT_COMPILE([input])
  
@@@ -538,7 -538,7 +538,7 @@@ AT_SETUP([Web2c Report]
  AT_KEYWORDS([report])
  
  AT_DATA([input.y],
 -[[%token	undef_id_tok const_id_tok
 +[[%token        undef_id_tok const_id_tok
  
  %start CONST_DEC_PART
  
@@@ -548,12 -548,12 +548,12 @@@ CONST_DEC_PART
          ;
  
  CONST_DEC_LIST:
 -	  CONST_DEC
 +          CONST_DEC
          | CONST_DEC_LIST CONST_DEC
          ;
  
  CONST_DEC:
 -	  { } undef_id_tok '=' const_id_tok ';'
 +          { } undef_id_tok '=' const_id_tok ';'
          ;
  %%
  ]])
@@@ -759,6 -759,15 +759,6 @@@ AT_CHECK([[cat tables.c]], 0
         2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
         5,     6
  };
 -static const yytype_uint8 yyprhs[] =
 -{
 -       0,     0,     3,     5,     6,     9,    14
 -};
 -static const yytype_int8 yyrhs[] =
 -{
 -       8,     0,    -1,     9,    -1,    -1,    10,    11,    -1,     3,
 -       4,     5,     8,    -1,     6,     8,    -1
 -};
  static const yytype_uint8 yyrline[] =
  {
         0,     2,     2,     3,     3,     4,     5
@@@ -772,24 -781,32 +772,24 @@@ static const yytype_uint16 yytoknum[] 
  {
         0,   256,   257,   258,   259,   260,   261
  };
 -static const yytype_uint8 yyr1[] =
 -{
 -       0,     7,     8,     9,     9,    10,    11
 -};
 -static const yytype_uint8 yyr2[] =
 +static const yytype_int8 yypact[] =
  {
 -       0,     2,     1,     0,     2,     4,     2
 +      -2,    -1,     4,    -8,     0,     2,    -8,    -2,    -8,    -2,
 +      -8,    -8
  };
  static const yytype_uint8 yydefact[] =
  {
         3,     0,     0,     2,     0,     0,     1,     3,     4,     3,
         6,     5
  };
 -static const yytype_int8 yydefgoto[] =
 -{
 -      -1,     2,     3,     4,     8
 -};
 -static const yytype_int8 yypact[] =
 -{
 -      -2,    -1,     4,    -8,     0,     2,    -8,    -2,    -8,    -2,
 -      -8,    -8
 -};
  static const yytype_int8 yypgoto[] =
  {
        -8,    -7,    -8,    -8,    -8
  };
 +static const yytype_int8 yydefgoto[] =
 +{
 +      -1,     2,     3,     4,     8
 +};
  static const yytype_uint8 yytable[] =
  {
        10,     1,    11,     5,     6,     0,     7,     9
@@@ -803,14 -820,6 +803,14 @@@ static const yytype_uint8 yystos[] 
         0,     3,     8,     9,    10,     4,     0,     6,    11,     5,
         8,     8
  };
 +static const yytype_uint8 yyr1[] =
 +{
 +       0,     7,     8,     9,     9,    10,    11
 +};
 +static const yytype_uint8 yyr2[] =
 +{
 +       0,     2,     1,     0,     2,     4,     2
 +};
  ]])
  
  AT_CLEANUP
@@@ -908,7 -917,6 +908,6 @@@ m4_define([AT_CHECK_DANCER]
  [AT_SETUP([Dancer $1])
  AT_BISON_OPTION_PUSHDEFS([$1])
  _AT_DATA_DANCER_Y([$1])
- AT_BISON_CHECK([-o dancer.c dancer.y])
  AT_FULL_COMPILE([dancer])
  AT_PARSER_CHECK([./dancer], 1, [],
  [syntax error, unexpected ':'
@@@ -931,11 -939,11 +930,11 @@@ AT_CHECK_DANCER([%skeleton "lalr1.cc"]
  # --------------------------------
  m4_define([_AT_DATA_EXPECT2_Y],
  [AT_DATA_GRAMMAR([expect2.y],
 -[[%{
 -static int yylex (]AT_LALR1_CC_IF([int *], [void]));
 -AT_LALR1_CC_IF([],
 -[[#include <stdio.h>
 -#include <stdlib.h>
 +[%{
 +static int yylex (AT_LALR1_CC_IF([int *], [void]));
 +AT_LALR1_CC_IF([[#include <cstdlib>]],
 +[[#include <stdlib.h>
 +#include <stdio.h>
  ]AT_YYERROR_DECLARE])[
  %}
  $1
@@@ -993,7 -1001,6 +992,6 @@@ m4_define([AT_CHECK_EXPECT2]
  [AT_SETUP([Expecting two tokens $1])
  AT_BISON_OPTION_PUSHDEFS([$1])
  _AT_DATA_EXPECT2_Y([$1])
- AT_BISON_CHECK([-o expect2.c expect2.y])
  AT_FULL_COMPILE([expect2])
  AT_PARSER_CHECK([./expect2], 1, [],
  [syntax error, unexpected '+', expecting A or B
@@@ -1031,7 -1038,7 +1029,7 @@@ AT_DATA_GRAMMAR([input.y]
  start:
    {
      printf ("Bison would once convert this action to a midrule because of the"
 -	    " subsequent braced code.\n");
 +            " subsequent braced code.\n");
    }
    ;
  
@@@ -1184,8 -1191,8 +1182,8 @@@ main (void
  AT_BISON_OPTION_POPDEFS
  
  AT_BISON_CHECK([[-o input.c input.y]], [[0]],,
 -[[input.y:23.5-19: warning: rule useless in parser due to conflicts: start: start
 -input.y:27.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias"
 +[[input.y:23.5-19: warning: rule useless in parser due to conflicts: start: start [-Wother]
 +input.y:27.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias" [-Wother]
  ]])
  AT_COMPILE([[input]])
  AT_PARSER_CHECK([[./input]])
@@@ -1203,9 -1210,8 +1201,9 @@@ AT_CLEANU
  
  AT_SETUP([[parse-gram.y: LALR = IELR]])
  
 -# Avoid differences in synclines by telling bison that the output files
 -# have the same name.
 +# Avoid tests/bison's dark magic by processing a local copy of the
 +# grammar.  Avoid differences in synclines by telling bison that the
 +# output files have the same name.
  [cp $abs_top_srcdir/src/parse-gram.y input.y]
  AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]])
  [mv input.c lalr.c]
@@@ -1219,11 -1225,11 +1217,11 @@@ AT_CLEANU
  
  
  
 -## --------------------------------------- ##
 -## %error-verbose and YYSTACK_USE_ALLOCA.  ##
 -## --------------------------------------- ##
 +## -------------------------------------------- ##
 +## parse.error=verbose and YYSTACK_USE_ALLOCA.  ##
 +## -------------------------------------------- ##
  
 -AT_SETUP([[%error-verbose and YYSTACK_USE_ALLOCA]])
 +AT_SETUP([[parse.error=verbose and YYSTACK_USE_ALLOCA]])
  
  AT_BISON_OPTION_PUSHDEFS
  AT_DATA_GRAMMAR([input.y],
@@@ -1234,7 -1240,7 +1232,7 @@@
    #define YYSTACK_USE_ALLOCA 1
  }
  
 -%error-verbose
 +%define parse.error verbose
  
  %%
  
@@@ -1267,9 -1273,9 +1265,9 @@@ syntax_error
  %%
  
  ]AT_YYERROR_DEFINE[
 -/* Induce two syntax error messages (which requires full error
 -   recovery by shifting 3 tokens) in order to detect any loss of the
 -   reallocated buffer.  */
 +  /* Induce two syntax error messages (which requires full error
 +     recovery by shifting 3 tokens) in order to detect any loss of the
 +     reallocated buffer.  */
  ]AT_YYLEX_DEFINE(["abc"])[
  int
  main (void)
@@@ -1290,9 -1296,9 +1288,9 @@@ AT_CLEANU
  
  
  
 -## ------------------------- ##
 -## %error-verbose overflow.  ##
 -## ------------------------- ##
 +## ------------------------------ ##
 +## parse.error=verbose overflow.  ##
 +## ------------------------------ ##
  
  # Imagine the case where YYSTACK_ALLOC_MAXIMUM = YYSIZE_MAXIMUM and an
  # invocation of yysyntax_error has caused yymsg_alloc to grow to exactly
@@@ -1302,8 -1308,7 +1300,8 @@@
  # size calculation would return YYSIZE_MAXIMUM to yyparse.  Then,
  # yyparse would invoke yyerror using the old contents of yymsg.
  
 -AT_SETUP([[%error-verbose overflow]])
 +AT_SETUP([[parse.error=verbose overflow]])
 +
  AT_BISON_OPTION_PUSHDEFS
  AT_DATA_GRAMMAR([input.y],
  [[%code {
@@@ -1328,7 -1333,7 +1326,7 @@@
    #define YYMAXDEPTH 100
  }
  
 -%error-verbose
 +%define parse.error verbose
  
  %%
  
@@@ -1376,8 -1381,8 +1374,8 @@@ syntax_error2
  %%
  
  ]AT_YYERROR_DEFINE[
 -/* Induce two syntax error messages (which requires full error
 -   recovery by shifting 3 tokens).  */
 +  /* Induce two syntax error messages (which requires full error
 +     recovery by shifting 3 tokens).  */
  ]AT_YYLEX_DEFINE(["abc"])[
  int
  main (void)
@@@ -1427,7 -1432,7 +1425,7 @@@ AT_DATA_GRAMMAR([input.y]
  }
  
  ]$1[
 -%error-verbose
 +%define parse.error verbose
  %token 'c'
  
  %%
@@@ -1578,3 -1583,87 +1576,87 @@@ Stack now 
  m4_popdef([AT_LAC_CHECK])
  
  AT_CLEANUP
+ 
+ 
+ ## ---------------------- ##
+ ## Lex and parse params.  ##
+ ## ---------------------- ##
+ 
+ # AT_TEST(SKELETON)
+ # -----------------
+ # Check that the identifier of the params is properly fetched
+ # even when there are trailing blanks.
+ 
+ m4_pushdef([AT_TEST],
+ [AT_SETUP([[Lex and parse params: $1]])
+ 
+ AT_BISON_OPTION_PUSHDEFS([%locations %skeleton $1])
+ 
+ ## FIXME: Improve parsing of parse-param and use the generated
+ ## yyerror.
+ AT_DATA_GRAMMAR([input.y],
+ [[%defines
+ %locations
+ %skeleton $1
+ %union { int ival; }
+ %parse-param { int x }
+ // Spaces, tabs, and new lines.
+ %parse-param { @&t@
+ 	 int y	 @&t@
+          @&t@
+  @&t@
+ }
+ 
+ %{
+ #include <stdio.h>
+ #include <stdlib.h>
+ 
+ ]AT_SKEL_CC_IF([], [[
+ static
+ void
+ yyerror (int x, int y, const char *msg)
+ {
+   fprintf (stderr, "x: %d, y: %d, %s\n", x, y, msg);
+ }]])[
+ 
+   ]AT_YYLEX_DECLARE[
+ %}
+ 
+ %%
+ exp: 'a' { fprintf (stdout, "x: %d, y: %d\n", x, y); };
+ %%
+ ]AT_YYLEX_DEFINE(["a"])[
+ 
+ ]AT_SKEL_CC_IF(
+ [AT_YYERROR_DEFINE
+ 
+ int
+ yyparse (int x, int y)
+ {
+   yy::parser parser(x, y);
+   return parser.parse ();
+ }
+ ])[
+ 
+ int
+ main (void)
+ {
+   return !!yyparse(1, 2);
+ }
+ ]])
+ 
+ AT_FULL_COMPILE([input])
+ AT_CHECK([./input], 0, [[x: 1, y: 2
+ ]])
+ AT_BISON_OPTION_POPDEFS
+ 
+ AT_CLEANUP
+ ])
+ 
+ ## FIXME: test Java, and iterate over skeletons.
+ AT_TEST("yacc.c")
+ AT_TEST("glr.c")
+ AT_TEST("lalr1.cc")
+ AT_TEST("glr.cc")
+ 
+ m4_popdef([AT_TEST])