version 2.6.2

* 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.1

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,
+MAINTAINER_CHECKS =				\
-## but also to run the tests.  Of course, you ought to keep a sane
+  maintainer-check				\
-## version of Bison nearby...
+  maintainer-push-check				\
-BISON = $(top_builddir)/tests/bison
+  maintainer-xml-check				\
-BISON_IN = $(top_srcdir)/tests/bison.in
+  maintainer-release-check
-YACC = $(BISON) -y
+.PHONY: $(MAINTAINER_CHECKS)
-AM_YFLAGS = -d -v --warnings=all,error --report=all
+$(MAINTAINER_CHECKS):
-
+	$(AM_V_GEN)cd tests && $(MAKE) $(AM_MAKEFLAGS) $@
-# 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
 
 # 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                    \
+	$(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,67 @@
 GNU Bison NEWS
 
-* Noteworthy changes in release ?.? (????-??-??) [?]
+* Noteworthy changes in release 2.6.2 (2012-08-03) [stable]
 
-** Warnings
+** Bug fixes
 
-*** Warning categories are now displayed in warnings
+  Buffer overruns, complaints from Flex, and portability issues in the test
+  suite have been fixed.
 
-  For instance:
+** Spaces in %lex- and %parse-param (lalr1.cc, glr.cc)
 
-  foo.y:4.6: warning: type clash on default action: <foo> != <bar> [-Wother]
+  Trailing end-of-lines in %parse-param or %lex-param would result in
+  invalid C++.  This is fixed.
 
-*** Useless semantic types
+** Spurious spaces and end-of-lines
 
-  Bison now warns about useless (uninhabited) semantic types.  Since
+  The generated files no longer end (nor start) with empty lines.
-  semantic types are not declared to Bison (they are defined in the opaque
-  %union structure), it is %printer/%destructor directives about useless
-  types that trigger the warning:
 
-    %token <type1> term
+* Noteworthy changes in release 2.6.1 (2012-07-30) [stable]
-    %type  <type2> nterm
-    %printer    {} <type1> <type3>
-    %destructor {} <type2> <type4>
-    %%
-    nterm: term { $$ = $1; };
 
-    3.28-34: warning: type <type3> is used, but is not associated to any symbol
+ Bison no longer executes user-specified M4 code when processing a grammar.
-    4.28-34: warning: type <type4> is used, but is not associated to any symbol
 
-*** Undeclared symbols
+** Future Changes
 
-  Bison used to raise an error for %printer and %destructor directives for
+  In addition to the removal of the features announced in Bison 2.6, the
-  undefined symbols.
+  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:
 
-    %printer    {} symbol1
+    exp: exp "+" exp { $$ = $1 + $3 };
-    %destructor {} symbol2
-    %%
-    exp: "a";
 
-  This is now only a warning.
+  write:
 
-*** Useless destructors or printers
+    exp: exp "+" exp { $$ = $1 + $3; };
 
-  Bison now warns about useless destructors or printers.  In the following
+** Bug fixes
-  example, the printer for <type1>, and the destructor for <type2> are
-  useless: all symbols of <type1> (token1) already have a printer, and all
-  symbols of type <type2> (token2) already have a destructor.
 
-    %token <type1> token1
+*** Type names are now properly escaped.
-           <type2> token2
-           <type3> token3
-           <type4> token4
-    %printer    {} token1 <type1> <type3>
-    %destructor {} token2 <type2> <type4>
 
-** Additional yylex/yyparse arguments
+*** glr.cc: set_debug_level and debug_level work as expected.
 
-  The new directive %param declares additional arguments to both yylex and
+*** Stray @ or $ in actions
-  yyparse.  The %lex-param, %parse-param, and %param directives support one
-  or more arguments.  Instead of
 
-    %lex-param   {arg1_type *arg1}
+  While Bison used to warn about stray $ or @ in action rules, it did not
-    %lex-param   {arg2_type *arg2}
+  for other actions such as printers, destructors, or initial actions.  It
-    %parse-param {arg1_type *arg1}
+  now does.
-    %parse-param {arg2_type *arg2}
 
-  one may now declare
+** Type names in actions
 
-    %param {arg1_type *arg1} {arg2_type *arg2}
+  For consistency with rule actions, it is now possible to qualify $$ by a
+  type-name in destructors, printers, and initial actions.  For instance:
 
-** Java skeleton improvements
+    %printer { fprintf (yyo, "(%d, %f)", $<ival>$, $<fval>$); } <*> <>;
-
-  The constants for token names were moved to the Lexer interface.
-  Also, it is possible to add code to the parser's constructors using
-  "%code init" and "%define init_throws".
-
-** C++ skeleton improvements
-
-  The C++ parser features a syntax_error exception, which can be
-  thrown from the scanner or from user rules to raise syntax errors.
-  This facilitates reporting errors caught in sub-functions (e.g.,
-  rejecting too large integral literals from a conversion function
-  used by the scanner, or rejecting invalid combinations from a
-  factory invoked by the user actions).
-
-** Variable api.tokens.prefix
-
-  The variable api.tokens.prefix changes the way tokens are identified in
-  the generated files.  This is especially useful to avoid collisions
-  with identifiers in the target language.  For instance
-
-    %token FILE for ERROR
-    %define api.tokens.prefix "TOK_"
-    %%
-    start: FILE for ERROR;
-
-  will generate the definition of the symbols TOK_FILE, TOK_for, and
-  TOK_ERROR in the generated sources.  In particular, the scanner must
-  use these prefixed token names, although the grammar itself still
-  uses the short names (as in the sample rule given above).
-
-** Variable api.namespace
-
-  The "namespace" variable is renamed "api.namespace".  Backward
-  compatibility is ensured, but upgrading is recommended.
-
-** Variable parse.error
-
-  The variable error controls the verbosity of error messages.  The
-  use of the %error-verbose directive is deprecated in favor of
-  %define parse.error "verbose".
-
-** Semantic predicates
-
-  The new, experimental, semantic-predicate feature allows actions of
-  the form %?{ BOOLEAN-EXPRESSION }, which cause syntax errors (as for
-  YYERROR) if the expression evaluates to 0, and are evaluated immediately
-  in GLR parsers, rather than being deferred.  The result is that they
-  allow the programmer to prune possible parses based on the values of
-  run-time expressions.
-
-* Noteworthy changes in release ?.? (????-??-??) [?]
 
+  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 +1857,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:  lang yyoutput dvi html ps POSIX lvalp llocp
- LocalWords:  TOK
 
 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
 
@@ -233,9 +226,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

THANKS

@@ -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]
@@ -70,7 +71,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]
@@ -88,7 +88,6 @@ Per Allansson             [email protected]
 Peter Fales               [email protected]
 Peter Hamorsky            [email protected]
 Piotr Gackiewicz          [email protected]
-Quentin Hocquet           [email protected]
 Quoc Peyrot               [email protected]
 R Blake                   [email protected]
 Raja R Harinath           [email protected]
@@ -102,7 +101,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
+  javaexec-script ldexpl malloc-gnu mbschr mbsrchr
-  mbswidth obstack perror progname
+  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 xalloc-die xmemdup0 xstrndup
-  xalloc-die
-  xconcat-filename
-  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:1:c-format --flag=complain_at:2:c-format\\\
- --flag=complain_at:3:c-format\\\
+ --flag=fatal:1:c-format --flag=fatal_at:2:c-format\\\
- --flag=complain_at_indent:4: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 +=                                   \
+EXTRA_DIST =					\
-  build-aux/cross-options.pl                    \
+  cross-options.pl				\
-  build-aux/darwin11.4.0.valgrind               \
+  darwin11.4.0.valgrind				\
-  build-aux/move-if-change                      \
+  prev-version.txt				\
-  build-aux/prev-version.txt                    \
+  update-b4-copyright
-  build-aux/update-b4-copyright

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".
+# 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_magic_number_exit=^doc/bison.texi$$				\
-  prohibit_strcmp=^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
+AM_INIT_AUTOMAKE([1.11.1 dist-xz silent-rules]
-                 color-tests parallel-tests
-                 silent-rules]
                  m4_bmatch(m4_defn([AC_PACKAGE_VERSION]), [[-_]],
                            [gnu], [gnits]))
 AM_SILENT_RULES([yes])
@@ -73,7 +71,6 @@ 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])
   for i in $warn_common $warn_c;
   do
@@ -90,7 +87,7 @@ if test "$enable_gcc_warnings" = yes; then
   do
     gl_WARN_ADD([$i], [WARN_CXXFLAGS])
   done
-  gl_WARN_ADD([-Wzero-as-null-pointer-constant], [WARN_CXXFLAGS],
+  gl_WARN_ADD([ -Wzero-as-null-pointer-constant], [WARN_CXXFLAGS],
               [AC_LANG_PROGRAM([], [nullptr])])
   gl_WARN_ADD([-Werror], [WERROR_CXXFLAGS])
   # Warnings for the test suite only.
@@ -108,8 +105,8 @@ AC_ARG_ENABLE([yacc],
   , [enable_yacc=yes])
 case $enable_yacc in
 yes)
-  YACC_SCRIPT=src/yacc
+  YACC_SCRIPT=yacc
-  YACC_LIBRARY=lib/liby.a;;
+  YACC_LIBRARY=liby.a;;
 *)
   YACC_SCRIPT=
   YACC_LIBRARY=;;
@@ -126,10 +123,6 @@ AC_PROG_GNU_M4
 AC_DEFINE_UNQUOTED([M4], ["$M4"], [Define to the GNU M4 executable name.])
 AC_DEFINE_UNQUOTED([M4_GNU_OPTION], ["$M4_GNU"], [Define to "-g" if GNU M4
 supports -g, otherwise to "".])
-AC_PATH_PROG([PERL], [perl])
-if test -z "$PERL"; then
-   AC_MSG_ERROR([perl not found])
-fi
 AM_MISSING_PROG([HELP2MAN], [help2man])
 AC_PATH_PROG([XSLTPROC], [xsltproc])
 AC_SUBST([XSLTPROC])
@@ -167,7 +160,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 +170,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
+		 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])
+# b4_copyright(TITLE, YEARS)
-# ----------------------------
+# --------------------------
-# If YEARS are not defined, use b4_copyright_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_text_wrap([Copyright (C) $2 Free Software Foundation, Inc.], [   ])
-]m4_ifval([$2], [[$2]], [m4_defn([b4_copyright_years])])[
-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.  ##
@@ -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.
 
-
+# yytoken_table is needed to support verbose errors.
-## --------- ##
+b4_error_verbose_if([m4_define([b4_token_table_flag], [1])])
-## 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]))])
 
 
 
@@ -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,15 +428,9 @@ 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],
+	  [m4_define([b4_percent_define_bison_variables(]$1[)])$2],
 	  [$3])])
 
-
-## --------- ##
-## Options.  ##
-## --------- ##
-
-
 # b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE])
 # --------------------------------------------------------
 # Mimic muscle_percent_define_flag_if in ../src/muscle-tab.h exactly.  That is,
@@ -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
@@ -800,44 +546,6 @@ m4_define([b4_percent_code_ifdef],
 	  [$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])])
-
-
 ## ----------------------------------------------------------- ##
 ## After processing the skeletons, check that all the user's   ##
 ## %define variables and %code qualifiers were used by Bison.  ##

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.  */
+[/* Tokens.  */
    enum yytokentype {
-    ]m4_join([,
+m4_map_sep([     b4_token_enum], [,
-      ],
+],
-             b4_symbol_map([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()
 # -----------------

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)
 # ----------------
@@ -48,34 +49,11 @@ m4_define([b4_cpp_guard_close],
 ## Identification.  ##
 ## ---------------- ##
 
-# b4_comment_(TEXT, OPEN, CONTINUE, END)
+# b4_comment(TEXT)
-# -------------------------------------
+# ----------------
-# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
+m4_define([b4_comment], [/* m4_bpatsubst([$1], [
-# Avoid adding indentation to the first line, as the indentation comes
+], [
-# from OPEN.  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
+   ])  */])
-#
-# Prefix all the output lines with PREFIX.
-m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [
-\(.\)], [
-$3\1])$4])
-
-
-# b4_c_comment(TEXT, [PREFIX])
-# ----------------------------
-# Put TEXT in comment.  Avoid trailing spaces: don't indent empty lines.
-# Avoid adding indentation to the first line, as the indentation comes
-# from "/*".  That's why we don't patsubst([$1], [^\(.\)], [   \1]).
-#
-# Prefix all the output lines with PREFIX.
-m4_define([b4_c_comment],
-[b4_comment_([$1], [$2/* ], [$2   ], [$2  */])])
-
-
-# b4_comment(TEXT, [PREFIX])
-# --------------------------
-# By default, C comments.
-m4_define([b4_comment], [b4_c_comment($@)])
-
 
 # b4_identification
 # -----------------
@@ -157,13 +135,11 @@ m4_popdef([$2])dnl
 m4_popdef([$1])dnl
 ])])
 
-# b4_parse_param_use([VAL], [LOC])
+# b4_parse_param_use
-# --------------------------------
+# ------------------
-# `YYUSE' VAL, LOC if locations are enabled, and all the parse-params.
+# `YYUSE' all the parse-params.
 m4_define([b4_parse_param_use],
-[m4_ifvaln([$1], [  YYUSE([$1]);])dnl
+[b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
-b4_locations_if([m4_ifvaln([$2], [  YYUSE ([$2]);])])dnl
-b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
 ])dnl
 ])
 
@@ -234,83 +210,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
+
-# ----------------
+# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
-# Output the definition of the tokens.
+# -------------------------------------------------------
+# Output the definition of the tokens (if there are) as #defines.
 m4_define([b4_token_defines],
-[b4_any_token_visible_if([/* Tokens.  */
+[m4_if([$#$1], [1], [],
-m4_join([
+[/* Tokens.  */
-], b4_symbol_map([b4_token_define]))])])
+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([,
+]m4_map_sep([     b4_token_enum], [,
-  ],
+],
-            b4_symbol_map([b4_token_enum]))[
+	   [$@])[
    };
 #endif
 ]])])
 
 
-# b4_token_enums_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,
+# Output the definition of the tokens (if there are any) as enums and, if POSIX
-# if POSIX Yacc is enabled, as #defines.
+# Yacc is enabled, as #defines.
 m4_define([b4_token_enums_defines],
-[b4_token_enums[]b4_yacc_if([b4_token_defines])])
+[b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], [])
-
+])
-
-## ----------------- ##
-## Semantic Values.  ##
-## ----------------- ##
-
-
-# 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]))])
 
 
 
@@ -401,7 +357,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 +416,25 @@ m4_define([b4_sync_start], [[#]line $1 $2])
 m4_define([b4_case],
 [  case $1:
 $2
-b4_syncline([@oline@], [@ofile@])
     break;])
 
-
+# b4_symbol_actions(FILENAME, LINENO,
-# b4_predicate_case(LABEL, CONDITIONS)
+#                   SYMBOL-TAG, SYMBOL-NUM,
-# ------------------------------------
+#                   SYMBOL-ACTION, SYMBOL-TYPENAME)
-m4_define([b4_predicate_case],
+# -------------------------------------------------
-[  case $1:
+# Issue the code for a symbol action (e.g., %printer).
-    if (! ($2)) YYERROR;
+#
+# 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,15 +456,19 @@ 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
+  YYUSE (yyvaluep);
-[  if (!yymsg)
+]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
+]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
-[      default:
+      default:
 	break;
     }
 }]dnl
@@ -528,19 +496,21 @@ 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
+  YYUSE (yyo);
-[  if (!yyvaluep)
+  if (!yyvaluep)
-    return;]
+    return;
-dnl glr.c does not feature yytoknum.
+]b4_locations_if([  YYUSE (yylocationp);
-m4_if(b4_skeleton, ["yacc.c"],
+])dnl
-[[# ifdef YYPRINT
+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;
     }
@@ -619,17 +589,17 @@ 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])[
+#  define ]b4_api_PREFIX[DEBUG ]b4_debug_flag[
 # endif /* ! defined ]b4_api_PREFIX[DEBUG */
 #endif  /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl
 ])

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])])
+[((*yyvalp)[]m4_ifval([$1], [.$1]))])
-
-
-# b4_rhs_data(RULE-LENGTH, NUM)
-# -----------------------------
-# Expand to the semantic stack place that contains value and location
-# of symbol number NUM in a rule of length RULE-LENGTH.
-m4_define([b4_rhs_data],
-[((yyGLRStackItem const *)yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate])
 
 
 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
@@ -142,7 +134,7 @@ 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
@@ -227,7 +219,7 @@ b4_percent_code_get([[top]])[
 # 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
@@ -357,6 +349,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 +378,17 @@ static const char *const yytname[] =
 };
 #endif
 
-#define YYPACT_NINF ]b4_pact_ninf[
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-#define YYTABLE_NINF ]b4_table_ninf[
+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 +402,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
+/* YYDEFACT[S] -- default reduction number in state S.  Performed when
-   in the case of predicates.  */
+   YYTABLE doesn't specify something else to do.  Zero means the default
-static const yybool yyimmediate[] =
+   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,7 +457,19 @@ 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
 
@@ -473,11 +527,8 @@ static const int YYEMPTY = -2;
 typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 
 #define YYCHK(YYE)                                                           \
-  do {                                          \
+   do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; }       \
-    YYRESULTTAG yychk_flag = YYE;               \
+   while (YYID (0))
-    if (yychk_flag != yyok)                     \
-      return yychk_flag;                        \
-  } while (YYID (0))
 
 #if ]b4_api_PREFIX[DEBUG
 
@@ -486,22 +537,22 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 # endif
 
 # define YYDPRINTF(Args)                        \
