Issues found with existing distfiles:
distfiles/eclipse-sourceBuild-srcIncluded-3.0.1.zip
distfiles/fortran-utils-1.1.tar.gz
distfiles/ivykis-0.39.tar.gz
distfiles/enum-1.11.tar.gz
distfiles/pvs-3.2-libraries.tgz
distfiles/pvs-3.2-linux.tgz
distfiles/pvs-3.2-solaris.tgz
distfiles/pvs-3.2-system.tgz
No changes made to these distinfo files.
Otherwise, existing SHA1 digests verified and found to be the same on
the machine holding the existing distfiles (morden). All existing
SHA1 digests retained for now as an audit trail.
* Noteworthy changes in release 3.0.4 (2015-01-23) [stable]
** Bug fixes
*** C++ with Variants (lalr1.cc)
Fix a compiler warning when no %destructor use $$.
*** Test suites
Several portability issues in tests were fixed.
(pkgsrc)
- Add comment on patch-lib_isnan.c (from cvs log)
(upstream)
- Update devel/bison 3.0.2 to 3.0.3
Thanks obache and wiz for review.
---------------------------------
* Noteworthy changes in release 3.0.3 (2015-01-15) [stable]
** Bug fixes
*** C++ with Variants (lalr1.cc)
Problems with %destructor and '%define parse.assert' have been fixed.
*** Named %union support (yacc.c, glr.c)
Bison 3.0 introduced a regression on named %union such as
%union foo { int ival; };
The possibility to use a name was introduced "for Yacc compatibility".
It is however not required by POSIX Yacc, and its usefulness is not clear.
*** %define api.value.type union with %defines (yacc.c, glr.c)
The C parsers were broken when %defines was used together with "%define
api.value.type union".
*** Redeclarations are reported in proper order
On
%token FOO "foo"
%printer {} "foo"
%printer {} FOO
bison used to report:
/tmp/foo.yy:2.10-11: error: %printer redeclaration for FOO
%printer {} "foo"
^^
/tmp/foo.yy:3.10-11: previous declaration
%printer {} FOO
^^
Now, the "previous" declaration is always the first one.
** Documentation
Bison now installs various files in its docdir (which defaults to
'/usr/local/share/doc/bison'), including the three fully blown examples
extracted from the documentation:
- rpcalc
Reverse polish calculator, a simple introductory example.
- mfcalc
Multi-function Calc, a calculator with memory and functions and located
error messages.
- calc++
a calculator in C++ using variant support and token constructors.
Do it for all packages that
* mention perl, or
* have a directory name starting with p5-*, or
* depend on a package starting with p5-
like last time, for 5.18, where this didn't lead to complaints.
Let me know if you have any this time.
* Noteworthy changes in release 3.0.2 (2013-12-05) [stable]
** Bug fixes
*** Generated source files when errors are reported
When warnings are issued and -Werror is set, bison would still generate
the source files (*.c, *.h...). As a consequence, some runs of "make"
could fail the first time, but not the second (as the files were generated
anyway).
This is fixed: bison no longer generates this source files, but, of
course, still produces the various reports (*.output, *.xml, etc.).
*** %empty is used in reports
Empty right-hand sides are denoted by '%empty' in all the reports (text,
dot, XML and formats derived from it).
*** YYERROR and variants
When C++ variant support is enabled, an error triggered via YYERROR, but
not caught via error recovery, resulted in a double deletion.
* Noteworthy changes in release 3.0.1 (2013-11-12) [stable]
** Bug fixes
*** Errors in caret diagnostics
On some platforms, some errors could result in endless diagnostics.
*** Fixes of the -Werror option
Options such as "-Werror -Wno-error=foo" were still turning "foo"
diagnostics into errors instead of warnings. This is fixed.
Actually, for consistency with GCC, "-Wno-error=foo -Werror" now also
leaves "foo" diagnostics as warnings. Similarly, with "-Werror=foo
-Wno-error", "foo" diagnostics are now errors.
*** GLR Predicates
As demonstrated in the documentation, one can now leave spaces between
"%?" and its "{".
*** Installation
The yacc.1 man page is no longer installed if --disable-yacc was
specified.
*** Fixes in the test suite
Bugs and portability issues.
* Noteworthy changes in release 3.0 (2013-07-25) [stable]
** WARNING: Future backward-incompatibilities!
Like other GNU packages, Bison will start using some of the C99 features
for its own code, especially the definition of variables after statements.
The generated C parsers still aim at C90.
** Backward incompatible changes
*** Obsolete features
Support for YYFAIL is removed (deprecated in Bison 2.4.2): use YYERROR.
Support for yystype and yyltype is removed (deprecated in Bison 1.875):
use YYSTYPE and YYLTYPE.
Support for YYLEX_PARAM and YYPARSE_PARAM is removed (deprecated in Bison
1.875): use %lex-param, %parse-param, or %param.
Missing semicolons at the end of actions are no longer added (as announced
in the release 2.5).
*** Use of YACC='bison -y'
TL;DR: With Autoconf <= 2.69, pass -Wno-yacc to (AM_)YFLAGS if you use
Bison extensions.
Traditional Yacc generates 'y.tab.c' whatever the name of the input file.
Therefore Makefiles written for Yacc expect 'y.tab.c' (and possibly
'y.tab.h' and 'y.outout') to be generated from 'foo.y'.
To this end, for ages, AC_PROG_YACC, Autoconf's macro to look for an
implementation of Yacc, was using Bison as 'bison -y'. While it does
ensure compatible output file names, it also enables warnings for
incompatibilities with POSIX Yacc. In other words, 'bison -y' triggers
warnings for Bison extensions.
Autoconf 2.70+ fixes this incompatibility by using YACC='bison -o y.tab.c'
(which also generates 'y.tab.h' and 'y.output' when needed).
Alternatively, disable Yacc warnings by passing '-Wno-yacc' to your Yacc
flags (YFLAGS, or AM_YFLAGS with Automake).
** Bug fixes
*** The epilogue is no longer affected by internal #defines (glr.c)
The glr.c skeleton uses defines such as #define yylval (yystackp->yyval) in
generated code. These weren't properly undefined before the inclusion of
the user epilogue, so functions such as the following were butchered by the
preprocessor expansion:
int yylex (YYSTYPE *yylval);
This is fixed: yylval, yynerrs, yychar, and yylloc are now valid
identifiers for user-provided variables.
*** stdio.h is no longer needed when locations are enabled (yacc.c)
Changes in Bison 2.7 introduced a dependency on FILE and fprintf when
locations are enabled. This is fixed.
*** Warnings about useless %pure-parser/%define api.pure are restored
** Diagnostics reported by Bison
Most of these features were contributed by Théophile Ranquet and Victor
Santet.
*** Carets
Version 2.7 introduced caret errors, for a prettier output. These are now
activated by default. The old format can still be used by invoking Bison
with -fno-caret (or -fnone).
Some error messages that reproduced excerpts of the grammar are now using
the caret information only. For instance on:
%%
exp: 'a' | 'a';
Bison 2.7 reports:
in.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
in.y:2.12-14: warning: rule useless in parser due to conflicts: exp: 'a' [-Wother]
Now bison reports:
in.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
in.y:2.12-14: warning: rule useless in parser due to conflicts [-Wother]
exp: 'a' | 'a';
^^^
and "bison -fno-caret" reports:
in.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
in.y:2.12-14: warning: rule useless in parser due to conflicts [-Wother]
*** Enhancements of the -Werror option
The -Werror=CATEGORY option is now recognized, and will treat specified
warnings as errors. The warnings need not have been explicitly activated
using the -W option, this is similar to what GCC 4.7 does.
For example, given the following command line, Bison will treat both
warnings related to POSIX Yacc incompatibilities and S/R conflicts as
errors (and only those):
$ bison -Werror=yacc,error=conflicts-sr input.y
If no categories are specified, -Werror will make all active warnings into
errors. For example, the following line does the same the previous example:
$ bison -Werror -Wnone -Wyacc -Wconflicts-sr input.y
(By default -Wconflicts-sr,conflicts-rr,deprecated,other is enabled.)
Note that the categories in this -Werror option may not be prefixed with
"no-". However, -Wno-error[=CATEGORY] is valid.
Note that -y enables -Werror=yacc. Therefore it is now possible to require
Yacc-like behavior (e.g., always generate y.tab.c), but to report
incompatibilities as warnings: "-y -Wno-error=yacc".
*** The display of warnings is now richer
The option that controls a given warning is now displayed:
foo.y:4.6: warning: type clash on default action: <foo> != <bar> [-Wother]
In the case of warnings treated as errors, the prefix is changed from
"warning: " to "error: ", and the suffix is displayed, in a manner similar
to GCC, as [-Werror=CATEGORY].
For instance, where the previous version of Bison would report (and exit
with failure):
bison: warnings being treated as errors
input.y:1.1: warning: stray ',' treated as white space
it now reports:
input.y:1.1: error: stray ',' treated as white space [-Werror=other]
*** Deprecated constructs
The new 'deprecated' warning category flags obsolete constructs whose
support will be discontinued. It is enabled by default. These warnings
used to be reported as 'other' warnings.
*** Useless semantic types
Bison now warns about useless (uninhabited) semantic types. Since
semantic types are not declared to Bison (they are defined in the opaque
%union structure), it is %printer/%destructor directives about useless
types that trigger the warning:
%token <type1> term
%type <type2> nterm
%printer {} <type1> <type3>
%destructor {} <type2> <type4>
%%
nterm: term { $$ = $1; };
3.28-34: warning: type <type3> is used, but is not associated to any symbol
4.28-34: warning: type <type4> is used, but is not associated to any symbol
*** Undefined but unused symbols
Bison used to raise an error for undefined symbols that are not used in
the grammar. This is now only a warning.
%printer {} symbol1
%destructor {} symbol2
%type <type> symbol3
%%
exp: "a";
*** Useless destructors or printers
Bison now warns about useless destructors or printers. In the following
example, the printer for <type1>, and the destructor for <type2> are
useless: all symbols of <type1> (token1) already have a printer, and all
symbols of type <type2> (token2) already have a destructor.
%token <type1> token1
<type2> token2
<type3> token3
<type4> token4
%printer {} token1 <type1> <type3>
%destructor {} token2 <type2> <type4>
*** Conflicts
The warnings and error messages about shift/reduce and reduce/reduce
conflicts have been normalized. For instance on the following foo.y file:
%glr-parser
%%
exp: exp '+' exp | '0' | '0';
compare the previous version of bison:
$ bison foo.y
foo.y: conflicts: 1 shift/reduce, 2 reduce/reduce
$ bison -Werror foo.y
bison: warnings being treated as errors
foo.y: conflicts: 1 shift/reduce, 2 reduce/reduce
with the new behavior:
$ bison foo.y
foo.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
foo.y: warning: 2 reduce/reduce conflicts [-Wconflicts-rr]
$ bison -Werror foo.y
foo.y: error: 1 shift/reduce conflict [-Werror=conflicts-sr]
foo.y: error: 2 reduce/reduce conflicts [-Werror=conflicts-rr]
When %expect or %expect-rr is used, such as with bar.y:
%expect 0
%glr-parser
%%
exp: exp '+' exp | '0' | '0';
Former behavior:
$ bison bar.y
bar.y: conflicts: 1 shift/reduce, 2 reduce/reduce
bar.y: expected 0 shift/reduce conflicts
bar.y: expected 0 reduce/reduce conflicts
New one:
$ bison bar.y
bar.y: error: shift/reduce conflicts: 1 found, 0 expected
bar.y: error: reduce/reduce conflicts: 2 found, 0 expected
** Incompatibilities with POSIX Yacc
The 'yacc' category is no longer part of '-Wall', enable it explicitly
with '-Wyacc'.
** Additional yylex/yyparse arguments
The new directive %param declares additional arguments to both yylex and
yyparse. The %lex-param, %parse-param, and %param directives support one
or more arguments. Instead of
%lex-param {arg1_type *arg1}
%lex-param {arg2_type *arg2}
%parse-param {arg1_type *arg1}
%parse-param {arg2_type *arg2}
one may now declare
%param {arg1_type *arg1} {arg2_type *arg2}
** Types of values for %define variables
Bison used to make no difference between '%define foo bar' and '%define
foo "bar"'. The former is now called a 'keyword value', and the latter a
'string value'. A third kind was added: 'code values', such as '%define
foo {bar}'.
Keyword variables are used for fixed value sets, e.g.,
%define lr.type lalr
Code variables are used for value in the target language, e.g.,
%define api.value.type {struct semantic_type}
String variables are used remaining cases, e.g. file names.
** Variable api.token.prefix
The variable api.token.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.token.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.value.type
This new %define variable supersedes the #define macro YYSTYPE. The use
of YYSTYPE is discouraged. In particular, #defining YYSTYPE *and* either
using %union or %defining api.value.type results in undefined behavior.
Either define api.value.type, or use "%union":
%union
{
int ival;
char *sval;
}
%token <ival> INT "integer"
%token <sval> STRING "string"
%printer { fprintf (yyo, "%d", $$); } <ival>
%destructor { free ($$); } <sval>
/* In yylex(). */
yylval.ival = 42; return INT;
yylval.sval = "42"; return STRING;
The %define variable api.value.type supports both keyword and code values.
The keyword value 'union' means that the user provides genuine types, not
union member names such as "ival" and "sval" above (WARNING: will fail if
-y/--yacc/%yacc is enabled).
%define api.value.type union
%token <int> INT "integer"
%token <char *> STRING "string"
%printer { fprintf (yyo, "%d", $$); } <int>
%destructor { free ($$); } <char *>
/* In yylex(). */
yylval.INT = 42; return INT;
yylval.STRING = "42"; return STRING;
The keyword value variant is somewhat equivalent, but for C++ special
provision is made to allow classes to be used (more about this below).
%define api.value.type variant
%token <int> INT "integer"
%token <std::string> STRING "string"
Code values (in braces) denote user defined types. This is where YYSTYPE
used to be used.
%code requires
{
struct my_value
{
enum
{
is_int, is_string
} kind;
union
{
int ival;
char *sval;
} u;
};
}
%define api.value.type {struct my_value}
%token <u.ival> INT "integer"
%token <u.sval> STRING "string"
%printer { fprintf (yyo, "%d", $$); } <u.ival>
%destructor { free ($$); } <u.sval>
/* In yylex(). */
yylval.u.ival = 42; return INT;
yylval.u.sval = "42"; return STRING;
** Variable parse.error
This variable controls the verbosity of error messages. The use of the
%error-verbose directive is deprecated in favor of "%define parse.error
verbose".
** Renamed %define variables
The following variables have been renamed for consistency. Backward
compatibility is ensured, but upgrading is recommended.
lr.default-reductions -> lr.default-reduction
lr.keep-unreachable-states -> lr.keep-unreachable-state
namespace -> api.namespace
stype -> api.value.type
** Semantic predicates
Contributed by Paul Hilfinger.
The new, experimental, semantic-predicate feature allows actions of the
form "%?{ BOOLEAN-EXPRESSION }", which cause syntax errors (as for
YYERROR) if the expression evaluates to 0, and are evaluated immediately
in GLR parsers, rather than being deferred. The result is that they allow
the programmer to prune possible parses based on the values of run-time
expressions.
** The directive %expect-rr is now an error in non GLR mode
It used to be an error only if used in non GLR mode, _and_ if there are
reduce/reduce conflicts.
** Tokens are numbered in their order of appearance
Contributed by Valentin Tolmer.
With '%token A B', A had a number less than the one of B. However,
precedence declarations used to generate a reversed order. This is now
fixed, and introducing tokens with any of %token, %left, %right,
%precedence, or %nonassoc yields the same result.
When mixing declarations of tokens with a litteral character (e.g., 'a')
or with an identifier (e.g., B) in a precedence declaration, Bison
numbered the litteral characters first. For example
%right A B 'c' 'd'
would lead to the tokens declared in this order: 'c' 'd' A B. Again, the
input order is now preserved.
These changes were made so that one can remove useless precedence and
associativity declarations (i.e., map %nonassoc, %left or %right to
%precedence, or to %token) and get exactly the same output.
** Useless precedence and associativity
Contributed by Valentin Tolmer.
When developing and maintaining a grammar, useless associativity and
precedence directives are common. They can be a nuisance: new ambiguities
arising are sometimes masked because their conflicts are resolved due to
the extra precedence or associativity information. Furthermore, it can
hinder the comprehension of a new grammar: one will wonder about the role
of a precedence, where in fact it is useless. The following changes aim
at detecting and reporting these extra directives.
*** Precedence warning category
A new category of warning, -Wprecedence, was introduced. It flags the
useless precedence and associativity directives.
*** Useless associativity
Bison now warns about symbols with a declared associativity that is never
used to resolve conflicts. In that case, using %precedence is sufficient;
the parsing tables will remain unchanged. Solving these warnings may raise
useless precedence warnings, as the symbols no longer have associativity.
For example:
%left '+'
%left '*'
%%
exp:
"number"
| exp '+' "number"
| exp '*' exp
;
will produce a
warning: useless associativity for '+', use %precedence [-Wprecedence]
%left '+'
^^^
*** Useless precedence
Bison now warns about symbols with a declared precedence and no declared
associativity (i.e., declared with %precedence), and whose precedence is
never used. In that case, the symbol can be safely declared with %token
instead, without modifying the parsing tables. For example:
%precedence '='
%%
exp: "var" '=' "number";
will produce a
warning: useless precedence for '=' [-Wprecedence]
%precedence '='
^^^
*** Useless precedence and associativity
In case of both useless precedence and associativity, the issue is flagged
as follows:
%nonassoc '='
%%
exp: "var" '=' "number";
The warning is:
warning: useless precedence and associativity for '=' [-Wprecedence]
%nonassoc '='
^^^
** Empty rules
With help from Joel E. Denny and Gabriel Rassoul.
Empty rules (i.e., with an empty right-hand side) can now be explicitly
marked by the new %empty directive. Using %empty on a non-empty rule is
an error. The new -Wempty-rule warning reports empty rules without
%empty. On the following grammar:
%%
s: a b c;
a: ;
b: %empty;
c: 'a' %empty;
bison reports:
3.4-5: warning: empty rule without %empty [-Wempty-rule]
a: {}
^^
5.8-13: error: %empty on non-empty rule
c: 'a' %empty {};
^^^^^^
** Java skeleton improvements
The constants for token names were moved to the Lexer interface. Also, it
is possible to add code to the parser's constructors using "%code init"
and "%define init_throws".
Contributed by Paolo Bonzini.
The Java skeleton now supports push parsing.
Contributed by Dennis Heimbigner.
** C++ skeletons improvements
*** The parser header is no longer mandatory (lalr1.cc, glr.cc)
Using %defines is now optional. Without it, the needed support classes
are defined in the generated parser, instead of additional files (such as
location.hh, position.hh and stack.hh).
*** Locations are no longer mandatory (lalr1.cc, glr.cc)
Both lalr1.cc and glr.cc no longer require %location.
*** syntax_error exception (lalr1.cc)
The C++ parser features a syntax_error exception, which can be
thrown from the scanner or from user rules to raise syntax errors.
This facilitates reporting errors caught in sub-functions (e.g.,
rejecting too large integral literals from a conversion function
used by the scanner, or rejecting invalid combinations from a
factory invoked by the user actions).
*** %define api.value.type variant
This is based on a submission from Michiel De Wilde. With help
from Théophile Ranquet.
In this mode, complex C++ objects can be used as semantic values. For
instance:
%token <::std::string> TEXT;
%token <int> NUMBER;
%token SEMICOLON ";"
%type <::std::string> item;
%type <::std::list<std::string>> list;
%%
result:
list { std::cout << $1 << std::endl; }
;
list:
%empty { /* Generates an empty string list. */ }
| list item ";" { std::swap ($$, $1); $$.push_back ($2); }
;
item:
TEXT { std::swap ($$, $1); }
| NUMBER { $$ = string_cast ($1); }
;
*** %define api.token.constructor
When variants are enabled, Bison can generate functions to build the
tokens. This guarantees that the token type (e.g., NUMBER) is consistent
with the semantic value (e.g., int):
parser::symbol_type yylex ()
{
parser::location_type loc = ...;
...
return parser::make_TEXT ("Hello, world!", loc);
...
return parser::make_NUMBER (42, loc);
...
return parser::make_SEMICOLON (loc);
...
}
*** C++ locations
There are operator- and operator-= for 'location'. Negative line/column
increments can no longer underflow the resulting value.
* Noteworthy changes in release 2.7 (2012-12-12) [stable]
** Bug fixes
Warnings about uninitialized yylloc in yyparse have been fixed.
Restored C90 compliance (yet no report was ever made).
** Diagnostics are improved
*** Changes in the format of error messages
This used to be the format of many error reports:
input.y:2.7-12: %type redeclaration for exp
input.y:1.7-12: previous declaration
It is now:
input.y:2.7-12: error: %type redeclaration for exp
input.y:1.7-12: previous declaration
*** New format for error reports: carets
Caret errors have been added to Bison:
input.y:2.7-12: error: %type redeclaration for exp
%type <sval> exp
^^^^^^
input.y:1.7-12: previous declaration
%type <ival> exp
^^^^^^
or
input.y:3.20-23: error: ambiguous reference: '$exp'
exp: exp '+' exp { $exp = $1 + $3; };
^^^^
input.y:3.1-3: refers to: $exp at $$
exp: exp '+' exp { $exp = $1 + $3; };
^^^
input.y:3.6-8: refers to: $exp at $1
exp: exp '+' exp { $exp = $1 + $3; };
^^^
input.y:3.14-16: refers to: $exp at $3
exp: exp '+' exp { $exp = $1 + $3; };
^^^
The default behaviour for now is still not to display these unless
explictly asked with -fcaret (or -fall). However, in a later release, it
will be made the default behavior (but may still be deactivated with
-fno-caret).
** New value for %define variable: api.pure full
The %define variable api.pure requests a pure (reentrant) parser. However,
for historical reasons, using it in a location-tracking Yacc parser
resulted in a yyerror function that did not take a location as a
parameter. With this new value, the user may request a better pure parser,
where yyerror does take a location as a parameter (in location-tracking
parsers).
The use of "%define api.pure true" is deprecated in favor of this new
"%define api.pure full".
** New %define variable: api.location.type (glr.cc, lalr1.cc, lalr1.java)
The %define variable api.location.type defines the name of the type to use
for locations. When defined, Bison no longer generates the position.hh
and location.hh files, nor does the parser will include them: the user is
then responsible to define her type.
This can be used in programs with several parsers to factor their location
and position files: let one of them generate them, and the others just use
them.
This feature was actually introduced, but not documented, in Bison 2.5,
under the name "location_type" (which is maintained for backward
compatibility).
For consistency, lalr1.java's %define variables location_type and
position_type are deprecated in favor of api.location.type and
api.position.type.
** Exception safety (lalr1.cc)
The parse function now catches exceptions, uses the %destructors to
release memory (the lookahead symbol and the symbols pushed on the stack)
before re-throwing the exception.
This feature is somewhat experimental. User feedback would be
appreciated.
** Graph improvements in DOT and XSLT
The graphical presentation of the states is more readable: their shape is
now rectangular, the state number is clearly displayed, and the items are
numbered and left-justified.
The reductions are now explicitly represented as transitions to other
diamond shaped nodes.
These changes are present in both --graph output and xml2dot.xsl XSLT
processing, with minor (documented) differences.
** %language is no longer an experimental feature.
The introduction of this feature, in 2.4, was four years ago. The
--language option and the %language directive are no longer experimental.
** Documentation
The sections about shift/reduce and reduce/reduce conflicts resolution
have been fixed and extended.
Although introduced more than four years ago, XML and Graphviz reports
were not properly documented.
The translation of mid-rule actions is now described.
* Noteworthy changes in release 2.6.5 (2012-11-07) [stable]
We consider compiler warnings about Bison generated parsers to be bugs.
Rather than working around them in your own project, please consider
reporting them to us.
** Bug fixes
Warnings about uninitialized yylval and/or yylloc for push parsers with a
pure interface have been fixed for GCC 4.0 up to 4.8, and Clang 2.9 to
3.2.
Other issues in the test suite have been addressed.
Nul characters are correctly displayed in error messages.
When possible, yylloc is correctly initialized before calling yylex. It
is no longer necessary to initialize it in the %initial-action.
* Noteworthy changes in release 2.6.4 (2012-10-23) [stable]
Bison 2.6.3's --version was incorrect. This release fixes this issue.
* Noteworthy changes in release 2.6.3 (2012-10-22) [stable]
** Bug fixes
Bugs and portability issues in the test suite have been fixed.
Some errors in translations have been addressed, and --help now directs
users to the appropriate place to report them.
Stray Info files shipped by accident are removed.
Incorrect definitions of YY_, issued by yacc.c when no parser header is
generated, are removed.
All the generated headers are self-contained.
** Header guards (yacc.c, glr.c, glr.cc)
In order to avoid collisions, the header guards are now
YY_<PREFIX>_<FILE>_INCLUDED, instead of merely <PREFIX>_<FILE>.
For instance the header generated from
%define api.prefix "calc"
%defines "lib/parse.h"
will use YY_CALC_LIB_PARSE_H_INCLUDED as guard.
** Fix compiler warnings in the generated parser (yacc.c, glr.c)
The compilation of pure parsers (%define api.pure) can trigger GCC
warnings such as:
input.c: In function 'yyparse':
input.c:1503:12: warning: 'yylval' may be used uninitialized in this
function [-Wmaybe-uninitialized]
*++yyvsp = yylval;
^
This is now fixed; pragmas to avoid these warnings are no longer needed.
Warnings from clang ("equality comparison with extraneous parentheses" and
"function declared 'noreturn' should not return") have also been
addressed.
* Bug fixes
Buffer overruns, complaints from Flex, and portability issues in the test
suite have been fixed.
* Spaces in %lex- and %parse-param (lalr1.cc, glr.cc)
Trailing end-of-lines in %parse-param or %lex-param would result in
invalid C++. This is fixed.
* Spurious spaces and end-of-lines
The generated files no longer end (nor start) with empty lines.
* Noteworthy changes in release 2.6 (2012-07-19) [stable]
** Future Changes
The next major release of Bison will drop support for the following
deprecated features. Please report disagreements to bug-bison@gnu.org.
*** K&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
compilers.
*** Features deprecated since Bison 1.875
The definitions of yystype and yyltype will be removed; use YYSTYPE and
YYLTYPE.
YYPARSE_PARAM and YYLEX_PARAM, deprecated in favor of %parse-param and
%lex-param, will no longer be supported.
Support for the preprocessor symbol YYERROR_VERBOSE will be removed, use
%error-verbose.
*** The generated header will be included (yacc.c)
Instead of duplicating the content of the generated header (definition of
YYSTYPE, yyparse declaration etc.), the generated parser will include it,
as is already the case for GLR or C++ parsers. This change is deferred
because existing versions of ylwrap (e.g., Automake 1.12.1) do not support
it.
** Generated Parser Headers
*** Guards (yacc.c, glr.c, glr.cc)
The generated headers are now guarded, as is already the case for C++
parsers (lalr1.cc). For instance, with --defines=foo.h:
#ifndef YY_FOO_H
# define YY_FOO_H
...
#endif /* !YY_FOO_H */
*** New declarations (yacc.c, glr.c)
The generated header now declares yydebug and yyparse. Both honor
--name-prefix=bar_, and yield
int bar_parse (void);
rather than
#define yyparse bar_parse
int yyparse (void);
in order to facilitate the inclusion of several parser headers inside a
single compilation unit.
*** Exported symbols in C++
The symbols YYTOKEN_TABLE and YYERROR_VERBOSE, which were defined in the
header, are removed, as they prevent the possibility of including several
generated headers from a single compilation unit.
*** YYLSP_NEEDED
For the same reasons, the undocumented and unused macro YYLSP_NEEDED is no
longer defined.
** New %define variable: api.prefix
Now that the generated headers are more complete and properly protected
against multiple inclusions, constant names, such as YYSTYPE are a
problem. While yyparse and others are properly renamed by %name-prefix,
YYSTYPE, YYDEBUG and others have never been affected by it. Because it
would introduce backward compatibility issues in projects not expecting
YYSTYPE to be renamed, instead of changing the behavior of %name-prefix,
it is deprecated in favor of a new %define variable: api.prefix.
The following examples compares both:
%name-prefix "bar_" | %define api.prefix "bar_"
%token <ival> FOO %token <ival> FOO
%union { int ival; } %union { int ival; }
%% %%
exp: 'a'; exp: 'a';
bison generates:
#ifndef BAR_FOO_H #ifndef BAR_FOO_H
# define BAR_FOO_H # define BAR_FOO_H
/* Enabling traces. */ /* Enabling traces. */
# ifndef YYDEBUG | # ifndef BAR_DEBUG
> # if defined YYDEBUG
> # if YYDEBUG
> # define BAR_DEBUG 1
> # else
> # define BAR_DEBUG 0
> # endif
> # else
# define YYDEBUG 0 | # define BAR_DEBUG 0
> # endif
# endif | # endif
# if YYDEBUG | # if BAR_DEBUG
extern int bar_debug; extern int bar_debug;
# endif # endif
/* Tokens. */ /* Tokens. */
# ifndef YYTOKENTYPE | # ifndef BAR_TOKENTYPE
# define YYTOKENTYPE | # define BAR_TOKENTYPE
enum yytokentype { | enum bar_tokentype {
FOO = 258 FOO = 258
}; };
# endif # endif
#if ! defined YYSTYPE \ | #if ! defined BAR_STYPE \
&& ! defined YYSTYPE_IS_DECLARED | && ! defined BAR_STYPE_IS_DECLARED
typedef union YYSTYPE | typedef union BAR_STYPE
{ {
int ival; int ival;
} YYSTYPE; | } BAR_STYPE;
# define YYSTYPE_IS_DECLARED 1 | # define BAR_STYPE_IS_DECLARED 1
#endif #endif
extern YYSTYPE bar_lval; | extern BAR_STYPE bar_lval;
int bar_parse (void); int bar_parse (void);
#endif /* !BAR_FOO_H */ #endif /* !BAR_FOO_H */
* Noteworthy changes in release 2.5.1 (2012-06-05) [stable]
** Future changes:
The next major release will drop support for generating parsers in K&R C.
** yacc.c: YYBACKUP works as expected.
** glr.c improvements:
*** Location support is eliminated when not requested:
GLR parsers used to include location-related code even when locations were
not requested, and therefore not even usable.
*** __attribute__ is preserved:
__attribute__ is no longer disabled when __STRICT_ANSI__ is defined (i.e.,
when -std is passed to GCC).
** lalr1.java: several fixes:
The Java parser no longer throws ArrayIndexOutOfBoundsException if the
first token leads to a syntax error. Some minor clean ups.
** Changes for C++:
*** C++11 compatibility:
C and C++ parsers use "nullptr" instead of "0" when __cplusplus is 201103L
or higher.
*** Header guards
The header files such as "parser.hh", "location.hh", etc. used a constant
name for preprocessor guards, for instance:
#ifndef BISON_LOCATION_HH
# define BISON_LOCATION_HH
...
#endif // !BISON_LOCATION_HH
The inclusion guard is now computed from "PREFIX/FILE-NAME", where lower
case characters are converted to upper case, and series of
non-alphanumerical characters are converted to an underscore.
With "bison -o lang++/parser.cc", "location.hh" would now include:
#ifndef YY_LANG_LOCATION_HH
# define YY_LANG_LOCATION_HH
...
#endif // !YY_LANG_LOCATION_HH
*** C++ locations:
The position and location constructors (and their initialize methods)
accept new arguments for line and column. Several issues in the
documentation were fixed.
** liby is no longer asking for "rpl_fprintf" on some platforms.
** Changes in the manual:
*** %printer is documented
The "%printer" directive, supported since at least Bison 1.50, is finally
documented. The "mfcalc" example is extended to demonstrate it.
For consistency with the C skeletons, the C++ parsers now also support
"yyoutput" (as an alias to "debug_stream ()").
*** Several improvements have been made:
The layout for grammar excerpts was changed to a more compact scheme.
Named references are motivated. The description of the automaton
description file (*.output) is updated to the current format. Incorrect
index entries were fixed. Some other errors were fixed.
** Building bison:
*** Conflicting prototypes with recent/modified Flex.
Fixed build problems with the current, unreleased, version of Flex, and
some modified versions of 2.5.35, which have modified function prototypes.
*** Warnings during the build procedure have been eliminated.
*** Several portability problems in the test suite have been fixed:
This includes warnings with some compilers, unexpected behavior of tools
such as diff, warning messages from the test suite itself, etc.
*** The install-pdf target work properly:
Running "make install-pdf" (or -dvi, -html, -info, and -ps) no longer
halts in the middle of its course.
* Changes in version 2.5 (2011-05-14):
** Grammar symbol names can now contain non-initial dashes:
Consistently with directives (such as %error-verbose) and with
%define variables (e.g. push-pull), grammar symbol names may contain
dashes in any position except the beginning. This is a GNU
extension over POSIX Yacc. Thus, use of this extension is reported
by -Wyacc and rejected in Yacc mode (--yacc).
** Named references:
Historically, Yacc and Bison have supported positional references
($n, $$) to allow access to symbol values from inside of semantic
actions code.
Starting from this version, Bison can also accept named references.
When no ambiguity is possible, original symbol names may be used
as named references:
if_stmt : "if" cond_expr "then" then_stmt ';'
{ $if_stmt = mk_if_stmt($cond_expr, $then_stmt); }
In the more common case, explicit names may be declared:
stmt[res] : "if" expr[cond] "then" stmt[then] "else" stmt[else] ';'
{ $res = mk_if_stmt($cond, $then, $else); }
Location information is also accessible using @name syntax. When
accessing symbol names containing dots or dashes, explicit bracketing
($[sym.1]) must be used.
These features are experimental in this version. More user feedback
will help to stabilize them.
** IELR(1) and canonical LR(1):
IELR(1) is a minimal LR(1) parser table generation algorithm. That
is, given any context-free grammar, IELR(1) generates parser tables
with the full language-recognition power of canonical LR(1) but with
nearly the same number of parser states as LALR(1). This reduction
in parser states is often an order of magnitude. More importantly,
because canonical LR(1)'s extra parser states may contain duplicate
conflicts in the case of non-LR(1) grammars, the number of conflicts
for IELR(1) is often an order of magnitude less as well. This can
significantly reduce the complexity of developing of a grammar.
Bison can now generate IELR(1) and canonical LR(1) parser tables in
place of its traditional LALR(1) parser tables, which remain the
default. You can specify the type of parser tables in the grammar
file with these directives:
%define lr.type lalr
%define lr.type ielr
%define lr.type canonical-lr
The default-reduction optimization in the parser tables can also be
adjusted using `%define lr.default-reductions'. For details on both
of these features, see the new section `Tuning LR' in the Bison
manual.
These features are experimental. More user feedback will help to
stabilize them.
** LAC (Lookahead Correction) for syntax error handling:
Canonical LR, IELR, and LALR can suffer from a couple of problems
upon encountering a syntax error. First, the parser might perform
additional parser stack reductions before discovering the syntax
error. Such reductions can perform user semantic actions that are
unexpected because they are based on an invalid token, and they
cause error recovery to begin in a different syntactic context than
the one in which the invalid token was encountered. Second, when
verbose error messages are enabled (with %error-verbose or the
obsolete `#define YYERROR_VERBOSE'), the expected token list in the
syntax error message can both contain invalid tokens and omit valid
tokens.
The culprits for the above problems are %nonassoc, default
reductions in inconsistent states, and parser state merging. Thus,
IELR and LALR suffer the most. Canonical LR can suffer only if
%nonassoc is used or if default reductions are enabled for
inconsistent states.
LAC is a new mechanism within the parsing algorithm that solves
these problems for canonical LR, IELR, and LALR without sacrificing
%nonassoc, default reductions, or state merging. When LAC is in
use, canonical LR and IELR behave almost exactly the same for both
syntactically acceptable and syntactically unacceptable input.
While LALR still does not support the full language-recognition
power of canonical LR and IELR, LAC at least enables LALR's syntax
error handling to correctly reflect LALR's language-recognition
power.
Currently, LAC is only supported for deterministic parsers in C.
You can enable LAC with the following directive:
%define parse.lac full
See the new section `LAC' in the Bison manual for additional
details including a few caveats.
LAC is an experimental feature. More user feedback will help to
stabilize it.
** %define improvements:
*** Can now be invoked via the command line:
Each of these command-line options
-D NAME[=VALUE]
--define=NAME[=VALUE]
-F NAME[=VALUE]
--force-define=NAME[=VALUE]
is equivalent to this grammar file declaration
%define NAME ["VALUE"]
except that the manner in which Bison processes multiple definitions
for the same NAME differs. Most importantly, -F and --force-define
quietly override %define, but -D and --define do not. For further
details, see the section `Bison Options' in the Bison manual.
*** Variables renamed:
The following %define variables
api.push_pull
lr.keep_unreachable_states
have been renamed to
api.push-pull
lr.keep-unreachable-states
The old names are now deprecated but will be maintained indefinitely
for backward compatibility.
*** Values no longer need to be quoted in the grammar file:
If a %define value is an identifier, it no longer needs to be placed
within quotations marks. For example,
%define api.push-pull "push"
can be rewritten as
%define api.push-pull push
*** Unrecognized variables are now errors not warnings.
*** Multiple invocations for any variable is now an error not a warning.
** Unrecognized %code qualifiers are now errors not warnings.
** Character literals not of length one:
Previously, Bison quietly converted all character literals to length
one. For example, without warning, Bison interpreted the operators in
the following grammar to be the same token:
exp: exp '++'
| exp '+' exp
;
Bison now warns when a character literal is not of length one. In
some future release, Bison will start reporting an error instead.
** Destructor calls fixed for lookaheads altered in semantic actions:
Previously for deterministic parsers in C, if a user semantic action
altered yychar, the parser in some cases used the old yychar value to
determine which destructor to call for the lookahead upon a syntax
error or upon parser return. This bug has been fixed.
** C++ parsers use YYRHSLOC:
Similarly to the C parsers, the C++ parsers now define the YYRHSLOC
macro and use it in the default YYLLOC_DEFAULT. You are encouraged
to use it. If, for instance, your location structure has `first'
and `last' members, instead of
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (N) \
{ \
(Current).first = (Rhs)[1].location.first; \
(Current).last = (Rhs)[N].location.last; \
} \
else \
{ \
(Current).first = (Current).last = (Rhs)[0].location.last; \
} \
while (false)
use:
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (N) \
{ \
(Current).first = YYRHSLOC (Rhs, 1).first; \
(Current).last = YYRHSLOC (Rhs, N).last; \
} \
else \
{ \
(Current).first = (Current).last = YYRHSLOC (Rhs, 0).last; \
} \
while (false)
** YYLLOC_DEFAULT in C++:
The default implementation of YYLLOC_DEFAULT used to be issued in
the header file. It is now output in the implementation file, after
the user %code sections so that its #ifndef guard does not try to
override the user's YYLLOC_DEFAULT if provided.
** YYFAIL now produces warnings and Java parsers no longer implement it:
YYFAIL has existed for many years as an undocumented feature of
deterministic parsers in C generated by Bison. More recently, it was
a documented feature of Bison's experimental Java parsers. As
promised in Bison 2.4.2's NEWS entry, any appearance of YYFAIL in a
semantic action now produces a deprecation warning, and Java parsers
no longer implement YYFAIL at all. For further details, including a
discussion of how to suppress C preprocessor warnings about YYFAIL
being unused, see the Bison 2.4.2 NEWS entry.
** Temporary hack for adding a semicolon to the user action:
Previously, Bison appended a semicolon to every user action for
reductions when the output language defaulted to C (specifically, when
neither %yacc, %language, %skeleton, or equivalent command-line
options were specified). This allowed actions such as
exp: exp "+" exp { $$ = $1 + $3 };
instead of
exp: exp "+" exp { $$ = $1 + $3; };
As a first step in removing this misfeature, Bison now issues a
warning when it appends a semicolon. Moreover, in cases where Bison
cannot easily determine whether a semicolon is needed (for example, an
action ending with a cpp directive or a braced compound initializer),
it no longer appends one. Thus, the C compiler might now complain
about a missing semicolon where it did not before. Future releases of
Bison will cease to append semicolons entirely.
** Verbose syntax error message fixes:
When %error-verbose or the obsolete `#define YYERROR_VERBOSE' is
specified, syntax error messages produced by the generated parser
include the unexpected token as well as a list of expected tokens.
The effect of %nonassoc on these verbose messages has been corrected
in two ways, but a more complete fix requires LAC, described above:
*** When %nonassoc is used, there can exist parser states that accept no
tokens, and so the parser does not always require a lookahead token
in order to detect a syntax error. Because no unexpected token or
expected tokens can then be reported, the verbose syntax error
message described above is suppressed, and the parser instead
reports the simpler message, `syntax error'. Previously, this
suppression was sometimes erroneously triggered by %nonassoc when a
lookahead was actually required. Now verbose messages are
suppressed only when all previous lookaheads have already been
shifted or discarded.
*** Previously, the list of expected tokens erroneously included tokens
that would actually induce a syntax error because conflicts for them
were resolved with %nonassoc in the current parser state. Such
tokens are now properly omitted from the list.
*** Expected token lists are still often wrong due to state merging
(from LALR or IELR) and default reductions, which can both add
invalid tokens and subtract valid tokens. Canonical LR almost
completely fixes this problem by eliminating state merging and
default reductions. However, there is one minor problem left even
when using canonical LR and even after the fixes above. That is,
if the resolution of a conflict with %nonassoc appears in a later
parser state than the one at which some syntax error is
discovered, the conflicted token is still erroneously included in
the expected token list. Bison's new LAC implementation,
described above, eliminates this problem and the need for
canonical LR. However, LAC is still experimental and is disabled
by default.
** Java skeleton fixes:
*** A location handling bug has been fixed.
*** The top element of each of the value stack and location stack is now
cleared when popped so that it can be garbage collected.
*** Parser traces now print the top element of the stack.
** -W/--warnings fixes:
*** Bison now properly recognizes the `no-' versions of categories:
For example, given the following command line, Bison now enables all
warnings except warnings for incompatibilities with POSIX Yacc:
bison -Wall,no-yacc gram.y
*** Bison now treats S/R and R/R conflicts like other warnings:
Previously, conflict reports were independent of Bison's normal
warning system. Now, Bison recognizes the warning categories
`conflicts-sr' and `conflicts-rr'. This change has important
consequences for the -W and --warnings command-line options. For
example:
bison -Wno-conflicts-sr gram.y # S/R conflicts not reported
bison -Wno-conflicts-rr gram.y # R/R conflicts not reported
bison -Wnone gram.y # no conflicts are reported
bison -Werror gram.y # any conflict is an error
However, as before, if the %expect or %expect-rr directive is
specified, an unexpected number of conflicts is an error, and an
expected number of conflicts is not reported, so -W and --warning
then have no effect on the conflict report.
*** The `none' category no longer disables a preceding `error':
For example, for the following command line, Bison now reports
errors instead of warnings for incompatibilities with POSIX Yacc:
bison -Werror,none,yacc gram.y
*** The `none' category now disables all Bison warnings:
Previously, the `none' category disabled only Bison warnings for
which there existed a specific -W/--warning category. However,
given the following command line, Bison is now guaranteed to
suppress all warnings:
bison -Wnone gram.y
** Precedence directives can now assign token number 0:
Since Bison 2.3b, which restored the ability of precedence
directives to assign token numbers, doing so for token number 0 has
produced an assertion failure. For example:
%left END 0
This bug has been fixed.
* Changes in version 2.4.3 (2010-08-05):
** Bison now obeys -Werror and --warnings=error for warnings about
grammar rules that are useless in the parser due to conflicts.
** Problems with spawning M4 on at least FreeBSD 8 and FreeBSD 9 have
been fixed.
** Failures in the test suite for GCC 4.5 have been fixed.
** Failures in the test suite for some versions of Sun Studio C++ have
been fixed.
** Contrary to Bison 2.4.2's NEWS entry, it has been decided that
warnings about undefined %prec identifiers will not be converted to
errors in Bison 2.5. They will remain warnings, which should be
sufficient for POSIX while avoiding backward compatibility issues.
** Minor documentation fixes.
* Changes in version 2.4.2 (2010-03-20):
** Some portability problems that resulted in failures and livelocks
in the test suite on some versions of at least Solaris, AIX, HP-UX,
RHEL4, and Tru64 have been addressed. As a result, fatal Bison
errors should no longer cause M4 to report a broken pipe on the
affected platforms.
** `%prec IDENTIFIER' requires IDENTIFIER to be defined separately.
POSIX specifies that an error be reported for any identifier that does
not appear on the LHS of a grammar rule and that is not defined by
%token, %left, %right, or %nonassoc. Bison 2.3b and later lost this
error report for the case when an identifier appears only after a
%prec directive. It is now restored. However, for backward
compatibility with recent Bison releases, it is only a warning for
now. In Bison 2.5 and later, it will return to being an error.
** Detection of GNU M4 1.4.6 or newer during configure is improved.
** Warnings from gcc's -Wundef option about undefined YYENABLE_NLS,
YYLTYPE_IS_TRIVIAL, and __STRICT_ANSI__ in C/C++ parsers are now
avoided.
** %code is now a permanent feature.
A traditional Yacc prologue directive is written in the form:
%{CODE%}
To provide a more flexible alternative, Bison 2.3b introduced the
%code directive with the following forms for C/C++:
%code {CODE}
%code requires {CODE}
%code provides {CODE}
%code top {CODE}
These forms are now considered permanent features of Bison. See the
%code entries in the section "Bison Declaration Summary" in the Bison
manual for a summary of their functionality. See the section
"Prologue Alternatives" for a detailed discussion including the
advantages of %code over the traditional Yacc prologue directive.
Bison's Java feature as a whole including its current usage of %code
is still considered experimental.
** YYFAIL is deprecated and will eventually be removed.
YYFAIL has existed for many years as an undocumented feature of
deterministic parsers in C generated by Bison. Previously, it was
documented for Bison's experimental Java parsers. YYFAIL is no longer
documented for Java parsers and is formally deprecated in both cases.
Users are strongly encouraged to migrate to YYERROR, which is
specified by POSIX.
Like YYERROR, you can invoke YYFAIL from a semantic action in order to
induce a syntax error. The most obvious difference from YYERROR is
that YYFAIL will automatically invoke yyerror to report the syntax
error so that you don't have to. However, there are several other
subtle differences between YYERROR and YYFAIL, and YYFAIL suffers from
inherent flaws when %error-verbose or `#define YYERROR_VERBOSE' is
used. For a more detailed discussion, see:
http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html
The upcoming Bison 2.5 will remove YYFAIL from Java parsers, but
deterministic parsers in C will continue to implement it. However,
because YYFAIL is already flawed, it seems futile to try to make new
Bison features compatible with it. Thus, during parser generation,
Bison 2.5 will produce a warning whenever it discovers YYFAIL in a
rule action. In a later release, YYFAIL will be disabled for
%error-verbose and `#define YYERROR_VERBOSE'. Eventually, YYFAIL will
be removed altogether.
There exists at least one case where Bison 2.5's YYFAIL warning will
be a false positive. Some projects add phony uses of YYFAIL and other
Bison-defined macros for the sole purpose of suppressing C
preprocessor warnings (from GCC cpp's -Wunused-macros, for example).
To avoid Bison's future warning, such YYFAIL uses can be moved to the
epilogue (that is, after the second `%%') in the Bison input file. In
this release (2.4.2), Bison already generates its own code to suppress
C preprocessor warnings for YYFAIL, so projects can remove their own
phony uses of YYFAIL if compatibility with Bison releases prior to
2.4.2 is not necessary.
** Internationalization.
Fix a regression introduced in Bison 2.4: Under some circumstances,
message translations were not installed although supported by the
host system.
The tools framework changed m4 on Darwin<9 from the native one to the
pkgsrc version last month. bison needs a PKGREVISION bump because it
embeds the path to m4 in its binary.
* Changes in version 2.4.1 (2008-12-11):
** In the GLR defines file, unexpanded M4 macros in the yylval and yylloc
declarations have been fixed.
** Temporary hack for adding a semicolon to the user action.
Bison used to prepend a trailing semicolon at the end of the user
action for reductions. This allowed actions such as
exp: exp "+" exp { $$ = $1 + $3 };
instead of
exp: exp "+" exp { $$ = $1 + $3; };
Some grammars still depend on this `feature'. Bison 2.4.1 restores
the previous behavior in the case of C output (specifically, when
neither %language or %skeleton or equivalent command-line options
are used) to leave more time for grammars depending on the old
behavior to be adjusted. Future releases of Bison will disable this
feature.
** A few minor improvements to the Bison manual.
a recent enough version of gettext(3) e.g. Mac OS X or Linux. Dynamically
adjust the package list depending on the configure result.
Bump the package revisions because the package list was incorrect on
various platforms.
