version 2.6.5

* NEWS: Record release date.

.gitignore

@@ -11,6 +11,7 @@
 /INSTALL
 /Makefile
 /Makefile.in
+/README-release
 /_*
 /a.exe
 /a.out
@@ -31,4 +32,3 @@
 /patches
 /releases
 /stamp-h*
-/README-release

.prev-version

@@ -1 +1 @@
-2.6
+2.6.4

Makefile.am

@@ -1,7 +1,7 @@
-## Process this file with automake to produce Makefile.in.
+## Process this file with automake to produce Makefile.in -*-Makefile-*-
+
+## Copyright (C) 2001-2012 Free Software Foundation, Inc.
 
-# Copyright (C) 2001-2012 Free Software Foundation, Inc.
-#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -15,51 +15,29 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-AUTOMAKE_OPTIONS = subdir-objects
 ACLOCAL_AMFLAGS = -I m4
 
-SUBDIRS = po runtime-po .
+SUBDIRS = build-aux po runtime-po lib data src doc examples tests etc
 
 # Files installed for use by Automake.
 aclocaldir = @aclocaldir@
 aclocal_DATA = m4/bison-i18n.m4
 
 EXTRA_DIST = .prev-version .version \
-  cfg.mk ChangeLog-1998 ChangeLog-2012 PACKAGING
+  cfg.mk ChangeLog-1998 ChangeLog-2012 PACKAGING \
+  djgpp/Makefile.maint djgpp/README.in djgpp/config.bat \
+  djgpp/config.sed djgpp/config.site djgpp/config_h.sed \
+  djgpp/subpipe.c djgpp/subpipe.h djgpp/djunpack.bat \
+  djgpp/fnchange.lst djgpp/testsuite.sed
 
-## Running the bison from this tarball.  To generate our own parser,
-## but also to run the tests.  Of course, you ought to keep a sane
-## version of Bison nearby...
-BISON = $(top_builddir)/tests/bison
-BISON_IN = $(top_srcdir)/tests/bison.in
-YACC = $(BISON) -y
-AM_YFLAGS = -d -v --warnings=all,error --report=all
-
-# Initialization before completion by local.mk's.
-AM_CFLAGS = $(WARN_CFLAGS)
-# Find builddir/src/scan-code.c etc.
-AM_CPPFLAGS = -I. -Ilib -I$(top_srcdir) -I$(top_srcdir)/lib
-BUILT_SOURCES =
-CLEANFILES =
-DISTCLEANFILES =
-EXTRA_DIST += $(dist_TESTS)
-MOSTLYCLEANDIRS =
-MOSTLYCLEANFILES =
-SUFFIXES =
-TESTS = $(dist_TESTS)
-check_PROGRAMS =
-dist_TESTS =
-noinst_LIBRARIES =
-
-include build-aux/local.mk
-include data/local.mk
-include djgpp/local.mk
-include doc/local.mk
-include etc/local.mk
-include examples/local.mk
-include lib/local.mk
-include src/local.mk
-include tests/local.mk
+MAINTAINER_CHECKS =				\
+  maintainer-check				\
+  maintainer-push-check				\
+  maintainer-xml-check				\
+  maintainer-release-check
+.PHONY: $(MAINTAINER_CHECKS)
+$(MAINTAINER_CHECKS):
+	$(AM_V_GEN)cd tests && $(MAKE) $(AM_MAKEFLAGS) $@
 
 # See comments in build-aux/git-version-gen.  However, we make .version depend
 # on configure so that .version and VERSION/PACKAGE_VERSION stay in sync in the
@@ -70,20 +48,20 @@ include tests/local.mk
 # a developer might naively reference .version in a test case while the bison
 # executable still compiles with VERSION, and so the test case might fail or
 # pass incorrectly.
-BUILT_SOURCES += $(top_srcdir)/.version
+BUILT_SOURCES = $(top_srcdir)/.version
 $(top_srcdir)/.version: configure
-	echo $(VERSION) > $@-t && mv $@-t $@
+	$(AM_V_GEN)echo $(VERSION) > $@-t && mv $@-t $@
 dist-hook: gen-ChangeLog
-	echo $(VERSION) > $(distdir)/.tarball-version
+	$(AM_V_GEN)echo $(VERSION) > $(distdir)/.tarball-version
 
 .PHONY: update-b4-copyright update-package-copyright-year
 update-b4-copyright:
-	find data -type f                    \
-	  | grep -v -E '^data/bison.m4$$'    \
+	$(AM_V_GEN) find data -type f		\
+	  | grep -v -E '^data/bison.m4$$'	\
 	  | xargs $(build_aux)/$@
 	@echo 'warning: src/parse-gram.[hc] may need to be regenerated.'
 update-package-copyright-year:
-	$(build_aux)/$@ configure.ac
+	$(AM_V_GEN)$(build_aux)/$@ configure.ac
 
 gen_start_date = 2012-01-16
 .PHONY: gen-ChangeLog

NEWS

@@ -1,135 +1,134 @@
 GNU Bison NEWS
 
-* Noteworthy changes in release ?.? (????-??-??) [?]
+* Noteworthy changes in release 2.6.5 (2012-11-07) [stable]
 
-** Warnings
+  We consider compiler warnings about Bison generated parsers to be bugs.
+  Rather than working around them in your own project, please consider
+  reporting them to us.
 
-*** Warning categories are now displayed in warnings
+** Bug fixes
 
-  For instance:
+  Warnings about uninitialized yylval and/or yylloc for push parsers with a
+  pure interface have been fixed for GCC 4.0 up to 4.8, and Clang 2.9 to
+  3.2.
 
-  foo.y:4.6: warning: type clash on default action: <foo> != <bar> [-Wother]
+  Other issues in the test suite have been addressed.
 
-*** Useless semantic types
+  Nul characters are correctly displayed in error messages.
 
-  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:
+  When possible, yylloc is correctly initialized before calling yylex.  It
+  is no longer necessary to initialize it in the %initial-action.
 
-    %token <type1> term
-    %type  <type2> nterm
-    %printer    {} <type1> <type3>
-    %destructor {} <type2> <type4>
-    %%
-    nterm: term { $$ = $1; };
+* Noteworthy changes in release 2.6.4 (2012-10-23) [stable]
 
-    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
+  Bison 2.6.3's --version was incorrect.  This release fixes this issue.
 
-*** Undeclared symbols
+* Noteworthy changes in release 2.6.3 (2012-10-22) [stable]
 
-  Bison used to raise an error for %printer and %destructor directives for
-  undefined symbols.
+** Bug fixes
 
-    %printer    {} symbol1
-    %destructor {} symbol2
-    %%
-    exp: "a";
+  Bugs and portability issues in the test suite have been fixed.
 
-  This is now only a warning.
+  Some errors in translations have been addressed, and --help now directs
+  users to the appropriate place to report them.
 
-*** Useless destructors or printers
+  Stray Info files shipped by accident are removed.
 
-  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.
+  Incorrect definitions of YY_, issued by yacc.c when no parser header is
+  generated, are removed.
 
-    %token <type1> token1
-           <type2> token2
-           <type3> token3
-           <type4> token4
-    %printer    {} token1 <type1> <type3>
-    %destructor {} token2 <type2> <type4>
+  All the generated headers are self-contained.
 
-** Additional yylex/yyparse arguments
+** Header guards (yacc.c, glr.c, glr.cc)
 
-  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
+  In order to avoid collisions, the header guards are now
+  YY_<PREFIX>_<FILE>_INCLUDED, instead of merely <PREFIX>_<FILE>.
+  For instance the header generated from
 
-    %lex-param   {arg1_type *arg1}
-    %lex-param   {arg2_type *arg2}
-    %parse-param {arg1_type *arg1}
-    %parse-param {arg2_type *arg2}
+    %define api.prefix "calc"
+    %defines "lib/parse.h"
 
-  one may now declare
+  will use YY_CALC_LIB_PARSE_H_INCLUDED as guard.
 
-    %param {arg1_type *arg1} {arg2_type *arg2}
+** Fix compiler warnings in the generated parser (yacc.c, glr.c)
 
-** Java skeleton improvements
+  The compilation of pure parsers (%define api.pure) can trigger GCC
+  warnings such as:
 
-  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".
+    input.c: In function 'yyparse':
+    input.c:1503:12: warning: 'yylval' may be used uninitialized in this
+                              function [-Wmaybe-uninitialized]
+       *++yyvsp = yylval;
+                ^
 
-** C++ skeleton improvements
+  This is now fixed; pragmas to avoid these warnings are no longer needed.
 
-  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).
+  Warnings from clang ("equality comparison with extraneous parentheses" and
+  "function declared 'noreturn' should not return") have also been
+  addressed.
 
-** Variable api.tokens.prefix
+* Noteworthy changes in release 2.6.2 (2012-08-03) [stable]
 
-  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
+** Bug fixes
 
-    %token FILE for ERROR
-    %define api.tokens.prefix "TOK_"
-    %%
-    start: FILE for ERROR;
+  Buffer overruns, complaints from Flex, and portability issues in the test
+  suite have been fixed.
 
-  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).
+** Spaces in %lex- and %parse-param (lalr1.cc, glr.cc)
 
-** Variable api.namespace
+  Trailing end-of-lines in %parse-param or %lex-param would result in
+  invalid C++.  This is fixed.
 
-  The "namespace" variable is renamed "api.namespace".  Backward
-  compatibility is ensured, but upgrading is recommended.
+** Spurious spaces and end-of-lines
 
-** Variable parse.error
+  The generated files no longer end (nor start) with empty lines.
 
-  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".
+* Noteworthy changes in release 2.6.1 (2012-07-30) [stable]
 
-** Semantic predicates
+ Bison no longer executes user-specified M4 code when processing a grammar.
 
-  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.
+** Future Changes
 
-* Noteworthy changes in release ?.? (????-??-??) [?]
+  In addition to the removal of the features announced in Bison 2.6, the
+  next major release will remove the "Temporary hack for adding a semicolon
+  to the user action", as announced in the release 2.5.  Instead of:
 
+    exp: exp "+" exp { $$ = $1 + $3 };
+
+  write:
+
+    exp: exp "+" exp { $$ = $1 + $3; };
+
+** Bug fixes
+
+*** Type names are now properly escaped.
+
+*** glr.cc: set_debug_level and debug_level work as expected.
+
+*** Stray @ or $ in actions
+
+  While Bison used to warn about stray $ or @ in action rules, it did not
+  for other actions such as printers, destructors, or initial actions.  It
+  now does.
+
+** Type names in actions
+
+  For consistency with rule actions, it is now possible to qualify $$ by a
+  type-name in destructors, printers, and initial actions.  For instance:
+
+    %printer { fprintf (yyo, "(%d, %f)", $<ival>$, $<fval>$); } <*> <>;
+
+  will display two values for each typed and untyped symbol (provided
+  that YYSTYPE has both "ival" and "fval" fields).
 
 * 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 [email protected].
 
-*** K&C parsers
+*** K&R C parsers
 
   Support for generating parsers in K&R C will be removed.  Parsers
   generated for C support ISO C90, and are tested with ISO C99 and ISO C11
@@ -1925,8 +1924,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  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 Wother nterm arg init
- LocalWords:  TOK
+ LocalWords:  lang yyoutput dvi html ps POSIX lvalp llocp calc yyo fval
 
 Local Variables:
 mode: outline

README-hacking

@@ -35,13 +35,6 @@ of the .output file etc.  This excludes impossible error messages
 (comparable to assert/abort), and all the --trace output which is
 meant for the maintainers only.
 
-** Horizontal tabs
-Do not add horizontal tab characters to any file in Bison's repository
-except where required.  For example, do not use tabs to format C code.
-However, make files, ChangeLog, and some regular expressions require
-tabs.  Also, test cases might need to contain tabs to check that Bison
-properly processes tabs in its input.
-
 
 * Working from the repository
 
@@ -175,6 +168,19 @@ decide whether to update.
 ** make check
 Use liberally.
 
+** Typical errors
+If the test suite shows failures such as the following one
+
+  .../bison/lib/getopt.h:196:8: error: redefinition of 'struct option'
+  /usr/include/getopt.h:54:8: error: previous definition of 'struct option'
+
+it probably means that some file was compiled without
+AT_DATA_SOURCE_PROLOGUE.  This error is due to the fact that our -I options
+pick up gnulib's replacement headers, such as getopt.h, and this will go
+wrong if config.h was not included first.
+
+See tests/local.at for details.
+
 ** make maintainer-check-valgrind
 This target uses valgrind both to check bison, and the generated parsers.
 
@@ -233,9 +239,6 @@ release:
   that it does not make sense for glr.c, which should be ANSI, but
   currently is actually GNU C, nor for lalr1.cc.
 
-- Test with a very recent version of GCC for both C and C++.  Testing
-  with older versions that are still in use is nice too.
-
 
 * Release Procedure
 This section needs to be updated to take into account features from

REFERENCES

@@ -25,8 +25,8 @@ LALR(1) Look-Ahead Sets", ACM Transactions on Programming Languages
 and Systems (TOPLAS) 4, 4 (October 1982), 615-649.  Their
 technique is the standard one now.)
 
-        paul rubin
-        free software foundation
+	paul rubin
+	free software foundation
 
 
 [DeRemer-Pennello reference corrected by Paul Eggert <[email protected]>,

THANKS

@@ -5,7 +5,7 @@ Airy Andre                [email protected]
 Akim Demaille             [email protected]
 Albert Chin-A-Young       [email protected]
 Alexander Belopolsky      [email protected]
-Alexandre Duret-Lutz      adl@src.lip6.fr
+Alexandre Duret-Lutz      adl@lrde.epita.fr
 Andreas Schwab            [email protected]
 Andrew Suffield           [email protected]
 Angelo Borsotti           [email protected]
@@ -13,6 +13,7 @@ Anthony Heading           [email protected]
 Arnold Robbins            [email protected]
 Art Haas                  [email protected]
 Baron Schwartz            [email protected]
+Ben Pfaff                 [email protected]
 Benoit Perrot             [email protected]
 Bernd Kiefer              [email protected]
 Bert Deknuydt             [email protected]
@@ -63,6 +64,7 @@ Laurent Mascherpa         [email protected]
 Lie Yan                   [email protected]
 Magnus Fromreide          [email protected]
 Marc Autret               [email protected]
+Marc Mendiola             [email protected]
 Martin Jacobs             [email protected]
 Martin Mokrejs            [email protected]
 Martin Nylin              [email protected]
@@ -70,7 +72,6 @@ Matt Kraai                [email protected]
 Matt Rosing               [email protected]
 Michael Hayes             [email protected]
 Michael Raskin            [email protected]
-Michiel De Wilde          [email protected]
 Mickael Labau             [email protected]
 Mike Castle               [email protected]
 Neil Booth                [email protected]
@@ -87,13 +88,14 @@ Paul Hilfinger            [email protected]
 Per Allansson             [email protected]
 Peter Fales               [email protected]
 Peter Hamorsky            [email protected]
+Peter Simons              [email protected]
 Piotr Gackiewicz          [email protected]
-Quentin Hocquet           [email protected]
 Quoc Peyrot               [email protected]
 R Blake                   [email protected]
 Raja R Harinath           [email protected]
 Ralf Wildenhues           [email protected]
 Richard Stallman          [email protected]
+Rob Vermaas               [email protected]
 Robert Anisko             [email protected]
 Satya Kiran Popuri        [email protected]
 Sebastian Setzer          [email protected]
@@ -102,7 +104,7 @@ Sergei Steshenko          [email protected]
 Shura                     [email protected]
 Stefano Lattarini         [email protected]
 Steve Murphy              [email protected]
-Summum Bonum              [email protected]
+Sum Wu                    [email protected]
 Thiru Ramakrishnan        [email protected]
 Tim Josling               [email protected]
 Tim Landscheidt           [email protected]

TODO

@@ -2,6 +2,11 @@
 ** Variable names.
 What should we name `variant' and `lex_symbol'?
 
+** Use b4_symbol in all the skeleton
+Move its definition in the more standard places and deploy it in other
+skeletons.  Then remove the older system, including the tables
+generated by output.c
+
 ** Update the documentation on gnu.org
 
 ** Get rid of fake #lines [Bison: ...]

bootstrap.conf

@@ -23,19 +23,18 @@ gnulib_modules='
   error extensions fdl fopen-safer getopt-gnu
   gettext git-version-gen gitlog-to-changelog
   gpl-3.0 hash inttypes isnan javacomp-script
-  javaexec-script ldexpl malloc-gnu
-  mbswidth obstack perror progname
+  javaexec-script ldexpl malloc-gnu mbschr mbsrchr
+  mbswidth
+  obstack
+  obstack-printf
+  perror progname
   quote quotearg
   readme-release
   realloc-posix
   spawn-pipe stdbool stpcpy strdup-posix strerror strtoul strverscmp
   unistd unistd-safer unlocked-io update-copyright unsetenv verify
   warnings
-  xalloc
-  xalloc-die
-  xconcat-filename
-  xmemdup0
-  xstrndup
+  xalloc xalloc-die xmemdup0 xstrndup
 
   fprintf-posix printf-posix snprintf-posix sprintf-posix
   vsnprintf-posix vsprintf-posix
@@ -45,9 +44,9 @@ gnulib_modules='
 XGETTEXT_OPTIONS=$XGETTEXT_OPTIONS'\\\
  --from-code=UTF-8\\\
  --flag=asprintf:2:c-format\\\
- --flag=complain:2:c-format\\\
- --flag=complain_at:3:c-format\\\
- --flag=complain_at_indent:4:c-format\\\
+ --flag=complain:1:c-format --flag=complain_at:2:c-format\\\
+ --flag=fatal:1:c-format --flag=fatal_at:2:c-format\\\
+ --flag=warn:1:c-format  --flag=warn_at:2:c-format\\\
  --flag=unexpected_end:2:c-format\\\
 '
 XGETTEXT_OPTIONS_RUNTIME=$XGETTEXT_OPTIONS'\\\
@@ -75,9 +74,6 @@ gnulib_tool_option_extras='--symlink --makefile-name=gnulib.mk'
 
 bootstrap_post_import_hook()
 {
-  # Massage lib/gnulib.mk before using it later in the bootstrapping process.
-  etc/prefix-gnulib-mk --lib-name=$gnulib_name lib/$gnulib_mk
-
   # Ensure that ChangeLog exists, for automake.
   test -f ChangeLog || touch ChangeLog
 }

build-aux/.gitignore

@@ -1,10 +1,11 @@
+/Makefile
+/Makefile.in
 /announce-gen
 /arg-nonnull.h
 /c++defs.h
 /compile
 /config.guess
 /config.rpath
-/config.rpath~
 /config.sub
 /depcomp
 /do-release-commit-and-tag
@@ -19,7 +20,6 @@
 /link-warning.h
 /mdate-sh
 /missing
-/test-driver
 /texinfo.tex
 /update-copyright
 /useless-if-before-free

build-aux/Makefile.am

@@ -1,7 +1,5 @@
-## Makefile for Bison testsuite.
+## Copyright (C) 2006, 2009-2012 Free Software Foundation, Inc.
 
-# Copyright (C) 2000-2012 Free Software Foundation, Inc.
-#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -15,9 +13,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-EXTRA_DIST +=                                   \
-  build-aux/cross-options.pl                    \
-  build-aux/darwin11.4.0.valgrind               \
-  build-aux/move-if-change                      \
-  build-aux/prev-version.txt                    \
-  build-aux/update-b4-copyright
+EXTRA_DIST =					\
+  cross-options.pl				\
+  darwin11.4.0.valgrind				\
+  prev-version.txt				\
+  update-b4-copyright

build-aux/cross-options.pl

@@ -18,50 +18,50 @@ while (<STDIN>)
         \s                # Spaces.
         /x)
     {
-        my ($short, $long, $opt, $arg) = ($1, $2, $3, $4);
-        $short = '' if ! defined $short;
-        $short = '-d' if $long eq '--defines' && ! $short;
-        my $dir = '%' . substr($long, 2);
-        if (index ($scanner, "\"$dir\"") < 0)
-        {
-          if ($long eq '--force-define') { $dir = '%define'; }
-          else { $dir = ''; }
-        }
-        if ($arg)
-        {
+	my ($short, $long, $opt, $arg) = ($1, $2, $3, $4);
+	$short = '' if ! defined $short;
+	$short = '-d' if $long eq '--defines' && ! $short;
+	my $dir = '%' . substr($long, 2);
+	if (index ($scanner, "\"$dir\"") < 0)
+	{
+	  if ($long eq '--force-define') { $dir = '%define'; }
+	  else { $dir = ''; }
+	}
+	if ($arg)
+	{
             # if $opt, $arg contains the closing ].
             substr ($arg, -1) = ''
                 if $opt eq '[';
-            $arg =~ s/^=//;
+	    $arg =~ s/^=//;
             $arg = lc ($arg);
-            my $dir_arg = $arg;
+	    my $dir_arg = $arg;
             # If the argument is compite (e.g., for --define[=NAME[=VALUE]]),
             # put each word in @var, to build @var{name}[=@var{value}], not
             # @var{name[=value]}].
-            $arg =~ s/(\w+)/\@var{$1}/g;
-            my $long_arg = "=$arg";
-            if ($opt eq '[') {
-              $long_arg = "[$long_arg]";
-              $arg = "[$arg]";
-            }
-            # For arguments of directives: this only works if all arguments
-            # are strings and have the same syntax as on the command line.
-            if ($dir_arg eq 'name[=value]')
-            {
-                $dir_arg = '@var{name} ["@var{value}"]';
-            }
-            else
-            {
-                $dir_arg =~ s/(\w+)/\@var{"$1"}/g;
-                $dir_arg = '[' . $dir_arg . ']'
-                    if $opt eq '[';
-            }
-            $long = "$long$long_arg";
-            $short = "$short $arg" if $short && $short ne '-d';
-            $dir = "$dir $dir_arg" if $dir;
-        }
-        $option{$long} = $short;
-        $directive{$long} = $dir;
+	    $arg =~ s/(\w+)/\@var{$1}/g;
+	    my $long_arg = "=$arg";
+	    if ($opt eq '[') {
+	      $long_arg = "[$long_arg]";
+	      $arg = "[$arg]";
+	    }
+	    # For arguments of directives: this only works if all arguments
+	    # are strings and have the same syntax as on the command line.
+	    if ($dir_arg eq 'name[=value]')
+	    {
+		$dir_arg = '@var{name} ["@var{value}"]';
+	    }
+	    else
+	    {
+		$dir_arg =~ s/(\w+)/\@var{"$1"}/g;
+		$dir_arg = '[' . $dir_arg . ']'
+		    if $opt eq '[';
+	    }
+	    $long = "$long$long_arg";
+	    $short = "$short $arg" if $short && $short ne '-d';
+	    $dir = "$dir $dir_arg" if $dir;
+	}
+	$option{$long} = $short;
+	$directive{$long} = $dir;
     }
 }
 

build-aux/move-if-change

@@ -1 +0,0 @@
-../gnulib/build-aux/move-if-change

cfg.mk

@@ -36,9 +36,15 @@ url_dir_list = \
   ftp://$(gnu_rel_host)/gnu/bison
 
 # Tests not to run as part of "make distcheck".
-local-checks-to-skip =			\
+# 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 \
   sc_immutable_NEWS			\
-  sc_prohibit_atoi_atof
+  sc_prohibit_always_true_header_tests	\
+  sc_prohibit_atoi_atof			\
+  sc_prohibit_strcmp
 
 # The local directory containing the checked-out copy of gnulib used in
 # this release.  Used solely to get a date for the "announcement" target.
@@ -59,14 +65,15 @@ exclude = \
 $(call exclude,								\
   bindtextdomain=^lib/main.c$$						\
   program_name=^lib/main.c$$						\
-  prohibit_always-defined_macros=^data/yacc.c|^djgpp/			\
+  prohibit_always-defined_macros=^data/yacc.c$$|^djgpp/			\
   prohibit_always-defined_macros+=?|^lib/timevar.c$$			\
   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_strcmp=^doc/bison\.texi$$					\
+  prohibit_magic_number_exit=^doc/bison.texi$$				\
+  prohibit_magic_number_exit+=?|^tests/(conflicts|regression).at$$	\
   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$$)			\
 )

configure.ac

@@ -45,9 +45,7 @@ AC_CONFIG_MACRO_DIR([m4])
 # releases, we want to be able run make dist without being required to
 # add a bogus NEWS entry.  In that case, the version string
 # automatically contains a dash, which we also let disable gnits.
-AM_INIT_AUTOMAKE([1.11.1 dist-xz nostdinc
-                 color-tests parallel-tests
-                 silent-rules]
+AM_INIT_AUTOMAKE([1.11.1 dist-xz silent-rules]
                  m4_bmatch(m4_defn([AC_PACKAGE_VERSION]), [[-_]],
                            [gnu], [gnits]))
 AM_SILENT_RULES([yes])
@@ -73,8 +71,19 @@ if test "$enable_gcc_warnings" = yes; then
   warn_c='-Wbad-function-cast -Wmissing-declarations -Wmissing-prototypes
     -Wshadow -Wstrict-prototypes'
   warn_cxx='-Wnoexcept'
-
   AC_LANG_PUSH([C])
+  # Clang supports many of GCC's -W options, but only issues warnings
+  # on the ones it does not recognize.  In that case, gl_WARN_ADD
+  # thinks the option is supported, and unknown options are then added
+  # to CFLAGS.  But then, when -Werror is added in the test suite for
+  # instance, the warning about the unknown option turns into an
+  # error.
+  #
+  # This should be addressed by gnulib's gl_WARN_ADD, but in the
+  # meanwhile, turn warnings about unknown options into errors in
+  # CFLAGS, and restore CFLAGS after the tests.
+  save_CFLAGS=$CFLAGS
+  gl_WARN_ADD([-Werror=unknown-warning-option], [CFLAGS])
   for i in $warn_common $warn_c;
   do
     gl_WARN_ADD([$i], [WARN_CFLAGS])
@@ -83,9 +92,12 @@ if test "$enable_gcc_warnings" = yes; then
   # Warnings for the test suite only.
   gl_WARN_ADD([-Wundef], [WARN_CFLAGS_TEST])
   gl_WARN_ADD([-pedantic], [WARN_CFLAGS_TEST])
+  CFLAGS=$save_CFLAGS
   AC_LANG_POP([C])
 
   AC_LANG_PUSH([C++])
+  save_CXXFLAGS=$CXXFLAGS
+  gl_WARN_ADD([-Werror=unknown-warning-option], [CXXFLAGS])
   for i in $warn_common $warn_cxx;
   do
     gl_WARN_ADD([$i], [WARN_CXXFLAGS])
@@ -96,11 +108,13 @@ if test "$enable_gcc_warnings" = yes; then
   # Warnings for the test suite only.
   gl_WARN_ADD([-Wundef], [WARN_CXXFLAGS_TEST])
   gl_WARN_ADD([-pedantic], [WARN_CXXFLAGS_TEST])
+  CXXFLAGS=$save_CXXFLAGS
   AC_LANG_POP([C++])
 fi
 
 BISON_TEST_FOR_WORKING_C_COMPILER
 BISON_TEST_FOR_WORKING_CXX_COMPILER
+BISON_C_COMPILER_POSIXLY_CORRECT
 
 AC_ARG_ENABLE([yacc],
   [AC_HELP_STRING([--disable-yacc],
@@ -108,8 +122,8 @@ AC_ARG_ENABLE([yacc],
   , [enable_yacc=yes])
 case $enable_yacc in
 yes)
-  YACC_SCRIPT=src/yacc
-  YACC_LIBRARY=lib/liby.a;;
+  YACC_SCRIPT=yacc
+  YACC_LIBRARY=liby.a;;
 *)
   YACC_SCRIPT=
   YACC_LIBRARY=;;
@@ -167,7 +181,7 @@ AC_CONFIG_FILES([etc/bench.pl], [chmod +x etc/bench.pl])
 
 # Initialize the test suite.
 AC_CONFIG_TESTDIR(tests)
-AC_CONFIG_FILES([tests/atlocal])
+AC_CONFIG_FILES([tests/Makefile tests/atlocal])
 AC_CONFIG_FILES([tests/bison], [chmod +x tests/bison])
 AC_CHECK_PROGS([VALGRIND], [valgrind])
 case $VALGRIND:$host_os in
@@ -177,30 +191,24 @@ case $VALGRIND:$host_os in
     # VALGRIND+=' --suppressions=$(abs_top_srcdir)/build-aux/darwin11.4.0.valgrind'
     VALGRIND=;;
   *:*)
-    AC_SUBST([VALGRIND_PREBISON], [$VALGRIND -q]);;
+    AC_SUBST([VALGRIND_PREBISON], ["$VALGRIND -q"]);;
 esac
 
 AM_MISSING_PROG([AUTOM4TE], [autom4te])
 # Needed by tests/atlocal.in.
 AC_SUBST([GCC])
 
-gt_JAVACOMP([1.3], [1.4])
+gt_JAVACOMP([1.3])
 gt_JAVAEXEC
 
-# We use gnulib, but from lib/local.mk instead of lib/Makefile.am.
-# So prefix paths with lib/.  See also etc/prefix-gnulib-mk.
-gl_LIBOBJS=`echo "$gl_LIBOBJS" | sed -e 's, , lib/,g'`
-# Listing the names of the variables to prefix is error-prone.
-# Rather, adjust all the AC_SUBST variables whose name ends in '_H',
-# and whose content ends in '.h'.
-for ac_var in $ac_subst_vars
-do
-  eval "ac_val=\$$ac_var"
-  case $ac_var=$ac_val in
-    (*_H=*.h) eval "$ac_var=lib/\$$ac_var";;
-  esac
-done
 AC_CONFIG_FILES([Makefile
-                 po/Makefile.in
-                 doc/yacc.1])
+		 build-aux/Makefile
+		 po/Makefile.in
+		 data/Makefile
+		 etc/Makefile
+		 examples/Makefile
+		    examples/calc++/Makefile
+		 lib/Makefile src/Makefile
+		 doc/Makefile
+		   doc/yacc.1])
 AC_OUTPUT

data/.cvsignore

@@ -0,0 +1,2 @@
+Makefile.in
+Makefile

data/.gitignore

@@ -0,0 +1,2 @@
+/Makefile.in
+/Makefile

data/Makefile.am

@@ -0,0 +1,30 @@
+## Copyright (C) 2002, 2005-2012 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+dist_pkgdata_DATA = README bison.m4 \
+   c-like.m4 \
+   c-skel.m4 c.m4 yacc.c glr.c \
+   c++-skel.m4 c++.m4 location.cc lalr1.cc glr.cc stack.hh \
+   java-skel.m4 java.m4 lalr1.java
+
+m4sugardir = $(pkgdatadir)/m4sugar
+dist_m4sugar_DATA = m4sugar/m4sugar.m4 m4sugar/foreach.m4
+
+xsltdir = $(pkgdatadir)/xslt
+dist_xslt_DATA =				\
+   xslt/bison.xsl				\
+   xslt/xml2dot.xsl				\
+   xslt/xml2text.xsl				\
+   xslt/xml2xhtml.xsl

data/bison.m4

@@ -22,17 +22,14 @@
 ## Identification.  ##
 ## ---------------- ##
 
-# b4_copyright(TITLE, [YEARS])
-# ----------------------------
-# If YEARS are not defined, use b4_copyright_years.
+# b4_copyright(TITLE, YEARS)
+# --------------------------
 m4_define([b4_copyright],
 [b4_comment([A Bison parser, made by GNU Bison b4_version.])
 
 b4_comment([$1
 
-]m4_dquote(m4_text_wrap([Copyright (C)
-]m4_ifval([$2], [[$2]], [m4_defn([b4_copyright_years])])[
-Free Software Foundation, Inc.]))[
+m4_text_wrap([Copyright (C) $2 Free Software Foundation, Inc.], [   ])
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -197,87 +194,6 @@ m4_define([b4_ints_in],
 [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
 
 
-# b4_subtract(LHS, RHS)
-# ---------------------
-# Evaluate LHS - RHS if they are integer literals, otherwise expand
-# to (LHS) - (RHS).
-m4_define([b4_subtract],
-[m4_bmatch([$1$2], [^[0123456789]*$],
-           [m4_eval([$1 - $2])],
-           [($1) - ($2)])])
-
-# b4_args(ARG1, ...)
-# _b4_args(ARG1, ...)
-# -------------------
-# Join with comma, skipping empty arguments.
-# b4_args calls itself recursively until it sees the first non-empty
-# argument, then calls _b4_args which prepends each non-empty argument
-# with a comma.
-m4_define([b4_args],
-[m4_if([$#$1],
-       [1], [],
-       [m4_ifval([$1],
-                 [$1[]_$0(m4_shift($@))],
-                 [$0(m4_shift($@))])])])
-
-# _b4_args(ARGS1, ...)
-# --------------------
-m4_define([_b4_args],
-[m4_if([$#$1],
-       [1], [],
-       [m4_ifval([$1], [, $1])[]$0(m4_shift($@))])])
-
-
-
-
-# b4_integral_parser_tables_map(MACRO)
-# -------------------------------------
-# Map MACRO on all the integral tables.  MACRO is expected to have
-# the signature MACRO(TABLE-NAME, CONTENT, COMMENT).
-m4_define([b4_integral_parser_tables_map],
-[$1([pact], [b4_pact],
-    [[YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-STATE-NUM.]])
-
-$1([defact], [b4_defact],
-   [[YYDEFACT[S] -- default reduction number in state S.  Performed when
-YYTABLE does not specify something else to do.  Zero means the default
-is an error.]])
-
-$1([pgoto], [b4_pgoto], [[YYPGOTO[NTERM-NUM].]])
-
-$1([defgoto], [b4_defgoto], [[YYDEFGOTO[NTERM-NUM].]])
-
-$1([table], [b4_table],
-   [[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.]])
-
-$1([check], [b4_check])
-
-$1([stos], [b4_stos],
-   [[STOS_[STATE-NUM] -- The (internal number of the) accessing
-symbol of state STATE-NUM.]])
-
-$1([r1], [b4_r1],
-   [[YYR1[YYN] -- Symbol number of symbol that rule YYN derives.]])
-
-$1([r2], [b4_r2],
-   [[YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.]])
-])
-
-
-# b4_parser_tables_declare
-# b4_parser_tables_define
-# ------------------------
-# Define/declare the (deterministic) parser tables.
-m4_define([b4_parser_tables_declare],
-[b4_integral_parser_tables_map([b4_integral_parser_table_declare])])
-
-m4_define([b4_parser_tables_define],
-[b4_integral_parser_tables_map([b4_integral_parser_table_define])])
-
-
 
 ## ------------------ ##
 ## Decoding options.  ##
@@ -289,8 +205,8 @@ m4_define([b4_parser_tables_define],
 m4_define([b4_flag_if],
 [m4_case(b4_$1_flag,
          [0], [$3],
-         [1], [$2],
-         [m4_fatal([invalid $1 value: ]$1)])])
+	 [1], [$2],
+	 [m4_fatal([invalid $1 value: ]$1)])])
 
 
 # b4_define_flag_if(FLAG)
@@ -316,166 +232,15 @@ m4_define([b4_$3_if],
 # -----------------------------
 # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise.
 b4_define_flag_if([defines])            # Whether headers are requested.
+b4_define_flag_if([error_verbose])      # Whether error are verbose.
 b4_define_flag_if([glr])                # Whether a GLR parser is requested.
+b4_define_flag_if([locations])          # Whether locations are tracked.
 b4_define_flag_if([nondeterministic])   # Whether conflicts should be handled.
 b4_define_flag_if([token_table])        # Whether yytoken_table is demanded.
 b4_define_flag_if([yacc])               # Whether POSIX Yacc is emulated.
 
-
-## --------- ##
-## Symbols.  ##
-## --------- ##
-
-# In order to unify the handling of the various aspects of symbols
-# (tag, type_name, whether terminal, etc.), bison.exe defines one
-# macro per (token, field), where field can has_id, id, etc.: see
-# src/output.c:prepare_symbols_definitions().
-#
-# The following macros provide access to these values.
-
-# b4_symbol_(NUM, FIELD)
-# ----------------------
-# Recover a FIELD about symbol #NUM.  Thanks to m4_indir, fails if
-# undefined.
-m4_define([b4_symbol_],
-[m4_indir([b4_symbol($1, $2)])])
-
-
-# b4_symbol(NUM, FIELD)
-# ---------------------
-# Recover a FIELD about symbol #NUM.  Thanks to m4_indir, fails if
-# undefined.  If FIELD = id, prepend the prefix.
-m4_define([b4_symbol],
-[m4_case([$2],
-         [id],    [m4_do([b4_percent_define_get([api.tokens.prefix])],
-                         [b4_symbol_([$1], [id])])],
-         [b4_symbol_($@)])])
-
-
-# b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE)
-# -------------------------------------------
-# If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE.
-# Otherwise an error.
-m4_define([b4_symbol_if],
-[m4_case(b4_symbol([$1], [$2]),
-         [1], [$3],
-         [0], [$4],
-         [m4_fatal([$0: field $2 of $1 is not a Boolean:] b4_symbol([$1], [$2]))])])
-
-
-# b4_symbol_action_location(SYMBOL-NUM, KIND)
-# -------------------------------------------
-# Report the location of the KIND action as FILE:LINE.
-m4_define([b4_symbol_action_location],
-[b4_symbol([$1], [$2_file]):b4_syncline([b4_symbol([$1], [$2_line])])])
-
-
-# b4_symbol_action(SYMBOL-NUM, KIND)
-# ----------------------------------
-# Run the action KIND (destructor or printer) for SYMBOL-NUM.
-# Same as in C, but using references instead of pointers.
-m4_define([b4_symbol_action],
-[b4_symbol_if([$1], [has_$2],
-[m4_pushdef([b4_dollar_dollar],
-    [b4_symbol_value([(*yyvaluep)],
-                     b4_symbol_if([$1], [has_type],
-                                  [b4_symbol([$1], [type])]))])dnl
-m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
-      b4_symbol_case_([$1])
-b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
-        b4_symbol([$1], [$2])
-b4_syncline([@oline@], [@ofile@])
-        break;
-
-m4_popdef([b4_at_dollar])dnl
-m4_popdef([b4_dollar_dollar])dnl
-])])
-
-
-# b4_symbol_destructor(SYMBOL-NUM)
-# b4_symbol_printer(SYMBOL-NUM)
-# --------------------------------
-m4_define([b4_symbol_destructor], [b4_symbol_action([$1], [destructor])])
-m4_define([b4_symbol_printer],    [b4_symbol_action([$1], [printer])])
-
-
-# b4_symbol_case_(SYMBOL-NUM)
-# ---------------------------
-# Issue a "case NUM" for SYMBOL-NUM.
-m4_define([b4_symbol_case_],
-[      case b4_symbol([$1], [number]): // b4_symbol([$1], [tag])
-])
-
-
-# b4_symbol_foreach(MACRO)
-# ------------------------
-# Invoke MACRO(SYMBOL-NUM) for each SYMBOL-NUM.
-m4_define([b4_symbol_foreach],
-          [m4_map([$1], m4_defn([b4_symbol_numbers]))])
-
-# b4_symbol_map(MACRO)
-# --------------------
-# Return a list (possibly empty elements) of MACRO invoked for each
-# SYMBOL-NUM.
-m4_define([b4_symbol_map],
-[m4_map_args_sep([$1(], [)], [,], b4_symbol_numbers)])
-
-
-# b4_token_visible_if(NUM, IF-TRUE, IF-FALSE)
-# -------------------------------------------
-# Whether NUM denotes a token that has an exported definition (i.e.,
-# shows in enum yytokentype).
-m4_define([b4_token_visible_if],
-[b4_symbol_if([$1], [is_token],
-              [b4_symbol_if([$1], [has_id], [$2], [$3])],
-              [$3])])
-
-# b4_token_has_definition(NUM)
-# ----------------------------
-# 1 if NUM is visible, nothing otherwise.
-m4_define([b4_token_has_definition],
-[b4_token_visible_if([$1], [1])])
-
-# b4_any_token_visible_if([IF-TRUE], [IF-FALSE])
-# ----------------------------------------------
-# Whether there is a token that needs to be defined.
-m4_define([b4_any_token_visible_if],
-[m4_ifval(b4_symbol_foreach([b4_token_has_definition]),
-          [$1], [$2])])
-
-
-# b4_token_format(FORMAT, NUM)
-# ----------------------------
-m4_define([b4_token_format],
-[b4_token_visible_if([$2],
-[m4_quote(m4_format([$1],
-                     [b4_symbol([$2], [id])],
-                     [b4_symbol([$2], [user_number])]))])])
-
-
-## ------- ##
-## Types.  ##
-## ------- ##
-
-# b4_type_action_(NUMS)
-# ---------------------
-# Run actions for the symbol NUMS that all have the same type-name.
-# Skip NUMS that have no type-name.
-m4_define([b4_type_action_],
-[b4_symbol_if([$1], [has_type],
-[m4_map_args([b4_symbol_case_], $@)[]dnl
-        b4_dollar_dollar([b4_symbol([$1], [number])],
-                         [b4_symbol([$1], [tag])],
-                         [b4_symbol([$1], [type])]);
-        break;
-
-])])
-
-# b4_type_foreach(MACRO)
-# ----------------------
-# Invoke MACRO(SYMBOL-NUMS) for each set of SYMBOL-NUMS for each type set.
-m4_define([b4_type_foreach],
-          [m4_map([$1], m4_defn([b4_type_names]))])
+# yytoken_table is needed to support verbose errors.
+b4_error_verbose_if([m4_define([b4_token_table_flag], [1])])
 
 
 
@@ -584,6 +349,7 @@ m4_popdef([b4_end])dnl
 
 
 
+
 ## --------------------- ##
 ## b4_percent_define_*.  ##
 ## --------------------- ##
@@ -613,6 +379,7 @@ m4_ifdef([b4_percent_define(]$1[)],
          [m4_indir([b4_percent_define(]$1[)])],
          [$2])])
 
+
 # b4_percent_define_get_loc(VARIABLE)
 # -----------------------------------
 # Mimic muscle_percent_define_get_loc in ../src/muscle-tab.h exactly.  That is,
@@ -661,14 +428,8 @@ m4_define([b4_percent_define_get_syncline],
 #   b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]])
 m4_define([b4_percent_define_ifdef],
 [m4_ifdef([b4_percent_define(]$1[)],
-          [b4_percent_define_use([$1])$2],
-          [$3])])
-
-
-## --------- ##
-## Options.  ##
-## --------- ##
-
+	  [m4_define([b4_percent_define_bison_variables(]$1[)])$2],
+	  [$3])])
 
 # b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE])
 # --------------------------------------------------------
@@ -693,7 +454,6 @@ m4_define([b4_percent_define_flag_if],
                            [[b4_percent_define_flag_if($1)]])])],
   [b4_fatal([[b4_percent_define_flag_if: undefined %%define variable '%s']], [$1])])])
 
-
 # b4_percent_define_default(VARIABLE, DEFAULT)
 # --------------------------------------------
 # Mimic muscle_percent_define_default in ../src/muscle-tab.h exactly.  That is,
@@ -712,20 +472,6 @@ m4_define([b4_percent_define_default],
                         [[<skeleton default value>:-1.-1]]]])dnl
             m4_define([b4_percent_define_syncline(]$1[)], [[]])])])
 
-
-# b4_percent_define_if_define(VARIABLE)
-# -------------------------------------
-# Define b4_VARIABLE_if that executes its $1 or $2 depending whether
-# VARIABLE was %defined.  The characters `.' and `-' in VARIABLE are mapped
-# to `_'.
-m4_define([b4_percent_define_if_define_],
-[m4_define(m4_bpatsubst([b4_$1_if], [[-.]], [_]),
-           [b4_percent_define_flag_if([$1], [$2], [$3])])])
-m4_define([b4_percent_define_if_define],
-[b4_percent_define_default([[$1]], [[false]])
-b4_percent_define_if_define_([$1], $[1], $[2])])
-
-
 # b4_percent_define_check_values(VALUES)
 # --------------------------------------
 # Mimic muscle_percent_define_check_values in ../src/muscle-tab.h exactly
@@ -797,45 +543,7 @@ m4_popdef([b4_macro_name])])
 m4_define([b4_percent_code_ifdef],
 [m4_ifdef([b4_percent_code(]$1[)],
           [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2],
-          [$3])])
-
-
-## ------------------ ##
-## Common variables.  ##
-## ------------------ ##
-
-# Default values for %define.
-# ---------------------------
-# If the api.tokens.prefix, it is empty.
-m4_percent_define_default([[api.tokens.prefix]], [[]])
-
-# b4_parse_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])
-# b4_parse_trace_if([IF-DEBUG-TRACES-ARE-ENABLED], [IF-NOT])
-# b4_lex_symbol_if([IF-YYLEX-RETURNS-A-COMPLETE-SYMBOL], [IF-NOT])
-# b4_variant_if([IF-VARIANT-ARE-USED], [IF-NOT])
-# ----------------------------------------------
-b4_percent_define_if_define([lex_symbol])
-b4_percent_define_if_define([locations])     # Whether locations are tracked.
-b4_percent_define_if_define([parse.assert])
-b4_percent_define_if_define([parse.trace])
-b4_percent_define_if_define([variant])
-
-
-# b4_error_verbose_if([IF-ERRORS-ARE-VERBOSE], [IF-NOT])
-# ------------------------------------------------------
-# Map %define parse.error "(simple|verbose)" to b4_error_verbose_if and
-# b4_error_verbose_flag.
-b4_percent_define_default([[parse.error]], [[simple]])
-b4_percent_define_check_values([[[[parse.error]],
-                                 [[simple]], [[verbose]]]])
-m4_define([b4_error_verbose_flag],
-          [m4_case(b4_percent_define_get([[parse.error]]),
-                   [simple],  [[0]],
-                   [verbose], [[1]])])
-b4_define_flag_if([error_verbose])
-
-# yytoken_table is needed to support verbose errors.
-b4_error_verbose_if([m4_define([b4_token_table_flag], [1])])
+	  [$3])])
 
 
 ## ----------------------------------------------------------- ##

data/c++.m4

@@ -23,6 +23,7 @@ m4_include(b4_pkgdatadir/[c.m4])
 ## Default values.  ##
 ## ---------------- ##
 
+# Default parser class name.
 b4_percent_define_default([[parser_class_name]], [[parser]])
 
 # Don't do that so that we remember whether we're using a user
@@ -31,21 +32,18 @@ b4_percent_define_default([[parser_class_name]], [[parser]])
 # b4_percent_define_default([[location_type]], [[location]])
 
 b4_percent_define_default([[filename_type]], [[std::string]])
-b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
-
+b4_percent_define_default([[namespace]], m4_defn([b4_prefix]))
 b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
 b4_percent_define_default([[define_location_comparison]],
                           [m4_if(b4_percent_define_get([[filename_type]]),
                                  [std::string], [[true]], [[false]])])
 
 
-
 ## ----------- ##
 ## Namespace.  ##
 ## ----------- ##
 
-m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])])
-
+m4_define([b4_namespace_ref], [b4_percent_define_get([[namespace]])])
 
 # Don't permit an empty b4_namespace_ref.  Any `::parser::foo' appended to it
 # would compile as an absolute reference with `parser' in the global namespace.
@@ -55,7 +53,7 @@ m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])])
 # include the header, which is always generated.  If we ever need to permit
 # internal linkage somehow, surely we can find a cleaner approach.
 m4_if(m4_bregexp(b4_namespace_ref, [^[	 ]*$]), [-1], [],
-[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
+[b4_complain_at(b4_percent_define_get_loc([[namespace]]),
                 [[namespace reference is empty]])])
 
 # Instead of assuming the C++ compiler will do it, Bison should reject any
@@ -66,37 +64,37 @@ m4_if(m4_bregexp(b4_namespace_ref, [^[	 ]*$]), [-1], [],
 # Specifically, don't allow empty names as b4_namespace_open would just convert
 # those into anonymous namespaces, and that might tempt some users.
 m4_if(m4_bregexp(b4_namespace_ref, [::[	 ]*::]), [-1], [],
-[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
+[b4_complain_at(b4_percent_define_get_loc([[namespace]]),
                 [[namespace reference has consecutive "::"]])])
 m4_if(m4_bregexp(b4_namespace_ref, [::[	 ]*$]), [-1], [],
-[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
+[b4_complain_at(b4_percent_define_get_loc([[namespace]]),
                 [[namespace reference has a trailing "::"]])])
 
 m4_define([b4_namespace_open],
-[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
+[b4_user_code([b4_percent_define_get_syncline([[namespace]])
 [namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref),
                                                 [^\(.\)[	 ]*::], [\1])),
                          [::], [ { namespace ])[ {]])])
 
 m4_define([b4_namespace_close],
-[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
+[b4_user_code([b4_percent_define_get_syncline([[namespace]])
 m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]),
                                     [^\(.\)[	 ]*\(::\)?\([^][:]\|:[^:]\)*],
                                     [\1])),
              [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])])
 
 
-# b4_token_enums
-# --------------
+# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
+# -----------------------------------------------------
 # Output the definition of the tokens as enums.
 m4_define([b4_token_enums],
-[[/* Tokens.  */
-    enum yytokentype {
-    ]m4_join([,
-      ],
-             b4_symbol_map([b4_token_enum]))[
-    };
-]])
+[/* Tokens.  */
+   enum yytokentype {
+m4_map_sep([     b4_token_enum], [,
+],
+           [$@])
+   };
+])
 
 
 
@@ -105,263 +103,12 @@ m4_define([b4_token_enums],
 ## Semantic Values.  ##
 ## ----------------- ##
 
-# b4_semantic_type_declare
-# ------------------------
-# Declare semantic_type.
-m4_define([b4_semantic_type_declare],
-[    /// Symbol semantic values.
-m4_ifdef([b4_stype],
-[    union semantic_type
-    {b4_user_stype
-    };],
-[m4_if(b4_tag_seen_flag, 0,
-[[    typedef int semantic_type;]],
-[[    typedef ]b4_api_PREFIX[STYPE semantic_type;]])])])
-
-
-# b4_public_types_declare
-# -----------------------
-# Define the public types: token, semantic value, location, and so forth.
-# Depending on %define token_lex, may be output in the header or source file.
-m4_define([b4_public_types_declare],
-[[#ifndef ]b4_api_PREFIX[STYPE
-]b4_semantic_type_declare[
-#else
-    typedef ]b4_api_PREFIX[STYPE semantic_type;
-#endif]b4_locations_if([
-    /// Symbol locations.
-    typedef b4_percent_define_get([[location_type]],
-                                  [[location]]) location_type;])[
-
-    /// Syntax errors thrown from user actions.
-    struct syntax_error : std::runtime_error
-    {
-      syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([
-      location_type location;])[
-    };
-
-    /// Tokens.
-    struct token
-    {
-      ]b4_token_enums[
-    };
-
-    /// Token type.
-    typedef token::yytokentype token_type;
-
-    /// A complete symbol, with its type.
-    template <typename Exact>
-    struct symbol_base_type
-    {
-      /// Default constructor.
-      inline symbol_base_type ();
-
-      /// Constructor.]b4_locations_if([
-      inline symbol_base_type (const location_type& l)])[;
-      inline symbol_base_type (]b4_args(
-        [const semantic_type& v],
-        b4_locations_if([const location_type& l]))[);
-
-      /// Return this with its exact type.
-      const Exact& self () const;
-      Exact& self ();
-
-      /// Return the type of this symbol.
-      int type_get () const;
-
-      /// The semantic value.
-      semantic_type value;]b4_locations_if([
-
-      /// The location.
-      location_type location;])[
-    };
-
-    /// External form of a symbol: its type and attributes.
-    struct symbol_type : symbol_base_type<symbol_type>
-    {
-      /// The parent class.
-      typedef symbol_base_type<symbol_type> super_type;
-
-      /// Default constructor.
-      inline symbol_type ();
-
-      /// Constructor for tokens with semantic value.
-      inline symbol_type (]b4_args([token_type t],
-                                   [const semantic_type& v],
-                                   b4_locations_if([const location_type& l]))[);
-
-      /// Constructor for valueless tokens.
-      inline symbol_type (]b4_args([token_type t],
-                                   b4_locations_if([const location_type& l]))[);
-
-      /// The symbol type.
-      int type;
-
-      /// The symbol type.
-      inline int type_get_ () const;
-
-      /// The token.
-      inline token_type token () const;
-    };
-]b4_symbol_constructor_declare])
-
-
-# b4_public_types_define
-# ----------------------
-# Provide the implementation needed by the public types.
-m4_define([b4_public_types_define],
-[[  inline
-  ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
-    : std::runtime_error (m)]b4_locations_if([
-    , location (l)])[
-  {}
-
-  // symbol_base_type.
-  template <typename Exact>
-  inline
-  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
-    : value()]b4_locations_if([
-    , location()])[
-  {
-  }]b4_locations_if([[
-
-  template <typename Exact>
-  inline
-  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const location_type& l)
-    : value()
-    , location(l)
-  {
-  }]])[
-
-  template <typename Exact>
-  inline
-  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (]b4_args(
-          [const semantic_type& v],
-          b4_locations_if([const location_type& l]))[)
-    : value(v)]b4_locations_if([
-    , location(l)])[
-  {
-  }
-
-  template <typename Exact>
-  inline
-  const Exact&
-  ]b4_parser_class_name[::symbol_base_type<Exact>::self () const
-  {
-    return static_cast<const Exact&>(*this);
-  }
-
-  template <typename Exact>
-  inline
-  Exact&
-  ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
-  {
-    return static_cast<Exact&>(*this);
-  }
-
-  template <typename Exact>
-  inline
-  int
-  ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
-  {
-    return self ().type_get_ ();
-  }
-
-  // symbol_type.
-  inline
-  ]b4_parser_class_name[::symbol_type::symbol_type ()
-    : super_type ()
-    , type ()
-  {
-  }
-
-  inline
-  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
-                [token_type t],
-                b4_locations_if([const location_type& l]))[)
-    : super_type (]b4_locations_if([l])[)
-    , type (yytranslate_ (t))
-  {
-  }
-
-  inline
-  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
-                 [token_type t],
-                 [const semantic_type& v],
-                 b4_locations_if([const location_type& l]))[)
-    : super_type (v]b4_locations_if([, l])[)
-    , type (yytranslate_ (t))
-  {
-  }
-
-  inline
-  int
-  ]b4_parser_class_name[::symbol_type::type_get_ () const
-  {
-    return type;
-  }
-]b4_lex_symbol_if([[
-  inline
-  ]b4_parser_class_name[::token_type
-  ]b4_parser_class_name[::symbol_type::token () const
-  {
-    // YYTOKNUM[NUM] -- (External) token number corresponding to the
-    // (internal) symbol number NUM (which must be that of a token).  */
-    static
-    const ]b4_int_type_for([b4_toknum])[
-    yytoken_number_[] =
-    {
-  ]b4_toknum[
-    };
-    return static_cast<token_type> (yytoken_number_[type]);
-  }
-]])[]dnl
-b4_symbol_constructor_define])
-
-
-# b4_symbol_constructor_declare
-# b4_symbol_constructor_define
-# -----------------------------
-# Declare/define symbol constructors for all the value types.
-# Use at class-level.  Redefined in variant.hh.
-m4_define([b4_symbol_constructor_declare], [])
-m4_define([b4_symbol_constructor_define], [])
-
-
-# b4_yytranslate_define
-# ---------------------
-# Define yytranslate_.  Sometimes used in the header file,
-# sometimes in the cc file.
-m4_define([b4_yytranslate_define],
-[[  // Symbol number corresponding to token number t.
-  ]b4_parser_class_name[::token_number_type
-  ]b4_parser_class_name[::yytranslate_ (]b4_lex_symbol_if([token_type],
-                                                          [int])[ t)
-  {
-    static
-    const token_number_type
-    translate_table[] =
-    {
-]b4_translate[
-    };
-    const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
-    const token_number_type undef_token_ = ]b4_undef_token_number[;
-
-    if (static_cast<int>(t) <= yyeof_)
-      return yyeof_;
-    else if (static_cast<unsigned int> (t) <= user_token_number_max_)
-      return translate_table[t];
-    else
-      return undef_token_;
-  }
-]])
-
 
 # b4_lhs_value([TYPE])
 # --------------------
 # Expansion of $<TYPE>$.
 m4_define([b4_lhs_value],
-[b4_symbol_value([yyval], [$1])])
+[(yyval[]m4_ifval([$1], [.$1]))])
 
 
 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
@@ -369,8 +116,7 @@ m4_define([b4_lhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
-[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])])
-
+[(yysemantic_stack_@{($1) - ($2)@}m4_ifval([$3], [.$3]))])
 
 # b4_lhs_location()
 # -----------------
@@ -407,27 +153,27 @@ m4_define([b4_parse_param_decl_1],
 # Extra initialisations of the constructor.
 m4_define([b4_parse_param_cons],
           [m4_ifset([b4_parse_param],
-                    [
+		    [
       b4_cc_constructor_calls(b4_parse_param)])])
 m4_define([b4_cc_constructor_calls],
-          [m4_map_sep([b4_cc_constructor_call], [,
+	  [m4_map_sep([b4_cc_constructor_call], [,
       ], [$@])])
 m4_define([b4_cc_constructor_call],
-          [$2 ($2_yyarg)])
+	  [$2 ($2_yyarg)])
 
 # b4_parse_param_vars
 # -------------------
 # Extra instance variables.
 m4_define([b4_parse_param_vars],
           [m4_ifset([b4_parse_param],
-                    [
+		    [
     /* User arguments.  */
 b4_cc_var_decls(b4_parse_param)])])
 m4_define([b4_cc_var_decls],
-          [m4_map_sep([b4_cc_var_decl], [
+	  [m4_map_sep([b4_cc_var_decl], [
 ], [$@])])
 m4_define([b4_cc_var_decl],
-          [    $1;])
+	  [    $1;])
 
 
 ## ---------##

data/c-like.m4

@@ -0,0 +1,44 @@
+                                                            -*- Autoconf -*-
+
+# Common code for C-like languages (C, C++, Java, etc.)
+
+# Copyright (C) 2012 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# b4_dollar_dollar_(VALUE, FIELD, DEFAULT-FIELD)
+# ----------------------------------------------
+# If FIELD (or DEFAULT-FIELD) is non-null, return "VALUE.FIELD",
+# otherwise just VALUE.  Be sure to pass "(VALUE)" is VALUE is a
+# pointer.
+m4_define([b4_dollar_dollar_],
+[m4_if([$2], [[]],
+       [m4_ifval([$3], [($1.$3)],
+                 [$1])],
+       [($1.$2)])])
+
+# b4_dollar_pushdef(VALUE-POINTER, DEFAULT-FIELD, LOCATION)
+# b4_dollar_popdef
+# ---------------------------------------------------------
+# Define b4_dollar_dollar for VALUE and DEFAULT-FIELD,
+# and b4_at_dollar for LOCATION.
+m4_define([b4_dollar_pushdef],
+[m4_pushdef([b4_dollar_dollar],
+            [b4_dollar_dollar_([$1], m4_dquote($][1), [$2])])dnl
+m4_pushdef([b4_at_dollar], [$3])dnl
+])
+m4_define([b4_dollar_popdef],
+[m4_popdef([b4_at_dollar])dnl
+m4_popdef([b4_dollar_dollar])dnl
+])

data/c.m4

@@ -17,6 +17,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+m4_include(b4_pkgdatadir/[c-like.m4])
 
 # b4_tocpp(STRING)
 # ----------------
@@ -29,53 +30,32 @@ m4_define([b4_tocpp],
 # ------------------
 # A valid C macro name to use as a CPP header guard for FILE.
 m4_define([b4_cpp_guard],
-[b4_tocpp(m4_defn([b4_prefix])/[$1])])
+[[YY_]b4_tocpp(m4_defn([b4_prefix])/[$1])[_INCLUDED]])
 
 
 # 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, OPEN, CONTINUE, END)
-# -------------------------------------
-# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
-# Avoid adding indentation to the first line, as the indentation comes
-# from OPEN.  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
-#
-# Prefix all the output lines with PREFIX.
-m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [
-\(.\)], [
-$3\1])$4])
-
-
-# b4_c_comment(TEXT, [PREFIX])
-# ----------------------------
-# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
-# Avoid adding indentation to the first line, as the indentation comes
-# from "/*".  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
-#
-# Prefix all the output lines with PREFIX.
-m4_define([b4_c_comment],
-[b4_comment_([$1], [$2/* ], [$2   ], [$2  */])])
-
-
-# b4_comment(TEXT, [PREFIX])
-# --------------------------
-# By default, C comments.
-m4_define([b4_comment], [b4_c_comment($@)])
-
+# b4_comment(TEXT)
+# ----------------
+m4_define([b4_comment], [/* m4_bpatsubst([$1], [
+], [
+   ])  */])
 
 # b4_identification
 # -----------------
@@ -157,13 +137,11 @@ m4_popdef([$2])dnl
 m4_popdef([$1])dnl
 ])])
 
-# b4_parse_param_use([VAL], [LOC])
-# --------------------------------
-# `YYUSE' VAL, LOC if locations are enabled, and all the parse-params.
+# b4_parse_param_use
+# ------------------
+# `YYUSE' all the parse-params.
 m4_define([b4_parse_param_use],
-[m4_ifvaln([$1], [  YYUSE([$1]);])dnl
-b4_locations_if([m4_ifvaln([$2], [  YYUSE ([$2]);])])dnl
-b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
+[b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
 ])dnl
 ])
 
@@ -185,7 +163,7 @@ m4_define([b4_int_type],
 
        m4_eval([0 <= $1]),                [1], [unsigned int],
 
-                                               [int])])
+					       [int])])
 
 
 # b4_int_type_for(NAME)
@@ -206,7 +184,7 @@ 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)]],
-       [[((]$2[) == (]$3[))]])])
+       [(!!(($2) == ($3)))])])
 
 
 ## ---------##
@@ -234,83 +212,63 @@ m4_define([b4_null_define],
 # Return a null pointer constant.
 m4_define([b4_null], [YY_NULL])
 
-# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
-# -------------------------------------------------------------
-# Define "yy<TABLE-NAME>" which contents is CONTENT.
-m4_define([b4_integral_parser_table_define],
-[m4_ifvaln([$3], [b4_c_comment([$3], [  ])])dnl
-static const b4_int_type_for([$2]) yy$1[[]] =
-{
-  $2
-};dnl
-])
 
 
 ## ------------------------- ##
 ## Assigning token numbers.  ##
 ## ------------------------- ##
 
-# b4_token_define(TOKEN-NUM)
-# --------------------------
+# b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
+# -----------------------------------------
 # Output the definition of this token as #define.
 m4_define([b4_token_define],
-[b4_token_format([#define %s %s], [$1])])
+[#define $1 $2
+])
 
-# b4_token_defines
-# ----------------
-# Output the definition of the tokens.
+
+# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
+# -------------------------------------------------------
+# Output the definition of the tokens (if there are) as #defines.
 m4_define([b4_token_defines],
-[b4_any_token_visible_if([/* Tokens.  */
-m4_join([
-], b4_symbol_map([b4_token_define]))])])
+[m4_if([$#$1], [1], [],
+[/* Tokens.  */
+m4_map([b4_token_define], [$@])])
+])
 
 
-# b4_token_enum(TOKEN-NUM)
-# ------------------------
+# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
+# ---------------------------------------
 # Output the definition of this token as an enum.
 m4_define([b4_token_enum],
-[b4_token_format([  %s = %s], [$1])])
+[$1 = $2])
 
 
-# b4_token_enums
-# --------------
+# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
+# -----------------------------------------------------
 # Output the definition of the tokens (if there are) as enums.
 m4_define([b4_token_enums],
-[b4_any_token_visible_if([[/* Tokens.  */
+[m4_if([$#$1], [1], [],
+[[/* 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_join([,
-  ],
-            b4_symbol_map([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_map_sep([     b4_token_enum], [,
+],
+	   [$@])[
+   };
 #endif
 ]])])
 
 
-# b4_token_enums_defines
-# ----------------------
-# Output the definition of the tokens (if there are any) as enums and,
-# if POSIX Yacc is enabled, as #defines.
+# 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.
 m4_define([b4_token_enums_defines],
-[b4_token_enums[]b4_yacc_if([b4_token_defines])])
-
-
-## ----------------- ##
-## Semantic Values.  ##
-## ----------------- ##
-
-
-# b4_symbol_value(VAL, [TYPE])
-# ----------------------------
-# Given a semantic value VAL ($$, $1 etc.), extract its value of type
-# TYPE if TYPE is given, otherwise just return VAL.  The result can be
-# used safetly, it is put in parens to avoid nasty precedence issues.
-# TYPE is *not* put in braces, provide some if needed.
-m4_define([b4_symbol_value],
-[($1[]m4_ifval([$2], [.$2]))])
+[b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], [])
+])
 
 
 
@@ -362,7 +320,7 @@ $1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl
 m4_define([b4_c_ansi_formals],
 [m4_if([$#], [0], [void],
        [$#$1], [1], [void],
-               [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
+	       [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
 
 m4_define([b4_c_ansi_formal],
 [$1])
@@ -383,9 +341,9 @@ m4_define([b4_c_knr_formal_name],
 # Output the K&R argument declarations.
 m4_define([b4_c_knr_formal_decls],
 [m4_map_sep([b4_c_knr_formal_decl],
-            [
+	    [
 ],
-            [$@])])
+	    [$@])])
 
 m4_define([b4_c_knr_formal_decl],
 [    $1;])
@@ -401,7 +359,7 @@ m4_define([b4_c_knr_formal_decl],
 # -----------------------------------------------------------
 # Declare the function NAME.
 m4_define([b4_c_function_decl],
-[#if b4_c_modern
+[#if defined __STDC__ || defined __cplusplus
 b4_c_ansi_function_decl($@)
 #else
 $2 $1 ();
@@ -460,17 +418,25 @@ m4_define([b4_sync_start], [[#]line $1 $2])
 m4_define([b4_case],
 [  case $1:
 $2
-b4_syncline([@oline@], [@ofile@])
     break;])
 
-
-# b4_predicate_case(LABEL, CONDITIONS)
-# ------------------------------------
-m4_define([b4_predicate_case],
-[  case $1:
-    if (! ($2)) YYERROR;
+# 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_syncline([@oline@], [@ofile@])
-    break;])
+	break;
+b4_dollar_popdef[]dnl
+])
 
 
 # b4_yydestruct_generate(FUNCTION-DECLARATOR)
@@ -492,16 +458,20 @@ m4_define_default([b4_yydestruct_generate],
 b4_locations_if(            [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 {
-]b4_parse_param_use([yyvaluep], [yylocationp])dnl
-[  if (!yymsg)
+  YYUSE (yyvaluep);
+]b4_locations_if([  YYUSE (yylocationp);
+])dnl
+b4_parse_param_use[]dnl
+[
+  if (!yymsg)
     yymsg = "Deleting";
   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
   switch (yytype)
     {
-]b4_symbol_foreach([b4_symbol_destructor])dnl
-[      default:
-        break;
+]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
+      default:
+	break;
     }
 }]dnl
 ])
@@ -521,28 +491,30 @@ m4_define_default([b4_yy_symbol_print_generate],
 /*ARGSUSED*/
 ]$1([yy_symbol_value_print],
     [static void],
-               [[FILE *yyoutput],                       [yyoutput]],
-               [[int yytype],                           [yytype]],
-               [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
+	       [[FILE *yyoutput],                       [yyoutput]],
+	       [[int yytype],                           [yytype]],
+	       [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 {
   FILE *yyo = yyoutput;
-]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
+  YYUSE (yyo);
+  if (!yyvaluep)
+    return;
+]b4_locations_if([  YYUSE (yylocationp);
+])dnl
+b4_parse_param_use[]dnl
+[# ifdef YYPRINT
   if (yytype < YYNTOKENS)
     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+  YYUSE (yyoutput);
 # endif
-]])dnl
-[  switch (yytype)
+  switch (yytype)
     {
-]b4_symbol_foreach([b4_symbol_printer])dnl
+]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 [      default:
-        break;
+	break;
     }
 }
 
@@ -553,9 +525,9 @@ m4_if(b4_skeleton, ["yacc.c"],
 
 ]$1([yy_symbol_print],
     [static void],
-               [[FILE *yyoutput],                       [yyoutput]],
-               [[int yytype],                           [yytype]],
-               [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
+	       [[FILE *yyoutput],                       [yyoutput]],
+	       [[int yytype],                           [yytype]],
+	       [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 {
@@ -619,18 +591,18 @@ m4_define([b4_YYDEBUG_define],
 [[/* Enabling traces.  */
 ]m4_if(b4_api_prefix, [yy],
 [[#ifndef YYDEBUG
-# define YYDEBUG ]b4_parse_trace_if([1], [0])[
+# define YYDEBUG ]b4_debug_flag[
 #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_parse_trace_if([1], [0])[
-# endif /* ! defined ]b4_api_PREFIX[DEBUG */
+#  define ]b4_api_PREFIX[DEBUG ]b4_debug_flag[
+# endif /* ! defined YYDEBUG */
 #endif  /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl
 ])
 
@@ -671,3 +643,46 @@ m4_define([b4_yylloc_default_define],
     while (YYID (0))
 #endif
 ]])
+
+# b4_yy_location_print_define
+# ---------------------------
+# Define YY_LOCATION_PRINT.
+m4_define([b4_yy_location_print_define],
+[b4_locations_if([[
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)                                   \
+  do {                                                                   \
+    fprintf (File, "%d.%d", (Loc).first_line, (Loc).first_column);       \
+    if ((Loc).first_line < (Loc).last_line)                              \
+      fprintf (File, "-%d.%d", (Loc).last_line,  (Loc).last_column - 1); \
+    else if ((Loc).first_column < (Loc).last_column - 1)                 \
+      fprintf (File, "-%d", (Loc).last_column - 1);                      \
+  } while (0)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif]],
+[[/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif]])
+])
+
+# b4_yyloc_default
+# ----------------
+# Expand to a possible default value for yylloc.
+m4_define([b4_yyloc_default],
+[[
+# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
+  = { ]m4_join([, ],
+               m4_defn([b4_location_initial_line]),
+               m4_defn([b4_location_initial_column]),
+               m4_defn([b4_location_initial_line]),
+               m4_defn([b4_location_initial_column]))[ }
+# endif
+]])

data/glr.c

@@ -126,15 +126,7 @@ m4_define([b4_locuser_args],
 # --------------------
 # Expansion of $<TYPE>$.
 m4_define([b4_lhs_value],
-[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])
+[((*yyvalp)[]m4_ifval([$1], [.$1]))])
 
 
 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
@@ -142,7 +134,7 @@ m4_define([b4_rhs_data],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
-[b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yysval], [$3])])
+[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))])
 
 
 
@@ -162,7 +154,7 @@ m4_define([b4_lhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
-[(b4_rhs_data([$1], [$2]).yyloc)])
+[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)])
 
 
 ## -------------- ##
@@ -176,7 +168,7 @@ m4_define([b4_rhs_location],
 m4_define([b4_shared_declarations],
 [b4_declare_yydebug[
 ]b4_percent_code_get([[requires]])[
-]b4_token_enums[
+]b4_token_enums(b4_tokens)[
 ]b4_declare_yylstype[
 ]b4_c_ansi_function_decl(b4_prefix[parse], [int], b4_parse_param)[
 ]b4_percent_code_get([[provides]])[]dnl
@@ -220,22 +212,22 @@ b4_percent_code_get([[top]])[
 ]b4_null_define[
 
 ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
-              [b4_shared_declarations])[
+               [b4_shared_declarations])[
 
 /* Enabling verbose error messages.  */
 #ifdef YYERROR_VERBOSE
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
-# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
+# define YYERROR_VERBOSE ]b4_error_verbose_flag[
 #endif
 
 /* Default (constant) value used for initialization for null
-   right-hand sides.  Unlike the standard yacc.c template,
-   here we set the default value of $$ to a zeroed-out value.
-   Since the default value is undefined, this behavior is
-   technically correct.  */
-static YYSTYPE yyval_default;
+   right-hand sides.  Unlike the standard yacc.c template, here we set
+   the default value of $$ to a zeroed-out value.  Since the default
+   value is undefined, this behavior is technically correct.  */
+static YYSTYPE yyval_default;]b4_locations_if([[
+static YYLTYPE yyloc_default][]b4_yyloc_default;])[
 
 /* Copy the second part of user declarations.  */
 ]b4_user_post_prologue
@@ -249,24 +241,24 @@ b4_percent_code_get[]dnl
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
 #  endif
 # endif
 # ifndef YY_
-#  define YY_(msgid) msgid
+#  define YY_(Msgid) Msgid
 # endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
+# define YYUSE(E) ((void) (E))
 #else
-# define YYUSE(e) /* empty */
+# define YYUSE(E) /* empty */
 #endif
 
 /* Identity function, used to suppress warnings about constant conditions.  */
 #ifndef lint
-# define YYID(n) (n)
+# define YYID(N) (N)
 #else
 ]b4_c_function_def([YYID], [static int], [[int i], [i]])[
 {
@@ -297,8 +289,9 @@ b4_percent_code_get[]dnl
 #ifndef YYSETJMP
 # include <setjmp.h>
 # define YYJMP_BUF jmp_buf
-# define YYSETJMP(env) setjmp (env)
-# define YYLONGJMP(env, val) longjmp (env, val)
+# define YYSETJMP(Env) setjmp (Env)
+// Pacify clang.
+# define YYLONGJMP(Env, Val) (longjmp (Env, Val), YYASSERT (0))
 #endif
 
 /*-----------------.
@@ -321,7 +314,7 @@ b4_percent_code_get[]dnl
 #endif])[
 
 #ifndef YYASSERT
-# define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))
+# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0)))
 #endif
 
 /* YYFINAL -- State number of the termination state.  */
@@ -357,6 +350,19 @@ static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
 };
 
 #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[] =
 {
@@ -373,10 +379,17 @@ static const char *const yytname[] =
 };
 #endif
 
-#define YYPACT_NINF ]b4_pact_ninf[
-#define YYTABLE_NINF ]b4_table_ninf[
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const ]b4_int_type_for([b4_r1])[ yyr1[] =
+{
+  ]b4_r1[
+};
 
-]b4_parser_tables_define[
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const ]b4_int_type_for([b4_r2])[ yyr2[] =
+{
+  ]b4_r2[
+};
 
 /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none).  */
 static const ]b4_int_type_for([b4_dprec])[ yydprec[] =
@@ -390,11 +403,41 @@ static const ]b4_int_type_for([b4_merger])[ yymerger[] =
   ]b4_merger[
 };
 
-/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as
-   in the case of predicates.  */
-static const yybool yyimmediate[] =
+/* 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_immediate[
+  ]b4_defact[
+};
+
+/* YYPDEFGOTO[NTERM-NUM].  */
+static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
+{
+  ]b4_defgoto[
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF ]b4_pact_ninf[
+static const ]b4_int_type_for([b4_pact])[ yypact[] =
+{
+  ]b4_pact[
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
+{
+  ]b4_pgoto[
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF ]b4_table_ninf[
+static const ]b4_int_type_for([b4_table])[ yytable[] =
+{
+  ]b4_table[
 };
 
 /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
@@ -415,33 +458,27 @@ dnl We probably ought to introduce a type for confl.
 {
   ]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
 
 ]b4_locations_if([[
-#ifndef YYLLOC_DEFAULT
 ]b4_yylloc_default_define[
 # define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
-
-# define YY_LOCATION_PRINT(File, Loc)                   \
-    fprintf (File, "%d.%d-%d.%d",                       \
-             (Loc).first_line, (Loc).first_column,      \
-             (Loc).last_line,  (Loc).last_column)
-#endif
-]],[
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0)
-#endif
-])[
-
-#ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-#endif
+]])[
+]b4_yy_location_print_define[
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
@@ -472,12 +509,9 @@ static const int YYEMPTY = -2;
 
 typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 
-#define YYCHK(YYE)                              \
-  do {                                          \
-    YYRESULTTAG yychk_flag = YYE;               \
-    if (yychk_flag != yyok)                     \
-      return yychk_flag;                        \
-  } while (YYID (0))
+#define YYCHK(YYE)                                                           \
+   do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; }       \
+   while (YYID (0))
 
 #if ]b4_api_PREFIX[DEBUG
 
@@ -486,22 +520,22 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 # endif
 
 # define YYDPRINTF(Args)                        \
-  do {                                          \
-    if (yydebug)                                \
-      YYFPRINTF Args;                           \
-  } while (YYID (0))
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (YYID (0))
 
 ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[
 
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                  \
-  do {                                                                  \
-    if (yydebug)                                                        \
-      {                                                                 \
-        YYFPRINTF (stderr, "%s ", Title);                               \
-        yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[);        \
-        YYFPRINTF (stderr, "\n");                                       \
-      }                                                                 \
-  } while (YYID (0))
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
+do {                                                            \
+  if (yydebug)                                                  \
+    {                                                           \
+      YYFPRINTF (stderr, "%s ", Title);                         \
+      yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[);        \
+      YYFPRINTF (stderr, "\n");                                 \
+    }                                                           \
+} while (YYID (0))
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
@@ -538,7 +572,13 @@ 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
@@ -635,7 +675,7 @@ typedef int yyStateNum;
 typedef int yyRuleNum;
 
 /** Grammar symbol */
-typedef int yySymbol;
+typedef short int yySymbol;
 
 /** Item references, as in LALR(1) machine */
 typedef short int yyItemNum;
@@ -656,7 +696,7 @@ struct yyGLRState {
   yyStateNum yylrState;
   /** Preceding state in this stack */
   yyGLRState* yypred;
-  /** Source position of the last token produced by my symbol */
+  /** Source position of the first token produced by my symbol */
   size_t yyposn;
   union {
     /** First in a chain of alternative reductions producing the
@@ -768,16 +808,9 @@ yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
   yyGLRState *s = yyvsp[yylow0].yystate.yypred;
   for (i = yylow0-1; i >= yylow1; i -= 1)
     {
-#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([[
+      YYASSERT (s->yyresolved);
+      yyvsp[i].yystate.yyresolved = yytrue;
+      yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;]b4_locations_if([[
       yyvsp[i].yystate.yyloc = s->yyloc;]])[
       s = yyvsp[i].yystate.yypred = s->yypred;
     }
@@ -812,7 +845,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
   yybool yynormal __attribute__ ((__unused__)) =
     (yystackp->yysplitPoint == YY_NULL);
   int yylow;
-]b4_parse_param_use([yyvalp], [yylocp])dnl
+]b4_parse_param_use[]dnl
 [# undef yyerrok
 # define yyerrok (yystackp->yyerrState = 0)
 # undef YYACCEPT
@@ -915,17 +948,17 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
     }
 }
 
-/** Left-hand-side symbol for rule #YYRULE.  */
+/** Left-hand-side symbol for rule #RULE.  */
 static inline yySymbol
 yylhsNonterm (yyRuleNum yyrule)
 {
   return yyr1[yyrule];
 }
 
-#define yypact_value_is_default(yystate) \
-  ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
+#define yypact_value_is_default(Yystate) \
+  ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[
 
-/** True iff LR state YYSTATE has only a default reduction (regardless
+/** True iff LR state STATE has only a default reduction (regardless
  *  of token).  */
 static inline yybool
 yyisDefaultedState (yyStateNum yystate)
@@ -933,23 +966,23 @@ yyisDefaultedState (yyStateNum yystate)
   return yypact_value_is_default (yypact[yystate]);
 }
 
-/** The default reduction for YYSTATE, assuming it has one.  */
+/** The default reduction for STATE, assuming it has one.  */
 static inline yyRuleNum
 yydefaultAction (yyStateNum yystate)
 {
   return yydefact[yystate];
 }
 
-#define yytable_value_is_error(yytable_value) \
-  ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
+#define yytable_value_is_error(Yytable_value) \
+  ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[
 
 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
  *  Result R means
  *    R < 0:  Reduce on rule -R.
  *    R = 0:  Error.
  *    R > 0:  Shift to state R.
- *  Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list
- *  of conflicting reductions.
+ *  Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of
+ *  conflicting reductions.
  */
 static inline void
 yygetLRActions (yyStateNum yystate, int yytoken,
@@ -977,7 +1010,8 @@ yygetLRActions (yyStateNum yystate, int yytoken,
 static inline yyStateNum
 yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
 {
-  int yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
+  int yyr;
+  yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
   if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)
     return yytable[yyr];
   else
@@ -998,10 +1032,9 @@ yyisErrorAction (int yyaction)
 
                                 /* GLRStates */
 
-/** 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.  */
+/** Return a fresh GLRStackItem.  Callers should call
+ * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
+ * headroom.  */
 
 static inline yyGLRStackItem*
 yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
@@ -1014,16 +1047,16 @@ yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
 }
 
 /** Add a new semantic action that will execute the action for rule
- *  YYRULE on the semantic values in YYRHS to the list of
- *  alternative actions for YYSTATE.  Assumes that YYRHS comes from
- *  stack #YYK of *YYSTACKP. */
+ *  RULENUM on the semantic values in RHS to the list of
+ *  alternative actions for STATE.  Assumes that RHS comes from
+ *  stack #K of *STACKP. */
 static void
 yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
-                     yyGLRState* yyrhs, yyRuleNum yyrule)
+                     yyGLRState* rhs, yyRuleNum yyrule)
 {
   yySemanticOption* yynewOption =
     &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
-  yynewOption->yystate = yyrhs;
+  yynewOption->yystate = rhs;
   yynewOption->yyrule = yyrule;
   if (yystackp->yytops.yylookaheadNeeds[yyk])
     {
@@ -1041,7 +1074,7 @@ yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
 
                                 /* GLRStacks */
 
-/** Initialize YYSET to a singleton set containing an empty stack.  */
+/** Initialize SET to a singleton set containing an empty stack.  */
 static yybool
 yyinitStateSet (yyGLRStateSet* yyset)
 {
@@ -1067,8 +1100,8 @@ static void yyfreeStateSet (yyGLRStateSet* yyset)
   YYFREE (yyset->yylookaheadNeeds);
 }
 
-/** Initialize *YYSTACKP to a single empty stack, with total maximum
- *  capacity for all stacks of YYSIZE.  */
+/** Initialize STACK to a single empty stack, with total maximum
+ *  capacity for all stacks of SIZE.  */
 static yybool
 yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
 {
@@ -1090,7 +1123,7 @@ yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
 # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
   &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
 
-/** If *YYSTACKP is expandable, extend it.  WARNING: Pointers into the
+/** If STACK 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
@@ -1160,9 +1193,9 @@ yyfreeGLRStack (yyGLRStack* yystackp)
   yyfreeStateSet (&yystackp->yytops);
 }
 
-/** 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.  */
+/** 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.  */
 static inline void
 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
 {
@@ -1170,7 +1203,7 @@ yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
     yystackp->yysplitPoint = yys;
 }
 
-/** Invalidate stack #YYK in *YYSTACKP.  */
+/** Invalidate stack #K in STACK.  */
 static inline void
 yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
 {
@@ -1179,8 +1212,8 @@ yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
   yystackp->yytops.yystates[yyk] = YY_NULL;
 }
 
-/** 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
+/** Undelete the last stack 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)
@@ -1229,9 +1262,8 @@ yyremoveDeletes (yyGLRStack* yystackp)
     }
 }
 
-/** 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.  */
+/** Shift to a new state on stack #K of STACK, corresponding to LR state
+ * LRSTATE, at input position POSN, with (resolved) semantic value SVAL.  */
 static inline void
 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
             size_t yyposn,
@@ -1250,12 +1282,12 @@ yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
   YY_RESERVE_GLRSTACK (yystackp);
 }
 
-/** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR
+/** Shift stack #K of YYSTACK, 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* yyrhs, yyRuleNum yyrule)
+                 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule)
 {
   yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
 
@@ -1267,55 +1299,14 @@ yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */
-  yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule);
+  yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
 }
 
-#if !]b4_api_PREFIX[DEBUG
-# define YY_REDUCE_PRINT(Args)
-#else
-# define YY_REDUCE_PRINT(Args)          \
-do {                                    \
-  if (yydebug)                          \
-    yy_reduce_print Args;               \
-} while (YYID (0))
-
-/*----------------------------------------------------------------------.
-| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
-`----------------------------------------------------------------------*/
-
-/*ARGSUSED*/ static inline void
-yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk,
-                 yyRuleNum yyrule]b4_user_formals[)
-{
-  int yynrhs = yyrhsLength (yyrule);]b4_locations_if([
-  int yylow = 1;])[
-  int yyi;
-  YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
-             (unsigned long int) yyk, yyrule - 1,
-             (unsigned long int) yyrline[yyrule]);
-  if (! yynormal)
-    yyfillin (yyvsp, 1, -yynrhs);
-  /* The symbols being reduced.  */
-  for (yyi = 0; yyi < yynrhs; yyi++)
-    {
-      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr,
-                       yystos[yyvsp[yyi - yynrhs + 1].yystate.yylrState],
-                       &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval
-                       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
-                       b4_user_args[);
-      if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved)
-        YYFPRINTF (stderr, " (unresolved)");
-      YYFPRINTF (stderr, "\n");
-    }
-}
-#endif
-
-/** Pop the symbols consumed by reduction #YYRULE from the top of stack
- *  #YYK of *YYSTACKP, and perform the appropriate semantic action on their
+/** Pop the symbols consumed by reduction #RULE from the top of stack
+ *  #K of STACK, and perform the appropriate semantic action on their
  *  semantic values.  Assumes that all ambiguities in semantic values
- *  have been previously resolved.  Set *YYVALP to the resulting value,
- *  and *YYLOCP to the computed location (if any).  Return value is as
+ *  have been previously resolved.  Set *VALP to the resulting value,
+ *  and *LOCP to the computed location (if any).  Return value is as
  *  for userAction.  */
 static inline YYRESULTTAG
 yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
@@ -1326,17 +1317,20 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
   if (yystackp->yysplitPoint == YY_NULL)
     {
       /* Standard special case: single stack.  */
-      yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
+      yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
       YYASSERT (yyk == 0);
       yystackp->yynextFree -= yynrhs;
       yystackp->yyspaceLeft += yynrhs;
       yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
-      YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[));
-      return yyuserAction (yyrule, yynrhs, yyrhs, yystackp,
+      return yyuserAction (yyrule, yynrhs, rhs, 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];
@@ -1352,21 +1346,62 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
         }
       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[);
     }
 }
 
-/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE,
+#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,
  *  and push back on the resulting nonterminal symbol.  Perform the
- *  semantic action associated with YYRULE and store its value with the
- *  newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently
+ *  semantic action associated with RULE and store its value with the
+ *  newly pushed state, if FORCEEVAL or if STACK 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 #YYK from
- *  *YYSTACKP.  In this case, the semantic value is
+ *  it is identified with that existing state, eliminating stack #K from
+ *  the STACK.  In this case, the (necessarily deferred) semantic value is
  *  added to the options for the existing state's semantic value.
  */
 static inline YYRESULTTAG
@@ -1377,18 +1412,11 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
 
   if (yyforceEval || yystackp->yysplitPoint == YY_NULL)
     {
-      YYRESULTTAG yyflag;
       YYSTYPE yysval;]b4_locations_if([
       YYLTYPE 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_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[));
+      YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[));
       YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
       yyglrShift (yystackp, yyk,
                   yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
@@ -1411,8 +1439,7 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
       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)
@@ -1483,7 +1510,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
   return yystackp->yytops.yysize-1;
 }
 
-/** True iff YYY0 and YYY1 represent identical options at the top level.
+/** True iff Y0 and Y1 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
@@ -1505,8 +1532,8 @@ yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
     return yyfalse;
 }
 
-/** Assuming identicalOptions (YYY0,YYY1), destructively merge the
- *  alternative semantic values for the RHS-symbols of YYY1 and YYY0.  */
+/** Assuming identicalOptions (Y0,Y1), destructively merge the
+ *  alternative semantic values for the RHS-symbols of Y1 and Y0.  */
 static void
 yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
 {
@@ -1585,11 +1612,11 @@ static YYRESULTTAG yyresolveValue (yyGLRState* yys,
                                    yyGLRStack* yystackp]b4_user_formals[);
 
 
-/** 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.  */
+/** 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.  */
 static YYRESULTTAG
 yyresolveStates (yyGLRState* yys, int yyn,
                  yyGLRStack* yystackp]b4_user_formals[)
@@ -1604,10 +1631,9 @@ yyresolveStates (yyGLRState* yys, int yyn,
   return yyok;
 }
 
-/** 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
+/** 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
  *  semantic values if invoked).  */
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
@@ -1681,11 +1707,11 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
         {
           if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
             YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
-                       yytokenName (yystos[yystates[yyi]->yylrState]));
+                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
           else
             YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
-                       yytokenName (yystos[yystates[yyi]->yylrState]),
-                       (unsigned long int) (yystates[yyi-1]->yyposn + 1),
+                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
+                       (unsigned long int) (yystates[yyi - 1]->yyposn + 1),
                        (unsigned long int) yystates[yyi]->yyposn);
         }
       else
@@ -1714,9 +1740,9 @@ yyreportAmbiguity (yySemanticOption* yyx0,
   return yyabort;
 }]b4_locations_if([[
 
-/** 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.  */
+/** 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.  */
 static void
 yyresolveLocations (yyGLRState* yys1, int yyn1,
                     yyGLRStack *yystackp]b4_user_formals[)
@@ -1770,12 +1796,11 @@ yyresolveLocations (yyGLRState* yys1, int yyn1,
     }
 }]])[
 
-/** 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
+/** 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
  *  yydestroyGLRState can be invoked if necessary.  */
 static YYRESULTTAG
 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
@@ -1913,6 +1938,10 @@ static YYRESULTTAG
 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;
@@ -1923,8 +1952,7 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
 
       if (yyisDefaultedState (yystate))
         {
-          YYRESULTTAG yyflag;
-          yyRuleNum yyrule = yydefaultAction (yystate);
+          yyrule = yydefaultAction (yystate);
           if (yyrule == 0)
             {
               YYDPRINTF ((stderr, "Stack %lu dies.\n",
@@ -1932,25 +1960,11 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
               yymarkStackDeleted (yystackp, yyk);
               return yyok;
             }
-          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;
+          YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
         }
       else
         {
           yySymbol yytoken;
-          int yyaction;
-          const short int* yyconflicts;
-
           yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
           if (yychar == YYEMPTY)
             {
@@ -1973,25 +1987,14 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
 
           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));
-              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;
+              YYCHK (yyglrReduce (yystackp, yynewStack,
+                                  *yyconflicts, yyfalse]b4_user_args[));
+              YYCHK (yyprocessOneStack (yystackp, yynewStack,
+                                        yyposn]b4_pure_args[));
               yyconflicts += 1;
             }
 
@@ -2005,21 +2008,8 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
               break;
             }
           else
-            {
-              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;
-            }
+            YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
+                                yyfalse]b4_user_args[));
         }
     }
   return yyok;
@@ -2272,6 +2262,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
     }                                                                        \
   } while (YYID (0))
 
+
 /*----------.
 | yyparse.  |
 `----------*/
@@ -2286,20 +2277,13 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yychar = YYEMPTY;
-  yylval = yyval_default;
-]b4_locations_if([
-#if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
-  yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
-  yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
-#endif
-])
-m4_ifdef([b4_initial_action], [
-m4_pushdef([b4_at_dollar],     [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
-  /* User initialization code.  */
-  b4_user_initial_action
-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
+  yylval = yyval_default;]b4_locations_if([
+  yylloc = yyloc_default;])[
+]m4_ifdef([b4_initial_action], [
+b4_dollar_pushdef([yylval], [], [yylloc])dnl
+/* User initialization code.  */
+b4_user_initial_action
+b4_dollar_popdef])[]dnl
 [
   if (! yyinitGLRStack (yystackp, YYINITDEPTH))
     goto yyexhaustedlab;
@@ -2606,5 +2590,5 @@ b4_copyright([Skeleton interface for Bison GLR parsers in C],
 ]b4_cpp_guard_open([b4_spec_defines_file])[
 ]b4_shared_declarations[
 ]b4_cpp_guard_close([b4_spec_defines_file])[
-]])])
+]])])dnl
 m4_divert_pop(0)

data/glr.cc

@@ -1,3 +1,5 @@
+                                                                    -*- C -*-
+
 # C++ GLR skeleton for Bison
 
 # Copyright (C) 2002-2012 Free Software Foundation, Inc.
@@ -27,7 +29,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's easy: make yyparser an
+#   throughout the C parser; that easy: just let yyparser become an
 #   additional parse-param.  But because the C++ skeleton needs to
 #   know the "real" original parse-param, we save them
 #   (b4_parse_param_orig).  Note that b4_parse_param is overquoted
@@ -37,14 +39,14 @@
 # The locations
 #
 #   We use location.cc just like lalr1.cc, but because glr.c stores
-#   the locations in a union, the position and location classes
+#   the locations in a (C++) 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_percent_define(locations)], [])
+m4_define([b4_locations_flag], [1])
 m4_define([b4_pure_flag],      [1])
 
 # The header is mandatory.
@@ -85,12 +87,17 @@ m4_define([b4_yy_symbol_print_generate],
 ]b4_parse_param_use[]dnl
 [  yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[);
 }
-]])
+]])[
 
+# Hijack the initial action to initialize the locations.
+]b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
+[m4_define([b4_initial_action],
+[yylloc.initialize ();]m4_ifdef([b4_initial_action], [
+m4_defn([b4_initial_action])]))])])[
 
 # Hijack the post prologue to insert early definition of YYLLOC_DEFAULT
 # and declaration of yyerror.
-m4_append([b4_post_prologue],
+]m4_append([b4_post_prologue],
 [b4_syncline([@oline@], [@ofile@])[
 ]b4_yylloc_default_define[
 #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
@@ -129,7 +136,8 @@ m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl
   ]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[
   {
   }
@@ -161,7 +169,7 @@ m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl
     YYUSE (yyo);
     switch (yytype)
       {
-]b4_symbol_foreach([b4_symbol_printer])dnl
+  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 [        default:
           break;
       }
@@ -202,13 +210,13 @@ m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl
   void
   ]b4_parser_class_name[::set_debug_level (debug_level_type l)
   {
+    // Actually, it is yydebug which is really used.
     yydebug = l;
   }
 
 #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.
@@ -225,7 +233,7 @@ 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-2012])[
+             [2002-2006, 2009-2012])[
 
 /* C++ GLR parser skeleton written by Akim Demaille.  */
 
@@ -233,11 +241,10 @@ b4_copyright([Skeleton interface for Bison GLR parsers in C++],
 
 ]b4_percent_code_get([[requires]])[
 
-#include <stdexcept>
-#include <string>
-#include <iostream>
+# include <string>
+# include <iostream>
 ]b4_percent_define_ifdef([[location_type]], [],
-                         [[#include "location.hh"]])[
+                         [[# include "location.hh"]])[
 
 ]b4_YYDEBUG_define[
 
@@ -246,7 +253,29 @@ b4_copyright([Skeleton interface for Bison GLR parsers in C++],
   class ]b4_parser_class_name[
   {
   public:
-]b4_public_types_declare[
+    /// 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;
 
     /// Build a parser object.
     ]b4_parser_class_name[ (]b4_parse_param_decl[);
@@ -268,11 +297,14 @@ b4_copyright([Skeleton interface for Bison GLR parsers in C++],
     /// Set the current debugging level.
     void set_debug_level (debug_level_type l);
 
+  private:
+
   public:
     /// Report a syntax error.
     /// \param loc    where the syntax error is found.
     /// \param msg    a description of the syntax error.
     virtual void error (const location_type& loc, const std::string& msg);
+  private:
 
 # if ]b4_api_PREFIX[DEBUG
   public:
@@ -293,14 +325,14 @@ b4_copyright([Skeleton interface for Bison GLR parsers in C++],
   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_token_defines(b4_tokens)])
 [
 #ifndef ]b4_api_PREFIX[STYPE
 # define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type

data/java.m4

@@ -17,6 +17,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+m4_include(b4_pkgdatadir/[c-like.m4])
 
 # b4_comment(TEXT)
 # ----------------
@@ -29,7 +30,7 @@ m4_define([b4_comment], [/* m4_bpatsubst([$1], [
 # --------------------------
 # Join two lists with a comma if necessary.
 m4_define([b4_list2],
-          [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2])
+	  [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2])
 
 
 # b4_percent_define_get3(DEF, PRE, POST, NOT)
@@ -37,8 +38,8 @@ m4_define([b4_list2],
 # Expand to the value of DEF surrounded by PRE and POST if it's %define'ed,
 # otherwise NOT.
 m4_define([b4_percent_define_get3],
-          [m4_ifval(m4_quote(b4_percent_define_get([$1])),
-                [$2[]b4_percent_define_get([$1])[]$3], [$4])])
+	  [m4_ifval(m4_quote(b4_percent_define_get([$1])),
+		[$2[]b4_percent_define_get([$1])[]$3], [$4])])
 
 
 
@@ -103,7 +104,7 @@ m4_define([b4_identification],
 m4_define([b4_int_type],
 [m4_if(b4_ints_in($@,   [-128],   [127]), [1], [byte],
        b4_ints_in($@, [-32768], [32767]), [1], [short],
-                                               [int])])
+					       [int])])
 
 # b4_int_type_for(NAME)
 # ---------------------
@@ -117,45 +118,27 @@ m4_define([b4_int_type_for],
 m4_define([b4_null], [null])
 
 
-# b4_typed_parser_table_define(TYPE, NAME, DATA, COMMENT)
-# -------------------------------------------------------
-m4_define([b4_typed_parser_table_define],
-[m4_ifval([$4], [b4_comment([$4])
-  ])dnl
-[private static final ]$1[ yy$2_[] = yy$2_init();
-  private static final ]$1[[] yy$2_init()
-  {
-    return new ]$1[[]
-    {
-  ]$3[
-    };
-  }]])
-
-
-# b4_integral_parser_table_define(NAME, DATA, COMMENT)
-#-----------------------------------------------------
-m4_define([b4_integral_parser_table_define],
-[b4_typed_parser_table_define([b4_int_type_for([$2])], [$1], [$2], [$3])])
-
-
 ## ------------------------- ##
 ## Assigning token numbers.  ##
 ## ------------------------- ##
 
-# b4_token_enum(TOKEN-NUM)
-# ------------------------
+# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
+# ---------------------------------------
 # Output the definition of this token as an enum.
 m4_define([b4_token_enum],
-[b4_token_format([    /** Token number, to be returned by the scanner.  */
-    static final int %s = %s;
-], [$1])])
+[  /** Token number, to be returned by the scanner.  */
+  public static final int $1 = $2;
+])
 
-# b4_token_enums
-# --------------
+
+# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
+# -----------------------------------------------------
 # Output the definition of the tokens (if there are) as enums.
 m4_define([b4_token_enums],
-[b4_any_token_visible_if([/* Tokens.  */
-b4_symbol_foreach([b4_token_enum])])])
+[m4_if([$#$1], [1], [],
+[/* Tokens.  */
+m4_map([b4_token_enum], [$@])])
+])
 
 # b4-case(ID, CODE)
 # -----------------
@@ -166,40 +149,30 @@ m4_define([b4_case], [  case $1:
   break;
     ])
 
-# b4_predicate_case(LABEL, CONDITIONS)
-# ------------------------------------
-m4_define([b4_predicate_case], [  case $1:
-     if (! ($2)) YYERROR;
-    break;
-    ])
-
 
 ## ---------------- ##
 ## Default values.  ##
 ## ---------------- ##
 
 m4_define([b4_yystype], [b4_percent_define_get([[stype]])])
-b4_percent_define_default([[stype]], [[Object]])
+b4_percent_define_default([[stype]], [[Object]])])
 
 # %name-prefix
 m4_define_default([b4_prefix], [[YY]])
 
-b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser])
+b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser])])
 m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])])
 
-b4_percent_define_default([[lex_throws]], [[java.io.IOException]])
+b4_percent_define_default([[lex_throws]], [[java.io.IOException]])])
 m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])])
 
-b4_percent_define_default([[throws]], [])
+b4_percent_define_default([[throws]], [])])
 m4_define([b4_throws], [b4_percent_define_get([[throws]])])
 
-b4_percent_define_default([[init_throws]], [])
-m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])])
-
-b4_percent_define_default([[location_type]], [Location])
+b4_percent_define_default([[location_type]], [Location])])
 m4_define([b4_location_type], [b4_percent_define_get([[location_type]])])
 
-b4_percent_define_default([[position_type]], [Position])
+b4_percent_define_default([[position_type]], [Position])])
 m4_define([b4_position_type], [b4_percent_define_get([[position_type]])])
 
 
@@ -246,21 +219,21 @@ m4_define([b4_rhs_location],
 # it to be single quoted.  Same for b4_parse_param.
 
 # TODO: should be in bison.m4
-m4_define_default([b4_lex_param], [[]])
-m4_define([b4_lex_param], b4_lex_param)
-m4_define([b4_parse_param], b4_parse_param)
+m4_define_default([b4_lex_param], [[]]))
+m4_define([b4_lex_param], b4_lex_param))
+m4_define([b4_parse_param], b4_parse_param))
 
 # b4_lex_param_decl
-# -----------------
+# -------------------
 # Extra formal arguments of the constructor.
 m4_define([b4_lex_param_decl],
 [m4_ifset([b4_lex_param],
           [b4_remove_comma([$1],
-                           b4_param_decls(b4_lex_param))],
-          [$1])])
+			   b4_param_decls(b4_lex_param))],
+	  [$1])])
 
 m4_define([b4_param_decls],
-          [m4_map_args([b4_param_decl], $@)])
+	  [m4_map([b4_param_decl], [$@])])
 m4_define([b4_param_decl], [, $1])
 
 m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)])
@@ -273,21 +246,21 @@ m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)])
 m4_define([b4_parse_param_decl],
 [m4_ifset([b4_parse_param],
           [b4_remove_comma([$1],
-                           b4_param_decls(b4_parse_param))],
-          [$1])])
+			   b4_param_decls(b4_parse_param))],
+	  [$1])])
 
 
 
 # b4_lex_param_call
-# -----------------
+# -------------------
 # Delegating the lexer parameters to the lexer constructor.
 m4_define([b4_lex_param_call],
           [m4_ifset([b4_lex_param],
-                    [b4_remove_comma([$1],
-                                     b4_param_calls(b4_lex_param))],
-                    [$1])])
+	            [b4_remove_comma([$1],
+				     b4_param_calls(b4_lex_param))],
+	            [$1])])
 m4_define([b4_param_calls],
-          [m4_map_args([b4_param_call], $@)])
+	  [m4_map([b4_param_call], [$@])])
 m4_define([b4_param_call], [, $2])
 
 
@@ -297,13 +270,13 @@ m4_define([b4_param_call], [, $2])
 # Extra initialisations of the constructor.
 m4_define([b4_parse_param_cons],
           [m4_ifset([b4_parse_param],
-                    [b4_constructor_calls(b4_parse_param)])])
+		    [b4_constructor_calls(b4_parse_param)])])
 
 m4_define([b4_constructor_calls],
-          [m4_map_args([b4_constructor_call], $@)])
+	  [m4_map([b4_constructor_call], [$@])])
 m4_define([b4_constructor_call],
-          [this.$2 = $2;
-          ])
+	  [this.$2 = $2;
+	  ])
 
 
 
@@ -312,15 +285,15 @@ m4_define([b4_constructor_call],
 # Extra instance variables.
 m4_define([b4_parse_param_vars],
           [m4_ifset([b4_parse_param],
-                    [
+		    [
     /* User arguments.  */
 b4_var_decls(b4_parse_param)])])
 
 m4_define([b4_var_decls],
-          [m4_map_sep([b4_var_decl], [
+	  [m4_map_sep([b4_var_decl], [
 ], [$@])])
 m4_define([b4_var_decl],
-          [    protected final $1;])
+	  [    protected final $1;])
 
 
 
@@ -328,4 +301,4 @@ m4_define([b4_var_decl],
 # -----------------------
 # Expand to either an empty string or "throws THROWS".
 m4_define([b4_maybe_throws],
-          [m4_ifval($1, [throws $1])])
+	  [m4_ifval($1, [throws $1])])

data/lalr1.java

@@ -17,18 +17,10 @@
 
 m4_include(b4_pkgdatadir/[java.m4])
 
-b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java],
-              [b4_skeleton])])
-
-# We don't depend on %debug in Java, but pacify warnings about non-used flags.
-b4_parse_trace_if([0], [0])
-
-m4_define([b4_symbol_no_destructor_assert],
-[b4_symbol_if([$1], [has_destructor],
-              [b4_fatal([%s: %s: %%destructor does not make sense in Java],
-                        [b4_skeleton],
-                        [b4_symbol_action_location([$1], [destructor])])])])
-b4_symbol_foreach([b4_symbol_no_destructor_assert])
+b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])])
+m4_ifval(m4_defn([b4_symbol_destructors]),
+        [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])],
+        [])
 
 m4_divert_push(0)dnl
 @output(b4_parser_file_name@)@
@@ -37,16 +29,14 @@ b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
 
 b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
 ])[/* First part of user declarations.  */
-]b4_user_pre_prologue
-b4_user_post_prologue
+]b4_pre_prologue
 b4_percent_code_get([[imports]])
 [/**
  * A Bison parser, automatically generated from <tt>]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[</tt>.
  *
  * @@author LALR (1) parser skeleton written by Paolo Bonzini.
  */
-]b4_percent_define_get3([annotations], [], [ ])dnl
-b4_public_if([public ])dnl
+]b4_public_if([public ])dnl
 b4_abstract_if([abstract ])dnl
 b4_final_if([final ])dnl
 b4_strictfp_if([strictfp ])dnl
@@ -55,22 +45,9 @@ b4_percent_define_get3([extends], [ extends ])dnl
 b4_percent_define_get3([implements], [ implements ])[
 {
   ]b4_identification[
-]b4_error_verbose_if([[
+
   /** True if verbose error messages are enabled.  */
-  private boolean yyErrorVerbose = true;
-
-  /**
-   * Return whether verbose error messages are enabled.
-   */
-  public final boolean getErrorVerbose() { return yyErrorVerbose; }
-
-  /**
-   * Set the verbosity of error messages.
-   * @@param verbose True to request verbose error messages.
-   */
-  public final void setErrorVerbose(boolean verbose)
-  { yyErrorVerbose = verbose; }
-]])
+  public boolean errorVerbose = ]b4_flag_value([error_verbose]);
 
 b4_locations_if([[
   /**
@@ -116,6 +93,11 @@ b4_locations_if([[
 
 ]])
 
+[  /** Token returned by the scanner to signal the end of its input.  */
+  public static final int EOF = 0;]
+
+b4_token_enums(b4_tokens)
+
   b4_locations_if([[
   private ]b4_location_type[ yylloc (YYStack rhs, int n)
   {
@@ -130,11 +112,6 @@ b4_locations_if([[
    * parser <tt>]b4_parser_class_name[</tt>.
    */
   public interface Lexer {
-    /** Token returned by the scanner to signal the end of its input.  */
-    public static final int EOF = 0;
-
-]b4_token_enums[
-
     ]b4_locations_if([[/**
      * Method to retrieve the beginning position of the last scanned token.
      * @@return the position at which the last scanned token starts.  */
@@ -163,8 +140,8 @@ b4_locations_if([[
      *
      * ]b4_locations_if([[@@param loc The location of the element to which the
      *                error message is related]])[
-     * @@param msg The string for the error message.  */
-     void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String msg);]
+     * @@param s The string for the error message.  */
+     void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s);]
   }
 
   b4_lexer_if([[private class YYLexer implements Lexer {
@@ -180,9 +157,7 @@ b4_lexer_if([[
   /**
    * Instantiates the Bison-generated parser.
    */
-  public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) ]b4_maybe_throws([b4_init_throws])[
-  {
-    ]b4_percent_code_get([[init]])[
+  public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) {
     this.yylexer = new YYLexer(]b4_lex_param_call[);
     ]b4_parse_param_cons[
   }
@@ -192,9 +167,7 @@ b4_lexer_if([[
    * Instantiates the Bison-generated parser.
    * @@param yylexer The scanner that will supply tokens to the parser.
    */
-  b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) ]b4_maybe_throws([b4_init_throws])[
-  {
-    ]b4_percent_code_get([[init]])[
+  b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) {
     this.yylexer = yylexer;
     ]b4_parse_param_cons[
   }
@@ -228,35 +201,20 @@ b4_lexer_if([[
    */
   public final void setDebugLevel(int level) { yydebug = level; }
 
-  /**
-   * Print an error message via the lexer.
-   *]b4_locations_if([[ Use a <code>null</code> location.]])[
-   * @@param msg The error message.
-   */
-  public final void yyerror (String msg)
-  {
-    yylexer.yyerror (]b4_locations_if([[(]b4_location_type[)null, ]])[msg);
+  private final int yylex () ]b4_maybe_throws([b4_lex_throws]) [{
+    return yylexer.yylex ();
   }
-]b4_locations_if([[
-  /**
-   * Print an error message via the lexer.
-   * @@param loc The location associated with the message.
-   * @@param msg The error message.
-   */
-  public final void yyerror (]b4_location_type[ loc, String msg)
-  {
-    yylexer.yyerror (loc, msg);
+  protected final void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s) {
+    yylexer.yyerror (]b4_locations_if([loc, ])[s);
   }
 
-  /**
-   * Print an error message via the lexer.
-   * @@param pos The position associated with the message.
-   * @@param msg The error message.
-   */
-  public final void yyerror (]b4_position_type[ pos, String msg)
-  {
-    yylexer.yyerror (new ]b4_location_type[ (pos), msg);
-  }]])
+  ]b4_locations_if([
+  protected final void yyerror (String s) {
+    yylexer.yyerror ((]b4_location_type[)null, s);
+  }
+  protected final void yyerror (]b4_position_type[ loc, String s) {
+    yylexer.yyerror (new ]b4_location_type[ (loc), s);
+  }])
 
   [protected final void yycdebug (String s) {
     if (yydebug > 0)
@@ -272,24 +230,24 @@ b4_lexer_if([[
     public int height = -1;
 
     public final void push (int state, ]b4_yystype[ value]dnl
-                            b4_locations_if([, ]b4_location_type[ loc])[) {
+			    b4_locations_if([, ]b4_location_type[ loc])[) {
       height++;
       if (size == height)
         {
-          int[] newStateStack = new int[size * 2];
-          System.arraycopy (stateStack, 0, newStateStack, 0, height);
-          stateStack = newStateStack;
-          ]b4_locations_if([[
-          ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2];
-          System.arraycopy (locStack, 0, newLocStack, 0, height);
-          locStack = newLocStack;]])
+	  int[] newStateStack = new int[size * 2];
+	  System.arraycopy (stateStack, 0, newStateStack, 0, height);
+	  stateStack = newStateStack;
+	  ]b4_locations_if([[
+	  ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2];
+	  System.arraycopy (locStack, 0, newLocStack, 0, height);
+	  locStack = newLocStack;]])
 
-          b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2];
-          System.arraycopy (valueStack, 0, newValueStack, 0, height);
-          valueStack = newValueStack;
+	  b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2];
+	  System.arraycopy (valueStack, 0, newValueStack, 0, height);
+	  valueStack = newValueStack;
 
-          size *= 2;
-        }
+	  size *= 2;
+	}
 
       stateStack[height] = state;
       ]b4_locations_if([[locStack[height] = loc;]])[
@@ -303,7 +261,7 @@ b4_lexer_if([[
     public final void pop (int num) {
       // Avoid memory leaks... garbage collection is a white lie!
       if (num > 0) {
-        java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null);
+	java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null);
         ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, null);]])[
       }
       height -= num;
@@ -328,8 +286,8 @@ b4_lexer_if([[
 
       for (int i = 0; i <= height; i++)
         {
-          out.print (' ');
-          out.print (stateStack[i]);
+	  out.print (' ');
+	  out.print (stateStack[i]);
         }
       out.println ();
     }
@@ -390,8 +348,8 @@ b4_lexer_if([[
 
     switch (yyn)
       {
-        ]b4_user_actions[
-        default: break;
+	]b4_user_actions[
+	default: break;
       }
 
     yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval]b4_locations_if([, yyloc])[);
@@ -403,7 +361,7 @@ b4_lexer_if([[
     yyn = yyr1_[yyn];
     int yystate = yypgoto_[yyn - yyntokens_] + yystack.stateAt (0);
     if (0 <= yystate && yystate <= yylast_
-        && yycheck_[yystate] == yystack.stateAt (0))
+	&& yycheck_[yystate] == yystack.stateAt (0))
       yystate = yytable_[yystate];
     else
       yystate = yydefgoto_[yyn - yyntokens_];
@@ -412,7 +370,6 @@ b4_lexer_if([[
     return YYNEWSTATE;
   }
 
-]b4_error_verbose_if([[
   /* Return YYSTR after stripping away unnecessary quotes and
      backslashes, so that it's suitable for yyerror.  The heuristic is
      that double-quoting is unnecessary unless the string contains an
@@ -431,7 +388,7 @@ b4_lexer_if([[
               break strip_quotes;
 
             case '\\':
-              if (yystr.charAt(++i) != '\\')
+	      if (yystr.charAt(++i) != '\\')
                 break strip_quotes;
               /* Fall through.  */
             default:
@@ -447,21 +404,20 @@ b4_lexer_if([[
 
     return yystr;
   }
-]])[
 
   /*--------------------------------.
   | Print this symbol on YYOUTPUT.  |
   `--------------------------------*/
 
   private void yy_symbol_print (String s, int yytype,
-                                 ]b4_yystype[ yyvaluep]dnl
-                                 b4_locations_if([, Object yylocationp])[)
+			         ]b4_yystype[ yyvaluep]dnl
+				 b4_locations_if([, Object yylocationp])[)
   {
     if (yydebug > 0)
     yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ")
-              + yytname_[yytype] + " ("]b4_locations_if([
-              + yylocationp + ": "])[
-              + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")");
+	      + yytname_[yytype] + " ("]b4_locations_if([
+	      + yylocationp + ": "])[
+	      + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")");
   }
 
   /**
@@ -502,12 +458,10 @@ b4_lexer_if([[
     yyerrstatus_ = 0;
 
 ]m4_ifdef([b4_initial_action], [
-m4_pushdef([b4_at_dollar],     [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
-    /* User initialization code.  */
-    b4_user_initial_action
-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
+b4_dollar_pushdef([yylval], [], [yylloc])dnl
+/* User initialization code.  */
+b4_user_initial_action
+b4_dollar_popdef])[]dnl
 
   [  /* Initialize the stack.  */
     yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
@@ -517,7 +471,7 @@ m4_popdef([b4_at_dollar])])dnl
       switch (label)
       {
         /* New state.  Unlike in the C/C++ skeletons, the state is already
-           pushed when we come here.  */
+	   pushed when we come here.  */
       case YYNEWSTATE:
         yycdebug ("Entering state " + yystate + "\n");
         if (yydebug > 0)
@@ -532,31 +486,31 @@ m4_popdef([b4_at_dollar])])dnl
         if (yy_pact_value_is_default_ (yyn))
           {
             label = YYDEFAULT;
-            break;
+	    break;
           }
 
         /* Read a lookahead token.  */
         if (yychar == yyempty_)
           {
-            yycdebug ("Reading a token: ");
-            yychar = yylexer.yylex ();]
+	    yycdebug ("Reading a token: ");
+	    yychar = yylex ();]
             b4_locations_if([[
-            yylloc = new ]b4_location_type[(yylexer.getStartPos (),
-                            yylexer.getEndPos ());]])
+	    yylloc = new ]b4_location_type[(yylexer.getStartPos (),
+				            yylexer.getEndPos ());]])
             yylval = yylexer.getLVal ();[
           }
 
         /* Convert token to internal form.  */
-        if (yychar <= Lexer.EOF)
+        if (yychar <= EOF)
           {
-            yychar = yytoken = Lexer.EOF;
-            yycdebug ("Now at end of input.\n");
+	    yychar = yytoken = EOF;
+	    yycdebug ("Now at end of input.\n");
           }
         else
           {
-            yytoken = yytranslate_ (yychar);
-            yy_symbol_print ("Next token is", yytoken,
-                             yylval]b4_locations_if([, yylloc])[);
+	    yytoken = yytranslate_ (yychar);
+	    yy_symbol_print ("Next token is", yytoken,
+			     yylval]b4_locations_if([, yylloc])[);
           }
 
         /* If the proper action on seeing token YYTOKEN is to reduce or to
@@ -568,20 +522,20 @@ m4_popdef([b4_at_dollar])])dnl
         /* <= 0 means reduce or error.  */
         else if ((yyn = yytable_[yyn]) <= 0)
           {
-            if (yy_table_value_is_error_ (yyn))
-              label = YYERRLAB;
-            else
-              {
-                yyn = -yyn;
-                label = YYREDUCE;
-              }
+	    if (yy_table_value_is_error_ (yyn))
+	      label = YYERRLAB;
+	    else
+	      {
+	        yyn = -yyn;
+	        label = YYREDUCE;
+	      }
           }
 
         else
           {
             /* Shift the lookahead token.  */
-            yy_symbol_print ("Shifting", yytoken,
-                             yylval]b4_locations_if([, yylloc])[);
+	    yy_symbol_print ("Shifting", yytoken,
+			     yylval]b4_locations_if([, yylloc])[);
 
             /* Discard the token being shifted.  */
             yychar = yyempty_;
@@ -614,7 +568,7 @@ m4_popdef([b4_at_dollar])])dnl
       case YYREDUCE:
         yylen = yyr2_[yyn];
         label = yyaction (yyn, yystack, yylen);
-        yystate = yystack.stateAt (0);
+	yystate = yystack.stateAt (0);
         break;
 
       /*------------------------------------.
@@ -633,17 +587,17 @@ m4_popdef([b4_at_dollar])])dnl
         ]b4_locations_if([yyerrloc = yylloc;])[
         if (yyerrstatus_ == 3)
           {
-        /* If just tried and failed to reuse lookahead token after an
-         error, discard it.  */
+	    /* If just tried and failed to reuse lookahead token after an
+	     error, discard it.  */
 
-        if (yychar <= Lexer.EOF)
-          {
-          /* Return failure if at end of input.  */
-          if (yychar == Lexer.EOF)
-            return false;
-          }
-        else
-              yychar = yyempty_;
+	    if (yychar <= EOF)
+	      {
+	      /* Return failure if at end of input.  */
+	      if (yychar == EOF)
+	        return false;
+	      }
+	    else
+	      yychar = yyempty_;
           }
 
         /* Else will try to reuse lookahead token after shifting the error
@@ -669,46 +623,46 @@ m4_popdef([b4_at_dollar])])dnl
       | yyerrlab1 -- common code for both syntax error and YYERROR.  |
       `-------------------------------------------------------------*/
       case YYERRLAB1:
-        yyerrstatus_ = 3;       /* Each real token shifted decrements this.  */
+        yyerrstatus_ = 3;	/* Each real token shifted decrements this.  */
 
         for (;;)
           {
-            yyn = yypact_[yystate];
-            if (!yy_pact_value_is_default_ (yyn))
-              {
-                yyn += yyterror_;
-                if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
-                  {
-                    yyn = yytable_[yyn];
-                    if (0 < yyn)
-                      break;
-                  }
-              }
+	    yyn = yypact_[yystate];
+	    if (!yy_pact_value_is_default_ (yyn))
+	      {
+	        yyn += yyterror_;
+	        if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
+	          {
+	            yyn = yytable_[yyn];
+	            if (0 < yyn)
+		      break;
+	          }
+	      }
 
-            /* Pop the current state because it cannot handle the error token.  */
-            if (yystack.height == 0)
-              return false;
+	    /* Pop the current state because it cannot handle the error token.  */
+	    if (yystack.height == 0)
+	      return false;
 
-            ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[
-            yystack.pop ();
-            yystate = yystack.stateAt (0);
-            if (yydebug > 0)
-              yystack.print (yyDebugStream);
+	    ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[
+	    yystack.pop ();
+	    yystate = yystack.stateAt (0);
+	    if (yydebug > 0)
+	      yystack.print (yyDebugStream);
           }
 
-        ]b4_locations_if([
-        /* Muck with the stack to setup for yylloc.  */
-        yystack.push (0, null, yylloc);
-        yystack.push (0, null, yyerrloc);
+	]b4_locations_if([
+	/* Muck with the stack to setup for yylloc.  */
+	yystack.push (0, null, yylloc);
+	yystack.push (0, null, yyerrloc);
         yyloc = yylloc (yystack, 2);
-        yystack.pop (2);])[
+	yystack.pop (2);])[
 
         /* Shift the error token.  */
         yy_symbol_print ("Shifting", yystos_[yyn],
-                         yylval]b4_locations_if([, yyloc])[);
+			 yylval]b4_locations_if([, yyloc])[);
 
         yystate = yyn;
-        yystack.push (yyn, yylval]b4_locations_if([, yyloc])[);
+	yystack.push (yyn, yylval]b4_locations_if([, yyloc])[);
         label = YYNEWSTATE;
         break;
 
@@ -724,8 +678,8 @@ m4_popdef([b4_at_dollar])])dnl
 
   // Generate an error message.
   private String yysyntax_error (int yystate, int tok)
-  {]b4_error_verbose_if([[
-    if (yyErrorVerbose)
+  {
+    if (errorVerbose)
       {
         /* There are many possibilities here to consider:
            - Assume YYFAIL is not used.  It's too flawed to consider.
@@ -796,7 +750,7 @@ m4_popdef([b4_at_dollar])])dnl
             return res.toString ();
           }
       }
-]])[
+
     return "syntax error";
   }
 
@@ -818,20 +772,107 @@ m4_popdef([b4_at_dollar])])dnl
     return yyvalue == yytable_ninf_;
   }
 
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+     STATE-NUM.  */
   private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[;
-  private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
+  private static final ]b4_int_type_for([b4_pact])[ yypact_[] =
+  {
+    ]b4_pact[
+  };
 
-  ]b4_parser_tables_define[
-  ]b4_integral_parser_table_define([token_number], [b4_toknum],
-     [TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
-     to YYLEX-NUM.])[
+  /* 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.  */
+  private static final ]b4_int_type_for([b4_defact])[ yydefact_[] =
+  {
+    ]b4_defact[
+  };
+
+  /* YYPGOTO[NTERM-NUM].  */
+  private static final ]b4_int_type_for([b4_pgoto])[ yypgoto_[] =
+  {
+    ]b4_pgoto[
+  };
+
+  /* YYDEFGOTO[NTERM-NUM].  */
+  private static final ]b4_int_type_for([b4_defgoto])[
+  yydefgoto_[] =
+  {
+    ]b4_defgoto[
+  };
+
+  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+     positive, shift that token.  If negative, reduce the rule which
+     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
+  private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
+  private static final ]b4_int_type_for([b4_table])[
+  yytable_[] =
+  {
+    ]b4_table[
+  };
+
+  /* YYCHECK.  */
+  private static final ]b4_int_type_for([b4_check])[
+  yycheck_[] =
+  {
+    ]b4_check[
+  };
+
+  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+  private static final ]b4_int_type_for([b4_stos])[
+  yystos_[] =
+  {
+    ]b4_stos[
+  };
+
+  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
+     to YYLEX-NUM.  */
+  private static final ]b4_int_type_for([b4_toknum])[
+  yytoken_number_[] =
+  {
+    ]b4_toknum[
+  };
+
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+  private static final ]b4_int_type_for([b4_r1])[
+  yyr1_[] =
+  {
+    ]b4_r1[
+  };
+
+  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+  private static final ]b4_int_type_for([b4_r2])[
+  yyr2_[] =
+  {
+    ]b4_r2[
+  };
 
   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
      First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
-  ]b4_typed_parser_table_define([String], [tname], [b4_tname])[
+  private static final String yytname_[] =
+  {
+    ]b4_tname[
+  };
 
-  ]b4_integral_parser_table_define([rline], [b4_rline],
-  [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
+  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+  private static final ]b4_int_type_for([b4_rhs])[ yyrhs_[] =
+  {
+    ]b4_rhs[
+  };
+
+  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+     YYRHS.  */
+  private static final ]b4_int_type_for([b4_prhs])[ yyprhs_[] =
+  {
+    ]b4_prhs[
+  };
+
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+  private static final ]b4_int_type_for([b4_rline])[ yyrline_[] =
+  {
+    ]b4_rline[
+  };
 
   // Report on the debug stream that the rule yyrule is going to be reduced.
   private void yy_reduce_print (int yyrule, YYStack yystack)
@@ -843,18 +884,21 @@ m4_popdef([b4_at_dollar])])dnl
     int yynrhs = yyr2_[yyrule];
     /* Print the symbols being reduced, and their result.  */
     yycdebug ("Reducing stack by rule " + (yyrule - 1)
-              + " (line " + yylno + "), ");
+	      + " (line " + yylno + "), ");
 
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       yy_symbol_print ("   $" + (yyi + 1) + " =",
-                       yystos_[yystack.stateAt(yynrhs - (yyi + 1))],
-                       ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
-                       b4_rhs_location(yynrhs, yyi + 1)])[);
+		       yyrhs_[yyprhs_[yyrule] + yyi],
+		       ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
+		       b4_rhs_location(yynrhs, yyi + 1)])[);
   }
 
   /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-  ]b4_integral_parser_table_define([translate_table], [b4_translate])[
+  private static final ]b4_int_type_for([b4_translate])[ yytranslate_table_[] =
+  {
+    ]b4_translate[
+  };
 
   private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t)
   {
@@ -880,5 +924,5 @@ b4_percent_code_get[]dnl
 
 }
 
-b4_epilogue[]dnl
+b4_epilogue
 m4_divert_pop(0)dnl

data/local.mk

@@ -1,44 +0,0 @@
-## Copyright (C) 2002, 2005-2012 Free Software Foundation, Inc.
-
-## This program is free software: you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation, either version 3 of the License, or
-## (at your option) any later version.
-##
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-dist_pkgdata_DATA =                             \
-  data/README                                   \
-  data/bison.m4                                 \
-  data/c++-skel.m4                              \
-  data/c++.m4                                   \
-  data/c-skel.m4                                \
-  data/c.m4                                     \
-  data/glr.c                                    \
-  data/glr.cc                                   \
-  data/java-skel.m4                             \
-  data/java.m4                                  \
-  data/lalr1.cc                                 \
-  data/lalr1.java                               \
-  data/location.cc                              \
-  data/stack.hh                                 \
-  data/variant.hh                               \
-  data/yacc.c
-
-m4sugardir = $(pkgdatadir)/m4sugar
-dist_m4sugar_DATA =                             \
-  data/m4sugar/foreach.m4                       \
-  data/m4sugar/m4sugar.m4
-
-xsltdir = $(pkgdatadir)/xslt
-dist_xslt_DATA =                                \
-  data/xslt/bison.xsl                           \
-  data/xslt/xml2dot.xsl                         \
-  data/xslt/xml2text.xsl                        \
-  data/xslt/xml2xhtml.xsl

data/location.cc

@@ -1,6 +1,6 @@
 # C++ skeleton for Bison
 
-# Copyright (C) 2002-2012 Free Software Foundation, Inc.
+# Copyright (C) 2002-2007, 2009-2012 Free Software Foundation, Inc.
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,14 +15,12 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-m4_pushdef([b4_copyright_years],
-           [2002-2012])
-
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()
 m4_divert_push(0)dnl
 @output(b4_dir_prefix[]position.hh@)@
-b4_copyright([Positions for Bison parsers in C++])[
+b4_copyright([Positions for Bison parsers in C++],
+             [2002-2007, 2009-2012])[
 
 /**
  ** \file ]b4_dir_prefix[position.hh
@@ -32,7 +30,7 @@ b4_copyright([Positions for Bison parsers in C++])[
 ]b4_cpp_guard_open([b4_dir_prefix[]position.hh])[
 
 # include <algorithm> // std::max
-# include <iosfwd>
+# include <iostream>
 # include <string>
 
 ]b4_null_define[
@@ -89,7 +87,7 @@ b4_copyright([Positions for Bison parsers in C++])[
   };
 
   /// Add and assign a position.
-  inline const position&
+  inline position&
   operator+= (position& res, const int width)
   {
     res.columns (width);
@@ -105,7 +103,7 @@ b4_copyright([Positions for Bison parsers in C++])[
   }
 
   /// Add and assign a position.
-  inline const position&
+  inline position&
   operator-= (position& res, const int width)
   {
     return res += -width;
@@ -151,7 +149,8 @@ b4_copyright([Positions for Bison parsers in C++])[
 ]b4_namespace_close[
 ]b4_cpp_guard_close([b4_dir_prefix[]position.hh])
 @output(b4_dir_prefix[]location.hh@)@
-b4_copyright([Locations for Bison parsers in C++])[
+b4_copyright([Locations for Bison parsers in C++],
+             [2002-2007, 2009-2012])[
 
 /**
  ** \file ]b4_dir_prefix[location.hh
@@ -160,8 +159,6 @@ b4_copyright([Locations for Bison parsers in C++])[
 
 ]b4_cpp_guard_open([b4_dir_prefix[]location.hh])[
 
-# include <iostream>
-# include <string>
 # include "position.hh"
 
 ]b4_namespace_open[
@@ -282,8 +279,8 @@ b4_copyright([Locations for Bison parsers in C++])[
     position last = loc.end - 1;
     ostr << loc.begin;
     if (last.filename
-        && (!loc.begin.filename
-            || *loc.begin.filename != *last.filename))
+	&& (!loc.begin.filename
+	    || *loc.begin.filename != *last.filename))
       ostr << '-' << last;
     else if (loc.begin.line != last.line)
       ostr << '-' << last.line  << '.' << last.column;
@@ -296,5 +293,4 @@ b4_copyright([Locations for Bison parsers in C++])[
 
 ]b4_cpp_guard_close([b4_dir_prefix[]location.hh])
 m4_divert_pop(0)
-m4_popdef([b4_copyright_years])dnl
 m4_changecom([#])

data/stack.hh

@@ -22,7 +22,8 @@ m4_pushdef([b4_copyright_years],
 m4_changecom()
 m4_divert_push(0)dnl
 @output(b4_dir_prefix[]stack.hh@)@
-b4_copyright([Stack handling for Bison parsers in C++])[
+b4_copyright([Stack handling for Bison parsers in C++],
+             [2002-2012])[
 
 /**
  ** \file ]b4_dir_prefix[stack.hh
@@ -42,13 +43,11 @@ b4_copyright([Stack handling for Bison parsers in C++])[
     typedef typename S::reverse_iterator iterator;
     typedef typename S::const_reverse_iterator const_iterator;
 
-    stack ()
-      : seq_ ()
+    stack () : seq_ ()
     {
     }
 
-    stack (unsigned int n)
-      : seq_ (n)
+    stack (unsigned int n) : seq_ (n)
     {
     }
 
@@ -82,28 +81,16 @@ b4_copyright([Stack handling for Bison parsers in C++])[
     }
 
     inline
-    typename S::size_type
-    size () const
+    unsigned int
+    height () const
     {
       return seq_.size ();
     }
 
-    inline
-    const_iterator
-    begin () const
-    {
-      return seq_.rbegin ();
-    }
-
-    inline
-    const_iterator
-    end () const
-    {
-      return seq_.rend ();
-    }
+    inline const_iterator begin () const { return seq_.rbegin (); }
+    inline const_iterator end () const { return seq_.rend (); }
 
   private:
-    /// The wrapped container.
     S seq_;
   };
 

data/variant.hh

@@ -1,277 +0,0 @@
-# C++ skeleton for Bison
-
-# Copyright (C) 2002-2012 Free Software Foundation, Inc.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-## --------- ##
-## variant.  ##
-## --------- ##
-
-# b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
-# ------------------------------------------------
-# Run some ACTION ("build", or "destroy") on YYVAL of symbol type
-# YYTYPE.
-m4_define([b4_symbol_variant],
-[m4_pushdef([b4_dollar_dollar],
-            [$2.$3< $][3 >(m4_shift3($@))])dnl
-  switch ($1)
-    {
-b4_type_foreach([b4_type_action_])[]dnl
-      default:
-        break;
-    }
-m4_popdef([b4_dollar_dollar])dnl
-])
-
-
-# _b4_char_sizeof_counter
-# -----------------------
-# A counter used by _b4_char_sizeof_dummy to create fresh symbols.
-m4_define([_b4_char_sizeof_counter],
-[0])
-
-# _b4_char_sizeof_dummy
-# ---------------------
-# At each call return a new C++ identifier.
-m4_define([_b4_char_sizeof_dummy],
-[m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl
-dummy[]_b4_char_sizeof_counter])
-
-
-# b4_char_sizeof_(SYMBOL-NUM)
-# ---------------------------
-# A comment describing this symbol.
-m4_define([b4_char_sizeof_],
-[      // b4_symbol([$1], [tag])
-])
-
-# b4_char_sizeof(SYMBOL-NUMS)
-# ---------------------------
-# To be mapped on the list of type names to produce:
-#
-#    char dummy1[sizeof(type_name_1)];
-#    char dummy2[sizeof(type_name_2)];
-#
-# for defined type names.
-m4_define([b4_char_sizeof],
-[b4_symbol_if([$1], [has_type],
-[
-m4_map_args([b4_char_sizeof_], $@)dnl
-      char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type])])@};
-])])
-
-
-# b4_variant_define
-# -----------------
-# Define "variant".
-m4_define([b4_variant_define],
-[[
-  /// A char[S] buffer to store and retrieve objects.
-  ///
-  /// Sort of a variant, but does not keep track of the nature
-  /// of the stored data, since that knowledge is available
-  /// via the current state.
-  template <size_t S>
-  struct variant
-  {]b4_parse_assert_if([
-    /// Whether something is contained.
-    bool built;
-])[
-    /// Empty construction.
-    inline
-    variant ()]b4_parse_assert_if([
-      : built (false)])[
-    {}
-
-    /// Instantiate a \a T in here.
-    template <typename T>
-    inline T&
-    build ()
-    {]b4_parse_assert_if([
-      assert (!built);
-      built = true;])[
-      return *new (buffer.raw) T;
-    }
-
-    /// Instantiate a \a T in here from \a t.
-    template <typename T>
-    inline T&
-    build (const T& t)
-    {]b4_parse_assert_if([
-      assert(!built);
-      built = true;])[
-      return *new (buffer.raw) T(t);
-    }
-
-    /// Construct and fill.
-    template <typename T>
-    inline
-    variant (const T& t)]b4_parse_assert_if([
-      : built (true)])[
-    {
-      new (buffer.raw) T(t);
-    }
-
-    /// Accessor to a built \a T.
-    template <typename T>
-    inline T&
-    as ()
-    {]b4_parse_assert_if([
-      assert (built);])[
-      return reinterpret_cast<T&>(buffer.raw);
-    }
-
-    /// Const accessor to a built \a T (for %printer).
-    template <typename T>
-    inline const T&
-    as () const
-    {]b4_parse_assert_if([
-      assert(built);])[
-      return reinterpret_cast<const T&>(buffer.raw);
-    }
-
-    /// Swap the content with \a other.
-    template <typename T>
-    inline void
-    swap (variant<S>& other)
-    {
-      std::swap (as<T>(), other.as<T>());
-    }
-
-    /// Assign the content of \a other to this.
-    /// Destroys \a other.
-    template <typename T>
-    inline void
-    build (variant<S>& other)
-    {
-      build<T>();
-      swap<T>(other);
-      other.destroy<T>();
-    }
-
-    /// Destroy the stored \a T.
-    template <typename T>
-    inline void
-    destroy ()
-    {
-      as<T>().~T();]b4_parse_assert_if([
-      built = false;])[
-    }
-
-    /// A buffer large enough to store any of the semantic values.
-    /// Long double is chosen as it has the strongest alignment
-    /// constraints.
-    union
-    {
-      long double align_me;
-      char raw[S];
-    } buffer;
-  };
-]])
-
-
-## -------------------------- ##
-## Adjustments for variants.  ##
-## -------------------------- ##
-
-
-# b4_semantic_type_declare
-# ------------------------
-# Declare semantic_type.
-m4_define([b4_semantic_type_declare],
-[    /// An auxiliary type to compute the largest semantic type.
-    union union_type
-    {]b4_type_foreach([b4_char_sizeof])[};
-
-    /// Symbol semantic values.
-    typedef variant<sizeof(union_type)> semantic_type;])
-
-
-# How the semantic value is extracted when using variants.
-
-# b4_symbol_value(VAL, [TYPE])
-# ----------------------------
-m4_define([b4_symbol_value],
-[m4_ifval([$2],
-          [$1.as< $2 >()],
-          [$1])])
-
-# b4_symbol_value_template(VAL, [TYPE])
-# -------------------------------------
-# Same as b4_symbol_value, but used in a template method.
-m4_define([b4_symbol_value_template],
-[m4_ifval([$2],
-          [$1.template as< $2 >()],
-          [$1])])
-
-
-
-## ------------- ##
-## make_SYMBOL.  ##
-## ------------- ##
-
-
-# b4_symbol_constructor_declare_(SYMBOL-NUMBER)
-# ---------------------------------------------
-# Declare the overloaded version of make_symbol for the (common) type of
-# these SYMBOL-NUMBERS.  Use at class-level.
-m4_define([b4_symbol_constructor_declare_],
-[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
-[    static inline
-    symbol_type
-    make_[]b4_symbol_([$1], [id]) (dnl
-b4_args(b4_symbol_if([$1], [has_type],
-                     [const b4_symbol([$1], [type])& v]),
-        b4_locations_if([const location_type& l])));
-
-])])])
-
-
-# b4_symbol_constructor_declare
-# -----------------------------
-# Declare symbol constructors for all the value types.
-# Use at class-level.
-m4_define([b4_symbol_constructor_declare],
-[    // Symbol constructors declarations.
-b4_symbol_foreach([b4_symbol_constructor_declare_])])
-
-
-
-# b4_symbol_constructor_define_(SYMBOL-NUMBER)
-# --------------------------------------------
-# Define symbol constructor for this SYMBOL-NUMBER.
-m4_define([b4_symbol_constructor_define_],
-[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
-[  b4_parser_class_name::symbol_type
-  b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
-b4_args(b4_symbol_if([$1], [has_type],
-                     [const b4_symbol([$1], [type])& v]),
-        b4_locations_if([const location_type& l])))
-  {
-    return symbol_type (b4_args([token::b4_symbol([$1], [id])],
-                                b4_symbol_if([$1], [has_type], [v]),
-                                b4_locations_if([l])));
-  }
-
-])])])
-
-
-# b4_symbol_constructor_define
-# ----------------------------
-# Define the overloaded versions of make_symbol for all the value types.
-m4_define([b4_symbol_constructor_define],
-[  // Implementation of make_symbol for each symbol type.
-b4_symbol_foreach([b4_symbol_constructor_define_])])

data/xslt/xml2dot.xsl

@@ -124,20 +124,20 @@
     <xsl:with-param name="dst" select="@state"/>
     <xsl:with-param name="style">
       <xsl:choose>
-        <xsl:when test="@symbol = 'error'">
-          <xsl:text>dotted</xsl:text>
-        </xsl:when>
-        <xsl:when test="@type = 'shift'">
-          <xsl:text>solid</xsl:text>
-        </xsl:when>
-        <xsl:otherwise>
-          <xsl:text>dashed</xsl:text>
-        </xsl:otherwise>
+	<xsl:when test="@symbol = 'error'">
+	  <xsl:text>dotted</xsl:text>
+	</xsl:when>
+	<xsl:when test="@type = 'shift'">
+	  <xsl:text>solid</xsl:text>
+	</xsl:when>
+	<xsl:otherwise>
+	  <xsl:text>dashed</xsl:text>
+	</xsl:otherwise>
       </xsl:choose>
     </xsl:with-param>
     <xsl:with-param name="label">
       <xsl:if test="not(@symbol = 'error')">
-        <xsl:value-of select="@symbol"/>
+	<xsl:value-of select="@symbol"/>
       </xsl:if>
     </xsl:with-param>
   </xsl:call-template>

data/xslt/xml2text.xsl

@@ -253,9 +253,9 @@
     <xsl:text>&#10;</xsl:text>
     <xsl:apply-templates select="transition[@type = $type]">
       <xsl:with-param name="pad">
-        <xsl:call-template name="max-width-symbol">
-          <xsl:with-param name="node" select="transition[@type = $type]"/>
-        </xsl:call-template>
+	<xsl:call-template name="max-width-symbol">
+	  <xsl:with-param name="node" select="transition[@type = $type]"/>
+	</xsl:call-template>
       </xsl:with-param>
     </xsl:apply-templates>
   </xsl:if>
@@ -266,9 +266,9 @@
     <xsl:text>&#10;</xsl:text>
     <xsl:apply-templates select="error">
       <xsl:with-param name="pad">
-        <xsl:call-template name="max-width-symbol">
-          <xsl:with-param name="node" select="error"/>
-        </xsl:call-template>
+	<xsl:call-template name="max-width-symbol">
+	  <xsl:with-param name="node" select="error"/>
+	</xsl:call-template>
       </xsl:with-param>
     </xsl:apply-templates>
   </xsl:if>
@@ -279,9 +279,9 @@
     <xsl:text>&#10;</xsl:text>
     <xsl:apply-templates select="reduction">
       <xsl:with-param name="pad">
-        <xsl:call-template name="max-width-symbol">
-          <xsl:with-param name="node" select="reduction"/>
-        </xsl:call-template>
+	<xsl:call-template name="max-width-symbol">
+	  <xsl:with-param name="node" select="reduction"/>
+	</xsl:call-template>
       </xsl:with-param>
     </xsl:apply-templates>
   </xsl:if>
@@ -290,7 +290,7 @@
 <xsl:template match="item">
   <xsl:param name="pad"/>
   <xsl:param name="prev-rule-number"
-             select="preceding-sibling::item[1]/@rule-number"/>
+	     select="preceding-sibling::item[1]/@rule-number"/>
   <xsl:apply-templates
     select="key('bison:ruleByNumber', current()/@rule-number)"
   >
@@ -329,14 +329,14 @@
   <xsl:choose>
     <xsl:when test="$itemset != 'true' and $prev-lhs = lhs[text()]">
       <xsl:call-template name="lpad">
-        <xsl:with-param name="str" select="'|'"/>
-        <xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 1"/>
+	<xsl:with-param name="str" select="'|'"/>
+	<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 1"/>
       </xsl:call-template>
     </xsl:when>
     <xsl:when test="$itemset = 'true' and $prev-lhs = lhs[text()]">
       <xsl:call-template name="lpad">
-        <xsl:with-param name="str" select="'|'"/>
-        <xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 1"/>
+	<xsl:with-param name="str" select="'|'"/>
+	<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 1"/>
       </xsl:call-template>
     </xsl:when>
     <xsl:otherwise>
@@ -442,7 +442,7 @@
       <xsl:value-of select="@rule"/>
       <xsl:text> (</xsl:text>
       <xsl:value-of
-          select="key('bison:ruleByNumber', current()/@rule)/lhs[text()]"/>
+	  select="key('bison:ruleByNumber', current()/@rule)/lhs[text()]"/>
       <xsl:text>)</xsl:text>
     </xsl:otherwise>
   </xsl:choose>
@@ -479,9 +479,9 @@
   <xsl:variable name="longest">
     <xsl:for-each select="$node">
       <xsl:sort data-type="number" select="string-length(@symbol)"
-                order="descending"/>
+		order="descending"/>
       <xsl:if test="position() = 1">
-        <xsl:value-of select="string-length(@symbol)"/>
+	<xsl:value-of select="string-length(@symbol)"/>
       </xsl:if>
     </xsl:for-each>
   </xsl:variable>
@@ -498,7 +498,7 @@
     </xsl:when>
     <xsl:otherwise>
       <xsl:call-template name="space">
-        <xsl:with-param name="repeat" select="$diff"/>
+	<xsl:with-param name="repeat" select="$diff"/>
       </xsl:call-template>
       <xsl:value-of select="$str"/>
     </xsl:otherwise>
@@ -516,7 +516,7 @@
     <xsl:otherwise>
       <xsl:value-of select="$str"/>
       <xsl:call-template name="space">
-        <xsl:with-param name="repeat" select="$diff"/>
+	<xsl:with-param name="repeat" select="$diff"/>
       </xsl:call-template>
     </xsl:otherwise>
   </xsl:choose>

data/xslt/xml2xhtml.xsl

@@ -31,32 +31,32 @@
 <xsl:import href="bison.xsl"/>
 
 <xsl:output method="xml" encoding="UTF-8"
-            doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
-            doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
-            indent="yes"/>
+	    doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
+	    doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
+	    indent="yes"/>
 
 <xsl:template match="/">
   <html>
     <head>
       <title>
-        <xsl:value-of select="bison-xml-report/filename"/>
-        <xsl:text> - GNU Bison XML Automaton Report</xsl:text>
+	<xsl:value-of select="bison-xml-report/filename"/>
+	<xsl:text> - GNU Bison XML Automaton Report</xsl:text>
       </title>
       <style type="text/css"><![CDATA[
       body {
         font-family: "Nimbus Sans L", Arial, sans-serif;
-        font-size: 9pt;
+	font-size: 9pt;
       }
       a:link {
-        color: #1f00ff;
-        text-decoration: none;
+	color: #1f00ff;
+	text-decoration: none;
       }
       a:visited {
-        color: #1f00ff;
-        text-decoration: none;
+	color: #1f00ff;
+	text-decoration: none;
       }
       a:hover {
-        color: red;
+	color: red;
       }
       #menu a {
         text-decoration: underline;
@@ -109,21 +109,21 @@
     <li>
       <a href="#reductions">Reductions</a>
       <ul class="lower-alpha">
-        <li><a href="#nonterminals_useless_in_grammar">Nonterminals useless in grammar</a></li>
-        <li><a href="#terminals_unused_in_grammar">Terminals unused in grammar</a></li>
-        <li><a href="#rules_useless_in_grammar">Rules useless in grammar</a></li>
-        <xsl:if test="grammar/rules/rule[@usefulness='useless-in-parser']">
-          <li><a href="#rules_useless_in_parser">Rules useless in parser due to conflicts</a></li>
-        </xsl:if>
+	<li><a href="#nonterminals_useless_in_grammar">Nonterminals useless in grammar</a></li>
+	<li><a href="#terminals_unused_in_grammar">Terminals unused in grammar</a></li>
+	<li><a href="#rules_useless_in_grammar">Rules useless in grammar</a></li>
+	<xsl:if test="grammar/rules/rule[@usefulness='useless-in-parser']">
+	  <li><a href="#rules_useless_in_parser">Rules useless in parser due to conflicts</a></li>
+	</xsl:if>
       </ul>
     </li>
     <li><a href="#conflicts">Conflicts</a></li>
     <li>
       <a href="#grammar">Grammar</a>
       <ul class="lower-alpha">
-        <li><a href="#grammar">Itemset</a></li>
-        <li><a href="#terminals">Terminal symbols</a></li>
-        <li><a href="#nonterminals">Nonterminal symbols</a></li>
+	<li><a href="#grammar">Itemset</a></li>
+	<li><a href="#terminals">Terminal symbols</a></li>
+	<li><a href="#nonterminals">Nonterminal symbols</a></li>
       </ul>
     </li>
     <li><a href="#automaton">Automaton</a></li>
@@ -154,9 +154,9 @@
   <xsl:if test="nonterminal[@usefulness='useless-in-grammar']">
     <p class="pre">
       <xsl:for-each select="nonterminal[@usefulness='useless-in-grammar']">
-        <xsl:text>   </xsl:text>
-        <xsl:value-of select="@name"/>
-        <xsl:text>&#10;</xsl:text>
+	<xsl:text>   </xsl:text>
+	<xsl:value-of select="@name"/>
+	<xsl:text>&#10;</xsl:text>
       </xsl:for-each>
       <xsl:text>&#10;&#10;</xsl:text>
     </p>
@@ -173,9 +173,9 @@
     <p class="pre">
       <xsl:for-each select="terminal[@usefulness='unused-in-grammar']">
         <xsl:sort select="@symbol-number" data-type="number"/>
-        <xsl:text>   </xsl:text>
-        <xsl:value-of select="@name"/>
-        <xsl:text>&#10;</xsl:text>
+	<xsl:text>   </xsl:text>
+	<xsl:value-of select="@name"/>
+	<xsl:text>&#10;</xsl:text>
       </xsl:for-each>
       <xsl:text>&#10;&#10;</xsl:text>
     </p>
@@ -381,7 +381,7 @@
   <h3>
     <a>
       <xsl:attribute name="name">
-        <xsl:value-of select="concat('state_', @number)"/>
+	<xsl:value-of select="concat('state_', @number)"/>
       </xsl:attribute>
     </a>
     <xsl:text>state </xsl:text>
@@ -410,9 +410,9 @@
     <xsl:text>&#10;</xsl:text>
     <xsl:apply-templates select="transition[@type = $type]">
       <xsl:with-param name="pad">
-        <xsl:call-template name="max-width-symbol">
-          <xsl:with-param name="node" select="transition[@type = $type]"/>
-        </xsl:call-template>
+	<xsl:call-template name="max-width-symbol">
+	  <xsl:with-param name="node" select="transition[@type = $type]"/>
+	</xsl:call-template>
       </xsl:with-param>
     </xsl:apply-templates>
   </xsl:if>
@@ -423,9 +423,9 @@
     <xsl:text>&#10;</xsl:text>
     <xsl:apply-templates select="error">
       <xsl:with-param name="pad">
-        <xsl:call-template name="max-width-symbol">
-          <xsl:with-param name="node" select="error"/>
-        </xsl:call-template>
+	<xsl:call-template name="max-width-symbol">
+	  <xsl:with-param name="node" select="error"/>
+	</xsl:call-template>
       </xsl:with-param>
     </xsl:apply-templates>
   </xsl:if>
@@ -436,9 +436,9 @@
     <xsl:text>&#10;</xsl:text>
     <xsl:apply-templates select="reduction">
       <xsl:with-param name="pad">
-        <xsl:call-template name="max-width-symbol">
-          <xsl:with-param name="node" select="reduction"/>
-        </xsl:call-template>
+	<xsl:call-template name="max-width-symbol">
+	  <xsl:with-param name="node" select="reduction"/>
+	</xsl:call-template>
       </xsl:with-param>
     </xsl:apply-templates>
   </xsl:if>
@@ -447,7 +447,7 @@
 <xsl:template match="item">
   <xsl:param name="pad"/>
   <xsl:param name="prev-rule-number"
-             select="preceding-sibling::item[1]/@rule-number"/>
+	     select="preceding-sibling::item[1]/@rule-number"/>
   <xsl:apply-templates
     select="key('bison:ruleByNumber', current()/@rule-number)"
   >
@@ -477,7 +477,7 @@
   <xsl:if test="$itemset != 'true'">
     <a>
       <xsl:attribute name="name">
-        <xsl:value-of select="concat('rule_', @number)"/>
+	<xsl:value-of select="concat('rule_', @number)"/>
       </xsl:attribute>
     </a>
   </xsl:if>
@@ -486,19 +486,19 @@
   <xsl:choose>
     <xsl:when test="$itemset = 'true'">
       <a>
-        <xsl:attribute name="href">
-          <xsl:value-of select="concat('#rule_', @number)"/>
-        </xsl:attribute>
-        <xsl:call-template name="lpad">
-          <xsl:with-param name="str" select="string(@number)"/>
-          <xsl:with-param name="pad" select="number($pad)"/>
-        </xsl:call-template>
+	<xsl:attribute name="href">
+	  <xsl:value-of select="concat('#rule_', @number)"/>
+	</xsl:attribute>
+	<xsl:call-template name="lpad">
+	  <xsl:with-param name="str" select="string(@number)"/>
+	  <xsl:with-param name="pad" select="number($pad)"/>
+	</xsl:call-template>
       </a>
     </xsl:when>
     <xsl:otherwise>
       <xsl:call-template name="lpad">
-        <xsl:with-param name="str" select="string(@number)"/>
-        <xsl:with-param name="pad" select="number($pad)"/>
+	<xsl:with-param name="str" select="string(@number)"/>
+	<xsl:with-param name="pad" select="number($pad)"/>
       </xsl:call-template>
     </xsl:otherwise>
   </xsl:choose>
@@ -508,19 +508,19 @@
   <xsl:choose>
     <xsl:when test="$itemset != 'true' and $prev-lhs = lhs[text()]">
       <xsl:call-template name="lpad">
-        <xsl:with-param name="str" select="'|'"/>
-        <xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 2"/>
+	<xsl:with-param name="str" select="'|'"/>
+	<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 2"/>
       </xsl:call-template>
     </xsl:when>
     <xsl:when test="$itemset = 'true' and $prev-lhs = lhs[text()]">
       <xsl:call-template name="lpad">
-        <xsl:with-param name="str" select="'|'"/>
-        <xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 2"/>
+	<xsl:with-param name="str" select="'|'"/>
+	<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 2"/>
       </xsl:call-template>
     </xsl:when>
     <xsl:otherwise>
       <span class="i">
-        <xsl:value-of select="lhs"/>
+	<xsl:value-of select="lhs"/>
       </span>
       <xsl:text> &#8594;</xsl:text>
     </xsl:otherwise>
@@ -589,18 +589,18 @@
   <xsl:choose>
     <xsl:when test="@type = 'shift'">
       <a>
-        <xsl:attribute name="href">
-          <xsl:value-of select="concat('#state_', @state)"/>
-        </xsl:attribute>
-        <xsl:value-of select="concat('shift, and go to state ', @state)"/>
+	<xsl:attribute name="href">
+	  <xsl:value-of select="concat('#state_', @state)"/>
+	</xsl:attribute>
+	<xsl:value-of select="concat('shift, and go to state ', @state)"/>
       </a>
     </xsl:when>
     <xsl:when test="@type = 'goto'">
       <a>
-        <xsl:attribute name="href">
-          <xsl:value-of select="concat('#state_', @state)"/>
-        </xsl:attribute>
-        <xsl:value-of select="concat('go to state ', @state)"/>
+	<xsl:attribute name="href">
+	  <xsl:value-of select="concat('#state_', @state)"/>
+	</xsl:attribute>
+	<xsl:value-of select="concat('go to state ', @state)"/>
       </a>
     </xsl:when>
   </xsl:choose>
@@ -637,10 +637,10 @@
     </xsl:when>
     <xsl:otherwise>
       <a>
-        <xsl:attribute name="href">
-          <xsl:value-of select="concat('#rule_', @rule)"/>
-        </xsl:attribute>
-        <xsl:value-of select="concat('reduce using rule ', @rule)"/>
+	<xsl:attribute name="href">
+	  <xsl:value-of select="concat('#rule_', @rule)"/>
+	</xsl:attribute>
+	<xsl:value-of select="concat('reduce using rule ', @rule)"/>
       </a>
       <xsl:text> (</xsl:text>
       <xsl:value-of
@@ -687,9 +687,9 @@
   <xsl:variable name="longest">
     <xsl:for-each select="$node">
       <xsl:sort data-type="number" select="string-length(@symbol)"
-                order="descending"/>
+		order="descending"/>
       <xsl:if test="position() = 1">
-        <xsl:value-of select="string-length(@symbol)"/>
+	<xsl:value-of select="string-length(@symbol)"/>
       </xsl:if>
     </xsl:for-each>
   </xsl:variable>
@@ -706,7 +706,7 @@
     </xsl:when>
     <xsl:otherwise>
       <xsl:call-template name="space">
-        <xsl:with-param name="repeat" select="$diff"/>
+	<xsl:with-param name="repeat" select="$diff"/>
       </xsl:call-template>
       <xsl:value-of select="$str"/>
     </xsl:otherwise>
@@ -724,7 +724,7 @@
     <xsl:otherwise>
       <xsl:value-of select="$str"/>
       <xsl:call-template name="space">
-        <xsl:with-param name="repeat" select="$diff"/>
+	<xsl:with-param name="repeat" select="$diff"/>
       </xsl:call-template>
     </xsl:otherwise>
   </xsl:choose>

data/yacc.c

@@ -1,12 +1,10 @@
                                                              -*- 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 @@ m4_define([b4_pure_flag],
 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
 m4_define([b4_yacc_pure_if],
 [b4_pure_if([m4_ifset([b4_parse_param],
-                      [$1], [$2])],
-            [$2])])
+		      [$1], [$2])],
+	    [$2])])
 
 
 # b4_yyerror_args
@@ -117,7 +115,7 @@ m4_define([b4_int_type],
 
        m4_eval([0 <= $1]),                [1], [unsigned int],
 
-                                               [int])])
+					       [int])])
 
 
 ## ----------------- ##
@@ -129,7 +127,7 @@ m4_define([b4_int_type],
 # --------------------
 # Expansion of $<TYPE>$.
 m4_define([b4_lhs_value],
-[b4_symbol_value(yyval, [$1])])
+[(yyval[]m4_ifval([$1], [.$1]))])
 
 
 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
@@ -137,7 +135,7 @@ m4_define([b4_lhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
-          [b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3])])
+[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
 
 
 
@@ -157,7 +155,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@{b4_subtract([$2], [$1])@})])
+[(yylsp@{($2) - ($1)@})])
 
 
 ## -------------- ##
@@ -172,11 +170,35 @@ m4_define([b4_declare_scanner_communication_variables], [[
 /* The lookahead symbol.  */
 int yychar;
 
+]b4_pure_if([[
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+/* Default value used for initialization, for pacifying older GCCs
+   or non-GCC compilers.  */
+static YYSTYPE yyval_default;
+# define YY_INITIAL_VALUE(Value) = Value
+#endif]])[
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
 /* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval;]b4_locations_if([[
+YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);]b4_locations_if([[
 
 /* Location data for the lookahead symbol.  */
-YYLTYPE yylloc;]])b4_pure_if([], [[
+YYLTYPE yylloc][]b4_yyloc_default[;
+]])b4_pure_if([], [[
 
 /* Number of syntax errors so far.  */
 int yynerrs;]])])
@@ -244,7 +266,7 @@ typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
   [[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_api_PREFIX[LTYPE *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_prefix[pstate *ps]], [[ps]]]m4_ifset([b4_parse_param], [,
@@ -284,7 +306,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_token_enums_defines(b4_tokens)[
 ]b4_declare_yylstype[
 ]b4_declare_yyparse[
 ]b4_percent_code_get([[provides]])[
@@ -299,7 +321,8 @@ m4_define([b4_shared_declarations],
 m4_changecom()
 m4_divert_push(0)dnl
 @output(b4_parser_file_name@)@
-b4_copyright([Bison implementation for Yacc-like parsers in C])[
+b4_copyright([Bison implementation for Yacc-like parsers in C],
+             [1984, 1989-1990, 2000-2012])[
 
 /* C LALR(1) parser skeleton written by Richard Stallman, by
    simplifying the original so-called "semantic" parser.  */
@@ -343,12 +366,14 @@ m4_if(b4_api_prefix, [yy], [],
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
-# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
+# define YYERROR_VERBOSE ]b4_error_verbose_flag[
 #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
@@ -403,24 +428,24 @@ typedef short int yytype_int16;
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
 #  endif
 # endif
 # ifndef YY_
-#  define YY_(msgid) msgid
+#  define YY_(Msgid) Msgid
 # endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
+# define YYUSE(E) ((void) (E))
 #else
-# define YYUSE(e) /* empty */
+# define YYUSE(E) /* empty */
 #endif
 
 /* Identity function, used to suppress warnings about constant conditions.  */
 #ifndef lint
-# define YYID(n) (n)
+# define YYID(N) (N)
 #else
 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
 {
@@ -475,7 +500,7 @@ b4_push_if([], [b4_lac_if([], [[
 #  endif
 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
        && ! ((defined YYMALLOC || defined malloc) \
-             && (defined YYFREE || defined free)))
+	     && (defined YYFREE || defined free)))
 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 #   ifndef EXIT_SUCCESS
 #    define EXIT_SUCCESS 0
@@ -500,8 +525,8 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */
 
 #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
@@ -531,15 +556,15 @@ union yyalloc
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
-    do                                                                  \
-      {                                                                 \
-        YYSIZE_T yynewbytes;                                            \
-        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
-        Stack = &yyptr->Stack_alloc;                                    \
-        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-        yyptr += yynewbytes / sizeof (*yyptr);                          \
-      }                                                                 \
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
+    do									\
+      {									\
+	YYSIZE_T yynewbytes;						\
+	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
+	Stack = &yyptr->Stack_alloc;					\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+	yyptr += yynewbytes / sizeof (*yyptr);				\
+      }									\
     while (YYID (0))
 
 #endif
@@ -575,27 +600,41 @@ union yyalloc
 #define YYNNTS  ]b4_nterms_number[
 /* YYNRULES -- Number of rules.  */
 #define YYNRULES  ]b4_rules_number[
-/* YYNSTATES -- Number of states.  */
+/* YYNRULES -- Number of states.  */
 #define YYNSTATES  ]b4_states_number[
 
-/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
-   by yylex, with out-of-bounds checking.  */
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #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[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
-   as returned by yylex, without out-of-bounds checking.  */
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
 {
   ]b4_translate[
 };
 
 #if ]b4_api_PREFIX[DEBUG
-]b4_integral_parser_table_define([rline], [b4_rline],
-     [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
+/* 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[
+};
 #endif
 
 #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
@@ -608,34 +647,89 @@ static const char *const yytname[] =
 #endif
 
 # ifdef YYPRINT
-/* YYTOKNUM[NUM] -- (External) token number corresponding to the
-   (internal) symbol number NUM (which must be that of a token).  */
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
 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[
+};
 
-#define yypact_value_is_default(yystate) \
-  ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
+/* 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 yytable_value_is_error(yytable_value) \
-  ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
+#define yypact_value_is_default(Yystate) \
+  ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[
 
-]b4_parser_tables_define[
+#define yytable_value_is_error(Yytable_value) \
+  ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[
 
-#define yyerrok         (yyerrstatus = 0)
-#define yyclearin       (yychar = YYEMPTY)
-#define YYEMPTY         (-2)
-#define YYEOF           0
+static const ]b4_int_type_for([b4_check])[ yycheck[] =
+{
+  ]b4_check[
+};
 
-#define YYACCEPT        goto yyacceptlab
-#define YYABORT         goto yyabortlab
-#define YYERROR         goto yyerrorlab
+/* 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
 
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
@@ -645,7 +739,7 @@ static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
    discussed.  */
 
-#define YYFAIL          goto yyerrlab
+#define YYFAIL		goto yyerrlab
 #if defined YYFAIL
   /* This is here to suppress warnings from the GCC cpp's
      -Wunused-macros.  Normally we don't worry about that warning, but
@@ -669,43 +763,21 @@ do                                                              \
   else                                                          \
     {                                                           \
       yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
-      YYERROR;                                                  \
-    }                                                           \
+      YYERROR;							\
+    }								\
 while (YYID (0))
 
-
-#define YYTERROR        1
-#define YYERRCODE       256
+/* Error token number */
+#define YYTERROR	1
+#define YYERRCODE	256
 
 ]b4_locations_if([[
 ]b4_yylloc_default_define[
 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
-
-#ifndef YY_LOCATION_PRINT
-# if defined ]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)
-# else
-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
-#endif]], [[
-
-
-/* This macro is provided for backward compatibility. */
-
-#ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-#endif]])[
-
+]])[
+]b4_yy_location_print_define[
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
-
 #ifdef YYLEX_PARAM
 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
 #else
@@ -720,21 +792,21 @@ while (YYID (0))
 #  define YYFPRINTF fprintf
 # endif
 
-# define YYDPRINTF(Args)                        \
-do {                                            \
-  if (yydebug)                                  \
-    YYFPRINTF Args;                             \
+# define YYDPRINTF(Args)			\
+do {						\
+  if (yydebug)					\
+    YYFPRINTF Args;				\
 } while (YYID (0))
 
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
-do {                                                                      \
-  if (yydebug)                                                            \
-    {                                                                     \
-      YYFPRINTF (stderr, "%s ", Title);                                   \
-      yy_symbol_print (stderr,                                            \
-                  Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
-      YYFPRINTF (stderr, "\n");                                           \
-    }                                                                     \
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+do {									  \
+  if (yydebug)								  \
+    {									  \
+      YYFPRINTF (stderr, "%s ", Title);					  \
+      yy_symbol_print (stderr,						  \
+		  Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
+      YYFPRINTF (stderr, "\n");						  \
+    }									  \
 } while (YYID (0))
 
 ]b4_yy_symbol_print_generate([b4_c_function_def])[
@@ -745,8 +817,8 @@ do {                                                                      \
 `------------------------------------------------------------------*/
 
 ]b4_c_function_def([yy_stack_print], [static void],
-                   [[yytype_int16 *yybottom], [yybottom]],
-                   [[yytype_int16 *yytop],    [yytop]])[
+		   [[yytype_int16 *yybottom], [yybottom]],
+		   [[yytype_int16 *yytop],    [yytop]])[
 {
   YYFPRINTF (stderr, "Stack now");
   for (; yybottom <= yytop; yybottom++)
@@ -757,10 +829,10 @@ do {                                                                      \
   YYFPRINTF (stderr, "\n");
 }
 
-# define YY_STACK_PRINT(Bottom, Top)                            \
-do {                                                            \
-  if (yydebug)                                                  \
-    yy_stack_print ((Bottom), (Top));                           \
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
 } while (YYID (0))
 
 
@@ -769,34 +841,32 @@ do {                                                            \
 `------------------------------------------------*/
 
 ]b4_c_function_def([yy_reduce_print], [static void],
-                   [[yytype_int16 *yyssp], [yyssp]],
-                   [[YYSTYPE *yyvsp], [yyvsp]],
+		   [[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,
-                       yystos[yyssp[yyi + 1 - yynrhs]],
-                       &]b4_rhs_value(yynrhs, yyi + 1)[
-                       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
-                       b4_user_args[);
+      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");
     }
 }
 
-# define YY_REDUCE_PRINT(Rule)          \
-do {                                    \
-  if (yydebug)                          \
-    yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
 } while (YYID (0))
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
@@ -811,7 +881,7 @@ int yydebug;
 
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
-#ifndef YYINITDEPTH
+#ifndef	YYINITDEPTH
 # define YYINITDEPTH ]b4_stack_depth_init[
 #endif
 
@@ -1118,27 +1188,27 @@ yytnamerr (char *yyres, const char *yystr)
       char const *yyp = yystr;
 
       for (;;)
-        switch (*++yyp)
-          {
-          case '\'':
-          case ',':
-            goto do_not_strip_quotes;
+	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 (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
 
-          case '"':
-            if (yyres)
-              yyres[yyn] = '\0';
-            return yyn;
-          }
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
     do_not_strip_quotes: ;
     }
 
@@ -1340,7 +1410,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
   yypstate *yyps_local;]b4_pure_if([[
   int yychar;
   YYSTYPE yylval;]b4_locations_if([[
-  YYLTYPE yylloc;]])])[
+  YYLTYPE yylloc][]b4_yyloc_default[;]])])[
   if (yyps)
     yyps_local = yyps;
   else
@@ -1420,7 +1490,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
   [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
   [[[int yypushed_char]], [[yypushed_char]]],
   [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
-  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
+  [[[YYLTYPE *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
   b4_parse_param]))], [[
 
 
@@ -1446,7 +1516,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
   int yyn;
   int yyresult;
   /* Lookahead token as an internal (translated) token number.  */
-  int yytoken;
+  int yytoken = 0;
   /* The variables used to return semantic value and location from the
      action routines.  */
   YYSTYPE yyval;]b4_locations_if([[
@@ -1471,10 +1541,9 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
       goto yyread_pushed_token;
     }]])[
 
-  yytoken = 0;
-  yyss = yyssa;
-  yyvs = yyvsa;]b4_locations_if([[
-  yyls = yylsa;]])[
+  yyssp = yyss = yyssa;
+  yyvsp = yyvs = yyvsa;]b4_locations_if([[
+  yylsp = yyls = yylsa;]])[
   yystacksize = YYINITDEPTH;]b4_lac_if([[
 
   yyes = yyesa;
@@ -1488,32 +1557,18 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
   yyerrstatus = 0;
   yynerrs = 0;
   yychar = YYEMPTY; /* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.
-     The wasted elements are never initialized.  */
-  yyssp = yyss;
-  yyvsp = yyvs;]b4_locations_if([[
-  yylsp = yyls;
-
-#if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
-  /* Initialize the default location before parsing starts.  */
-  yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
-  yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
-#endif]])
-m4_ifdef([b4_initial_action],[
-m4_pushdef([b4_at_dollar],     [m4_define([b4_at_dollar_used])yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
+]m4_ifdef([b4_initial_action], [
+b4_dollar_pushdef([m4_define([b4_dollar_dollar_used])yylval], [],
+               [m4_define([b4_at_dollar_used])dnl
+b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])])dnl
 /* User initialization code.  */
 b4_user_initial_action
-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
+b4_dollar_popdef[]dnl
 m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
+]])])dnl
+b4_locations_if([[  yylsp[0] = ]b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])[;
 ]])dnl
-m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
-]])[
-  goto yysetstate;
+[  goto yysetstate;
 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
@@ -1533,26 +1588,26 @@ m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
 
 #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;])[
+	/* 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);
+	/* 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
@@ -1560,23 +1615,23 @@ m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
 # 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 */
@@ -1586,10 +1641,10 @@ m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
       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));
@@ -1683,7 +1738,9 @@ yyread_pushed_token:]])[
   YY_LAC_DISCARD ("shift");]])[
 
   yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
 ]b4_locations_if([  *++yylsp = yylloc;])[
   goto yynewstate;
 
@@ -1825,20 +1882,20 @@ yyerrlab:
   if (yyerrstatus == 3)
     {
       /* If just tried and failed to reuse lookahead token after an
-         error, discard it.  */
+	 error, discard it.  */
 
       if (yychar <= YYEOF)
-        {
-          /* Return failure if at end of input.  */
-          if (yychar == YYEOF)
-            YYABORT;
-        }
+	{
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
+	}
       else
-        {
-          yydestruct ("Error: discarding",
-                      yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
-          yychar = YYEMPTY;
-        }
+	{
+	  yydestruct ("Error: discarding",
+		      yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
+	  yychar = YYEMPTY;
+	}
     }
 
   /* Else will try to reuse lookahead token after shifting the error
@@ -1871,29 +1928,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);
@@ -1903,7 +1960,9 @@ yyerrlab1:
      current lookahead token, the shift below will for sure.  */
   YY_LAC_DISCARD ("error recovery");]])[
 
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
 ]b4_locations_if([[
   yyerror_range[2] = yylloc;
   /* Using YYLLOC is tempting, but would change the location of
@@ -1958,7 +2017,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
@@ -1978,12 +2037,13 @@ yypushreturn:]])[
   return YYID (yyresult);
 }
 
+
 ]b4_epilogue[]dnl
 b4_defines_if(
 [@output(b4_spec_defines_file@)@
-b4_copyright([Bison interface for Yacc-like parsers in C])[
+b4_copyright([Bison interface for Yacc-like parsers in C],
+             [1984, 1989-1990, 2000-2012])[
 
 ]b4_shared_declarations[
 ]])dnl b4_defines_if
 m4_divert_pop(0)
-m4_popdef([b4_copyright_years])

djgpp/local.mk

@@ -1,27 +0,0 @@
-## Copyright (C) 2008-2012 Free Software Foundation, Inc.
-
-## This program is free software: you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation, either version 3 of the License, or
-## (at your option) any later version.
-##
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-EXTRA_DIST +=					\
-  djgpp/Makefile.maint				\
-  djgpp/README.in				\
-  djgpp/config.bat				\
-  djgpp/config.sed				\
-  djgpp/config.site				\
-  djgpp/config_h.sed				\
-  djgpp/djunpack.bat				\
-  djgpp/fnchange.lst				\
-  djgpp/subpipe.c				\
-  djgpp/subpipe.h				\
-  djgpp/testsuite.sed

doc/.gitignore

@@ -1,14 +1,15 @@
-/*.info*
 /*~
 /.dirstamp
+/Makefile
+/Makefile.in
 /bison.1
 /bison.aux
 /bison.cp
 /bison.cps
 /bison.dvi
 /bison.fn
-/bison.help
 /bison.html
+/bison.info
 /bison.ky
 /bison.log
 /bison.pdf

doc/Makefile.am

@@ -0,0 +1,124 @@
+## Process this file with automake to produce Makefile.in -*-Makefile-*-
+
+## Copyright (C) 2001-2003, 2005-2012 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+AM_MAKEINFOFLAGS = --no-split
+info_TEXINFOS = bison.texi
+bison_TEXINFOS = $(srcdir)/cross-options.texi gpl-3.0.texi fdl.texi
+
+CLEANFILES = bison.fns
+CLEANDIRS = *.t2d
+clean-local:
+	rm -rf $(CLEANDIRS)
+
+CROSS_OPTIONS_PL = $(top_srcdir)/build-aux/cross-options.pl
+$(srcdir)/cross-options.texi: $(top_srcdir)/src/getargs.c $(CROSS_OPTIONS_PL)
+	$(AM_V_GEN)mv -f $@ $@~ || : >$@~
+	$(AM_V_at)rm -f $@.tmp
+	$(AM_V_at)cd $(top_builddir)/src && $(MAKE) $(AM_MAKEFLAGS) bison
+	$(AM_V_at)$(top_builddir)/src/bison --help \
+	  | $(PERL) $(CROSS_OPTIONS_PL) $(top_srcdir)/src/scan-gram.l >$@.tmp
+	$(AM_V_at)diff -u $@~ $@.tmp || true
+	$(AM_V_at)mv $@.tmp $@
+MAINTAINERCLEANFILES = $(srcdir)/cross-options.texi
+
+## ---------- ##
+## Ref card.  ##
+## ---------- ##
+
+EXTRA_DIST = refcard.tex
+CLEANFILES += refcard.dvi refcard.log refcard.ps
+
+refcard.dvi: refcard.tex
+	$(AM_V_GEN)tex refcard.tex
+
+refcard.ps: refcard.dvi
+
+
+## ----------- ##
+## Man Pages.  ##
+## ----------- ##
+
+dist_man_MANS = $(srcdir)/bison.1
+
+EXTRA_DIST += $(dist_man_MANS:.1=.x) common.x
+MAINTAINERCLEANFILES += $(dist_man_MANS)
+
+# Depend on configure to get version number changes.
+common_dep = $(top_srcdir)/configure $(srcdir)/common.x
+srcsrcdir = $(top_srcdir)/bin
+$(srcdir)/bison.1:      $(common_dep) $(top_srcdir)/src/getargs.c
+
+# Differences to ignore when comparing the man page (the date).
+remove_time_stamp = \
+  sed 's/^\(\.TH[^"]*"[^"]*"[^"]*\)"[^"]*"/\1/'
+
+MOSTLYCLEANFILES = $(srcdir)/*.t
+
+SUFFIXES = .x .1
+
+PREPATH = $(top_builddir)/src
+.x.1:
+	$(AM_V_GEN)program=`expr "/$*" : '.*/\(.*\)'` &&		\
+	save_IFS=$IFS;							\
+	IFS=$(PATH_SEPARATOR);						\
+	for dir in $(PREPATH); do					\
+	  IFS=$save_IFS;						\
+	  echo cd $$dir '&&' $(MAKE) $(AM_MAKEFLAGS) $$program &&	\
+	  (cd $$dir && $(MAKE) $(AM_MAKEFLAGS) $$program) || exit;	\
+	done
+	$(AM_V_at)PATH="$(PREPATH)$(PATH_SEPARATOR)$$PATH";		     \
+	export PATH;							     \
+	$(HELP2MAN)							     \
+	    --include=$*.x						     \
+	    --include=$(srcdir)/common.x				     \
+	    --output=$@.t `echo '$*' | sed 's,.*/,,'`
+	$(AM_V_at)if $(remove_time_stamp) $@ >$@a.t 2>/dev/null &&	     \
+	   $(remove_time_stamp) $@.t | cmp $@a.t - >/dev/null 2>&1; then     \
+		touch $@;						     \
+	else								     \
+		mv $@.t $@;						     \
+	fi
+	$(AM_V_at)rm -f $@*.t
+
+nodist_man_MANS = yacc.1
+
+## -------------- ##
+## Doxygenation.  ##
+## -------------- ##
+
+DOXYGEN = doxygen
+
+.PHONY: doc html
+
+doc: html
+
+html-local: Doxyfile
+	$(DOXYGEN)
+
+edit = sed -e 's,@PACKAGE_NAME\@,$(PACKAGE_NAME),g' \
+	   -e 's,@PACKAGE_VERSION\@,$(PACKAGE_VERSION),g' \
+	   -e 's,@top_builddir\@,$(top_builddir),g' \
+	   -e 's,@top_srcdir\@,$(top_srcdir),g'
+
+EXTRA_DIST += Doxyfile.in
+CLEANFILES += Doxyfile
+# Sed is used to generate Doxyfile from Doxyfile.in instead of
+# configure, because the former is way faster than the latter.
+Doxyfile: $(srcdir)/Doxyfile.in
+	$(AM_V_GEN)$(edit) $(srcdir)/Doxyfile.in >Doxyfile
+
+CLEANDIRS += html latex

doc/bison.x

@@ -39,7 +39,7 @@ This description of the options that can be given to
 is adapted from the node
 .B Invocation
 in the
-.B bison.texi
+.B bison.texinfo
 manual, which should be taken as authoritative.
 .PP
 .I Bison
@@ -53,8 +53,3 @@ are unique.  When a long option takes an argument, like
 .BR \-\-file-prefix ,
 connect the option name and the argument with
 .BR = .
-
-[see also]
-.BR lex (1),
-.BR flex (1),
-.BR yacc (1).

doc/common.x

@@ -0,0 +1,4 @@
+[see also]
+.BR lex (1),
+.BR flex (1),
+.BR yacc (1).

doc/local.mk

@@ -1,141 +0,0 @@
-## Copyright (C) 2001-2003, 2005-2012 Free Software Foundation, Inc.
-
-## This program is free software: you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation, either version 3 of the License, or
-## (at your option) any later version.
-##
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-AM_MAKEINFOFLAGS = --no-split
-info_TEXINFOS = doc/bison.texi
-doc_bison_TEXINFOS =                            \
-  $(CROSS_OPTIONS_TEXI)                         \
-  doc/fdl.texi                                  \
-  doc/gpl-3.0.texi
-
-TEXI2DVI = texi2dvi --build-dir=doc/bison.t2d
-CLEANDIRS = doc/bison.t2d
-clean-local:
-	rm -rf $(CLEANDIRS)
-
-MOSTLYCLEANFILES += $(top_srcdir)/doc/*.t
-
-CROSS_OPTIONS_PL = $(top_srcdir)/build-aux/cross-options.pl
-CROSS_OPTIONS_TEXI = $(top_srcdir)/doc/cross-options.texi
-$(CROSS_OPTIONS_TEXI): doc/bison.help $(CROSS_OPTIONS_PL)
-# Create $@~ which is the previous contents.  Don't use `mv' here so
-# that even if we are interrupted, the file is still available for
-# diff in the next run.  Note that $@ might not exist yet.
-	$(AM_V_GEN){ test ! -f $@ || cat $@; } >$@~
-	$(AM_V_at)test ! -f $@.tmp || rm -f $@.tmp
-	$(AM_V_at)src/bison$(EXEEXT) --help |				 \
-	  $(PERL) $(CROSS_OPTIONS_PL) $(top_srcdir)/src/scan-gram.l >$@.tmp
-	$(AM_V_at)diff -u $@~ $@.tmp || true
-	$(AM_V_at)mv $@.tmp $@
-MAINTAINERCLEANFILES = $(CROSS_OPTIONS_TEXI)
-
-## ---------- ##
-## Ref card.  ##
-## ---------- ##
-
-EXTRA_DIST += doc/refcard.tex
-CLEANFILES += doc/refcard.pdf
-
-doc/refcard.pdf: doc/refcard.tex
-	$(AM_V_GEN) cd doc && pdftex $(abs_top_srcdir)/doc/refcard.tex
-
-
-
-## ---------------- ##
-## doc/bison.help.  ##
-## ---------------- ##
-
-# Some of our targets (cross-option.texi, bison.1) use "bison --help".
-# Since we want to ship the generated file to avoid additional
-# requirements over the user environment, we used not depend on
-# src/bison itself, but on src/getargs.c and other files.  Yet, we
-# need "bison --help" to work to make help2man happy, so we used to
-# include "make src/bison" in the commands.  Then we may have a
-# problem with concurrent builds, since one make might be aiming one
-# of its jobs at compiling src/bison, and another job at generating
-# the man page.  If the latter is faster than the former, then we have
-# two makes that concurrently try to compile src/bison.  Doomed to
-# failure.
-#
-# As a simple scheme to get our way out, make a stamp file,
-# bison.help, which contains --version then --help.  This file can
-# depend on bison, which ensures its correctness.  But update it
-# *only* if needed (content changes).  This way, we avoid useless
-# compilations of cross-option.texi and bison.1.  At the cost of
-# repeated builds of bison.help.
-
-EXTRA_DIST += $(top_srcdir)/doc/bison.help
-MAINTAINERCLEANFILES += $(top_srcdir)/doc/bison.help
-$(top_srcdir)/doc/bison.help: src/bison$(EXEEXT)
-	$(AM_V_GEN)src/bison$(EXEEXT) --version >doc/bison.help.tmp
-	$(AM_V_at) src/bison$(EXEEXT) --help   >>doc/bison.help.tmp
-	$(AM_V_at)$(top_srcdir)/build-aux/move-if-change doc/bison.help.tmp $@
-
-
-## ----------- ##
-## Man Pages.  ##
-## ----------- ##
-
-dist_man_MANS = $(top_srcdir)/doc/bison.1
-
-EXTRA_DIST += $(dist_man_MANS:.1=.x)
-MAINTAINERCLEANFILES += $(dist_man_MANS)
-
-# Differences to ignore when comparing the man page (the date).
-remove_time_stamp = \
-  sed 's/^\(\.TH[^"]*"[^"]*"[^"]*\)"[^"]*"/\1/'
-
-# Depend on configure to get version number changes.
-$(top_srcdir)/doc/bison.1: doc/bison.help doc/bison.x $(top_srcdir)/configure
-	$(AM_V_GEN)$(HELP2MAN)			\
-	    --include=$(top_srcdir)/doc/bison.x	\
-	    --output=$@.t src/bison$(EXEEXT)
-	$(AM_V_at)if $(remove_time_stamp) $@ >$@a.t 2>/dev/null &&	 \
-	   $(remove_time_stamp) $@.t | cmp $@a.t - >/dev/null 2>&1; then \
-	  touch $@;							 \
-	else								 \
-	  mv $@.t $@;							 \
-	fi
-	$(AM_V_at)rm -f $@*.t
-
-nodist_man_MANS = doc/yacc.1
-
-## -------------- ##
-## Doxygenation.  ##
-## -------------- ##
-
-DOXYGEN = doxygen
-
-.PHONY: doc html
-
-doc: html
-
-html-local: doc/Doxyfile
-	$(AM_V_GEN) $(DOXYGEN) doc/Doxyfile
-
-edit = sed -e 's,@PACKAGE_NAME\@,$(PACKAGE_NAME),g' \
-	   -e 's,@PACKAGE_VERSION\@,$(PACKAGE_VERSION),g' \
-	   -e 's,@PERL\@,$(PERL),g' \
-	   -e 's,@top_builddir\@,$(top_builddir),g' \
-	   -e 's,@top_srcdir\@,$(top_srcdir),g'
-
-EXTRA_DIST += doc/Doxyfile.in
-CLEANFILES += doc/Doxyfile
-# Sed is used to generate Doxyfile from Doxyfile.in instead of
-# configure, because the former is way faster than the latter.
-doc/Doxyfile: $(top_srcdir)/doc/Doxyfile.in
-	$(AM_V_GEN) $(edit) $(top_srcdir)/doc/Doxyfile.in >doc/Doxyfile
-
-CLEANDIRS += doc/html

etc/.gitignore

@@ -1 +1,3 @@
+/Makefile
+/Makefile.in
 /bench.pl

etc/Makefile.am

@@ -1,7 +1,5 @@
-#! /bin/sh
+## Copyright (C) 2006, 2009-2012 Free Software Foundation, Inc.
 
-# Copyright (C) 2005-2012 Free Software Foundation, Inc.
-#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -15,13 +13,4 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-cat >input <<EOF
-1+2*3
-EOF
-run 0 7
-
-cat >input <<EOF
-(1+2) * 3
-EOF
-run 0 9
-run 0 9 -p
+nodist_noinst_SCRIPTS = bench.pl

etc/bench.pl.in

@@ -17,235 +17,23 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-=head1 NAME
-
-bench.pl - bench marks for Bison parsers.
-
-=head1 SYNOPSIS
-
-  ./bench.pl [OPTIONS]... DIRECTIVES
-
-=head1 DIRECTIVES
-
-Specify the set of benches to run.  The following grammar defines the
-I<directives>:
-
-   directives ::=
-       directives | directives  -- Alternation
-     | directives & directives  -- Concatenation
-     | [ directives> ]          -- Optional
-     | ( directives> )          -- Parentheses
-     | #d NAME[=VALUE]          -- %code { #define NAME [VALUE] }
-     | %d NAME[=VALUE]          -- %define NAME ["VALUE"]
-     | %s skeleton              -- %skeleton "skeleton"
-     | directive
-
-Parentheses only group to override precedence.  For instance:
-
-  [ %debug ] & [ %error-verbose ] & [ %define variant ]
-
-will generate eight different cases.
-
-=head1 OPTIONS
-
-=over 4
-
-=item B<-b>, B<--bench>
-
-Predefined benches, that is, combimation between a grammar and a I<directives>
-request.
-
-=over 4
-
-=item I<push>
-
-Test the push parser vs. the pull interface.  Use the C parser.
-
-=item I<variant>
-
-Test the use of variants instead of union in the C++ parser.
-
-=back
-
-=item B<-c>, B<--cflags>=I<flags>
-
-Flags to pass to the C or C++ compiler.  Defaults to -O2.
-
-=item B<-d>, B<--directive>=I<directives>
-
-Add a set of Bison directives to bench against each other.
-
-=item B<-g>, B<--grammar>=I<grammar>
-
-Select the base I<grammar> to use.  Defaults to I<calc>.
-
-=over 4
-
-=item I<calc>
-
-Traditional calculator.
-
-=item I<list>
-
-C++ grammar that uses std::string and std::list.  Can be used with
-or without %define variant.
-
-=item I<triangular>
-
-Artificial grammar with very long rules.
-
-=back
-
-=item B<-h>, B<--help>
-
-Display this message and exit succesfully.  The more verbose, the more
-details.
-
-=item B<-i>, B<--iterations>=I<integer>
-
-Say how many times a single test of the bench must be run.  If
-negative, specify the minimum number of CPU seconds to run.  Defaults
-to -1.
-
-=item B<-q>, B<--quiet>
-
-Decrease the verbosity level (defaults to 1).
-
-=item B<-v>, B<--verbose>
-
-Raise the verbosity level (defaults to 1).
-
-=back
-
-=cut
-
-use strict;
 use IO::File;
+use Benchmark qw (:all);
+
+my $bison = $ENV{'BISON'} || '@abs_top_builddir@/tests/bison';
+my $cc = $ENV{'CC'} || 'gcc';
 
 ##################################################################
 
-=head1 VARIABLES
-
-=over 4
-
-=item C<@bench>
-
-The list of benches to run.
-
-=item C<$bison>
-
-The Bison program to use to compile the grammar.
-
-=item C<$cc>
-
-The C compiler.
-
-=item C<$cxx>
-
-The C++ compiler.
-
-=item C<$cflags>
-
-Compiler flags (C or C++).
-
-=item C<@directive>
-
-A list of directive sets to measure against each other.
-
-=item C<$iterations>
-
-The number of times the parser is run for a bench.
-
-=item C<$verbose>
-
-Verbosity level.
-
-=back
-
-=cut
-
-my $bench;
-my $bison = $ENV{'BISON'} || '@abs_top_builddir@/tests/bison';
-my $cc = $ENV{'CC'} || 'gcc';
-my $cxx = $ENV{'CXX'} || 'g++';
-my $cflags = '-O2';
-my @directive = ();
-my $grammar = 'calc';
-my $iterations = -1;
-my $verbose = 1;
-
-=head1 FUNCTIONS
-
-=over 4
-
-=item C<verbose($level, $message)>
-
-Report the C<$message> is C<$level> E<lt>= C<$verbose>.
-
-=cut
-
-sub verbose($$)
+sub triangular_grammar ($$$)
 {
-  my ($level, $message) = @_;
-  print STDERR $message
-    if $level <= $verbose;
-}
-
-
-######################################################################
-
-=item C<directives($bench, @directive)>
-
-Format the list of directives for Bison for bench named C<$bench>.
-
-=cut
-
-sub directives($@)
-{
-  my ($bench, @directive) = @_;
-  my $res = "/* Directives for bench `$bench'. */\n";
-  $res .= join ("\n", @directive) . "\n";
-  $res .= "/* End of directives for bench `$bench'. */\n";
-  return $res;
-}
-
-######################################################################
-
-=item C<generate_grammar_triangular ($base, $max, @directive)>
-
-Create a large triangular grammar which looks like :
-
-  input:
-    exp        { if ($1 != 0) abort (); $$ = $1; }
-  | input exp  { if ($2 != $1 + 1) abort (); $$ = $2; }
-  ;
-
-  exp:
-    END                         { $$ = 0; }
-  | "1"  END                    { $$ = 1; }
-  | "1" "2"  END                { $$ = 2; }
-  | "1" "2" "3"  END            { $$ = 3; }
-  | "1" "2" "3" "4"  END        { $$ = 4; }
-  | "1" "2" "3" "4" "5"  END    { $$ = 5; }
-  ;
-
-C<$base> is the base name for the file to create (F<$base.y>).
-C<$max> is the number of such rules (here, 5).  You may pass
-additional Bison C<@directive>.
-
-The created parser is self contained: it includes its scanner, and
-source of input.
-=cut
-
-sub generate_grammar_triangular ($$@)
-{
-  my ($base, $max, @directive) = @_;
-  my $directives = directives ($base, @directive);
+  my ($base, $max, $directives) = @_;
 
   my $out = new IO::File ">$base.y"
     or die;
   print $out <<EOF;
 %error-verbose
+%debug
 %{
 #include <stdio.h>
 #include <stdlib.h>
@@ -253,7 +41,6 @@ sub generate_grammar_triangular ($$@)
 static int yylex (void);
 static void yyerror (const char *msg);
 %}
-$directives
 %union
 {
   int val;
@@ -284,8 +71,8 @@ for my $size (1 .. $max)
   {
     use Text::Wrap;
     print $out wrap ("| ", "   ",
-                     (map { "\"$_\"" } (1 .. $size)),
-                     " END \n"),
+		     (map { "\"$_\"" } (1 .. $size)),
+		     " END \n"),
                "    { \$\$ = $size; }\n";
   };
 print $out ";\n";
@@ -317,9 +104,7 @@ yyerror (const char *msg)
 int
 main (void)
 {
-#if YYDEBUG
   yydebug = !!getenv ("YYDEBUG");
-#endif
   return yyparse ();
 }
 EOF
@@ -327,15 +112,6 @@ EOF
 
 ##################################################################
 
-=item C<calc_input ($base, $max)>
-
-Generate the input file F<$base.input> for the calc parser.  The input
-is composed of two expressions.  The first one is using left recursion
-only and consumes no stack.  The second one requires a deep stack.
-These two expressions are repeated C<$max> times in the output file.
-
-=cut
-
 sub calc_input ($$)
 {
   my ($base, $max) = @_;
@@ -350,22 +126,9 @@ sub calc_input ($$)
 
 ##################################################################
 
-=item C<generate_grammar_calc ($base, $max, @directive)>
-
-Generate a Bison file F<$base.y> for a calculator parser in C.  Pass
-the additional Bison C<@directive>.  C<$max> is ignored, but left to
-have the same interface as C<triangular_grammar>.
-
-=cut
-
-sub generate_grammar_calc ($$@)
+sub calc_grammar ($$$)
 {
-  my ($base, $max, @directive) = @_;
-  my $directives = directives ($base, @directive);
-
-  # Putting this request here is stupid, since the input will be
-  # generated each time we generate a grammar.
-  calc_input ('calc', 200);
+  my ($base, $max, $directives) = @_;
 
   my $out = new IO::File ">$base.y"
     or die;
@@ -385,9 +148,9 @@ static semantic_value global_result = 0;
 static int global_count = 0;
 %}
 
+/* Exercise %union. */
 $directives
 %error-verbose
-/* Exercise %union. */
 %union
 {
   semantic_value ival;
@@ -411,7 +174,7 @@ static int yylex (void);
 %token <ival> NUM "number"
 %type  <ival> exp
 
-%nonassoc '=' /* comparison            */
+%nonassoc '=' /* comparison	       */
 %left '-' '+'
 %left '*' '/'
 %left NEG     /* negation--unary minus */
@@ -543,10 +306,6 @@ main (int argc, const char **argv)
   int count = 0;
   int status;
 
-#if YYDEBUG
-  yydebug = !!getenv ("YYDEBUG");
-#endif
-
   input = fopen ("calc.input", "r");
   if (!input)
     {
@@ -567,560 +326,44 @@ EOF
 
 ##################################################################
 
-=item C<generate_grammar_list ($base, $max, @directive)>
-
-Generate a Bison file F<$base.y> for a C++ parser that uses C++
-objects (std::string, std::list).  Tailored for using %define variant.
-
-=cut
-
-sub generate_grammar_list ($$@)
-{
-  my ($base, $max, @directive) = @_;
-  my $directives = directives ($base, @directive);
-  my $variant = grep { /%define "?variant"?/ } @directive;
-  my $lex_symbol = grep { /%define "?lex_symbol"?/ } @directive;
-  my $out = new IO::File ">$base.y"
-    or die;
-  print $out <<EOF;
-%language "C++"
-%defines
-%locations
-$directives
-
-%code requires // *.h
-{
-#include <string>
-}
-
-%code // *.c
-{
-#include <algorithm>
-#include <iostream>
-#include <sstream>
-
-#define STAGE_MAX    ($max * 10) // max = $max
-
-#define USE_LEX_SYMBOL $lex_symbol
-#define USE_VARIANTS $variant
-
-  // Prototype of the yylex function providing subsequent tokens.
-  static
-#if USE_LEX_SYMBOL
-  yy::parser::symbol_type yylex();
-#else
-  yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
-                               yy::parser::location_type* yylloc);
-#endif
-
-  // Conversion to string.
-  template <typename T>
-    inline
-    std::string
-    string_cast (const T& t)
-  {
-    std::ostringstream o;
-    o << t;
-    return o.str ();
-  }
-}
-
-%token END_OF_FILE 0
-EOF
-
-  if ($variant)
-    {
-      print $out <<'EOF';
-%token <std::string> TEXT
-%token <int> NUMBER
-%printer { std::cerr << "Number: " << $$; } <int>
-%printer { std::cerr << "Text: " << $$; } <std::string>
-%type <std::string> text result
-
-%%
-result:
-  text                  { /* Throw away the result. */ }
-;
-
-text:
-  /* nothing */         { /* This will generate an empty string */ }
-| text TEXT             { std::swap ($$, $2); }
-| text NUMBER           { $$ = string_cast($2); }
-;
-EOF
-    }
-  else
-    {
-      # Not using Bison variants.
-      print $out <<'EOF';
-%union {int ival; std::string* sval;}
-%token <sval> TEXT
-%token <ival> NUMBER
-%printer { std::cerr << "Number: " << $$; } <ival>
-%printer { std::cerr << "Text: " << *$$; } <sval>
-%type <sval> text result
-
-%%
-result:
-  text                  { delete $1; }
-;
-
-text:
-  /* nothing */         { $$ = new std::string; }
-| text TEXT             { delete $1; $$ = $2; }
-| text NUMBER           { delete $1; $$ = new std::string (string_cast ($2)); }
-;
-EOF
-    }
-
-  print $out <<'EOF';
-%%
-#
-
-static
-#if USE_LEX_SYMBOL
-yy::parser::symbol_type yylex()
-#else
-yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
-                             yy::parser::location_type* yylloc)
-#endif
-{
-  typedef yy::parser::location_type location_type;
-  typedef yy::parser::token token;
-  static int stage = -1;
-  ++stage;
-  if (stage == STAGE_MAX)
-    {
-#if USE_LEX_SYMBOL
-      return yy::parser::make_END_OF_FILE (location_type ());
-#else
-      *yylloc = location_type ();
-      return token::END_OF_FILE;
-#endif
-    }
-  else if (stage % 2)
-    {
-#if USE_LEX_SYMBOL
-      return yy::parser::make_NUMBER (stage, location_type ());
-#else
-# if defined ONE_STAGE_BUILD
-      yylval->build(stage);
-# elif USE_VARIANTS
-      yylval->build<int>() = stage;
-# else
-      yylval->ival = stage;
-# endif
-      *yylloc = location_type ();
-      return token::NUMBER;
-#endif
-    }
-  else
-    {
-#if USE_LEX_SYMBOL
-      return yy::parser::make_TEXT ("A string.", location_type ());
-#else
-# if defined ONE_STAGE_BUILD
-      yylval->build(std::string("A string."));
-# elif USE_VARIANTS
-      yylval->build<std::string>() = std::string("A string.");
-# else
-      yylval->sval = new std::string("A string.");
-# endif
-      *yylloc = location_type ();
-      return token::TEXT;
-#endif
-    }
-  abort();
-}
-
-// Mandatory error function
-void
-yy::parser::error(const yy::parser::location_type& loc, const std::string& msg)
-{
-  std::cerr << loc << ": " << msg << std::endl;
-}
-
-int main(int argc, char *argv[])
-{
-  yy::parser p;
-#if YYDEBUG
-  p.set_debug_level(!!getenv("YYDEBUG"));
-#endif
-  p.parse();
-  return 0;
-}
-EOF
-}
-
-##################################################################
-
-=item C<generate_grammar ($name, $base, @directive)>
-
-Generate F<$base.y> by calling C<&generate_grammar_$name>.
-
-=cut
-
-sub generate_grammar ($$@)
-{
-  my ($name, $base, @directive) = @_;
-  verbose 3, "Generating $base.y\n";
-  my %generator =
-    (
-      "calc"       => \&generate_grammar_calc,
-      "list"       => \&generate_grammar_list,
-      "triangular" => \&generate_grammar_triangular,
-    );
-  &{$generator{$name}}($base, 200, @directive);
-}
-
-##################################################################
-
-=item C<run ($command)>
-
-Run, possibly verbosely, the shell C<$command>.
-
-=cut
-
-sub run ($)
-{
-  my ($command) = @_;
-  verbose 3, "$command\n";
-  system ("$command") == 0
-    or die "$command failed";
-}
-
-##################################################################
-
-=item C<compile ($base)>
-
-Compile C<$base.y> to an executable C, Using the C or C++ compiler
-depending on the %language specification in C<$base.y>.
-
-=cut
-
 sub compile ($)
 {
   my ($base) = @_;
-  my $language = `sed -ne '/%language "\\(.*\\)"/{s//\\1/;p;q;}' $base.y`;
-  chomp $language;
-
-  my $compiler = $language eq 'C++' ? $cxx : $cc;
-
-  run "$bison $base.y -o $base.c";
-  run "$compiler -o $base $cflags $base.c";
+  system ("$bison $base.y -o $base.c") == 0
+    or die;
+  system ("$cc -o $base $base.c") == 0
+    or die;
 }
 
-######################################################################
-
-=item C<bench ($grammar, @token)>
-
-Generate benches for the C<$grammar> and the directive specification
-given in the list of C<@token>.
-
-=cut
-
-sub bench ($@)
+sub bench_grammar ($)
 {
-  my ($grammar, @token) = @_;
-  use Benchmark qw (:all :hireswallclock);
+  my ($gram) = @_;
+  my %test =
+    (
+     "pull-impure" => '',
+     "pull-pure" => '%define api.pure',
+     "push-impure" => '%define api.push-pull "both"',
+     "push-pure" => '%define api.push-pull "both" %define api.pure',
+    );
 
-  my @directive = parse (@token);
-
-  # Set up the benches as expected by timethese.
   my %bench;
-  # A counter of directive sets.
-  my $count = 1;
-  for my $d (@directive)
+  while (my ($name, $directives) = each %test)
     {
-      $bench{$count} = $d;
-      printf " %2d. %s\n", $count, join (' ', split ("\n", $d));
-      $count++;
-    };
-
-  # For each bench, capture the size.
-  my %size;
-
-  while (my ($name, $directives) = each %bench)
-    {
-      generate_grammar ($grammar, $name, $directives);
-      # Compile the executable.
+      print STDERR "$name\n";
+      my $generator = "$gram" . "_grammar";
+      &$generator ($name, 200, $directives);
       compile ($name);
       $bench{$name} = "system ('./$name');";
-      chop($size{$name} = `wc -c <$name`);
     }
 
-  # Run the benches.
-  #
-  # STYLE can be any of 'all', 'none', 'noc', 'nop' or 'auto'.  'all'
-  # shows each of the 5 times available ('wallclock' time, user time,
-  # system time, user time of children, and system time of
-  # children). 'noc' shows all except the two children times. 'nop'
-  # shows only wallclock and the two children times.  'auto' (the
-  # default) will act as 'all' unless the children times are both
-  # zero, in which case it acts as 'noc'.  'none' prevents output.
-  verbose 3, "Running the benches for $grammar\n";
-  my $res = timethese ($iterations, \%bench, 'nop');
-
-  # Output the speed result.
+  print "$gram:\n";
+  my $res = timethese (50, \%bench, 'nop');
   cmpthese ($res, 'nop');
-
-  # Display the sizes.
-  print "Sizes (decreasing):\n";
-  my $width = 10;
-  for my $bench (keys %size)
-    {
-      $width = length $bench
-        if $width < length $bench;
-    }
-  # Benches sorted by decreasing size.
-  my @benches_per_size = sort {$size{$b} <=> $size{$a}} keys %size;
-  for my $bench (@benches_per_size)
-    {
-      printf "%${width}s: %5.2fkB\n", $bench, $size{$bench} / 1024;
-    }
 }
 
-######################################################################
-
-=item C<bench_push_parser ()>
-
-Bench the C push parser against the pull parser, pure and impure
-interfaces.
-
-=cut
-
-sub bench_push_parser ()
-{
-  bench ('calc',
-         qw(
-            [ %d api.pure ]
-            &
-            [ %d api.push-pull=both ]
-         ));
-}
-
-######################################################################
-
-=item C<bench_variant_parser ()>
-
-Bench the C++ lalr1.cc parser using variants or %union.
-
-=cut
-
-sub bench_variant_parser ()
-{
-  bench ('list',
-         qw(
-            [
-              %d variant
-              &
-              [ #d ONE_STAGE_BUILD | %d lex_symbol ]
-            ]
-         )
-    );
-}
-
-############################################################################
-
-sub help ($)
-{
-  my ($verbose) = @_;
-  use Pod::Usage;
-  # See <URL:http://perldoc.perl.org/pod2man.html#NOTES>.
-  pod2usage( { -message => "Bench Bison parsers",
-               -exitval => 0,
-               -verbose => $verbose,
-               -output  => \*STDOUT });
-}
-
-######################################################################
-
-# The end of the directives to parse.
-my $eod = "end of directives";
-# The list of tokens parsed by the following functions.
-my @token;
-
-# eat ($EXPECTED)
-# ---------------
-# Check that the current token is $EXPECTED, and move to the next.
-sub eat ($)
-{
-  my ($expected) = @_;
-  die "expected $expected, unexpected: $token[0] (@token)\n"
-    unless $token[0] eq $expected;
-  shift @token;
-}
-
-# Parse directive specifications:
-#   expr: term (| term)*
-#   term: fact (& fact)*
-#   fact: ( expr ) | [ expr ] | dirs
-#   dirs: %s SKELETON | #d NAME[=VALUE] | %d NAME[=VALUE] | directive
-sub parse (@)
-{
-  @token = (@_, $eod);
-  verbose 3, "Parsing: @token\n";
-  my @res = parse_expr ();
-  eat ($eod);
-  return @res;
-}
-
-sub parse_expr ()
-{
-  my @res = parse_term ();
-  while ($token[0] eq '|')
-    {
-      eat ('|');
-      # Alternation.
-      push @res, parse_term ();
-    }
-  return @res;
-}
-
-sub parse_term ()
-{
-  my @res = parse_fact ();
-  while ($token[0] eq '&')
-    {
-      eat ('&');
-      # Cartesian product.
-      my @lhs = @res;
-      @res = ();
-      for my $rhs (parse_fact ())
-        {
-          for my $lhs (@lhs)
-            {
-              push @res, $lhs . ($lhs && $rhs ? "\n" : "") . $rhs;
-            }
-        }
-    }
-  return @res;
-}
-
-sub parse_fact ()
-{
-  my @res;
-  die "unexpected end of expression"
-    unless defined $token[0];
-
-  if ($token[0] eq '(')
-    {
-      eat ('(');
-      @res = parse_expr ();
-      eat (')');
-    }
-  elsif ($token[0] eq '[')
-    {
-      eat ('[');
-      @res = (parse_expr (), '');
-      eat (']');
-    }
-  else
-    {
-      @res = parse_dirs ();
-    }
-  return @res;
-}
-
-sub parse_dirs ()
-{
-  my @res;
-  die "unexpected end of expression"
-    unless defined $token[0];
-
-  if ($token[0] eq '#d')
-    {
-      eat ('#d');
-      $token[0] =~ s/(.*?)=(.*)/$1 $2/;
-      @res = ("%code {\n#define $token[0]\n}");
-      shift @token;
-    }
-  elsif ($token[0] eq '%d')
-    {
-      shift @token;
-      $token[0] =~ s/(.*?)=(.*)/$1 "$2"/;
-      @res = ("%define $token[0]");
-      shift @token;
-    }
-  elsif ($token[0] eq '%s')
-    {
-      shift @token;
-      @res = ("%skeleton \"$token[0]\"");
-      shift @token;
-    }
-  else
-    {
-      @res = $token[0];
-      shift @token;
-    }
-
-  return @res;
-}
-
-######################################################################
-
-sub getopt ()
-{
-  use Getopt::Long;
-  my %option = (
-    "b|bench=s"      => \$bench,
-    "c|cflags=s"     => \$cflags,
-    "d|directive=s"  => \@directive,
-    "g|grammar=s"    => \$grammar,
-    "h|help"         => sub { help ($verbose) },
-    "i|iterations=i" => \$iterations,
-    "q|quiet"        => sub { --$verbose },
-    "v|verbose"      => sub { ++$verbose },
-    );
-  Getopt::Long::Configure ("bundling", "pass_through");
-  GetOptions (%option)
-    or exit 1;
-}
-
-######################################################################
-
-getopt;
-
-# Create the directory we work in.
-mkdir "benches" or die "cannot create benches"
-  unless -d "benches";
-my $count = 1;
-++$count
-  while -d "benches/$count";
-my $dir = "benches/$count";
-mkdir $dir
-  or die "cannot create $dir";
-chdir $dir
-  or die "cannot chdir $dir";
-
-# The following message is tailored to please Emacs' compilation-mode.
-verbose 1, "Entering directory `$dir'\n";
-verbose 1, "Using bison=$bison.\n";
-verbose 2, "Using cc=$cc.\n";
-verbose 2, "Using cxx=$cxx.\n";
-verbose 2, "Using cflags=$cflags.\n";
-verbose 2, "Grammar: $grammar\n";
-
-
-# Support -b: predefined benches.
-my %bench =
-  (
-   "push"     => \&bench_push_parser,
-   "variant"  => \&bench_variant_parser,
-  );
-
-if (defined $bench)
-{
-  die "invalid argument for --bench: $bench"
-    unless defined $bench{$bench};
-  &{$bench{$bench}}();
-  exit 0;
-}
-else
-{
-  # Launch the bench marking.
-  bench ($grammar, @ARGV);
-}
+print STDERR "Using $bison, $cc.\n";
+calc_input ('calc', 200);
+bench_grammar ('calc');
 
 ### Setup "GNU" style for perl-mode and cperl-mode.
 ## Local Variables:

etc/local.mk

@@ -1,16 +0,0 @@
-## Copyright (C) 2006, 2008-2012 Free Software Foundation, Inc.
-
-## This program is free software: you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation, either version 3 of the License, or
-## (at your option) any later version.
-##
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-nodist_noinst_SCRIPTS = etc/bench.pl

etc/prefix-gnulib-mk

@@ -1,220 +0,0 @@
-#! /usr/bin/perl -w
-
-use strict;
-use IO::File;
-use Getopt::Long;
-use File::Basename; # for dirname
-
-my $VERSION = '2012-01-21 17:13'; # UTC
-(my $ME = $0) =~ s|.*/||;
-
-my $prefix;
-my $lib_name;
-
-sub usage ($)
-{
-  my ($exit_code) = @_;
-  my $STREAM = ($exit_code == 0 ? *STDOUT : *STDERR);
-  if ($exit_code != 0)
-    {
-      print $STREAM "Try '$ME --help' for more information.\n";
-    }
-  else
-    {
-      print $STREAM <<EOF;
-Usage: $ME --lib-name=NAME FILE
-   or: $ME [--help|--version]
-Rewrite a gnulib-tool-generated FILE like lib/gnulib.mk to work with
-automake's subdir-objects.
-
-OPTIONS:
-
-This option must be specified:
-
-   --lib-name=NAME    library name, often "lib\$project"
-
-The following are optional:
-
-   --help             display this help and exit
-   --version          output version information and exit
-
-EOF
-    }
-  exit $exit_code;
-}
-
-# contents ($FILE_NAME)
-# ---------------------
-sub contents ($)
-{
-  my ($file) = @_;
-  local $/;                     # Turn on slurp-mode.
-  my $f = new IO::File "< $file" or die "$file";
-  my $contents = $f->getline or die "$file";
-  $f->close;
-  return $contents;
-}
-
-# prefix_word ($WORD)
-# -------------------
-# Do not prefix special words such as variable dereferences.  Also,
-# "Makefile" is really "Makefile", since precisely there is no
-# lib/Makefile.
-sub prefix_word ($)
-{
-  local ($_) = @_;
-  $_ = $prefix . $_
-    unless /^-/ || m{^\$\(\w+\)} || $_ eq "Makefile" || $_ eq '\\';
-  return $_;
-}
-
-
-# prefix_words ($TEXT)
-# --------------------
-sub prefix_words ($)
-{
-  local ($_) = @_;
-  s{(\S+)}{prefix_word($1)}gem;
-  return $_;
-}
-
-
-# prefix_assignment ($LHS-AND-ASSIGN-OP, $RHS)
-# --------------------------------------------
-sub prefix_assignment ($$)
-{
-  my ($lhs_and_assign_op, $rhs) = @_;
-  my $res;
-
-  # Some variables are initialized by gnulib.mk, and we don't want
-  # that.  Change '=' to '+='.
-  if ($lhs_and_assign_op =~ /^(SUBDIRS|EXTRA_DIST|BUILT_SOURCES|SUFFIXES|MOSTLYCLEANFILES|CLEANFILES|DISTCLEANFILES|MAINTAINERCLEANFILES|AM_CFLAGS|AM_CPPFLAGS|AM_GNU_GETTEXT) =/)
-    {
-      $lhs_and_assign_op =~ s/=/+=/;
-    }
-  # We don't want to inherit gnulib's AUTOMAKE_OPTIONS, comment them.
-  elsif ($lhs_and_assign_op =~ /^AUTOMAKE_OPTIONS =/)
-    {
-      $lhs_and_assign_op =~ s/^/# /;
-    }
-  # Don't touch suffixes.
-  elsif ($lhs_and_assign_op =~ /^SUFFIXES /)
-    {
-    }
-  # The words are (probably) paths to files in lib/: prefix them.
-  else
-    {
-      $rhs = prefix_words($rhs)
-    }
-
-  # Variables which name depend on the location: libbison_a_SOURCES =>
-  # lib_libbison_a_SOURCES.
-  $lhs_and_assign_op =~ s/($lib_name)/lib_$1/g;
-
-  return $lhs_and_assign_op . $rhs;
-}
-
-# prefix $CONTENTS
-# ----------------
-# $CONTENTS is a Makefile content.  Post-process it so that each file-name
-# is prefixed with $prefix (e.g., "lib/").
-#
-# Relies heavily on the regularity of the file generated by gnulib-tool.
-sub prefix ($)
-{
-  # Work on $_.
-  local ($_) = @_;
-
-  # Prefix all the occurrence of files in rules.  If there is nothing
-  # after in the :, it's probably a phony target, or a suffix rule.
-  # Don't touch it.
-  s{^([-\w+/]+\.[-\w.]+ *: *\S.*)$}
-   {prefix_words($1)}gem;
-
-  # Prefix files in variables.
-  s{^([\w.]+\s*\+?=)(.*)$}
-   {prefix_assignment($1, $2)}gem;
-
-  # These three guys escape all the other regular rules.
-  s{(charset\.alias|ref-add\.sed|ref-del\.sed)}{$prefix$1}g;
-  # Unfortunately, as a result we sometimes have lib/lib.
-  s{($prefix){2}}{$1}g;
-
-  # $(srcdir) is actually $(top_srcdir)/lib.
-  s{\$\(srcdir\)}{\$(top_srcdir)/lib}g;
-
-  # Sometimes, t-$@ is used instead of $@-t, which, of course, does
-  # not work when we have a $@ with a directory in it.
-  s{t-\$\@}{\$\@-t}g;
-
-  # Some AC_SUBST patterns remain and would better be Make macros.
-  s{\@(MKDIR_P)\@}{\$($1)}g;
-
-  # Adjust paths in mkdir.
-  s{(\$\(MKDIR_P\))\s*(\w+)}{$1 $prefix$2}g;
-
-  return $_;
-}
-
-# process ($IN)
-# -------------
-sub process ($)
-{
-  my ($file) = @_;
-  my ($bak) = "$file.bak";
-  rename ($file, $bak) or die;
-  my $contents = contents ($bak);
-  $contents = prefix ($contents);
-  my $out = new IO::File(">$file") or die;
-  print $out $contents;
-}
-
-{
-  GetOptions
-    (
-     'lib-name=s' => \$lib_name,
-     help => sub { usage 0 },
-     version => sub { print "$ME version $VERSION\n"; exit },
-    ) or usage 1;
-
-  my $fail = 0;
-  defined $lib_name
-    or (warn "$ME: no library name; use --lib-name=NAME\n"), $fail = 1;
-
-  # There must be exactly one argument.
-  @ARGV == 0
-    and (warn "$ME: missing FILE argument\n"), $fail = 1;
-  1 < @ARGV
-    and (warn "$ME: too many arguments:\n", join ("\n", @ARGV), "\n"),
-      $fail = 1;
-  $fail
-    and usage 1;
-
-  my $file = $ARGV[0];
-  $prefix = (dirname $file) . '/';
-  warn "prefix=$prefix\n";
-
-  process $file;
-}
-
-### Setup "GNU" style for perl-mode and cperl-mode.
-## Local Variables:
-## perl-indent-level: 2
-## perl-continued-statement-offset: 2
-## perl-continued-brace-offset: 0
-## perl-brace-offset: 0
-## perl-brace-imaginary-offset: 0
-## perl-label-offset: -2
-## cperl-indent-level: 2
-## cperl-brace-offset: 0
-## cperl-continued-brace-offset: 0
-## cperl-label-offset: -2
-## cperl-extra-newline-before-brace: t
-## cperl-merge-trailing-else: nil
-## cperl-continued-statement-offset: 2
-## eval: (add-hook 'write-file-hooks 'time-stamp)
-## time-stamp-start: "my $VERSION = '"
-## time-stamp-format: "%:y-%02m-%02d %02H:%02M"
-## time-stamp-time-zone: "UTC"
-## time-stamp-end: "'; # UTC"
-## End:

examples/.cvsignore

@@ -0,0 +1,2 @@
+Makefile
+Makefile.in

examples/.gitignore

@@ -0,0 +1,2 @@
+/Makefile
+/Makefile.in

examples/Makefile.am

@@ -1,7 +1,6 @@
-#! /bin/sh
+## Process this file with automake to produce Makefile.in -*-Makefile-*-
+## Copyright (C) 2005, 2009-2012 Free Software Foundation, Inc.
 
-# Copyright (C) 2005-2012 Free Software Foundation, Inc.
-#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -15,32 +14,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-cat >input <<EOF
-1 2 3 * +
-EOF
-run 0 7
+if BISON_CXX_WORKS
+SUBDIRS = calc++
+endif
 
-cat >input <<EOF
-1.1 2.2 3.3 * +
-EOF
-run 0 8.36
-
-cat >input <<EOF
-1 2 + 3 *
-EOF
-run 0 9
-
-cat >input <<EOF
-1 2 3 4 5 6 7 8 9 * * * * * * * *
-EOF
-run 0 362880
-
-cat >input <<EOF
-3 7 + 3 4 5 * + - n
-EOF
-run 0 13
-
-cat >input <<EOF
-3 4 ^
-EOF
-run 0 81
+dist_noinst_SCRIPTS = extexi

examples/calc++/.gitignore

@@ -1,19 +1,13 @@
+/*.cc
+/*.hh
+/*.ll
 /*.o
+/*.output
+/*.stamp
 /*.tmp
+/*.yy
 /.deps
+/Makefile
+/Makefile.in
 /calc++
-/calc++-driver.cc
-/calc++-driver.hh
-/calc++-parser.cc
-/calc++-parser.hh
-/calc++-parser.output
-/calc++-parser.stamp
-/calc++-parser.yy
-/calc++-scanner.cc
-/calc++-scanner.ll
-/calc++.cc
 /calc++.exe
-/calc.stamp
-/location.hh
-/position.hh
-/stack.hh

examples/calc++/Makefile.am

@@ -0,0 +1,93 @@
+## Process this file with automake to produce Makefile.in -*-Makefile-*-
+## Copyright (C) 2005-2006, 2009-2012 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+## ------------------------------------- ##
+## Running the bison from this tarball.  ##
+## ------------------------------------- ##
+
+BISON = $(top_builddir)/tests/bison
+BISON_IN = $(top_srcdir)/tests/bison.in
+
+$(BISON): $(BISON_IN)
+	$(AM_V_GEN)cd $(top_builddir)/tests && $(MAKE) $(AM_MAKEFLAGS) bison
+
+## ------------ ##
+## Extracting.  ##
+## ------------ ##
+
+doc = $(top_srcdir)/doc/bison.texi
+extexi = $(top_srcdir)/examples/extexi
+# Extract in src.
+$(srcdir)/calc.stamp: $(doc) $(extexi)
+	$(AM_V_GEN)rm -f $@ $@.tmp
+	$(AM_V_at)touch $@.tmp
+	$(AM_V_at)cd $(srcdir) && \
+	   $(AWK) -f ../extexi -v VERSION="$(VERSION)" \
+	     ../../doc/bison.texi -- calc++-parser.yy \
+	     calc++-scanner.ll calc++.cc calc++-driver.hh calc++-driver.cc
+	$(AM_V_at)mv $@.tmp $@
+
+$(calc_extracted): $(srcdir)/calc.stamp
+
+## ------------------- ##
+## Parser generation.  ##
+## ------------------- ##
+
+DEFAULT_INCLUDES = -I. -I$(srcdir)
+BUILT_SOURCES = $(calc_extracted) $(calc_sources_generated)
+CLEANFILES = $(srcdir)/*.output *.tmp
+MAINTAINERCLEANFILES = $(srcdir)/*.stamp $(BUILT_SOURCES)
+
+# Compile the parser and save cycles.
+# This code comes from "Handling Tools that Produce Many Outputs",
+# from the Automake documentation.
+EXTRA_DIST =					\
+  $(srcdir)/calc++-parser.stamp			\
+  $(srcdir)/calc++-parser.yy			\
+  $(srcdir)/calc.stamp
+# Don't depend on $(BISON) otherwise we would rebuild these files
+# in srcdir, including during distcheck, which is forbidden.
+$(srcdir)/calc++-parser.stamp: $(srcdir)/calc++-parser.yy $(BISON_IN)
+	$(AM_V_GEN)rm -f calc++-parser.tmp
+	$(AM_V_at)touch calc++-parser.tmp
+	$(AM_V_at)$(BISON) -d -ra -S lalr1.cc -o $(srcdir)/calc++-parser.cc \
+	  $(srcdir)/calc++-parser.yy
+	$(AM_V_at)mv -f calc++-parser.tmp $@
+
+$(calc_sources_generated): $(srcdir)/calc++-parser.stamp
+	$(AM_V_GEN)if test -f $@; then :; else \
+	  rm -f $(srcdir)/calc++-parser.stamp && \
+	  $(MAKE) $(AM_MAKEFLAGS) $(srcdir)/calc++-parser.stamp; \
+	fi
+
+
+## --------------------------- ##
+## Building & testing calc++.  ##
+## --------------------------- ##
+
+check_PROGRAMS = calc++
+
+calc_sources_extracted = $(srcdir)/calc++-scanner.ll $(srcdir)/calc++.cc \
+  $(srcdir)/calc++-driver.hh $(srcdir)/calc++-driver.cc
+calc_extracted = $(calc_sources_extracted) $(srcdir)/calc++-parser.yy
+calc_sources_generated = \
+  $(srcdir)/stack.hh $(srcdir)/position.hh $(srcdir)/location.hh \
+  $(srcdir)/calc++-parser.hh $(srcdir)/calc++-parser.cc
+
+calc___SOURCES = $(calc_sources_extracted) $(calc_sources_generated)
+
+TESTS = test
+EXTRA_DIST += $(TESTS)

examples/calc++/local.mk

@@ -1,73 +0,0 @@
-# Copyright (C) 2005-2006, 2008-2012 Free Software Foundation, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-## ------------------- ##
-## Parser generation.  ##
-## ------------------- ##
-
-# Don't depend on $(BISON) otherwise we would rebuild these files
-# in srcdir, including during distcheck, which is forbidden.
-examples/calc++/calc++-parser.stamp: $(BISON_IN)
-SUFFIXES += .yy .stamp
-.yy.stamp:
-	$(AM_V_YACC)rm -f $@
-	$(AM_V_at)touch $@.tmp
-	$(AM_V_at)$(YACCCOMPILE) -o $*.cc $<
-	$(AM_V_at)mv -f $@.tmp $@
-
-$(calc_sources_generated): examples/calc++/calc++-parser.stamp
-	@test -f $@ || rm -f examples/calc++/calc++-parser.stamp
-	@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) examples/calc++/calc++-parser.stamp
-CLEANFILES +=                                   \
-  $(calc_sources_generated)                     \
-  examples/calc++/calc++-parser.output          \
-  examples/calc++/calc++-parser.stamp           \
-  examples/calc++/calc++-scanner.cc
-
-
-## -------------------- ##
-## Building & testing.  ##
-## -------------------- ##
-
-# Avoid using BUILT_SOURCES which is too global.
-$(examples_calc___calc___OBJECTS): $(calc_sources_generated)
-
-calc_sources_extracted =			\
-  examples/calc++/calc++-driver.cc		\
-  examples/calc++/calc++-driver.hh		\
-  examples/calc++/calc++-scanner.ll		\
-  examples/calc++/calc++.cc
-calc_extracted =				\
-  $(calc_sources_extracted)			\
-  examples/calc++/calc++-parser.yy
-extracted += $(calc_extracted)
-calc_sources_generated =			\
-  examples/calc++/calc++-parser.cc		\
-  examples/calc++/calc++-parser.hh		\
-  examples/calc++/location.hh			\
-  examples/calc++/position.hh			\
-  examples/calc++/stack.hh
-calc_sources =					\
-  $(calc_sources_extracted)			\
-  $(calc_sources_generated)
-
-if BISON_CXX_WORKS
-check_PROGRAMS += examples/calc++/calc++
-nodist_examples_calc___calc___SOURCES =		\
-  $(calc_sources)
-
-examples_calc___calc___CPPFLAGS = -I$(top_builddir)/examples/calc++
-dist_TESTS += examples/calc++/calc++.test
-endif

examples/calc++/test

@@ -15,36 +15,32 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+test -z "$VERBOSE" && {
+   exec > /dev/null 2>&1
+   set -x
+}
+
+cat >input <<EOF
+a := 1
+b := 2
+c := 3
+d := a + b * c
+d
+EOF
+
+./calc++ input
+./calc++ -p input
+
+cat >input <<EOF
+a := 1
+d := a + b * c
+EOF
+./calc++ input
+
 cat >input <<EOF
 toto := 1
 toto
 EOF
-run 0 1 -s
+./calc++ -s input
 
-
-cat >input <<EOF
-a := 1
-b := 2
-c := 3
-d := a + b * c
-d
-EOF
-run 0 7
-run 0 7 -p
-
-
-cat >input <<EOF
-a := 1
-b := 2
-c := 3
-d := (a + b) * c
-d
-EOF
-run 0 9
-
-
-cat >input <<EOF
-a := 1
-d := a + b * c
-EOF
-run 1 ''
+rm input

examples/calc++/y.tab.h

@@ -1,6 +0,0 @@
-// Work around an Automake 1.11.2 bug: it asks for the creation of
-// y.tab.c and y.tab.h and then renames them as calc++-parser.cc and
-// calc++-parser.h, but in the former it does not convert the
-// #include "y.tab.h".  We don't want this to show in the
-// documentation.
-#include "calc++-parser.hh"

examples/extexi

@@ -1,5 +1,4 @@
-#! /usr/bin/perl -w
-# Extract all examples from the manual source.
+# Extract all examples from the manual source.            -*- AWK -*-
 
 # This file is part of GNU Bison
 
@@ -19,154 +18,122 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+# This script is for use with any Awk that conforms to POSIX.
+# It was derived from a similar script tests/generate.awk in GNU m4.
+#
 # Usage: extexi input-file.texi ... -- [FILES to extract]
-
-# Look for @example environments preceded with lines such as:
-#
-#      @comment file calc.y
-# or
-#      @comment file calc.y: 3
-#
-# and output their content in that file (calc.y).  When numbers are
-# provided, use them to decide the output order (block numbered 1 is
-# output before block 2, even if the latter appears before).  The same
-# number may be used several time, in which case the order of
-# appearance is used.
-
-use strict;
-
-# normalize($block)
-# -----------------
-# Remove Texinfo mark up.
-sub normalize($)
-{
-  local ($_) = @_;
-
-  s/^\@(c |comment|dots|end (ignore|group)|ignore|group).*//mg;
-  s/\@value\{VERSION\}/$ENV{VERSION}/g;
-  s/^\@(error|result)\{\}//mg;
-  s/\@([{}@])/$1/g;
-  s/\@comment.*//;
-  $_;
+BEGIN {
+  if (!output_dir)
+    output_dir = ".";
+  for (argc = 1; argc < ARGC; ++argc)
+    if (ARGV[argc] == "--")
+      break;
+  for (i = argc + 1; i < ARGC; ++i)
+    file_wanted[ARGV[i]] = 1;
+  ARGC = argc;
 }
 
-# Print messages only once.
-my %msg;
-sub message($)
-{
-  my ($msg) = @_;
-  if (! $msg{$msg})
-    {
-      print STDERR "extexi: $msg\n";
-      $msg{$msg} = 1;
-    }
+/^@node / {
+  if (seq > 0)
+    print "AT_CLEANUP";
+
+  split ($0, tmp, ",");
+  node = substr(tmp[1], 7);
+  seq = 0;
 }
 
-# basename => full file name for files we should extract.
-my %file_wanted;
-
-sub process ($)
-{
-  my ($in) = @_;
-  use IO::File;
-  my $f = new IO::File($in)
-    or die "$in: cannot open: $?";
-  # FILE-NAME => { BLOCK-NUM => CODE }
-  my %file;
-
-  # The latest "@comment file: FILE [BLOCK-NUM]" arguments.
-  my $file;
-  my $block;
-  # The @example block currently read.
-  my $input;
-  local $_;
-  while (<$f>)
-    {
-      if (/^\@comment file: ([^:\n]+)(?::\s*(\d+))?$/)
-        {
-          my $f = $1;
-          $block = $2 || 1;
-          if ($file_wanted{$f})
-            {
-              $file = $file_wanted{$f};
-              message(" GEN $file");
-            }
-          else
-            {
-              message("SKIP $f");
-            }
-        }
-      elsif ($file && /^\@(small)?example$/ .. /^\@end (small)?example$/)
-        {
-          if (/^\@(small)?example$/)
-            {
-              # Bison supports synclines, but not Flex.
-              $input .= sprintf ("#line %s \"$in\"\n", $. + 1)
-                if $file =~ /\.[chy]*$/;
-              next;
-            }
-          elsif (/^\@end (small)?example$/)
-            {
-              die "no contents: $file"
-                if $input eq "";
-
-              $file{$file}{$block} .= normalize($input);
-              $file = $input = undef;
-              ++$block;
-            }
-          else
-            {
-              $input .= $_;
-            }
-        }
-    }
-
-  # Output the files.
-  for my $file (keys %file)
-    {
-      # No spurious end of line: use printf.
-      my $o = new IO::File(">$file")
-        or die "$file: cannot create: $?";
-      print $o $file{$file}{$_}
-        for sort keys %{$file{$file}};
-    }
-}
-
-my @input;
-my $seen_dash = 0;
-for my $arg (@ARGV)
-{
-  if ($arg eq '--')
-    {
-      $seen_dash = 1;
-    }
-  elsif ($seen_dash)
-    {
-      use File::Basename;
-      $file_wanted{basename($arg)} = $arg;
-    }
+/^@comment file: / {
+  if (!file_wanted[$3])
+    message("ignoring " $3);
   else
     {
-      push @input, $arg;
+      message("extracting " $3);
+      file = $3;
     }
 }
-process $_
-  foreach @input;
+
+/^@example$/, /^@end example$/ {
+  if (!file)
+    next;
+
+  if ($0 ~ /^@example$/)
+    {
+      input = files_output[file] ? "\n" : "";
+
+      # FNR is starting at 0 instead of 1, and
+      # #line report the line number of the *next* line.
+      # => + 2.
+      # Note that recent Bison support it, but not Flex.
+      if (file ~ /\.[chy]*$/)
+	input = "#line " (FNR + 1) " \"" FILENAME "\"\n";
+      next;
+    }
+
+  if ($0 ~ /^@end example$/)
+    {
+      if (input == "")
+	fatal("no contents: " file);
+
+      input = normalize(input);
+      # No spurious end of line: use printf.
+      if (files_output[file])
+	# The parens around the output file seem to be required
+        # by awk on Mac OS X Tiger (darwin 8.4.6).
+        printf ("%s", input) >> (output_dir "/" file);
+      else
+	printf ("%s", input) > (output_dir "/" file);
+      close (output_dir "/" file);
+      files_output[file] = 1;
+
+      file = input = "";
+      next;
+    }
+
+  input = input $0 "\n";
+}
 
 
-### Setup "GNU" style for perl-mode and cperl-mode.
-## Local Variables:
-## perl-indent-level: 2
-## perl-continued-statement-offset: 2
-## perl-continued-brace-offset: 0
-## perl-brace-offset: 0
-## perl-brace-imaginary-offset: 0
-## perl-label-offset: -2
-## cperl-indent-level: 2
-## cperl-brace-offset: 0
-## cperl-continued-brace-offset: 0
-## cperl-label-offset: -2
-## cperl-extra-newline-before-brace: t
-## cperl-merge-trailing-else: nil
-## cperl-continued-statement-offset: 2
-## End:
+# We have to handle CONTENTS line per line, since anchors in AWK are
+# referring to the whole string, not the lines.
+function normalize(contents,    i, lines, n, line, res) {
+  # Remove the Texinfo tags.
+  n = split (contents, lines, "\n");
+  # We don't want the last field which empty: it's behind the last \n.
+  for (i = 1; i < n; ++i)
+    {
+      line = lines[i];
+
+      # Whole line commands.
+      if (line ~ /^@(c |comment|dots|end (ignore|group)|ignore|group)/)
+	# Gperf accepts empty lines as valid input!!!
+	if (file ~ /\.gperf$/)
+	  continue;
+	else
+	  line = "";
+
+      gsub (/"@value\{VERSION\}"/, "\"" VERSION "\"", line)
+      gsub (/^@result\{\}/, "", line);
+      gsub (/^@error\{\}/,  "", line);
+      gsub ("@[{]", "{", line);
+      gsub ("@}", "}", line);
+      gsub ("@@", "@", line);
+      gsub ("@comment.*", "", line);
+
+      res = res line "\n";
+    }
+  return res;
+}
+
+
+function message(msg) {
+  if (! message_printed[msg])
+    {
+      print "extexi: " msg > "/dev/stderr";
+      message_printed[msg] = 1;
+    }
+}
+
+function fatal(msg) {
+  message(msg);
+  exit 1
+}

examples/local.mk

@@ -1,40 +0,0 @@
-# Copyright (C) 2005, 2008-2012 Free Software Foundation, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-dist_noinst_SCRIPTS = examples/extexi examples/test
-TEST_LOG_COMPILER = $(top_srcdir)/examples/test
-
-## ------------ ##
-## Extracting.  ##
-## ------------ ##
-
-doc = $(top_srcdir)/doc/bison.texi
-extexi = $(top_srcdir)/examples/extexi
-extract = VERSION="$(VERSION)" $(PERL) -f $(extexi) $(doc) --
-extracted =
-CLEANFILES += $(extracted) examples/extracted.stamp
-examples/extracted.stamp: $(doc) $(extexi)
-	$(AM_V_GEN)rm -f $@ $@.tmp
-	$(AM_V_at)touch $@.tmp
-	$(AM_V_at)$(extract) $(extracted)
-	$(AM_V_at)mv $@.tmp $@
-
-$(extracted): examples/extracted.stamp
-	@test -f $@ || rm -f examples/extracted.stamp
-	@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) examples/extracted.stamp
-
-include examples/calc++/local.mk
-include examples/mfcalc/local.mk
-include examples/rpcalc/local.mk

examples/mfcalc/.gitignore

@@ -1,11 +0,0 @@
-/*.o
-/*.tmp
-/.deps
-/calc.h
-/mfcalc
-/mfcalc.c
-/mfcalc.exe
-/mfcalc.h
-/mfcalc.output
-/mfcalc.stamp
-/mfcalc.y

examples/mfcalc/local.mk

@@ -1,36 +0,0 @@
-# Copyright (C) 2005-2006, 2008-2012 Free Software Foundation, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-## -------------------- ##
-## Building & testing.  ##
-## -------------------- ##
-
-BUILT_SOURCES += $(mfcalc_sources)
-CLEANFILES +=  examples/mfcalc/mfcalc.[ch] examples/mfcalc/mfcalc.output
-
-mfcalc_extracted =				\
-  examples/mfcalc/calc.h			\
-  examples/mfcalc/mfcalc.y
-mfcalc_sources =				\
-  $(mfcalc_extracted)
-extracted += $(mfcalc_extracted)
-
-check_PROGRAMS += examples/mfcalc/mfcalc
-examples_mfcalc_mfcalc_LDADD = -lm
-nodist_examples_mfcalc_mfcalc_SOURCES =		\
-  $(mfcalc_sources)
-
-examples_mfcalc_mfcalc_CPPFLAGS = -I$(top_builddir)/examples/mfcalc
-dist_TESTS += examples/mfcalc/mfcalc.test

examples/rpcalc/.gitignore

@@ -1,6 +0,0 @@
-/calc.h
-/rpcalc.c
-/rpcalc.h
-/rpcalc.output
-/rpcalc.stamp
-/rpcalc.y

examples/rpcalc/local.mk

@@ -1,35 +0,0 @@
-# Copyright (C) 2005-2006, 2008-2012 Free Software Foundation, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-## -------------------- ##
-## Building & testing.  ##
-## -------------------- ##
-
-BUILT_SOURCES += $(rpcalc_sources)
-CLEANFILES +=  examples/rpcalc/rpcalc.[ch] examples/rpcalc/rpcalc.output
-
-rpcalc_extracted =				\
-  examples/rpcalc/rpcalc.y
-rpcalc_sources =				\
-  $(rpcalc_extracted)
-extracted += $(rpcalc_extracted)
-
-check_PROGRAMS += examples/rpcalc/rpcalc
-examples_rpcalc_rpcalc_LDADD = -lm
-nodist_examples_rpcalc_rpcalc_SOURCES =		\
-  $(rpcalc_sources)
-
-examples_rpcalc_rpcalc_CPPFLAGS = -I$(top_builddir)/examples/rpcalc
-dist_TESTS += examples/rpcalc/rpcalc.test

examples/test

@@ -1,82 +0,0 @@
-#! /bin/sh
-
-# Copyright (C) 2005-2012 Free Software Foundation, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-me=`basename $1 .test`
-
-# Number of the current test.
-number=1
-
-# Exit status of this script.
-exit=true
-
-# top_buiddir.
-cwd=`pwd`
-
-# The exercised program.
-prog=$cwd/examples/$me/$me
-
-# cleanup
-# -------
-cleanup ()
-{
-  local status=$?
-  if test -z "$DEBUG"; then
-     cd $cwd
-     rm -rf $$.dir
-  fi
-  exit $status
-}
-trap cleanup 0 1 2 13 15
-mkdir $$.dir
-cd $$.dir
-
-# run EXPECTED-EXIT-STATUS EXPECTED-OUTPUT [PARSER-OPTIONS]
-# ---------------------------------------------------------
-run ()
-{
-  # Expected exit status.
-  local sta_exp=$1
-  shift
-  # Expected output.
-  local out_exp=$1
-  shift
-  $prog "$@" - <input >out_eff
-  # Effective exit status.
-  local sta_eff=$?
-  # Effective output.
-  local out_eff=`cat out_eff`
-  if test $sta_eff -eq $sta_exp; then
-    if test "$out_eff" = "$out_exp"; then
-      echo "$me: PASS: $number"
-    else
-      echo "$me: FAIL: $number (expected output: $out_exp, effective: $out_eff)"
-      exit=false
-    fi
-  else
-    echo "$me: FAIL: $number (expected status: $sta_exp, effective: $sta_eff)"
-    exit=false
-  fi
-  number=`expr $number + 1`
-}
-
-# We have cd'd one level deeper.
-case $1 in
-  /*) . "$1";;
-  *)  . "../$1";;
-esac
-
-$exit

examples/variant.yy

@@ -1,141 +0,0 @@
-/*
-  Copyright (C) 2008-2012 Free Software Foundation, Inc.
-
-  This program is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-%debug
-%skeleton "lalr1.cc"
-%defines
-%define parse.assert
-%define variant
-%define lex_symbol
-%locations
-
-%code requires // *.hh
-{
-#include <list>
-#include <string>
-typedef std::list<std::string> strings_type;
-}
-
-%code // *.cc
-{
-#include <algorithm>
-#include <iostream>
-#include <iterator>
-#include <sstream>
-
-  // Prototype of the yylex function providing subsequent tokens.
-  static yy::parser::symbol_type yylex ();
-
-  // Printing a list of strings.
-  // Koening look up will look into std, since that's an std::list.
-  namespace std
-  {
-    std::ostream&
-    operator<< (std::ostream& o, const strings_type& s)
-    {
-      std::copy (s.begin (), s.end (),
-                 std::ostream_iterator<strings_type::value_type> (o, "\n"));
-      return o;
-    }
-  }
-
-  // Conversion to string.
-  template <typename T>
-    inline
-    std::string
-    string_cast (const T& t)
-  {
-    std::ostringstream o;
-    o << t;
-    return o.str ();
-  }
-}
-
-%token <::std::string> TEXT;
-%token <int> NUMBER;
-%printer { debug_stream () << $$; }
-   <int> <::std::string> <::std::list<std::string>>;
-%token END_OF_FILE 0;
-
-%type <::std::string> item;
-%type <::std::list<std::string>> list;
-
-%%
-
-result:
-  list  { std::cout << $1 << std::endl; }
-;
-
-list:
-  /* nothing */ { /* Generates an empty string list */ }
-| list item     { std::swap ($$, $1); $$.push_back ($2); }
-;
-
-item:
-  TEXT          { std::swap ($$, $1); }
-| NUMBER        { $$ = string_cast ($1); }
-;
-%%
-
-// The yylex function providing subsequent tokens:
-// TEXT         "I have three numbers for you:"
-// NUMBER       1
-// NUMBER       2
-// NUMBER       3
-// TEXT         " and that's all!"
-// END_OF_FILE
-
-static
-yy::parser::symbol_type
-yylex ()
-{
-  static int stage = -1;
-  ++stage;
-  yy::parser::location_type loc(0, stage + 1, stage + 1);
-  switch (stage)
-  {
-    case 0:
-      return yy::parser::make_TEXT ("I have three numbers for you.", loc);
-    case 1:
-    case 2:
-    case 3:
-      return yy::parser::make_NUMBER (stage, loc);
-    case 4:
-      return yy::parser::make_TEXT ("And that's all!", loc);
-    default:
-      return yy::parser::make_END_OF_FILE (loc);
-  }
-}
-
-// Mandatory error function
-void
-yy::parser::error (const yy::parser::location_type& loc, const std::string& msg)
-{
-  std::cerr << loc << ": " << msg << std::endl;
-}
-
-int
-main ()
-{
-  yy::parser p;
-  p.set_debug_level (!!getenv ("YYDEBUG"));
-  return p.parse ();
-}
-
-// Local Variables:
-// mode: C++
-// End:

externals/bootstrap.cfg

@@ -1 +0,0 @@
-external: gnulib

lib/.gitignore

@@ -109,7 +109,9 @@
 /mbchar.c
 /mbchar.h
 /mbrtowc.c
+/mbschr.c
 /mbsinit.c
+/mbsrchr.c
 /mbswidth.c
 /mbswidth.h
 /mbuiter.h
@@ -266,7 +268,7 @@
 /xmemdup0.c
 /xmemdup0.h
 /sys_types.in.h
-/concat-filename.c
-/concat-filename.h
-/filename.h
-/xconcat-filename.c
+/obstack_printf.c
+/binary-io.c
+/mbuiter.c
+/xsize.c

lib/Makefile.am

@@ -0,0 +1,55 @@
+# Make bison/lib.
+
+# Copyright (C) 2001-2004, 2006, 2008-2012 Free Software Foundation,
+# Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+AM_CFLAGS =
+AM_CPPFLAGS =
+BUILT_SOURCES =
+CLEANFILES =
+EXTRA_DIST =
+MOSTLYCLEANDIRS =
+MOSTLYCLEANFILES =
+SUFFIXES =
+noinst_LIBRARIES =
+
+include gnulib.mk
+
+AM_CFLAGS += $(WARN_CFLAGS)
+
+# Implementation of bitsets.
+bitsets_sources = \
+  abitset.c abitset.h bbitset.h bitset.c bitset.h bitset_stats.c	\
+  bitset_stats.h bitsetv.c bitsetv.h ebitset.c ebitset.h lbitset.c	\
+  lbitset.h libiberty.h vbitset.c vbitset.h
+
+# Additional bitset operations.
+additional_bitsets_sources = \
+  bitsetv-print.h bitsetv-print.c
+
+# timevars, stolen from GCC.
+timevars_sources = \
+  timevar.h timevar.c timevar.def
+
+# Non-gnulib sources in Bison's internal library.
+libbison_a_SOURCES += \
+  get-errno.h get-errno.c \
+  $(bitsets_sources) $(additional_bitsets_sources) $(timevars_sources)
+
+# The Yacc compatibility library.
+lib_LIBRARIES = $(YACC_LIBRARY)
+EXTRA_LIBRARIES = liby.a
+liby_a_SOURCES = main.c yyerror.c

lib/abitset.c

@@ -47,7 +47,7 @@ abitset_resize (bitset src, bitset_bindex size)
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 abitset_small_list (bitset src, bitset_bindex *list,
-                    bitset_bindex num, bitset_bindex *next)
+		    bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex bitno;
   bitset_bindex count;
@@ -73,27 +73,27 @@ abitset_small_list (bitset src, bitset_bindex *list,
   if (num >= BITSET_WORD_BITS)
     {
       for (count = 0; word; bitno++)
-        {
-          if (word & 1)
-            list[count++] = bitno;
-          word >>= 1;
-        }
+	{
+	  if (word & 1)
+	    list[count++] = bitno;
+	  word >>= 1;
+	}
     }
   else
     {
       for (count = 0; word; bitno++)
-        {
-          if (word & 1)
-            {
-              list[count++] = bitno;
-              if (count >= num)
-                {
-                  bitno++;
-                  break;
-                }
-            }
-          word >>= 1;
-        }
+	{
+	  if (word & 1)
+	    {
+	      list[count++] = bitno;
+	      if (count >= num)
+		{
+		  bitno++;
+		  break;
+		}
+	    }
+	  word >>= 1;
+	}
     }
 
   *next = bitno;
@@ -115,7 +115,7 @@ abitset_set (bitset dst ATTRIBUTE_UNUSED, bitset_bindex bitno ATTRIBUTE_UNUSED)
 /* Reset bit BITNO in bitset DST.  */
 static void
 abitset_reset (bitset dst ATTRIBUTE_UNUSED,
-               bitset_bindex bitno ATTRIBUTE_UNUSED)
+	       bitset_bindex bitno ATTRIBUTE_UNUSED)
 {
   /* This should never occur for abitsets since we should always hit
      the cache.  It is likely someone is trying to access outside the
@@ -126,7 +126,7 @@ abitset_reset (bitset dst ATTRIBUTE_UNUSED,
 /* Test bit BITNO in bitset SRC.  */
 static bool
 abitset_test (bitset src ATTRIBUTE_UNUSED,
-              bitset_bindex bitno ATTRIBUTE_UNUSED)
+	      bitset_bindex bitno ATTRIBUTE_UNUSED)
 {
   /* This should never occur for abitsets since we should always
      hit the cache.  */
@@ -140,7 +140,7 @@ abitset_test (bitset src ATTRIBUTE_UNUSED,
    stopped.  */
 static bitset_bindex
 abitset_list_reverse (bitset src, bitset_bindex *list,
-                      bitset_bindex num, bitset_bindex *next)
+		      bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex bitno;
   bitset_bindex rbitno;
@@ -173,18 +173,18 @@ abitset_list_reverse (bitset src, bitset_bindex *list,
 
       word = srcp[windex] << (BITSET_WORD_BITS - 1 - bitcnt);
       for (; word; bitcnt--)
-        {
-          if (word & BITSET_MSB)
-            {
-              list[count++] = bitoff + bitcnt;
-              if (count >= num)
-                {
-                  *next = n_bits - (bitoff + bitcnt);
-                  return count;
-                }
-            }
-          word <<= 1;
-        }
+	{
+	  if (word & BITSET_MSB)
+	    {
+	      list[count++] = bitoff + bitcnt;
+	      if (count >= num)
+		{
+		  *next = n_bits - (bitoff + bitcnt);
+		  return count;
+		}
+	    }
+	  word <<= 1;
+	}
       bitoff -= BITSET_WORD_BITS;
       bitcnt = BITSET_WORD_BITS - 1;
     }
@@ -200,7 +200,7 @@ abitset_list_reverse (bitset src, bitset_bindex *list,
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 abitset_list (bitset src, bitset_bindex *list,
-              bitset_bindex num, bitset_bindex *next)
+	      bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex bitno;
   bitset_bindex count;
@@ -217,80 +217,80 @@ abitset_list (bitset src, bitset_bindex *list,
     {
       /* Many bitsets are zero, so make this common case fast.  */
       for (windex = 0; windex < size && !srcp[windex]; windex++)
-        continue;
+	continue;
       if (windex >= size)
-        return 0;
+	return 0;
 
       /* If num is 1, we could speed things up with a binary search
-         of the current word.  */
+	 of the current word.  */
 
       bitoff = windex * BITSET_WORD_BITS;
     }
   else
     {
       if (bitno >= BITSET_SIZE_ (src))
-        return 0;
+	return 0;
 
       windex = bitno / BITSET_WORD_BITS;
       bitno = bitno % BITSET_WORD_BITS;
 
       if (bitno)
-        {
-          /* Handle the case where we start within a word.
-             Most often, this is executed with large bitsets
-             with many set bits where we filled the array
-             on the previous call to this function.  */
+	{
+	  /* Handle the case where we start within a word.
+	     Most often, this is executed with large bitsets
+	     with many set bits where we filled the array
+	     on the previous call to this function.  */
 
-          bitoff = windex * BITSET_WORD_BITS;
-          word = srcp[windex] >> bitno;
-          for (bitno = bitoff + bitno; word; bitno++)
-            {
-              if (word & 1)
-                {
-                  list[count++] = bitno;
-                  if (count >= num)
-                    {
-                      *next = bitno + 1;
-                      return count;
-                    }
-                }
-              word >>= 1;
-            }
-          windex++;
-        }
+	  bitoff = windex * BITSET_WORD_BITS;
+	  word = srcp[windex] >> bitno;
+	  for (bitno = bitoff + bitno; word; bitno++)
+	    {
+	      if (word & 1)
+		{
+		  list[count++] = bitno;
+		  if (count >= num)
+		    {
+		      *next = bitno + 1;
+		      return count;
+		    }
+		}
+	      word >>= 1;
+	    }
+	  windex++;
+	}
       bitoff = windex * BITSET_WORD_BITS;
     }
 
   for (; windex < size; windex++, bitoff += BITSET_WORD_BITS)
     {
       if (!(word = srcp[windex]))
-        continue;
+	continue;
 
       if ((count + BITSET_WORD_BITS) < num)
-        {
-          for (bitno = bitoff; word; bitno++)
-            {
-              if (word & 1)
-                list[count++] = bitno;
-              word >>= 1;
-            }
-        }
+	{
+	  for (bitno = bitoff; word; bitno++)
+	    {
+	      if (word & 1)
+		list[count++] = bitno;
+	      word >>= 1;
+	    }
+	}
       else
-        {
-          for (bitno = bitoff; word; bitno++)
-            {
-              if (word & 1)
-                {
-                  list[count++] = bitno;
-                  if (count >= num)
-                    {
-                      *next = bitno + 1;
-                      return count;
-                    }
-                }
-              word >>= 1;
-            }
-        }
+	{
+	  for (bitno = bitoff; word; bitno++)
+	    {
+	      if (word & 1)
+		{
+		  list[count++] = bitno;
+		  if (count >= num)
+		    {
+		      *next = bitno + 1;
+		      return count;
+		    }
+		}
+	      word >>= 1;
+	    }
+	}
     }
 
   *next = bitoff;
@@ -387,7 +387,7 @@ abitset_equal_p (bitset dst, bitset src)
 
   for (i = 0; i < size; i++)
       if (*srcp++ != *dstp++)
-          return false;
+	  return false;
   return true;
 }
 
@@ -402,7 +402,7 @@ abitset_subset_p (bitset dst, bitset src)
 
   for (i = 0; i < size; i++, dstp++, srcp++)
       if (*dstp != (*srcp | *dstp))
-          return false;
+	  return false;
   return true;
 }
 
@@ -417,7 +417,7 @@ abitset_disjoint_p (bitset dst, bitset src)
 
   for (i = 0; i < size; i++)
       if (*srcp++ & *dstp++)
-          return false;
+	  return false;
 
   return true;
 }
@@ -452,10 +452,10 @@ abitset_and_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ & *src2p++;
 
       if (*dstp != tmp)
-        {
-          changed = true;
-          *dstp = tmp;
-        }
+	{
+	  changed = true;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -490,10 +490,10 @@ abitset_andn_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ & ~(*src2p++);
 
       if (*dstp != tmp)
-        {
-          changed = true;
-          *dstp = tmp;
-        }
+	{
+	  changed = true;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -528,10 +528,10 @@ abitset_or_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ | *src2p++;
 
       if (*dstp != tmp)
-        {
-          changed = true;
-          *dstp = tmp;
-        }
+	{
+	  changed = true;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -566,10 +566,10 @@ abitset_xor_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ ^ *src2p++;
 
       if (*dstp != tmp)
-        {
-          changed = true;
-          *dstp = tmp;
-        }
+	{
+	  changed = true;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -606,10 +606,10 @@ abitset_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;
 
       if (*dstp != tmp)
-        {
-          changed = true;
-          *dstp = tmp;
-        }
+	{
+	  changed = true;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -646,10 +646,10 @@ abitset_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ & ~(*src2p++)) | *src3p++;
 
       if (*dstp != tmp)
-        {
-          changed = true;
-          *dstp = tmp;
-        }
+	{
+	  changed = true;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -686,10 +686,10 @@ abitset_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ | *src2p++) & *src3p++;
 
       if (*dstp != tmp)
-        {
-          changed = true;
-          *dstp = tmp;
-        }
+	{
+	  changed = true;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }

lib/bbitset.h

@@ -32,9 +32,9 @@
                   Memory for bit array and bitset structure allocated
                   contiguously.
    BITSET_LIST:   Linked list of arrays of bits (variable size, least storage
-                  for large very sparse sets).
+		  for large very sparse sets).
    BITSET_TABLE:  Expandable table of pointers to arrays of bits
-                  (variable size, less storage for large sparse sets).
+		  (variable size, less storage for large sparse sets).
                   Faster than BITSET_LIST for random access.
    BITSET_VARRAY: Variable array of bits (variable size, fast for
                   dense bitsets).
@@ -42,7 +42,7 @@
                   statistics and/or better run-time checking.
 */
 enum bitset_type {BITSET_ARRAY, BITSET_LIST, BITSET_TABLE, BITSET_VARRAY,
-                  BITSET_TYPE_NUM, BITSET_STATS};
+		  BITSET_TYPE_NUM, BITSET_STATS};
 #define BITSET_TYPE_NAMES {"abitset", "lbitset", "ebitset", "vbitset"}
 
 extern const char * const bitset_type_names[];
@@ -78,19 +78,19 @@ typedef size_t bitset_windex;
 #define BITSET_LIST_SIZE 1024
 
 enum bitset_ops {BITSET_OP_ZERO, BITSET_OP_ONES,
-                 BITSET_OP_COPY, BITSET_OP_NOT,
-                 BITSET_OP_EMPTY_P, BITSET_OP_EQUAL_P,
-                 BITSET_OP_SUBSET_P, BITSET_OP_DISJOINT_P,
-                 BITSET_OP_AND, BITSET_OP_OR, BITSET_OP_XOR, BITSET_OP_ANDN,
-                 BITSET_OP_OR_AND, BITSET_OP_AND_OR, BITSET_OP_ANDN_OR};
+		 BITSET_OP_COPY, BITSET_OP_NOT,
+		 BITSET_OP_EMPTY_P, BITSET_OP_EQUAL_P,
+		 BITSET_OP_SUBSET_P, BITSET_OP_DISJOINT_P,
+		 BITSET_OP_AND, BITSET_OP_OR, BITSET_OP_XOR, BITSET_OP_ANDN,
+		 BITSET_OP_OR_AND, BITSET_OP_AND_OR, BITSET_OP_ANDN_OR};
 
 struct bbitset_struct
 {
   const struct bitset_vtable *vtable;
-  bitset_windex cindex;         /* Cache word index.  */
-  bitset_windex csize;          /* Cache size in words.  */
-  bitset_word *cdata;           /* Cache data pointer.  */
-  bitset_bindex n_bits;         /* Number of bits.  */
+  bitset_windex cindex;		/* Cache word index.  */
+  bitset_windex csize;		/* Cache size in words.  */
+  bitset_word *cdata;		/* Cache data pointer.  */
+  bitset_bindex n_bits;		/* Number of bits.  */
   /* Perhaps we could sacrifice another word to indicate
      that the bitset is known to be zero, that a bit has been set
      in the cache, and that a bit has been cleared in the cache.
@@ -148,9 +148,9 @@ struct bitset_vtable
   bool (*or_and_cmp) (bitset, bitset, bitset, bitset);
 
   bitset_bindex (*list) (bitset, bitset_bindex *, bitset_bindex,
-                         bitset_bindex *);
+			 bitset_bindex *);
   bitset_bindex (*list_reverse) (bitset, bitset_bindex *, bitset_bindex,
-                                 bitset_bindex *);
+				 bitset_bindex *);
   void (*free) (bitset);
   enum bitset_type type;
 };

lib/bitset.c

@@ -151,7 +151,7 @@ bitset_alloc (bitset_bindex n_bits, enum bitset_type type)
 /* Create a bitset of N_BITS of type TYPE.  */
 bitset
 bitset_obstack_alloc (struct obstack *bobstack,
-                      bitset_bindex n_bits, enum bitset_type type)
+		      bitset_bindex n_bits, enum bitset_type type)
 {
   size_t bytes;
   bitset bset;
@@ -296,15 +296,15 @@ bitset_print (FILE *file, bitset bset, bool verbose)
 
   if (verbose)
     fprintf (file, "n_bits = %lu, set = {",
-             (unsigned long int) bitset_size (bset));
+	     (unsigned long int) bitset_size (bset));
 
   pos = 30;
   BITSET_FOR_EACH (iter, bset, i, 0)
   {
     if (pos > 70)
       {
-        fprintf (file, "\n");
-        pos = 0;
+	fprintf (file, "\n");
+	pos = 0;
       }
 
     fprintf (file, "%lu ", (unsigned long int) i);
@@ -407,7 +407,7 @@ bitset_copy_ (bitset dst, bitset src)
    four operand operations.  */
 static inline bool
 bitset_op4_cmp (bitset dst, bitset src1, bitset src2, bitset src3,
-                enum bitset_ops op)
+		enum bitset_ops op)
 {
   bool changed = false;
   bool stats_enabled_save;

lib/bitset.h

@@ -33,11 +33,11 @@
 
 /* Attributes used to select a bitset implementation.  */
 enum bitset_attr {BITSET_FIXED = 1,    /* Bitset size fixed.  */
-                  BITSET_VARIABLE = 2, /* Bitset size variable.  */
-                  BITSET_DENSE = 4,    /* Bitset dense.  */
-                  BITSET_SPARSE = 8,   /* Bitset sparse.  */
-                  BITSET_FRUGAL = 16,  /* Prefer most compact.  */
-                  BITSET_GREEDY = 32}; /* Prefer fastest at memory expense.  */
+		  BITSET_VARIABLE = 2, /* Bitset size variable.  */
+		  BITSET_DENSE = 4,    /* Bitset dense.  */
+		  BITSET_SPARSE = 8,   /* Bitset sparse.  */
+		  BITSET_FRUGAL = 16,  /* Prefer most compact.  */
+		  BITSET_GREEDY = 32}; /* Prefer fastest at memory expense.  */
 
 typedef unsigned int bitset_attrs;
 
@@ -49,26 +49,26 @@ union bitset_union
 {
   /* This must be the first member of every other structure that is a
      member of this union.  */
-  struct bbitset_struct b;              /* Base bitset data.  */
+  struct bbitset_struct b;	        /* Base bitset data.  */
 
   struct abitset_struct
   {
     struct bbitset_struct b;
-    bitset_word words[1];               /* The array of bits.  */
+    bitset_word words[1];		/* The array of bits.  */
   } a;
 
   struct ebitset_struct
   {
     struct bbitset_struct b;
-    bitset_windex size;                 /* Number of elements.  */
-    struct ebitset_elt_struct **elts;   /* Expanding array of ptrs to elts.  */
+    bitset_windex size;			/* Number of elements.  */
+    struct ebitset_elt_struct **elts;	/* Expanding array of ptrs to elts.  */
   } e;
 
   struct lbitset_struct
   {
     struct bbitset_struct b;
-    struct lbitset_elt_struct *head;    /* First element in linked list.  */
-    struct lbitset_elt_struct *tail;    /* Last element in linked list.  */
+    struct lbitset_elt_struct *head;	/* First element in linked list.  */
+    struct lbitset_elt_struct *tail;	/* Last element in linked list.  */
   } l;
 
   struct bitset_stats_struct
@@ -80,7 +80,7 @@ union bitset_union
   struct vbitset_struct
   {
     struct bbitset_struct b;
-    bitset_windex size;                 /* Allocated size of array.  */
+    bitset_windex size;			/* Allocated size of array.  */
   } v;
 
 };
@@ -116,7 +116,7 @@ extern void bitset_free (bitset);
 /* Create a bitset of desired type and size using an obstack.  The
    bitset is zeroed.  */
 extern bitset bitset_obstack_alloc (struct obstack *bobstack,
-                                    bitset_bindex, enum bitset_type);
+				    bitset_bindex, enum bitset_type);
 
 /* Free bitset allocated on obstack.  */
 extern void bitset_obstack_free (bitset);
@@ -312,14 +312,14 @@ extern void bitset_dump (FILE *, bitset);
       printf ("%lu ", (unsigned long int) i);
    };
 */
-#define BITSET_FOR_EACH(ITER, BSET, INDEX, MIN)                               \
-  for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;                        \
-       (ITER.num == BITSET_LIST_SIZE)                                         \
-       && (ITER.num = bitset_list (BSET, ITER.list,                           \
-                                   BITSET_LIST_SIZE, &ITER.next));)           \
-    for (ITER.i = 0;                                                          \
-         ITER.i < ITER.num && ((INDEX) = ITER.list[ITER.i], 1);               \
-         ITER.i++)
+#define BITSET_FOR_EACH(ITER, BSET, INDEX, MIN)				      \
+  for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;			      \
+       (ITER.num == BITSET_LIST_SIZE)					      \
+       && (ITER.num = bitset_list (BSET, ITER.list,			      \
+				   BITSET_LIST_SIZE, &ITER.next));)	      \
+    for (ITER.i = 0;							      \
+	 ITER.i < ITER.num && ((INDEX) = ITER.list[ITER.i], 1);		      \
+	 ITER.i++)
 
 
 /* Loop over all elements of BSET, in reverse order starting with
@@ -334,14 +334,14 @@ extern void bitset_dump (FILE *, bitset);
       printf ("%lu ", (unsigned long int) i);
    };
 */
-#define BITSET_FOR_EACH_REVERSE(ITER, BSET, INDEX, MIN)                       \
-  for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;                        \
-       (ITER.num == BITSET_LIST_SIZE)                                         \
-       && (ITER.num = bitset_list_reverse (BSET, ITER.list,                   \
-                                           BITSET_LIST_SIZE, &ITER.next));)   \
-    for (ITER.i = 0;                                                          \
-         ITER.i < ITER.num && ((INDEX) = ITER.list[ITER.i], 1);               \
-         ITER.i++)
+#define BITSET_FOR_EACH_REVERSE(ITER, BSET, INDEX, MIN)			      \
+  for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;			      \
+       (ITER.num == BITSET_LIST_SIZE)					      \
+       && (ITER.num = bitset_list_reverse (BSET, ITER.list,		      \
+					   BITSET_LIST_SIZE, &ITER.next));)   \
+    for (ITER.i = 0;							      \
+	 ITER.i < ITER.num && ((INDEX) = ITER.list[ITER.i], 1);		      \
+	 ITER.i++)
 
 
 /* Define set operations in terms of logical operations.  */

lib/bitset_stats.c

@@ -48,29 +48,29 @@
 
 
 /* Accessor macros.  */
-#define BITSET_STATS_ALLOCS_INC(TYPE)                   \
+#define BITSET_STATS_ALLOCS_INC(TYPE)			\
     bitset_stats_info->types[(TYPE)].allocs++
-#define BITSET_STATS_FREES_INC(BSET)                    \
+#define BITSET_STATS_FREES_INC(BSET)			\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].frees++
-#define BITSET_STATS_SETS_INC(BSET)                     \
+#define BITSET_STATS_SETS_INC(BSET)			\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].sets++
-#define BITSET_STATS_CACHE_SETS_INC(BSET)               \
+#define BITSET_STATS_CACHE_SETS_INC(BSET)		\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_sets++
-#define BITSET_STATS_RESETS_INC(BSET)                   \
+#define BITSET_STATS_RESETS_INC(BSET)			\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].resets++
-#define BITSET_STATS_CACHE_RESETS_INC(BSET)             \
+#define BITSET_STATS_CACHE_RESETS_INC(BSET)		\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_resets++
-#define BITSET_STATS_TESTS_INC(BSET)                    \
+#define BITSET_STATS_TESTS_INC(BSET)			\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].tests++
-#define BITSET_STATS_CACHE_TESTS_INC(BSET)              \
+#define BITSET_STATS_CACHE_TESTS_INC(BSET)		\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_tests++
-#define BITSET_STATS_LISTS_INC(BSET)                    \
+#define BITSET_STATS_LISTS_INC(BSET)			\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].lists++
-#define BITSET_STATS_LIST_COUNTS_INC(BSET, I)           \
+#define BITSET_STATS_LIST_COUNTS_INC(BSET, I)		\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_counts[(I)]++
-#define BITSET_STATS_LIST_SIZES_INC(BSET, I)            \
+#define BITSET_STATS_LIST_SIZES_INC(BSET, I)		\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_sizes[(I)]++
-#define BITSET_STATS_LIST_DENSITY_INC(BSET, I)          \
+#define BITSET_STATS_LIST_DENSITY_INC(BSET, I)		\
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_density[(I)]++
 
 
@@ -105,7 +105,7 @@ bool bitset_stats_enabled = false;
 /* Print a percentage histogram with message MSG to FILE.  */
 static void
 bitset_percent_histogram_print (FILE *file, const char *name, const char *msg,
-                                unsigned int n_bins, unsigned int *bins)
+				unsigned int n_bins, unsigned int *bins)
 {
   unsigned int i;
   unsigned int total;
@@ -120,16 +120,16 @@ bitset_percent_histogram_print (FILE *file, const char *name, const char *msg,
   fprintf (file, "%s %s", name, msg);
   for (i = 0; i < n_bins; i++)
     fprintf (file, "%.0f-%.0f%%\t%8u (%5.1f%%)\n",
-             i * 100.0 / n_bins,
-             (i + 1) * 100.0 / n_bins, bins[i],
-             (100.0 * bins[i]) / total);
+	     i * 100.0 / n_bins,
+	     (i + 1) * 100.0 / n_bins, bins[i],
+	     (100.0 * bins[i]) / total);
 }
 
 
 /* Print a log histogram with message MSG to FILE.  */
 static void
 bitset_log_histogram_print (FILE *file, const char *name, const char *msg,
-                            unsigned int n_bins, unsigned int *bins)
+			    unsigned int n_bins, unsigned int *bins)
 {
   unsigned int i;
   unsigned int total;
@@ -153,50 +153,50 @@ bitset_log_histogram_print (FILE *file, const char *name, const char *msg,
   fprintf (file, "%s %s", name, msg);
   for (i = 0; i < 2; i++)
     fprintf (file, "%*d\t%8u (%5.1f%%)\n",
-             max_width, i, bins[i], 100.0 * bins[i] / total);
+	     max_width, i, bins[i], 100.0 * bins[i] / total);
 
   for (; i < n_bins; i++)
     fprintf (file, "%*lu-%lu\t%8u (%5.1f%%)\n",
-             max_width - ((unsigned int) (0.30103 * (i) + 0.9999) + 1),
-             1UL << (i - 1),
-             (1UL << i) - 1,
-             bins[i],
-             (100.0 * bins[i]) / total);
+	     max_width - ((unsigned int) (0.30103 * (i) + 0.9999) + 1),
+	     1UL << (i - 1),
+	     (1UL << i) - 1,
+	     bins[i],
+	     (100.0 * bins[i]) / total);
 }
 
 
 /* Print bitset statistics to FILE.  */
 static void
 bitset_stats_print_1 (FILE *file, const char *name,
-                      struct bitset_type_info_struct *stats)
+		      struct bitset_type_info_struct *stats)
 {
   if (!stats)
     return;
 
   fprintf (file, "%s:\n", name);
   fprintf (file, _("%u bitset_allocs, %u freed (%.2f%%).\n"),
-           stats->allocs, stats->frees,
-           stats->allocs ? 100.0 * stats->frees / stats->allocs : 0);
+	   stats->allocs, stats->frees,
+	   stats->allocs ? 100.0 * stats->frees / stats->allocs : 0);
   fprintf (file, _("%u bitset_sets, %u cached (%.2f%%)\n"),
-           stats->sets, stats->cache_sets,
-           stats->sets ? 100.0 * stats->cache_sets / stats->sets : 0);
+	   stats->sets, stats->cache_sets,
+	   stats->sets ? 100.0 * stats->cache_sets / stats->sets : 0);
   fprintf (file, _("%u bitset_resets, %u cached (%.2f%%)\n"),
-           stats->resets, stats->cache_resets,
-           stats->resets ? 100.0 * stats->cache_resets / stats->resets : 0);
+	   stats->resets, stats->cache_resets,
+	   stats->resets ? 100.0 * stats->cache_resets / stats->resets : 0);
   fprintf (file, _("%u bitset_tests, %u cached (%.2f%%)\n"),
-           stats->tests, stats->cache_tests,
-           stats->tests ? 100.0 * stats->cache_tests / stats->tests : 0);
+	   stats->tests, stats->cache_tests,
+	   stats->tests ? 100.0 * stats->cache_tests / stats->tests : 0);
 
   fprintf (file, _("%u bitset_lists\n"), stats->lists);
 
   bitset_log_histogram_print (file, name, _("count log histogram\n"),
-                              BITSET_LOG_COUNT_BINS, stats->list_counts);
+			      BITSET_LOG_COUNT_BINS, stats->list_counts);
 
   bitset_log_histogram_print (file, name, _("size log histogram\n"),
-                              BITSET_LOG_SIZE_BINS, stats->list_sizes);
+			      BITSET_LOG_SIZE_BINS, stats->list_sizes);
 
   bitset_percent_histogram_print (file, name, _("density histogram\n"),
-                                  BITSET_DENSITY_BINS, stats->list_density);
+				  BITSET_DENSITY_BINS, stats->list_density);
 }
 
 
@@ -216,7 +216,7 @@ bitset_stats_print (FILE *file, bool verbose ATTRIBUTE_UNUSED)
 
   for (i = 0; i < BITSET_TYPE_NUM; i++)
     bitset_stats_print_1 (file, bitset_type_names[i],
-                          &bitset_stats_info->types[i]);
+			  &bitset_stats_info->types[i]);
 }
 
 
@@ -340,7 +340,7 @@ bitset_stats_reset (bitset dst, bitset_bindex bitno)
   if (offset < bset->b.csize)
     {
       bset->b.cdata[offset] &=
-        ~((bitset_word) 1 << (bitno % BITSET_WORD_BITS));
+	~((bitset_word) 1 << (bitno % BITSET_WORD_BITS));
       BITSET_STATS_CACHE_RESETS_INC (bset);
     }
   else
@@ -570,7 +570,7 @@ bitset_stats_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 
 static bitset_bindex
 bitset_stats_list (bitset bset, bitset_bindex *list,
-                   bitset_bindex num, bitset_bindex *next)
+		   bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex count;
   bitset_bindex tmp;
@@ -607,7 +607,7 @@ bitset_stats_list (bitset bset, bitset_bindex *list,
 
 static bitset_bindex
 bitset_stats_list_reverse (bitset bset, bitset_bindex *list,
-                           bitset_bindex num, bitset_bindex *next)
+			   bitset_bindex num, bitset_bindex *next)
 {
   return BITSET_LIST_REVERSE_ (bset->s.bset, list, num, next);
 }

lib/bitsetv-print.c

@@ -56,7 +56,7 @@ bitsetv_matrix_dump (FILE * out, const char *title, bitsetv bset)
     {
       fprintf (out, "%2lu|", (unsigned long int) i);
       for (j = 0; j < hsize; ++j)
-        fputs (bitset_test (bset[i], j) ? "1" : " ", out);
+	fputs (bitset_test (bset[i], j) ? "1" : " ", out);
       fputs ("|\n", out);
     }
 

lib/bitsetv.c

@@ -27,7 +27,7 @@
    type TYPE.  */
 bitset *
 bitsetv_alloc (bitset_bindex n_vecs, bitset_bindex n_bits,
-               enum bitset_type type)
+	       enum bitset_type type)
 {
   size_t vector_bytes;
   size_t bytes;
@@ -116,7 +116,7 @@ bitsetv_transitive_closure (bitsetv bsetv)
   for (i = 0; bsetv[i]; i++)
     for (j = 0; bsetv[j]; j++)
       if (bitset_test (bsetv[j], i))
-        bitset_or (bsetv[j], bsetv[j], bsetv[i]);
+	bitset_or (bsetv[j], bsetv[j], bsetv[i]);
 }
 
 
@@ -139,7 +139,7 @@ bitsetv_reflexive_transitive_closure (bitsetv bsetv)
    FILE.  */
 void
 bitsetv_dump (FILE *file, char const *title, char const *subtitle,
-              bitsetv bsetv)
+	      bitsetv bsetv)
 {
   bitset_windex i;
 

lib/ebitset.c

@@ -58,7 +58,7 @@ typedef struct ebitset_elt_struct
 {
   union
   {
-    bitset_word words[EBITSET_ELT_WORDS];       /* Bits that are set.  */
+    bitset_word words[EBITSET_ELT_WORDS];	/* Bits that are set.  */
     struct ebitset_elt_struct *next;
   }
   u;
@@ -84,7 +84,7 @@ static ebitset_elt ebitset_zero_elts[1]; /* Elements of all zero bits.  */
 /* Obstack to allocate bitset elements from.  */
 static struct obstack ebitset_obstack;
 static bool ebitset_obstack_init = false;
-static ebitset_elt *ebitset_free_list;  /* Free list of bitset elements.  */
+static ebitset_elt *ebitset_free_list;	/* Free list of bitset elements.  */
 
 #define EBITSET_N_ELTS(N) (((N) + EBITSET_ELT_BITS - 1) / EBITSET_ELT_BITS)
 #define EBITSET_ELTS(BSET) ((BSET)->e.elts)
@@ -96,7 +96,7 @@ static ebitset_elt *ebitset_free_list;  /* Free list of bitset elements.  */
 
 /* Disable bitset cache and mark BSET as being zero.  */
 #define EBITSET_ZERO_SET(BSET) ((BSET)->b.cindex = BITSET_WINDEX_MAX, \
-        (BSET)->b.cdata = 0)
+	(BSET)->b.cdata = 0)
 
 #define EBITSET_CACHE_DISABLE(BSET)  ((BSET)->b.cindex = BITSET_WINDEX_MAX)
 
@@ -136,37 +136,37 @@ ebitset_resize (bitset src, bitset_bindex n_bits)
       bitset_windex size;
 
       /* The bitset needs to grow.  If we already have enough memory
-         allocated, then just zero what we need.  */
+	 allocated, then just zero what we need.  */
       if (newsize > EBITSET_ASIZE (src))
-        {
-          /* We need to allocate more memory.  When oldsize is
-             non-zero this means that we are changing the size, so
-             grow the bitset 25% larger than requested to reduce
-             number of reallocations.  */
+	{
+	  /* We need to allocate more memory.  When oldsize is
+	     non-zero this means that we are changing the size, so
+	     grow the bitset 25% larger than requested to reduce
+	     number of reallocations.  */
 
-          if (oldsize == 0)
-            size = newsize;
-          else
-            size = newsize + newsize / 4;
+	  if (oldsize == 0)
+	    size = newsize;
+	  else
+	    size = newsize + newsize / 4;
 
-          EBITSET_ELTS (src)
-            = realloc (EBITSET_ELTS (src), size * sizeof (ebitset_elt *));
-          EBITSET_ASIZE (src) = size;
-        }
+	  EBITSET_ELTS (src)
+	    = realloc (EBITSET_ELTS (src), size * sizeof (ebitset_elt *));
+	  EBITSET_ASIZE (src) = size;
+	}
 
       memset (EBITSET_ELTS (src) + oldsize, 0,
-              (newsize - oldsize) * sizeof (ebitset_elt *));
+	      (newsize - oldsize) * sizeof (ebitset_elt *));
     }
   else
     {
       /* The bitset needs to shrink.  There's no point deallocating
-         the memory unless it is shrinking by a reasonable amount.  */
+	 the memory unless it is shrinking by a reasonable amount.  */
       if ((oldsize - newsize) >= oldsize / 2)
-        {
-          EBITSET_ELTS (src)
-            = realloc (EBITSET_ELTS (src), newsize * sizeof (ebitset_elt *));
-          EBITSET_ASIZE (src) = newsize;
-        }
+	{
+	  EBITSET_ELTS (src)
+	    = realloc (EBITSET_ELTS (src), newsize * sizeof (ebitset_elt *));
+	  EBITSET_ASIZE (src) = newsize;
+	}
 
       /* Need to prune any excess bits.  FIXME.  */
     }
@@ -190,16 +190,16 @@ ebitset_elt_alloc (void)
   else
     {
       if (!ebitset_obstack_init)
-        {
-          ebitset_obstack_init = true;
+	{
+	  ebitset_obstack_init = true;
 
-          /* Let particular systems override the size of a chunk.  */
+	  /* Let particular systems override the size of a chunk.  */
 
 #ifndef OBSTACK_CHUNK_SIZE
 #define OBSTACK_CHUNK_SIZE 0
 #endif
 
-          /* Let them override the alloc and free routines too.  */
+	  /* Let them override the alloc and free routines too.  */
 
 #ifndef OBSTACK_CHUNK_ALLOC
 #define OBSTACK_CHUNK_ALLOC xmalloc
@@ -213,16 +213,16 @@ ebitset_elt_alloc (void)
 #define __alignof__(type) 0
 #endif
 
-          obstack_specify_allocation (&ebitset_obstack, OBSTACK_CHUNK_SIZE,
-                                      __alignof__ (ebitset_elt),
-                                      OBSTACK_CHUNK_ALLOC,
-                                      OBSTACK_CHUNK_FREE);
-        }
+	  obstack_specify_allocation (&ebitset_obstack, OBSTACK_CHUNK_SIZE,
+				      __alignof__ (ebitset_elt),
+				      OBSTACK_CHUNK_ALLOC,
+				      OBSTACK_CHUNK_FREE);
+	}
 
       /* Perhaps we should add a number of new elements to the free
-         list.  */
+	 list.  */
       elt = (ebitset_elt *) obstack_alloc (&ebitset_obstack,
-                                           sizeof (ebitset_elt));
+					   sizeof (ebitset_elt));
     }
 
   return elt;
@@ -293,7 +293,7 @@ ebitset_elt_zero_p (ebitset_elt *elt)
 
 static ebitset_elt *
 ebitset_elt_find (bitset bset, bitset_bindex bindex,
-                  enum ebitset_find_mode mode)
+		  enum ebitset_find_mode mode)
 {
   ebitset_elt *elt;
   bitset_windex size;
@@ -308,13 +308,13 @@ ebitset_elt_find (bitset bset, bitset_bindex bindex,
   if (eindex < size)
     {
       if ((elt = elts[eindex]))
-        {
-          if (EBITSET_WORDS (elt) == bset->b.cdata)
-            return elt;
+	{
+	  if (EBITSET_WORDS (elt) == bset->b.cdata)
+	    return elt;
 
-          EBITSET_CACHE_SET (bset, eindex);
-          return elt;
-        }
+	  EBITSET_CACHE_SET (bset, eindex);
+	  return elt;
+	}
     }
 
   /* The element could not be found.  */
@@ -329,7 +329,7 @@ ebitset_elt_find (bitset bset, bitset_bindex bindex,
 
     case EBITSET_CREATE:
       if (eindex >= size)
-        ebitset_resize (bset, bindex);
+	ebitset_resize (bset, bindex);
 
       /* Create a new element.  */
       elt = ebitset_elt_calloc ();
@@ -361,22 +361,22 @@ ebitset_weed (bitset bset)
       ebitset_elt *elt = elts[j];
 
       if (elt)
-        {
-          if (ebitset_elt_zero_p (elt))
-            {
-              ebitset_elt_remove (bset, j);
-              count++;
-            }
-        }
+	{
+	  if (ebitset_elt_zero_p (elt))
+	    {
+	      ebitset_elt_remove (bset, j);
+	      count++;
+	    }
+	}
       else
-        count++;
+	count++;
     }
 
   count = j - count;
   if (!count)
     {
       /* All the bits are zero.  We could shrink the elts.
-         For now just mark BSET as known to be zero.  */
+	 For now just mark BSET as known to be zero.  */
       EBITSET_ZERO_SET (bset);
     }
   else
@@ -402,7 +402,7 @@ ebitset_zero (bitset bset)
       ebitset_elt *elt = elts[j];
 
       if (elt)
-        ebitset_elt_remove (bset, j);
+	ebitset_elt_remove (bset, j);
     }
 
   /* All the bits are zero.  We could shrink the elts.
@@ -437,13 +437,13 @@ ebitset_equal_p (bitset dst, bitset src)
       ebitset_elt *delt = delts[j];
 
       if (!selt && !delt)
-        continue;
+	continue;
       if ((selt && !delt) || (!selt && delt))
-        return false;
+	return false;
 
       for (i = 0; i < EBITSET_ELT_WORDS; i++)
-        if (EBITSET_WORDS (selt)[i] != EBITSET_WORDS (delt)[i])
-          return false;
+	if (EBITSET_WORDS (selt)[i] != EBITSET_WORDS (delt)[i])
+	  return false;
     }
   return true;
 }
@@ -472,14 +472,14 @@ ebitset_copy_ (bitset dst, bitset src)
       ebitset_elt *selt = selts[j];
 
       if (selt)
-        {
-          ebitset_elt *tmp;
+	{
+	  ebitset_elt *tmp;
 
-          tmp = ebitset_elt_alloc ();
-          delts[j] = tmp;
-          memcpy (EBITSET_WORDS (tmp), EBITSET_WORDS (selt),
-                  sizeof (EBITSET_WORDS (selt)));
-        }
+	  tmp = ebitset_elt_alloc ();
+	  delts[j] = tmp;
+	  memcpy (EBITSET_WORDS (tmp), EBITSET_WORDS (selt),
+		  sizeof (EBITSET_WORDS (selt)));
+	}
     }
   EBITSET_NONZERO_SET (dst);
 }
@@ -545,9 +545,9 @@ ebitset_test (bitset src, bitset_bindex bitno)
   bitset_windex windex = bitno / BITSET_WORD_BITS;
 
   return (ebitset_elt_find (src, bitno, EBITSET_FIND)
-          && ((src->b.cdata[windex - src->b.cindex]
-               >> (bitno % BITSET_WORD_BITS))
-              & 1));
+	  && ((src->b.cdata[windex - src->b.cindex]
+	       >> (bitno % BITSET_WORD_BITS))
+	      & 1));
 }
 
 
@@ -564,7 +564,7 @@ ebitset_free (bitset bset)
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 ebitset_list_reverse (bitset bset, bitset_bindex *list,
-                      bitset_bindex num, bitset_bindex *next)
+		      bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex n_bits;
   bitset_bindex bitno;
@@ -610,33 +610,33 @@ ebitset_list_reverse (bitset bset, bitset_bindex *list,
 
       elt = elts[eindex];
       if (elt)
-        {
-          srcp = EBITSET_WORDS (elt);
+	{
+	  srcp = EBITSET_WORDS (elt);
 
-          do
-            {
-              bitset_word word;
+	  do
+	    {
+	      bitset_word word;
 
-              word = srcp[woffset] << (BITSET_WORD_BITS - 1 - bcount);
+	      word = srcp[woffset] << (BITSET_WORD_BITS - 1 - bcount);
 
-              for (; word; bcount--)
-                {
-                  if (word & BITSET_MSB)
-                    {
-                      list[count++] = boffset + bcount;
-                      if (count >= num)
-                        {
-                          *next = n_bits - (boffset + bcount);
-                          return count;
-                        }
-                    }
-                  word <<= 1;
-                }
-              boffset -= BITSET_WORD_BITS;
-              bcount = BITSET_WORD_BITS - 1;
-            }
-          while (woffset--);
-        }
+	      for (; word; bcount--)
+		{
+		  if (word & BITSET_MSB)
+		    {
+		      list[count++] = boffset + bcount;
+		      if (count >= num)
+			{
+			  *next = n_bits - (boffset + bcount);
+			  return count;
+			}
+		    }
+		  word <<= 1;
+		}
+	      boffset -= BITSET_WORD_BITS;
+	      bcount = BITSET_WORD_BITS - 1;
+	    }
+	  while (woffset--);
+	}
 
       woffset = EBITSET_ELT_WORDS - 1;
       boffset = eindex * EBITSET_ELT_BITS - BITSET_WORD_BITS;
@@ -653,7 +653,7 @@ ebitset_list_reverse (bitset bset, bitset_bindex *list,
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 ebitset_list (bitset bset, bitset_bindex *list,
-              bitset_bindex num, bitset_bindex *next)
+	      bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex bitno;
   bitset_windex windex;
@@ -680,33 +680,33 @@ ebitset_list (bitset bset, bitset_bindex *list,
 
       elt = elts[eindex];
       if (elt)
-        {
-          bitset_windex woffset;
-          bitset_word *srcp = EBITSET_WORDS (elt);
+	{
+	  bitset_windex woffset;
+	  bitset_word *srcp = EBITSET_WORDS (elt);
 
-          windex = bitno / BITSET_WORD_BITS;
-          woffset = eindex * EBITSET_ELT_WORDS;
+	  windex = bitno / BITSET_WORD_BITS;
+	  woffset = eindex * EBITSET_ELT_WORDS;
 
-          for (; (windex - woffset) < EBITSET_ELT_WORDS; windex++)
-            {
-              word = srcp[windex - woffset] >> (bitno % BITSET_WORD_BITS);
+	  for (; (windex - woffset) < EBITSET_ELT_WORDS; windex++)
+	    {
+	      word = srcp[windex - woffset] >> (bitno % BITSET_WORD_BITS);
 
-              for (; word; bitno++)
-                {
-                  if (word & 1)
-                    {
-                      list[count++] = bitno;
-                      if (count >= num)
-                        {
-                          *next = bitno + 1;
-                          return count;
-                        }
-                    }
-                  word >>= 1;
-                }
-              bitno = (windex + 1) * BITSET_WORD_BITS;
-            }
-        }
+	      for (; word; bitno++)
+		{
+		  if (word & 1)
+		    {
+		      list[count++] = bitno;
+		      if (count >= num)
+			{
+			  *next = bitno + 1;
+			  return count;
+			}
+		    }
+		  word >>= 1;
+		}
+	      bitno = (windex + 1) * BITSET_WORD_BITS;
+	    }
+	}
 
       /* Skip to next element.  */
       eindex++;
@@ -722,108 +722,108 @@ ebitset_list (bitset bset, bitset_bindex *list,
 
       elt = elts[eindex];
       if (!elt)
-        continue;
+	continue;
 
       srcp = EBITSET_WORDS (elt);
       windex = eindex * EBITSET_ELT_WORDS;
 
       if ((count + EBITSET_ELT_BITS) < num)
-        {
-          /* The coast is clear, plant boot!  */
+	{
+	  /* The coast is clear, plant boot!  */
 
 #if EBITSET_ELT_WORDS == 2
-          word = srcp[0];
-          if (word)
-            {
-              if (!(word & 0xffff))
-                {
-                  word >>= 16;
-                  bitno += 16;
-                }
-              if (!(word & 0xff))
-                {
-                  word >>= 8;
-                  bitno += 8;
-                }
-              for (; word; bitno++)
-                {
-                  if (word & 1)
-                    list[count++] = bitno;
-                  word >>= 1;
-                }
-            }
-          windex++;
-          bitno = windex * BITSET_WORD_BITS;
+	  word = srcp[0];
+	  if (word)
+	    {
+	      if (!(word & 0xffff))
+		{
+		  word >>= 16;
+		  bitno += 16;
+		}
+	      if (!(word & 0xff))
+		{
+		  word >>= 8;
+		  bitno += 8;
+		}
+	      for (; word; bitno++)
+		{
+		  if (word & 1)
+		    list[count++] = bitno;
+		  word >>= 1;
+		}
+	    }
+	  windex++;
+	  bitno = windex * BITSET_WORD_BITS;
 
-          word = srcp[1];
-          if (word)
-            {
-              if (!(word & 0xffff))
-                {
-                  word >>= 16;
-                  bitno += 16;
-                }
-              for (; word; bitno++)
-                {
-                  if (word & 1)
-                    list[count++] = bitno;
-                  word >>= 1;
-                }
-            }
-          windex++;
-          bitno = windex * BITSET_WORD_BITS;
+	  word = srcp[1];
+	  if (word)
+	    {
+	      if (!(word & 0xffff))
+		{
+		  word >>= 16;
+		  bitno += 16;
+		}
+	      for (; word; bitno++)
+		{
+		  if (word & 1)
+		    list[count++] = bitno;
+		  word >>= 1;
+		}
+	    }
+	  windex++;
+	  bitno = windex * BITSET_WORD_BITS;
 #else
-          for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++)
-            {
-              bitno = windex * BITSET_WORD_BITS;
+	  for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++)
+	    {
+	      bitno = windex * BITSET_WORD_BITS;
 
-              word = srcp[i];
-              if (word)
-                {
-                  if (!(word & 0xffff))
-                    {
-                      word >>= 16;
-                      bitno += 16;
-                    }
-                  if (!(word & 0xff))
-                    {
-                      word >>= 8;
-                      bitno += 8;
-                    }
-                  for (; word; bitno++)
-                    {
-                      if (word & 1)
-                        list[count++] = bitno;
-                      word >>= 1;
-                    }
-                }
-            }
+	      word = srcp[i];
+	      if (word)
+		{
+		  if (!(word & 0xffff))
+		    {
+		      word >>= 16;
+		      bitno += 16;
+		    }
+		  if (!(word & 0xff))
+		    {
+		      word >>= 8;
+		      bitno += 8;
+		    }
+		  for (; word; bitno++)
+		    {
+		      if (word & 1)
+			list[count++] = bitno;
+		      word >>= 1;
+		    }
+		}
+	    }
 #endif
-        }
+	}
       else
-        {
-          /* Tread more carefully since we need to check
-             if array overflows.  */
+	{
+	  /* Tread more carefully since we need to check
+	     if array overflows.  */
 
-          for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++)
-            {
-              bitno = windex * BITSET_WORD_BITS;
+	  for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++)
+	    {
+	      bitno = windex * BITSET_WORD_BITS;
 
-              for (word = srcp[i]; word; bitno++)
-                {
-                  if (word & 1)
-                    {
-                      list[count++] = bitno;
-                      if (count >= num)
-                        {
-                          *next = bitno + 1;
-                          return count;
-                        }
-                    }
-                  word >>= 1;
-                }
-            }
-        }
+	      for (word = srcp[i]; word; bitno++)
+		{
+		  if (word & 1)
+		    {
+		      list[count++] = bitno;
+		      if (count >= num)
+			{
+			  *next = bitno + 1;
+			  return count;
+			}
+		    }
+		  word >>= 1;
+		}
+	    }
+	}
     }
 
   *next = bitno;
@@ -853,19 +853,19 @@ ebitset_unused_clear (bitset dst)
 
       elt = elts[eindex];
       if (elt)
-        {
-          bitset_windex windex;
-          bitset_windex woffset;
-          bitset_word *srcp = EBITSET_WORDS (elt);
+	{
+	  bitset_windex windex;
+	  bitset_windex woffset;
+	  bitset_word *srcp = EBITSET_WORDS (elt);
 
-          windex = n_bits / BITSET_WORD_BITS;
-          woffset = eindex * EBITSET_ELT_WORDS;
+	  windex = n_bits / BITSET_WORD_BITS;
+	  woffset = eindex * EBITSET_ELT_WORDS;
 
-          srcp[windex - woffset] &= ((bitset_word) 1 << last_bit) - 1;
-          windex++;
-          for (; (windex - woffset) < EBITSET_ELT_WORDS; windex++)
-            srcp[windex - woffset] = 0;
-        }
+	  srcp[windex - woffset] &= ((bitset_word) 1 << last_bit) - 1;
+	  windex++;
+	  for (; (windex - woffset) < EBITSET_ELT_WORDS; windex++)
+	    srcp[windex - woffset] = 0;
+	}
     }
 }
 
@@ -879,9 +879,9 @@ ebitset_ones (bitset dst)
   for (j = 0; j < EBITSET_SIZE (dst); j++)
     {
       /* Create new elements if they cannot be found.  Perhaps
-         we should just add pointers to a ones element?  */
+	 we should just add pointers to a ones element?  */
       elt =
-        ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_CREATE);
+	ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_CREATE);
       memset (EBITSET_WORDS (elt), -1, sizeof (EBITSET_WORDS (elt)));
     }
   EBITSET_NONZERO_SET (dst);
@@ -904,12 +904,12 @@ ebitset_empty_p (bitset dst)
       ebitset_elt *elt = elts[j];
 
       if (elt)
-        {
-          if (!ebitset_elt_zero_p (elt))
-            return 0;
-          /* Do some weeding as we go.  */
-          ebitset_elt_remove (dst, j);
-        }
+	{
+	  if (!ebitset_elt_zero_p (elt))
+	    return 0;
+	  /* Do some weeding as we go.  */
+	  ebitset_elt_remove (dst, j);
+	}
     }
 
   /* All the bits are zero.  We could shrink the elts.
@@ -932,14 +932,14 @@ ebitset_not (bitset dst, bitset src)
   for (j = 0; j < EBITSET_SIZE (src); j++)
     {
       /* Create new elements for dst if they cannot be found
-         or substitute zero elements if src elements not found.  */
+	 or substitute zero elements if src elements not found.  */
       selt =
-        ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_SUBST);
+	ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_SUBST);
       delt =
-        ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_CREATE);
+	ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_CREATE);
 
       for (i = 0; i < EBITSET_ELT_WORDS; i++)
-        EBITSET_WORDS (delt)[i] = ~EBITSET_WORDS (selt)[i];
+	EBITSET_WORDS (delt)[i] = ~EBITSET_WORDS (selt)[i];
     }
   EBITSET_NONZERO_SET (dst);
   ebitset_unused_clear (dst);
@@ -972,17 +972,17 @@ ebitset_subset_p (bitset dst, bitset src)
       delt = j < dsize ? delts[j] : 0;
 
       if (!selt && !delt)
-        continue;
+	continue;
 
       if (!selt)
-        selt = &ebitset_zero_elts[0];
+	selt = &ebitset_zero_elts[0];
       if (!delt)
-        delt = &ebitset_zero_elts[0];
+	delt = &ebitset_zero_elts[0];
 
       for (i = 0; i < EBITSET_ELT_WORDS; i++)
-        if (EBITSET_WORDS (delt)[i]
-            != (EBITSET_WORDS (selt)[i] | EBITSET_WORDS (delt)[i]))
-          return false;
+	if (EBITSET_WORDS (delt)[i]
+	    != (EBITSET_WORDS (selt)[i] | EBITSET_WORDS (delt)[i]))
+	  return false;
     }
   return true;
 }
@@ -1014,11 +1014,11 @@ ebitset_disjoint_p (bitset dst, bitset src)
       delt = j < dsize ? delts[j] : 0;
 
       if (!selt || !delt)
-        continue;
+	continue;
 
       for (i = 0; i < EBITSET_ELT_WORDS; i++)
-        if ((EBITSET_WORDS (selt)[i] & EBITSET_WORDS (delt)[i]))
-          return false;
+	if ((EBITSET_WORDS (selt)[i] & EBITSET_WORDS (delt)[i]))
+	  return false;
     }
   return true;
 }
@@ -1066,93 +1066,93 @@ ebitset_op3_cmp (bitset dst, bitset src1, bitset src2, enum bitset_ops op)
       delt = j < dsize ? delts[j] : 0;
 
       if (!selt1 && !selt2)
-        {
-          if (delt)
-            {
-              changed = true;
-              ebitset_elt_remove (dst, j);
-            }
-          continue;
-        }
+	{
+	  if (delt)
+	    {
+	      changed = true;
+	      ebitset_elt_remove (dst, j);
+	    }
+	  continue;
+	}
 
       if (!selt1)
-        selt1 = &ebitset_zero_elts[0];
+	selt1 = &ebitset_zero_elts[0];
       if (!selt2)
-        selt2 = &ebitset_zero_elts[0];
+	selt2 = &ebitset_zero_elts[0];
       if (!delt)
-        delt = ebitset_elt_calloc ();
+	delt = ebitset_elt_calloc ();
       else
-        delts[j] = 0;
+	delts[j] = 0;
 
       srcp1 = EBITSET_WORDS (selt1);
       srcp2 = EBITSET_WORDS (selt2);
       dstp = EBITSET_WORDS (delt);
       switch (op)
-        {
-        default:
-          abort ();
+	{
+	default:
+	  abort ();
 
-        case BITSET_OP_OR:
-          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ | *srcp2++;
+	case BITSET_OP_OR:
+	  for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ | *srcp2++;
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
 
-        case BITSET_OP_AND:
-          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ & *srcp2++;
+	case BITSET_OP_AND:
+	  for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ & *srcp2++;
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
 
-        case BITSET_OP_XOR:
-          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ ^ *srcp2++;
+	case BITSET_OP_XOR:
+	  for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ ^ *srcp2++;
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
 
-        case BITSET_OP_ANDN:
-          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ & ~(*srcp2++);
+	case BITSET_OP_ANDN:
+	  for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ & ~(*srcp2++);
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
-        }
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
+	}
 
       if (!ebitset_elt_zero_p (delt))
-        {
-          ebitset_elt_add (dst, delt, j);
-        }
+	{
+	  ebitset_elt_add (dst, delt, j);
+	}
       else
-        {
-          ebitset_elt_free (delt);
-        }
+	{
+	  ebitset_elt_free (delt);
+	}
     }
 
   /* If we have elements of DST left over, free them all.  */
@@ -1165,7 +1165,7 @@ ebitset_op3_cmp (bitset dst, bitset src1, bitset src2, enum bitset_ops op)
       delt = delts[j];
 
       if (delt)
-        ebitset_elt_remove (dst, j);
+	ebitset_elt_remove (dst, j);
     }
 
   EBITSET_NONZERO_SET (dst);

lib/lbitset.c

@@ -1,6 +1,7 @@
 /* Functions to support link list bitsets.
 
-   Copyright (C) 2002-2004, 2006, 2009-2012 Free Software Foundation, Inc.
+   Copyright (C) 2002-2004, 2006, 2009-2012 Free Software Foundation,
+   Inc.
 
    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 
@@ -59,10 +60,10 @@ typedef bitset_word lbitset_word;
    These are linked together in a doubly-linked list.  */
 typedef struct lbitset_elt_struct
 {
-  struct lbitset_elt_struct *next;      /* Next element.  */
-  struct lbitset_elt_struct *prev;      /* Previous element.  */
-  bitset_windex index;  /* bitno / BITSET_WORD_BITS.  */
-  bitset_word words[LBITSET_ELT_WORDS]; /* Bits that are set.  */
+  struct lbitset_elt_struct *next;	/* Next element.  */
+  struct lbitset_elt_struct *prev;	/* Previous element.  */
+  bitset_windex index;	/* bitno / BITSET_WORD_BITS.  */
+  bitset_word words[LBITSET_ELT_WORDS];	/* Bits that are set.  */
 }
 lbitset_elt;
 
@@ -75,7 +76,7 @@ static lbitset_elt lbitset_zero_elts[3]; /* Elements of all zero bits.  */
 /* Obstack to allocate bitset elements from.  */
 static struct obstack lbitset_obstack;
 static bool lbitset_obstack_init = false;
-static lbitset_elt *lbitset_free_list;  /* Free list of bitset elements.  */
+static lbitset_elt *lbitset_free_list;	/* Free list of bitset elements.  */
 
 extern void debug_lbitset (bitset);
 
@@ -101,16 +102,16 @@ lbitset_elt_alloc (void)
   else
     {
       if (!lbitset_obstack_init)
-        {
-          lbitset_obstack_init = true;
+	{
+	  lbitset_obstack_init = true;
 
-          /* Let particular systems override the size of a chunk.  */
+	  /* Let particular systems override the size of a chunk.  */
 
 #ifndef OBSTACK_CHUNK_SIZE
 #define OBSTACK_CHUNK_SIZE 0
 #endif
 
-          /* Let them override the alloc and free routines too.  */
+	  /* Let them override the alloc and free routines too.  */
 
 #ifndef OBSTACK_CHUNK_ALLOC
 #define OBSTACK_CHUNK_ALLOC xmalloc
@@ -124,16 +125,16 @@ lbitset_elt_alloc (void)
 #define __alignof__(type) 0
 #endif
 
-          obstack_specify_allocation (&lbitset_obstack, OBSTACK_CHUNK_SIZE,
-                                      __alignof__ (lbitset_elt),
-                                      OBSTACK_CHUNK_ALLOC,
-                                      OBSTACK_CHUNK_FREE);
-        }
+	  obstack_specify_allocation (&lbitset_obstack, OBSTACK_CHUNK_SIZE,
+				      __alignof__ (lbitset_elt),
+				      OBSTACK_CHUNK_ALLOC,
+				      OBSTACK_CHUNK_FREE);
+	}
 
       /* Perhaps we should add a number of new elements to the free
-         list.  */
+	 list.  */
       elt = (lbitset_elt *) obstack_alloc (&lbitset_obstack,
-                                           sizeof (lbitset_elt));
+					   sizeof (lbitset_elt));
     }
 
   return elt;
@@ -184,20 +185,20 @@ lbitset_elt_unlink (bitset bset, lbitset_elt *elt)
   if (LBITSET_CURRENT (bset) == elt)
     {
       if (next)
-        {
-          bset->b.cdata = next->words;
-          bset->b.cindex = next->index;
-        }
+	{
+	  bset->b.cdata = next->words;
+	  bset->b.cindex = next->index;
+	}
       else if (prev)
-        {
-          bset->b.cdata = prev->words;
-          bset->b.cindex = prev->index;
-        }
+	{
+	  bset->b.cdata = prev->words;
+	  bset->b.cindex = prev->index;
+	}
       else
-        {
-          bset->b.csize = 0;
-          bset->b.cdata = 0;
-        }
+	{
+	  bset->b.csize = 0;
+	  bset->b.cdata = 0;
+	}
     }
 
   lbitset_elt_free (elt);
@@ -277,13 +278,13 @@ lbitset_elt_link (bitset bset, lbitset_elt *elt)
   else if (windex < bset->b.cindex)
     {
       for (ptr = current;
-           ptr->prev && ptr->prev->index > windex; ptr = ptr->prev)
-        continue;
+	   ptr->prev && ptr->prev->index > windex; ptr = ptr->prev)
+	continue;
 
       if (ptr->prev)
-        ptr->prev->next = elt;
+	ptr->prev->next = elt;
       else
-        LBITSET_HEAD (bset) = elt;
+	LBITSET_HEAD (bset) = elt;
 
       elt->prev = ptr->prev;
       elt->next = ptr;
@@ -294,13 +295,13 @@ lbitset_elt_link (bitset bset, lbitset_elt *elt)
   else
     {
       for (ptr = current;
-           ptr->next && ptr->next->index < windex; ptr = ptr->next)
-        continue;
+	   ptr->next && ptr->next->index < windex; ptr = ptr->next)
+	continue;
 
       if (ptr->next)
-        ptr->next->prev = elt;
+	ptr->next->prev = elt;
       else
-        LBITSET_TAIL (bset) = elt;
+	LBITSET_TAIL (bset) = elt;
 
       elt->next = ptr->next;
       elt->prev = ptr;
@@ -316,7 +317,7 @@ lbitset_elt_link (bitset bset, lbitset_elt *elt)
 
 static lbitset_elt *
 lbitset_elt_find (bitset bset, bitset_windex windex,
-                  enum lbitset_find_mode mode)
+		  enum lbitset_find_mode mode)
 {
   lbitset_elt *elt;
   lbitset_elt *current;
@@ -326,7 +327,7 @@ lbitset_elt_find (bitset bset, bitset_windex windex,
       current = LBITSET_CURRENT (bset);
       /* Check if element is the cached element.  */
       if ((windex - bset->b.cindex) < bset->b.csize)
-        return current;
+	return current;
     }
   else
     {
@@ -336,28 +337,28 @@ lbitset_elt_find (bitset bset, bitset_windex windex,
   if (current)
     {
       if (windex < bset->b.cindex)
-        {
-          for (elt = current;
-               elt->prev && elt->index > windex; elt = elt->prev)
-            continue;
-        }
+	{
+	  for (elt = current;
+	       elt->prev && elt->index > windex; elt = elt->prev)
+	    continue;
+	}
       else
-        {
-          for (elt = current;
-               elt->next && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
-               elt = elt->next)
-            continue;
-        }
+	{
+	  for (elt = current;
+	       elt->next && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
+	       elt = elt->next)
+	    continue;
+	}
 
       /* ELT is the nearest to the one we want.  If it's not the one
-         we want, the one we want does not exist.  */
+	 we want, the one we want does not exist.  */
       if (windex - elt->index < LBITSET_ELT_WORDS)
-        {
-          bset->b.cindex = elt->index;
-          bset->b.csize = LBITSET_ELT_WORDS;
-          bset->b.cdata = elt->words;
-          return elt;
-        }
+	{
+	  bset->b.cindex = elt->index;
+	  bset->b.csize = LBITSET_ELT_WORDS;
+	  bset->b.cdata = elt->words;
+	  return elt;
+	}
     }
 
   switch (mode)
@@ -393,7 +394,7 @@ lbitset_weed (bitset bset)
     {
       next = elt->next;
       if (lbitset_elt_zero_p (elt))
-        lbitset_elt_unlink (bset, elt);
+	lbitset_elt_unlink (bset, elt);
     }
 }
 
@@ -430,11 +431,11 @@ lbitset_equal_p (bitset dst, bitset src)
        selt && delt; selt = selt->next, delt = delt->next)
     {
       if (selt->index != delt->index)
-        return false;
+	return false;
 
       for (j = 0; j < LBITSET_ELT_WORDS; j++)
-        if (delt->words[j] != selt->words[j])
-          return false;
+	if (delt->words[j] != selt->words[j])
+	  return false;
     }
   return !selt && !delt;
 }
@@ -466,9 +467,9 @@ lbitset_copy (bitset dst, bitset src)
       tmp->prev = prev;
       tmp->next = 0;
       if (prev)
-        prev->next = tmp;
+	prev->next = tmp;
       else
-        LBITSET_HEAD (dst) = tmp;
+	LBITSET_HEAD (dst) = tmp;
       prev = tmp;
 
       memcpy (tmp->words, elt->words, sizeof (elt->words));
@@ -548,9 +549,9 @@ lbitset_test (bitset src, bitset_bindex bitno)
   bitset_windex windex = bitno / BITSET_WORD_BITS;
 
   return (lbitset_elt_find (src, windex, LBITSET_FIND)
-          && ((src->b.cdata[windex - src->b.cindex]
-               >> (bitno % BITSET_WORD_BITS))
-              & 1));
+	  && ((src->b.cdata[windex - src->b.cindex]
+	       >> (bitno % BITSET_WORD_BITS))
+	      & 1));
 }
 
 
@@ -566,7 +567,7 @@ lbitset_free (bitset bset)
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 lbitset_list_reverse (bitset bset, bitset_bindex *list,
-                      bitset_bindex num, bitset_bindex *next)
+		      bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex rbitno;
   bitset_bindex bitno;
@@ -602,7 +603,7 @@ lbitset_list_reverse (bitset bset, bitset_bindex *list,
   if (windex >= elt->index + LBITSET_ELT_WORDS)
     {
       /* We are trying to start in no-mans land so start
-         at end of current elt.  */
+	 at end of current elt.  */
       bcount = BITSET_WORD_BITS - 1;
       windex = elt->index + LBITSET_ELT_WORDS - 1;
     }
@@ -622,33 +623,33 @@ lbitset_list_reverse (bitset bset, bitset_bindex *list,
       bitset_word *srcp = elt->words;
 
       for (; (windex - elt->index) < LBITSET_ELT_WORDS;
-           windex--, boffset -= BITSET_WORD_BITS,
-             bcount = BITSET_WORD_BITS - 1)
-        {
-          word =
-            srcp[windex - elt->index] << (BITSET_WORD_BITS - 1 - bcount);
+	   windex--, boffset -= BITSET_WORD_BITS,
+	     bcount = BITSET_WORD_BITS - 1)
+	{
+	  word =
+	    srcp[windex - elt->index] << (BITSET_WORD_BITS - 1 - bcount);
 
-          for (; word; bcount--)
-            {
-              if (word & BITSET_MSB)
-                {
-                  list[count++] = boffset + bcount;
-                  if (count >= num)
-                    {
-                      *next = n_bits - (boffset + bcount);
-                      return count;
-                    }
-                }
-              word <<= 1;
-            }
-        }
+	  for (; word; bcount--)
+	    {
+	      if (word & BITSET_MSB)
+		{
+		  list[count++] = boffset + bcount;
+		  if (count >= num)
+		    {
+		      *next = n_bits - (boffset + bcount);
+		      return count;
+		    }
+		}
+	      word <<= 1;
+	    }
+	}
 
       elt = elt->prev;
       if (elt)
-        {
-          windex = elt->index + LBITSET_ELT_WORDS - 1;
-          boffset = windex * BITSET_WORD_BITS;
-        }
+	{
+	  windex = elt->index + LBITSET_ELT_WORDS - 1;
+	  boffset = windex * BITSET_WORD_BITS;
+	}
     }
 
   *next = n_bits - (boffset + 1);
@@ -661,7 +662,7 @@ lbitset_list_reverse (bitset bset, bitset_bindex *list,
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 lbitset_list (bitset bset, bitset_bindex *list,
-              bitset_bindex num, bitset_bindex *next)
+	      bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex bitno;
   bitset_windex windex;
@@ -692,51 +693,51 @@ lbitset_list (bitset bset, bitset_bindex *list,
 
       /* Skip to starting element.  */
       for (elt = head;
-           elt && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
-           elt = elt->next)
-        continue;
+	   elt && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
+	   elt = elt->next)
+	continue;
 
       if (!elt)
-        return 0;
+	return 0;
 
       if (windex < elt->index)
-        {
-          windex = elt->index;
-          bitno = windex * BITSET_WORD_BITS;
-        }
+	{
+	  windex = elt->index;
+	  bitno = windex * BITSET_WORD_BITS;
+	}
       else
-        {
-          bitset_word *srcp = elt->words;
+	{
+	  bitset_word *srcp = elt->words;
 
-          /* We are starting within an element.  */
+	  /* We are starting within an element.  */
 
-          for (; (windex - elt->index) < LBITSET_ELT_WORDS; windex++)
-            {
-              word = srcp[windex - elt->index] >> (bitno % BITSET_WORD_BITS);
+	  for (; (windex - elt->index) < LBITSET_ELT_WORDS; windex++)
+	    {
+	      word = srcp[windex - elt->index] >> (bitno % BITSET_WORD_BITS);
 
-              for (; word; bitno++)
-                {
-                  if (word & 1)
-                    {
-                      list[count++] = bitno;
-                      if (count >= num)
-                        {
-                          *next = bitno + 1;
-                          return count;
-                        }
-                    }
-                  word >>= 1;
-                }
-              bitno = (windex + 1) * BITSET_WORD_BITS;
-            }
+	      for (; word; bitno++)
+		{
+		  if (word & 1)
+		    {
+		      list[count++] = bitno;
+		      if (count >= num)
+			{
+			  *next = bitno + 1;
+			  return count;
+			}
+		    }
+		  word >>= 1;
+		}
+	      bitno = (windex + 1) * BITSET_WORD_BITS;
+	    }
 
-          elt = elt->next;
-          if (elt)
-            {
-              windex = elt->index;
-              bitno = windex * BITSET_WORD_BITS;
-            }
-        }
+	  elt = elt->next;
+	  if (elt)
+	    {
+	      windex = elt->index;
+	      bitno = windex * BITSET_WORD_BITS;
+	    }
+	}
     }
 
 
@@ -749,109 +750,109 @@ lbitset_list (bitset bset, bitset_bindex *list,
       bitset_word *srcp = elt->words;
 
       if ((count + LBITSET_ELT_BITS) < num)
-        {
-          /* The coast is clear, plant boot!  */
+	{
+	  /* The coast is clear, plant boot!  */
 
 #if LBITSET_ELT_WORDS == 2
-          word = srcp[0];
-          if (word)
-            {
-              if (!(word & 0xffff))
-                {
-                  word >>= 16;
-                  bitno += 16;
-                }
-              if (!(word & 0xff))
-                {
-                  word >>= 8;
-                  bitno += 8;
-                }
-              for (; word; bitno++)
-                {
-                  if (word & 1)
-                    list[count++] = bitno;
-                  word >>= 1;
-                }
-            }
-          windex++;
-          bitno = windex * BITSET_WORD_BITS;
+	  word = srcp[0];
+	  if (word)
+	    {
+	      if (!(word & 0xffff))
+		{
+		  word >>= 16;
+		  bitno += 16;
+		}
+	      if (!(word & 0xff))
+		{
+		  word >>= 8;
+		  bitno += 8;
+		}
+	      for (; word; bitno++)
+		{
+		  if (word & 1)
+		    list[count++] = bitno;
+		  word >>= 1;
+		}
+	    }
+	  windex++;
+	  bitno = windex * BITSET_WORD_BITS;
 
-          word = srcp[1];
-          if (word)
-            {
-              if (!(word & 0xffff))
-                {
-                  word >>= 16;
-                  bitno += 16;
-                }
-              for (; word; bitno++)
-                {
-                  if (word & 1)
-                    list[count++] = bitno;
-                  word >>= 1;
-                }
-            }
-          windex++;
-          bitno = windex * BITSET_WORD_BITS;
+	  word = srcp[1];
+	  if (word)
+	    {
+	      if (!(word & 0xffff))
+		{
+		  word >>= 16;
+		  bitno += 16;
+		}
+	      for (; word; bitno++)
+		{
+		  if (word & 1)
+		    list[count++] = bitno;
+		  word >>= 1;
+		}
+	    }
+	  windex++;
+	  bitno = windex * BITSET_WORD_BITS;
 #else
-          for (i = 0; i < LBITSET_ELT_WORDS; i++)
-            {
-              word = srcp[i];
-              if (word)
-                {
-                  if (!(word & 0xffff))
-                    {
-                      word >>= 16;
-                      bitno += 16;
-                    }
-                  if (!(word & 0xff))
-                    {
-                      word >>= 8;
-                      bitno += 8;
-                    }
-                  for (; word; bitno++)
-                    {
-                      if (word & 1)
-                        list[count++] = bitno;
-                      word >>= 1;
-                    }
-                }
-              windex++;
-              bitno = windex * BITSET_WORD_BITS;
-            }
+	  for (i = 0; i < LBITSET_ELT_WORDS; i++)
+	    {
+	      word = srcp[i];
+	      if (word)
+		{
+		  if (!(word & 0xffff))
+		    {
+		      word >>= 16;
+		      bitno += 16;
+		    }
+		  if (!(word & 0xff))
+		    {
+		      word >>= 8;
+		      bitno += 8;
+		    }
+		  for (; word; bitno++)
+		    {
+		      if (word & 1)
+			list[count++] = bitno;
+		      word >>= 1;
+		    }
+		}
+	      windex++;
+	      bitno = windex * BITSET_WORD_BITS;
+	    }
 #endif
-        }
+	}
       else
-        {
-          /* Tread more carefully since we need to check
-             if array overflows.  */
+	{
+	  /* Tread more carefully since we need to check
+	     if array overflows.  */
 
-          for (i = 0; i < LBITSET_ELT_WORDS; i++)
-            {
-              for (word = srcp[i]; word; bitno++)
-                {
-                  if (word & 1)
-                    {
-                      list[count++] = bitno;
-                      if (count >= num)
-                        {
-                          *next = bitno + 1;
-                          return count;
-                        }
-                    }
-                  word >>= 1;
-                }
-              windex++;
-              bitno = windex * BITSET_WORD_BITS;
-            }
-        }
+	  for (i = 0; i < LBITSET_ELT_WORDS; i++)
+	    {
+	      for (word = srcp[i]; word; bitno++)
+		{
+		  if (word & 1)
+		    {
+		      list[count++] = bitno;
+		      if (count >= num)
+			{
+			  *next = bitno + 1;
+			  return count;
+			}
+		    }
+		  word >>= 1;
+		}
+	      windex++;
+	      bitno = windex * BITSET_WORD_BITS;
+	    }
+	}
 
       elt = elt->next;
       if (elt)
-        {
-          windex = elt->index;
-          bitno = windex * BITSET_WORD_BITS;
-        }
+	{
+	  windex = elt->index;
+	  bitno = windex * BITSET_WORD_BITS;
+	}
     }
 
   *next = bitno;
@@ -869,7 +870,7 @@ lbitset_empty_p (bitset dst)
     {
       next = elt->next;
       if (!lbitset_elt_zero_p (elt))
-        return 0;
+	return 0;
       /* Weed as we go.  */
       lbitset_elt_unlink (dst, elt);
     }
@@ -902,7 +903,7 @@ lbitset_unused_clear (bitset dst)
       windex++;
 
       for (; (windex - elt->index) < LBITSET_ELT_WORDS; windex++)
-        srcp[windex - elt->index] = 0;
+	srcp[windex - elt->index] = 0;
     }
 }
 
@@ -946,12 +947,12 @@ lbitset_not (bitset dst, bitset src)
   for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
     {
       /* Create new elements for dst if they cannot be found
-         or substitute zero elements if src elements not found.  */
+	 or substitute zero elements if src elements not found.  */
       selt = lbitset_elt_find (src, i, LBITSET_SUBST);
       delt = lbitset_elt_find (dst, i, LBITSET_CREATE);
 
       for (j = 0; j < LBITSET_ELT_WORDS; j++)
-        delt->words[j] = ~selt->words[j];
+	delt->words[j] = ~selt->words[j];
     }
   lbitset_unused_clear (dst);
   lbitset_weed (dst);
@@ -971,26 +972,26 @@ lbitset_subset_p (bitset dst, bitset src)
        selt || delt; selt = selt->next, delt = delt->next)
     {
       if (!selt)
-        selt = &lbitset_zero_elts[0];
+	selt = &lbitset_zero_elts[0];
       else if (!delt)
-        delt = &lbitset_zero_elts[0];
+	delt = &lbitset_zero_elts[0];
       else if (selt->index != delt->index)
-        {
-          if (selt->index < delt->index)
-            {
-              lbitset_zero_elts[2].next = delt;
-              delt = &lbitset_zero_elts[2];
-            }
-          else
-            {
-              lbitset_zero_elts[1].next = selt;
-              selt = &lbitset_zero_elts[1];
-            }
-        }
+	{
+	  if (selt->index < delt->index)
+	    {
+	      lbitset_zero_elts[2].next = delt;
+	      delt = &lbitset_zero_elts[2];
+	    }
+	  else
+	    {
+	      lbitset_zero_elts[1].next = selt;
+	      selt = &lbitset_zero_elts[1];
+	    }
+	}
 
       for (j = 0; j < LBITSET_ELT_WORDS; j++)
-        if (delt->words[j] != (selt->words[j] | delt->words[j]))
-          return false;
+	if (delt->words[j] != (selt->words[j] | delt->words[j]))
+	  return false;
     }
   return true;
 }
@@ -1008,25 +1009,25 @@ lbitset_disjoint_p (bitset dst, bitset src)
        selt && delt; selt = selt->next, delt = delt->next)
     {
       if (selt->index != delt->index)
-        {
-          if (selt->index < delt->index)
-            {
-              lbitset_zero_elts[2].next = delt;
-              delt = &lbitset_zero_elts[2];
-            }
-          else
-            {
-              lbitset_zero_elts[1].next = selt;
-              selt = &lbitset_zero_elts[1];
-            }
-          /* Since the elements are different, there is no
-             intersection of these elements.  */
-          continue;
-        }
+	{
+	  if (selt->index < delt->index)
+	    {
+	      lbitset_zero_elts[2].next = delt;
+	      delt = &lbitset_zero_elts[2];
+	    }
+	  else
+	    {
+	      lbitset_zero_elts[1].next = selt;
+	      selt = &lbitset_zero_elts[1];
+	    }
+	  /* Since the elements are different, there is no
+	     intersection of these elements.  */
+	  continue;
+	}
 
       for (j = 0; j < LBITSET_ELT_WORDS; j++)
-        if (selt->words[j] & delt->words[j])
-          return false;
+	if (selt->words[j] & delt->words[j])
+	  return false;
     }
   return true;
 }
@@ -1059,124 +1060,124 @@ lbitset_op3_cmp (bitset dst, bitset src1, bitset src2, enum bitset_ops op)
   while (selt1 || selt2)
     {
       /* Figure out whether we need to substitute zero elements for
-         missing links.  */
+	 missing links.  */
       if (windex1 == windex2)
-        {
-          windex = windex1;
-          stmp1 = selt1;
-          stmp2 = selt2;
-          selt1 = selt1->next;
-          windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
-          selt2 = selt2->next;
-          windex2 = (selt2) ? selt2->index : BITSET_WINDEX_MAX;
-        }
+	{
+	  windex = windex1;
+	  stmp1 = selt1;
+	  stmp2 = selt2;
+	  selt1 = selt1->next;
+	  windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
+	  selt2 = selt2->next;
+	  windex2 = (selt2) ? selt2->index : BITSET_WINDEX_MAX;
+	}
       else if (windex1 < windex2)
-        {
-          windex = windex1;
-          stmp1 = selt1;
-          stmp2 = &lbitset_zero_elts[0];
-          selt1 = selt1->next;
-          windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
-        }
+	{
+	  windex = windex1;
+	  stmp1 = selt1;
+	  stmp2 = &lbitset_zero_elts[0];
+	  selt1 = selt1->next;
+	  windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
+	}
       else
-        {
-          windex = windex2;
-          stmp1 = &lbitset_zero_elts[0];
-          stmp2 = selt2;
-          selt2 = selt2->next;
-          windex2 = (selt2) ? selt2->index : BITSET_WINDEX_MAX;
-        }
+	{
+	  windex = windex2;
+	  stmp1 = &lbitset_zero_elts[0];
+	  stmp2 = selt2;
+	  selt2 = selt2->next;
+	  windex2 = (selt2) ? selt2->index : BITSET_WINDEX_MAX;
+	}
 
       /* Find the appropriate element from DST.  Begin by discarding
-         elements that we've skipped.  */
+	 elements that we've skipped.  */
       while (delt && delt->index < windex)
-        {
-          changed = true;
-          dtmp = delt;
-          delt = delt->next;
-          lbitset_elt_free (dtmp);
-        }
+	{
+	  changed = true;
+	  dtmp = delt;
+	  delt = delt->next;
+	  lbitset_elt_free (dtmp);
+	}
       if (delt && delt->index == windex)
-        {
-          dtmp = delt;
-          delt = delt->next;
-        }
+	{
+	  dtmp = delt;
+	  delt = delt->next;
+	}
       else
-        dtmp = lbitset_elt_calloc ();
+	dtmp = lbitset_elt_calloc ();
 
       /* Do the operation, and if any bits are set, link it into the
-         linked list.  */
+	 linked list.  */
       srcp1 = stmp1->words;
       srcp2 = stmp2->words;
       dstp = dtmp->words;
       switch (op)
-        {
-        default:
-          abort ();
+	{
+	default:
+	  abort ();
 
-        case BITSET_OP_OR:
-          for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ | *srcp2++;
+	case BITSET_OP_OR:
+	  for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ | *srcp2++;
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
 
-        case BITSET_OP_AND:
-          for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ & *srcp2++;
+	case BITSET_OP_AND:
+	  for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ & *srcp2++;
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
 
-        case BITSET_OP_XOR:
-          for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ ^ *srcp2++;
+	case BITSET_OP_XOR:
+	  for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ ^ *srcp2++;
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
 
-        case BITSET_OP_ANDN:
-          for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
-            {
-              bitset_word tmp = *srcp1++ & ~(*srcp2++);
+	case BITSET_OP_ANDN:
+	  for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
+	    {
+	      bitset_word tmp = *srcp1++ & ~(*srcp2++);
 
-              if (*dstp != tmp)
-                {
-                  changed = true;
-                  *dstp = tmp;
-                }
-            }
-          break;
-        }
+	      if (*dstp != tmp)
+		{
+		  changed = true;
+		  *dstp = tmp;
+		}
+	    }
+	  break;
+	}
 
       if (!lbitset_elt_zero_p (dtmp))
-        {
-          dtmp->index = windex;
-          /* Perhaps this could be optimised...  */
-          lbitset_elt_link (dst, dtmp);
-        }
+	{
+	  dtmp->index = windex;
+	  /* Perhaps this could be optimised...  */
+	  lbitset_elt_link (dst, dtmp);
+	}
       else
-        {
-          lbitset_elt_free (dtmp);
-        }
+	{
+	  lbitset_elt_free (dtmp);
+	}
     }
 
   /* If we have elements of DST left over, free them all.  */
@@ -1384,17 +1385,17 @@ debug_lbitset (bitset bset)
     {
       fprintf (stderr, "Elt %lu\n", (unsigned long int) elt->index);
       for (i = 0; i < LBITSET_ELT_WORDS; i++)
-        {
-          unsigned int j;
-          bitset_word word;
+	{
+	  unsigned int j;
+	  bitset_word word;
 
-          word = elt->words[i];
+	  word = elt->words[i];
 
-          fprintf (stderr, "  Word %u:", i);
-          for (j = 0; j < LBITSET_WORD_BITS; j++)
-            if ((word & ((bitset_word) 1 << j)))
-              fprintf (stderr, " %u", j);
-          fprintf (stderr, "\n");
-        }
+	  fprintf (stderr, "  Word %u:", i);
+	  for (j = 0; j < LBITSET_WORD_BITS; j++)
+	    if ((word & ((bitset_word) 1 << j)))
+	      fprintf (stderr, " %u", j);
+	  fprintf (stderr, "\n");
+	}
     }
 }

lib/local.mk

@@ -1,56 +0,0 @@
-# Copyright (C) 2001-2012 Free Software Foundation, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-include lib/gnulib.mk
-
-# Implementation of bitsets.
-lib_libbison_a_SOURCES +=                       \
-  lib/abitset.c                                 \
-  lib/abitset.h                                 \
-  lib/bbitset.h                                 \
-  lib/bitset.c                                  \
-  lib/bitset.h                                  \
-  lib/bitset_stats.c                            \
-  lib/bitset_stats.h                            \
-  lib/bitsetv.c                                 \
-  lib/bitsetv.h                                 \
-  lib/ebitset.c                                 \
-  lib/ebitset.h                                 \
-  lib/lbitset.c                                 \
-  lib/lbitset.h                                 \
-  lib/libiberty.h                               \
-  lib/vbitset.c                                 \
-  lib/vbitset.h
-
-# Additional bitset operations.
-lib_libbison_a_SOURCES +=                       \
-  lib/bitsetv-print.h                           \
-  lib/bitsetv-print.c
-
-# timevars, stolen from GCC.
-lib_libbison_a_SOURCES +=                       \
-  lib/timevar.h                                 \
-  lib/timevar.c                                 \
-  lib/timevar.def
-
-# Non-gnulib sources in Bison's internal library.
-lib_libbison_a_SOURCES +=                       \
-  lib/get-errno.h                               \
-  lib/get-errno.c
-
-# The Yacc compatibility library.
-lib_LIBRARIES = $(YACC_LIBRARY)
-EXTRA_LIBRARIES = lib/liby.a
-lib_liby_a_SOURCES = lib/main.c lib/yyerror.c

lib/timevar.c

@@ -189,8 +189,8 @@ static struct timevar_time_def start_time;
 
 static void get_time (struct timevar_time_def *);
 static void timevar_accumulate (struct timevar_time_def *,
-                                struct timevar_time_def *,
-                                struct timevar_time_def *);
+				struct timevar_time_def *,
+				struct timevar_time_def *);
 
 /* Fill the current times into TIME.  The definition of this function
    also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and
@@ -479,20 +479,20 @@ timevar_print (fp)
       const float tiny = 5e-3;
 
       /* Don't print the total execution time here; that goes at the
-         end.  */
+	 end.  */
       if ((timevar_id_t) id == TV_TOTAL)
-        continue;
+	continue;
 
       /* Don't print timing variables that were never used.  */
       if (!tv->used)
-        continue;
+	continue;
 
       /* Don't print timing variables if we're going to get a row of
-         zeroes.  */
+	 zeroes.  */
       if (tv->elapsed.user < tiny
-          && tv->elapsed.sys < tiny
-          && tv->elapsed.wall < tiny)
-        continue;
+	  && tv->elapsed.sys < tiny
+	  && tv->elapsed.wall < tiny)
+	continue;
 
       /* The timing variable name.  */
       fprintf (fp, " %-22s:", tv->name);
@@ -500,22 +500,22 @@ timevar_print (fp)
 #ifdef HAVE_USER_TIME
       /* Print user-mode time for this process.  */
       fprintf (fp, "%7.2f (%2.0f%%) usr",
-               tv->elapsed.user,
-               (total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100);
+	       tv->elapsed.user,
+	       (total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100);
 #endif /* HAVE_USER_TIME */
 
 #ifdef HAVE_SYS_TIME
       /* Print system-mode time for this process.  */
       fprintf (fp, "%7.2f (%2.0f%%) sys",
-               tv->elapsed.sys,
-               (total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100);
+	       tv->elapsed.sys,
+	       (total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100);
 #endif /* HAVE_SYS_TIME */
 
 #ifdef HAVE_WALL_TIME
       /* Print wall clock time elapsed.  */
       fprintf (fp, "%7.2f (%2.0f%%) wall",
-               tv->elapsed.wall,
-               (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
+	       tv->elapsed.wall,
+	       (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
 #endif /* HAVE_WALL_TIME */
 
       putc ('\n', fp);
@@ -534,7 +534,7 @@ timevar_print (fp)
 #endif
 
 #endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
-          || defined (HAVE_WALL_TIME) */
+	  || defined (HAVE_WALL_TIME) */
 }
 
 /* Returns time (user + system) used so far by the compiler process,
@@ -558,8 +558,8 @@ print_time (str, total)
 {
   long all_time = get_run_time ();
   fprintf (stderr,
-           _("time in %s: %ld.%06ld (%ld%%)\n"),
-           str, total / 1000000, total % 1000000,
-           all_time == 0 ? 0
-           : (long) (((100.0 * (double) total) / (double) all_time) + .5));
+	   _("time in %s: %ld.%06ld (%ld%%)\n"),
+	   str, total / 1000000, total % 1000000,
+	   all_time == 0 ? 0
+	   : (long) (((100.0 * (double) total) / (double) all_time) + .5));
 }

lib/vbitset.c

@@ -38,9 +38,9 @@ static void vbitset_set (bitset, bitset_bindex);
 static void vbitset_reset (bitset, bitset_bindex);
 static bool vbitset_test (bitset, bitset_bindex);
 static bitset_bindex vbitset_list (bitset, bitset_bindex *,
-                                   bitset_bindex, bitset_bindex *);
+				   bitset_bindex, bitset_bindex *);
 static bitset_bindex vbitset_list_reverse (bitset, bitset_bindex *,
-                                           bitset_bindex, bitset_bindex *);
+					   bitset_bindex, bitset_bindex *);
 
 #define VBITSET_N_WORDS(N) (((N) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS)
 #define VBITSET_WORDS(X) ((X)->b.cdata)
@@ -69,38 +69,38 @@ vbitset_resize (bitset src, bitset_bindex n_bits)
       bitset_windex size;
 
       /* The bitset needs to grow.  If we already have enough memory
-         allocated, then just zero what we need.  */
+	 allocated, then just zero what we need.  */
       if (newsize > VBITSET_ASIZE (src))
-        {
-          /* We need to allocate more memory.  When oldsize is
-             non-zero this means that we are changing the size, so
-             grow the bitset 25% larger than requested to reduce
-             number of reallocations.  */
+	{
+	  /* We need to allocate more memory.  When oldsize is
+	     non-zero this means that we are changing the size, so
+	     grow the bitset 25% larger than requested to reduce
+	     number of reallocations.  */
 
-          if (oldsize == 0)
-            size = newsize;
-          else
-            size = newsize + newsize / 4;
+	  if (oldsize == 0)
+	    size = newsize;
+	  else
+	    size = newsize + newsize / 4;
 
-          VBITSET_WORDS (src)
-            = realloc (VBITSET_WORDS (src), size * sizeof (bitset_word));
-          VBITSET_ASIZE (src) = size;
-        }
+	  VBITSET_WORDS (src)
+	    = realloc (VBITSET_WORDS (src), size * sizeof (bitset_word));
+	  VBITSET_ASIZE (src) = size;
+	}
 
       memset (VBITSET_WORDS (src) + oldsize, 0,
-              (newsize - oldsize) * sizeof (bitset_word));
+	      (newsize - oldsize) * sizeof (bitset_word));
       VBITSET_SIZE (src) = newsize;
     }
   else
     {
       /* The bitset needs to shrink.  There's no point deallocating
-         the memory unless it is shrinking by a reasonable amount.  */
+	 the memory unless it is shrinking by a reasonable amount.  */
       if ((oldsize - newsize) >= oldsize / 2)
-        {
-          VBITSET_WORDS (src)
-            = realloc (VBITSET_WORDS (src), newsize * sizeof (bitset_word));
-          VBITSET_ASIZE (src) = newsize;
-        }
+	{
+	  VBITSET_WORDS (src)
+	    = realloc (VBITSET_WORDS (src), newsize * sizeof (bitset_word));
+	  VBITSET_ASIZE (src) = newsize;
+	}
 
       /* Need to prune any excess bits.  FIXME.  */
 
@@ -196,18 +196,18 @@ vbitset_list_reverse (src, list, num, next)
 
       word = srcp[windex] << (BITSET_WORD_BITS - 1 - bitcnt);
       for (; word; bitcnt--)
-        {
-          if (word & BITSET_MSB)
-            {
-              list[count++] = bitoff + bitcnt;
-              if (count >= num)
-                {
-                  *next = n_bits - (bitoff + bitcnt);
-                  return count;
-                }
-            }
-          word <<= 1;
-        }
+	{
+	  if (word & BITSET_MSB)
+	    {
+	      list[count++] = bitoff + bitcnt;
+	      if (count >= num)
+		{
+		  *next = n_bits - (bitoff + bitcnt);
+		  return count;
+		}
+	    }
+	  word <<= 1;
+	}
       bitoff -= BITSET_WORD_BITS;
       bitcnt = BITSET_WORD_BITS - 1;
     }
@@ -243,80 +243,80 @@ vbitset_list (src, list, num, next)
     {
       /* Many bitsets are zero, so make this common case fast.  */
       for (windex = 0; windex < size && !srcp[windex]; windex++)
-        continue;
+	continue;
       if (windex >= size)
-        return 0;
+	return 0;
 
       /* If num is 1, we could speed things up with a binary search
-         of the current word.  */
+	 of the current word.  */
 
       bitoff = windex * BITSET_WORD_BITS;
     }
   else
     {
       if (bitno >= BITSET_SIZE_ (src))
-        return 0;
+	return 0;
 
       windex = bitno / BITSET_WORD_BITS;
       bitno = bitno % BITSET_WORD_BITS;
 
       if (bitno)
-        {
-          /* Handle the case where we start within a word.
-             Most often, this is executed with large bitsets
-             with many set bits where we filled the array
-             on the previous call to this function.  */
+	{
+	  /* Handle the case where we start within a word.
+	     Most often, this is executed with large bitsets
+	     with many set bits where we filled the array
+	     on the previous call to this function.  */
 
-          bitoff = windex * BITSET_WORD_BITS;
-          word = srcp[windex] >> bitno;
-          for (bitno = bitoff + bitno; word; bitno++)
-            {
-              if (word & 1)
-                {
-                  list[count++] = bitno;
-                  if (count >= num)
-                    {
-                      *next = bitno + 1;
-                      return count;
-                    }
-                }
-              word >>= 1;
-            }
-          windex++;
-        }
+	  bitoff = windex * BITSET_WORD_BITS;
+	  word = srcp[windex] >> bitno;
+	  for (bitno = bitoff + bitno; word; bitno++)
+	    {
+	      if (word & 1)
+		{
+		  list[count++] = bitno;
+		  if (count >= num)
+		    {
+		      *next = bitno + 1;
+		      return count;
+		    }
+		}
+	      word >>= 1;
+	    }
+	  windex++;
+	}
       bitoff = windex * BITSET_WORD_BITS;
     }
 
   for (; windex < size; windex++, bitoff += BITSET_WORD_BITS)
     {
       if (!(word = srcp[windex]))
-        continue;
+	continue;
 
       if ((count + BITSET_WORD_BITS) < num)
-        {
-          for (bitno = bitoff; word; bitno++)
-            {
-              if (word & 1)
-                list[count++] = bitno;
-              word >>= 1;
-            }
-        }
+	{
+	  for (bitno = bitoff; word; bitno++)
+	    {
+	      if (word & 1)
+		list[count++] = bitno;
+	      word >>= 1;
+	    }
+	}
       else
-        {
-          for (bitno = bitoff; word; bitno++)
-            {
-              if (word & 1)
-                {
-                  list[count++] = bitno;
-                  if (count >= num)
-                    {
-                      *next = bitno + 1;
-                      return count;
-                    }
-                }
-              word >>= 1;
-            }
-        }
+	{
+	  for (bitno = bitoff; word; bitno++)
+	    {
+	      if (word & 1)
+		{
+		  list[count++] = bitno;
+		  if (count >= num)
+		    {
+		      *next = bitno + 1;
+		      return count;
+		    }
+		}
+	      word >>= 1;
+	    }
+	}
     }
 
   *next = bitoff;
@@ -398,7 +398,7 @@ vbitset_copy1 (bitset dst, bitset src)
   memcpy (dstp, srcp, sizeof (bitset_word) * ssize);
 
   memset (dstp + sizeof (bitset_word) * ssize, 0,
-          sizeof (bitset_word) * (dsize - ssize));
+	  sizeof (bitset_word) * (dsize - ssize));
 }
 
 
@@ -423,7 +423,7 @@ vbitset_not (bitset dst, bitset src)
 
   vbitset_unused_clear (dst);
   memset (dstp + sizeof (bitset_word) * ssize, 0,
-          sizeof (bitset_word) * (dsize - ssize));
+	  sizeof (bitset_word) * (dsize - ssize));
 }
 
 
@@ -438,19 +438,19 @@ vbitset_equal_p (bitset dst, bitset src)
 
   for (i = 0; i < min (ssize, dsize); i++)
       if (*srcp++ != *dstp++)
-          return 0;
+	  return 0;
 
   if (ssize > dsize)
     {
       for (; i < ssize; i++)
-        if (*srcp++)
-          return 0;
+	if (*srcp++)
+	  return 0;
     }
   else
     {
       for (; i < dsize; i++)
-        if (*dstp++)
-          return 0;
+	if (*dstp++)
+	  return 0;
     }
 
   return 1;
@@ -468,13 +468,13 @@ vbitset_subset_p (bitset dst, bitset src)
 
   for (i = 0; i < min (ssize, dsize); i++, dstp++, srcp++)
       if (*dstp != (*srcp | *dstp))
-          return 0;
+	  return 0;
 
   if (ssize > dsize)
     {
       for (; i < ssize; i++)
-        if (*srcp++)
-          return 0;
+	if (*srcp++)
+	  return 0;
     }
 
   return 1;
@@ -492,7 +492,7 @@ vbitset_disjoint_p (bitset dst, bitset src)
 
   for (i = 0; i < min (ssize, dsize); i++)
       if (*srcp++ & *dstp++)
-          return 0;
+	  return 0;
 
   return 1;
 }
@@ -551,10 +551,10 @@ vbitset_and_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ & *src2p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
 
   if (ssize2 > ssize1)
@@ -566,10 +566,10 @@ vbitset_and_cmp (bitset dst, bitset src1, bitset src2)
   for (; i < ssize1; i++, dstp++)
     {
       if (*dstp != 0)
-        {
-          changed = 1;
-          *dstp = 0;
-        }
+	{
+	  changed = 1;
+	  *dstp = 0;
+	}
     }
 
   memset (dstp, 0, sizeof (bitset_word) * (dsize - ssize1));
@@ -604,14 +604,14 @@ vbitset_andn (bitset dst, bitset src1, bitset src2)
   if (ssize2 > ssize1)
     {
       for (; i < ssize2; i++)
-        *dstp++ = 0;
+	*dstp++ = 0;
 
       memset (dstp, 0, sizeof (bitset_word) * (dsize - ssize2));
     }
   else
     {
       for (; i < ssize1; i++)
-        *dstp++ = *src1p++;
+	*dstp++ = *src1p++;
 
       memset (dstp, 0, sizeof (bitset_word) * (dsize - ssize1));
     }
@@ -644,37 +644,37 @@ vbitset_andn_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ & ~(*src2p++);
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
 
   if (ssize2 > ssize1)
     {
       for (; i < ssize2; i++, dstp++)
-        {
-          if (*dstp != 0)
-            {
-              changed = 1;
-              *dstp = 0;
-            }
-        }
+	{
+	  if (*dstp != 0)
+	    {
+	      changed = 1;
+	      *dstp = 0;
+	    }
+	}
 
       memset (dstp, 0, sizeof (bitset_word) * (dsize - ssize2));
     }
   else
     {
       for (; i < ssize1; i++, dstp++)
-        {
-          bitset_word tmp = *src1p++;
+	{
+	  bitset_word tmp = *src1p++;
 
-          if (*dstp != tmp)
-            {
-              changed = 1;
-              *dstp = tmp;
-            }
-        }
+	  if (*dstp != tmp)
+	    {
+	      changed = 1;
+	      *dstp = tmp;
+	    }
+	}
 
       memset (dstp, 0, sizeof (bitset_word) * (dsize - ssize1));
     }
@@ -745,10 +745,10 @@ vbitset_or_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ | *src2p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
 
   if (ssize2 > ssize1)
@@ -762,10 +762,10 @@ vbitset_or_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
 
   memset (dstp, 0, sizeof (bitset_word) * (dsize - ssize1));
@@ -836,10 +836,10 @@ vbitset_xor_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ ^ *src2p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
 
   if (ssize2 > ssize1)
@@ -853,10 +853,10 @@ vbitset_xor_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
 
   memset (dstp, 0, sizeof (bitset_word) * (dsize - ssize1));
@@ -926,10 +926,10 @@ vbitset_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -993,10 +993,10 @@ vbitset_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ & ~(*src2p++)) | *src3p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }
@@ -1060,10 +1060,10 @@ vbitset_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ | *src2p++) & *src3p++;
 
       if (*dstp != tmp)
-        {
-          changed = 1;
-          *dstp = tmp;
-        }
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
     }
   return changed;
 }

m4/.gitignore

@@ -51,7 +51,6 @@
 /inline.m4
 /intdiv0.m4
 /intl.m4
-/intl.m4~
 /intldir.m4
 /intlmacosx.m4
 /intmax.m4
@@ -103,7 +102,6 @@
 /perror.m4
 /pipe2.m4
 /po.m4
-/po.m4~
 /posix_spawn.m4
 /printf-frexp.m4
 /printf-frexpl.m4
@@ -181,3 +179,5 @@
 /xalloc.m4
 /xsize.m4
 /xstrndup.m4
+/obstack-printf.m4
+/extern-inline.m4

m4/c-working.m4

@@ -21,7 +21,51 @@ AC_DEFUN([BISON_TEST_FOR_WORKING_C_COMPILER], [
   AC_COMPILE_IFELSE(
     [AC_LANG_PROGRAM(
        [[#include <limits.h>
-         int test_array[CHAR_BIT];]])],
+	 int test_array[CHAR_BIT];]])],
     [],
     [AC_MSG_FAILURE([cannot compile a simple C program])])
 ])
+
+# BISON_CHECK_WITH_POSIXLY_CORRECT(CODE)
+# --------------------------------------
+# Run the Autoconf CODE with POSIXLY_CORRECT set to 1, and restored to
+# its initial value afterwards.
+AC_DEFUN([BISON_CHECK_WITH_POSIXLY_CORRECT],
+[gl_awk_probe='BEGIN { if ("POSIXLY_CORRECT" in ENVIRON) print "x" }'
+case ${POSIXLY_CORRECT+x}`$AWK "$gl_awk_probe" </dev/null` in
+  xx) gl_had_POSIXLY_CORRECT=exported ;;
+  x)  gl_had_POSIXLY_CORRECT=yes      ;;
+  *)  gl_had_POSIXLY_CORRECT=         ;;
+esac
+POSIXLY_CORRECT=1
+export POSIXLY_CORRECT
+$1
+case $gl_had_POSIXLY_CORRECT in
+  exported) ;;
+  yes) AS_UNSET([POSIXLY_CORRECT]); POSIXLY_CORRECT=1 ;;
+  *) AS_UNSET([POSIXLY_CORRECT]) ;;
+esac
+])
+
+# BISON_C_COMPILER_POSIXLY_CORRECT
+# --------------------------------
+# Whether the compiler supports -g in POSIXLY_CORRECT mode.  clang-2.9
+# on OS X does not, because "clang-mp-2.9 -o test -g test.c" launches
+# "/usr/bin/dsymutil test -o test.dSYM" which fails with "error:
+# unable to open executable '-o'".
+#
+# Sets C_COMPILER_POSIXLY_CORRECT to true/false.
+AC_DEFUN([BISON_C_COMPILER_POSIXLY_CORRECT],
+[AC_CACHE_CHECK([whether $CC supports POSIXLY_CORRECT=1],
+                [bison_cv_cc_supports_posixly_correct],
+[BISON_CHECK_WITH_POSIXLY_CORRECT(
+[AC_LANG_PUSH([C])
+AC_LINK_IFELSE([AC_LANG_PROGRAM],
+                [bison_cv_cc_supports_posixly_correct=yes],
+                [bison_cv_cc_supports_posixly_correct=no])
+AC_LANG_POP([C])])])
+case $bison_cv_cc_supports_posixly_correct in
+  yes) AC_SUBST([C_COMPILER_POSIXLY_CORRECT], [true]) ;;
+  no)  AC_SUBST([C_COMPILER_POSIXLY_CORRECT], [false]);;
+esac
+])

m4/cxx.m4

@@ -26,25 +26,25 @@ AC_DEFUN([BISON_TEST_FOR_WORKING_CXX_COMPILER],
     bison_cv_cxx_works=no
     AC_COMPILE_IFELSE(
       [AC_LANG_PROGRAM(
-         [#include <cstdlib>
-          #include <iostream>
-          #include <map>
-          #include <string>
-          using namespace std;],
+	 [#include <cstdlib>
+	  #include <iostream>
+	  #include <map>
+	  #include <string>
+	  using namespace std;],
          [std::cerr << "";
           cout << "";
-          typedef std::pair<unsigned int, int> uipair;
-          std::map<unsigned int, int> m;
-          std::map<unsigned int, int>::iterator i;
-          m.insert (uipair (4, -4));
-          for (i = m.begin (); i != m.end (); ++i)
-            if (i->first != 4)
-              return 1;])],
+	  typedef std::pair<unsigned int, int> uipair;
+	  std::map<unsigned int, int> m;
+	  std::map<unsigned int, int>::iterator i;
+	  m.insert (uipair (4, -4));
+	  for (i = m.begin (); i != m.end (); ++i)
+	    if (i->first != 4)
+	      return 1;])],
       [AS_IF([AC_TRY_COMMAND([$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_objext $LIBS >&AS_MESSAGE_LOG_FD])],
-         [AS_IF([test "$cross_compiling" = yes],
-            [bison_cv_cxx_works=cross],
-            [AS_IF([AC_TRY_COMMAND(./conftest$ac_exeext)],
-               [bison_cv_cxx_works=yes])])])
+	 [AS_IF([test "$cross_compiling" = yes],
+	    [bison_cv_cxx_works=cross],
+	    [AS_IF([AC_TRY_COMMAND(./conftest$ac_exeext)],
+	       [bison_cv_cxx_works=yes])])])
        rm -f conftest$ac_exeext])
     AC_LANG_POP([C++])])
 

po/.gitignore

@@ -6,7 +6,6 @@
 /Makefile
 /Makefile.in
 /Makefile.in.in
-/Makefile.in.in~
 /Makevars
 /Makevars.template
 /POTFILES

runtime-po/.gitignore

@@ -6,7 +6,6 @@
 /Makefile
 /Makefile.in
 /Makefile.in.in
-/Makefile.in.in~
 /Makevars
 /Makevars.template
 /POTFILES

src/.gitignore

@@ -4,6 +4,8 @@
 /*.output
 /.deps
 /.dirstamp
+/Makefile
+/Makefile.in
 /bison
 /bison.exe
 /scan-code.c

src/InadequacyList.h

@@ -90,7 +90,7 @@ typedef struct InadequacyList {
  *     <tt>manifesting_state->reductions->num + 1</tt>.
  *   - If the set of all \c InadequacyList nodes with which the new
  *     \c InadequacyList node might be compared is currently empty, then
- *     it is best if <tt>*node_count</tt> is zero so that the node count
+ *     it is best if <tt>*node_count</t> is zero so that the node count
  *     does not eventually overflow.  However, if that set is not
  *     currently empty, then <tt>*node_count</tt> has not been modified
  *     by any function except \c InadequacyList__new_conflict since the

src/LR0.c

@@ -1,7 +1,7 @@
 /* Generate the LR(0) parser states for Bison.
 
-   Copyright (C) 1984, 1986, 1989, 2000-2002, 2004-2012 Free Software
-   Foundation, Inc.
+   Copyright (C) 1984, 1986, 1989, 2000-2002, 2004-2007, 2009-2012 Free
+   Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -32,6 +32,7 @@
 #include "complain.h"
 #include "getargs.h"
 #include "gram.h"
+#include "gram.h"
 #include "lalr.h"
 #include "reader.h"
 #include "reduce.h"
@@ -61,7 +62,7 @@ state_list_append (symbol_number sym, size_t core_size, item_number *core)
 
   if (trace_flag & trace_automaton)
     fprintf (stderr, "state_list_append (state = %d, symbol = %d (%s))\n",
-             nstates, sym, symbols[sym]->tag);
+	     nstates, sym, symbols[sym]->tag);
 
   node->next = NULL;
   node->state = s;
@@ -99,13 +100,13 @@ allocate_itemsets (void)
      symbols.  */
   size_t count = 0;
   size_t *symbol_count = xcalloc (nsyms + nuseless_nonterminals,
-                                  sizeof *symbol_count);
+				  sizeof *symbol_count);
 
   for (r = 0; r < nrules; ++r)
     for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
       {
-        count++;
-        symbol_count[*rhsp]++;
+	count++;
+	symbol_count[*rhsp]++;
       }
 
   /* See comments before new_itemsets.  All the vectors of items
@@ -186,15 +187,15 @@ new_itemsets (state *s)
   for (i = 0; i < nitemset; ++i)
     if (item_number_is_symbol_number (ritem[itemset[i]]))
       {
-        symbol_number sym = item_number_as_symbol_number (ritem[itemset[i]]);
-        if (!kernel_size[sym])
-          {
-            shift_symbol[nshifts] = sym;
-            nshifts++;
-          }
+	symbol_number sym = item_number_as_symbol_number (ritem[itemset[i]]);
+	if (!kernel_size[sym])
+	  {
+	    shift_symbol[nshifts] = sym;
+	    nshifts++;
+	  }
 
-        kernel_base[sym][kernel_size[sym]] = itemset[i] + 1;
-        kernel_size[sym]++;
+	kernel_base[sym][kernel_size[sym]] = itemset[i] + 1;
+	kernel_size[sym]++;
       }
 }
 
@@ -213,7 +214,7 @@ get_state (symbol_number sym, size_t core_size, item_number *core)
 
   if (trace_flag & trace_automaton)
     fprintf (stderr, "Entering get_state, symbol = %d (%s)\n",
-             sym, symbols[sym]->tag);
+	     sym, symbols[sym]->tag);
 
   s = state_hash_lookup (core_size, core);
   if (!s)
@@ -227,7 +228,7 @@ get_state (symbol_number sym, size_t core_size, item_number *core)
 
 /*---------------------------------------------------------------.
 | Use the information computed by new_itemsets to find the state |
-| numbers reached by each shift transition from S.               |
+| numbers reached by each shift transition from S.		 |
 |                                                                |
 | SHIFTSET is set up as a vector of those states.                |
 `---------------------------------------------------------------*/
@@ -247,7 +248,7 @@ append_states (state *s)
       symbol_number sym = shift_symbol[i];
       int j;
       for (j = i; 0 < j && sym < shift_symbol[j - 1]; j--)
-        shift_symbol[j] = shift_symbol[j - 1];
+	shift_symbol[j] = shift_symbol[j - 1];
       shift_symbol[j] = sym;
     }
 
@@ -276,16 +277,16 @@ save_reductions (state *s)
     {
       item_number item = ritem[itemset[i]];
       if (item_number_is_rule_number (item))
-        {
-          rule_number r = item_number_as_rule_number (item);
-          redset[count++] = &rules[r];
-          if (r == 0)
-            {
-              /* This is "reduce 0", i.e., accept. */
-              aver (!final_state);
-              final_state = s;
-            }
-        }
+	{
+	  rule_number r = item_number_as_rule_number (item);
+	  redset[count++] = &rules[r];
+	  if (r == 0)
+	    {
+	      /* This is "reduce 0", i.e., accept. */
+	      aver (!final_state);
+	      final_state = s;
+	    }
+	}
     }
 
   /* Make a reductions structure and copy the data into it.  */
@@ -307,14 +308,14 @@ set_states (void)
       state_list *this = first_state;
 
       /* Pessimization, but simplification of the code: make sure all
-         the states have valid transitions and reductions members,
-         even if reduced to 0.  It is too soon for errs, which are
-         computed later, but set_conflicts.  */
+	 the states have valid transitions and reductions members,
+	 even if reduced to 0.  It is too soon for errs, which are
+	 computed later, but set_conflicts.  */
       state *s = this->state;
       if (!s->transitions)
-        state_transitions_set (s, 0, 0);
+	state_transitions_set (s, 0, 0);
       if (!s->reductions)
-        state_reductions_set (s, 0, 0);
+	state_reductions_set (s, 0, 0);
 
       states[s->number] = s;
 
@@ -348,9 +349,9 @@ generate_states (void)
     {
       state *s = list->state;
       if (trace_flag & trace_automaton)
-        fprintf (stderr, "Processing state %d (reached by %s)\n",
-                 s->number,
-                 symbols[s->accessing_symbol]->tag);
+	fprintf (stderr, "Processing state %d (reached by %s)\n",
+		 s->number,
+		 symbols[s->accessing_symbol]->tag);
       /* Set up itemset for the transitions out of this state.  itemset gets a
          vector of all the items that could be accepted next.  */
       closure (s->items, s->nitems);
@@ -362,7 +363,7 @@ generate_states (void)
       append_states (s);
 
       /* Create the shifts structures for the shifts to those states,
-         now that the state numbers transitioning to are known.  */
+	 now that the state numbers transitioning to are known.  */
       state_transitions_set (s, nshifts, shiftset);
     }
 

src/Makefile.am

@@ -0,0 +1,117 @@
+# Make bison/src.
+
+# Copyright (C) 2001-2012 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+AM_CFLAGS = $(WARN_CFLAGS) $(WERROR_CFLAGS)
+AM_CPPFLAGS = -I$(top_srcdir)/lib
+BISON = ../tests/bison
+# Use our own Bison to build the parser.  Of course, you ought to
+# keep a sane version of Bison nearby...
+YACC = $(BISON) -y
+AM_YFLAGS = -d -v --warnings=all,error --report=all
+
+LDADD = ../lib/libbison.a $(LIBINTL)
+
+bin_PROGRAMS = bison
+bin_SCRIPTS = $(YACC_SCRIPT)
+EXTRA_SCRIPTS = yacc
+
+bison_SOURCES =                                 \
+  AnnotationList.c AnnotationList.h             \
+  InadequacyList.c InadequacyList.h             \
+  LR0.c LR0.h                                   \
+  Sbitset.c Sbitset.h                           \
+  assoc.c assoc.h                               \
+  closure.c closure.h                           \
+  complain.c complain.h                         \
+  conflicts.c conflicts.h                       \
+  derives.c derives.h                           \
+  files.c files.h                               \
+  flex-scanner.h                                \
+  getargs.c getargs.h                           \
+  gram.c gram.h                                 \
+  lalr.h lalr.c                                 \
+  ielr.h ielr.c                                 \
+  location.c location.h                         \
+  main.c                                        \
+  muscle-tab.c muscle-tab.h                     \
+  named-ref.c named-ref.h                       \
+  nullable.c nullable.h                         \
+  output.c output.h                             \
+  parse-gram.y                                  \
+  print.c print.h                               \
+  print_graph.c print_graph.h                   \
+  print-xml.c print-xml.h                       \
+  reader.c reader.h                             \
+  reduce.c reduce.h                             \
+  relation.c relation.h                         \
+  scan-code.h scan-code-c.c                     \
+  scan-gram.h scan-gram-c.c                     \
+  scan-skel.h scan-skel-c.c                     \
+  state.c state.h                               \
+  symlist.c symlist.h                           \
+  symtab.c symtab.h                             \
+  system.h                                      \
+  tables.h tables.c                             \
+  uniqstr.c uniqstr.h                           \
+  graphviz.c graphviz.h
+
+EXTRA_bison_SOURCES = scan-code.l scan-skel.l scan-gram.l
+
+BUILT_SOURCES =                                 \
+  parse-gram.c parse-gram.h                     \
+  scan-code.c                                   \
+  scan-skel.c                                   \
+  scan-gram.c
+
+MOSTLYCLEANFILES = yacc
+
+yacc:
+	$(AM_V_GEN)echo '#! /bin/sh' >$@
+	$(AM_V_at)echo "exec '$(bindir)/bison' -y "'"$$@"' >>$@
+	$(AM_V_at)chmod a+x $@
+
+
+# The following rule is not designed to be portable,
+# and relies on tools that not everyone has.
+
+# Most functions in src/*.c should have static scope.
+# Any that don't must be marked with `extern', but `main'
+# and `usage' are exceptions.  They're always extern, but
+# don't need to be marked.
+#
+# The second nm|grep checks for file-scope variables with `extern' scope.
+sc_tight_scope: $(all_programs)
+	@t=exceptions-$$$$;						\
+	trap 's=$$?; rm -f $$t; exit $$s' 0 1 2 13 15;			\
+	( printf '^main$$\n^usage$$\n';					\
+	  grep -h -A1 '^extern .*[^;]$$' $(SOURCES)			\
+	    | grep -vE '^(extern |--)' |sed 's/^/^/;s/ .*/$$/' ) > $$t;	\
+	if nm -e *.$(OBJEXT)						\
+	    | sed -n 's/.* T //p'					\
+	    | grep -Ev -f $$t; then					\
+	  echo 'the above functions should have static scope' 1>&2;	\
+	  exit 1;							\
+	fi;								\
+	( printf '^program_name$$\n';					\
+	  sed -n 's/^extern .*[* ]\([a-zA-Z_][a-zA-Z_0-9]*\);$$/^\1$$/p' \
+	    $$(ls $(SOURCES) | grep '\.h$$') /dev/null) > $$t;		\
+	if nm -e *.$(OBJEXT)						\
+	    | sed -n 's/.* [BD] //p'					\
+	    | grep -Ev -f $$t; then					\
+	  echo 'the above variables should have static scope' 1>&2;	\
+	  exit 1;							\
+	fi

src/assoc.c

@@ -1,6 +1,6 @@
 /* Associativity information.
 
-   Copyright (C) 2002, 2005-2006, 2008-2012 Free Software Foundation,
+   Copyright (C) 2002, 2005-2006, 2009-2012 Free Software Foundation,
    Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
@@ -43,8 +43,5 @@ assoc_to_string (assoc a)
 
     case non_assoc:
       return "%nonassoc";
-
-    case precedence_assoc:
-      return "%precedence";
     }
 }

src/assoc.h

@@ -1,6 +1,6 @@
 /* Associativity information.
 
-   Copyright (C) 2002, 2006, 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2006, 2009-2012 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -23,11 +23,10 @@
 /* Associativity values for tokens and rules.  */
 typedef enum
 {
-  undef_assoc,     /** Not defined. */
-  right_assoc,     /** %right */
-  left_assoc,      /** %left */
-  non_assoc,       /** %nonassoc */
-  precedence_assoc /** %precedence */
+  undef_assoc,
+  right_assoc,
+  left_assoc,
+  non_assoc
 } assoc;
 
 char const *assoc_to_string (assoc a);

src/closure.c

@@ -61,7 +61,7 @@ print_closure (char const *title, item_number *array, size_t size)
       item_number *rp;
       fprintf (stderr, "  %2d: .", array[i]);
       for (rp = &ritem[array[i]]; *rp >= 0; ++rp)
-        fprintf (stderr, " %s", symbols[*rp]->tag);
+	fprintf (stderr, " %s", symbols[*rp]->tag);
       fprintf (stderr, "  (rule %d)\n", -*rp - 1);
     }
   fputs ("\n\n", stderr);
@@ -79,10 +79,10 @@ print_firsts (void)
       bitset_iterator iter;
       fprintf (stderr, "\t%s firsts\n", symbols[i]->tag);
       BITSET_FOR_EACH (iter, FIRSTS (i), j, 0)
-        {
-          fprintf (stderr, "\t\t%s\n",
-                   symbols[j + ntokens]->tag);
-        }
+	{
+	  fprintf (stderr, "\t\t%s\n",
+		   symbols[j + ntokens]->tag);
+	}
     }
   fprintf (stderr, "\n\n");
 }
@@ -100,11 +100,10 @@ print_fderives (void)
       bitset_iterator iter;
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
       BITSET_FOR_EACH (iter, FDERIVES (i), r, 0)
-        {
-          fprintf (stderr, "\t\t%3d ", r);
-          rule_rhs_print (&rules[r], stderr);
-          fprintf (stderr, "\n");
-        }
+	{
+	  fprintf (stderr, "\t\t%3d ", r);
+	  rule_rhs_print (&rules[r], stderr);
+	}
     }
   fprintf (stderr, "\n\n");
 }
@@ -130,9 +129,9 @@ set_firsts (void)
   for (i = ntokens; i < nsyms; i++)
     for (j = 0; derives[i - ntokens][j]; ++j)
       {
-        item_number sym = derives[i - ntokens][j]->rhs[0];
-        if (ISVAR (sym))
-          bitset_set (FIRSTS (i), sym - ntokens);
+	item_number sym = derives[i - ntokens][j]->rhs[0];
+	if (ISVAR (sym))
+	  bitset_set (FIRSTS (i), sym - ntokens);
       }
 
   if (trace_flag & trace_sets)
@@ -168,8 +167,8 @@ set_fderives (void)
   for (i = ntokens; i < nsyms; ++i)
     for (j = ntokens; j < nsyms; ++j)
       if (bitset_test (FIRSTS (i), j - ntokens))
-        for (k = 0; derives[j - ntokens][k]; ++k)
-          bitset_set (FDERIVES (i), derives[j - ntokens][k]->number);
+	for (k = 0; derives[j - ntokens][k]; ++k)
+	  bitset_set (FDERIVES (i), derives[j - ntokens][k]->number);
 
   if (trace_flag & trace_sets)
     print_fderives ();
@@ -219,11 +218,11 @@ closure (item_number *core, size_t n)
     {
       item_number itemno = rules[ruleno].rhs - ritem;
       while (c < n && core[c] < itemno)
-        {
-          itemset[nitemset] = core[c];
-          nitemset++;
-          c++;
-        }
+	{
+	  itemset[nitemset] = core[c];
+	  nitemset++;
+	  c++;
+	}
       itemset[nitemset] = itemno;
       nitemset++;
     };

src/complain.c

@@ -29,43 +29,15 @@
 #include "files.h"
 #include "getargs.h"
 
-warnings warnings_flag = Wconflicts_sr | Wconflicts_rr | Wother;
-
 bool complaint_issued;
 static unsigned *indent_ptr = 0;
 
-void
-warnings_print_categories (warnings warn_flags)
-{
-  if (! (warn_flags & silent))
-    {
-      char const *warn_names[] =
-        {
-          "midrule-values",
-          "yacc",
-          "conflicts-sr",
-          "conflicts-rr",
-          "other"
-        };
-
-      bool any = false;
-      int i;
-      for (i = 0; i < ARRAY_CARDINALITY (warn_names); ++i)
-        if (warn_flags & 1 << i)
-          {
-            fprintf (stderr, "%s-W%s", any ? ", " : " [", warn_names[i]);
-            any = true;
-          }
-      if (any)
-        fprintf (stderr, "]");
-    }
-}
+
 
 /** Report an error message.
  *
  * \param loc     the location, defaulting to the current file,
  *                or the program name.
- * \param flags   the category for this message.
  * \param prefix  put before the message (e.g., "warning").
  * \param message the error message, a printf format string.  Iff it
  *                ends with ": ", then no trailing newline is printed,
@@ -75,10 +47,10 @@ warnings_print_categories (warnings warn_flags)
  */
 static
 void
-error_message (const location *loc, warnings flags, const char *prefix,
-               const char *message, va_list args)
+error_message (location *loc,
+	       const char *prefix,
+	       const char *message, va_list args)
 {
-  (void) flags;
   unsigned pos = 0;
 
   if (loc)
@@ -100,82 +72,24 @@ error_message (const location *loc, warnings flags, const char *prefix,
     fprintf (stderr, "%s: ", prefix);
 
   vfprintf (stderr, message, args);
-  warnings_print_categories (flags);
   {
     size_t l = strlen (message);
-    if (l < 2 || message[l-2] != ':' || message[l-1] != ' ')
-      {
-        putc ('\n', stderr);
-        fflush (stderr);
-      }
+    if (l < 2 || message[l-2] != ':' || message[l-1] != ' ') {
+      putc ('\n', stderr);
+      fflush (stderr);
+    }
   }
 }
 
-/** Raise a complaint. That can be a fatal error, a complaint or just a
-    warning.  */
-
-static inline void
-complains (const location *loc, warnings flags, const char *message,
-           va_list args)
-{
-  if (flags & complaint)
-    {
-      error_message (loc, complaint, NULL, message, args);
-      complaint_issued = true;
-    }
-  else if (flags & fatal)
-    {
-      error_message (loc, fatal, _("fatal error"), message, args);
-      exit (EXIT_FAILURE);
-    }
-  else if (flags & Wyacc)
-    {
-      if (yacc_flag)
-        {
-          error_message (loc, flags, NULL, message, args);
-          complaint_issued = true;
-        }
-      else if (warnings_flag & Wyacc)
-        {
-          set_warning_issued ();
-          error_message (loc, flags, _("warning"), message, args);
-        }
-    }
-  else if (warnings_flag & flags)
-    {
-      set_warning_issued ();
-      error_message (loc, flags, _("warning"), message, args);
-    }
+/** Wrap error_message() with varargs handling. */
+#define ERROR_MESSAGE(Loc, Prefix, Message)	\
+{						\
+  va_list args;					\
+  va_start (args, Message);			\
+  error_message (Loc, Prefix, Message, args);	\
+  va_end (args);				\
 }
 
-void
-complain (warnings flags, const char *message, ...)
-{
-  va_list args;
-  va_start (args, message);
-  complains (NULL, flags, message, args);
-  va_end (args);
-}
-
-void
-complain_at (location loc, warnings flags, const char *message, ...)
-{
-  va_list args;
-  va_start (args, message);
-  complains (&loc, flags, message, args);
-  va_end (args);
-}
-
-void complain_at_indent (location loc, warnings flags, unsigned *indent,
-                         const char *message, ...)
-{
-  indent_ptr = indent;
-
-  va_list args;
-  va_start (args, message);
-  complains (&loc, flags, message, args);
-  va_end (args);
-}
 
 /*--------------------------------.
 | Report a warning, and proceed.  |
@@ -185,10 +99,115 @@ void
 set_warning_issued (void)
 {
   static bool warning_issued = false;
-  if (!warning_issued && (warnings_flag & Werror))
+  if (!warning_issued && (warnings_flag & warnings_error))
     {
       fprintf (stderr, "%s: warnings being treated as errors\n", program_name);
       complaint_issued = true;
     }
   warning_issued = true;
 }
+
+void
+warn_at (location loc, const char *message, ...)
+{
+  if (!(warnings_flag & warnings_other))
+    return;
+  set_warning_issued ();
+  ERROR_MESSAGE (&loc, _("warning"), message);
+}
+
+void
+warn_at_indent (location loc, unsigned *indent,
+                const char *message, ...)
+{
+  if (!(warnings_flag & warnings_other))
+    return;
+  set_warning_issued ();
+  indent_ptr = indent;
+  ERROR_MESSAGE (&loc, _("warning"), message);
+}
+
+void
+warn (const char *message, ...)
+{
+  if (!(warnings_flag & warnings_other))
+    return;
+  set_warning_issued ();
+  ERROR_MESSAGE (NULL, _("warning"), message);
+}
+
+
+/*-----------------------------------------------------------.
+| An error has occurred, but we can proceed, and die later.  |
+`-----------------------------------------------------------*/
+
+void
+complain_at (location loc, const char *message, ...)
+{
+  ERROR_MESSAGE (&loc, NULL, message);
+  complaint_issued = true;
+}
+
+void
+complain_at_indent (location loc, unsigned *indent,
+                    const char *message, ...)
+{
+  indent_ptr = indent;
+  ERROR_MESSAGE (&loc, NULL, message);
+  complaint_issued = true;
+}
+
+void
+complain (const char *message, ...)
+{
+  ERROR_MESSAGE (NULL, NULL, message);
+  complaint_issued = true;
+}
+
+
+/*--------------------------------------------------------------.
+| An incompatibility with POSIX Yacc: mapped either to warn* or |
+| complain* depending on yacc_flag.                             |
+`--------------------------------------------------------------*/
+
+void
+yacc_at (location loc, const char *message, ...)
+{
+  if (yacc_flag)
+    {
+      ERROR_MESSAGE (&loc, NULL, message);
+      complaint_issued = true;
+    }
+  else if (warnings_flag & warnings_yacc)
+    {
+      set_warning_issued ();
+      ERROR_MESSAGE (&loc, _("warning"), message);
+    }
+}
+
+void
+midrule_value_at (location loc, const char *message, ...)
+{
+  if (!(warnings_flag & warnings_midrule_values))
+    return;
+  set_warning_issued ();
+  ERROR_MESSAGE (&loc, _("warning"), message);
+}
+
+/*-------------------------------------------------.
+| A severe error has occurred, we cannot proceed.  |
+`-------------------------------------------------*/
+
+void
+fatal_at (location loc, const char *message, ...)
+{
+  ERROR_MESSAGE (&loc, _("fatal error"), message);
+  exit (EXIT_FAILURE);
+}
+
+void
+fatal (const char *message, ...)
+{
+  ERROR_MESSAGE (NULL, _("fatal error"), message);
+  exit (EXIT_FAILURE);
+}

src/complain.h

@@ -21,60 +21,72 @@
 
 # include "location.h"
 
-# ifdef __cplusplus
+# ifdef	__cplusplus
 extern "C" {
 # endif
 
-/*-------------.
-| --warnings.  |
-`-------------*/
-
-typedef enum
-  {
-    Wnone             = 0,       /**< Issue no warnings.  */
-    Wmidrule_values   = 1 << 0,  /**< Unset or unused midrule values.  */
-    Wyacc             = 1 << 1,  /**< POSIXME.  */
-    Wconflicts_sr     = 1 << 2,  /**< S/R conflicts.  */
-    Wconflicts_rr     = 1 << 3,  /**< R/R conflicts.  */
-    Wother            = 1 << 4,  /**< All other warnings.  */
-
-    Werror            = 1 << 10, /**< Warnings are treated as errors.  */
-    complaint         = 1 << 11, /**< All complaints.  */
-    fatal             = 1 << 12, /**< All fatal errors.  */
-    silent            = 1 << 13, /**< Do not display the warning type.  */
-    Wall              = ~Werror  /**< All above warnings.  */
-  } warnings;
-
-/** What warnings are issued.  */
-extern warnings warnings_flag;
-
-/** Display a "[-Wyacc]" like message on stderr.  */
-void warnings_print_categories (warnings warn_flags);
-
 /** Record that a warning is about to be issued, and treat it as an
-    error if <tt>warnings_flag & Werror</tt>.  This is exported
+    error if <tt>warnings_flag & warnings_error</tt>.  This is exported
     only for the sake of Yacc-compatible conflict reports in conflicts.c.
     All other warnings should be implemented in complain.c and should use
     the normal warning format.  */
 void set_warning_issued (void);
 
-/** Make a complaint, but don't specify any location.  */
-void complain (warnings flags, char const *message, ...)
+/** Informative messages, but we proceed.  Report iff
+    <tt>warnings_flag & warnings_other</tt>.  */
+
+void warn (char const *format, ...)
+  __attribute__ ((__format__ (__printf__, 1, 2)));
+
+void warn_at (location loc, char const *format, ...)
   __attribute__ ((__format__ (__printf__, 2, 3)));
 
-/** Make a complaint with location.  */
-void complain_at (location loc, warnings flags, char const *message, ...)
+/* Generate a message aligned by an indent.
+   When *indent == 0, assign message's indent to *indent,
+   When *indent > 0, align the message by *indent value. */
+void warn_at_indent (location loc, unsigned *indent,
+                     char const *format, ...)
   __attribute__ ((__format__ (__printf__, 3, 4)));
 
-/** Make a complaint with location and some indentation.  */
-void complain_at_indent (location loc, warnings flags, unsigned *indent,
-                         char const *message, ...)
-  __attribute__ ((__format__ (__printf__, 4, 5)));
+/** An error, but we continue and die later.  */
+
+void complain (char const *format, ...)
+  __attribute__ ((__format__ (__printf__, 1, 2)));
+
+void complain_at (location loc, char const *format, ...)
+  __attribute__ ((__format__ (__printf__, 2, 3)));
+
+/* Generate a message aligned by an indent.
+   When *indent == 0, assign message's indent to *indent,
+   When *indent > 0, align the message by *indent value. */
+void complain_at_indent (location loc, unsigned *indent,
+                         char const *format, ...)
+  __attribute__ ((__format__ (__printf__, 3, 4)));
+
+/** An incompatibility with POSIX Yacc: mapped either to warn* or
+    complain* depending on yacc_flag. */
+
+void yacc_at (location loc, char const *format, ...)
+  __attribute__ ((__format__ (__printf__, 2, 3)));
+
+/** A midrule-value warning.  Report iff
+    <tt>warnings_flag & warnings_midrule_values</tt>.  */
+
+void midrule_value_at (location loc, char const *format, ...)
+  __attribute__ ((__format__ (__printf__, 2, 3)));
+
+/** A fatal error, causing immediate exit.  */
+
+void fatal (char const *format, ...)
+  __attribute__ ((__noreturn__, __format__ (__printf__, 1, 2)));
+
+void fatal_at (location loc, char const *format, ...)
+  __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
 
 /** Whether an error was reported.  */
 extern bool complaint_issued;
 
-# ifdef __cplusplus
+# ifdef	__cplusplus
 }
 # endif
 

src/conflicts.c

@@ -1,7 +1,7 @@
 /* Find and resolve or report lookahead conflicts for bison,
 
-   Copyright (C) 1984, 1989, 1992, 2000-2012 Free Software Foundation,
-   Inc.
+   Copyright (C) 1984, 1989, 1992, 2000-2007, 2009-2012 Free Software
+   Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -64,75 +64,75 @@ enum conflict_resolution
 
 static inline void
 log_resolution (rule *r, symbol_number token,
-                enum conflict_resolution resolution)
+		enum conflict_resolution resolution)
 {
   if (report_flag & report_solved_conflicts)
     {
       /* The description of the resolution. */
       switch (resolution)
-        {
-        case shift_resolution:
-        case right_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
-                          _("    Conflict between rule %d and token %s"
-                            " resolved as shift"),
-                          r->number,
-                          symbols[token]->tag);
-          break;
+	{
+	case shift_resolution:
+	case right_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  _("    Conflict between rule %d and token %s"
+			    " resolved as shift"),
+			  r->number,
+			  symbols[token]->tag);
+	  break;
 
-        case reduce_resolution:
-        case left_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
-                          _("    Conflict between rule %d and token %s"
-                            " resolved as reduce"),
-                          r->number,
-                          symbols[token]->tag);
-          break;
+	case reduce_resolution:
+	case left_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  _("    Conflict between rule %d and token %s"
+			    " resolved as reduce"),
+			  r->number,
+			  symbols[token]->tag);
+	  break;
 
-        case nonassoc_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
-                          _("    Conflict between rule %d and token %s"
-                            " resolved as an error"),
-                          r->number,
-                          symbols[token]->tag);
-          break;
-        }
+	case nonassoc_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  _("    Conflict between rule %d and token %s"
+			    " resolved as an error"),
+			  r->number,
+			  symbols[token]->tag);
+	  break;
+	}
 
       /* The reason. */
       switch (resolution)
-        {
-        case shift_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
-                          " (%s < %s)",
-                          r->prec->tag,
-                          symbols[token]->tag);
-          break;
+	{
+	case shift_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  " (%s < %s)",
+			  r->prec->tag,
+			  symbols[token]->tag);
+	  break;
 
-        case reduce_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
-                          " (%s < %s)",
-                          symbols[token]->tag,
-                          r->prec->tag);
-          break;
+	case reduce_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  " (%s < %s)",
+			  symbols[token]->tag,
+			  r->prec->tag);
+	  break;
 
-        case left_resolution:
-          obstack_fgrow1 (&solved_conflicts_obstack,
-                          " (%%left %s)",
-                          symbols[token]->tag);
-          break;
+	case left_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  " (%%left %s)",
+			  symbols[token]->tag);
+	  break;
 
-        case right_resolution:
-          obstack_fgrow1 (&solved_conflicts_obstack,
-                          " (%%right %s)",
-                          symbols[token]->tag);
-          break;
+	case right_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  " (%%right %s)",
+			  symbols[token]->tag);
+	  break;
 
-        case nonassoc_resolution:
-          obstack_fgrow1 (&solved_conflicts_obstack,
-                          " (%%nonassoc %s)",
-                          symbols[token]->tag);
-          break;
-        }
+	case nonassoc_resolution:
+	  obstack_printf (&solved_conflicts_obstack,
+			  " (%%nonassoc %s)",
+			  symbols[token]->tag);
+	  break;
+	}
 
       obstack_sgrow (&solved_conflicts_obstack, ".\n");
     }
@@ -145,7 +145,7 @@ log_resolution (rule *r, symbol_number token,
         {
         case shift_resolution:
         case right_resolution:
-          obstack_fgrow2 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "        <resolution rule=\"%d\" symbol=\"%s\""
                           " type=\"shift\">",
                           r->number,
@@ -154,7 +154,7 @@ log_resolution (rule *r, symbol_number token,
 
         case reduce_resolution:
         case left_resolution:
-          obstack_fgrow2 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "        <resolution rule=\"%d\" symbol=\"%s\""
                           " type=\"reduce\">",
                           r->number,
@@ -162,7 +162,7 @@ log_resolution (rule *r, symbol_number token,
           break;
 
         case nonassoc_resolution:
-          obstack_fgrow2 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "        <resolution rule=\"%d\" symbol=\"%s\""
                           " type=\"error\">",
                           r->number,
@@ -174,33 +174,33 @@ log_resolution (rule *r, symbol_number token,
       switch (resolution)
         {
         case shift_resolution:
-          obstack_fgrow2 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "%s &lt; %s",
                           xml_escape_n (0, r->prec->tag),
                           xml_escape_n (1, symbols[token]->tag));
           break;
 
         case reduce_resolution:
-          obstack_fgrow2 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "%s &lt; %s",
                           xml_escape_n (0, symbols[token]->tag),
                           xml_escape_n (1, r->prec->tag));
           break;
 
         case left_resolution:
-          obstack_fgrow1 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "%%left %s",
                           xml_escape (symbols[token]->tag));
           break;
 
         case right_resolution:
-          obstack_fgrow1 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "%%right %s",
                           xml_escape (symbols[token]->tag));
           break;
 
         case nonassoc_resolution:
-          obstack_fgrow1 (&solved_conflicts_xml_obstack,
+          obstack_printf (&solved_conflicts_xml_obstack,
                           "%%nonassoc %s",
                           xml_escape (symbols[token]->tag));
       break;
@@ -226,7 +226,7 @@ flush_shift (state *s, int token)
   bitset_reset (lookahead_set, token);
   for (i = 0; i < trans->num; i++)
     if (!TRANSITION_IS_DISABLED (trans, i)
-        && TRANSITION_SYMBOL (trans, i) == token)
+	&& TRANSITION_SYMBOL (trans, i) == token)
       TRANSITION_DISABLE (trans, i);
 }
 
@@ -268,56 +268,51 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs)
 
   for (i = 0; i < ntokens; i++)
     if (bitset_test (lookahead_tokens, i)
-        && bitset_test (lookahead_set, i)
-        && symbols[i]->prec)
+	&& bitset_test (lookahead_set, i)
+	&& symbols[i]->prec)
       {
-        /* Shift-reduce conflict occurs for token number i
-           and it has a precedence.
-           The precedence of shifting is that of token i.  */
-        if (symbols[i]->prec < redprec)
-          {
-            log_resolution (redrule, i, reduce_resolution);
-            flush_shift (s, i);
-          }
-        else if (symbols[i]->prec > redprec)
-          {
-            log_resolution (redrule, i, shift_resolution);
-            flush_reduce (lookahead_tokens, i);
-          }
-        else
-          /* Matching precedence levels.
-             For non-defined associativity, keep both: unexpected
-             associativity conflict.
-             For left associativity, keep only the reduction.
-             For right associativity, keep only the shift.
-             For nonassociativity, keep neither.  */
+	/* Shift-reduce conflict occurs for token number i
+	   and it has a precedence.
+	   The precedence of shifting is that of token i.  */
+	if (symbols[i]->prec < redprec)
+	  {
+	    log_resolution (redrule, i, reduce_resolution);
+	    flush_shift (s, i);
+	  }
+	else if (symbols[i]->prec > redprec)
+	  {
+	    log_resolution (redrule, i, shift_resolution);
+	    flush_reduce (lookahead_tokens, i);
+	  }
+	else
+	  /* Matching precedence levels.
+	     For left association, keep only the reduction.
+	     For right association, keep only the shift.
+	     For nonassociation, keep neither.  */
 
-          switch (symbols[i]->assoc)
-            {
-            case undef_assoc:
-              abort ();
+	  switch (symbols[i]->assoc)
+	    {
+	    default:
+	      abort ();
 
-            case precedence_assoc:
-              break;
+	    case right_assoc:
+	      log_resolution (redrule, i, right_resolution);
+	      flush_reduce (lookahead_tokens, i);
+	      break;
 
-            case right_assoc:
-              log_resolution (redrule, i, right_resolution);
-              flush_reduce (lookahead_tokens, i);
-              break;
+	    case left_assoc:
+	      log_resolution (redrule, i, left_resolution);
+	      flush_shift (s, i);
+	      break;
 
-            case left_assoc:
-              log_resolution (redrule, i, left_resolution);
-              flush_shift (s, i);
-              break;
-
-            case non_assoc:
-              log_resolution (redrule, i, nonassoc_resolution);
-              flush_shift (s, i);
-              flush_reduce (lookahead_tokens, i);
-              /* Record an explicit error for this token.  */
-              errors[(*nerrs)++] = symbols[i];
-              break;
-            }
+	    case non_assoc:
+	      log_resolution (redrule, i, nonassoc_resolution);
+	      flush_shift (s, i);
+	      flush_reduce (lookahead_tokens, i);
+	      /* Record an explicit error for this token.  */
+	      errors[(*nerrs)++] = symbols[i];
+	      break;
+	    }
       }
 }
 
@@ -350,7 +345,7 @@ set_conflicts (state *s, symbol **errors)
      precedence.  */
   for (i = 0; i < reds->num; ++i)
     if (reds->rules[i]->prec && reds->rules[i]->prec->prec
-        && !bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))
+	&& !bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))
       resolve_sr_conflict (s, i, errors, &nerrs);
 
   if (nerrs)
@@ -375,7 +370,7 @@ set_conflicts (state *s, symbol **errors)
   for (i = 0; i < reds->num; ++i)
     {
       if (!bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))
-        conflicts[s->number] = 1;
+	conflicts[s->number] = 1;
       bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]);
     }
 }
@@ -404,9 +399,9 @@ conflicts_solve (void)
       set_conflicts (states[i], errors);
 
       /* For uniformity of the code, make sure all the states have a valid
-         `errs' member.  */
+	 `errs' member.  */
       if (!states[i]->errs)
-        states[i]->errs = errs_new (0, 0);
+	states[i]->errs = errs_new (0, 0);
     }
 
   free (errors);
@@ -475,11 +470,11 @@ count_rr_conflicts (state *s, bool one_per_token)
       int count = 0;
       int j;
       for (j = 0; j < reds->num; ++j)
-        if (bitset_test (reds->lookahead_tokens[j], i))
-          count++;
+	if (bitset_test (reds->lookahead_tokens[j], i))
+	  count++;
 
       if (count >= 2)
-        rrc_count += one_per_token ? 1 : count-1;
+	rrc_count += one_per_token ? 1 : count-1;
     }
 
   return rrc_count;
@@ -495,7 +490,7 @@ conflict_report (FILE *out, int src_num, int rrc_num)
 {
   if (src_num && rrc_num)
     fprintf (out, _("conflicts: %d shift/reduce, %d reduce/reduce\n"),
-             src_num, rrc_num);
+	     src_num, rrc_num);
   else if (src_num)
     fprintf (out, _("conflicts: %d shift/reduce\n"), src_num);
   else if (rrc_num)
@@ -516,12 +511,12 @@ conflicts_output (FILE *out)
     {
       state *s = states[i];
       if (conflicts[i])
-        {
-          fprintf (out, _("State %d "), i);
-          conflict_report (out, count_sr_conflicts (s),
-                           count_rr_conflicts (s, true));
-          printed_sth = true;
-        }
+	{
+	  fprintf (out, _("State %d "), i);
+	  conflict_report (out, count_sr_conflicts (s),
+			   count_rr_conflicts (s, true));
+	  printed_sth = true;
+	}
     }
   if (printed_sth)
     fputs ("\n\n", out);
@@ -531,7 +526,7 @@ conflicts_output (FILE *out)
 | Total the number of S/R and R/R conflicts.  Unlike the  |
 | code in conflicts_output, however, count EACH pair of   |
 | reductions for the same state and lookahead as one      |
-| conflict.                                               |
+| conflict.						  |
 `--------------------------------------------------------*/
 
 int
@@ -545,8 +540,8 @@ conflicts_total_count (void)
   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {
-        count += count_sr_conflicts (states[i]);
-        count += count_rr_conflicts (states[i], false);
+	count += count_sr_conflicts (states[i]);
+	count += count_rr_conflicts (states[i], false);
       }
   return count;
 }
@@ -576,15 +571,15 @@ conflicts_print (void)
 
     for (i = 0; i < nstates; i++)
       if (conflicts[i])
-        {
-          src_total += count_sr_conflicts (states[i]);
-          rrc_total += count_rr_conflicts (states[i], true);
-        }
+	{
+	  src_total += count_sr_conflicts (states[i]);
+	  rrc_total += count_rr_conflicts (states[i], true);
+	}
   }
 
   if (! glr_parser && rrc_total > 0 && expected_rr_conflicts != -1)
     {
-      complain (Wother, _("%%expect-rr applies only to GLR parsers"));
+      warn (_("%%expect-rr applies only to GLR parsers"));
       expected_rr_conflicts = -1;
     }
 
@@ -601,9 +596,9 @@ conflicts_print (void)
   /* Report the total number of conflicts on STDERR.  */
   if (expected_sr_conflicts == -1 && expected_rr_conflicts == -1)
     {
-      if (!(warnings_flag & Wconflicts_sr))
+      if (!(warnings_flag & warnings_conflicts_sr))
         src_total = 0;
-      if (!(warnings_flag & Wconflicts_rr))
+      if (!(warnings_flag & warnings_conflicts_rr))
         rrc_total = 0;
     }
   if (src_total | rrc_total)
@@ -611,22 +606,22 @@ conflicts_print (void)
       if (expected_sr_conflicts == -1 && expected_rr_conflicts == -1)
         set_warning_issued ();
       if (! yacc_flag)
-        fprintf (stderr, "%s: ", current_file);
+	fprintf (stderr, "%s: ", current_file);
       conflict_report (stderr, src_total, rrc_total);
     }
 
   if (expected_sr_conflicts != -1 || expected_rr_conflicts != -1)
     {
       if (! src_ok)
-        complain (complaint, ngettext ("expected %d shift/reduce conflict",
-                                       "expected %d shift/reduce conflicts",
-                                       src_expected),
-                  src_expected);
+	complain (ngettext ("expected %d shift/reduce conflict",
+			    "expected %d shift/reduce conflicts",
+			    src_expected),
+		  src_expected);
       if (! rrc_ok)
-        complain (complaint, ngettext ("expected %d reduce/reduce conflict",
-                                       "expected %d reduce/reduce conflicts",
-                                       rrc_expected),
-                  rrc_expected);
+	complain (ngettext ("expected %d reduce/reduce conflict",
+			    "expected %d reduce/reduce conflicts",
+			    rrc_expected),
+		  rrc_expected);
     }
 }
 

src/derives.c

@@ -49,11 +49,10 @@ print_derives (void)
       rule **rp;
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
       for (rp = derives[i - ntokens]; *rp; ++rp)
-        {
-          fprintf (stderr, "\t\t%3d ", (*rp)->user_number);
-          rule_rhs_print (*rp, stderr);
-          fprintf (stderr, "\n");
-        }
+	{
+	  fprintf (stderr, "\t\t%3d ", (*rp)->user_number);
+	  rule_rhs_print (*rp, stderr);
+	}
     }
 
   fputs ("\n\n", stderr);
@@ -97,10 +96,10 @@ derives_compute (void)
       rule_list *p = dset[i - ntokens];
       derives[i - ntokens] = q;
       while (p)
-        {
-          *q++ = p->value;
-          p = p->next;
-        }
+	{
+	  *q++ = p->value;
+	  p = p->next;
+	}
       *q++ = NULL;
     }
 

src/files.c

@@ -134,18 +134,6 @@ xfclose (FILE *ptr)
 }
 
 
-FILE *
-xfdopen (int fd, char const *mode)
-{
-  FILE *res = fdopen (fd, mode);
-  if (! res)
-    error (EXIT_FAILURE, get_errno (),
-           // On a separate line to please the "unmarked_diagnostics"
-           // syntax-check.
-           "fdopen");
-  return res;
-}
-
 /*------------------------------------------------------------------.
 | Compute ALL_BUT_EXT, ALL_BUT_TAB_EXT and output files extensions. |
 `------------------------------------------------------------------*/
@@ -154,7 +142,7 @@ xfdopen (int fd, char const *mode)
 static void
 compute_exts_from_gf (const char *ext)
 {
-  if (STREQ (ext, ".y"))
+  if (strcmp (ext, ".y") == 0)
     {
       src_extension = xstrdup (language->src_extension);
       header_extension = xstrdup (language->header_extension);
@@ -214,12 +202,12 @@ compute_exts_from_src (const char *ext)
 
 static void
 file_name_split (const char *file_name,
-                 const char **base, const char **tab, const char **ext)
+		 const char **base, const char **tab, const char **ext)
 {
   *base = last_component (file_name);
 
   /* Look for the extension, i.e., look for the last dot. */
-  *ext = strrchr (*base, '.');
+  *ext = mbsrchr (*base, '.');
   *tab = NULL;
 
   /* If there is an extension, check if there is a `.tab' part right
@@ -227,10 +215,11 @@ file_name_split (const char *file_name,
   if (*ext)
     {
       size_t baselen = *ext - *base;
-      size_t dottablen = sizeof (TAB_EXT) - 1;
+      size_t dottablen = 4;
       if (dottablen < baselen
-          && STRPREFIX_LIT (TAB_EXT, *ext - dottablen))
-        *tab = *ext - dottablen;
+	  && (strncmp (*ext - dottablen, ".tab", dottablen) == 0
+	      || strncmp (*ext - dottablen, "_tab", dottablen) == 0))
+	*tab = *ext - dottablen;
     }
 }
 
@@ -252,44 +241,44 @@ compute_file_name_parts (void)
 
       /* ALL_BUT_EXT goes up the EXT, excluding it. */
       all_but_ext =
-        xstrndup (spec_outfile,
-                  (strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
+	xstrndup (spec_outfile,
+		  (strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
 
       /* ALL_BUT_TAB_EXT goes up to TAB, excluding it.  */
       all_but_tab_ext =
-        xstrndup (spec_outfile,
-                  (strlen (spec_outfile)
-                   - (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
+	xstrndup (spec_outfile,
+		  (strlen (spec_outfile)
+		   - (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
 
       if (ext)
-        compute_exts_from_src (ext);
+	compute_exts_from_src (ext);
     }
   else
     {
       file_name_split (grammar_file, &base, &tab, &ext);
 
       if (spec_file_prefix)
-        {
-          /* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT = `foo'.  */
-          dir_prefix =
+	{
+	  /* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT = `foo'.  */
+	  dir_prefix =
             xstrndup (spec_file_prefix,
                       last_component (spec_file_prefix) - spec_file_prefix);
-          all_but_tab_ext = xstrdup (spec_file_prefix);
-        }
+	  all_but_tab_ext = xstrdup (spec_file_prefix);
+	}
       else if (yacc_flag)
-        {
-          /* If --yacc, then the output is `y.tab.c'.  */
-          dir_prefix = xstrdup ("");
-          all_but_tab_ext = xstrdup ("y");
-        }
+	{
+	  /* If --yacc, then the output is `y.tab.c'.  */
+	  dir_prefix = xstrdup ("");
+	  all_but_tab_ext = xstrdup ("y");
+	}
       else
-        {
-          /* Otherwise, ALL_BUT_TAB_EXT is computed from the input
-             grammar: `foo/bar.yy' => `bar'.  */
-          dir_prefix = xstrdup ("");
-          all_but_tab_ext =
-            xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0)));
-        }
+	{
+	  /* Otherwise, ALL_BUT_TAB_EXT is computed from the input
+	     grammar: `foo/bar.yy' => `bar'.  */
+	  dir_prefix = xstrdup ("");
+	  all_but_tab_ext =
+	    xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0)));
+	}
 
       if (language->add_tab)
         all_but_ext = concat2 (all_but_tab_ext, TAB_EXT);
@@ -298,7 +287,7 @@ compute_file_name_parts (void)
 
       /* Compute the extensions from the grammar file name.  */
       if (ext && !yacc_flag)
-        compute_exts_from_gf (ext);
+	compute_exts_from_gf (ext);
     }
 }
 
@@ -325,20 +314,20 @@ compute_output_file_names (void)
   if (defines_flag)
     {
       if (! spec_defines_file)
-        spec_defines_file = concat2 (all_but_ext, header_extension);
+	spec_defines_file = concat2 (all_but_ext, header_extension);
     }
 
   if (graph_flag)
     {
       if (! spec_graph_file)
-        spec_graph_file = concat2 (all_but_tab_ext, ".dot");
+	spec_graph_file = concat2 (all_but_tab_ext, ".dot");
       output_file_name_check (&spec_graph_file);
     }
 
   if (xml_flag)
     {
       if (! spec_xml_file)
-        spec_xml_file = concat2 (all_but_tab_ext, ".xml");
+	spec_xml_file = concat2 (all_but_tab_ext, ".xml");
       output_file_name_check (&spec_xml_file);
     }
 
@@ -358,9 +347,9 @@ void
 output_file_name_check (char **file_name)
 {
   bool conflict = false;
-  if (STREQ (*file_name, grammar_file))
+  if (0 == strcmp (*file_name, grammar_file))
     {
-      complain (complaint, _("refusing to overwrite the input file %s"),
+      complain (_("refusing to overwrite the input file %s"),
                 quote (*file_name));
       conflict = true;
     }
@@ -368,10 +357,10 @@ output_file_name_check (char **file_name)
     {
       int i;
       for (i = 0; i < file_names_count; i++)
-        if (STREQ (file_names[i], *file_name))
+        if (0 == strcmp (file_names[i], *file_name))
           {
-            complain (Wother, _("conflicting outputs to file %s"),
-                      quote (*file_name));
+            warn (_("conflicting outputs to file %s"),
+                  quote (*file_name));
             conflict = true;
           }
     }

src/files.h

@@ -65,8 +65,7 @@ void compute_output_file_names (void);
 void output_file_names_free (void);
 void output_file_name_check (char **file_name);
 
-FILE *xfopen (const char *name, char const *mode);
+FILE *xfopen (const char *name, const char *mode);
 void xfclose (FILE *ptr);
-FILE *xfdopen (int fd, char const *mode);
 
 #endif /* !FILES_H_ */

src/flex-scanner.h

@@ -34,7 +34,7 @@
                        && Subminor < YY_FLEX_SUBMINOR_VERSION))))))
 
 /* Pacify "gcc -Wmissing-prototypes" when flex 2.5.31 is used.  */
-#if ! FLEX_VERSION_GT (2, 5, 31)
+# if ! FLEX_VERSION_GT (2, 5, 31)
 int   FLEX_PREFIX (get_lineno) (void);
 FILE *FLEX_PREFIX (get_in) (void);
 FILE *FLEX_PREFIX (get_out) (void);
@@ -82,16 +82,16 @@ int   FLEX_PREFIX (lex_destroy) (void);
 
 static struct obstack obstack_for_string;
 
-# define STRING_GROW                                    \
+# define STRING_GROW   \
   obstack_grow (&obstack_for_string, yytext, yyleng)
 
-# define STRING_FINISH                                  \
-  do {                                                  \
-    obstack_1grow (&obstack_for_string, '\0');          \
-    last_string = obstack_finish (&obstack_for_string); \
+# define STRING_FINISH					\
+  do {							\
+    obstack_1grow (&obstack_for_string, '\0');		\
+    last_string = obstack_finish (&obstack_for_string);	\
   } while (0)
 
-# define STRING_FREE                                    \
+# define STRING_FREE \
   obstack_free (&obstack_for_string, last_string)
 
 #endif