-  do {                                          \
+do {                                            \
   if (yydebug)                                  \
     YYFPRINTF Args;                             \
-  } while (YYID (0))
+} while (YYID (0))
 
 ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[
 
 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
-  do {                                                                  \
+do {                                                            \
   if (yydebug)                                                  \
     {                                                           \
       YYFPRINTF (stderr, "%s ", Title);                         \
       yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[);        \
       YYFPRINTF (stderr, "\n");                                 \
     }                                                           \
-  } while (YYID (0))
+} while (YYID (0))
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
@@ -538,7 +589,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 +692,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 +713,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 +825,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
+      YYASSERT (s->yyresolved);
-      yyvsp[i].yystate.yylrState = s->yylrState;
+      yyvsp[i].yystate.yyresolved = yytrue;
-#endif
+      yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;]b4_locations_if([[
-      yyvsp[i].yystate.yyresolved = s->yyresolved;
-      if (s->yyresolved)
-        yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;
-      else
-        /* The effect of using yysval or yyloc (in an immediate rule) is
-         * undefined.  */
-        yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULL;]b4_locations_if([[
       yyvsp[i].yystate.yyloc = s->yyloc;]])[
       s = yyvsp[i].yystate.yypred = s->yypred;
     }
@@ -812,7 +862,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,7 +965,7 @@ 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)
 {
@@ -925,7 +975,7 @@ yylhsNonterm (yyRuleNum yyrule)
 #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,7 +983,7 @@ 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)
 {
@@ -948,8 +998,8 @@ yydefaultAction (yyStateNum yystate)
  *    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
+ *  Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of
- *  of conflicting reductions.
+ *  conflicting reductions.
  */
 static inline void
 yygetLRActions (yyStateNum yystate, int yytoken,
@@ -977,7 +1027,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,8 +1049,7 @@ yyisErrorAction (int yyaction)
 
                                 /* GLRStates */
 
-/** Return a fresh GLRStackItem in YYSTACKP.  The item is an LR state
+/** Return a fresh GLRStackItem.  Callers should call
- *  if YYISSTATE, and otherwise a semantic option.  Callers should call
  * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
  * headroom.  */
 
@@ -1014,16 +1064,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
+ *  RULENUM on the semantic values in RHS to the list of
- *  alternative actions for YYSTATE.  Assumes that YYRHS comes from
+ *  alternative actions for STATE.  Assumes that RHS comes from
- *  stack #YYK of *YYSTACKP. */
+ *  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 +1091,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 +1117,8 @@ static void yyfreeStateSet (yyGLRStateSet* yyset)
   YYFREE (yyset->yylookaheadNeeds);
 }
 
-/** Initialize *YYSTACKP to a single empty stack, with total maximum
+/** Initialize STACK to a single empty stack, with total maximum
- *  capacity for all stacks of YYSIZE.  */
+ *  capacity for all stacks of SIZE.  */
 static yybool
 yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
 {
@@ -1090,7 +1140,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 +1210,9 @@ yyfreeGLRStack (yyGLRStack* yystackp)
   yyfreeStateSet (&yystackp->yytops);
 }
 
-/** Assuming that YYS is a GLRState somewhere on *YYSTACKP, update the
+/** Assuming that S is a GLRState somewhere on STACK, update the
- *  splitpoint of *YYSTACKP, if needed, so that it is at least as deep as
+ *  splitpoint of STACK, if needed, so that it is at least as deep as
- *  YYS.  */
+ *  S.  */
 static inline void
 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
 {
@@ -1170,7 +1220,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 +1229,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
+/** Undelete the last stack that was marked as deleted.  Can only be
-    only be done once after a deletion, and only when all other stacks have
+    done once after a deletion, and only when all other stacks have
     been deleted.  */
 static void
 yyundeleteLastStack (yyGLRStack* yystackp)
@@ -1229,9 +1279,8 @@ yyremoveDeletes (yyGLRStack* yystackp)
     }
 }
 
-/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR
+/** Shift to a new state on stack #K of STACK, corresponding to LR state
- * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic
+ * LRSTATE, at input position POSN, with (resolved) semantic value SVAL.  */
- * value *YYVALP and source location *YYLOCP.  */
 static inline void
 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
             size_t yyposn,
@@ -1250,12 +1299,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 +1316,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
+/** Pop the symbols consumed by reduction #RULE from the top of stack
-# define YY_REDUCE_PRINT(Args)
+ *  #K of STACK, and perform the appropriate semantic action on their
-#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
  *  semantic values.  Assumes that all ambiguities in semantic values
- *  have been previously resolved.  Set *YYVALP to the resulting value,
+ *  have been previously resolved.  Set *VALP to the resulting value,
- *  and *YYLOCP to the computed location (if any).  Return value is as
+ *  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 +1334,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, rhs, yystackp,
-      return yyuserAction (yyrule, yynrhs, yyrhs, yystackp,
                            yyvalp]b4_locuser_args[);
     }
   else
     {
+      /* At present, doAction is never called in nondeterministic
+       * mode, so this branch is never taken.  It is here in
+       * anticipation of a future feature that will allow immediate
+       * evaluation of selected actions in nondeterministic mode.  */
       int yyi;
       yyGLRState* yys;
       yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
@@ -1352,21 +1363,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
+ *  semantic action associated with RULE and store its value with the
- *  newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently
+ *  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
+ *  it is identified with that existing state, eliminating stack #K from
- *  *YYSTACKP.  In this case, the semantic value is
+ *  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 +1429,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])[);
+      YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[));
-      if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULL)
+      YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[));
-        {
-          YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n",
-                     (unsigned long int) yyk, yyrule - 1));
-        }
-      if (yyflag != yyok)
-        return yyflag;
       YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
       yyglrShift (yystackp, yyk,
                   yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
@@ -1411,8 +1456,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.  "
+                  "Reduced stack %lu by rule #%d; action deferred.  Now in state %d.\n",
-                  "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 +1527,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 +1549,8 @@ yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
     return yyfalse;
 }
 
-/** Assuming identicalOptions (YYY0,YYY1), destructively merge the
+/** Assuming identicalOptions (Y0,Y1), destructively merge the
- *  alternative semantic values for the RHS-symbols of YYY1 and YYY0.  */
+ *  alternative semantic values for the RHS-symbols of Y1 and Y0.  */
 static void
 yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
 {
@@ -1585,11 +1629,11 @@ static YYRESULTTAG yyresolveValue (yyGLRState* yys,
                                    yyGLRStack* yystackp]b4_user_formals[);
 
 
-/** Resolve the previous YYN states starting at and including state YYS
+/** Resolve the previous N states starting at and including state S.  If result
- *  on *YYSTACKP. If result != yyok, some states may have been left
+ *  != yyok, some states may have been left unresolved possibly with empty
- *  unresolved possibly with empty semantic option chains.  Regardless
+ *  semantic option chains.  Regardless of whether result = yyok, each state
- *  of whether result = yyok, each state has been left with consistent
+ *  has been left with consistent data so that yydestroyGLRState can be invoked
- *  data so that yydestroyGLRState can be invoked if necessary.  */
+ *  if necessary.  */
 static YYRESULTTAG
 yyresolveStates (yyGLRState* yys, int yyn,
                  yyGLRStack* yystackp]b4_user_formals[)
@@ -1604,10 +1648,9 @@ yyresolveStates (yyGLRState* yys, int yyn,
   return yyok;
 }
 
-/** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its
+/** Resolve the states for the RHS of OPT, perform its user action, and return
- *  user action, and return the semantic value and location in *YYVALP
+ *  the semantic value and location.  Regardless of whether result = yyok, all
- *  and *YYLOCP.  Regardless of whether result = yyok, all RHS states
+ *  RHS states have been destroyed (assuming the user action destroys all RHS
- *  have been destroyed (assuming the user action destroys all RHS
  *  semantic values if invoked).  */
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
@@ -1681,11 +1724,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]),
+                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
-                       (unsigned long int) (yystates[yyi-1]->yyposn + 1),
+                       (unsigned long int) (yystates[yyi - 1]->yyposn + 1),
                        (unsigned long int) yystates[yyi]->yyposn);
         }
       else
@@ -1714,9 +1757,9 @@ yyreportAmbiguity (yySemanticOption* yyx0,
   return yyabort;
 }]b4_locations_if([[
 
-/** Resolve the locations for each of the YYN1 states in *YYSTACKP,
+/** Starting at and including state S1, resolve the location for each of the
- *  ending at YYS1.  Has no effect on previously resolved states.
+ *  previous N1 states that is unresolved.  The first semantic option of a state
- *  The first semantic option of a state is always chosen.  */
+ *  is always chosen.  */
 static void
 yyresolveLocations (yyGLRState* yys1, int yyn1,
                     yyGLRStack *yystackp]b4_user_formals[)
@@ -1770,12 +1813,11 @@ yyresolveLocations (yyGLRState* yys1, int yyn1,
     }
 }]])[
 
-/** Resolve the ambiguity represented in state YYS in *YYSTACKP,
+/** Resolve the ambiguity represented in state S, perform the indicated
- *  perform the indicated actions, and set the semantic value of YYS.
+ *  actions, and set the semantic value of S.  If result != yyok, the chain of
- *  If result != yyok, the chain of semantic options in YYS has been
+ *  semantic options in S has been cleared instead or it has been left
- *  cleared instead or it has been left unmodified except that
+ *  unmodified except that redundant options may have been removed.  Regardless
- *  redundant options may have been removed.  Regardless of whether
+ *  of whether result = yyok, S has been left with consistent data so that
- *  result = yyok, YYS has been left with consistent data so that
  *  yydestroyGLRState can be invoked if necessary.  */
 static YYRESULTTAG
 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
@@ -1913,6 +1955,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 +1969,7 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
 
       if (yyisDefaultedState (yystate))
         {
-          YYRESULTTAG yyflag;
+          yyrule = yydefaultAction (yystate);
-          yyRuleNum yyrule = yydefaultAction (yystate);
           if (yyrule == 0)
             {
               YYDPRINTF ((stderr, "Stack %lu dies.\n",
@@ -1932,25 +1977,11 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
               yymarkStackDeleted (yystackp, yyk);
               return yyok;
             }
-          yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[);
+          YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
-          if (yyflag == yyerr)
-            {
-              YYDPRINTF ((stderr,
-                          "Stack %lu dies "
-                          "(predicate failure or explicit user error).\n",
-                          (unsigned long int) yyk));
-              yymarkStackDeleted (yystackp, yyk);
-              return yyok;
-            }
-          if (yyflag != yyok)
-            return yyflag;
         }
       else
         {
           yySymbol yytoken;
-          int yyaction;
-          const short int* yyconflicts;
-
           yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
           if (yychar == YYEMPTY)
             {
@@ -1973,25 +2004,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,
+              YYCHK (yyglrReduce (yystackp, yynewStack,
-                                    *yyconflicts,
+                                  *yyconflicts, yyfalse]b4_user_args[));
-                                    yyimmediate[*yyconflicts]]b4_user_args[);
-              if (yyflag == yyok)
               YYCHK (yyprocessOneStack (yystackp, yynewStack,
                                         yyposn]b4_pure_args[));
-              else if (yyflag == yyerr)
-                {
-                  YYDPRINTF ((stderr, "Stack %lu dies.\n",
-                              (unsigned long int) yynewStack));
-                  yymarkStackDeleted (yystackp, yynewStack);
-                }
-              else
-                return yyflag;
               yyconflicts += 1;
             }
 
@@ -2005,21 +2025,8 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
               break;
             }
           else
-            {
+            YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
-              YYRESULTTAG yyflag = yyglrReduce (yystackp, yyk, -yyaction,
+                                yyfalse]b4_user_args[));
-                                                yyimmediate[-yyaction]]b4_user_args[);
-              if (yyflag == yyerr)
-                {
-                  YYDPRINTF ((stderr,
-                              "Stack %lu dies "
-                              "(predicate failure or explicit user error).\n",
-                              (unsigned long int) yyk));
-                  yymarkStackDeleted (yystackp, yyk);
-                  break;
-                }
-              else if (yyflag != yyok)
-                return yyflag;
-            }
         }
     }
   return yyok;
@@ -2272,6 +2279,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
     }                                                                        \
   } while (YYID (0))
 
+
 /*----------.
 | yyparse.  |
 `----------*/
@@ -2294,12 +2302,10 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 #endif
 ])
 m4_ifdef([b4_initial_action], [
-m4_pushdef([b4_at_dollar],     [yylloc])dnl
+b4_dollar_pushdef([yylval], [], [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
+/* User initialization code.  */
-  /* User initialization code.  */
+b4_user_initial_action
-  b4_user_initial_action
+b4_dollar_popdef])[]dnl
-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
 [
   if (! yyinitGLRStack (yystackp, YYINITDEPTH))
     goto yyexhaustedlab;
@@ -2606,5 +2612,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.
@@ -129,7 +131,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 +164,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 +205,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 +228,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 +236,10 @@ b4_copyright([Skeleton interface for Bison GLR parsers in C++],
 
 ]b4_percent_code_get([[requires]])[
 
-#include <stdexcept>
+# include <string>
-#include <string>
+# include <iostream>
-#include <iostream>
 ]b4_percent_define_ifdef([[location_type]], [],
-                         [[#include "location.hh"]])[
+                         [[# include "location.hh"]])[
 
 ]b4_YYDEBUG_define[
 
@@ -246,7 +248,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 +292,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 +320,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)
 # ----------------
@@ -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.  */
+[  /** Token number, to be returned by the scanner.  */
-    static final int %s = %s;
+  public static final int $1 = $2;
-], [$1])])
+])
 
-# 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], [],
-b4_symbol_foreach([b4_token_enum])])])
+[/* 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]], [])
+b4_percent_define_default([[location_type]], [Location])])
-m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])])
-
-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,12 +219,12 @@ 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_default([b4_lex_param], [[]]))
-m4_define([b4_lex_param], b4_lex_param)
+m4_define([b4_lex_param], b4_lex_param))
-m4_define([b4_parse_param], b4_parse_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],
@@ -260,7 +233,7 @@ m4_define([b4_lex_param_decl],
 	  [$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($@)])
@@ -279,7 +252,7 @@ m4_define([b4_parse_param_decl],
 
 
 # b4_lex_param_call
-# -----------------
+# -------------------
 # Delegating the lexer parameters to the lexer constructor.
 m4_define([b4_lex_param_call],
           [m4_ifset([b4_lex_param],
@@ -287,7 +260,7 @@ m4_define([b4_lex_param_call],
 				     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])
 
 
@@ -300,7 +273,7 @@ m4_define([b4_parse_param_cons],
 		    [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;
 	  ])

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_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])])
-              [b4_skeleton])])
+m4_ifval(m4_defn([b4_symbol_destructors]),
-
+        [b4_fatal([%s: %%destructor 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])
 
 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_pre_prologue
-b4_user_post_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;
+  public boolean errorVerbose = ]b4_flag_value([error_verbose]);
-
-  /**
-   * 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; }
-]])
 
 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.  */
+     * @@param s The string for the error message.  */
-     void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String msg);]
+     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])[
+  public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) {
-  {
-    ]b4_percent_code_get([[init]])[
     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_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) {
-  {
-    ]b4_percent_code_get([[init]])[
     this.yylexer = yylexer;
     ]b4_parse_param_cons[
   }
@@ -228,35 +201,20 @@ b4_lexer_if([[
    */
   public final void setDebugLevel(int level) { yydebug = level; }
 
-  /**
+  private final int yylex () ]b4_maybe_throws([b4_lex_throws]) [{
-   * Print an error message via the lexer.
+    return yylexer.yylex ();
-   *]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);
   }
-]b4_locations_if([[
+  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 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);
   }
 
-  /**
+  ]b4_locations_if([
-   * Print an error message via the lexer.
+  protected final void yyerror (String s) {
-   * @@param pos The position associated with the message.
+    yylexer.yyerror ((]b4_location_type[)null, s);
-   * @@param msg The error message.
+  }
-   */
+  protected final void yyerror (]b4_position_type[ loc, String s) {
-  public final void yyerror (]b4_position_type[ pos, String msg)
+    yylexer.yyerror (new ]b4_location_type[ (loc), s);
-  {
+  }])
-    yylexer.yyerror (new ]b4_location_type[ (pos), msg);
-  }]])
 
   [protected final void yycdebug (String s) {
     if (yydebug > 0)
@@ -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
@@ -447,7 +404,6 @@ b4_lexer_if([[
 
     return yystr;
   }
-]])[
 
   /*--------------------------------.
   | Print this symbol on YYOUTPUT.  |
@@ -502,12 +458,10 @@ b4_lexer_if([[
     yyerrstatus_ = 0;
 
 ]m4_ifdef([b4_initial_action], [
-m4_pushdef([b4_at_dollar],     [yylloc])dnl
+b4_dollar_pushdef([yylval], [], [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
+/* User initialization code.  */
-    /* User initialization code.  */
+b4_user_initial_action
-    b4_user_initial_action
+b4_dollar_popdef])[]dnl
-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
 
   [  /* Initialize the stack.  */
     yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
@@ -539,7 +493,7 @@ m4_popdef([b4_at_dollar])])dnl
         if (yychar == yyempty_)
           {
 	    yycdebug ("Reading a token: ");
-            yychar = yylexer.yylex ();]
+	    yychar = yylex ();]
             b4_locations_if([[
 	    yylloc = new ]b4_location_type[(yylexer.getStartPos (),
 				            yylexer.getEndPos ());]])
@@ -547,9 +501,9 @@ m4_popdef([b4_at_dollar])])dnl
           }
 
         /* Convert token to internal form.  */
-        if (yychar <= Lexer.EOF)
+        if (yychar <= EOF)
           {
-            yychar = yytoken = Lexer.EOF;
+	    yychar = yytoken = EOF;
 	    yycdebug ("Now at end of input.\n");
           }
         else
@@ -636,10 +590,10 @@ m4_popdef([b4_at_dollar])])dnl
 	    /* If just tried and failed to reuse lookahead token after an
 	     error, discard it.  */
 
-        if (yychar <= Lexer.EOF)
+	    if (yychar <= EOF)
 	      {
 	      /* Return failure if at end of input.  */
-          if (yychar == Lexer.EOF)
+	      if (yychar == EOF)
 	        return false;
 	      }
 	    else
@@ -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[
+  /* YYDEFACT[S] -- default reduction number in state S.  Performed when
-  ]b4_integral_parser_table_define([token_number], [b4_toknum],
+     YYTABLE doesn't specify something else to do.  Zero means the
-     [TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
+     default is an error.  */
-     to YYLEX-NUM.])[
+  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],
+  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
-  [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
+  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)
@@ -848,13 +889,16 @@ m4_popdef([b4_at_dollar])])dnl
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       yy_symbol_print ("   $" + (yyi + 1) + " =",
-                       yystos_[yystack.stateAt(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
@@ -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
@@ -296,5 +295,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 ()
+    stack () : seq_ ()
-      : seq_ ()
     {
     }
 
-    stack (unsigned int n)
+    stack (unsigned int n) : seq_ (n)
-      : seq_ (n)
     {
     }
 
@@ -82,28 +81,16 @@ b4_copyright([Stack handling for Bison parsers in C++])[
     }
 
     inline
-    typename S::size_type
+    unsigned int
-    size () const
+    height () const
     {
       return seq_.size ();
     }
 
-    inline
+    inline const_iterator begin () const { return seq_.rbegin (); }
-    const_iterator
+    inline const_iterator end () const { return seq_.rend (); }
-    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/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
@@ -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)@})])
 
 
 ## -------------- ##
@@ -284,7 +282,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 +297,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,7 +342,7 @@ 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
@@ -575,27 +574,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
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-   by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  ]b4_undef_token_number[
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
 #define YYTRANSLATE(YYX)						\
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
-/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-   as returned by yylex, without out-of-bounds checking.  */
 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
 {
   ]b4_translate[
 };
 
 #if ]b4_api_PREFIX[DEBUG
-]b4_integral_parser_table_define([rline], [b4_rline],
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-     [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
+   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,25 +621,80 @@ static const char *const yytname[] =
 #endif
 
 # ifdef YYPRINT
-/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-   (internal) symbol number NUM (which must be that of a token).  */
+   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[
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
+{
+  ]b4_pgoto[
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF ]b4_table_ninf[
+static const ]b4_int_type_for([b4_table])[ yytable[] =
+{
+  ]b4_table[
+};
 
 #define yypact_value_is_default(yystate) \
   ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
 
-#define YYTABLE_NINF ]b4_table_ninf[
-
 #define yytable_value_is_error(yytable_value) \
   ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
 
-]b4_parser_tables_define[
+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[
+};
 
 #define yyerrok		(yyerrstatus = 0)
 #define yyclearin	(yychar = YYEMPTY)
@@ -677,9 +745,10 @@ while (YYID (0))
 #define YYTERROR	1
 #define YYERRCODE	256
 
-]b4_locations_if([[
 ]b4_yylloc_default_define[
 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
+]b4_locations_if([[
+
 
 /* YY_LOCATION_PRINT -- Print the location on the stream.
    This macro was not mandated originally: define only if we know
@@ -769,23 +838,21 @@ do {                                                            \
 `------------------------------------------------*/
 
 ]b4_c_function_def([yy_reduce_print], [static void],
-                   [[yytype_int16 *yyssp], [yyssp]],
 		   [[YYSTYPE *yyvsp], [yyvsp]],
     b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
 		   ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
 		   b4_parse_param]))[
 {
-  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);
   /* The symbols being reduced.  */
   for (yyi = 0; yyi < yynrhs; yyi++)
     {
       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr,
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
-                       yystos[yyssp[yyi + 1 - yynrhs]],
 		       &]b4_rhs_value(yynrhs, yyi + 1)[
 		       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
 		       b4_user_args[);
@@ -796,7 +863,7 @@ do {                                                            \
 # define YY_REDUCE_PRINT(Rule)		\
 do {					\
   if (yydebug)				\
-    yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
+    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
@@ -1503,17 +1570,16 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
   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
+b4_dollar_pushdef([m4_define([b4_dollar_dollar_used])yylval], [],
-m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
+                  [m4_define([b4_at_dollar_used])yylloc])dnl
 /* User initialization code.  */
 b4_user_initial_action
-m4_popdef([b4_dollar_dollar])dnl
+b4_dollar_popdef[]dnl
-m4_popdef([b4_at_dollar])])dnl
 m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
 ]])dnl
 m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
-]])[
+]])])dnl
-  goto yysetstate;
+[  goto yysetstate;
 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
@@ -1978,12 +2044,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,13 +1,14 @@
 /*.info*
 /*~
 /.dirstamp
+/Makefile
+/Makefile.in
 /bison.1
 /bison.aux
 /bison.cp
 /bison.cps
 /bison.dvi
 /bison.fn
-/bison.help
 /bison.html
 /bison.ky
 /bison.log

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
+nodist_noinst_SCRIPTS = bench.pl
-1+2*3
-EOF
-run 0 7
-
-cat >input <<EOF
-(1+2) * 3
-EOF
-run 0 9
-run 0 9 -p

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
+sub triangular_grammar ($$$)
-
-=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($$)
 {
-  my ($level, $message) = @_;
+  my ($base, $max, $directives) = @_;
-  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 $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;
@@ -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)>
+sub calc_grammar ($$$)
-
-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 ($$@)
 {
-  my ($base, $max, @directive) = @_;
+  my ($base, $max, $directives) = @_;
-  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 $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;
@@ -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`;
+  system ("$bison $base.y -o $base.c") == 0
-  chomp $language;
+    or die;
-
+  system ("$cc -o $base $base.c") == 0
-  my $compiler = $language eq 'C++' ? $cxx : $cc;
+    or die;
-
-  run "$bison $base.y -o $base.c";
-  run "$compiler -o $base $cflags $base.c";
 }
 
-######################################################################
+sub bench_grammar ($)
-
-=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 ($@)
 {
-  my ($grammar, @token) = @_;
+  my ($gram) = @_;
-  use Benchmark qw (:all :hireswallclock);
+  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.
+  while (my ($name, $directives) = each %test)
-  my $count = 1;
-  for my $d (@directive)
     {
-      $bench{$count} = $d;
+      print STDERR "$name\n";
-      printf " %2d. %s\n", $count, join (' ', split ("\n", $d));
+      my $generator = "$gram" . "_grammar";
-      $count++;
+      &$generator ($name, 200, $directives);
-    };
-
-  # For each bench, capture the size.
-  my %size;
-
-  while (my ($name, $directives) = each %bench)
-    {
-      generate_grammar ($grammar, $name, $directives);
-      # Compile the executable.
       compile ($name);
       $bench{$name} = "system ('./$name');";
-      chop($size{$name} = `wc -c <$name`);
     }
 
-  # Run the benches.
+  print "$gram:\n";
-  #
+  my $res = timethese (50, \%bench, 'nop');
-  # 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.
   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;
-    }
 }
 
-######################################################################
+print STDERR "Using $bison, $cc.\n";
-
+calc_input ('calc', 200);
-=item C<bench_push_parser ()>
+bench_grammar ('calc');
-
-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);
-}
 
 ### 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
+if BISON_CXX_WORKS
-1 2 3 * +
+SUBDIRS = calc++
-EOF
+endif
-run 0 7
 
-cat >input <<EOF
+dist_noinst_SCRIPTS = extexi
-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

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
 
-
+rm 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 ''

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.            -*- AWK -*-
-# Extract all examples from the manual source.
 
 # 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]
-
+BEGIN {
-# Look for @example environments preceded with lines such as:
+  if (!output_dir)
-#
+    output_dir = ".";
-#      @comment file calc.y
+  for (argc = 1; argc < ARGC; ++argc)
-# or
+    if (ARGV[argc] == "--")
-#      @comment file calc.y: 3
+      break;
-#
+  for (i = argc + 1; i < ARGC; ++i)
-# and output their content in that file (calc.y).  When numbers are
+    file_wanted[ARGV[i]] = 1;
-# provided, use them to decide the output order (block numbered 1 is
+  ARGC = argc;
-# 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.*//;
-  $_;
 }
 
-# Print messages only once.
+/^@node / {
-my %msg;
+  if (seq > 0)
-sub message($)
+    print "AT_CLEANUP";
-{
+
-  my ($msg) = @_;
+  split ($0, tmp, ",");
-  if (! $msg{$msg})
+  node = substr(tmp[1], 7);
-    {
+  seq = 0;
-      print STDERR "extexi: $msg\n";
-      $msg{$msg} = 1;
-    }
 }
 
-# basename => full file name for files we should extract.
+/^@comment file: / {
-my %file_wanted;
+  if (!file_wanted[$3])
-
+    message("ignoring " $3);
-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");
+      message("extracting " $3);
+      file = $3;
     }
-        }
+}
-      elsif ($file && /^\@(small)?example$/ .. /^\@end (small)?example$/)
+
+/^@example$/, /^@end example$/ {
+  if (!file)
+    next;
+
+  if ($0 ~ /^@example$/)
     {
-          if (/^\@(small)?example$/)
+      input = files_output[file] ? "\n" : "";
-            {
+
-              # Bison supports synclines, but not Flex.
+      # FNR is starting at 0 instead of 1, and
-              $input .= sprintf ("#line %s \"$in\"\n", $. + 1)
+      # #line report the line number of the *next* line.
-                if $file =~ /\.[chy]*$/;
+      # => + 2.
+      # Note that recent Bison support it, but not Flex.
+      if (file ~ /\.[chy]*$/)
+	input = "#line " (FNR + 1) " \"" FILENAME "\"\n";
       next;
     }
-          elsif (/^\@end (small)?example$/)
-            {
-              die "no contents: $file"
-                if $input eq "";
 
-              $file{$file}{$block} .= normalize($input);
+  if ($0 ~ /^@end example$/)
-              $file = $input = undef;
-              ++$block;
-            }
-          else
     {
-              $input .= $_;
+      if (input == "")
-            }
+	fatal("no contents: " file);
-        }
-    }
 
-  # Output the files.
+      input = normalize(input);
-  for my $file (keys %file)
-    {
       # No spurious end of line: use printf.
-      my $o = new IO::File(">$file")
+      if (files_output[file])
-        or die "$file: cannot create: $?";
+	# The parens around the output file seem to be required
-      print $o $file{$file}{$_}
+        # by awk on Mac OS X Tiger (darwin 8.4.6).
-        for sort keys %{$file{$file}};
+        printf ("%s", input) >> (output_dir "/" 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;
-    }
       else
+	printf ("%s", input) > (output_dir "/" file);
+      close (output_dir "/" file);
+      files_output[file] = 1;
+
+      file = input = "";
+      next;
+    }
+
+  input = input $0 "\n";
+}
+
+
+# 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)
     {
-      push @input, $arg;
+      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;
     }
 }
-process $_
-  foreach @input;
 
-
+function fatal(msg) {
-### Setup "GNU" style for perl-mode and cperl-mode.
+  message(msg);
-## Local Variables:
+  exit 1
-## 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:

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:

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,4 @@
 /xmemdup0.c
 /xmemdup0.h
 /sys_types.in.h
-/concat-filename.c
+/obstack_printf.c
-/concat-filename.h
-/filename.h
-/xconcat-filename.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/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).
 

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

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,4 @@
 /xalloc.m4
 /xsize.m4
 /xstrndup.m4
+/obstack-printf.m4

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
+   Copyright (C) 1984, 1986, 1989, 2000-2002, 2004-2007, 2009-2012 Free
-   Foundation, Inc.
+   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"

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. */
+  undef_assoc,
-  right_assoc,     /** %right */
+  right_assoc,
-  left_assoc,      /** %left */
+  left_assoc,
-  non_assoc,       /** %nonassoc */
+  non_assoc
-  precedence_assoc /** %precedence */
 } assoc;
 
 char const *assoc_to_string (assoc a);

src/closure.c

@@ -103,7 +103,6 @@ print_fderives (void)
 	{
 	  fprintf (stderr, "\t\t%3d ", r);
 	  rule_rhs_print (&rules[r], stderr);
-          fprintf (stderr, "\n");
 	}
     }
   fprintf (stderr, "\n\n");

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,
+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] != ' ')
+    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
+/** Wrap error_message() with varargs handling. */
-    warning.  */
+#define ERROR_MESSAGE(Loc, Prefix, Message)	\
-
+{						\
-static inline void
+  va_list args;					\
-complains (const location *loc, warnings flags, const char *message,
+  va_start (args, Message);			\
-           va_list args)
+  error_message (Loc, Prefix, Message, args);	\
-{
+  va_end (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);
-    }
 }
 
-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

@@ -25,51 +25,63 @@
 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.  */
+/** Informative messages, but we proceed.  Report iff
-void complain (warnings flags, char const *message, ...)
+    <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.  */
+/* Generate a message aligned by an indent.
-void complain_at (location loc, warnings flags, char const *message, ...)
+   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.  */
+/** An error, but we continue and die later.  */
-void complain_at_indent (location loc, warnings flags, unsigned *indent,
+
-                         char const *message, ...)
+void complain (char const *format, ...)
-  __attribute__ ((__format__ (__printf__, 4, 5)));
+  __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;

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,
+   Copyright (C) 1984, 1989, 1992, 2000-2007, 2009-2012 Free Software
-   Inc.
+   Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -73,7 +73,7 @@ log_resolution (rule *r, symbol_number token,
 	{
 	case shift_resolution:
 	case right_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  _("    Conflict between rule %d and token %s"
 			    " resolved as shift"),
 			  r->number,
@@ -82,7 +82,7 @@ log_resolution (rule *r, symbol_number token,
 
 	case reduce_resolution:
 	case left_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  _("    Conflict between rule %d and token %s"
 			    " resolved as reduce"),
 			  r->number,
@@ -90,7 +90,7 @@ log_resolution (rule *r, symbol_number token,
 	  break;
 
 	case nonassoc_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  _("    Conflict between rule %d and token %s"
 			    " resolved as an error"),
 			  r->number,
@@ -102,33 +102,33 @@ log_resolution (rule *r, symbol_number token,
       switch (resolution)
 	{
 	case shift_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  " (%s < %s)",
 			  r->prec->tag,
 			  symbols[token]->tag);
 	  break;
 
 	case reduce_resolution:
-          obstack_fgrow2 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  " (%s < %s)",
 			  symbols[token]->tag,
 			  r->prec->tag);
 	  break;
 
 	case left_resolution:
-          obstack_fgrow1 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  " (%%left %s)",
 			  symbols[token]->tag);
 	  break;
 
 	case right_resolution:
-          obstack_fgrow1 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  " (%%right %s)",
 			  symbols[token]->tag);
 	  break;
 
 	case nonassoc_resolution:
-          obstack_fgrow1 (&solved_conflicts_obstack,
+	  obstack_printf (&solved_conflicts_obstack,
 			  " (%%nonassoc %s)",
 			  symbols[token]->tag);
 	  break;
@@ -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;
@@ -286,20 +286,15 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs)
 	  }
 	else
 	  /* Matching precedence levels.
-             For non-defined associativity, keep both: unexpected
+	     For left association, keep only the reduction.
-             associativity conflict.
+	     For right association, keep only the shift.
-             For left associativity, keep only the reduction.
+	     For nonassociation, keep neither.  */
-             For right associativity, keep only the shift.
-             For nonassociativity, keep neither.  */
 
 	  switch (symbols[i]->assoc)
 	    {
-            case undef_assoc:
+	    default:
 	      abort ();
 
-            case precedence_assoc:
-              break;
-
 	    case right_assoc:
 	      log_resolution (redrule, i, right_resolution);
 	      flush_reduce (lookahead_tokens, i);
@@ -584,7 +579,7 @@ conflicts_print (void)
 
   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)
@@ -618,12 +613,12 @@ conflicts_print (void)
   if (expected_sr_conflicts != -1 || expected_rr_conflicts != -1)
     {
       if (! src_ok)
-        complain (complaint, ngettext ("expected %d shift/reduce conflict",
+	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",
+	complain (ngettext ("expected %d reduce/reduce conflict",
 			    "expected %d reduce/reduce conflicts",
 			    rrc_expected),
 		  rrc_expected);

src/derives.c

@@ -52,7 +52,6 @@ print_derives (void)
 	{
 	  fprintf (stderr, "\t\t%3d ", (*rp)->user_number);
 	  rule_rhs_print (*rp, stderr);
-          fprintf (stderr, "\n");
 	}
     }
 

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);
@@ -219,7 +207,7 @@ file_name_split (const char *file_name,
   *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,9 +215,10 @@ 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))
+	  && (strncmp (*ext - dottablen, ".tab", dottablen) == 0
+	      || strncmp (*ext - dottablen, "_tab", dottablen) == 0))
 	*tab = *ext - dottablen;
     }
 }
@@ -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,9 +357,9 @@ 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"),
+            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);

src/getargs.c

@@ -49,18 +49,24 @@
 #include "quote.h"
 #include "uniqstr.h"
 
+bool debug_flag;
 bool defines_flag;
 bool graph_flag;
 bool xml_flag;
+bool locations_flag;
 bool no_lines_flag;
 bool token_table_flag;
 bool yacc_flag;	/* for -y */
 
+bool error_verbose = false;
+
 bool nondeterministic_parser = false;
 bool glr_parser = false;
 
 int report_flag = report_none;
 int trace_flag = trace_none;
