yystype, yyltype: remove.
[bison.git] / NEWS
1 GNU Bison NEWS
2
3 * Noteworthy changes in release ?.? (????-??-??) [?]
4
5 ** Incompatible changes
6
7 *** Obsolete features
8
9 Support for YYFAIL is removed, as announced since Bison 2.4.2.
10 Support for yystype and yyltype (instead of YYSTYPE and YYLTYPE)
11 is removed, as announced in Bison 1.875.
12
13 ** Warnings
14
15 *** Warning categories are now displayed in warnings
16
17 For instance:
18
19 foo.y:4.6: warning: type clash on default action: <foo> != <bar> [-Wother]
20
21 *** Useless semantic types
22
23 Bison now warns about useless (uninhabited) semantic types. Since
24 semantic types are not declared to Bison (they are defined in the opaque
25 %union structure), it is %printer/%destructor directives about useless
26 types that trigger the warning:
27
28 %token <type1> term
29 %type <type2> nterm
30 %printer {} <type1> <type3>
31 %destructor {} <type2> <type4>
32 %%
33 nterm: term { $$ = $1; };
34
35 3.28-34: warning: type <type3> is used, but is not associated to any symbol
36 4.28-34: warning: type <type4> is used, but is not associated to any symbol
37
38 *** Undeclared symbols
39
40 Bison used to raise an error for %printer and %destructor directives for
41 undefined symbols.
42
43 %printer {} symbol1
44 %destructor {} symbol2
45 %%
46 exp: "a";
47
48 This is now only a warning.
49
50 *** Useless destructors or printers
51
52 Bison now warns about useless destructors or printers. In the following
53 example, the printer for <type1>, and the destructor for <type2> are
54 useless: all symbols of <type1> (token1) already have a printer, and all
55 symbols of type <type2> (token2) already have a destructor.
56
57 %token <type1> token1
58 <type2> token2
59 <type3> token3
60 <type4> token4
61 %printer {} token1 <type1> <type3>
62 %destructor {} token2 <type2> <type4>
63
64 ** Additional yylex/yyparse arguments
65
66 The new directive %param declares additional arguments to both yylex and
67 yyparse. The %lex-param, %parse-param, and %param directives support one
68 or more arguments. Instead of
69
70 %lex-param {arg1_type *arg1}
71 %lex-param {arg2_type *arg2}
72 %parse-param {arg1_type *arg1}
73 %parse-param {arg2_type *arg2}
74
75 one may now declare
76
77 %param {arg1_type *arg1} {arg2_type *arg2}
78
79 ** Java skeleton improvements
80
81 The constants for token names were moved to the Lexer interface.
82 Also, it is possible to add code to the parser's constructors using
83 "%code init" and "%define init_throws".
84
85 ** C++ skeleton improvements
86
87 The C++ parser features a syntax_error exception, which can be
88 thrown from the scanner or from user rules to raise syntax errors.
89 This facilitates reporting errors caught in sub-functions (e.g.,
90 rejecting too large integral literals from a conversion function
91 used by the scanner, or rejecting invalid combinations from a
92 factory invoked by the user actions).
93
94 ** Variable api.tokens.prefix
95
96 The variable api.tokens.prefix changes the way tokens are identified in
97 the generated files. This is especially useful to avoid collisions
98 with identifiers in the target language. For instance
99
100 %token FILE for ERROR
101 %define api.tokens.prefix "TOK_"
102 %%
103 start: FILE for ERROR;
104
105 will generate the definition of the symbols TOK_FILE, TOK_for, and
106 TOK_ERROR in the generated sources. In particular, the scanner must
107 use these prefixed token names, although the grammar itself still
108 uses the short names (as in the sample rule given above).
109
110 ** Variable api.namespace
111
112 The "namespace" variable is renamed "api.namespace". Backward
113 compatibility is ensured, but upgrading is recommended.
114
115 ** Variable parse.error
116
117 The variable error controls the verbosity of error messages. The
118 use of the %error-verbose directive is deprecated in favor of
119 %define parse.error "verbose".
120
121 ** Semantic predicates
122
123 The new, experimental, semantic-predicate feature allows actions of
124 the form %?{ BOOLEAN-EXPRESSION }, which cause syntax errors (as for
125 YYERROR) if the expression evaluates to 0, and are evaluated immediately
126 in GLR parsers, rather than being deferred. The result is that they
127 allow the programmer to prune possible parses based on the values of
128 run-time expressions.
129
130 * Noteworthy changes in release ?.? (????-??-??) [?]
131
132
133 * Noteworthy changes in release 2.6 (2012-07-19) [stable]
134
135 ** Future changes:
136
137 The next major release of Bison will drop support for the following
138 deprecated features. Please report disagreements to bug-bison@gnu.org.
139
140 *** K&C parsers
141
142 Support for generating parsers in K&R C will be removed. Parsers
143 generated for C support ISO C90, and are tested with ISO C99 and ISO C11
144 compilers.
145
146 *** Features deprecated since Bison 1.875
147
148 The definitions of yystype and yyltype will be removed; use YYSTYPE and
149 YYLTYPE.
150
151 YYPARSE_PARAM and YYLEX_PARAM, deprecated in favor of %parse-param and
152 %lex-param, will no longer be supported.
153
154 Support for the preprocessor symbol YYERROR_VERBOSE will be removed, use
155 %error-verbose.
156
157 *** The generated header will be included (yacc.c)
158
159 Instead of duplicating the content of the generated header (definition of
160 YYSTYPE, yyparse declaration etc.), the generated parser will include it,
161 as is already the case for GLR or C++ parsers. This change is deferred
162 because existing versions of ylwrap (e.g., Automake 1.12.1) do not support
163 it.
164
165 ** Generated Parser Headers
166
167 *** Guards (yacc.c, glr.c, glr.cc)
168
169 The generated headers are now guarded, as is already the case for C++
170 parsers (lalr1.cc). For instance, with --defines=foo.h:
171
172 #ifndef YY_FOO_H
173 # define YY_FOO_H
174 ...
175 #endif /* !YY_FOO_H */
176
177 *** New declarations (yacc.c, glr.c)
178
179 The generated header now declares yydebug and yyparse. Both honor
180 --name-prefix=bar_, and yield
181
182 int bar_parse (void);
183
184 rather than
185
186 #define yyparse bar_parse
187 int yyparse (void);
188
189 in order to facilitate the inclusion of several parser headers inside a
190 single compilation unit.
191
192 *** Exported symbols in C++
193
194 The symbols YYTOKEN_TABLE and YYERROR_VERBOSE, which were defined in the
195 header, are removed, as they prevent the possibility of including several
196 generated headers from a single compilation unit.
197
198 *** YYLSP_NEEDED
199
200 For the same reasons, the undocumented and unused macro YYLSP_NEEDED is no
201 longer defined.
202
203 ** New %define variable: api.prefix
204
205 Now that the generated headers are more complete and properly protected
206 against multiple inclusions, constant names, such as YYSTYPE are a
207 problem. While yyparse and others are properly renamed by %name-prefix,
208 YYSTYPE, YYDEBUG and others have never been affected by it. Because it
209 would introduce backward compatibility issues in projects not expecting
210 YYSTYPE to be renamed, instead of changing the behavior of %name-prefix,
211 it is deprecated in favor of a new %define variable: api.prefix.
212
213 The following examples compares both:
214
215 %name-prefix "bar_" | %define api.prefix "bar_"
216 %token <ival> FOO %token <ival> FOO
217 %union { int ival; } %union { int ival; }
218 %% %%
219 exp: 'a'; exp: 'a';
220
221 bison generates:
222
223 #ifndef BAR_FOO_H #ifndef BAR_FOO_H
224 # define BAR_FOO_H # define BAR_FOO_H
225
226 /* Enabling traces. */ /* Enabling traces. */
227 # ifndef YYDEBUG | # ifndef BAR_DEBUG
228 > # if defined YYDEBUG
229 > # if YYDEBUG
230 > # define BAR_DEBUG 1
231 > # else
232 > # define BAR_DEBUG 0
233 > # endif
234 > # else
235 # define YYDEBUG 0 | # define BAR_DEBUG 0
236 > # endif
237 # endif | # endif
238
239 # if YYDEBUG | # if BAR_DEBUG
240 extern int bar_debug; extern int bar_debug;
241 # endif # endif
242
243 /* Tokens. */ /* Tokens. */
244 # ifndef YYTOKENTYPE | # ifndef BAR_TOKENTYPE
245 # define YYTOKENTYPE | # define BAR_TOKENTYPE
246 enum yytokentype { | enum bar_tokentype {
247 FOO = 258 FOO = 258
248 }; };
249 # endif # endif
250
251 #if ! defined YYSTYPE \ | #if ! defined BAR_STYPE \
252 && ! defined YYSTYPE_IS_DECLARED | && ! defined BAR_STYPE_IS_DECLARED
253 typedef union YYSTYPE | typedef union BAR_STYPE
254 { {
255 int ival; int ival;
256 } YYSTYPE; | } BAR_STYPE;
257 # define YYSTYPE_IS_DECLARED 1 | # define BAR_STYPE_IS_DECLARED 1
258 #endif #endif
259
260 extern YYSTYPE bar_lval; | extern BAR_STYPE bar_lval;
261
262 int bar_parse (void); int bar_parse (void);
263
264 #endif /* !BAR_FOO_H */ #endif /* !BAR_FOO_H */
265
266 * Noteworthy changes in release 2.5.1 (2012-06-05) [stable]
267
268 ** Future changes:
269
270 The next major release will drop support for generating parsers in K&R C.
271
272 ** yacc.c: YYBACKUP works as expected.
273
274 ** glr.c improvements:
275
276 *** Location support is eliminated when not requested:
277
278 GLR parsers used to include location-related code even when locations were
279 not requested, and therefore not even usable.
280
281 *** __attribute__ is preserved:
282
283 __attribute__ is no longer disabled when __STRICT_ANSI__ is defined (i.e.,
284 when -std is passed to GCC).
285
286 ** lalr1.java: several fixes:
287
288 The Java parser no longer throws ArrayIndexOutOfBoundsException if the
289 first token leads to a syntax error. Some minor clean ups.
290
291 ** Changes for C++:
292
293 *** C++11 compatibility:
294
295 C and C++ parsers use "nullptr" instead of "0" when __cplusplus is 201103L
296 or higher.
297
298 *** Header guards
299
300 The header files such as "parser.hh", "location.hh", etc. used a constant
301 name for preprocessor guards, for instance:
302
303 #ifndef BISON_LOCATION_HH
304 # define BISON_LOCATION_HH
305 ...
306 #endif // !BISON_LOCATION_HH
307
308 The inclusion guard is now computed from "PREFIX/FILE-NAME", where lower
309 case characters are converted to upper case, and series of
310 non-alphanumerical characters are converted to an underscore.
311
312 With "bison -o lang++/parser.cc", "location.hh" would now include:
313
314 #ifndef YY_LANG_LOCATION_HH
315 # define YY_LANG_LOCATION_HH
316 ...
317 #endif // !YY_LANG_LOCATION_HH
318
319 *** C++ locations:
320
321 The position and location constructors (and their initialize methods)
322 accept new arguments for line and column. Several issues in the
323 documentation were fixed.
324
325 ** liby is no longer asking for "rpl_fprintf" on some platforms.
326
327 ** Changes in the manual:
328
329 *** %printer is documented
330
331 The "%printer" directive, supported since at least Bison 1.50, is finally
332 documented. The "mfcalc" example is extended to demonstrate it.
333
334 For consistency with the C skeletons, the C++ parsers now also support
335 "yyoutput" (as an alias to "debug_stream ()").
336
337 *** Several improvements have been made:
338
339 The layout for grammar excerpts was changed to a more compact scheme.
340 Named references are motivated. The description of the automaton
341 description file (*.output) is updated to the current format. Incorrect
342 index entries were fixed. Some other errors were fixed.
343
344 ** Building bison:
345
346 *** Conflicting prototypes with recent/modified Flex.
347
348 Fixed build problems with the current, unreleased, version of Flex, and
349 some modified versions of 2.5.35, which have modified function prototypes.
350
351 *** Warnings during the build procedure have been eliminated.
352
353 *** Several portability problems in the test suite have been fixed:
354
355 This includes warnings with some compilers, unexpected behavior of tools
356 such as diff, warning messages from the test suite itself, etc.
357
358 *** The install-pdf target works properly:
359
360 Running "make install-pdf" (or -dvi, -html, -info, and -ps) no longer
361 halts in the middle of its course.
362
363 * Changes in version 2.5 (2011-05-14):
364
365 ** Grammar symbol names can now contain non-initial dashes:
366
367 Consistently with directives (such as %error-verbose) and with
368 %define variables (e.g. push-pull), grammar symbol names may contain
369 dashes in any position except the beginning. This is a GNU
370 extension over POSIX Yacc. Thus, use of this extension is reported
371 by -Wyacc and rejected in Yacc mode (--yacc).
372
373 ** Named references:
374
375 Historically, Yacc and Bison have supported positional references
376 ($n, $$) to allow access to symbol values from inside of semantic
377 actions code.
378
379 Starting from this version, Bison can also accept named references.
380 When no ambiguity is possible, original symbol names may be used
381 as named references:
382
383 if_stmt : "if" cond_expr "then" then_stmt ';'
384 { $if_stmt = mk_if_stmt($cond_expr, $then_stmt); }
385
386 In the more common case, explicit names may be declared:
387
388 stmt[res] : "if" expr[cond] "then" stmt[then] "else" stmt[else] ';'
389 { $res = mk_if_stmt($cond, $then, $else); }
390
391 Location information is also accessible using @name syntax. When
392 accessing symbol names containing dots or dashes, explicit bracketing
393 ($[sym.1]) must be used.
394
395 These features are experimental in this version. More user feedback
396 will help to stabilize them.
397
398 ** IELR(1) and canonical LR(1):
399
400 IELR(1) is a minimal LR(1) parser table generation algorithm. That
401 is, given any context-free grammar, IELR(1) generates parser tables
402 with the full language-recognition power of canonical LR(1) but with
403 nearly the same number of parser states as LALR(1). This reduction
404 in parser states is often an order of magnitude. More importantly,
405 because canonical LR(1)'s extra parser states may contain duplicate
406 conflicts in the case of non-LR(1) grammars, the number of conflicts
407 for IELR(1) is often an order of magnitude less as well. This can
408 significantly reduce the complexity of developing of a grammar.
409
410 Bison can now generate IELR(1) and canonical LR(1) parser tables in
411 place of its traditional LALR(1) parser tables, which remain the
412 default. You can specify the type of parser tables in the grammar
413 file with these directives:
414
415 %define lr.type lalr
416 %define lr.type ielr
417 %define lr.type canonical-lr
418
419 The default-reduction optimization in the parser tables can also be
420 adjusted using "%define lr.default-reductions". For details on both
421 of these features, see the new section "Tuning LR" in the Bison
422 manual.
423
424 These features are experimental. More user feedback will help to
425 stabilize them.
426
427 ** LAC (Lookahead Correction) for syntax error handling:
428
429 Canonical LR, IELR, and LALR can suffer from a couple of problems
430 upon encountering a syntax error. First, the parser might perform
431 additional parser stack reductions before discovering the syntax
432 error. Such reductions can perform user semantic actions that are
433 unexpected because they are based on an invalid token, and they
434 cause error recovery to begin in a different syntactic context than
435 the one in which the invalid token was encountered. Second, when
436 verbose error messages are enabled (with %error-verbose or the
437 obsolete "#define YYERROR_VERBOSE"), the expected token list in the
438 syntax error message can both contain invalid tokens and omit valid
439 tokens.
440
441 The culprits for the above problems are %nonassoc, default
442 reductions in inconsistent states, and parser state merging. Thus,
443 IELR and LALR suffer the most. Canonical LR can suffer only if
444 %nonassoc is used or if default reductions are enabled for
445 inconsistent states.
446
447 LAC is a new mechanism within the parsing algorithm that solves
448 these problems for canonical LR, IELR, and LALR without sacrificing
449 %nonassoc, default reductions, or state merging. When LAC is in
450 use, canonical LR and IELR behave almost exactly the same for both
451 syntactically acceptable and syntactically unacceptable input.
452 While LALR still does not support the full language-recognition
453 power of canonical LR and IELR, LAC at least enables LALR's syntax
454 error handling to correctly reflect LALR's language-recognition
455 power.
456
457 Currently, LAC is only supported for deterministic parsers in C.
458 You can enable LAC with the following directive:
459
460 %define parse.lac full
461
462 See the new section "LAC" in the Bison manual for additional
463 details including a few caveats.
464
465 LAC is an experimental feature. More user feedback will help to
466 stabilize it.
467
468 ** %define improvements:
469
470 *** Can now be invoked via the command line:
471
472 Each of these command-line options
473
474 -D NAME[=VALUE]
475 --define=NAME[=VALUE]
476
477 -F NAME[=VALUE]
478 --force-define=NAME[=VALUE]
479
480 is equivalent to this grammar file declaration
481
482 %define NAME ["VALUE"]
483
484 except that the manner in which Bison processes multiple definitions
485 for the same NAME differs. Most importantly, -F and --force-define
486 quietly override %define, but -D and --define do not. For further
487 details, see the section "Bison Options" in the Bison manual.
488
489 *** Variables renamed:
490
491 The following %define variables
492
493 api.push_pull
494 lr.keep_unreachable_states
495
496 have been renamed to
497
498 api.push-pull
499 lr.keep-unreachable-states
500
501 The old names are now deprecated but will be maintained indefinitely
502 for backward compatibility.
503
504 *** Values no longer need to be quoted in the grammar file:
505
506 If a %define value is an identifier, it no longer needs to be placed
507 within quotations marks. For example,
508
509 %define api.push-pull "push"
510
511 can be rewritten as
512
513 %define api.push-pull push
514
515 *** Unrecognized variables are now errors not warnings.
516
517 *** Multiple invocations for any variable is now an error not a warning.
518
519 ** Unrecognized %code qualifiers are now errors not warnings.
520
521 ** Character literals not of length one:
522
523 Previously, Bison quietly converted all character literals to length
524 one. For example, without warning, Bison interpreted the operators in
525 the following grammar to be the same token:
526
527 exp: exp '++'
528 | exp '+' exp
529 ;
530
531 Bison now warns when a character literal is not of length one. In
532 some future release, Bison will start reporting an error instead.
533
534 ** Destructor calls fixed for lookaheads altered in semantic actions:
535
536 Previously for deterministic parsers in C, if a user semantic action
537 altered yychar, the parser in some cases used the old yychar value to
538 determine which destructor to call for the lookahead upon a syntax
539 error or upon parser return. This bug has been fixed.
540
541 ** C++ parsers use YYRHSLOC:
542
543 Similarly to the C parsers, the C++ parsers now define the YYRHSLOC
544 macro and use it in the default YYLLOC_DEFAULT. You are encouraged
545 to use it. If, for instance, your location structure has "first"
546 and "last" members, instead of
547
548 # define YYLLOC_DEFAULT(Current, Rhs, N) \
549 do \
550 if (N) \
551 { \
552 (Current).first = (Rhs)[1].location.first; \
553 (Current).last = (Rhs)[N].location.last; \
554 } \
555 else \
556 { \
557 (Current).first = (Current).last = (Rhs)[0].location.last; \
558 } \
559 while (false)
560
561 use:
562
563 # define YYLLOC_DEFAULT(Current, Rhs, N) \
564 do \
565 if (N) \
566 { \
567 (Current).first = YYRHSLOC (Rhs, 1).first; \
568 (Current).last = YYRHSLOC (Rhs, N).last; \
569 } \
570 else \
571 { \
572 (Current).first = (Current).last = YYRHSLOC (Rhs, 0).last; \
573 } \
574 while (false)
575
576 ** YYLLOC_DEFAULT in C++:
577
578 The default implementation of YYLLOC_DEFAULT used to be issued in
579 the header file. It is now output in the implementation file, after
580 the user %code sections so that its #ifndef guard does not try to
581 override the user's YYLLOC_DEFAULT if provided.
582
583 ** YYFAIL now produces warnings and Java parsers no longer implement it:
584
585 YYFAIL has existed for many years as an undocumented feature of
586 deterministic parsers in C generated by Bison. More recently, it was
587 a documented feature of Bison's experimental Java parsers. As
588 promised in Bison 2.4.2's NEWS entry, any appearance of YYFAIL in a
589 semantic action now produces a deprecation warning, and Java parsers
590 no longer implement YYFAIL at all. For further details, including a
591 discussion of how to suppress C preprocessor warnings about YYFAIL
592 being unused, see the Bison 2.4.2 NEWS entry.
593
594 ** Temporary hack for adding a semicolon to the user action:
595
596 Previously, Bison appended a semicolon to every user action for
597 reductions when the output language defaulted to C (specifically, when
598 neither %yacc, %language, %skeleton, or equivalent command-line
599 options were specified). This allowed actions such as
600
601 exp: exp "+" exp { $$ = $1 + $3 };
602
603 instead of
604
605 exp: exp "+" exp { $$ = $1 + $3; };
606
607 As a first step in removing this misfeature, Bison now issues a
608 warning when it appends a semicolon. Moreover, in cases where Bison
609 cannot easily determine whether a semicolon is needed (for example, an
610 action ending with a cpp directive or a braced compound initializer),
611 it no longer appends one. Thus, the C compiler might now complain
612 about a missing semicolon where it did not before. Future releases of
613 Bison will cease to append semicolons entirely.
614
615 ** Verbose syntax error message fixes:
616
617 When %error-verbose or the obsolete "#define YYERROR_VERBOSE" is
618 specified, syntax error messages produced by the generated parser
619 include the unexpected token as well as a list of expected tokens.
620 The effect of %nonassoc on these verbose messages has been corrected
621 in two ways, but a more complete fix requires LAC, described above:
622
623 *** When %nonassoc is used, there can exist parser states that accept no
624 tokens, and so the parser does not always require a lookahead token
625 in order to detect a syntax error. Because no unexpected token or
626 expected tokens can then be reported, the verbose syntax error
627 message described above is suppressed, and the parser instead
628 reports the simpler message, "syntax error". Previously, this
629 suppression was sometimes erroneously triggered by %nonassoc when a
630 lookahead was actually required. Now verbose messages are
631 suppressed only when all previous lookaheads have already been
632 shifted or discarded.
633
634 *** Previously, the list of expected tokens erroneously included tokens
635 that would actually induce a syntax error because conflicts for them
636 were resolved with %nonassoc in the current parser state. Such
637 tokens are now properly omitted from the list.
638
639 *** Expected token lists are still often wrong due to state merging
640 (from LALR or IELR) and default reductions, which can both add
641 invalid tokens and subtract valid tokens. Canonical LR almost
642 completely fixes this problem by eliminating state merging and
643 default reductions. However, there is one minor problem left even
644 when using canonical LR and even after the fixes above. That is,
645 if the resolution of a conflict with %nonassoc appears in a later
646 parser state than the one at which some syntax error is
647 discovered, the conflicted token is still erroneously included in
648 the expected token list. Bison's new LAC implementation,
649 described above, eliminates this problem and the need for
650 canonical LR. However, LAC is still experimental and is disabled
651 by default.
652
653 ** Java skeleton fixes:
654
655 *** A location handling bug has been fixed.
656
657 *** The top element of each of the value stack and location stack is now
658 cleared when popped so that it can be garbage collected.
659
660 *** Parser traces now print the top element of the stack.
661
662 ** -W/--warnings fixes:
663
664 *** Bison now properly recognizes the "no-" versions of categories:
665
666 For example, given the following command line, Bison now enables all
667 warnings except warnings for incompatibilities with POSIX Yacc:
668
669 bison -Wall,no-yacc gram.y
670
671 *** Bison now treats S/R and R/R conflicts like other warnings:
672
673 Previously, conflict reports were independent of Bison's normal
674 warning system. Now, Bison recognizes the warning categories
675 "conflicts-sr" and "conflicts-rr". This change has important
676 consequences for the -W and --warnings command-line options. For
677 example:
678
679 bison -Wno-conflicts-sr gram.y # S/R conflicts not reported
680 bison -Wno-conflicts-rr gram.y # R/R conflicts not reported
681 bison -Wnone gram.y # no conflicts are reported
682 bison -Werror gram.y # any conflict is an error
683
684 However, as before, if the %expect or %expect-rr directive is
685 specified, an unexpected number of conflicts is an error, and an
686 expected number of conflicts is not reported, so -W and --warning
687 then have no effect on the conflict report.
688
689 *** The "none" category no longer disables a preceding "error":
690
691 For example, for the following command line, Bison now reports
692 errors instead of warnings for incompatibilities with POSIX Yacc:
693
694 bison -Werror,none,yacc gram.y
695
696 *** The "none" category now disables all Bison warnings:
697
698 Previously, the "none" category disabled only Bison warnings for
699 which there existed a specific -W/--warning category. However,
700 given the following command line, Bison is now guaranteed to
701 suppress all warnings:
702
703 bison -Wnone gram.y
704
705 ** Precedence directives can now assign token number 0:
706
707 Since Bison 2.3b, which restored the ability of precedence
708 directives to assign token numbers, doing so for token number 0 has
709 produced an assertion failure. For example:
710
711 %left END 0
712
713 This bug has been fixed.
714
715 * Changes in version 2.4.3 (2010-08-05):
716
717 ** Bison now obeys -Werror and --warnings=error for warnings about
718 grammar rules that are useless in the parser due to conflicts.
719
720 ** Problems with spawning M4 on at least FreeBSD 8 and FreeBSD 9 have
721 been fixed.
722
723 ** Failures in the test suite for GCC 4.5 have been fixed.
724
725 ** Failures in the test suite for some versions of Sun Studio C++ have
726 been fixed.
727
728 ** Contrary to Bison 2.4.2's NEWS entry, it has been decided that
729 warnings about undefined %prec identifiers will not be converted to
730 errors in Bison 2.5. They will remain warnings, which should be
731 sufficient for POSIX while avoiding backward compatibility issues.
732
733 ** Minor documentation fixes.
734
735 * Changes in version 2.4.2 (2010-03-20):
736
737 ** Some portability problems that resulted in failures and livelocks
738 in the test suite on some versions of at least Solaris, AIX, HP-UX,
739 RHEL4, and Tru64 have been addressed. As a result, fatal Bison
740 errors should no longer cause M4 to report a broken pipe on the
741 affected platforms.
742
743 ** "%prec IDENTIFIER" requires IDENTIFIER to be defined separately.
744
745 POSIX specifies that an error be reported for any identifier that does
746 not appear on the LHS of a grammar rule and that is not defined by
747 %token, %left, %right, or %nonassoc. Bison 2.3b and later lost this
748 error report for the case when an identifier appears only after a
749 %prec directive. It is now restored. However, for backward
750 compatibility with recent Bison releases, it is only a warning for
751 now. In Bison 2.5 and later, it will return to being an error.
752 [Between the 2.4.2 and 2.4.3 releases, it was decided that this
753 warning will not be converted to an error in Bison 2.5.]
754
755 ** Detection of GNU M4 1.4.6 or newer during configure is improved.
756
757 ** Warnings from gcc's -Wundef option about undefined YYENABLE_NLS,
758 YYLTYPE_IS_TRIVIAL, and __STRICT_ANSI__ in C/C++ parsers are now
759 avoided.
760
761 ** %code is now a permanent feature.
762
763 A traditional Yacc prologue directive is written in the form:
764
765 %{CODE%}
766
767 To provide a more flexible alternative, Bison 2.3b introduced the
768 %code directive with the following forms for C/C++:
769
770 %code {CODE}
771 %code requires {CODE}
772 %code provides {CODE}
773 %code top {CODE}
774
775 These forms are now considered permanent features of Bison. See the
776 %code entries in the section "Bison Declaration Summary" in the Bison
777 manual for a summary of their functionality. See the section
778 "Prologue Alternatives" for a detailed discussion including the
779 advantages of %code over the traditional Yacc prologue directive.
780
781 Bison's Java feature as a whole including its current usage of %code
782 is still considered experimental.
783
784 ** YYFAIL is deprecated and will eventually be removed.
785
786 YYFAIL has existed for many years as an undocumented feature of
787 deterministic parsers in C generated by Bison. Previously, it was
788 documented for Bison's experimental Java parsers. YYFAIL is no longer
789 documented for Java parsers and is formally deprecated in both cases.
790 Users are strongly encouraged to migrate to YYERROR, which is
791 specified by POSIX.
792
793 Like YYERROR, you can invoke YYFAIL from a semantic action in order to
794 induce a syntax error. The most obvious difference from YYERROR is
795 that YYFAIL will automatically invoke yyerror to report the syntax
796 error so that you don't have to. However, there are several other
797 subtle differences between YYERROR and YYFAIL, and YYFAIL suffers from
798 inherent flaws when %error-verbose or "#define YYERROR_VERBOSE" is
799 used. For a more detailed discussion, see:
800
801 http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html
802
803 The upcoming Bison 2.5 will remove YYFAIL from Java parsers, but
804 deterministic parsers in C will continue to implement it. However,
805 because YYFAIL is already flawed, it seems futile to try to make new
806 Bison features compatible with it. Thus, during parser generation,
807 Bison 2.5 will produce a warning whenever it discovers YYFAIL in a
808 rule action. In a later release, YYFAIL will be disabled for
809 %error-verbose and "#define YYERROR_VERBOSE". Eventually, YYFAIL will
810 be removed altogether.
811
812 There exists at least one case where Bison 2.5's YYFAIL warning will
813 be a false positive. Some projects add phony uses of YYFAIL and other
814 Bison-defined macros for the sole purpose of suppressing C
815 preprocessor warnings (from GCC cpp's -Wunused-macros, for example).
816 To avoid Bison's future warning, such YYFAIL uses can be moved to the
817 epilogue (that is, after the second "%%") in the Bison input file. In
818 this release (2.4.2), Bison already generates its own code to suppress
819 C preprocessor warnings for YYFAIL, so projects can remove their own
820 phony uses of YYFAIL if compatibility with Bison releases prior to
821 2.4.2 is not necessary.
822
823 ** Internationalization.
824
825 Fix a regression introduced in Bison 2.4: Under some circumstances,
826 message translations were not installed although supported by the
827 host system.
828
829 * Changes in version 2.4.1 (2008-12-11):
830
831 ** In the GLR defines file, unexpanded M4 macros in the yylval and yylloc
832 declarations have been fixed.
833
834 ** Temporary hack for adding a semicolon to the user action.
835
836 Bison used to prepend a trailing semicolon at the end of the user
837 action for reductions. This allowed actions such as
838
839 exp: exp "+" exp { $$ = $1 + $3 };
840
841 instead of
842
843 exp: exp "+" exp { $$ = $1 + $3; };
844
845 Some grammars still depend on this "feature". Bison 2.4.1 restores
846 the previous behavior in the case of C output (specifically, when
847 neither %language or %skeleton or equivalent command-line options
848 are used) to leave more time for grammars depending on the old
849 behavior to be adjusted. Future releases of Bison will disable this
850 feature.
851
852 ** A few minor improvements to the Bison manual.
853
854 * Changes in version 2.4 (2008-11-02):
855
856 ** %language is an experimental feature.
857
858 We first introduced this feature in test release 2.3b as a cleaner
859 alternative to %skeleton. Since then, we have discussed the possibility of
860 modifying its effect on Bison's output file names. Thus, in this release,
861 we consider %language to be an experimental feature that will likely evolve
862 in future releases.
863
864 ** Forward compatibility with GNU M4 has been improved.
865
866 ** Several bugs in the C++ skeleton and the experimental Java skeleton have been
867 fixed.
868
869 * Changes in version 2.3b (2008-05-27):
870
871 ** The quotes around NAME that used to be required in the following directive
872 are now deprecated:
873
874 %define NAME "VALUE"
875
876 ** The directive "%pure-parser" is now deprecated in favor of:
877
878 %define api.pure
879
880 which has the same effect except that Bison is more careful to warn about
881 unreasonable usage in the latter case.
882
883 ** Push Parsing
884
885 Bison can now generate an LALR(1) parser in C with a push interface. That
886 is, instead of invoking "yyparse", which pulls tokens from "yylex", you can
887 push one token at a time to the parser using "yypush_parse", which will
888 return to the caller after processing each token. By default, the push
889 interface is disabled. Either of the following directives will enable it:
890
891 %define api.push_pull "push" // Just push; does not require yylex.
892 %define api.push_pull "both" // Push and pull; requires yylex.
893
894 See the new section "A Push Parser" in the Bison manual for details.
895
896 The current push parsing interface is experimental and may evolve. More user
897 feedback will help to stabilize it.
898
899 ** The -g and --graph options now output graphs in Graphviz DOT format,
900 not VCG format. Like --graph, -g now also takes an optional FILE argument
901 and thus cannot be bundled with other short options.
902
903 ** Java
904
905 Bison can now generate an LALR(1) parser in Java. The skeleton is
906 "data/lalr1.java". Consider using the new %language directive instead of
907 %skeleton to select it.
908
909 See the new section "Java Parsers" in the Bison manual for details.
910
911 The current Java interface is experimental and may evolve. More user
912 feedback will help to stabilize it.
913
914 ** %language
915
916 This new directive specifies the programming language of the generated
917 parser, which can be C (the default), C++, or Java. Besides the skeleton
918 that Bison uses, the directive affects the names of the generated files if
919 the grammar file's name ends in ".y".
920
921 ** XML Automaton Report
922
923 Bison can now generate an XML report of the LALR(1) automaton using the new
924 "--xml" option. The current XML schema is experimental and may evolve. More
925 user feedback will help to stabilize it.
926
927 ** The grammar file may now specify the name of the parser header file using
928 %defines. For example:
929
930 %defines "parser.h"
931
932 ** When reporting useless rules, useless nonterminals, and unused terminals,
933 Bison now employs the terms "useless in grammar" instead of "useless",
934 "useless in parser" instead of "never reduced", and "unused in grammar"
935 instead of "unused".
936
937 ** Unreachable State Removal
938
939 Previously, Bison sometimes generated parser tables containing unreachable
940 states. A state can become unreachable during conflict resolution if Bison
941 disables a shift action leading to it from a predecessor state. Bison now:
942
943 1. Removes unreachable states.
944
945 2. Does not report any conflicts that appeared in unreachable states.
946 WARNING: As a result, you may need to update %expect and %expect-rr
947 directives in existing grammar files.
948
949 3. For any rule used only in such states, Bison now reports the rule as
950 "useless in parser due to conflicts".
951
952 This feature can be disabled with the following directive:
953
954 %define lr.keep_unreachable_states
955
956 See the %define entry in the "Bison Declaration Summary" in the Bison manual
957 for further discussion.
958
959 ** Lookahead Set Correction in the ".output" Report
960
961 When instructed to generate a ".output" file including lookahead sets
962 (using "--report=lookahead", for example), Bison now prints each reduction's
963 lookahead set only next to the associated state's one item that (1) is
964 associated with the same rule as the reduction and (2) has its dot at the end
965 of its RHS. Previously, Bison also erroneously printed the lookahead set
966 next to all of the state's other items associated with the same rule. This
967 bug affected only the ".output" file and not the generated parser source
968 code.
969
970 ** --report-file=FILE is a new option to override the default ".output" file
971 name.
972
973 ** The "=" that used to be required in the following directives is now
974 deprecated:
975
976 %file-prefix "parser"
977 %name-prefix "c_"
978 %output "parser.c"
979
980 ** An Alternative to "%{...%}" -- "%code QUALIFIER {CODE}"
981
982 Bison 2.3a provided a new set of directives as a more flexible alternative to
983 the traditional Yacc prologue blocks. Those have now been consolidated into
984 a single %code directive with an optional qualifier field, which identifies
985 the purpose of the code and thus the location(s) where Bison should generate
986 it:
987
988 1. "%code {CODE}" replaces "%after-header {CODE}"
989 2. "%code requires {CODE}" replaces "%start-header {CODE}"
990 3. "%code provides {CODE}" replaces "%end-header {CODE}"
991 4. "%code top {CODE}" replaces "%before-header {CODE}"
992
993 See the %code entries in section "Bison Declaration Summary" in the Bison
994 manual for a summary of the new functionality. See the new section "Prologue
995 Alternatives" for a detailed discussion including the advantages of %code
996 over the traditional Yacc prologues.
997
998 The prologue alternatives are experimental. More user feedback will help to
999 determine whether they should become permanent features.
1000
1001 ** Revised warning: unset or unused mid-rule values
1002
1003 Since Bison 2.2, Bison has warned about mid-rule values that are set but not
1004 used within any of the actions of the parent rule. For example, Bison warns
1005 about unused $2 in:
1006
1007 exp: '1' { $$ = 1; } '+' exp { $$ = $1 + $4; };
1008
1009 Now, Bison also warns about mid-rule values that are used but not set. For
1010 example, Bison warns about unset $$ in the mid-rule action in:
1011
1012 exp: '1' { $1 = 1; } '+' exp { $$ = $2 + $4; };
1013
1014 However, Bison now disables both of these warnings by default since they
1015 sometimes prove to be false alarms in existing grammars employing the Yacc
1016 constructs $0 or $-N (where N is some positive integer).
1017
1018 To enable these warnings, specify the option "--warnings=midrule-values" or
1019 "-W", which is a synonym for "--warnings=all".
1020
1021 ** Default %destructor or %printer with "<*>" or "<>"
1022
1023 Bison now recognizes two separate kinds of default %destructor's and
1024 %printer's:
1025
1026 1. Place "<*>" in a %destructor/%printer symbol list to define a default
1027 %destructor/%printer for all grammar symbols for which you have formally
1028 declared semantic type tags.
1029
1030 2. Place "<>" in a %destructor/%printer symbol list to define a default
1031 %destructor/%printer for all grammar symbols without declared semantic
1032 type tags.
1033
1034 Bison no longer supports the "%symbol-default" notation from Bison 2.3a.
1035 "<*>" and "<>" combined achieve the same effect with one exception: Bison no
1036 longer applies any %destructor to a mid-rule value if that mid-rule value is
1037 not actually ever referenced using either $$ or $n in a semantic action.
1038
1039 The default %destructor's and %printer's are experimental. More user
1040 feedback will help to determine whether they should become permanent
1041 features.
1042
1043 See the section "Freeing Discarded Symbols" in the Bison manual for further
1044 details.
1045
1046 ** %left, %right, and %nonassoc can now declare token numbers. This is required
1047 by POSIX. However, see the end of section "Operator Precedence" in the Bison
1048 manual for a caveat concerning the treatment of literal strings.
1049
1050 ** The nonfunctional --no-parser, -n, and %no-parser options have been
1051 completely removed from Bison.
1052
1053 * Changes in version 2.3a, 2006-09-13:
1054
1055 ** Instead of %union, you can define and use your own union type
1056 YYSTYPE if your grammar contains at least one <type> tag.
1057 Your YYSTYPE need not be a macro; it can be a typedef.
1058 This change is for compatibility with other Yacc implementations,
1059 and is required by POSIX.
1060
1061 ** Locations columns and lines start at 1.
1062 In accordance with the GNU Coding Standards and Emacs.
1063
1064 ** You may now declare per-type and default %destructor's and %printer's:
1065
1066 For example:
1067
1068 %union { char *string; }
1069 %token <string> STRING1
1070 %token <string> STRING2
1071 %type <string> string1
1072 %type <string> string2
1073 %union { char character; }
1074 %token <character> CHR
1075 %type <character> chr
1076 %destructor { free ($$); } %symbol-default
1077 %destructor { free ($$); printf ("%d", @$.first_line); } STRING1 string1
1078 %destructor { } <character>
1079
1080 guarantees that, when the parser discards any user-defined symbol that has a
1081 semantic type tag other than "<character>", it passes its semantic value to
1082 "free". However, when the parser discards a "STRING1" or a "string1", it
1083 also prints its line number to "stdout". It performs only the second
1084 "%destructor" in this case, so it invokes "free" only once.
1085
1086 [Although we failed to mention this here in the 2.3a release, the default
1087 %destructor's and %printer's were experimental, and they were rewritten in
1088 future versions.]
1089
1090 ** Except for LALR(1) parsers in C with POSIX Yacc emulation enabled (with "-y",
1091 "--yacc", or "%yacc"), Bison no longer generates #define statements for
1092 associating token numbers with token names. Removing the #define statements
1093 helps to sanitize the global namespace during preprocessing, but POSIX Yacc
1094 requires them. Bison still generates an enum for token names in all cases.
1095
1096 ** Handling of traditional Yacc prologue blocks is now more consistent but
1097 potentially incompatible with previous releases of Bison.
1098
1099 As before, you declare prologue blocks in your grammar file with the
1100 "%{ ... %}" syntax. To generate the pre-prologue, Bison concatenates all
1101 prologue blocks that you've declared before the first %union. To generate
1102 the post-prologue, Bison concatenates all prologue blocks that you've
1103 declared after the first %union.
1104
1105 Previous releases of Bison inserted the pre-prologue into both the header
1106 file and the code file in all cases except for LALR(1) parsers in C. In the
1107 latter case, Bison inserted it only into the code file. For parsers in C++,
1108 the point of insertion was before any token definitions (which associate
1109 token numbers with names). For parsers in C, the point of insertion was
1110 after the token definitions.
1111
1112 Now, Bison never inserts the pre-prologue into the header file. In the code
1113 file, it always inserts it before the token definitions.
1114
1115 ** Bison now provides a more flexible alternative to the traditional Yacc
1116 prologue blocks: %before-header, %start-header, %end-header, and
1117 %after-header.
1118
1119 For example, the following declaration order in the grammar file reflects the
1120 order in which Bison will output these code blocks. However, you are free to
1121 declare these code blocks in your grammar file in whatever order is most
1122 convenient for you:
1123
1124 %before-header {
1125 /* Bison treats this block like a pre-prologue block: it inserts it into
1126 * the code file before the contents of the header file. It does *not*
1127 * insert it into the header file. This is a good place to put
1128 * #include's that you want at the top of your code file. A common
1129 * example is '#include "system.h"'. */
1130 }
1131 %start-header {
1132 /* Bison inserts this block into both the header file and the code file.
1133 * In both files, the point of insertion is before any Bison-generated
1134 * token, semantic type, location type, and class definitions. This is a
1135 * good place to define %union dependencies, for example. */
1136 }
1137 %union {
1138 /* Unlike the traditional Yacc prologue blocks, the output order for the
1139 * new %*-header blocks is not affected by their declaration position
1140 * relative to any %union in the grammar file. */
1141 }
1142 %end-header {
1143 /* Bison inserts this block into both the header file and the code file.
1144 * In both files, the point of insertion is after the Bison-generated
1145 * definitions. This is a good place to declare or define public
1146 * functions or data structures that depend on the Bison-generated
1147 * definitions. */
1148 }
1149 %after-header {
1150 /* Bison treats this block like a post-prologue block: it inserts it into
1151 * the code file after the contents of the header file. It does *not*
1152 * insert it into the header file. This is a good place to declare or
1153 * define internal functions or data structures that depend on the
1154 * Bison-generated definitions. */
1155 }
1156
1157 If you have multiple occurrences of any one of the above declarations, Bison
1158 will concatenate the contents in declaration order.
1159
1160 [Although we failed to mention this here in the 2.3a release, the prologue
1161 alternatives were experimental, and they were rewritten in future versions.]
1162
1163 ** The option "--report=look-ahead" has been changed to "--report=lookahead".
1164 The old spelling still works, but is not documented and may be removed
1165 in a future release.
1166
1167 * Changes in version 2.3, 2006-06-05:
1168
1169 ** GLR grammars should now use "YYRECOVERING ()" instead of "YYRECOVERING",
1170 for compatibility with LALR(1) grammars.
1171
1172 ** It is now documented that any definition of YYSTYPE or YYLTYPE should
1173 be to a type name that does not contain parentheses or brackets.
1174
1175 * Changes in version 2.2, 2006-05-19:
1176
1177 ** The distribution terms for all Bison-generated parsers now permit
1178 using the parsers in nonfree programs. Previously, this permission
1179 was granted only for Bison-generated LALR(1) parsers in C.
1180
1181 ** %name-prefix changes the namespace name in C++ outputs.
1182
1183 ** The C++ parsers export their token_type.
1184
1185 ** Bison now allows multiple %union declarations, and concatenates
1186 their contents together.
1187
1188 ** New warning: unused values
1189 Right-hand side symbols whose values are not used are reported,
1190 if the symbols have destructors. For instance:
1191
1192 exp: exp "?" exp ":" exp { $1 ? $1 : $3; }
1193 | exp "+" exp
1194 ;
1195
1196 will trigger a warning about $$ and $5 in the first rule, and $3 in
1197 the second ($1 is copied to $$ by the default rule). This example
1198 most likely contains three errors, and could be rewritten as:
1199
1200 exp: exp "?" exp ":" exp
1201 { $$ = $1 ? $3 : $5; free ($1 ? $5 : $3); free ($1); }
1202 | exp "+" exp
1203 { $$ = $1 ? $1 : $3; if ($1) free ($3); }
1204 ;
1205
1206 However, if the original actions were really intended, memory leaks
1207 and all, the warnings can be suppressed by letting Bison believe the
1208 values are used, e.g.:
1209
1210 exp: exp "?" exp ":" exp { $1 ? $1 : $3; (void) ($$, $5); }
1211 | exp "+" exp { $$ = $1; (void) $3; }
1212 ;
1213
1214 If there are mid-rule actions, the warning is issued if no action
1215 uses it. The following triggers no warning: $1 and $3 are used.
1216
1217 exp: exp { push ($1); } '+' exp { push ($3); sum (); };
1218
1219 The warning is intended to help catching lost values and memory leaks.
1220 If a value is ignored, its associated memory typically is not reclaimed.
1221
1222 ** %destructor vs. YYABORT, YYACCEPT, and YYERROR.
1223 Destructors are now called when user code invokes YYABORT, YYACCEPT,
1224 and YYERROR, for all objects on the stack, other than objects
1225 corresponding to the right-hand side of the current rule.
1226
1227 ** %expect, %expect-rr
1228 Incorrect numbers of expected conflicts are now actual errors,
1229 instead of warnings.
1230
1231 ** GLR, YACC parsers.
1232 The %parse-params are available in the destructors (and the
1233 experimental printers) as per the documentation.
1234
1235 ** Bison now warns if it finds a stray "$" or "@" in an action.
1236
1237 ** %require "VERSION"
1238 This specifies that the grammar file depends on features implemented
1239 in Bison version VERSION or higher.
1240
1241 ** lalr1.cc: The token and value types are now class members.
1242 The tokens were defined as free form enums and cpp macros. YYSTYPE
1243 was defined as a free form union. They are now class members:
1244 tokens are enumerations of the "yy::parser::token" struct, and the
1245 semantic values have the "yy::parser::semantic_type" type.
1246
1247 If you do not want or can update to this scheme, the directive
1248 '%define "global_tokens_and_yystype" "1"' triggers the global
1249 definition of tokens and YYSTYPE. This change is suitable both
1250 for previous releases of Bison, and this one.
1251
1252 If you wish to update, then make sure older version of Bison will
1253 fail using '%require "2.2"'.
1254
1255 ** DJGPP support added.
1256 \f
1257 * Changes in version 2.1, 2005-09-16:
1258
1259 ** The C++ lalr1.cc skeleton supports %lex-param.
1260
1261 ** Bison-generated parsers now support the translation of diagnostics like
1262 "syntax error" into languages other than English. The default
1263 language is still English. For details, please see the new
1264 Internationalization section of the Bison manual. Software
1265 distributors should also see the new PACKAGING file. Thanks to
1266 Bruno Haible for this new feature.
1267
1268 ** Wording in the Bison-generated parsers has been changed slightly to
1269 simplify translation. In particular, the message "memory exhausted"
1270 has replaced "parser stack overflow", as the old message was not
1271 always accurate for modern Bison-generated parsers.
1272
1273 ** Destructors are now called when the parser aborts, for all symbols left
1274 behind on the stack. Also, the start symbol is now destroyed after a
1275 successful parse. In both cases, the behavior was formerly inconsistent.
1276
1277 ** When generating verbose diagnostics, Bison-generated parsers no longer
1278 quote the literal strings associated with tokens. For example, for
1279 a syntax error associated with '%token NUM "number"' they might
1280 print 'syntax error, unexpected number' instead of 'syntax error,
1281 unexpected "number"'.
1282 \f
1283 * Changes in version 2.0, 2004-12-25:
1284
1285 ** Possibly-incompatible changes
1286
1287 - Bison-generated parsers no longer default to using the alloca function
1288 (when available) to extend the parser stack, due to widespread
1289 problems in unchecked stack-overflow detection. You can "#define
1290 YYSTACK_USE_ALLOCA 1" to require the use of alloca, but please read
1291 the manual to determine safe values for YYMAXDEPTH in that case.
1292
1293 - Error token location.
1294 During error recovery, the location of the syntax error is updated
1295 to cover the whole sequence covered by the error token: it includes
1296 the shifted symbols thrown away during the first part of the error
1297 recovery, and the lookahead rejected during the second part.
1298
1299 - Semicolon changes:
1300 . Stray semicolons are no longer allowed at the start of a grammar.
1301 . Semicolons are now required after in-grammar declarations.
1302
1303 - Unescaped newlines are no longer allowed in character constants or
1304 string literals. They were never portable, and GCC 3.4.0 has
1305 dropped support for them. Better diagnostics are now generated if
1306 forget a closing quote.
1307
1308 - NUL bytes are no longer allowed in Bison string literals, unfortunately.
1309
1310 ** New features
1311
1312 - GLR grammars now support locations.
1313
1314 - New directive: %initial-action.
1315 This directive allows the user to run arbitrary code (including
1316 initializing @$) from yyparse before parsing starts.
1317
1318 - A new directive "%expect-rr N" specifies the expected number of
1319 reduce/reduce conflicts in GLR parsers.
1320
1321 - %token numbers can now be hexadecimal integers, e.g., "%token FOO 0x12d".
1322 This is a GNU extension.
1323
1324 - The option "--report=lookahead" was changed to "--report=look-ahead".
1325 [However, this was changed back after 2.3.]
1326
1327 - Experimental %destructor support has been added to lalr1.cc.
1328
1329 - New configure option --disable-yacc, to disable installation of the
1330 yacc command and -ly library introduced in 1.875 for POSIX conformance.
1331
1332 ** Bug fixes
1333
1334 - For now, %expect-count violations are now just warnings, not errors.
1335 This is for compatibility with Bison 1.75 and earlier (when there are
1336 reduce/reduce conflicts) and with Bison 1.30 and earlier (when there
1337 are too many or too few shift/reduce conflicts). However, in future
1338 versions of Bison we plan to improve the %expect machinery so that
1339 these violations will become errors again.
1340
1341 - Within Bison itself, numbers (e.g., goto numbers) are no longer
1342 arbitrarily limited to 16-bit counts.
1343
1344 - Semicolons are now allowed before "|" in grammar rules, as POSIX requires.
1345 \f
1346 * Changes in version 1.875, 2003-01-01:
1347
1348 ** The documentation license has been upgraded to version 1.2
1349 of the GNU Free Documentation License.
1350
1351 ** syntax error processing
1352
1353 - In Yacc-style parsers YYLLOC_DEFAULT is now used to compute error
1354 locations too. This fixes bugs in error-location computation.
1355
1356 - %destructor
1357 It is now possible to reclaim the memory associated to symbols
1358 discarded during error recovery. This feature is still experimental.
1359
1360 - %error-verbose
1361 This new directive is preferred over YYERROR_VERBOSE.
1362
1363 - #defining yyerror to steal internal variables is discouraged.
1364 It is not guaranteed to work forever.
1365
1366 ** POSIX conformance
1367
1368 - Semicolons are once again optional at the end of grammar rules.
1369 This reverts to the behavior of Bison 1.33 and earlier, and improves
1370 compatibility with Yacc.
1371
1372 - "parse error" -> "syntax error"
1373 Bison now uniformly uses the term "syntax error"; formerly, the code
1374 and manual sometimes used the term "parse error" instead. POSIX
1375 requires "syntax error" in diagnostics, and it was thought better to
1376 be consistent.
1377
1378 - The documentation now emphasizes that yylex and yyerror must be
1379 declared before use. C99 requires this.
1380
1381 - Bison now parses C99 lexical constructs like UCNs and
1382 backslash-newline within C escape sequences, as POSIX 1003.1-2001 requires.
1383
1384 - File names are properly escaped in C output. E.g., foo\bar.y is
1385 output as "foo\\bar.y".
1386
1387 - Yacc command and library now available
1388 The Bison distribution now installs a "yacc" command, as POSIX requires.
1389 Also, Bison now installs a small library liby.a containing
1390 implementations of Yacc-compatible yyerror and main functions.
1391 This library is normally not useful, but POSIX requires it.
1392
1393 - Type clashes now generate warnings, not errors.
1394
1395 - If the user does not define YYSTYPE as a macro, Bison now declares it
1396 using typedef instead of defining it as a macro.
1397 For consistency, YYLTYPE is also declared instead of defined.
1398
1399 ** Other compatibility issues
1400
1401 - %union directives can now have a tag before the "{", e.g., the
1402 directive "%union foo {...}" now generates the C code
1403 "typedef union foo { ... } YYSTYPE;"; this is for Yacc compatibility.
1404 The default union tag is "YYSTYPE", for compatibility with Solaris 9 Yacc.
1405 For consistency, YYLTYPE's struct tag is now "YYLTYPE" not "yyltype".
1406 This is for compatibility with both Yacc and Bison 1.35.
1407
1408 - ";" is output before the terminating "}" of an action, for
1409 compatibility with Bison 1.35.
1410
1411 - Bison now uses a Yacc-style format for conflict reports, e.g.,
1412 "conflicts: 2 shift/reduce, 1 reduce/reduce".
1413
1414 - "yystype" and "yyltype" are now obsolescent macros instead of being
1415 typedefs or tags; they are no longer documented and are planned to be
1416 withdrawn in a future release.
1417
1418 ** GLR parser notes
1419
1420 - GLR and inline
1421 Users of Bison have to decide how they handle the portability of the
1422 C keyword "inline".
1423
1424 - "parsing stack overflow..." -> "parser stack overflow"
1425 GLR parsers now report "parser stack overflow" as per the Bison manual.
1426
1427 ** %parse-param and %lex-param
1428 The macros YYPARSE_PARAM and YYLEX_PARAM provide a means to pass
1429 additional context to yyparse and yylex. They suffer from several
1430 shortcomings:
1431
1432 - a single argument only can be added,
1433 - their types are weak (void *),
1434 - this context is not passed to ancillary functions such as yyerror,
1435 - only yacc.c parsers support them.
1436
1437 The new %parse-param/%lex-param directives provide a more precise control.
1438 For instance:
1439
1440 %parse-param {int *nastiness}
1441 %lex-param {int *nastiness}
1442 %parse-param {int *randomness}
1443
1444 results in the following signatures:
1445
1446 int yylex (int *nastiness);
1447 int yyparse (int *nastiness, int *randomness);
1448
1449 or, if both %pure-parser and %locations are used:
1450
1451 int yylex (YYSTYPE *lvalp, YYLTYPE *llocp, int *nastiness);
1452 int yyparse (int *nastiness, int *randomness);
1453
1454 ** Bison now warns if it detects conflicting outputs to the same file,
1455 e.g., it generates a warning for "bison -d -o foo.h foo.y" since
1456 that command outputs both code and header to foo.h.
1457
1458 ** #line in output files
1459 - --no-line works properly.
1460
1461 ** Bison can no longer be built by a K&R C compiler; it requires C89 or
1462 later to be built. This change originally took place a few versions
1463 ago, but nobody noticed until we recently asked someone to try
1464 building Bison with a K&R C compiler.
1465 \f
1466 * Changes in version 1.75, 2002-10-14:
1467
1468 ** Bison should now work on 64-bit hosts.
1469
1470 ** Indonesian translation thanks to Tedi Heriyanto.
1471
1472 ** GLR parsers
1473 Fix spurious parse errors.
1474
1475 ** Pure parsers
1476 Some people redefine yyerror to steal yyparse' private variables.
1477 Reenable this trick until an official feature replaces it.
1478
1479 ** Type Clashes
1480 In agreement with POSIX and with other Yaccs, leaving a default
1481 action is valid when $$ is untyped, and $1 typed:
1482
1483 untyped: ... typed;
1484
1485 but the converse remains an error:
1486
1487 typed: ... untyped;
1488
1489 ** Values of mid-rule actions
1490 The following code:
1491
1492 foo: { ... } { $$ = $1; } ...
1493
1494 was incorrectly rejected: $1 is defined in the second mid-rule
1495 action, and is equal to the $$ of the first mid-rule action.
1496 \f
1497 * Changes in version 1.50, 2002-10-04:
1498
1499 ** GLR parsing
1500 The declaration
1501 %glr-parser
1502 causes Bison to produce a Generalized LR (GLR) parser, capable of handling
1503 almost any context-free grammar, ambiguous or not. The new declarations
1504 %dprec and %merge on grammar rules allow parse-time resolution of
1505 ambiguities. Contributed by Paul Hilfinger.
1506
1507 Unfortunately Bison 1.50 does not work properly on 64-bit hosts
1508 like the Alpha, so please stick to 32-bit hosts for now.
1509
1510 ** Output Directory
1511 When not in Yacc compatibility mode, when the output file was not
1512 specified, running "bison foo/bar.y" created "foo/bar.c". It
1513 now creates "bar.c".
1514
1515 ** Undefined token
1516 The undefined token was systematically mapped to 2 which prevented
1517 the use of 2 by the user. This is no longer the case.
1518
1519 ** Unknown token numbers
1520 If yylex returned an out of range value, yyparse could die. This is
1521 no longer the case.
1522
1523 ** Error token
1524 According to POSIX, the error token must be 256.
1525 Bison extends this requirement by making it a preference: *if* the
1526 user specified that one of her tokens is numbered 256, then error
1527 will be mapped onto another number.
1528
1529 ** Verbose error messages
1530 They no longer report "..., expecting error or..." for states where
1531 error recovery is possible.
1532
1533 ** End token
1534 Defaults to "$end" instead of "$".
1535
1536 ** Error recovery now conforms to documentation and to POSIX
1537 When a Bison-generated parser encounters a syntax error, it now pops
1538 the stack until it finds a state that allows shifting the error
1539 token. Formerly, it popped the stack until it found a state that
1540 allowed some non-error action other than a default reduction on the
1541 error token. The new behavior has long been the documented behavior,
1542 and has long been required by POSIX. For more details, please see
1543 Paul Eggert, "Reductions during Bison error handling" (2002-05-20)
1544 <http://lists.gnu.org/archive/html/bug-bison/2002-05/msg00038.html>.
1545
1546 ** Traces
1547 Popped tokens and nonterminals are now reported.
1548
1549 ** Larger grammars
1550 Larger grammars are now supported (larger token numbers, larger grammar
1551 size (= sum of the LHS and RHS lengths), larger LALR tables).
1552 Formerly, many of these numbers ran afoul of 16-bit limits;
1553 now these limits are 32 bits on most hosts.
1554
1555 ** Explicit initial rule
1556 Bison used to play hacks with the initial rule, which the user does
1557 not write. It is now explicit, and visible in the reports and
1558 graphs as rule 0.
1559
1560 ** Useless rules
1561 Before, Bison reported the useless rules, but, although not used,
1562 included them in the parsers. They are now actually removed.
1563
1564 ** Useless rules, useless nonterminals
1565 They are now reported, as a warning, with their locations.
1566
1567 ** Rules never reduced
1568 Rules that can never be reduced because of conflicts are now
1569 reported.
1570
1571 ** Incorrect "Token not used"
1572 On a grammar such as
1573
1574 %token useless useful
1575 %%
1576 exp: '0' %prec useful;
1577
1578 where a token was used to set the precedence of the last rule,
1579 bison reported both "useful" and "useless" as useless tokens.
1580
1581 ** Revert the C++ namespace changes introduced in 1.31
1582 as they caused too many portability hassles.
1583
1584 ** Default locations
1585 By an accident of design, the default computation of @$ was
1586 performed after another default computation was performed: @$ = @1.
1587 The latter is now removed: YYLLOC_DEFAULT is fully responsible of
1588 the computation of @$.
1589
1590 ** Token end-of-file
1591 The token end of file may be specified by the user, in which case,
1592 the user symbol is used in the reports, the graphs, and the verbose
1593 error messages instead of "$end", which remains being the default.
1594 For instance
1595 %token MYEOF 0
1596 or
1597 %token MYEOF 0 "end of file"
1598
1599 ** Semantic parser
1600 This old option, which has been broken for ages, is removed.
1601
1602 ** New translations
1603 Brazilian Portuguese, thanks to Alexandre Folle de Menezes.
1604 Croatian, thanks to Denis Lackovic.
1605
1606 ** Incorrect token definitions
1607 When given
1608 %token 'a' "A"
1609 bison used to output
1610 #define 'a' 65
1611
1612 ** Token definitions as enums
1613 Tokens are output both as the traditional #define's, and, provided
1614 the compiler supports ANSI C or is a C++ compiler, as enums.
1615 This lets debuggers display names instead of integers.
1616
1617 ** Reports
1618 In addition to --verbose, bison supports --report=THINGS, which
1619 produces additional information:
1620 - itemset
1621 complete the core item sets with their closure
1622 - lookahead [changed to "look-ahead" in 1.875e through 2.3, but changed back]
1623 explicitly associate lookahead tokens to items
1624 - solved
1625 describe shift/reduce conflicts solving.
1626 Bison used to systematically output this information on top of
1627 the report. Solved conflicts are now attached to their states.
1628
1629 ** Type clashes
1630 Previous versions don't complain when there is a type clash on
1631 the default action if the rule has a mid-rule action, such as in:
1632
1633 %type <foo> bar
1634 %%
1635 bar: '0' {} '0';
1636
1637 This is fixed.
1638
1639 ** GNU M4 is now required when using Bison.
1640 \f
1641 * Changes in version 1.35, 2002-03-25:
1642
1643 ** C Skeleton
1644 Some projects use Bison's C parser with C++ compilers, and define
1645 YYSTYPE as a class. The recent adjustment of C parsers for data
1646 alignment and 64 bit architectures made this impossible.
1647
1648 Because for the time being no real solution for C++ parser
1649 generation exists, kludges were implemented in the parser to
1650 maintain this use. In the future, when Bison has C++ parsers, this
1651 kludge will be disabled.
1652
1653 This kludge also addresses some C++ problems when the stack was
1654 extended.
1655 \f
1656 * Changes in version 1.34, 2002-03-12:
1657
1658 ** File name clashes are detected
1659 $ bison foo.y -d -o foo.x
1660 fatal error: header and parser would both be named "foo.x"
1661
1662 ** A missing ";" at the end of a rule triggers a warning
1663 In accordance with POSIX, and in agreement with other
1664 Yacc implementations, Bison will mandate this semicolon in the near
1665 future. This eases the implementation of a Bison parser of Bison
1666 grammars by making this grammar LALR(1) instead of LR(2). To
1667 facilitate the transition, this release introduces a warning.
1668
1669 ** Revert the C++ namespace changes introduced in 1.31, as they caused too
1670 many portability hassles.
1671
1672 ** DJGPP support added.
1673
1674 ** Fix test suite portability problems.
1675 \f
1676 * Changes in version 1.33, 2002-02-07:
1677
1678 ** Fix C++ issues
1679 Groff could not be compiled for the definition of size_t was lacking
1680 under some conditions.
1681
1682 ** Catch invalid @n
1683 As is done with $n.
1684 \f
1685 * Changes in version 1.32, 2002-01-23:
1686
1687 ** Fix Yacc output file names
1688
1689 ** Portability fixes
1690
1691 ** Italian, Dutch translations
1692 \f
1693 * Changes in version 1.31, 2002-01-14:
1694
1695 ** Many Bug Fixes
1696
1697 ** GNU Gettext and %expect
1698 GNU Gettext asserts 10 s/r conflicts, but there are 7. Now that
1699 Bison dies on incorrect %expectations, we fear there will be
1700 too many bug reports for Gettext, so _for the time being_, %expect
1701 does not trigger an error when the input file is named "plural.y".
1702
1703 ** Use of alloca in parsers
1704 If YYSTACK_USE_ALLOCA is defined to 0, then the parsers will use
1705 malloc exclusively. Since 1.29, but was not NEWS'ed.
1706
1707 alloca is used only when compiled with GCC, to avoid portability
1708 problems as on AIX.
1709
1710 ** yyparse now returns 2 if memory is exhausted; formerly it dumped core.
1711
1712 ** When the generated parser lacks debugging code, YYDEBUG is now 0
1713 (as POSIX requires) instead of being undefined.
1714
1715 ** User Actions
1716 Bison has always permitted actions such as { $$ = $1 }: it adds the
1717 ending semicolon. Now if in Yacc compatibility mode, the semicolon
1718 is no longer output: one has to write { $$ = $1; }.
1719
1720 ** Better C++ compliance
1721 The output parsers try to respect C++ namespaces.
1722 [This turned out to be a failed experiment, and it was reverted later.]
1723
1724 ** Reduced Grammars
1725 Fixed bugs when reporting useless nonterminals.
1726
1727 ** 64 bit hosts
1728 The parsers work properly on 64 bit hosts.
1729
1730 ** Error messages
1731 Some calls to strerror resulted in scrambled or missing error messages.
1732
1733 ** %expect
1734 When the number of shift/reduce conflicts is correct, don't issue
1735 any warning.
1736
1737 ** The verbose report includes the rule line numbers.
1738
1739 ** Rule line numbers are fixed in traces.
1740
1741 ** Swedish translation
1742
1743 ** Parse errors
1744 Verbose parse error messages from the parsers are better looking.
1745 Before: parse error: unexpected `'/'', expecting `"number"' or `'-'' or `'(''
1746 Now: parse error: unexpected '/', expecting "number" or '-' or '('
1747
1748 ** Fixed parser memory leaks.
1749 When the generated parser was using malloc to extend its stacks, the
1750 previous allocations were not freed.
1751
1752 ** Fixed verbose output file.
1753 Some newlines were missing.
1754 Some conflicts in state descriptions were missing.
1755
1756 ** Fixed conflict report.
1757 Option -v was needed to get the result.
1758
1759 ** %expect
1760 Was not used.
1761 Mismatches are errors, not warnings.
1762
1763 ** Fixed incorrect processing of some invalid input.
1764
1765 ** Fixed CPP guards: 9foo.h uses BISON_9FOO_H instead of 9FOO_H.
1766
1767 ** Fixed some typos in the documentation.
1768
1769 ** %token MY_EOF 0 is supported.
1770 Before, MY_EOF was silently renumbered as 257.
1771
1772 ** doc/refcard.tex is updated.
1773
1774 ** %output, %file-prefix, %name-prefix.
1775 New.
1776
1777 ** --output
1778 New, aliasing "--output-file".
1779 \f
1780 * Changes in version 1.30, 2001-10-26:
1781
1782 ** "--defines" and "--graph" have now an optional argument which is the
1783 output file name. "-d" and "-g" do not change; they do not take any
1784 argument.
1785
1786 ** "%source_extension" and "%header_extension" are removed, failed
1787 experiment.
1788
1789 ** Portability fixes.
1790 \f
1791 * Changes in version 1.29, 2001-09-07:
1792
1793 ** The output file does not define const, as this caused problems when used
1794 with common autoconfiguration schemes. If you still use ancient compilers
1795 that lack const, compile with the equivalent of the C compiler option
1796 "-Dconst=". Autoconf's AC_C_CONST macro provides one way to do this.
1797
1798 ** Added "-g" and "--graph".
1799
1800 ** The Bison manual is now distributed under the terms of the GNU FDL.
1801
1802 ** The input and the output files has automatically a similar extension.
1803
1804 ** Russian translation added.
1805
1806 ** NLS support updated; should hopefully be less troublesome.
1807
1808 ** Added the old Bison reference card.
1809
1810 ** Added "--locations" and "%locations".
1811
1812 ** Added "-S" and "--skeleton".
1813
1814 ** "%raw", "-r", "--raw" is disabled.
1815
1816 ** Special characters are escaped when output. This solves the problems
1817 of the #line lines with path names including backslashes.
1818
1819 ** New directives.
1820 "%yacc", "%fixed_output_files", "%defines", "%no_parser", "%verbose",
1821 "%debug", "%source_extension" and "%header_extension".
1822
1823 ** @$
1824 Automatic location tracking.
1825 \f
1826 * Changes in version 1.28, 1999-07-06:
1827
1828 ** Should compile better now with K&R compilers.
1829
1830 ** Added NLS.
1831
1832 ** Fixed a problem with escaping the double quote character.
1833
1834 ** There is now a FAQ.
1835 \f
1836 * Changes in version 1.27:
1837
1838 ** The make rule which prevented bison.simple from being created on
1839 some systems has been fixed.
1840 \f
1841 * Changes in version 1.26:
1842
1843 ** Bison now uses Automake.
1844
1845 ** New mailing lists: <bug-bison@gnu.org> and <help-bison@gnu.org>.
1846
1847 ** Token numbers now start at 257 as previously documented, not 258.
1848
1849 ** Bison honors the TMPDIR environment variable.
1850
1851 ** A couple of buffer overruns have been fixed.
1852
1853 ** Problems when closing files should now be reported.
1854
1855 ** Generated parsers should now work even on operating systems which do
1856 not provide alloca().
1857 \f
1858 * Changes in version 1.25, 1995-10-16:
1859
1860 ** Errors in the input grammar are not fatal; Bison keeps reading
1861 the grammar file, and reports all the errors found in it.
1862
1863 ** Tokens can now be specified as multiple-character strings: for
1864 example, you could use "<=" for a token which looks like <=, instead
1865 of choosing a name like LESSEQ.
1866
1867 ** The %token_table declaration says to write a table of tokens (names
1868 and numbers) into the parser file. The yylex function can use this
1869 table to recognize multiple-character string tokens, or for other
1870 purposes.
1871
1872 ** The %no_lines declaration says not to generate any #line preprocessor
1873 directives in the parser file.
1874
1875 ** The %raw declaration says to use internal Bison token numbers, not
1876 Yacc-compatible token numbers, when token names are defined as macros.
1877
1878 ** The --no-parser option produces the parser tables without including
1879 the parser engine; a project can now use its own parser engine.
1880 The actions go into a separate file called NAME.act, in the form of
1881 a switch statement body.
1882 \f
1883 * Changes in version 1.23:
1884
1885 The user can define YYPARSE_PARAM as the name of an argument to be
1886 passed into yyparse. The argument should have type void *. It should
1887 actually point to an object. Grammar actions can access the variable
1888 by casting it to the proper pointer type.
1889
1890 Line numbers in output file corrected.
1891 \f
1892 * Changes in version 1.22:
1893
1894 --help option added.
1895 \f
1896 * Changes in version 1.20:
1897
1898 Output file does not redefine const for C++.
1899
1900 -----
1901
1902 Copyright (C) 1995-2012 Free Software Foundation, Inc.
1903
1904 This file is part of Bison, the GNU Parser Generator.
1905
1906 This program is free software: you can redistribute it and/or modify
1907 it under the terms of the GNU General Public License as published by
1908 the Free Software Foundation, either version 3 of the License, or
1909 (at your option) any later version.
1910
1911 This program is distributed in the hope that it will be useful,
1912 but WITHOUT ANY WARRANTY; without even the implied warranty of
1913 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1914 GNU General Public License for more details.
1915
1916 You should have received a copy of the GNU General Public License
1917 along with this program. If not, see <http://www.gnu.org/licenses/>.
1918
1919 LocalWords: yacc YYBACKUP glr GCC lalr ArrayIndexOutOfBoundsException nullptr
1920 LocalWords: cplusplus liby rpl fprintf mfcalc Wyacc stmt cond expr mk sym lr
1921 LocalWords: IELR ielr Lookahead YYERROR nonassoc LALR's api lookaheads yychar
1922 LocalWords: destructor lookahead YYRHSLOC YYLLOC Rhs ifndef YYFAIL cpp sr rr
1923 LocalWords: preprocessor initializer Wno Wnone Werror FreeBSD prec livelocks
1924 LocalWords: Solaris AIX UX RHEL Tru LHS gcc's Wundef YYENABLE NLS YYLTYPE VCG
1925 LocalWords: yyerror cpp's Wunused yylval yylloc prepend yyparse yylex yypush
1926 LocalWords: Graphviz xml nonterminals midrule destructor's YYSTYPE typedef ly
1927 LocalWords: CHR chr printf stdout namespace preprocessing enum pre include's
1928 LocalWords: YYRECOVERING nonfree destructors YYABORT YYACCEPT params enums de
1929 LocalWords: struct yystype DJGPP lex param Haible NUM alloca YYSTACK NUL goto
1930 LocalWords: YYMAXDEPTH Unescaped UCNs YYLTYPE's yyltype typedefs inline Yaccs
1931 LocalWords: Heriyanto Reenable dprec Hilfinger Eggert MYEOF Folle Menezes EOF
1932 LocalWords: Lackovic define's itemset Groff Gettext malloc NEWS'ed YYDEBUG YY
1933 LocalWords: namespaces strerror const autoconfiguration Dconst Autoconf's FDL
1934 LocalWords: Automake TMPDIR LESSEQ ylwrap endif yydebug YYTOKEN YYLSP ival hh
1935 LocalWords: extern YYTOKENTYPE TOKENTYPE yytokentype tokentype STYPE lval pdf
1936 LocalWords: lang yyoutput dvi html ps POSIX lvalp llocp Wother nterm arg init
1937 LocalWords: TOK
1938
1939 Local Variables:
1940 mode: outline
1941 fill-column: 76
1942 End: