X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/34a6c2d19b85d4650b2d90f60b76d44071d167d1..a6e5a28079865c4924194685723962f198fd33ff:/NEWS?ds=inline

diff --git a/NEWS b/NEWS
index 91bde870..423cd7e0 100644
--- a/NEWS
+++ b/NEWS
@@ -3,13 +3,46 @@ Bison News
 
 * Changes in version 2.5 (????-??-??):
 
-** IELR(1) and Canonical LR(1) Support
+** 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,
+  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
@@ -20,33 +53,186 @@ Bison News
   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"
+    %define lr.type lalr
+    %define lr.type ielr
+    %define lr.type canonical-lr
 
-  The default rules optimization in the parser tables can also be
-  adjusted using `%define lr.default_rules'.  See the documentation for
-  `%define lr.type' and `%define lr.default_rules' in the section `Bison
-  Declaration Summary' in the Bison manual for the details.
+  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.
 
-** %define can now be invoked via the command line.
+** 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
 
-  Each of these bison command-line options
+  See the new section `LAC' in the Bison manual for additional
+  details including a few caveats.
 
-    -D NAME=VALUE
-    --define=NAME=VALUE
+  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"
+    %define NAME ["VALUE"]
 
-  for any NAME and VALUE.  Omitting `=VALUE' on the command line is
-  equivalent to omitting `"VALUE"' in the declaration.
+  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.
 
-** Temporary hack for adding a semicolon to the user action.
+*** 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 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
@@ -67,7 +253,166 @@ Bison News
   about a missing semicolon where it did not before.  Future releases of
   Bison will cease to append semicolons entirely.
 
-* Changes in version 2.4.2 (????-??-??):
+** 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.
+
+* 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.
+  [Between the 2.4.2 and 2.4.3 releases, it was decided that this
+  warning will not be converted to an error in Bison 2.5.]
+
+** 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.
 
 * Changes in version 2.4.1 (2008-12-11):
 
@@ -1116,8 +1461,7 @@ End:
 
 -----
 
-Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
-2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright (C) 1995-2011 Free Software Foundation, Inc.
 
 This file is part of Bison, the GNU Parser Generator.