+int warnings_flag = warnings_conflicts_sr | warnings_conflicts_rr
+                    | warnings_other;
 
 static struct bison_language const valid_languages[] = {
   { "c", "c-skel.m4", ".c", ".h", true },
@@ -100,7 +106,7 @@ flags_argmatch (const char *option,
       args = strtok (args, ",");
       while (args)
 	{
-          int no = STRPREFIX_LIT ("no-", args) ? 3 : 0;
+	  int no = strncmp (args, "no-", 3) == 0 ? 3 : 0;
 	  int value = XARGMATCH (option, args + no, keys, values);
 	  if (value == 0)
 	    {
@@ -127,15 +133,15 @@ flags_argmatch (const char *option,
  *
  *  \param FlagName  the flag familly to update.
  *  \param Args      the effective sub arguments to decode.
- *  \param All       the "all" value.
  *
  *  \arg FlagName_args   the list of keys.
  *  \arg FlagName_types  the list of values.
+ *  \arg FlagName_all    the all value.
  *  \arg FlagName_flag   the flag to update.
  */
-#define FLAGS_ARGMATCH(FlagName, Args, All)                             \
+#define FLAGS_ARGMATCH(FlagName, Args)					\
   flags_argmatch ("--" #FlagName, FlagName ## _args, FlagName ## _types, \
-                  All, &FlagName ## _flag, Args)
+		  FlagName ## _all, &FlagName ## _flag, Args)
 
 
 /*----------------------.
@@ -239,18 +245,19 @@ static const char * const warnings_args[] =
 
 static const int warnings_types[] =
 {
-  Wnone,
+  warnings_none,
-  Wmidrule_values,
+  warnings_midrule_values,
-  Wyacc,
+  warnings_yacc,
-  Wconflicts_sr,
+  warnings_conflicts_sr,
-  Wconflicts_rr,
+  warnings_conflicts_rr,
-  Wother,
+  warnings_other,
-  Wall,
+  warnings_all,
-  Werror
+  warnings_error
 };
 
 ARGMATCH_VERIFY (warnings_args, warnings_types);
 
+
 /*-------------------------------------------.
 | Display the help message and exit STATUS.  |
 `-------------------------------------------*/
@@ -302,8 +309,7 @@ Parser:\n\
   -L, --language=LANGUAGE          specify the output programming language\n\
                                    (this is an experimental feature)\n\
   -S, --skeleton=FILE              specify the skeleton to use\n\
-  -t, --debug                      instrument the parser for tracing\n\
+  -t, --debug                      instrument the parser for debugging\n\
-                                   same as `-Dparse.trace'\n\
       --locations                  enable location support\n\
   -D, --define=NAME[=VALUE]        similar to '%define NAME \"VALUE\"'\n\
   -F, --force-define=NAME[=VALUE]  override '%define NAME \"VALUE\"'\n\
@@ -401,8 +407,7 @@ skeleton_arg (char const *arg, int prio, location loc)
       skeleton = arg;
     }
   else if (prio == skeleton_prio)
-    complain_at (loc, complaint,
+    complain_at (loc, _("multiple skeleton declarations are invalid"));
-                 _("multiple skeleton declarations are invalid"));
 }
 
 void
@@ -427,7 +432,7 @@ language_argmatch (char const *arg, int prio, location loc)
   else
     return;
 
-  complain_at (loc, complaint, msg, quotearg_colon (arg));
+  complain_at (loc, msg, quotearg_colon (arg));
 }
 
 /*----------------------.
@@ -558,7 +563,7 @@ getargs (int argc, char *argv[])
       case 'F': /* -FNAME[=VALUE]. */
         {
           char* name = optarg;
-          char* value = strchr (optarg, '=');
+          char* value = mbschr (optarg, '=');
           if (value)
             *value++ = 0;
           muscle_percent_define_insert (name, command_line_location (),
@@ -583,7 +588,7 @@ getargs (int argc, char *argv[])
 	break;
 
       case 'T':
-        FLAGS_ARGMATCH (trace, optarg, trace_all);
+	FLAGS_ARGMATCH (trace, optarg);
 	break;
 
       case 'V':
@@ -591,7 +596,7 @@ getargs (int argc, char *argv[])
 	exit (EXIT_SUCCESS);
 
       case 'W':
-        FLAGS_ARGMATCH (warnings, optarg, Wall);
+	FLAGS_ARGMATCH (warnings, optarg);
 	break;
 
       case 'b':
@@ -637,13 +642,11 @@ getargs (int argc, char *argv[])
 	break;
 
       case 'r':
-        FLAGS_ARGMATCH (report, optarg, report_all);
+	FLAGS_ARGMATCH (report, optarg);
 	break;
 
       case 't':
-        muscle_percent_define_insert ("parse.trace",
+	debug_flag = true;
-                                      command_line_location (), "",
-                                      MUSCLE_PERCENT_DEFINE_D);
 	break;
 
       case 'v':
@@ -664,8 +667,7 @@ getargs (int argc, char *argv[])
 	break;
 
       case LOCATIONS_OPTION:
-        muscle_percent_define_ensure ("locations",
+	locations_flag = true;
-                                      command_line_location (), true);
 	break;
 
       case PRINT_LOCALEDIR_OPTION:
@@ -673,7 +675,7 @@ getargs (int argc, char *argv[])
 	exit (EXIT_SUCCESS);
 
       case PRINT_DATADIR_OPTION:
-        printf ("%s\n", pkgdatadir ());
+	printf ("%s\n", compute_pkgdatadir ());
 	exit (EXIT_SUCCESS);
 
       case REPORT_FILE_OPTION:

src/getargs.h

@@ -34,13 +34,17 @@ extern int skeleton_prio;
 /* for -I */
 extern char const *include;
 
+extern bool debug_flag;			/* for -t */
 extern bool defines_flag;		/* for -d */
 extern bool graph_flag;			/* for -g */
 extern bool xml_flag;			/* for -x */
+extern bool locations_flag;
 extern bool no_lines_flag;		/* for -l */
 extern bool token_table_flag;		/* for -k */
 extern bool yacc_flag;			/* for -y */
 
+extern bool error_verbose;
+
 
 /* GLR_PARSER is true if the input file says to use the GLR
    (Generalized LR) parser, and to output some additional information
@@ -108,6 +112,24 @@ enum trace
 /** What debug items bison displays during its run.  */
 extern int trace_flag;
 
+/*-------------.
+| --warnings.  |
+`-------------*/
+
+enum warnings
+  {
+    warnings_none             = 0,      /**< Issue no warnings.  */
+    warnings_error            = 1 << 0, /**< Warnings are treated as errors.  */
+    warnings_midrule_values   = 1 << 1, /**< Unset or unused midrule values.  */
+    warnings_yacc             = 1 << 2, /**< POSIXME.  */
+    warnings_conflicts_sr     = 1 << 3, /**< S/R conflicts.  */
+    warnings_conflicts_rr     = 1 << 4, /**< R/R conflicts.  */
+    warnings_other            = 1 << 5, /**< All other warnings.  */
+    warnings_all              = ~warnings_error /**< All above warnings.  */
+  };
+/** What warnings are issued.  */
+extern int warnings_flag;
+
 
 /** Process the command line arguments.
  *

src/gram.c

@@ -87,10 +87,10 @@ rule_lhs_print_xml (rule *r, FILE *out, int level)
   xml_printf (out, level, "<lhs>%s</lhs>", r->lhs->tag);
 }
 
-size_t
+int
 rule_rhs_length (rule *r)
 {
-  size_t res = 0;
+  int res = 0;
   item_number *rhsp;
   for (rhsp = r->rhs; *rhsp >= 0; ++rhsp)
     ++res;
@@ -105,10 +105,11 @@ rule_rhs_print (rule *r, FILE *out)
       item_number *rp;
       for (rp = r->rhs; *rp >= 0; rp++)
 	fprintf (out, " %s", symbols[*rp]->tag);
+      fputc ('\n', out);
     }
   else
     {
-      fprintf (out, " /* %s */", _("empty"));
+      fprintf (out, " /* %s */\n", _("empty"));
     }
 }
 
@@ -132,7 +133,7 @@ rule_rhs_print_xml (rule *r, FILE *out, int level)
     }
 }
 
-static void
+void
 rule_print (rule *r, FILE *out)
 {
   fprintf (out, "%s:", r->lhs->tag);
@@ -188,7 +189,6 @@ grammar_rules_partial_print (FILE *out, const char *title,
       first = false;
       rule_lhs_print (&rules[r], previous_lhs, out);
       rule_rhs_print (&rules[r], out);
-      fprintf (out, "\n");
       previous_lhs = rules[r].lhs;
     }
   if (!first)
@@ -296,7 +296,6 @@ grammar_dump (FILE *out, const char *title)
       {
 	fprintf (out, "%-5d  ", r);
 	rule_print (&rules[r], out);
-        fprintf (out, "\n");
       }
   }
   fprintf (out, "\n\n");
@@ -305,17 +304,15 @@ grammar_dump (FILE *out, const char *title)
 void
 grammar_rules_useless_report (const char *message)
 {
-  warnings w = Wother;
-  if (warnings_flag & w)
-    {
   rule_number r;
   for (r = 0; r < nrules ; ++r)
     if (!rules[r].useful)
       {
-            complain_at (rules[r].location, w | silent, "%s: ", message);
+        warn_at (rules[r].location, "%s: ", message);
+        if (warnings_flag & warnings_other)
+          {
             rule_print (&rules[r], stderr);
-            warnings_print_categories (w);
+            fflush (stderr);
-            fprintf (stderr, "\n");
           }
       }
 }

src/gram.h

@@ -194,7 +194,6 @@ typedef struct
 
   location location;
   bool useful;
-  bool is_predicate;
 
   const char *action;
   location action_location;
@@ -224,11 +223,14 @@ void rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out);
 void rule_lhs_print_xml (rule *r, FILE *out, int level);
 
 /* Return the length of the RHS.  */
-size_t rule_rhs_length (rule *r);
+int rule_rhs_length (rule *r);
 
 /* Print this rule's RHS on OUT.  */
 void rule_rhs_print (rule *r, FILE *out);
 
+/* Print this rule on OUT.  */
+void rule_print (rule *r, FILE *out);
+
 
 
 

src/ielr.c

@@ -1095,11 +1095,11 @@ ielr (void)
   /* Examine user options.  */
   {
     char *type = muscle_percent_define_get ("lr.type");
-    if (STREQ (type, "lalr"))
+    if (0 == strcmp (type, "lalr"))
       lr_type = LR_TYPE__LALR;
-    else if (STREQ (type, "ielr"))
+    else if (0 == strcmp (type, "ielr"))
       lr_type = LR_TYPE__IELR;
-    else if (STREQ (type, "canonical-lr"))
+    else if (0 == strcmp (type, "canonical-lr"))
       lr_type = LR_TYPE__CANONICAL_LR;
     else
       aver (false);

src/lalr.c

@@ -372,7 +372,8 @@ initialize_LA (void)
   {
     char *default_reductions =
       muscle_percent_define_get ("lr.default-reductions");
-    default_reduction_only_for_accept = STREQ (default_reductions, "accepting");
+    default_reduction_only_for_accept =
+      0 == strcmp (default_reductions, "accepting");
     free (default_reductions);
   }
 

src/local.mk

@@ -1,123 +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/>.
-
-LDADD = lib/libbison.a $(LIBINTL)
-
-bin_PROGRAMS = src/bison
-# Prettify Automake-computed names of compiled objects.
-src_bison_SHORTNAME = bison
-
-src_bison_CFLAGS = $(AM_CFLAGS) $(WERROR_CFLAGS)
-src_bison_SOURCES =                             \
-  src/AnnotationList.c                          \
-  src/AnnotationList.h                          \
-  src/InadequacyList.c                          \
-  src/InadequacyList.h                          \
-  src/LR0.c                                     \
-  src/LR0.h                                     \
-  src/Sbitset.c                                 \
-  src/Sbitset.h                                 \
-  src/assoc.c                                   \
-  src/assoc.h                                   \
-  src/closure.c                                 \
-  src/closure.h                                 \
-  src/complain.c                                \
-  src/complain.h                                \
-  src/conflicts.c                               \
-  src/conflicts.h                               \
-  src/derives.c                                 \
-  src/derives.h                                 \
-  src/files.c                                   \
-  src/files.h                                   \
-  src/flex-scanner.h                            \
-  src/getargs.c                                 \
-  src/getargs.h                                 \
-  src/gram.c                                    \
-  src/gram.h                                    \
-  src/graphviz.c                                \
-  src/graphviz.h                                \
-  src/lalr.c                                    \
-  src/lalr.h                                    \
-  src/ielr.c                                    \
-  src/ielr.h                                    \
-  src/location.c                                \
-  src/location.h                                \
-  src/main.c                                    \
-  src/muscle-tab.c                              \
-  src/muscle-tab.h                              \
-  src/named-ref.c                               \
-  src/named-ref.h                               \
-  src/nullable.c                                \
-  src/nullable.h                                \
-  src/output.c                                  \
-  src/output.h                                  \
-  src/parse-gram.y                              \
-  src/print-xml.c                               \
-  src/print-xml.h                               \
-  src/print.c                                   \
-  src/print.h                                   \
-  src/print_graph.c                             \
-  src/print_graph.h                             \
-  src/reader.c                                  \
-  src/reader.h                                  \
-  src/reduce.c                                  \
-  src/reduce.h                                  \
-  src/relation.c                                \
-  src/relation.h                                \
-  src/scan-code-c.c                             \
-  src/scan-code.h                               \
-  src/scan-gram-c.c                             \
-  src/scan-gram.h                               \
-  src/scan-skel-c.c                             \
-  src/scan-skel.h                               \
-  src/state.c                                   \
-  src/state.h                                   \
-  src/symlist.c                                 \
-  src/symlist.h                                 \
-  src/symtab.c                                  \
-  src/symtab.h                                  \
-  src/system.h                                  \
-  src/tables.c                                  \
-  src/tables.h                                  \
-  src/uniqstr.c                                 \
-  src/uniqstr.h
-
-EXTRA_src_bison_SOURCES =                       \
-  src/scan-code.l                               \
-  src/scan-gram.l                               \
-  src/scan-skel.l
-
-BUILT_SOURCES +=                                \
-  src/parse-gram.c                              \
-  src/parse-gram.h                              \
-  src/scan-code.c                               \
-  src/scan-gram.c                               \
-  src/scan-skel.c
-
-
-## ------ ##
-## yacc.  ##
-## ------ ##
-
-bin_SCRIPTS = $(YACC_SCRIPT)
-EXTRA_SCRIPTS = src/yacc
-MOSTLYCLEANFILES += src/yacc
-
-src/yacc:
-	$(AM_V_GEN)rm -f $@ $@.tmp
-	$(AM_V_at)echo '#! /bin/sh' >$@.tmp
-	$(AM_V_at)echo "exec '$(bindir)/bison' -y "'"$$@"' >>$@.tmp
-	$(AM_V_at)chmod a+x $@.tmp
-	$(AM_V_at)mv $@.tmp $@

src/location.c

@@ -90,9 +90,9 @@ location_compute (location *loc, boundary *cur, char const *token, size_t size)
   loc->end = *cur;
 
   if (line == INT_MAX && loc->start.line != INT_MAX)
-    complain_at (*loc, Wother, _("line number overflow"));
+    warn_at (*loc, _("line number overflow"));
   if (column == INT_MAX && loc->start.column != INT_MAX)
-    complain_at (*loc, Wother, _("column number overflow"));
+    warn_at (*loc, _("column number overflow"));
 }
 
 
@@ -143,11 +143,11 @@ boundary_set_from_string (boundary *bound, char *loc_str)
 {
   /* Must search in reverse since the file name field may
    * contain `.' or `:'.  */
-  char *delim = strrchr (loc_str, '.');
+  char *delim = mbsrchr (loc_str, '.');
   aver (delim);
   *delim = '\0';
   bound->column = atoi (delim+1);
-  delim = strrchr (loc_str, ':');
+  delim = mbsrchr (loc_str, ':');
   aver (delim);
   *delim = '\0';
   bound->line = atoi (delim+1);

src/main.c

@@ -66,7 +66,7 @@ main (int argc, char *argv[])
 
   {
     char const *cp = getenv ("LC_CTYPE");
-    if (cp && STREQ (cp, "C"))
+    if (cp && !strcmp (cp, "C"))
       set_custom_quoting (&quote_quoting_options, "'", "'");
     else
       set_quoting_style (&quote_quoting_options, locale_quoting_style);
@@ -142,7 +142,8 @@ main (int argc, char *argv[])
   tables_generate ();
   timevar_pop (TV_ACTIONS);
 
-  grammar_rules_useless_report (_("rule useless in parser due to conflicts"));
+  grammar_rules_useless_report
+    (_("rule useless in parser due to conflicts"));
 
   /* Output file names. */
   compute_output_file_names ();

src/muscle-tab.c

@@ -50,7 +50,7 @@ hash_compare_muscles (void const *x, void const *y)
 {
   muscle_entry const *m1 = x;
   muscle_entry const *m2 = y;
-  return STREQ (m1->key, m2->key);
+  return strcmp (m1->key, m2->key) == 0;
 }
 
 static size_t
@@ -177,10 +177,10 @@ static void
 muscle_syncline_grow (char const *key, location loc)
 {
   char *extension = NULL;
-  obstack_fgrow1 (&muscle_obstack, "]b4_syncline(%d, [[", loc.start.line);
+  obstack_printf (&muscle_obstack, "]b4_syncline(%d, ", loc.start.line);
-  MUSCLE_OBSTACK_SGROW (&muscle_obstack,
+  obstack_quote (&muscle_obstack,
                  quotearg_style (c_quoting_style, loc.start.file));
-  obstack_sgrow (&muscle_obstack, "]])[");
+  obstack_sgrow (&muscle_obstack, ")[");
   obstack_1grow (&muscle_obstack, 0);
   extension = obstack_finish (&muscle_obstack);
   muscle_grow (key, extension, "");
@@ -205,11 +205,11 @@ void muscle_pair_list_grow (const char *muscle,
 			    const char *a1, const char *a2)
 {
   char *pair;
-  obstack_sgrow (&muscle_obstack, "[[[");
+  obstack_sgrow (&muscle_obstack, "[");
-  MUSCLE_OBSTACK_SGROW (&muscle_obstack, a1);
+  obstack_quote (&muscle_obstack, a1);
-  obstack_sgrow (&muscle_obstack, "]], [[");
+  obstack_sgrow (&muscle_obstack, ", ");
-  MUSCLE_OBSTACK_SGROW (&muscle_obstack, a2);
+  obstack_quote (&muscle_obstack, a2);
-  obstack_sgrow (&muscle_obstack, "]]]");
+  obstack_sgrow (&muscle_obstack, "]");
   obstack_1grow (&muscle_obstack, 0);
   pair = obstack_finish (&muscle_obstack);
   muscle_grow (muscle, pair, ",\n");
@@ -259,32 +259,40 @@ muscle_find (char const *key)
 }
 
 
-void
+/* In the format `file_name:line.column', append BOUND to MUSCLE.  Use
+   digraphs for special characters in the file name.  */
+
+static void
 muscle_boundary_grow (char const *key, boundary bound)
 {
   char *extension;
-  MUSCLE_OBSTACK_SGROW (&muscle_obstack, bound.file);
+  obstack_sgrow  (&muscle_obstack, "[[");
+  obstack_escape (&muscle_obstack, bound.file);
   obstack_1grow  (&muscle_obstack, ':');
-  obstack_fgrow1 (&muscle_obstack, "%d", bound.line);
+  obstack_printf (&muscle_obstack, "%d", bound.line);
   obstack_1grow  (&muscle_obstack, '.');
-  obstack_fgrow1 (&muscle_obstack, "%d", bound.column);
+  obstack_printf (&muscle_obstack, "%d", bound.column);
+  obstack_sgrow  (&muscle_obstack, "]]");
   obstack_1grow  (&muscle_obstack, '\0');
   extension = obstack_finish (&muscle_obstack);
   muscle_grow (key, extension, "");
   obstack_free (&muscle_obstack, extension);
 }
 
-void
+
+/* In the format `[[file_name:line.column]], [[file_name:line.column]]',
+   append LOC to MUSCLE.  Use digraphs for special characters in each
+   file name.  */
+
+static void
 muscle_location_grow (char const *key, location loc)
 {
-  muscle_grow (key, "[[", "");
   muscle_boundary_grow (key, loc.start);
-  muscle_grow (key, "]], [[", "");
+  muscle_grow (key, "", ", ");
   muscle_boundary_grow (key, loc.end);
-  muscle_grow (key, "]]", "");
 }
 
-#define MUSCLE_COMMON_DECODE(Value)                                           \
+#define COMMON_DECODE(Value)                                    \
   case '$':                                                     \
     aver (*++(Value) == ']');                                   \
     aver (*++(Value) == '[');                                   \
@@ -303,9 +311,9 @@ muscle_location_grow (char const *key, location loc)
     obstack_1grow (&muscle_obstack, *(Value));                  \
     break;
 
-/* Reverse of MUSCLE_OBSTACK_SGROW.  */
+/* Reverse of obstack_escape.  */
 static char *
-muscle_string_decode (char const *key)
+string_decode (char const *key)
 {
   char const *value;
   char *value_decoded;
@@ -317,7 +325,7 @@ muscle_string_decode (char const *key)
   do {
     switch (*value)
       {
-        MUSCLE_COMMON_DECODE (value)
+        COMMON_DECODE (value)
         case '[':
         case ']':
           aver (false);
@@ -332,7 +340,7 @@ muscle_string_decode (char const *key)
 
 /* Reverse of muscle_location_grow.  */
 static location
-muscle_location_decode (char const *key)
+location_decode (char const *key)
 {
   location loc;
   char const *value = muscle_find_const (key);
@@ -342,7 +350,7 @@ muscle_location_decode (char const *key)
   while (*++value)
     switch (*value)
       {
-        MUSCLE_COMMON_DECODE (value)
+        COMMON_DECODE (value)
         case '[':
           aver (false);
           break;
@@ -388,42 +396,25 @@ muscle_user_name_list_grow (char const *key, char const *user_name,
   muscle_grow (key, "]]", "");
 }
 
-/** If the \a variable name is obsolete, return the name to use,
- * otherwise \a variable. */
-static
-char const *
-muscle_percent_variable_update (char const *variable)
-{
-  typedef struct
-  {
-    const char *obsolete;
-    const char *updated;
-  } conversion_type;
-  const conversion_type conversion[] =
-    {
-      { "api.push_pull", "api.push-pull", },
-      { "lr.keep_unreachable_states", "lr.keep-unreachable-states", },
-      { "namespace", "api.namespace", },
-    };
-  int i;
-  for (i = 0; i < sizeof conversion / sizeof *conversion; ++i)
-    if (STREQ (conversion[i].obsolete, variable))
-      return conversion[i].updated;
-  return variable;
-}
-
 void
 muscle_percent_define_insert (char const *variable, location variable_loc,
                               char const *value,
                               muscle_percent_define_how how)
 {
+  char *variable_tr = NULL;
   char const *name;
   char const *loc_name;
   char const *syncline_name;
   char const *how_name;
 
   /* Permit certain names with underscores for backward compatibility.  */
-  variable = muscle_percent_variable_update (variable);
+  if (0 == strcmp (variable, "api.push_pull")
+      || 0 == strcmp (variable, "lr.keep_unreachable_states"))
+    {
+      variable_tr = strdup (variable);
+      tr (variable_tr, '_', '-');
+      variable = variable_tr;
+    }
 
   name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
   loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")");
@@ -438,11 +429,14 @@ muscle_percent_define_insert (char const *variable, location variable_loc,
       muscle_percent_define_how how_old =
         atoi (muscle_find_const (how_name));
       if (how_old == MUSCLE_PERCENT_DEFINE_F)
+        {
+          free (variable_tr);
           return;
-      complain_at (variable_loc, complaint, _("%%define variable %s redefined"),
+        }
+      complain_at (variable_loc, _("%%define variable %s redefined"),
                    quote (variable));
-      location loc = muscle_percent_define_get_loc (variable);
+      complain_at (muscle_percent_define_get_loc (variable),
-      complain_at (loc, complaint, _("previous definition"));
+                   _("previous definition"));
     }
 
   MUSCLE_INSERT_STRING (name, value);
@@ -453,30 +447,8 @@ muscle_percent_define_insert (char const *variable, location variable_loc,
   muscle_user_name_list_grow ("percent_define_user_variables", variable,
                               variable_loc);
   MUSCLE_INSERT_INT (how_name, how);
-}
 
-/* This is used for backward compatibility, e.g., "%define api.pure"
+  free (variable_tr);
-   supersedes "%pure-parser".  */
-void
-muscle_percent_define_ensure (char const *variable, location loc,
-                              bool value)
-{
-  char const *val = value ? "" : "false";
-  char const *name;
-  name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
-
-  /* %pure-parser is deprecated in favor of `%define api.pure', so use
-     `%define api.pure' in a backward-compatible manner here.  First,
-     don't complain if %pure-parser is specified multiple times.  */
-  if (!muscle_find_const (name))
-    muscle_percent_define_insert (variable, loc, val,
-                                  MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
-  /* In all cases, use api.pure now so that the backend doesn't complain if
-     the skeleton ignores api.pure, but do warn now if there's a previous
-     conflicting definition from an actual %define.  */
-  if (muscle_percent_define_flag_if (variable) != value)
-    muscle_percent_define_insert (variable, loc, val,
-                                  MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
 }
 
 char *
@@ -491,7 +463,7 @@ muscle_percent_define_get (char const *variable)
                                variable, ")");
 
   muscle_insert (usage_name, "");
-  value = muscle_string_decode (name);
+  value = string_decode (name);
   if (!value)
     value = xstrdup ("");
   return value;
@@ -503,9 +475,9 @@ muscle_percent_define_get_loc (char const *variable)
   char const *loc_name;
   loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")");
   if (!muscle_find_const (loc_name))
-    complain (fatal, _("%s: undefined %%define variable %s"),
+    fatal(_("%s: undefined %%define variable %s"),
           "muscle_percent_define_get_loc", quote (variable));
-  return muscle_location_decode (loc_name);
+  return location_decode (loc_name);
 }
 
 char const *
@@ -517,7 +489,7 @@ muscle_percent_define_get_syncline (char const *variable)
     UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
   syncline = muscle_find_const (syncline_name);
   if (!syncline)
-    complain (fatal, _("%s: undefined %%define variable %s"),
+    fatal(_("%s: undefined %%define variable %s"),
           "muscle_percent_define_get_syncline", quote (variable));
   return syncline;
 }
@@ -555,22 +527,21 @@ muscle_percent_define_flag_if (char const *variable)
   if (muscle_percent_define_ifdef (variable))
     {
       char *value = muscle_percent_define_get (variable);
-      if (value[0] == '\0' || STREQ (value, "true"))
+      if (value[0] == '\0' || 0 == strcmp (value, "true"))
         result = true;
-      else if (STREQ (value, "false"))
+      else if (0 == strcmp (value, "false"))
         result = false;
       else if (!muscle_find_const (invalid_boolean_name))
         {
           muscle_insert (invalid_boolean_name, "");
-          location loc = muscle_percent_define_get_loc (variable);
+          complain_at(muscle_percent_define_get_loc (variable),
-          complain_at (loc, complaint,
                       _("invalid value for %%define Boolean variable %s"),
                       quote (variable));
         }
       free (value);
     }
   else
-    complain (fatal, _("%s: undefined %%define variable %s"),
+    fatal(_("%s: undefined %%define variable %s"),
           "muscle_percent_define_flag", quote (variable));
 
   return result;
@@ -610,23 +581,22 @@ muscle_percent_define_check_values (char const * const *values)
 
       name = UNIQSTR_CONCAT ("percent_define(", *variablep, ")");
 
-      value = muscle_string_decode (name);
+      value = string_decode (name);
       if (value)
         {
           for (++values; *values; ++values)
             {
-              if (STREQ (value, *values))
+              if (0 == strcmp (value, *values))
                 break;
             }
           if (!*values)
             {
               location loc = muscle_percent_define_get_loc (*variablep);
-              complain_at (loc, complaint,
+              complain_at(loc,
                           _("invalid value for %%define variable %s: %s"),
                           quote (*variablep), quote_n (1, value));
               for (values = variablep + 1; *values; ++values)
-                complain_at (loc, complaint, _("accepted value: %s"),
+                complain_at (loc, _("accepted value: %s"), quote (*values));
-                             quote (*values));
             }
           else
             {
@@ -636,7 +606,7 @@ muscle_percent_define_check_values (char const * const *values)
           free (value);
         }
       else
-        complain (fatal, _("%s: undefined %%define variable %s"),
+        fatal (_("%s: undefined %%define variable %s"),
                "muscle_percent_define_check_values", quote (*variablep));
     }
 }

src/muscle-tab.h

@@ -1,6 +1,7 @@
 /* Muscle table manager for Bison,
 
-   Copyright (C) 2001-2003, 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2003, 2006-2007, 2009-2012 Free Software
+   Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -35,63 +36,46 @@ void muscle_free (void);
 extern struct obstack muscle_obstack;
 
 #define MUSCLE_INSERT_BOOL(Key, Value)                          \
-do {                                                            \
+  do {                                                          \
-  int v__ = Value;                                              \
+    int v = Value;                                              \
-  MUSCLE_INSERT_INT (Key, v__);                                 \
+    MUSCLE_INSERT_INT (Key, v);                                 \
-} while(0)
+  } while (0)
 
 #define MUSCLE_INSERT_INT(Key, Value)                           \
-do {                                                            \
+  do {                                                          \
-  obstack_fgrow1 (&muscle_obstack, "%d", Value);                \
+    obstack_printf (&muscle_obstack, "%d", Value);              \
     obstack_1grow (&muscle_obstack, 0);                         \
     muscle_insert (Key, obstack_finish (&muscle_obstack));      \
-} while(0)
+  } while (0)
 
 #define MUSCLE_INSERT_LONG_INT(Key, Value)                      \
-do {                                                            \
+  do {                                                          \
-  obstack_fgrow1 (&muscle_obstack, "%ld", Value);               \
+    obstack_printf (&muscle_obstack, "%ld", Value);             \
     obstack_1grow (&muscle_obstack, 0);                         \
     muscle_insert (Key, obstack_finish (&muscle_obstack));      \
-} while(0)
+  } while (0)
 
-/* Key -> Value, but don't apply escaping to Value. */
 #define MUSCLE_INSERT_STRING_RAW(Key, Value)                    \
-do {                                                            \
+  do {                                                          \
     obstack_sgrow (&muscle_obstack, Value);                     \
     obstack_1grow (&muscle_obstack, 0);                         \
     muscle_insert (Key, obstack_finish (&muscle_obstack));      \
-} while(0)
+  } while (0)
 
-/* Key -> Value, applying M4 escaping to Value. */
 #define MUSCLE_INSERT_STRING(Key, Value)                        \
-do {                                                            \
+  do {                                                          \
-  MUSCLE_OBSTACK_SGROW (&muscle_obstack, Value);                \
+    obstack_escape (&muscle_obstack, Value);                    \
     obstack_1grow (&muscle_obstack, 0);                         \
     muscle_insert (Key, obstack_finish (&muscle_obstack));      \
-} while(0)
+  } while (0)
-
-#define MUSCLE_OBSTACK_SGROW(Obstack, Value)            \
-do {                                                    \
-  char const *p__;                                      \
-  for (p__ = Value; *p__; p__++)                        \
-    switch (*p__)                                       \
-      {                                                 \
-      case '$': obstack_sgrow (Obstack, "$]["); break;  \
-      case '@': obstack_sgrow (Obstack, "@@" ); break;  \
-      case '[': obstack_sgrow (Obstack, "@{" ); break;  \
-      case ']': obstack_sgrow (Obstack, "@}" ); break;  \
-      default: obstack_1grow (Obstack, *p__); break;    \
-      }                                                 \
-} while(0)
 
 #define MUSCLE_INSERT_C_STRING(Key, Value)                      \
-do {                                                            \
+  do {                                                          \
-  MUSCLE_OBSTACK_SGROW (&muscle_obstack,                        \
+    obstack_escape (&muscle_obstack,                            \
-                        quotearg_style (c_quoting_style,        \
+                    quotearg_style (c_quoting_style, Value));   \
-                                        Value));                \
     obstack_1grow (&muscle_obstack, 0);                         \
     muscle_insert (Key, obstack_finish (&muscle_obstack));      \
-} while(0)
+  } while (0)
 
 /* Append VALUE to the current value of KEY.  If KEY did not already
    exist, create it.  Use MUSCLE_OBSTACK.  De-allocate the previously
@@ -113,14 +97,6 @@ void muscle_code_grow (const char *key, const char *value, location loc);
 void muscle_pair_list_grow (const char *muscle,
                             const char *a1, const char *a2);
 
-/* In the format `[[file_name:line.column]], [[file_name:line.column]]', append
-   LOC to MUSCLE.  Use digraphs for special characters in each file name.  */
-void muscle_location_grow (char const *key, location loc);
-
-/* In the format `file_name:line.column', append BOUND to MUSCLE.  Use digraphs
-   for special characters in the file name.  */
-void muscle_boundary_grow (char const *key, boundary bound);
-
 /* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for
    use with b4_check_user_names in ../data/bison.m4.  USER_NAME is not escaped
    with digraphs, so it must not contain `[' or `]'.  */
@@ -147,13 +123,6 @@ void muscle_percent_define_insert (char const *variable, location variable_loc,
                                    char const *value,
                                    muscle_percent_define_how how);
 
-/* Make sure that VARIABLE is set to the boolean VALUE.  Warn on mismatches
-   only, but accept repeated declaration.  Used for backward compatibility
-   between old directives such as %pure-parser, and the recommended use of
-   variables (%define api.pure).   */
-void muscle_percent_define_ensure (char const *variable, location variable_loc,
-                                   bool value);
-
 /* Mimic b4_percent_define_get in ../data/bison.m4 exactly.  That is, if the
    %define variable VARIABLE is defined, return its value.  Otherwise, return
    the empty string.  Also, record Bison's usage of VARIABLE by defining

src/output.c

@@ -21,9 +21,8 @@
 #include <config.h>
 #include "system.h"
 
-#include <concat-filename.h>
 #include <configmake.h>
-#include <filename.h>
+#include <error.h>
 #include <get-errno.h>
 #include <quotearg.h>
 #include <spawn-pipe.h>
@@ -42,6 +41,8 @@
 #include "symtab.h"
 #include "tables.h"
 
+# define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
+
 static struct obstack format_obstack;
 
 
@@ -69,7 +70,7 @@ Name (char const *name,                                                 \
   int i;								\
   int j = 1;								\
 									\
-  obstack_fgrow1 (&format_obstack, "%6d", first);                       \
+  obstack_printf (&format_obstack, "%6d", first);			\
   for (i = begin; i < end; ++i)						\
     {									\
       obstack_1grow (&format_obstack, ',');				\
@@ -80,7 +81,7 @@ Name (char const *name,                                                 \
 	}								\
       else								\
 	++j;								\
-      obstack_fgrow1 (&format_obstack, "%6d", table_data[i]);           \
+      obstack_printf (&format_obstack, "%6d", table_data[i]);		\
       if (table_data[i] < min)						\
 	min = table_data[i];						\
       if (max < table_data[i])						\
@@ -92,10 +93,10 @@ Name (char const *name,                                                 \
   lmin = min;								\
   lmax = max;								\
   /* Build `NAME_min' and `NAME_max' in the obstack. */			\
-  obstack_fgrow1 (&format_obstack, "%s_min", name);                     \
+  obstack_printf (&format_obstack, "%s_min", name);			\
   obstack_1grow (&format_obstack, 0);					\
   MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmin);	\
-  obstack_fgrow1 (&format_obstack, "%s_max", name);                     \
+  obstack_printf (&format_obstack, "%s_max", name);			\
   obstack_1grow (&format_obstack, 0);					\
   MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmax);	\
 }
@@ -105,32 +106,43 @@ GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_number)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number)
 
 
-/*--------------------------------------------------------------------.
+/*----------------------------------------------------------------.
-| Print to OUT a representation of STRING escaped both for C and M4.  |
+| Print to OUT a representation of CP quoted and escaped for M4.  |
-`--------------------------------------------------------------------*/
+`----------------------------------------------------------------*/
 
 static void
-escaped_output (FILE *out, char const *string)
+quoted_output (FILE *out, char const *cp)
 {
-  char const *p;
   fprintf (out, "[[");
 
-  for (p = quotearg_style (c_quoting_style, string); *p; p++)
+  for (; *cp; cp++)
-    switch (*p)
+    switch (*cp)
       {
       case '$': fputs ("$][", out); break;
       case '@': fputs ("@@",  out); break;
       case '[': fputs ("@{",  out); break;
       case ']': fputs ("@}",  out); break;
-      default: fputc (*p, out); break;
+      default:  fputc (*cp,   out); break;
       }
 
   fprintf (out, "]]");
 }
 
+/*----------------------------------------------------------------.
+| Print to OUT a representation of STRING quoted and escaped both |
+| for C and M4.                                                   |
+`----------------------------------------------------------------*/
+
+static void
+string_output (FILE *out, char const *string)
+{
+  quoted_output (out, quotearg_style (c_quoting_style, string));
+}
+
 
 /*------------------------------------------------------------------.
 | Prepare the muscles related to the symbols: translate, tname, and |
@@ -142,7 +154,6 @@ prepare_symbols (void)
 {
   MUSCLE_INSERT_INT ("tokens_number", ntokens);
   MUSCLE_INSERT_INT ("nterms_number", nvars);
-  MUSCLE_INSERT_INT ("symbols_number", nsyms);
   MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
   MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
 
@@ -174,7 +185,7 @@ prepare_symbols (void)
 
 	if (i)
 	  obstack_1grow (&format_obstack, ' ');
-        MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
+	obstack_escape (&format_obstack, cp);
         free (cp);
 	obstack_1grow (&format_obstack, ',');
 	j += width;
@@ -200,54 +211,65 @@ prepare_symbols (void)
 }
 
 
-/*----------------------------------------------------------------.
+/*-------------------------------------------------------------.
-| Prepare the muscles related to the rules: r1, r2, rline, dprec, |
+| Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
-| merger, immediate.                                              |
+| rline, dprec, merger.                                        |
-`----------------------------------------------------------------*/
+`-------------------------------------------------------------*/
 
 static void
 prepare_rules (void)
 {
+  rule_number r;
+  unsigned int i = 0;
+  item_number *rhs = xnmalloc (nritems, sizeof *rhs);
+  unsigned int *prhs = xnmalloc (nrules, sizeof *prhs);
   unsigned int *rline = xnmalloc (nrules, sizeof *rline);
   symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
   unsigned int *r2 = xnmalloc (nrules, sizeof *r2);
   int *dprec = xnmalloc (nrules, sizeof *dprec);
   int *merger = xnmalloc (nrules, sizeof *merger);
-  int *immediate = xnmalloc (nrules, sizeof *immediate);
 
-  rule_number r;
   for (r = 0; r < nrules; ++r)
     {
+      item_number *rhsp = NULL;
+      /* Index of rule R in RHS. */
+      prhs[r] = i;
+      /* RHS of the rule R. */
+      for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
+	rhs[i++] = *rhsp;
       /* LHS of the rule R. */
       r1[r] = rules[r].lhs->number;
       /* Length of rule R's RHS. */
-      r2[r] = rule_rhs_length(&rules[r]);
+      r2[r] = i - prhs[r];
+      /* Separator in RHS. */
+      rhs[i++] = -1;
       /* Line where rule was defined. */
       rline[r] = rules[r].location.start.line;
       /* Dynamic precedence (GLR).  */
       dprec[r] = rules[r].dprec;
       /* Merger-function index (GLR).  */
       merger[r] = rules[r].merger;
-      /* Immediate reduction flags (GLR).  */
-      immediate[r] = rules[r].is_predicate;
     }
+  aver (i == nritems);
 
+  muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
+  muscle_insert_unsigned_int_table ("prhs", prhs, 0, 0, nrules);
   muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
   muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
   muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
   muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
   muscle_insert_int_table ("merger", merger, 0, 0, nrules);
-  muscle_insert_int_table ("immediate", immediate, 0, 0, nrules);
 
   MUSCLE_INSERT_INT ("rules_number", nrules);
   MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
 
+  free (rhs);
+  free (prhs);
   free (rline);
   free (r1);
   free (r2);
   free (dprec);
   free (merger);
-  free (immediate);
 }
 
 /*--------------------------------------------.
@@ -271,73 +293,6 @@ prepare_states (void)
 }
 
 
-/*-------------------------------------------------------.
-| Compare two symbols by type-name, and then by number.  |
-`-------------------------------------------------------*/
-
-static int
-symbol_type_name_cmp (const symbol **lhs, const symbol **rhs)
-{
-  int res = UNIQSTR_CMP((*lhs)->type_name, (*rhs)->type_name);
-  if (res)
-    return res;
-  return (*lhs)->number - (*rhs)->number;
-}
-
-
-/*----------------------------------------------------------------.
-| Return a (malloc'ed) table of the symbols sorted by type-name.  |
-`----------------------------------------------------------------*/
-
-static symbol **
-symbols_by_type_name (void)
-{
-  typedef int (*qcmp_type) (const void *, const void *);
-  symbol **res = xmemdup (symbols, nsyms * sizeof *res);
-  qsort (res, nsyms, sizeof *res, (qcmp_type) &symbol_type_name_cmp);
-  return res;
-}
-
-
-/*------------------------------------------------------------------.
-| Define b4_type_names, which is a list of (lists of the numbers of |
-| symbols with same type-name).                                     |
-`------------------------------------------------------------------*/
-
-static void
-type_names_output (FILE *out)
-{
-  int i;
-  symbol **syms = symbols_by_type_name ();
-  fputs ("m4_define([b4_type_names],\n[", out);
-  for (i = 0; i < nsyms; /* nothing */)
-    {
-      // The index of the first symbol of the current type-name.
-      int i0 = i;
-      fputs (i ? ",\n[" : "[", out);
-      for (; i < nsyms && syms[i]->type_name == syms[i0]->type_name; ++i)
-        fprintf (out, "%s%d", i != i0 ? ", " : "", syms[i]->number);
-      fputs ("]", out);
-    }
-  fputs ("])\n\n", out);
-  free (syms);
-}
-
-
-/*-------------------------------------.
-| The list of all the symbol numbers.  |
-`-------------------------------------*/
-
-static void
-symbol_numbers_output (FILE *out)
-{
-  int i;
-  fputs ("m4_define([b4_symbol_numbers],\n[", out);
-  for (i = 0; i < nsyms; ++i)
-    fprintf (out, "%s[%d]", i ? ", " : "", i);
-  fputs ("])\n\n", out);
-}
-
 
 /*---------------------------------.
 | Output the user actions to OUT.  |
@@ -352,18 +307,17 @@ user_actions_output (FILE *out)
   for (r = 0; r < nrules; ++r)
     if (rules[r].action)
       {
-        fprintf (out, "b4_%scase(%d, [b4_syncline(%d, ",
+	fprintf (out, "b4_case(%d, [b4_syncline(%d, ", r + 1,
-                 rules[r].is_predicate ? "predicate_" : "",
+		 rules[r].action_location.start.line);
-                 r + 1, rules[r].action_location.start.line);
+	string_output (out, rules[r].action_location.start.file);
-        escaped_output (out, rules[r].action_location.start.file);
 	fprintf (out, ")\n[    %s]])\n\n", rules[r].action);
       }
   fputs ("])\n\n", out);
 }
 
-/*------------------------------------.
+/*--------------------------------------.
 | Output the merge functions to OUT.   |
-`------------------------------------*/
+`--------------------------------------*/
 
 static void
 merger_output (FILE *out)
@@ -384,88 +338,96 @@ merger_output (FILE *out)
   fputs ("]])\n\n", out);
 }
 
-
+/*--------------------------------------.
-/*---------------------------------------------.
+| Output the tokens definition to OUT.  |
-| Prepare the muscles for symbol definitions.  |
+`--------------------------------------*/
-`---------------------------------------------*/
 
 static void
-prepare_symbol_definitions (void)
+token_definitions_output (FILE *out)
 {
   int i;
+  char const *sep = "";
+
+  fputs ("m4_define([b4_tokens], \n[", out);
+  for (i = 0; i < ntokens; ++i)
+    {
+      symbol *sym = symbols[i];
+      int number = sym->user_token_number;
+
+      /* At this stage, if there are literal string aliases, they are
+         part of SYMBOLS, so we should not find their aliased symbols
+         here.  */
+      aver (number != USER_NUMBER_HAS_STRING_ALIAS);
+
+      /* Skip error token.  */
+      if (sym == errtoken)
+	continue;
+
+      /* If this string has an alias, then it is necessarily the alias
+	 which is to be output.  */
+      if (sym->alias)
+	sym = sym->alias;
+
+      /* Don't output literal chars or strings (when defined only as a
+	 string).  Note that must be done after the alias resolution:
+	 think about `%token 'f' "f"'.  */
+      if (sym->tag[0] == '\'' || sym->tag[0] == '\"')
+	continue;
+
+      /* Don't #define nonliteral tokens whose names contain periods,
+         dashes or '$' (as does the default value of the EOF token).  */
+      if (mbschr (sym->tag, '.')
+          || mbschr (sym->tag, '-')
+          || mbschr (sym->tag, '$'))
+	continue;
+
+      fprintf (out, "%s[[[%s]], %d]",
+	       sep, sym->tag, number);
+      sep = ",\n";
+    }
+  fputs ("])\n\n", out);
+}
+
+
+/*---------------------------------------------------.
+| Output the symbol destructors or printers to OUT.  |
+`---------------------------------------------------*/
+
+static void
+symbol_code_props_output (FILE *out, char const *what,
+                          code_props const *(*get)(symbol const *))
+{
+  int i;
+  char const *sep = "";
+
+  fputs ("m4_define([b4_symbol_", out);
+  fputs (what, out);
+  fputs ("], \n[", out);
   for (i = 0; i < nsyms; ++i)
     {
       symbol *sym = symbols[i];
-      const char *key;
+      char const *code = (*get) (sym)->code;
-      const char *value;
+      if (code)
-
-#define SET_KEY(Entry)                                          \
-      obstack_fgrow2 (&format_obstack, "symbol(%d, %s)",        \
-                      i, Entry);                                \
-      obstack_1grow (&format_obstack, 0);                       \
-      key = obstack_finish (&format_obstack);
-
-#define SET_KEY2(Entry, Suffix)                                 \
-      obstack_fgrow3 (&format_obstack, "symbol(%d, %s_%s)",     \
-                      i, Entry, Suffix);                        \
-      obstack_1grow (&format_obstack, 0);                       \
-      key = obstack_finish (&format_obstack);
-
-      // Whether the symbol has an identifier.
-      value = symbol_id_get (sym);
-      SET_KEY("has_id");
-      MUSCLE_INSERT_INT (key, !!value);
-
-      // Its identifier.
-      SET_KEY("id");
-      MUSCLE_INSERT_STRING (key, value ? value : "");
-
-      // Its tag.  Typically for documentation purpose.
-      SET_KEY("tag");
-      MUSCLE_INSERT_STRING (key, sym->tag);
-
-      SET_KEY("user_number");
-      MUSCLE_INSERT_INT (key, sym->user_token_number);
-
-      SET_KEY("is_token");
-      MUSCLE_INSERT_INT (key,
-                         i < ntokens && sym != errtoken && sym != undeftoken);
-
-      SET_KEY("number");
-      MUSCLE_INSERT_INT (key, sym->number);
-
-      SET_KEY("has_type");
-      MUSCLE_INSERT_INT (key, !!sym->type_name);
-
-      SET_KEY("type");
-      MUSCLE_INSERT_STRING (key, sym->type_name ? sym->type_name : "");
-
         {
-        int j;
+          location loc = (*get) (sym)->location;
-        for (j = 0; j < CODE_PROPS_SIZE; ++j)
+          /* Filename, lineno,
+             Symbol-name, Symbol-number,
+             code, optional typename.  */
+          fprintf (out, "%s[", sep);
+          sep = ",\n";
+          string_output (out, loc.start.file);
+          fprintf (out, ", %d, ", loc.start.line);
+          quoted_output (out, sym->tag);
+          fprintf (out, ", %d, [[%s]]", sym->number, code);
+          if (sym->type_name)
             {
-            /* "printer", not "%printer".  */
+              fputs (", ", out);
-            char const *pname = code_props_type_string (j) + 1;
+              quoted_output (out, sym->type_name);
-            code_props const *p = symbol_code_props_get (sym, j);
+            }
-            SET_KEY2("has", pname);
+          fputc (']', out);
-            MUSCLE_INSERT_INT (key, !!p->code);
-
-            if (p->code)
-              {
-                SET_KEY2(pname, "file");
-                MUSCLE_INSERT_STRING (key, p->location.start.file);
-
-                SET_KEY2(pname, "line");
-                MUSCLE_INSERT_INT (key, p->location.start.line);
-
-                SET_KEY(pname);
-                MUSCLE_INSERT_STRING_RAW (key, p->code);
         }
     }
-      }
+  fputs ("])\n\n", out);
-#undef SET_KEY2
-#undef SET_KEY
-    }
 }
 
 
@@ -516,7 +478,6 @@ prepare_actions (void)
 				    0, 1, conflict_list_cnt);
 }
 
-
 /*--------------------------------------------.
 | Output the definitions of all the muscles.  |
 `--------------------------------------------*/
@@ -525,11 +486,13 @@ static void
 muscles_output (FILE *out)
 {
   fputs ("m4_init()\n", out);
-  merger_output (out);
+
-  symbol_numbers_output (out);
-  type_names_output (out);
   user_actions_output (out);
-  // Must be last.
+  merger_output (out);
+  token_definitions_output (out);
+  symbol_code_props_output (out, "destructors", &symbol_destructor_get);
+  symbol_code_props_output (out, "printers", &symbol_printer_get);
+
   muscles_m4_output (out);
 }
 
@@ -540,28 +503,48 @@ muscles_output (FILE *out)
 static void
 output_skeleton (void)
 {
+  FILE *in;
   int filter_fd[2];
+  char const *argv[10];
   pid_t pid;
 
   /* Compute the names of the package data dir and skeleton files.  */
-  char const *m4 = (m4 = getenv ("M4")) ? m4 : M4;
+  char const m4sugar[] = "m4sugar/m4sugar.m4";
-  char const *datadir = pkgdatadir ();
+  char const m4bison[] = "bison.m4";
-  char *m4sugar = xconcatenated_filename (datadir, "m4sugar/m4sugar.m4", NULL);
+  char *full_m4sugar;
-  char *m4bison = xconcatenated_filename (datadir, "bison.m4", NULL);
+  char *full_m4bison;
-  char *skel = (IS_PATH_WITH_DIR (skeleton)
+  char *full_skeleton;
-                ? xstrdup (skeleton)
+  char const *p;
-                : xconcatenated_filename (datadir, skeleton, NULL));
+  char const *m4 = (p = getenv ("M4")) ? p : M4;
+  char const *pkgdatadir = compute_pkgdatadir ();
+  size_t skeleton_size = strlen (skeleton) + 1;
+  size_t pkgdatadirlen = strlen (pkgdatadir);
+  while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
+    pkgdatadirlen--;
+  full_skeleton = xmalloc (pkgdatadirlen + 1
+			   + (skeleton_size < sizeof m4sugar
+			      ? sizeof m4sugar : skeleton_size));
+  memcpy (full_skeleton, pkgdatadir, pkgdatadirlen);
+  full_skeleton[pkgdatadirlen] = '/';
+  strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
+  full_m4sugar = xstrdup (full_skeleton);
+  strcpy (full_skeleton + pkgdatadirlen + 1, m4bison);
+  full_m4bison = xstrdup (full_skeleton);
+  if (mbschr (skeleton, '/'))
+    strcpy (full_skeleton, skeleton);
+  else
+    strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
 
   /* Test whether m4sugar.m4 is readable, to check for proper
      installation.  A faulty installation can cause deadlock, so a
      cheap sanity check is worthwhile.  */
-  xfclose (xfopen (m4sugar, "r"));
+  xfclose (xfopen (full_m4sugar, "r"));
 
   /* Create an m4 subprocess connected to us via two pipes.  */
 
   if (trace_flag & trace_tools)
     fprintf (stderr, "running: %s %s - %s %s\n",
-             m4, m4sugar, m4bison, skel);
+             m4, full_m4sugar, full_m4bison, full_skeleton);
 
   /* Some future version of GNU M4 (most likely 1.6) may treat the -dV in a
      position-dependent manner.  Keep it as the first argument so that all
@@ -571,7 +554,6 @@ output_skeleton (void)
      <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
      for details.  */
   {
-    char const *argv[10];
     int i = 0;
     argv[i++] = m4;
 
@@ -588,44 +570,47 @@ output_skeleton (void)
       argv[i++] = M4_GNU_OPTION;
 
     argv[i++] = "-I";
-    argv[i++] = datadir;
+    argv[i++] = pkgdatadir;
     if (trace_flag & trace_m4)
       argv[i++] = "-dV";
-    argv[i++] = m4sugar;
+    argv[i++] = full_m4sugar;
     argv[i++] = "-";
-    argv[i++] = m4bison;
+    argv[i++] = full_m4bison;
-    argv[i++] = skel;
+    argv[i++] = full_skeleton;
     argv[i++] = NULL;
     aver (i <= ARRAY_CARDINALITY (argv));
+  }
 
   /* The ugly cast is because gnulib gets the const-ness wrong.  */
   pid = create_pipe_bidi ("m4", m4, (char **)(void*)argv, false, true,
                           true, filter_fd);
-  }
+  free (full_m4sugar);
-
+  free (full_m4bison);
-  free (m4sugar);
+  free (full_skeleton);
-  free (m4bison);
-  free (skel);
 
   if (trace_flag & trace_muscles)
     muscles_output (stderr);
   {
-    FILE *out = xfdopen (filter_fd[1], "w");
+    FILE *out = fdopen (filter_fd[1], "w");
+    if (! out)
+      error (EXIT_FAILURE, get_errno (),
+             "fdopen");
     muscles_output (out);
     xfclose (out);
   }
 
   /* Read and process m4's output.  */
   timevar_push (TV_M4);
-  {
+  in = fdopen (filter_fd[0], "r");
-    FILE *in = xfdopen (filter_fd[0], "r");
+  if (! in)
+    error (EXIT_FAILURE, get_errno (),
+	   "fdopen");
   scan_skel (in);
   /* scan_skel should have read all of M4's output.  Otherwise, when we
      close the pipe, we risk letting M4 report a broken-pipe to the
      Bison user.  */
   aver (feof (in));
   xfclose (in);
-  }
   wait_subprocess (pid, "m4", false, false, true, true, NULL);
   timevar_pop (TV_M4);
 }
@@ -633,14 +618,21 @@ output_skeleton (void)
 static void
 prepare (void)
 {
-  /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be
+  /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be documented
-     documented for the user.  */
+     for the user.  */
-  char const *cp = getenv ("BISON_USE_PUSH_FOR_PULL");
+  char const *use_push_for_pull_env = getenv ("BISON_USE_PUSH_FOR_PULL");
-  bool use_push_for_pull_flag = cp && *cp && strtol (cp, 0, 10);
+  bool use_push_for_pull_flag = false;
+  if (use_push_for_pull_env != NULL
+      && use_push_for_pull_env[0] != '\0'
+      && 0 != strcmp (use_push_for_pull_env, "0"))
+    use_push_for_pull_flag = true;
 
   /* Flags. */
+  MUSCLE_INSERT_BOOL ("debug_flag", debug_flag);
   MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
+  MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose);
   MUSCLE_INSERT_BOOL ("glr_flag", glr_parser);
+  MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);
   MUSCLE_INSERT_BOOL ("nondeterministic_flag", nondeterministic_parser);
   MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
   MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
@@ -676,7 +668,7 @@ prepare (void)
     /* b4_pkgdatadir is used inside m4_include in the skeletons, so digraphs
        would never be expanded.  Hopefully no one has M4-special characters in
        his Bison installation path.  */
-    MUSCLE_INSERT_STRING_RAW ("pkgdatadir", pkgdatadir ());
+    MUSCLE_INSERT_STRING_RAW ("pkgdatadir", compute_pkgdatadir ());
   }
 }
 
