From: Akim Demaille <akim@lrde.epita.fr>
Date: Wed, 26 Sep 2012 10:19:15 +0000 (+0200)
Subject: Merge remote-tracking branch 'origin/maint'
X-Git-Tag: v2.7.90~325
X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/6c05543cb03b40b9728f7073c4073ce993d796c6?ds=inline;hp=-c

Merge remote-tracking branch 'origin/maint'

* origin/maint:
  regen
  yacc: fix handling of CPP guards when no header is generated
  gnulib: update
---

6c05543cb03b40b9728f7073c4073ce993d796c6
diff --combined NEWS
index bc66a4cb,75a11bf0..7f0fe8b2
--- a/NEWS
+++ b/NEWS
@@@ -2,203 -2,17 +2,214 @@@ 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
 +
 +*** Deprecated constructs
 +
 +  The new 'deprecated' warning category flags obsolete constructs whose
 +  support will be discontinued.  It is enabled by default.  These warnings
 +  used to be reported as 'other' 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
 +
 +*** Undefined but unused symbols
 +
 +  Bison used to raise an error for undefined symbols that are not used in
 +  the grammar.  This is now only a warning.
 +
 +    %printer    {} symbol1
 +    %destructor {} symbol2
 +    %type <type>   symbol3
 +    %%
 +    exp: "a";
 +
 +*** 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>
 +
 +*** Conflicts
 +
 +  The warnings and error messages about shift/reduce and reduce/reduce
 +  conflicts have been normalized.  For instance on the following foo.y file:
 +
 +    %glr-parser
 +    %%
 +    exp: exp '+' exp | '0' | '0';
 +
 +  compare the previous version of bison:
 +
 +    $ bison foo.y
 +    foo.y: conflicts: 1 shift/reduce, 2 reduce/reduce
 +    $ bison -Werror foo.y
 +    bison: warnings being treated as errors
 +    foo.y: conflicts: 1 shift/reduce, 2 reduce/reduce
 +
 +  with the new behavior:
 +
 +    $ bison foo.y
 +    foo.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
 +    foo.y: warning: 2 reduce/reduce conflicts [-Wconflicts-rr]
 +    $ bison -Werror foo.y
 +    bison: warnings being treated as errors
 +    foo.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
 +    foo.y: warning: 2 reduce/reduce conflicts [-Wconflicts-rr]
 +
 +  When %expect or %expect-rr is used, such as with bar.y:
 +
 +    %expect 0
 +    %glr-parser
 +    %%
 +    exp: exp '+' exp | '0' | '0';
 +
 +  Former behavior:
 +
 +    $ bison bar.y
 +    bar.y: conflicts: 1 shift/reduce, 2 reduce/reduce
 +    bar.y: expected 0 shift/reduce conflicts
 +    bar.y: expected 0 reduce/reduce conflicts
 +
 +  New one:
 +
 +    $ bison bar.y
 +    bar.y: shift/reduce conflicts: 1 found, 0 expected
 +    bar.y: reduce/reduce conflicts: 2 found, 0 expected
 +
 +** 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
 +
 +*** The parser header is no longer mandatory (lalr1.cc, glr.cc)
 +
 +  Using %defines is now optional.  Without it, the needed support classes
 +  are defined in the generated parser, instead of additional files (such as
 +  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
 +
 +  This variable 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.
 +
 +** The directive %expect-rr is now an error in non GLR mode
 +
 +  It used to be an error only if used in non GLR mode, _and_ if there are
 +  reduce/reduce conflicts.
 +
 +* Noteworthy changes in release ?.? (????-??-??) [?]
 +
+ ** Bug fixes
+ 
+   Bugs in the test suite have been fixed.
+ 
+   Some errors in translations have been addressed, and --help now directs
+   users to the appropriate place to report them.
+ 
+   Stray Info files shipped by accident are removed.
+ 
+   Incorrect definitions of YY_, issued by yacc.c when no parser header is
+   generated, are removed.
  
  * Noteworthy changes in release 2.6.2 (2012-08-03) [stable]
  
@@@ -256,7 -70,7 +267,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.
@@@ -2057,8 -1871,7 +2068,8 @@@ along with this program.  If not, see <
   LocalWords:  namespaces strerror const autoconfiguration Dconst Autoconf's FDL
   LocalWords:  Automake TMPDIR LESSEQ ylwrap endif yydebug YYTOKEN YYLSP ival hh
   LocalWords:  extern YYTOKENTYPE TOKENTYPE yytokentype tokentype STYPE lval pdf
 - LocalWords:  lang yyoutput dvi html ps POSIX lvalp llocp
 + LocalWords:  lang yyoutput dvi html ps POSIX lvalp llocp Wother nterm arg init
 + LocalWords:  TOK
  
  Local Variables:
  mode: outline
diff --combined data/c.m4
index 1a527b58,ccb4969e..84713884
--- a/data/c.m4
+++ b/data/c.m4
@@@ -36,41 -36,26 +36,43 @@@ m4_define([b4_cpp_guard]
  # b4_cpp_guard_open(FILE)
  # b4_cpp_guard_close(FILE)
  # ------------------------
- # Open/close CPP inclusion guards for FILE.
+ # If FILE does not expand to nothing, open/close CPP inclusion guards for FILE.
  m4_define([b4_cpp_guard_open],
+ [m4_ifval(m4_quote($1),
  [#ifndef b4_cpp_guard([$1])
- # define b4_cpp_guard([$1])])
+ # define b4_cpp_guard([$1])])])
  
  m4_define([b4_cpp_guard_close],
- [#endif b4_comment([!b4_cpp_guard([$1])])])
+ [m4_ifval(m4_quote($1),
+ [#endif b4_comment([!b4_cpp_guard([$1])])])])
  
  
  ## ---------------- ##
  ## Identification.  ##
  ## ---------------- ##
  
 -# b4_comment(TEXT)
 -# ----------------
 -m4_define([b4_comment], [/* m4_bpatsubst([$1], [
 -], [
 -   ])  */])
 +# b4_comment_(TEXT, OPEN, CONTINUE, END)
 +# --------------------------------------
 +# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
 +# Avoid adding indentation to the first line, as the indentation comes
 +# from OPEN.  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
 +#
 +# Prefix all the output lines with PREFIX.
 +m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [
 +\(.\)], [
 +$3\1])$4])
 +
 +
 +# b4_comment(TEXT, [PREFIX])
 +# --------------------------
 +# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
 +# Avoid adding indentation to the first line, as the indentation comes
 +# from "/*".  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
 +#
 +# Prefix all the output lines with PREFIX.
 +m4_define([b4_comment],
 +[b4_comment_([$1], [$2/* ], [$2   ], [$2  */])])
 +
  
  # b4_identification
  # -----------------
@@@ -128,7 -113,7 +130,7 @@@ m4_define_default([b4_union_name], [b4_
  # b4_user_args
  # ------------
  m4_define([b4_user_args],
 -[m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])])
 +[m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])])
  
  
  # b4_parse_param
@@@ -152,13 -137,11 +154,13 @@@ m4_popdef([$2])dn
  m4_popdef([$1])dnl
  ])])
  
 -# b4_parse_param_use
 -# ------------------
 -# `YYUSE' all the parse-params.
 +# b4_parse_param_use([VAL], [LOC])
 +# --------------------------------
 +# `YYUSE' VAL, LOC if locations are enabled, and all the parse-params.
  m4_define([b4_parse_param_use],
 -[b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
 +[m4_ifvaln([$1], [  YYUSE([$1]);])dnl
 +b4_locations_if([m4_ifvaln([$2], [  YYUSE ([$2]);])])dnl
 +b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
  ])dnl
  ])
  
