]> git.saurik.com Git - bison.git/blame_incremental - NEWS
Fix %error-verbose for conflicts resolved by %nonassoc.
[bison.git] / NEWS
... / ...
CommitLineData
1Bison News
2----------
3
4* Changes in version ?.? (????-??-??):
5
6** Java skeleton improvements:
7
8 The constants for token names were moved to the Lexer interface.
9 Also, it is possible to add code to the parser's constructors using
10 "%code init" and "%define init_throws".
11
12** Variable api.tokens.prefix
13
14 The variable api.tokens.prefix changes the way tokens are identified in
15 the generated files. This is especially useful to avoid collisions
16 with identifiers in the target language. For instance
17
18 %token FILE for ERROR
19 %define api.tokens.prefix "TOK_"
20 %%
21 start: FILE for ERROR;
22
23 will generate the definition of the symbols TOK_FILE, TOK_for, and
24 TOK_ERROR in the generated sources. In particular, the scanner must
25 use these prefixed token names, although the grammar itself still
26 uses the short names (as in the sample rule given above).
27
28** Variable api.namespace
29
30 The "namespace" variable is renamed "api.namespace". Backward
31 compatibility is ensured, but upgrading is recommended.
32
33** Variable parse.error
34
35 The variable error controls the verbosity of error messages. The
36 use of the %error-verbose directive is deprecated in favor of
37 %define parse.error "verbose".
38
39* Changes in version 2.5 (????-??-??):
40
41** IELR(1) and Canonical LR(1) Support
42
43 IELR(1) is a minimal LR(1) parser table generation algorithm. That
44 is, given any context-free grammar, IELR(1) generates parser tables
45 with the full language recognition power of canonical LR(1) but with
46 nearly the same number of parser states as LALR(1). This reduction in
47 parser states is often an order of magnitude. More importantly,
48 because canonical LR(1)'s extra parser states may contain duplicate
49 conflicts in the case of non-LR(1) grammars, the number of conflicts
50 for IELR(1) is often an order of magnitude less as well. This can
51 significantly reduce the complexity of developing of a grammar.
52
53 Bison can now generate IELR(1) and canonical LR(1) parser tables in
54 place of its traditional LALR(1) parser tables, which remain the
55 default. You can specify the type of parser tables in the grammar
56 file with these directives:
57
58 %define lr.type "LALR"
59 %define lr.type "IELR"
60 %define lr.type "canonical LR"
61
62 The default reduction optimization in the parser tables can also be
63 adjusted using `%define lr.default-reductions'. See the documentation
64 for `%define lr.type' and `%define lr.default-reductions' in the
65 section `Bison Declaration Summary' in the Bison manual for the
66 details.
67
68 These features are experimental. More user feedback will help to
69 stabilize them.
70
71** Multiple %define's for any variable is now an error not a warning.
72
73** %define can now be invoked via the command line.
74
75 Each of these command-line options
76
77 -D NAME[=VALUE]
78 --define=NAME[=VALUE]
79
80 -F NAME[=VALUE]
81 --force-define=NAME[=VALUE]
82
83 is equivalent to this grammar file declaration
84
85 %define NAME ["VALUE"]
86
87 except that the manner in which Bison processes multiple definitions
88 for the same NAME differs. Most importantly, -F and --force-define
89 quietly override %define, but -D and --define do not. For further
90 details, see the section "Bison Options" in the Bison manual.
91
92** %define variables renamed.
93
94 The following %define variables
95
96 api.push_pull
97 lr.keep_unreachable_states
98
99 have been renamed to
100
101 api.push-pull
102 lr.keep-unreachable-states
103
104 The old names are now deprecated but will be maintained indefinitely
105 for backward compatibility.
106
107** Symbols names
108
109 Consistently with directives (such as %error-verbose) and variables
110 (e.g. push-pull), symbol names may include dashes in any position,
111 similarly to periods and underscores. This is GNU extension over
112 POSIX Yacc whose use is reported by -Wyacc, and rejected in Yacc
113 mode (--yacc).
114
115** Temporary hack for adding a semicolon to the user action.
116
117 Previously, Bison appended a semicolon to every user action for
118 reductions when the output language defaulted to C (specifically, when
119 neither %yacc, %language, %skeleton, or equivalent command-line
120 options were specified). This allowed actions such as
121
122 exp: exp "+" exp { $$ = $1 + $3 };
123
124 instead of
125
126 exp: exp "+" exp { $$ = $1 + $3; };
127
128 As a first step in removing this misfeature, Bison now issues a
129 warning when it appends a semicolon. Moreover, in cases where Bison
130 cannot easily determine whether a semicolon is needed (for example, an
131 action ending with a cpp directive or a braced compound initializer),
132 it no longer appends one. Thus, the C compiler might now complain
133 about a missing semicolon where it did not before. Future releases of
134 Bison will cease to append semicolons entirely.
135
136** Character literals not of length one.
137
138 Previously, Bison quietly converted all character literals to length
139 one. For example, without warning, Bison interpreted the operators in
140 the following grammar to be the same token:
141
142 exp: exp '++'
143 | exp '+' exp
144 ;
145
146 Bison now warns when a character literal is not of length one. In
147 some future release, Bison will report an error instead.
148
149** Verbose error messages fixed for nonassociative tokens.
150
151 When %error-verbose is specified, syntax error messages produced by
152 the generated parser include the unexpected token as well as a list of
153 expected tokens. Previously, this list erroneously included tokens
154 that would actually induce a syntax error because conflicts for them
155 were resolved with %nonassoc. Such tokens are now properly omitted
156 from the list.
157
158* Changes in version 2.4.2 (????-??-??):
159
160** Detection of GNU M4 1.4.6 or newer during configure is improved.
161
162** %code is now a permanent feature.
163
164 A traditional Yacc prologue directive is written in the form:
165
166 %{CODE%}
167
168 To provide a more flexible alternative, Bison 2.3b introduced the
169 %code directive with the following forms for C/C++:
170
171 %code {CODE}
172 %code requires {CODE}
173 %code provides {CODE}
174 %code top {CODE}
175
176 These forms are now considered permanent features of Bison. See the
177 %code entries in the section "Bison Declaration Summary" in the Bison
178 manual for a summary of their functionality. See the section
179 "Prologue Alternatives" for a detailed discussion including the
180 advantages of %code over the traditional Yacc prologue directive.
181
182 Bison's Java feature as a whole including its current usage of %code
183 is still considered experimental.
184
185* Changes in version 2.4.1 (2008-12-11):
186
187** In the GLR defines file, unexpanded M4 macros in the yylval and yylloc
188 declarations have been fixed.
189
190** Temporary hack for adding a semicolon to the user action.
191
192 Bison used to prepend a trailing semicolon at the end of the user
193 action for reductions. This allowed actions such as
194
195 exp: exp "+" exp { $$ = $1 + $3 };
196
197 instead of
198
199 exp: exp "+" exp { $$ = $1 + $3; };
200
201 Some grammars still depend on this `feature'. Bison 2.4.1 restores
202 the previous behavior in the case of C output (specifically, when
203 neither %language or %skeleton or equivalent command-line options
204 are used) to leave more time for grammars depending on the old
205 behavior to be adjusted. Future releases of Bison will disable this
206 feature.
207
208** A few minor improvements to the Bison manual.
209
210* Changes in version 2.4 (2008-11-02):
211
212** %language is an experimental feature.
213
214 We first introduced this feature in test release 2.3b as a cleaner
215 alternative to %skeleton. Since then, we have discussed the possibility of
216 modifying its effect on Bison's output file names. Thus, in this release,
217 we consider %language to be an experimental feature that will likely evolve
218 in future releases.
219
220** Forward compatibility with GNU M4 has been improved.
221
222** Several bugs in the C++ skeleton and the experimental Java skeleton have been
223 fixed.
224
225* Changes in version 2.3b (2008-05-27):
226
227** The quotes around NAME that used to be required in the following directive
228 are now deprecated:
229
230 %define NAME "VALUE"
231
232** The directive `%pure-parser' is now deprecated in favor of:
233
234 %define api.pure
235
236 which has the same effect except that Bison is more careful to warn about
237 unreasonable usage in the latter case.
238
239** Push Parsing
240
241 Bison can now generate an LALR(1) parser in C with a push interface. That
242 is, instead of invoking `yyparse', which pulls tokens from `yylex', you can
243 push one token at a time to the parser using `yypush_parse', which will
244 return to the caller after processing each token. By default, the push
245 interface is disabled. Either of the following directives will enable it:
246
247 %define api.push_pull "push" // Just push; does not require yylex.
248 %define api.push_pull "both" // Push and pull; requires yylex.
249
250 See the new section `A Push Parser' in the Bison manual for details.
251
252 The current push parsing interface is experimental and may evolve. More user
253 feedback will help to stabilize it.
254
255** The -g and --graph options now output graphs in Graphviz DOT format,
256 not VCG format. Like --graph, -g now also takes an optional FILE argument
257 and thus cannot be bundled with other short options.
258
259** Java
260
261 Bison can now generate an LALR(1) parser in Java. The skeleton is
262 `data/lalr1.java'. Consider using the new %language directive instead of
263 %skeleton to select it.
264
265 See the new section `Java Parsers' in the Bison manual for details.
266
267 The current Java interface is experimental and may evolve. More user
268 feedback will help to stabilize it.
269
270** %language
271
272 This new directive specifies the programming language of the generated
273 parser, which can be C (the default), C++, or Java. Besides the skeleton
274 that Bison uses, the directive affects the names of the generated files if
275 the grammar file's name ends in ".y".
276
277** XML Automaton Report
278
279 Bison can now generate an XML report of the LALR(1) automaton using the new
280 `--xml' option. The current XML schema is experimental and may evolve. More
281 user feedback will help to stabilize it.
282
283** The grammar file may now specify the name of the parser header file using
284 %defines. For example:
285
286 %defines "parser.h"
287
288** When reporting useless rules, useless nonterminals, and unused terminals,
289 Bison now employs the terms "useless in grammar" instead of "useless",
290 "useless in parser" instead of "never reduced", and "unused in grammar"
291 instead of "unused".
292
293** Unreachable State Removal
294
295 Previously, Bison sometimes generated parser tables containing unreachable
296 states. A state can become unreachable during conflict resolution if Bison
297 disables a shift action leading to it from a predecessor state. Bison now:
298
299 1. Removes unreachable states.
300
301 2. Does not report any conflicts that appeared in unreachable states.
302 WARNING: As a result, you may need to update %expect and %expect-rr
303 directives in existing grammar files.
304
305 3. For any rule used only in such states, Bison now reports the rule as
306 "useless in parser due to conflicts".
307
308 This feature can be disabled with the following directive:
309
310 %define lr.keep_unreachable_states
311
312 See the %define entry in the `Bison Declaration Summary' in the Bison manual
313 for further discussion.
314
315** Lookahead Set Correction in the `.output' Report
316
317 When instructed to generate a `.output' file including lookahead sets
318 (using `--report=lookahead', for example), Bison now prints each reduction's
319 lookahead set only next to the associated state's one item that (1) is
320 associated with the same rule as the reduction and (2) has its dot at the end
321 of its RHS. Previously, Bison also erroneously printed the lookahead set
322 next to all of the state's other items associated with the same rule. This
323 bug affected only the `.output' file and not the generated parser source
324 code.
325
326** --report-file=FILE is a new option to override the default `.output' file
327 name.
328
329** The `=' that used to be required in the following directives is now
330 deprecated:
331
332 %file-prefix "parser"
333 %name-prefix "c_"
334 %output "parser.c"
335
336** An Alternative to `%{...%}' -- `%code QUALIFIER {CODE}'
337
338 Bison 2.3a provided a new set of directives as a more flexible alternative to
339 the traditional Yacc prologue blocks. Those have now been consolidated into
340 a single %code directive with an optional qualifier field, which identifies
341 the purpose of the code and thus the location(s) where Bison should generate
342 it:
343
344 1. `%code {CODE}' replaces `%after-header {CODE}'
345 2. `%code requires {CODE}' replaces `%start-header {CODE}'
346 3. `%code provides {CODE}' replaces `%end-header {CODE}'
347 4. `%code top {CODE}' replaces `%before-header {CODE}'
348
349 See the %code entries in section `Bison Declaration Summary' in the Bison
350 manual for a summary of the new functionality. See the new section `Prologue
351 Alternatives' for a detailed discussion including the advantages of %code
352 over the traditional Yacc prologues.
353
354 The prologue alternatives are experimental. More user feedback will help to
355 determine whether they should become permanent features.
356
357** Revised warning: unset or unused mid-rule values
358
359 Since Bison 2.2, Bison has warned about mid-rule values that are set but not
360 used within any of the actions of the parent rule. For example, Bison warns
361 about unused $2 in:
362
363 exp: '1' { $$ = 1; } '+' exp { $$ = $1 + $4; };
364
365 Now, Bison also warns about mid-rule values that are used but not set. For
366 example, Bison warns about unset $$ in the mid-rule action in:
367
368 exp: '1' { $1 = 1; } '+' exp { $$ = $2 + $4; };
369
370 However, Bison now disables both of these warnings by default since they
371 sometimes prove to be false alarms in existing grammars employing the Yacc
372 constructs $0 or $-N (where N is some positive integer).
373
374 To enable these warnings, specify the option `--warnings=midrule-values' or
375 `-W', which is a synonym for `--warnings=all'.
376
377** Default %destructor or %printer with `<*>' or `<>'
378
379 Bison now recognizes two separate kinds of default %destructor's and
380 %printer's:
381
382 1. Place `<*>' in a %destructor/%printer symbol list to define a default
383 %destructor/%printer for all grammar symbols for which you have formally
384 declared semantic type tags.
385
386 2. Place `<>' in a %destructor/%printer symbol list to define a default
387 %destructor/%printer for all grammar symbols without declared semantic
388 type tags.
389
390 Bison no longer supports the `%symbol-default' notation from Bison 2.3a.
391 `<*>' and `<>' combined achieve the same effect with one exception: Bison no
392 longer applies any %destructor to a mid-rule value if that mid-rule value is
393 not actually ever referenced using either $$ or $n in a semantic action.
394
395 The default %destructor's and %printer's are experimental. More user
396 feedback will help to determine whether they should become permanent
397 features.
398
399 See the section `Freeing Discarded Symbols' in the Bison manual for further
400 details.
401
402** %left, %right, and %nonassoc can now declare token numbers. This is required
403 by POSIX. However, see the end of section `Operator Precedence' in the Bison
404 manual for a caveat concerning the treatment of literal strings.
405
406** The nonfunctional --no-parser, -n, and %no-parser options have been
407 completely removed from Bison.
408
409* Changes in version 2.3a, 2006-09-13:
410
411** Instead of %union, you can define and use your own union type
412 YYSTYPE if your grammar contains at least one <type> tag.
413 Your YYSTYPE need not be a macro; it can be a typedef.
414 This change is for compatibility with other Yacc implementations,
415 and is required by POSIX.
416
417** Locations columns and lines start at 1.
418 In accordance with the GNU Coding Standards and Emacs.
419
420** You may now declare per-type and default %destructor's and %printer's:
421
422 For example:
423
424 %union { char *string; }
425 %token <string> STRING1
426 %token <string> STRING2
427 %type <string> string1
428 %type <string> string2
429 %union { char character; }
430 %token <character> CHR
431 %type <character> chr
432 %destructor { free ($$); } %symbol-default
433 %destructor { free ($$); printf ("%d", @$.first_line); } STRING1 string1
434 %destructor { } <character>
435
436 guarantees that, when the parser discards any user-defined symbol that has a
437 semantic type tag other than `<character>', it passes its semantic value to
438 `free'. However, when the parser discards a `STRING1' or a `string1', it
439 also prints its line number to `stdout'. It performs only the second
440 `%destructor' in this case, so it invokes `free' only once.
441
442 [Although we failed to mention this here in the 2.3a release, the default
443 %destructor's and %printer's were experimental, and they were rewritten in
444 future versions.]
445
446** Except for LALR(1) parsers in C with POSIX Yacc emulation enabled (with `-y',
447 `--yacc', or `%yacc'), Bison no longer generates #define statements for
448 associating token numbers with token names. Removing the #define statements
449 helps to sanitize the global namespace during preprocessing, but POSIX Yacc
450 requires them. Bison still generates an enum for token names in all cases.
451
452** Handling of traditional Yacc prologue blocks is now more consistent but
453 potentially incompatible with previous releases of Bison.
454
455 As before, you declare prologue blocks in your grammar file with the
456 `%{ ... %}' syntax. To generate the pre-prologue, Bison concatenates all
457 prologue blocks that you've declared before the first %union. To generate
458 the post-prologue, Bison concatenates all prologue blocks that you've
459 declared after the first %union.
460
461 Previous releases of Bison inserted the pre-prologue into both the header
462 file and the code file in all cases except for LALR(1) parsers in C. In the
463 latter case, Bison inserted it only into the code file. For parsers in C++,
464 the point of insertion was before any token definitions (which associate
465 token numbers with names). For parsers in C, the point of insertion was
466 after the token definitions.
467
468 Now, Bison never inserts the pre-prologue into the header file. In the code
469 file, it always inserts it before the token definitions.
470
471** Bison now provides a more flexible alternative to the traditional Yacc
472 prologue blocks: %before-header, %start-header, %end-header, and
473 %after-header.
474
475 For example, the following declaration order in the grammar file reflects the
476 order in which Bison will output these code blocks. However, you are free to
477 declare these code blocks in your grammar file in whatever order is most
478 convenient for you:
479
480 %before-header {
481 /* Bison treats this block like a pre-prologue block: it inserts it into
482 * the code file before the contents of the header file. It does *not*
483 * insert it into the header file. This is a good place to put
484 * #include's that you want at the top of your code file. A common
485 * example is `#include "system.h"'. */
486 }
487 %start-header {
488 /* Bison inserts this block into both the header file and the code file.
489 * In both files, the point of insertion is before any Bison-generated
490 * token, semantic type, location type, and class definitions. This is a
491 * good place to define %union dependencies, for example. */
492 }
493 %union {
494 /* Unlike the traditional Yacc prologue blocks, the output order for the
495 * new %*-header blocks is not affected by their declaration position
496 * relative to any %union in the grammar file. */
497 }
498 %end-header {
499 /* Bison inserts this block into both the header file and the code file.
500 * In both files, the point of insertion is after the Bison-generated
501 * definitions. This is a good place to declare or define public
502 * functions or data structures that depend on the Bison-generated
503 * definitions. */
504 }
505 %after-header {
506 /* Bison treats this block like a post-prologue block: it inserts it into
507 * the code file after the contents of the header file. It does *not*
508 * insert it into the header file. This is a good place to declare or
509 * define internal functions or data structures that depend on the
510 * Bison-generated definitions. */
511 }
512
513 If you have multiple occurrences of any one of the above declarations, Bison
514 will concatenate the contents in declaration order.
515
516 [Although we failed to mention this here in the 2.3a release, the prologue
517 alternatives were experimental, and they were rewritten in future versions.]
518
519** The option `--report=look-ahead' has been changed to `--report=lookahead'.
520 The old spelling still works, but is not documented and may be removed
521 in a future release.
522
523* Changes in version 2.3, 2006-06-05:
524
525** GLR grammars should now use `YYRECOVERING ()' instead of `YYRECOVERING',
526 for compatibility with LALR(1) grammars.
527
528** It is now documented that any definition of YYSTYPE or YYLTYPE should
529 be to a type name that does not contain parentheses or brackets.
530
531* Changes in version 2.2, 2006-05-19:
532
533** The distribution terms for all Bison-generated parsers now permit
534 using the parsers in nonfree programs. Previously, this permission
535 was granted only for Bison-generated LALR(1) parsers in C.
536
537** %name-prefix changes the namespace name in C++ outputs.
538
539** The C++ parsers export their token_type.
540
541** Bison now allows multiple %union declarations, and concatenates
542 their contents together.
543
544** New warning: unused values
545 Right-hand side symbols whose values are not used are reported,
546 if the symbols have destructors. For instance:
547
548 exp: exp "?" exp ":" exp { $1 ? $1 : $3; }
549 | exp "+" exp
550 ;
551
552 will trigger a warning about $$ and $5 in the first rule, and $3 in
553 the second ($1 is copied to $$ by the default rule). This example
554 most likely contains three errors, and could be rewritten as:
555
556 exp: exp "?" exp ":" exp
557 { $$ = $1 ? $3 : $5; free ($1 ? $5 : $3); free ($1); }
558 | exp "+" exp
559 { $$ = $1 ? $1 : $3; if ($1) free ($3); }
560 ;
561
562 However, if the original actions were really intended, memory leaks
563 and all, the warnings can be suppressed by letting Bison believe the
564 values are used, e.g.:
565
566 exp: exp "?" exp ":" exp { $1 ? $1 : $3; (void) ($$, $5); }
567 | exp "+" exp { $$ = $1; (void) $3; }
568 ;
569
570 If there are mid-rule actions, the warning is issued if no action
571 uses it. The following triggers no warning: $1 and $3 are used.
572
573 exp: exp { push ($1); } '+' exp { push ($3); sum (); };
574
575 The warning is intended to help catching lost values and memory leaks.
576 If a value is ignored, its associated memory typically is not reclaimed.
577
578** %destructor vs. YYABORT, YYACCEPT, and YYERROR.
579 Destructors are now called when user code invokes YYABORT, YYACCEPT,
580 and YYERROR, for all objects on the stack, other than objects
581 corresponding to the right-hand side of the current rule.
582
583** %expect, %expect-rr
584 Incorrect numbers of expected conflicts are now actual errors,
585 instead of warnings.
586
587** GLR, YACC parsers.
588 The %parse-params are available in the destructors (and the
589 experimental printers) as per the documentation.
590
591** Bison now warns if it finds a stray `$' or `@' in an action.
592
593** %require "VERSION"
594 This specifies that the grammar file depends on features implemented
595 in Bison version VERSION or higher.
596
597** lalr1.cc: The token and value types are now class members.
598 The tokens were defined as free form enums and cpp macros. YYSTYPE
599 was defined as a free form union. They are now class members:
600 tokens are enumerations of the `yy::parser::token' struct, and the
601 semantic values have the `yy::parser::semantic_type' type.
602
603 If you do not want or can update to this scheme, the directive
604 `%define "global_tokens_and_yystype" "1"' triggers the global
605 definition of tokens and YYSTYPE. This change is suitable both
606 for previous releases of Bison, and this one.
607
608 If you wish to update, then make sure older version of Bison will
609 fail using `%require "2.2"'.
610
611** DJGPP support added.
612\f
613* Changes in version 2.1, 2005-09-16:
614
615** The C++ lalr1.cc skeleton supports %lex-param.
616
617** Bison-generated parsers now support the translation of diagnostics like
618 "syntax error" into languages other than English. The default
619 language is still English. For details, please see the new
620 Internationalization section of the Bison manual. Software
621 distributors should also see the new PACKAGING file. Thanks to
622 Bruno Haible for this new feature.
623
624** Wording in the Bison-generated parsers has been changed slightly to
625 simplify translation. In particular, the message "memory exhausted"
626 has replaced "parser stack overflow", as the old message was not
627 always accurate for modern Bison-generated parsers.
628
629** Destructors are now called when the parser aborts, for all symbols left
630 behind on the stack. Also, the start symbol is now destroyed after a
631 successful parse. In both cases, the behavior was formerly inconsistent.
632
633** When generating verbose diagnostics, Bison-generated parsers no longer
634 quote the literal strings associated with tokens. For example, for
635 a syntax error associated with '%token NUM "number"' they might
636 print 'syntax error, unexpected number' instead of 'syntax error,
637 unexpected "number"'.
638\f
639* Changes in version 2.0, 2004-12-25:
640
641** Possibly-incompatible changes
642
643 - Bison-generated parsers no longer default to using the alloca function
644 (when available) to extend the parser stack, due to widespread
645 problems in unchecked stack-overflow detection. You can "#define
646 YYSTACK_USE_ALLOCA 1" to require the use of alloca, but please read
647 the manual to determine safe values for YYMAXDEPTH in that case.
648
649 - Error token location.
650 During error recovery, the location of the syntax error is updated
651 to cover the whole sequence covered by the error token: it includes
652 the shifted symbols thrown away during the first part of the error
653 recovery, and the lookahead rejected during the second part.
654
655 - Semicolon changes:
656 . Stray semicolons are no longer allowed at the start of a grammar.
657 . Semicolons are now required after in-grammar declarations.
658
659 - Unescaped newlines are no longer allowed in character constants or
660 string literals. They were never portable, and GCC 3.4.0 has
661 dropped support for them. Better diagnostics are now generated if
662 forget a closing quote.
663
664 - NUL bytes are no longer allowed in Bison string literals, unfortunately.
665
666** New features
667
668 - GLR grammars now support locations.
669
670 - New directive: %initial-action.
671 This directive allows the user to run arbitrary code (including
672 initializing @$) from yyparse before parsing starts.
673
674 - A new directive "%expect-rr N" specifies the expected number of
675 reduce/reduce conflicts in GLR parsers.
676
677 - %token numbers can now be hexadecimal integers, e.g., `%token FOO 0x12d'.
678 This is a GNU extension.
679
680 - The option `--report=lookahead' was changed to `--report=look-ahead'.
681 [However, this was changed back after 2.3.]
682
683 - Experimental %destructor support has been added to lalr1.cc.
684
685 - New configure option --disable-yacc, to disable installation of the
686 yacc command and -ly library introduced in 1.875 for POSIX conformance.
687
688** Bug fixes
689
690 - For now, %expect-count violations are now just warnings, not errors.
691 This is for compatibility with Bison 1.75 and earlier (when there are
692 reduce/reduce conflicts) and with Bison 1.30 and earlier (when there
693 are too many or too few shift/reduce conflicts). However, in future
694 versions of Bison we plan to improve the %expect machinery so that
695 these violations will become errors again.
696
697 - Within Bison itself, numbers (e.g., goto numbers) are no longer
698 arbitrarily limited to 16-bit counts.
699
700 - Semicolons are now allowed before "|" in grammar rules, as POSIX requires.
701\f
702* Changes in version 1.875, 2003-01-01:
703
704** The documentation license has been upgraded to version 1.2
705 of the GNU Free Documentation License.
706
707** syntax error processing
708
709 - In Yacc-style parsers YYLLOC_DEFAULT is now used to compute error
710 locations too. This fixes bugs in error-location computation.
711
712 - %destructor
713 It is now possible to reclaim the memory associated to symbols
714 discarded during error recovery. This feature is still experimental.
715
716 - %error-verbose
717 This new directive is preferred over YYERROR_VERBOSE.
718
719 - #defining yyerror to steal internal variables is discouraged.
720 It is not guaranteed to work forever.
721
722** POSIX conformance
723
724 - Semicolons are once again optional at the end of grammar rules.
725 This reverts to the behavior of Bison 1.33 and earlier, and improves
726 compatibility with Yacc.
727
728 - `parse error' -> `syntax error'
729 Bison now uniformly uses the term `syntax error'; formerly, the code
730 and manual sometimes used the term `parse error' instead. POSIX
731 requires `syntax error' in diagnostics, and it was thought better to
732 be consistent.
733
734 - The documentation now emphasizes that yylex and yyerror must be
735 declared before use. C99 requires this.
736
737 - Bison now parses C99 lexical constructs like UCNs and
738 backslash-newline within C escape sequences, as POSIX 1003.1-2001 requires.
739
740 - File names are properly escaped in C output. E.g., foo\bar.y is
741 output as "foo\\bar.y".
742
743 - Yacc command and library now available
744 The Bison distribution now installs a `yacc' command, as POSIX requires.
745 Also, Bison now installs a small library liby.a containing
746 implementations of Yacc-compatible yyerror and main functions.
747 This library is normally not useful, but POSIX requires it.
748
749 - Type clashes now generate warnings, not errors.
750
751 - If the user does not define YYSTYPE as a macro, Bison now declares it
752 using typedef instead of defining it as a macro.
753 For consistency, YYLTYPE is also declared instead of defined.
754
755** Other compatibility issues
756
757 - %union directives can now have a tag before the `{', e.g., the
758 directive `%union foo {...}' now generates the C code
759 `typedef union foo { ... } YYSTYPE;'; this is for Yacc compatibility.
760 The default union tag is `YYSTYPE', for compatibility with Solaris 9 Yacc.
761 For consistency, YYLTYPE's struct tag is now `YYLTYPE' not `yyltype'.
762 This is for compatibility with both Yacc and Bison 1.35.
763
764 - `;' is output before the terminating `}' of an action, for
765 compatibility with Bison 1.35.
766
767 - Bison now uses a Yacc-style format for conflict reports, e.g.,
768 `conflicts: 2 shift/reduce, 1 reduce/reduce'.
769
770 - `yystype' and `yyltype' are now obsolescent macros instead of being
771 typedefs or tags; they are no longer documented and are planned to be
772 withdrawn in a future release.
773
774** GLR parser notes
775
776 - GLR and inline
777 Users of Bison have to decide how they handle the portability of the
778 C keyword `inline'.
779
780 - `parsing stack overflow...' -> `parser stack overflow'
781 GLR parsers now report `parser stack overflow' as per the Bison manual.
782
783** Bison now warns if it detects conflicting outputs to the same file,
784 e.g., it generates a warning for `bison -d -o foo.h foo.y' since
785 that command outputs both code and header to foo.h.
786
787** #line in output files
788 - --no-line works properly.
789
790** Bison can no longer be built by a K&R C compiler; it requires C89 or
791 later to be built. This change originally took place a few versions
792 ago, but nobody noticed until we recently asked someone to try
793 building Bison with a K&R C compiler.
794\f
795* Changes in version 1.75, 2002-10-14:
796
797** Bison should now work on 64-bit hosts.
798
799** Indonesian translation thanks to Tedi Heriyanto.
800
801** GLR parsers
802 Fix spurious parse errors.
803
804** Pure parsers
805 Some people redefine yyerror to steal yyparse' private variables.
806 Reenable this trick until an official feature replaces it.
807
808** Type Clashes
809 In agreement with POSIX and with other Yaccs, leaving a default
810 action is valid when $$ is untyped, and $1 typed:
811
812 untyped: ... typed;
813
814 but the converse remains an error:
815
816 typed: ... untyped;
817
818** Values of mid-rule actions
819 The following code:
820
821 foo: { ... } { $$ = $1; } ...
822
823 was incorrectly rejected: $1 is defined in the second mid-rule
824 action, and is equal to the $$ of the first mid-rule action.
825\f
826* Changes in version 1.50, 2002-10-04:
827
828** GLR parsing
829 The declaration
830 %glr-parser
831 causes Bison to produce a Generalized LR (GLR) parser, capable of handling
832 almost any context-free grammar, ambiguous or not. The new declarations
833 %dprec and %merge on grammar rules allow parse-time resolution of
834 ambiguities. Contributed by Paul Hilfinger.
835
836 Unfortunately Bison 1.50 does not work properly on 64-bit hosts
837 like the Alpha, so please stick to 32-bit hosts for now.
838
839** Output Directory
840 When not in Yacc compatibility mode, when the output file was not
841 specified, running `bison foo/bar.y' created `foo/bar.c'. It
842 now creates `bar.c'.
843
844** Undefined token
845 The undefined token was systematically mapped to 2 which prevented
846 the use of 2 by the user. This is no longer the case.
847
848** Unknown token numbers
849 If yylex returned an out of range value, yyparse could die. This is
850 no longer the case.
851
852** Error token
853 According to POSIX, the error token must be 256.
854 Bison extends this requirement by making it a preference: *if* the
855 user specified that one of her tokens is numbered 256, then error
856 will be mapped onto another number.
857
858** Verbose error messages
859 They no longer report `..., expecting error or...' for states where
860 error recovery is possible.
861
862** End token
863 Defaults to `$end' instead of `$'.
864
865** Error recovery now conforms to documentation and to POSIX
866 When a Bison-generated parser encounters a syntax error, it now pops
867 the stack until it finds a state that allows shifting the error
868 token. Formerly, it popped the stack until it found a state that
869 allowed some non-error action other than a default reduction on the
870 error token. The new behavior has long been the documented behavior,
871 and has long been required by POSIX. For more details, please see
872 Paul Eggert, "Reductions during Bison error handling" (2002-05-20)
873 <http://lists.gnu.org/archive/html/bug-bison/2002-05/msg00038.html>.
874
875** Traces
876 Popped tokens and nonterminals are now reported.
877
878** Larger grammars
879 Larger grammars are now supported (larger token numbers, larger grammar
880 size (= sum of the LHS and RHS lengths), larger LALR tables).
881 Formerly, many of these numbers ran afoul of 16-bit limits;
882 now these limits are 32 bits on most hosts.
883
884** Explicit initial rule
885 Bison used to play hacks with the initial rule, which the user does
886 not write. It is now explicit, and visible in the reports and
887 graphs as rule 0.
888
889** Useless rules
890 Before, Bison reported the useless rules, but, although not used,
891 included them in the parsers. They are now actually removed.
892
893** Useless rules, useless nonterminals
894 They are now reported, as a warning, with their locations.
895
896** Rules never reduced
897 Rules that can never be reduced because of conflicts are now
898 reported.
899
900** Incorrect `Token not used'
901 On a grammar such as
902
903 %token useless useful
904 %%
905 exp: '0' %prec useful;
906
907 where a token was used to set the precedence of the last rule,
908 bison reported both `useful' and `useless' as useless tokens.
909
910** Revert the C++ namespace changes introduced in 1.31
911 as they caused too many portability hassles.
912
913** Default locations
914 By an accident of design, the default computation of @$ was
915 performed after another default computation was performed: @$ = @1.
916 The latter is now removed: YYLLOC_DEFAULT is fully responsible of
917 the computation of @$.
918
919** Token end-of-file
920 The token end of file may be specified by the user, in which case,
921 the user symbol is used in the reports, the graphs, and the verbose
922 error messages instead of `$end', which remains being the default.
923 For instance
924 %token MYEOF 0
925 or
926 %token MYEOF 0 "end of file"
927
928** Semantic parser
929 This old option, which has been broken for ages, is removed.
930
931** New translations
932 Brazilian Portuguese, thanks to Alexandre Folle de Menezes.
933 Croatian, thanks to Denis Lackovic.
934
935** Incorrect token definitions
936 When given `%token 'a' "A"', Bison used to output `#define 'a' 65'.
937
938** Token definitions as enums
939 Tokens are output both as the traditional #define's, and, provided
940 the compiler supports ANSI C or is a C++ compiler, as enums.
941 This lets debuggers display names instead of integers.
942
943** Reports
944 In addition to --verbose, bison supports --report=THINGS, which
945 produces additional information:
946 - itemset
947 complete the core item sets with their closure
948 - lookahead [changed to `look-ahead' in 1.875e through 2.3, but changed back]
949 explicitly associate lookahead tokens to items
950 - solved
951 describe shift/reduce conflicts solving.
952 Bison used to systematically output this information on top of
953 the report. Solved conflicts are now attached to their states.
954
955** Type clashes
956 Previous versions don't complain when there is a type clash on
957 the default action if the rule has a mid-rule action, such as in:
958
959 %type <foo> bar
960 %%
961 bar: '0' {} '0';
962
963 This is fixed.
964
965** GNU M4 is now required when using Bison.
966\f
967* Changes in version 1.35, 2002-03-25:
968
969** C Skeleton
970 Some projects use Bison's C parser with C++ compilers, and define
971 YYSTYPE as a class. The recent adjustment of C parsers for data
972 alignment and 64 bit architectures made this impossible.
973
974 Because for the time being no real solution for C++ parser
975 generation exists, kludges were implemented in the parser to
976 maintain this use. In the future, when Bison has C++ parsers, this
977 kludge will be disabled.
978
979 This kludge also addresses some C++ problems when the stack was
980 extended.
981\f
982* Changes in version 1.34, 2002-03-12:
983
984** File name clashes are detected
985 $ bison foo.y -d -o foo.x
986 fatal error: header and parser would both be named `foo.x'
987
988** A missing `;' at the end of a rule triggers a warning
989 In accordance with POSIX, and in agreement with other
990 Yacc implementations, Bison will mandate this semicolon in the near
991 future. This eases the implementation of a Bison parser of Bison
992 grammars by making this grammar LALR(1) instead of LR(2). To
993 facilitate the transition, this release introduces a warning.
994
995** Revert the C++ namespace changes introduced in 1.31, as they caused too
996 many portability hassles.
997
998** DJGPP support added.
999
1000** Fix test suite portability problems.
1001\f
1002* Changes in version 1.33, 2002-02-07:
1003
1004** Fix C++ issues
1005 Groff could not be compiled for the definition of size_t was lacking
1006 under some conditions.
1007
1008** Catch invalid @n
1009 As is done with $n.
1010\f
1011* Changes in version 1.32, 2002-01-23:
1012
1013** Fix Yacc output file names
1014
1015** Portability fixes
1016
1017** Italian, Dutch translations
1018\f
1019* Changes in version 1.31, 2002-01-14:
1020
1021** Many Bug Fixes
1022
1023** GNU Gettext and %expect
1024 GNU Gettext asserts 10 s/r conflicts, but there are 7. Now that
1025 Bison dies on incorrect %expectations, we fear there will be
1026 too many bug reports for Gettext, so _for the time being_, %expect
1027 does not trigger an error when the input file is named `plural.y'.
1028
1029** Use of alloca in parsers
1030 If YYSTACK_USE_ALLOCA is defined to 0, then the parsers will use
1031 malloc exclusively. Since 1.29, but was not NEWS'ed.
1032
1033 alloca is used only when compiled with GCC, to avoid portability
1034 problems as on AIX.
1035
1036** yyparse now returns 2 if memory is exhausted; formerly it dumped core.
1037
1038** When the generated parser lacks debugging code, YYDEBUG is now 0
1039 (as POSIX requires) instead of being undefined.
1040
1041** User Actions
1042 Bison has always permitted actions such as { $$ = $1 }: it adds the
1043 ending semicolon. Now if in Yacc compatibility mode, the semicolon
1044 is no longer output: one has to write { $$ = $1; }.
1045
1046** Better C++ compliance
1047 The output parsers try to respect C++ namespaces.
1048 [This turned out to be a failed experiment, and it was reverted later.]
1049
1050** Reduced Grammars
1051 Fixed bugs when reporting useless nonterminals.
1052
1053** 64 bit hosts
1054 The parsers work properly on 64 bit hosts.
1055
1056** Error messages
1057 Some calls to strerror resulted in scrambled or missing error messages.
1058
1059** %expect
1060 When the number of shift/reduce conflicts is correct, don't issue
1061 any warning.
1062
1063** The verbose report includes the rule line numbers.
1064
1065** Rule line numbers are fixed in traces.
1066
1067** Swedish translation
1068
1069** Parse errors
1070 Verbose parse error messages from the parsers are better looking.
1071 Before: parse error: unexpected `'/'', expecting `"number"' or `'-'' or `'(''
1072 Now: parse error: unexpected '/', expecting "number" or '-' or '('
1073
1074** Fixed parser memory leaks.
1075 When the generated parser was using malloc to extend its stacks, the
1076 previous allocations were not freed.
1077
1078** Fixed verbose output file.
1079 Some newlines were missing.
1080 Some conflicts in state descriptions were missing.
1081
1082** Fixed conflict report.
1083 Option -v was needed to get the result.
1084
1085** %expect
1086 Was not used.
1087 Mismatches are errors, not warnings.
1088
1089** Fixed incorrect processing of some invalid input.
1090
1091** Fixed CPP guards: 9foo.h uses BISON_9FOO_H instead of 9FOO_H.
1092
1093** Fixed some typos in the documentation.
1094
1095** %token MY_EOF 0 is supported.
1096 Before, MY_EOF was silently renumbered as 257.
1097
1098** doc/refcard.tex is updated.
1099
1100** %output, %file-prefix, %name-prefix.
1101 New.
1102
1103** --output
1104 New, aliasing `--output-file'.
1105\f
1106* Changes in version 1.30, 2001-10-26:
1107
1108** `--defines' and `--graph' have now an optional argument which is the
1109 output file name. `-d' and `-g' do not change; they do not take any
1110 argument.
1111
1112** `%source_extension' and `%header_extension' are removed, failed
1113 experiment.
1114
1115** Portability fixes.
1116\f
1117* Changes in version 1.29, 2001-09-07:
1118
1119** The output file does not define const, as this caused problems when used
1120 with common autoconfiguration schemes. If you still use ancient compilers
1121 that lack const, compile with the equivalent of the C compiler option
1122 `-Dconst='. autoconf's AC_C_CONST macro provides one way to do this.
1123
1124** Added `-g' and `--graph'.
1125
1126** The Bison manual is now distributed under the terms of the GNU FDL.
1127
1128** The input and the output files has automatically a similar extension.
1129
1130** Russian translation added.
1131
1132** NLS support updated; should hopefully be less troublesome.
1133
1134** Added the old Bison reference card.
1135
1136** Added `--locations' and `%locations'.
1137
1138** Added `-S' and `--skeleton'.
1139
1140** `%raw', `-r', `--raw' is disabled.
1141
1142** Special characters are escaped when output. This solves the problems
1143 of the #line lines with path names including backslashes.
1144
1145** New directives.
1146 `%yacc', `%fixed_output_files', `%defines', `%no_parser', `%verbose',
1147 `%debug', `%source_extension' and `%header_extension'.
1148
1149** @$
1150 Automatic location tracking.
1151\f
1152* Changes in version 1.28, 1999-07-06:
1153
1154** Should compile better now with K&R compilers.
1155
1156** Added NLS.
1157
1158** Fixed a problem with escaping the double quote character.
1159
1160** There is now a FAQ.
1161\f
1162* Changes in version 1.27:
1163
1164** The make rule which prevented bison.simple from being created on
1165 some systems has been fixed.
1166\f
1167* Changes in version 1.26:
1168
1169** Bison now uses automake.
1170
1171** New mailing lists: <bug-bison@gnu.org> and <help-bison@gnu.org>.
1172
1173** Token numbers now start at 257 as previously documented, not 258.
1174
1175** Bison honors the TMPDIR environment variable.
1176
1177** A couple of buffer overruns have been fixed.
1178
1179** Problems when closing files should now be reported.
1180
1181** Generated parsers should now work even on operating systems which do
1182 not provide alloca().
1183\f
1184* Changes in version 1.25, 1995-10-16:
1185
1186** Errors in the input grammar are not fatal; Bison keeps reading
1187the grammar file, and reports all the errors found in it.
1188
1189** Tokens can now be specified as multiple-character strings: for
1190example, you could use "<=" for a token which looks like <=, instead
1191of chosing a name like LESSEQ.
1192
1193** The %token_table declaration says to write a table of tokens (names
1194and numbers) into the parser file. The yylex function can use this
1195table to recognize multiple-character string tokens, or for other
1196purposes.
1197
1198** The %no_lines declaration says not to generate any #line preprocessor
1199directives in the parser file.
1200
1201** The %raw declaration says to use internal Bison token numbers, not
1202Yacc-compatible token numbers, when token names are defined as macros.
1203
1204** The --no-parser option produces the parser tables without including
1205the parser engine; a project can now use its own parser engine.
1206The actions go into a separate file called NAME.act, in the form of
1207a switch statement body.
1208\f
1209* Changes in version 1.23:
1210
1211The user can define YYPARSE_PARAM as the name of an argument to be
1212passed into yyparse. The argument should have type void *. It should
1213actually point to an object. Grammar actions can access the variable
1214by casting it to the proper pointer type.
1215
1216Line numbers in output file corrected.
1217\f
1218* Changes in version 1.22:
1219
1220--help option added.
1221\f
1222* Changes in version 1.20:
1223
1224Output file does not redefine const for C++.
1225
1226Local Variables:
1227mode: outline
1228End:
1229
1230-----
1231
1232Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
12332004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
1234
1235This file is part of Bison, the GNU Parser Generator.
1236
1237This program is free software: you can redistribute it and/or modify
1238it under the terms of the GNU General Public License as published by
1239the Free Software Foundation, either version 3 of the License, or
1240(at your option) any later version.
1241
1242This program is distributed in the hope that it will be useful,
1243but WITHOUT ANY WARRANTY; without even the implied warranty of
1244MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1245GNU General Public License for more details.
1246
1247You should have received a copy of the GNU General Public License
1248along with this program. If not, see <http://www.gnu.org/licenses/>.