@@ -694,7 +686,6 @@ output (void)
   prepare_rules ();
   prepare_states ();
   prepare_actions ();
-  prepare_symbol_definitions ();
 
   prepare ();
 
@@ -705,8 +696,8 @@ output (void)
 }
 
 char const *
-pkgdatadir (void)
+compute_pkgdatadir (void)
 {
-  char const *cp = getenv ("BISON_PKGDATADIR");
+  char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
-  return cp ? cp : PKGDATADIR;
+  return pkgdatadir ? pkgdatadir : PKGDATADIR;
 }

src/output.h

@@ -23,8 +23,6 @@
 
 /* Output the parsing tables and the parser code to FTABLE.  */
 void output (void);
-
+char const *compute_pkgdatadir (void);
-/* Where our data files are installed.  */
-char const *pkgdatadir (void);
 
 #endif /* !OUTPUT_H_ */

src/parse-gram.h

@@ -1,4 +1,4 @@
-/* A Bison parser, made by GNU Bison 2.5.1.815-22b0.  */
+/* A Bison parser, made by GNU Bison 2.6.1.12-3153-dirty.  */
 
 /* Bison interface for Yacc-like parsers in C
    
@@ -30,8 +30,8 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef GRAM_______SRC_PARSE_GRAM_H
+#ifndef GRAM__________SRC_PARSE_GRAM_H
-# define GRAM_______SRC_PARSE_GRAM_H
+# define GRAM__________SRC_PARSE_GRAM_H
 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -39,24 +39,6 @@
 #if YYDEBUG
 extern int gram_debug;
 #endif
-/* "%code requires" blocks.  */
-/* Line 1996 of yacc.c  */
-#line 221 "src/parse-gram.y"
-
-# ifndef PARAM_TYPE
-#  define PARAM_TYPE
-  typedef enum
-  {
-    param_none   = 0,
-    param_lex    = 1 << 0,
-    param_parse  = 1 << 1,
-    param_both   = param_lex | param_parse
-  } param_type;
-# endif
-
-
-/* Line 1996 of yacc.c  */
-#line 60 "src/parse-gram.h"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -75,50 +57,51 @@ extern int gram_debug;
      PERCENT_LEFT = 265,
      PERCENT_RIGHT = 266,
      PERCENT_NONASSOC = 267,