@@@ -180,7 -163,7 +182,7 @@@ m4_define([b4_int_type]
  
         m4_eval([0 <= $1]),                [1], [unsigned int],
  
 -					       [int])])
 +                                               [int])])
  
  
  # b4_int_type_for(NAME)
@@@ -195,11 -178,12 +197,11 @@@ m4_define([b4_int_type_for]
  # --------------------------------------------
  # Without inducing a comparison warning from the compiler, check if the
  # literal value LITERAL equals VALUE from table TABLE, which must have
 -# TABLE_min and TABLE_max defined.  YYID must be defined as an identity
 -# function that suppresses warnings about constant conditions.
 +# TABLE_min and TABLE_max defined.
  m4_define([b4_table_value_equals],
  [m4_if(m4_eval($3 < m4_indir([b4_]$1[_min])
                 || m4_indir([b4_]$1[_max]) < $3), [1],
 -       [[YYID (0)]],
 +       [[0]],
         [[((]$2[) == (]$3[))]])])
  
  
@@@ -228,125 -212,166 +230,125 @@@ m4_define([b4_null_define]
  # Return a null pointer constant.
  m4_define([b4_null], [YY_NULL])
  
 +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
 +# -------------------------------------------------------------
 +# Define "yy<TABLE-NAME>" which contents is CONTENT.
 +m4_define([b4_integral_parser_table_define],
 +[m4_ifvaln([$3], [b4_comment([$3], [  ])])dnl
 +static const b4_int_type_for([$2]) yy$1[[]] =
 +{
 +  $2
 +};dnl
 +])
  
  
  ## ------------------------- ##
  ## Assigning token numbers.  ##
  ## ------------------------- ##
  
 -# b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
 -# -----------------------------------------
 +# b4_token_define(TOKEN-NUM)
 +# --------------------------
  # Output the definition of this token as #define.
  m4_define([b4_token_define],
 -[#define $1 $2
 -])
 +[b4_token_format([#define %s %s], [$1])])
  
 -
 -# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 -# -------------------------------------------------------
 -# Output the definition of the tokens (if there are) as #defines.
 +# b4_token_defines
 +# ----------------
 +# Output the definition of the tokens.
  m4_define([b4_token_defines],
 -[m4_if([$#$1], [1], [],
 -[/* Tokens.  */
 -m4_map([b4_token_define], [$@])])
 -])
 +[b4_any_token_visible_if([/* Tokens.  */
 +m4_join([
 +], b4_symbol_map([b4_token_define]))
 +])])
  
  
 -# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
 -# ---------------------------------------
 +# b4_token_enum(TOKEN-NUM)
 +# ------------------------
  # Output the definition of this token as an enum.
  m4_define([b4_token_enum],
 -[$1 = $2])
 +[b4_token_format([%s = %s], [$1])])
  
  
 -# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 -# -----------------------------------------------------
 +# b4_token_enums
 +# --------------
  # Output the definition of the tokens (if there are) as enums.
  m4_define([b4_token_enums],
 -[m4_if([$#$1], [1], [],
 -[[/* Tokens.  */
 +[b4_any_token_visible_if([[/* Tokens.  */
  #ifndef ]b4_api_PREFIX[TOKENTYPE
  # define ]b4_api_PREFIX[TOKENTYPE
 -   /* Put the tokens into the symbol table, so that GDB and other debuggers
 -      know about them.  */
 -   enum ]b4_api_prefix[tokentype {
 -]m4_map_sep([     b4_token_enum], [,
 -],
 -	   [$@])[
 -   };
 +  /* Put the tokens into the symbol table, so that GDB and other debuggers
 +     know about them.  */
 +  enum ]b4_api_prefix[tokentype
 +  {
 +    ]m4_join([,
 +    ],
 +             b4_symbol_map([b4_token_enum]))[
 +  };
  #endif
  ]])])
  
  
 -# b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 -# -------------------------------------------------------------
 -# Output the definition of the tokens (if there are any) as enums and, if POSIX
 -# Yacc is enabled, as #defines.
 +# b4_token_enums_defines
 +# ----------------------
 +# Output the definition of the tokens (if there are any) as enums and,
 +# if POSIX Yacc is enabled, as #defines.
  m4_define([b4_token_enums_defines],
 -[b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], [])
 -])
 +[b4_token_enums[]b4_yacc_if([b4_token_defines])])
  
  
 +## ----------------- ##
 +## Semantic Values.  ##
 +## ----------------- ##
  
 -## --------------------------------------------- ##
 -## Defining C functions in both K&R and ANSI-C.  ##
 -## --------------------------------------------- ##
  
 +# b4_symbol_value(VAL, [TYPE])
 +# ----------------------------
 +# Given a semantic value VAL ($$, $1 etc.), extract its value of type
 +# TYPE if TYPE is given, otherwise just return VAL.  The result can be
 +# used safetly, it is put in parens to avoid nasty precedence issues.
 +# TYPE is *not* put in braces, provide some if needed.
 +m4_define([b4_symbol_value],
 +[($1[]m4_ifval([$2], [.$2]))])
  
 -# b4_modern_c
 -# -----------
 -# A predicate useful in #if to determine whether C is ancient or modern.
 -#
 -# If __STDC__ is defined, the compiler is modern.  IBM xlc 7.0 when run
 -# as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic
 -# reasons, but it defines __C99__FUNC__ so check that as well.
 -# Microsoft C normally doesn't define these macros, but it defines _MSC_VER.
 -# Consider a C++ compiler to be modern if it defines __cplusplus.
 -#
 -m4_define([b4_c_modern],
 -  [[(defined __STDC__ || defined __C99__FUNC__ \
 -     || defined __cplusplus || defined _MSC_VER)]])
  
 -# b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 -# ----------------------------------------------------------
 -# Declare the function NAME.
 -m4_define([b4_c_function_def],
 -[#if b4_c_modern
 -b4_c_ansi_function_def($@)
 -#else
 -$2
 -$1 (b4_c_knr_formal_names(m4_shift2($@)))
 -b4_c_knr_formal_decls(m4_shift2($@))
 -#endif[]dnl
 -])
 +
 +## ---------------------- ##
 +## Defining C functions.  ##
 +## ---------------------- ##
  
  
 -# b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 -# ---------------------------------------------------------------
 -# Declare the function NAME in ANSI.
 -m4_define([b4_c_ansi_function_def],
 +# b4_function_define(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 +# -----------------------------------------------------------
 +# Declare the function NAME in C.
 +m4_define([b4_function_define],
  [$2
 -$1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl
 +$1 (b4_formals(m4_shift2($@)))[]dnl
  ])
  
  
 -# b4_c_ansi_formals([DECL1, NAME1], ...)
 -# --------------------------------------
 -# Output the arguments ANSI-C definition.
 -m4_define([b4_c_ansi_formals],
 +# b4_formals([DECL1, NAME1], ...)
 +# -------------------------------
 +# The formal arguments of a C function definition.
 +m4_define([b4_formals],
  [m4_if([$#], [0], [void],
         [$#$1], [1], [void],
 -	       [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
 +               [m4_map_sep([b4_formal], [, ], [$@])])])
  
 -m4_define([b4_c_ansi_formal],
 +m4_define([b4_formal],
  [$1])
  
  
 -# b4_c_knr_formal_names([DECL1, NAME1], ...)
 -# ------------------------------------------
 -# Output the argument names.
 -m4_define([b4_c_knr_formal_names],
 -[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
 -
 -m4_define([b4_c_knr_formal_name],
 -[$2])
 -
 -
 -# b4_c_knr_formal_decls([DECL1, NAME1], ...)
 -# ------------------------------------------
 -# Output the K&R argument declarations.
 -m4_define([b4_c_knr_formal_decls],
 -[m4_map_sep([b4_c_knr_formal_decl],
 -	    [
 -],
 -	    [$@])])
 -
 -m4_define([b4_c_knr_formal_decl],
 -[    $1;])
 -
 -
  
 -## ------------------------------------------------------------ ##
 -## Declaring (prototyping) C functions in both K&R and ANSI-C.  ##
 -## ------------------------------------------------------------ ##
 +## ----------------------- ##
 +## Declaring C functions.  ##
 +## ----------------------- ##
  
  
 -# b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 -# -----------------------------------------------------------
 +# b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 +# ------------------------------------------------------------
  # Declare the function NAME.
 -m4_define([b4_c_function_decl],
 -[#if defined __STDC__ || defined __cplusplus
 -b4_c_ansi_function_decl($@)
 -#else
 -$2 $1 ();
 -#endif[]dnl
 -])
 -
 -
 -# b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 -# ----------------------------------------------------------------
 -# Declare the function NAME.
 -m4_define([b4_c_ansi_function_decl],
 -[$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl
 +m4_define([b4_function_declare],
 +[$2 $1 (b4_formals(m4_shift2($@)));[]dnl
  ])
  
  
@@@ -357,21 -382,21 +359,21 @@@
  ## --------------------- ##
  
  
 -# b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 +# b4_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
  # -----------------------------------------------------------
  # Call the function NAME with arguments NAME1, NAME2 etc.
 -m4_define([b4_c_function_call],
 -[$1 (b4_c_args(m4_shift2($@)))[]dnl
 +m4_define([b4_function_call],
 +[$1 (b4_args(m4_shift2($@)))[]dnl
  ])
  
  
 -# b4_c_args([DECL1, NAME1], ...)
 -# ------------------------------
 +# b4_args([DECL1, NAME1], ...)
 +# ----------------------------
  # Output the arguments NAME1, NAME2...
 -m4_define([b4_c_args],
 -[m4_map_sep([b4_c_arg], [, ], [$@])])
 +m4_define([b4_args],
 +[m4_map_sep([b4_arg], [, ], [$@])])
  
 -m4_define([b4_c_arg],
 +m4_define([b4_arg],
  [$2])
  
  
@@@ -380,7 -405,7 +382,7 @@@
  ## ----------- ##
  
  # b4_sync_start(LINE, FILE)
 -# -----------------------
 +# -------------------------
  m4_define([b4_sync_start], [[#]line $1 $2])
  
  
@@@ -393,28 -418,39 +395,28 @@@
  m4_define([b4_case],
  [  case $1:
  $2
 +b4_syncline([@oline@], [@ofile@])
      break;])
  
 -# b4_symbol_actions(FILENAME, LINENO,
 -#                   SYMBOL-TAG, SYMBOL-NUM,
 -#                   SYMBOL-ACTION, SYMBOL-TYPENAME)
 -# -------------------------------------------------
 -# Issue the code for a symbol action (e.g., %printer).
 -#
 -# Define b4_dollar_dollar([TYPE-NAME]), and b4_at_dollar, which are
 -# invoked where $<TYPE-NAME>$ and @$ were specified by the user.
 -m4_define([b4_symbol_actions],
 -[b4_dollar_pushdef([(*yyvaluep)], [$6], [(*yylocationp)])dnl
 -      case $4: /* $3 */
 -b4_syncline([$2], [$1])
 -	$5;
 +
 +# b4_predicate_case(LABEL, CONDITIONS)
 +# ------------------------------------
 +m4_define([b4_predicate_case],
 +[  case $1:
 +    if (! ($2)) YYERROR;
  b4_syncline([@oline@], [@ofile@])
 -	break;
 -b4_dollar_popdef[]dnl
 -])
 +    break;])
  
  
 -# b4_yydestruct_generate(FUNCTION-DECLARATOR)
 -# -------------------------------------------
 -# Generate the "yydestruct" function, which declaration is issued using
 -# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
 -# or "b4_c_function_def" for K&R.
 -m4_define_default([b4_yydestruct_generate],
 +# b4_yydestruct_define
 +# --------------------
 +# Define the "yydestruct" function.
 +m4_define_default([b4_yydestruct_define],
  [[/*-----------------------------------------------.
  | Release the memory associated to this symbol.  |
  `-----------------------------------------------*/
  
 -/*ARGSUSED*/
 -]$1([yydestruct],
 +]b4_function_define([yydestruct],
      [static void],
      [[const char *yymsg],    [yymsg]],
      [[int yytype],           [yytype]],
@@@ -422,54 -458,63 +424,54 @@@
  b4_locations_if(            [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
  m4_ifset([b4_parse_param], [, b4_parse_param]))[
  {
 -  YYUSE (yyvaluep);
 -]b4_locations_if([  YYUSE (yylocationp);
 -])dnl
 -b4_parse_param_use[]dnl
 -[
 -  if (!yymsg)
 +]b4_parse_param_use([yyvaluep], [yylocationp])dnl
 +[  if (!yymsg)
      yymsg = "Deleting";
    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
  
    switch (yytype)
      {
 -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 -      default:
 -	break;
 +]b4_symbol_foreach([b4_symbol_destructor])dnl
 +[      default:
 +        break;
      }
  }]dnl
  ])
  
  
 -# b4_yy_symbol_print_generate(FUNCTION-DECLARATOR)
 -# ------------------------------------------------
 -# Generate the "yy_symbol_print" function, which declaration is issued using
 -# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
 -# or "b4_c_function_def" for K&R.
 -m4_define_default([b4_yy_symbol_print_generate],
 +# b4_yy_symbol_print_define
 +# -------------------------
 +# Define the "yy_symbol_print" function.
 +m4_define_default([b4_yy_symbol_print_define],
  [[
  /*--------------------------------.
  | Print this symbol on YYOUTPUT.  |
  `--------------------------------*/
  
 -/*ARGSUSED*/
 -]$1([yy_symbol_value_print],
 +]b4_function_define([yy_symbol_value_print],
      [static void],
 -	       [[FILE *yyoutput],                       [yyoutput]],
 -	       [[int yytype],                           [yytype]],
 -	       [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 +               [[FILE *yyoutput],                       [yyoutput]],
 +               [[int yytype],                           [yytype]],
 +               [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
  b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
  m4_ifset([b4_parse_param], [, b4_parse_param]))[
  {
    FILE *yyo = yyoutput;
 -  YYUSE (yyo);
 -  if (!yyvaluep)
 -    return;
 -]b4_locations_if([  YYUSE (yylocationp);
 -])dnl
 -b4_parse_param_use[]dnl
 -[# ifdef YYPRINT
 +]b4_parse_param_use([yyo], [yylocationp])dnl
 +[  if (!yyvaluep)
 +    return;]
 +dnl glr.c does not feature yytoknum.
 +m4_if(b4_skeleton, ["yacc.c"],
 +[[# ifdef YYPRINT
    if (yytype < YYNTOKENS)
      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 -# else
 -  YYUSE (yyoutput);
  # endif
 -  switch (yytype)
 +]])dnl
 +[  switch (yytype)
      {
 -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 +]b4_symbol_foreach([b4_symbol_printer])dnl
  [      default:
 -	break;
 +        break;
      }
  }
  
@@@ -478,11 -523,11 +480,11 @@@
  | Print this symbol on YYOUTPUT.  |
  `--------------------------------*/
  
 -]$1([yy_symbol_print],
 +]b4_function_define([yy_symbol_print],
      [static void],
 -	       [[FILE *yyoutput],                       [yyoutput]],
 -	       [[int yytype],                           [yytype]],
 -	       [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 +               [[FILE *yyoutput],                       [yyoutput]],
 +               [[int yytype],                           [yytype]],
 +               [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
  b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
  m4_ifset([b4_parse_param], [, b4_parse_param]))[
  {
@@@ -519,6 -564,7 +521,6 @@@ m4_define([b4_declare_yylstype]
  [m4_if(b4_tag_seen_flag, 0,
  [[typedef int ]b4_api_PREFIX[STYPE;
  # define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]])])[
 -# define ]b4_api_prefix[stype ]b4_api_PREFIX[STYPE /* obsolescent; will be withdrawn */
  # define ]b4_api_PREFIX[STYPE_IS_DECLARED 1
  #endif]b4_locations_if([[
  
@@@ -530,6 -576,7 +532,6 @@@ typedef struct ]b4_api_PREFIX[LTYP
    int last_line;
    int last_column;
  } ]b4_api_PREFIX[LTYPE;
 -# define ]b4_api_prefix[ltype ]b4_api_PREFIX[LTYPE /* obsolescent; will be withdrawn */
  # define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1
  # define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1
  #endif]])
@@@ -544,17 -591,17 +546,17 @@@ m4_define([b4_YYDEBUG_define]
  [[/* Enabling traces.  */
  ]m4_if(b4_api_prefix, [yy],
  [[#ifndef YYDEBUG
 -# define YYDEBUG ]b4_debug_flag[
 +# define YYDEBUG ]b4_parse_trace_if([1], [0])[
  #endif]],
  [[#ifndef ]b4_api_PREFIX[DEBUG
  # if defined YYDEBUG
 -#  if YYDEBUG
 +#if YYDEBUG
  #   define ]b4_api_PREFIX[DEBUG 1
  #  else
  #   define ]b4_api_PREFIX[DEBUG 0
  #  endif
  # else /* ! defined YYDEBUG */
 -#  define ]b4_api_PREFIX[DEBUG ]b4_debug_flag[
 +#  define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[
  # endif /* ! defined ]b4_api_PREFIX[DEBUG */
  #endif  /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl
  ])
@@@ -579,7 -626,7 +581,7 @@@ m4_define([b4_yylloc_default_define]
  #ifndef YYLLOC_DEFAULT
  # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
      do                                                                  \
 -      if (YYID (N))                                                     \
 +      if (N)                                                            \
          {                                                               \
            (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
            (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
@@@ -593,6 -640,6 +595,6 @@@
            (Current).first_column = (Current).last_column =              \
              YYRHSLOC (Rhs, 0).last_column;                              \
          }                                                               \
 -    while (YYID (0))
 +    while (0)
  #endif
  ]])
diff --combined data/yacc.c
index a15ef770,7bcbd7ca..44f96dda
--- 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,12 -342,14 +337,14 @@@ 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
+ ]m4_ifval(m4_quote(b4_spec_defines_file),
+ [[/* In a future release of Bison, this section will be replaced
     by #include "@basename(]b4_spec_defines_file[@)".  */
- ]b4_shared_declarations[
+ ]])dnl
+ b4_shared_declarations[
  
  /* Copy the second part of user declarations.  */
  ]b4_user_post_prologue
@@@ -360,8 -367,10 +362,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 -390,7 +383,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 -413,22 +406,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 -447,7 +430,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 -460,7 +443,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 -476,7 +459,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 -484,13 +467,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 -501,8 +484,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 -532,16 +515,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 -560,7 +543,7 @@@
            for (yyi = 0; yyi < (Count); yyi++)   \
              (Dst)[yyi] = (Src)[yyi];            \
          }                                       \
 -      while (YYID (0))
 +      while (0)
  #  endif
  # endif
  #endif /* !YYCOPY_NEEDED */
@@@ -557,27 -576,41 +559,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 -623,105 +592,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 -739,18 +638,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 -758,10 +656,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 -780,7 +678,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 -791,33 +689,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 -828,45 +726,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 -880,7 +780,7 @@@ int yydebug
  
  
  /* YYINITDEPTH -- initial size of the parser's stacks.  */
 -#ifndef	YYINITDEPTH
 +#ifndef YYINITDEPTH
  # define YYINITDEPTH ]b4_stack_depth_init[
  #endif
  
@@@ -898,7 -1000,7 +900,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 -1023,7 +923,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 -1139,7 +1039,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 -1156,7 +1056,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 -1187,27 +1087,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 -1246,10 +1146,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 -1380,7 +1276,7 @@@
  }
  #endif /* YYERROR_VERBOSE */
  
 -]b4_yydestruct_generate([b4_c_function_def])[
 +]b4_yydestruct_define[
  
  ]b4_pure_if([], [
  
@@@ -1289,13 -1395,13 +1291,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 -1426,7 +1322,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 -1434,7 +1330,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 -1447,7 +1343,7 @@@
    return yyps;
  }
  
 -]b4_c_function_def([[yypstate_delete]], [[void]],
 +]b4_function_define([[yypstate_delete]], [[void]],
                     [[[yypstate *yyps]], [[yyps]]])[
  {
  #ifndef yyoverflow
@@@ -1379,7 -1485,7 +1381,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 -1497,12 +1393,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;
@@@ -1489,26 -1600,26 +1491,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
@@@ -1516,23 -1627,23 +1518,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 */
@@@ -1542,10 -1653,10 +1544,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));
@@@ -1725,9 -1836,9 +1727,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.  */
@@@ -1781,20 -1892,20 +1783,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
@@@ -1827,29 -1938,29 +1829,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);
@@@ -1914,7 -2025,7 +1916,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
@@@ -1930,14 -2041,17 +1932,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 gnulib
index bd54a45e,4430dd02..cb38ce7d
--- a/gnulib
+++ b/gnulib
@@@ -1,1 -1,1 +1,1 @@@
- Subproject commit bd54a45e6e4bcb3ee7359c9b4f1d831a6291148f
 -Subproject commit 4430dd023d6c2b7b63a87fa62dcc2360c5a34a12
++Subproject commit cb38ce7db84edb421fbaeea5abe16ebeb8ad8a5c
diff --combined lib/.gitignore
index a448e841,a5595ab9..e62b99c3
--- a/lib/.gitignore
+++ b/lib/.gitignore
@@@ -35,8 -35,6 +35,8 @@@
  /close.c
  /closeout.c
  /closeout.h
 +/concat-filename.c
 +/concat-filename.h
  /config.charset
  /config.h
  /config.in.h
@@@ -64,7 -62,6 +64,7 @@@
  /fd-hook.h
  /fd-safer-flag.c
  /fd-safer.c
 +/filename.h
  /float+.h
  /float.c
  /float.h
@@@ -112,7 -109,9 +112,7 @@@
  /mbchar.c
  /mbchar.h
  /mbrtowc.c
 -/mbschr.c
  /mbsinit.c
 -/mbsrchr.c
  /mbswidth.c
  /mbswidth.h
  /mbuiter.h
@@@ -126,7 -125,6 +126,7 @@@
  /nonblocking.h
  /obstack.c
  /obstack.h
 +/obstack_printf.c
  /open.c
  /pathmax.h
  /perror.c
@@@ -227,7 -225,6 +227,7 @@@
  /sys_socket.in.h
  /sys_stat.h
  /sys_stat.in.h
 +/sys_types.in.h
  /sys_wait.h
  /sys_wait.in.h
  /sysexits.in.h
@@@ -264,10 -261,14 +264,12 @@@
  /xalloc-die.c
  /xalloc-oversized.h
  /xalloc.h
 +/xconcat-filename.c
  /xmalloc.c
 +/xmemdup0.c
 +/xmemdup0.h
  /xsize.h
  /xstrndup.c
  /xstrndup.h
 -/xmemdup0.c
 -/xmemdup0.h
 -/sys_types.in.h
 -/obstack_printf.c
+ /binary-io.c
 -/mbuiter.c
+ /xsize.c
diff --combined m4/.gitignore
index c6a84ce8,e85072b3..d3178586
--- a/m4/.gitignore
+++ b/m4/.gitignore
@@@ -51,7 -51,6 +51,7 @@@
  /inline.m4
  /intdiv0.m4
  /intl.m4
 +/intl.m4~
  /intldir.m4
  /intlmacosx.m4
  /intmax.m4
@@@ -103,7 -102,6 +103,7 @@@
  /perror.m4
  /pipe2.m4
  /po.m4
 +/po.m4~
  /posix_spawn.m4
  /printf-frexp.m4
  /printf-frexpl.m4
@@@ -182,3 -180,4 +182,4 @@@
  /xsize.m4
  /xstrndup.m4
  /obstack-printf.m4
+ /extern-inline.m4