-     PERCENT_PRECEDENCE = 268,
+     PERCENT_PREC = 268,
-     PERCENT_PREC = 269,
+     PERCENT_DPREC = 269,
-     PERCENT_DPREC = 270,
+     PERCENT_MERGE = 270,
-     PERCENT_MERGE = 271,
+     PERCENT_CODE = 271,
-     PERCENT_CODE = 272,
+     PERCENT_DEBUG = 272,
      PERCENT_DEFAULT_PREC = 273,
      PERCENT_DEFINE = 274,
      PERCENT_DEFINES = 275,
      PERCENT_ERROR_VERBOSE = 276,
      PERCENT_EXPECT = 277,
      PERCENT_EXPECT_RR = 278,
-     PERCENT_FLAG = 279,
+     PERCENT_FILE_PREFIX = 279,
-     PERCENT_FILE_PREFIX = 280,
+     PERCENT_GLR_PARSER = 280,
-     PERCENT_GLR_PARSER = 281,
+     PERCENT_INITIAL_ACTION = 281,
-     PERCENT_INITIAL_ACTION = 282,
+     PERCENT_LANGUAGE = 282,
-     PERCENT_LANGUAGE = 283,
+     PERCENT_LEX_PARAM = 283,
-     PERCENT_NAME_PREFIX = 284,
+     PERCENT_LOCATIONS = 284,
-     PERCENT_NO_DEFAULT_PREC = 285,
+     PERCENT_NAME_PREFIX = 285,
-     PERCENT_NO_LINES = 286,
+     PERCENT_NO_DEFAULT_PREC = 286,
-     PERCENT_NONDETERMINISTIC_PARSER = 287,
+     PERCENT_NO_LINES = 287,
-     PERCENT_OUTPUT = 288,
+     PERCENT_NONDETERMINISTIC_PARSER = 288,
-     PERCENT_REQUIRE = 289,
+     PERCENT_OUTPUT = 289,
-     PERCENT_SKELETON = 290,
+     PERCENT_PARSE_PARAM = 290,
-     PERCENT_START = 291,
+     PERCENT_PURE_PARSER = 291,
-     PERCENT_TOKEN_TABLE = 292,
+     PERCENT_REQUIRE = 292,
-     PERCENT_VERBOSE = 293,
+     PERCENT_SKELETON = 293,
-     PERCENT_YACC = 294,
+     PERCENT_START = 294,
-     BRACED_CODE = 295,
+     PERCENT_TOKEN_TABLE = 295,
-     BRACED_PREDICATE = 296,
+     PERCENT_VERBOSE = 296,
-     BRACKETED_ID = 297,
+     PERCENT_YACC = 297,
-     CHAR = 298,
+     BRACED_CODE = 298,
-     EPILOGUE = 299,
+     BRACKETED_ID = 299,
-     EQUAL = 300,
+     CHAR = 300,
-     ID = 301,
+     EPILOGUE = 301,
-     ID_COLON = 302,
+     EQUAL = 302,
-     PERCENT_PERCENT = 303,
+     ID = 303,
-     PIPE = 304,
+     ID_COLON = 304,
-     PROLOGUE = 305,
+     PERCENT_PERCENT = 305,
-     SEMICOLON = 306,
+     PIPE = 306,
-     TAG = 307,
+     PROLOGUE = 307,
-     TAG_ANY = 308,
+     SEMICOLON = 308,
-     TAG_NONE = 309,
+     TYPE = 309,
-     PERCENT_PARAM = 310,
+     TYPE_TAG_ANY = 310,
-     PERCENT_UNION = 311
+     TYPE_TAG_NONE = 311,
+     PERCENT_UNION = 312
    };
 #endif
 /* Tokens.  */
@@ -133,77 +116,73 @@ extern int gram_debug;
 #define PERCENT_LEFT 265
 #define PERCENT_RIGHT 266
 #define PERCENT_NONASSOC 267
-#define PERCENT_PRECEDENCE 268
+#define PERCENT_PREC 268
-#define PERCENT_PREC 269
+#define PERCENT_DPREC 269
-#define PERCENT_DPREC 270
+#define PERCENT_MERGE 270
-#define PERCENT_MERGE 271
+#define PERCENT_CODE 271
-#define PERCENT_CODE 272
+#define PERCENT_DEBUG 272
 #define PERCENT_DEFAULT_PREC 273
 #define PERCENT_DEFINE 274
 #define PERCENT_DEFINES 275
 #define PERCENT_ERROR_VERBOSE 276
 #define PERCENT_EXPECT 277
 #define PERCENT_EXPECT_RR 278
-#define PERCENT_FLAG 279
+#define PERCENT_FILE_PREFIX 279
-#define PERCENT_FILE_PREFIX 280
+#define PERCENT_GLR_PARSER 280
-#define PERCENT_GLR_PARSER 281
+#define PERCENT_INITIAL_ACTION 281
-#define PERCENT_INITIAL_ACTION 282
+#define PERCENT_LANGUAGE 282
-#define PERCENT_LANGUAGE 283
+#define PERCENT_LEX_PARAM 283
-#define PERCENT_NAME_PREFIX 284
+#define PERCENT_LOCATIONS 284
-#define PERCENT_NO_DEFAULT_PREC 285
+#define PERCENT_NAME_PREFIX 285
-#define PERCENT_NO_LINES 286
+#define PERCENT_NO_DEFAULT_PREC 286
-#define PERCENT_NONDETERMINISTIC_PARSER 287
+#define PERCENT_NO_LINES 287
-#define PERCENT_OUTPUT 288
+#define PERCENT_NONDETERMINISTIC_PARSER 288
-#define PERCENT_REQUIRE 289
+#define PERCENT_OUTPUT 289
-#define PERCENT_SKELETON 290
+#define PERCENT_PARSE_PARAM 290
-#define PERCENT_START 291
+#define PERCENT_PURE_PARSER 291
-#define PERCENT_TOKEN_TABLE 292
+#define PERCENT_REQUIRE 292
-#define PERCENT_VERBOSE 293
+#define PERCENT_SKELETON 293
-#define PERCENT_YACC 294
+#define PERCENT_START 294
-#define BRACED_CODE 295
+#define PERCENT_TOKEN_TABLE 295
-#define BRACED_PREDICATE 296
+#define PERCENT_VERBOSE 296
-#define BRACKETED_ID 297
+#define PERCENT_YACC 297
-#define CHAR 298
+#define BRACED_CODE 298
-#define EPILOGUE 299
+#define BRACKETED_ID 299
-#define EQUAL 300
+#define CHAR 300
-#define ID 301
+#define EPILOGUE 301
-#define ID_COLON 302
+#define EQUAL 302
-#define PERCENT_PERCENT 303
+#define ID 303
-#define PIPE 304
+#define ID_COLON 304
-#define PROLOGUE 305
+#define PERCENT_PERCENT 305
-#define SEMICOLON 306
+#define PIPE 306
-#define TAG 307
+#define PROLOGUE 307
-#define TAG_ANY 308
+#define SEMICOLON 308
-#define TAG_NONE 309
+#define TYPE 309
-#define PERCENT_PARAM 310
+#define TYPE_TAG_ANY 310
-#define PERCENT_UNION 311
+#define TYPE_TAG_NONE 311
+#define PERCENT_UNION 312
 
 
 
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
 {
-/* Line 1996 of yacc.c  */
+/* Line 2049 of yacc.c  */
-#line 107 "src/parse-gram.y"
+#line 114 "parse-gram.y"
 
-  assoc assoc;
-  char *code;
-  char const *chars;
-  int integer;
-  named_ref *named_ref;
   symbol *symbol;
   symbol_list *list;
+  int integer;
+  char const *chars;
+  char *code;
+  assoc assoc;
   uniqstr uniqstr;
   unsigned char character;
-
+  named_ref *named_ref;
-/* Line 1996 of yacc.c  */
-#line 245 "src/parse-gram.y"
-
-  param_type param;
 
 
-/* Line 1996 of yacc.c  */
+/* Line 2049 of yacc.c  */
-#line 207 "src/parse-gram.h"
+#line 186 "parse-gram.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -225,19 +204,17 @@ typedef struct YYLTYPE
 
 
 #ifdef YYPARSE_PARAM
-#if (defined __STDC__ || defined __C99__FUNC__ \
+#if defined __STDC__ || defined __cplusplus
-     || defined __cplusplus || defined _MSC_VER)
 int gram_parse (void *YYPARSE_PARAM);
 #else
 int gram_parse ();
 #endif
 #else /* ! YYPARSE_PARAM */
-#if (defined __STDC__ || defined __C99__FUNC__ \
+#if defined __STDC__ || defined __cplusplus
-     || defined __cplusplus || defined _MSC_VER)
 int gram_parse (void);
 #else
 int gram_parse ();
 #endif
 #endif /* ! YYPARSE_PARAM */
 
-#endif /* !GRAM_______SRC_PARSE_GRAM_H  */
+#endif /* !GRAM__________SRC_PARSE_GRAM_H  */

src/parse-gram.y

@@ -50,24 +50,30 @@ static void version_check (location const *loc, char const *version);
 static void gram_error (location const *, char const *);
 
 static char const *char_name (char);
-%}
 
-%code
+/** Add a lex-param or a parse-param.
-{
+ *
-  static int current_prec = 0;
+ * \param type  \a lex_param or \a parse_param
-  static location current_lhs_location;
+ * \param decl  the formal argument
-  static named_ref *current_lhs_named_ref;
+ * \param loc   the location in the source.
-  static symbol *current_lhs_symbol;
+ */
-  static symbol_class current_class = unknown_sym;
+static void add_param (char const *type, char *decl, location loc);
-  static uniqstr current_type = NULL;
 
-  /** Set the new current left-hand side symbol, possibly common
+
+static symbol_class current_class = unknown_sym;
+static uniqstr current_type = NULL;
+static symbol *current_lhs_symbol;
+static location current_lhs_location;
+static named_ref *current_lhs_named_ref;
+static int current_prec = 0;
+
+/** Set the new current left-hand side symbol, possibly common
  * to several right-hand side parts of rule.
  */
-  static
+static
-  void
+void
-  current_lhs(symbol *sym, location loc, named_ref *ref)
+current_lhs(symbol *sym, location loc, named_ref *ref)
-  {
+{
   current_lhs_symbol = sym;
   current_lhs_location = loc;
   /* In order to simplify memory management, named references for lhs
@@ -77,20 +83,21 @@ static char const *char_name (char);
      rules using "|".  Therefore free the parser's original copy.  */
   free (current_lhs_named_ref);
   current_lhs_named_ref = ref;
-  }
-
-  #define YYTYPE_INT16 int_fast16_t
-  #define YYTYPE_INT8 int_fast8_t
-  #define YYTYPE_UINT16 uint_fast16_t
-  #define YYTYPE_UINT8 uint_fast8_t
 }
 
+
+#define YYTYPE_INT16 int_fast16_t
+#define YYTYPE_INT8 int_fast8_t
+#define YYTYPE_UINT16 uint_fast16_t
+#define YYTYPE_UINT8 uint_fast8_t
+%}
+
 %debug
 %verbose
 %defines
 %locations
 %pure-parser
-%define parse.error "verbose"
+%error-verbose
 %define parse.lac full
 %name-prefix="gram_"
 %expect 0
@@ -105,15 +112,15 @@ static char const *char_name (char);
 
 %union
 {
-  assoc assoc;
-  char *code;
-  char const *chars;
-  int integer;
-  named_ref *named_ref;
   symbol *symbol;
   symbol_list *list;
+  int integer;
+  char const *chars;
+  char *code;
+  assoc assoc;
   uniqstr uniqstr;
   unsigned char character;
+  named_ref *named_ref;
 };
 
 /* Define the tokens together with their human representation.  */
@@ -131,35 +138,39 @@ static char const *char_name (char);
 %token PERCENT_LEFT        "%left"
 %token PERCENT_RIGHT       "%right"
 %token PERCENT_NONASSOC    "%nonassoc"
-%token PERCENT_PRECEDENCE  "%precedence"
 
 %token PERCENT_PREC          "%prec"
 %token PERCENT_DPREC         "%dprec"
 %token PERCENT_MERGE         "%merge"
 
+
 /*----------------------.
 | Global Declarations.  |
 `----------------------*/
 
 %token
   PERCENT_CODE            "%code"
+  PERCENT_DEBUG           "%debug"
   PERCENT_DEFAULT_PREC    "%default-prec"
   PERCENT_DEFINE          "%define"
   PERCENT_DEFINES         "%defines"
   PERCENT_ERROR_VERBOSE   "%error-verbose"
   PERCENT_EXPECT          "%expect"
   PERCENT_EXPECT_RR	  "%expect-rr"
-  PERCENT_FLAG            "%<flag>"
   PERCENT_FILE_PREFIX     "%file-prefix"
   PERCENT_GLR_PARSER      "%glr-parser"
   PERCENT_INITIAL_ACTION  "%initial-action"
   PERCENT_LANGUAGE        "%language"
+  PERCENT_LEX_PARAM       "%lex-param"
+  PERCENT_LOCATIONS       "%locations"
   PERCENT_NAME_PREFIX     "%name-prefix"
   PERCENT_NO_DEFAULT_PREC "%no-default-prec"
   PERCENT_NO_LINES        "%no-lines"
   PERCENT_NONDETERMINISTIC_PARSER
 			  "%nondeterministic-parser"
   PERCENT_OUTPUT          "%output"
+  PERCENT_PARSE_PARAM     "%parse-param"
+  PERCENT_PURE_PARSER     "%pure-parser"
   PERCENT_REQUIRE	  "%require"
   PERCENT_SKELETON        "%skeleton"
   PERCENT_START           "%start"
@@ -169,7 +180,6 @@ static char const *char_name (char);
 ;
 
 %token BRACED_CODE     "{...}"
-%token BRACED_PREDICATE "%?{...}"
 %token BRACKETED_ID    "[identifier]"
 %token CHAR            "char"
 %token EPILOGUE        "epilogue"
@@ -180,9 +190,9 @@ static char const *char_name (char);
 %token PIPE            "|"
 %token PROLOGUE        "%{...%}"
 %token SEMICOLON       ";"
-%token TAG             "<tag>"
+%token TYPE            "type"
-%token TAG_ANY         "<*>"
+%token TYPE_TAG_ANY    "<*>"
-%token TAG_NONE        "<>"
+%token TYPE_TAG_NONE   "<>"
 
 %type <character> CHAR
 %printer { fputs (char_name ($$), stderr); } CHAR
@@ -190,18 +200,17 @@ static char const *char_name (char);
 /* braceless is not to be used for rule or symbol actions, as it
    calls code_props_plain_init.  */
 %type <chars> STRING "%{...%}" EPILOGUE braceless content.opt
-%type <code> "{...}" "%?{...}"
+%type <code> "{...}"
 %printer { fputs (quotearg_style (c_quoting_style, $$), stderr); }
 	 STRING
 %printer { fprintf (stderr, "{\n%s\n}", $$); }
 	 braceless content.opt "{...}" "%{...%}" EPILOGUE
 
-%type <uniqstr> BRACKETED_ID ID ID_COLON PERCENT_FLAG TAG variable
+%type <uniqstr> BRACKETED_ID ID ID_COLON TYPE variable
 %printer { fputs ($$, stderr); } <uniqstr>
 %printer { fprintf (stderr, "[%s]", $$); } BRACKETED_ID
 %printer { fprintf (stderr, "%s:", $$); } ID_COLON
-%printer { fprintf (stderr, "%%%s", $$); } PERCENT_FLAG
+%printer { fprintf (stderr, "<%s>", $$); } TYPE
-%printer { fprintf (stderr, "<%s>", $$); } TAG
 
 %type <integer> INT
 %printer { fprintf (stderr, "%d", $$); } <integer>
@@ -214,56 +223,6 @@ static char const *char_name (char);
 %type <list>  symbols.1 symbols.prec generic_symlist generic_symlist_item
 %type <named_ref> named_ref.opt
 
-/*---------.
-| %param.  |
-`---------*/
-%code requires
-{
-# ifndef PARAM_TYPE
-#  define PARAM_TYPE
-  typedef enum
-  {
-    param_none   = 0,
-    param_lex    = 1 << 0,
-    param_parse  = 1 << 1,
-    param_both   = param_lex | param_parse
-  } param_type;
-# endif
-};
-%code
-{
-  /** Add a lex-param and/or a parse-param.
-   *
-   * \param type  where to push this formal argument.
-   * \param decl  the formal argument.  Destroyed.
-   * \param loc   the location in the source.
-   */
-  static void add_param (param_type type, char *decl, location loc);
-  static param_type current_param = param_none;
-};
-%union
-{
-  param_type param;
-}
-%token <param> PERCENT_PARAM "%param";
-%printer
-{
-  switch ($$)
-    {
-#define CASE(In, Out)                                           \
-      case param_ ## In: fputs ("%" #Out, stderr); break
-      CASE(lex,   lex-param);
-      CASE(parse, parse-param);
-      CASE(both,  param);
-#undef CASE
-      case param_none: aver (false); break;
-    }
-} <param>;
-
-
-                     /*==========\
-                     | Grammar.  |
-                     \==========*/
 %%
 
 input:
@@ -292,10 +251,7 @@ prologue_declaration:
                         plain_code.code, @1);
       code_scanner_last_string_free ();
     }
-| "%<flag>"
+| "%debug"                         { debug_flag = true; }
-    {
-      muscle_percent_define_ensure ($1, @1, true);
-    }
 | "%define" variable content.opt
     {
       muscle_percent_define_insert ($2, @2, $3,
@@ -307,11 +263,7 @@ prologue_declaration:
       defines_flag = true;
       spec_defines_file = xstrdup ($2);
     }
-| "%error-verbose"
+| "%error-verbose"                 { error_verbose = true; }
-    {
-      muscle_percent_define_insert ("parse.error", @1, "verbose",
-                                    MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
-    }
 | "%expect" INT                    { expected_sr_conflicts = $2; }
 | "%expect-rr" INT		   { expected_rr_conflicts = $2; }
 | "%file-prefix" STRING            { spec_file_prefix = $2; }
@@ -331,18 +283,35 @@ prologue_declaration:
       code_scanner_last_string_free ();
     }
 | "%language" STRING		{ language_argmatch ($2, grammar_prio, @1); }
+| "%lex-param" "{...}"		{ add_param ("lex_param", $2, @2); }
+| "%locations"                  { locations_flag = true; }
 | "%name-prefix" STRING         { spec_name_prefix = $2; }
 | "%name-prefix" "=" STRING     { spec_name_prefix = $3; } /* deprecated */
 | "%no-lines"                   { no_lines_flag = true; }
 | "%nondeterministic-parser"	{ nondeterministic_parser = true; }
 | "%output" STRING              { spec_outfile = $2; }
 | "%output" "=" STRING          { spec_outfile = $3; }  /* deprecated */
-| "%param" { current_param = $1; } params { current_param = param_none; }
+| "%parse-param" "{...}"	{ add_param ("parse_param", $2, @2); }
+| "%pure-parser"
+    {
+      /* %pure-parser is deprecated in favor of `%define api.pure', so use
+         `%define api.pure' in a backward-compatible manner here.  First, don't
+         complain if %pure-parser is specified multiple times.  */
+      if (!muscle_find_const ("percent_define(api.pure)"))
+        muscle_percent_define_insert ("api.pure", @1, "",
+                                      MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
+      /* In all cases, use api.pure now so that the backend doesn't complain if
+         the skeleton ignores api.pure, but do warn now if there's a previous
+         conflicting definition from an actual %define.  */
+      if (!muscle_percent_define_flag_if ("api.pure"))
+        muscle_percent_define_insert ("api.pure", @1, "",
+                                      MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
+    }
 | "%require" STRING             { version_check (&@2, $2); }
 | "%skeleton" STRING
     {
       char const *skeleton_user = $2;
-      if (strchr (skeleton_user, '/'))
+      if (mbschr (skeleton_user, '/'))
         {
           size_t dir_length = strlen (current_file);
           char *skeleton_build;
@@ -369,16 +338,6 @@ prologue_declaration:
 | /*FIXME: Err?  What is this horror doing here? */ ";"
 ;
 
-params:
-   params "{...}"  { add_param (current_param, $2, @2); }
-| "{...}"          { add_param (current_param, $1, @1); }
-;
-
-
-/*----------------------.
-| grammar_declaration.  |
-`----------------------*/
-
 grammar_declaration:
   precedence_declaration
 | symbol_declaration
@@ -388,18 +347,28 @@ grammar_declaration:
     }
 | "%destructor" "{...}" generic_symlist
     {
-      symbol_list *list;
+      code_props code;
-      for (list = $3; list; list = list->next)
+      code_props_symbol_action_init (&code, $2, @2);
-        symbol_list_code_props_set (list, destructor, @2, $2);
+      code_props_translate_code (&code);
-      symbol_list_free ($3);
-    }
-| "%printer" "{...}" generic_symlist
       {
         symbol_list *list;
         for (list = $3; list; list = list->next)
-        symbol_list_code_props_set (list, printer, @2, $2);
+          symbol_list_destructor_set (list, &code);
         symbol_list_free ($3);
       }
+    }
+| "%printer" "{...}" generic_symlist
+    {
+      code_props code;
+      code_props_symbol_action_init (&code, $2, @2);
+      code_props_translate_code (&code);
+      {
+        symbol_list *list;
+        for (list = $3; list; list = list->next)
+          symbol_list_printer_set (list, &code);
+        symbol_list_free ($3);
+      }
+    }
 | "%default-prec"
     {
       default_prec = true;
@@ -423,9 +392,9 @@ grammar_declaration:
 ;
 
 
-/*---------.
+/*----------*
-| %union.  |
+ | %union.  |
-`---------*/
+ *----------*/
 
 %token PERCENT_UNION "%union";
 
@@ -457,7 +426,7 @@ symbol_declaration:
       current_class = unknown_sym;
       current_type = NULL;
     }
-| "%type" TAG symbols.1
+| "%type" TYPE symbols.1
     {
       symbol_list *list;
       tag_seen = true;
@@ -468,7 +437,7 @@ symbol_declaration:
 ;
 
 precedence_declaration:
-  precedence_declarator tag.opt symbols.prec
+  precedence_declarator type.opt symbols.prec
     {
       symbol_list *list;
       ++current_prec;
@@ -486,12 +455,11 @@ precedence_declarator:
   "%left"     { $$ = left_assoc; }
 | "%right"    { $$ = right_assoc; }
 | "%nonassoc" { $$ = non_assoc; }
-| "%precedence" { $$ = precedence_assoc; }
 ;
 
-tag.opt:
+type.opt:
   /* Nothing. */ { current_type = NULL; }
-| TAG            { current_type = $1; tag_seen = true; }
+| TYPE           { current_type = $1; tag_seen = true; }
 ;
 
 /* Just like symbols.1 but accept INT for the sake of POSIX.  */
@@ -522,14 +490,14 @@ generic_symlist:
 
 generic_symlist_item:
   symbol            { $$ = symbol_list_sym_new ($1, @1); }
-| TAG       { $$ = symbol_list_type_new ($1, @1); }
+| TYPE              { $$ = symbol_list_type_new ($1, @1); }
 | "<*>"             { $$ = symbol_list_default_tagged_new (@1); }
 | "<>"             { $$ = symbol_list_default_tagless_new (@1); }
 ;
 
 /* One token definition.  */
 symbol_def:
-  TAG
+  TYPE
      {
        current_type = $1;
        tag_seen = true;
@@ -608,14 +576,12 @@ rhs:
 | rhs symbol named_ref.opt
     { grammar_current_rule_symbol_append ($2, @2, $3); }
 | rhs "{...}" named_ref.opt
-    { grammar_current_rule_action_append ($2, @2, $3, false); }
+    { grammar_current_rule_action_append ($2, @2, $3); }
-| rhs "%?{...}"
-    { grammar_current_rule_action_append ($2, @2, NULL, true); }
 | rhs "%prec" symbol
     { grammar_current_rule_prec_set ($3, @3); }
 | rhs "%dprec" INT
     { grammar_current_rule_dprec_set ($3, @3); }
-| rhs "%merge" TAG
+| rhs "%merge" TYPE
     { grammar_current_rule_merge_set ($3, @3); }
 ;
 
@@ -625,9 +591,10 @@ named_ref.opt:
   BRACKETED_ID   { $$ = named_ref_new($1, @1); }
 ;
 
-/*---------------------------.
+
-| variable and content.opt.  |
+/*----------------------------*
-`---------------------------*/
+ | variable and content.opt.  |
+ *---------------------------*/
 
 /* The STRING form of variable is deprecated and is not M4-friendly.
    For example, M4 fails for `%define "[" "value"'.  */
@@ -644,9 +611,9 @@ content.opt:
 ;
 
 
-/*------------.
+/*-------------*
-| braceless.  |
+ | braceless.  |
-`------------*/
+ *-------------*/
 
 braceless:
   "{...}"
@@ -661,9 +628,9 @@ braceless:
 ;
 
 
-/*--------------.
+/*---------------*
-| Identifiers.  |
+ | Identifiers.  |
-`--------------*/
+ *---------------*/
 
 /* Identifiers are returned as uniqstr values by the scanner.
    Depending on their use, we may need to make them genuine symbols.  */
@@ -744,18 +711,20 @@ lloc_default (YYLTYPE const *rhs, int n)
 }
 
 
+/* Add a lex-param or a parse-param (depending on TYPE) with
+   declaration DECL and location LOC.  */
+
 static void
-add_param (param_type type, char *decl, location loc)
+add_param (char const *type, char *decl, location loc)
 {
   static char const alphanum[26 + 26 + 1 + 10] =
     "abcdefghijklmnopqrstuvwxyz"
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "_"
     "0123456789";
-
   char const *name_start = NULL;
-  {
   char *p;
+
   /* Stop on last actual character.  */
   for (p = decl; p[1]; p++)
     if ((p == decl
@@ -765,23 +734,20 @@ add_param (param_type type, char *decl, location loc)
 
   /* Strip the surrounding '{' and '}', and any blanks just inside
      the braces.  */
-    while (*--p == ' ' || *p == '\t')
+  --p;
-      continue;
+  while (isspace ((unsigned char) *p))
+    --p;
   p[1] = '\0';
-    while (*++decl == ' ' || *decl == '\t')
+  ++decl;
-      continue;
+  while (isspace ((unsigned char) *decl))
-  }
+    ++decl;
 
   if (! name_start)
-    complain_at (loc, complaint,
+    complain_at (loc, _("missing identifier in parameter declaration"));
-                 _("missing identifier in parameter declaration"));
   else
     {
       char *name = xmemdup0 (name_start, strspn (name_start, alphanum));
-      if (type & param_lex)
+      muscle_pair_list_grow (type, decl, name);
-        muscle_pair_list_grow ("lex_param", decl, name);
-      if (type & param_parse)
-        muscle_pair_list_grow ("parse_param", decl, name);
       free (name);
     }
 
@@ -794,7 +760,7 @@ version_check (location const *loc, char const *version)
 {
   if (strverscmp (version, PACKAGE_VERSION) > 0)
     {
-      complain_at (*loc, complaint, "require bison %s, but have %s",
+      complain_at (*loc, "require bison %s, but have %s",
                    version, PACKAGE_VERSION);
       exit (EX_MISMATCH);
     }
@@ -803,7 +769,7 @@ version_check (location const *loc, char const *version)
 static void
 gram_error (location const *loc, char const *msg)
 {
-  complain_at (*loc, complaint, "%s", msg);
+  complain_at (*loc, "%s", msg);
 }
 
 char const *

src/print.c

@@ -336,8 +336,8 @@ print_reductions (FILE *out, state *s)
       char *default_reductions =
         muscle_percent_define_get ("lr.default-reductions");
       print_reduction (out, width, _("$default"), default_reduction, true);
-      aver (STREQ (default_reductions, "most")
+      aver (0 == strcmp (default_reductions, "most")
-            || (STREQ (default_reductions, "consistent")
+            || (0 == strcmp (default_reductions, "consistent")
                 && default_reduction_only)
             || (reds->num == 1 && reds->rules[0]->number == 0));
       free (default_reductions);
@@ -386,14 +386,14 @@ print_state (FILE *out, state *s)
 `-----------------------------------------*/
 
 #define END_TEST(End)				\
-  do {                                          \
+do {						\
-    if (column + strlen (buffer) > (End))       \
+  if (column + strlen(buffer) > (End))		\
     {						\
       fprintf (out, "%s\n   ", buffer);		\
       column = 3;				\
       buffer[0] = 0;				\
     }						\
-  } while (0)
+} while (0)
 
 
 static void

src/print_graph.c

@@ -54,7 +54,7 @@ print_core (struct obstack *oout, state *s)
       snritems = nitemset;
     }
 
-  obstack_fgrow1 (oout, "%d", s->number);
+  obstack_printf (oout, "%d", s->number);
   for (i = 0; i < snritems; i++)
     {
       item_number *sp;
@@ -68,15 +68,15 @@ print_core (struct obstack *oout, state *s)
 
       r = item_number_as_rule_number (*sp);
 
-      obstack_fgrow1 (oout, "\n%s -> ", rules[r].lhs->tag);
+      obstack_printf (oout, "\n%s -> ", rules[r].lhs->tag);
 
       for (sp = rules[r].rhs; sp < sp1; sp++)
-        obstack_fgrow1 (oout, "%s ", symbols[*sp]->tag);
+	obstack_printf (oout, "%s ", symbols[*sp]->tag);
 
       obstack_1grow (oout, '.');
 
       for (/* Nothing */; *sp >= 0; ++sp)
-        obstack_fgrow1 (oout, " %s", symbols[*sp]->tag);
+	obstack_printf (oout, " %s", symbols[*sp]->tag);
 
       /* Experimental feature: display the lookahead tokens. */
       if (report_flag & report_lookahead_tokens
@@ -95,7 +95,7 @@ print_core (struct obstack *oout, state *s)
 	      obstack_sgrow (oout, "[");
 	      BITSET_FOR_EACH (biter, reds->lookahead_tokens[redno], k, 0)
 		{
-                  obstack_fgrow2 (oout, "%s%s", sep, symbols[k]->tag);
+		  obstack_printf (oout, "%s%s", sep, symbols[k]->tag);
 		  sep = ", ";
 		}
 	      obstack_sgrow (oout, "]");
@@ -133,7 +133,7 @@ print_actions (state const *s, FILE *fgraph)
 	   : "dashed");
 
 	if (TRANSITION_IS_ERROR (trans, i)
-            && STRNEQ (symbols[sym]->tag, "error"))
+	    && strcmp (symbols[sym]->tag, "error") != 0)
 	  abort ();
 	output_edge (s->number, s1->number,
 		     TRANSITION_IS_ERROR (trans, i) ? NULL : symbols[sym]->tag,