X-Recipient: archive-cygwin AT delorie DOT com X-Original-To: cygwin AT cygwin DOT com Delivered-To: cygwin AT cygwin DOT com DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 34A2F3850425 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=SystematicSW.ab.ca Authentication-Results: sourceware.org; spf=none smtp.mailfrom=systematicsw.ab.ca X-Authority-Analysis: v=2.4 cv=Ac10o1bG c=1 sm=1 tr=0 ts=61188fce a=T+ovY1NZ+FAi/xYICV7Bgg==:117 a=T+ovY1NZ+FAi/xYICV7Bgg==:17 a=mDV3o1hIAAAA:8 a=lWizVls1n1EzbxuD0BsA:9 a=eSld530IFJO7Hid5:21 a=S8fYYf7SKEEOPhLw:21 a=2NaJnCOvhsC-0isc:21 a=_FVE-zBwftR9WsbkzFJk:22 From: Cygwin bison Co-Maintainer To: cygwin AT cygwin DOT com Date: Sat, 14 Aug 2021 21:52:35 -0600 Message-Id: Subject: [ANNOUNCEMENT] Updated: bison 3.7.6 X-CMAE-Envelope: MS4xfIM4yev2Kj13gU3NjQiGEaeDQLofBjN2KWl8JO+QOUpn5LTAGRJKYOQP+yPPYFAlrrObSZKz0ZO4T+UEqa7YpGbj2KDqoYc+WjN9se6kKv0m0OEGzBkh MZOAChi7QxwoLCHSK0bvJ5+TMgMSvkUak2v2q+kUrc8em/BoBGuV8BzpOmzWYilPOLXtir4l9yEK2G5byu120Jj08I19G3NxSBw/2Hj9cn1Dquj5OBy/ZRHO BKCkjOoKqbk6tP00onR/v5tW2vZv3nzxi00NW8dG4lc= X-Spam-Status: No, score=-1159.4 required=5.0 tests=BAYES_00, KAM_DMARC_STATUS, KAM_LAZY_DOMAIN_SECURITY, KAM_NUMSUBJECT, KAM_SHORT, KAM_STOCKGEN, PP_MIME_FAKE_ASCII_TEXT, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=no autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: cygwin-announce AT cygwin DOT com X-Mailman-Version: 2.1.29 X-Mailer: Perl5 Mail::Internet v2.20 X-BeenThere: cygwin AT cygwin DOT com List-Id: General Cygwin discussions and problem reports List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: cygwin AT cygwin DOT com MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============1444346346172439217==" Sender: "Cygwin" --===============1444346346172439217== Content-Type: text/plain The following packages have been upgraded in the Cygwin distribution: * bison 3.7.6 Bison is a general-purpose parser generator that converts an annotated context-free grammar into a deterministic LR or generalized LR (GLR) parser employing LALR(1) parser tables. As an experimental feature, Bison can also generate IELR(1) or canonical LR(1) parser tables. Once you are proficient with Bison, you can use it to develop a wide range of language parsers, from those used in simple desk calculators to complex programming languages. Bison is upward compatible with Yacc: all properly-written Yacc grammars ought to work with Bison with no change. Anyone familiar with Yacc should be able to use Bison with little trouble. You need to be fluent in C or C++ programming in order to use Bison. Java is also supported as an experimental feature. For more information see the project home pages: https://www.gnu.org/software/bison/ https://sv.gnu.org/projects/bison/ As there have been many changes since the previous Cygwin release please see below or read /usr/share/doc/bison/NEWS after installation; for complete details see: /usr/share/doc/bison/ChangeLog https://git.sv.gnu.org/gitweb/?p=bison.git;a=log;h=refs/tags/v3.7.6 Noteworthy changes in release 3.7.6 (2021-03-08) [stable] * Bug fixes - Reused Push Parsers When a push-parser state structure is used for multiple parses, it was possible for some state to leak from one run into the following one. - Fix Table Generation In some very rare conditions, when there are many useless tokens, it was possible to generate incorrect parsers. Noteworthy changes in release 3.7.5 (2021-01-24) [stable] * Bug fixes - Counterexample Generation In some cases counterexample generation could crash. This is fixed. - Fix Table Generation In some very rare conditions, when there are many useless tokens, it was possible to generate incorrect parsers. - GLR parsers now support %merge together with api.value.type=union. - C++ parsers use noexcept in more places. - Generated parsers avoid some warnings about signedness issues. - C-language parsers now avoid warnings from pedantic clang. - C-language parsers now work around quirks of HP-UX 11.23 (2003). Noteworthy changes in release 3.7.4 (2020-11-14) [stable] * Bug fixes - Bug fixes in yacc.c In Yacc mode, all the tokens are defined twice: once as an enum, and then as a macro. YYEMPTY was missing its macro. - Bug fixes in lalr1.cc The lalr1.cc skeleton used to emit internal assertions (using YY_ASSERT) even when the `parse.assert` %define variable is not enabled. It no longer does. The private internal macro YY_ASSERT now obeys the `api.prefix` %define variable. When there is a very large number of tokens, some assertions could be long enough to hit arbitrary limits in Visual C++. They have been rewritten to work around this limitation. * Changes The YYBISON macro in generated "regular C parsers" (from the "yacc.c" skeleton) used to be defined to 1. It is now defined to the version of Bison as an integer (e.g., 30704 for version 3.7.4). Noteworthy changes in release 3.7.3 (2020-10-13) [stable] * Bug fixes Fix concurrent build issues. The bison executable is no longer linked uselessly against libreadline. Fix incorrect use of yytname in glr.cc. Noteworthy changes in release 3.7.2 (2020-09-05) [stable] This release of Bison fixes all known bugs reported for Bison in MITRE's Common Vulnerabilities and Exposures (CVE) system. These vulnerabilities are only about bison-the-program itself, not the generated code. Although these bugs are typically irrelevant to how Bison is used, they are worth fixing if only to give users peace of mind. There is no known vulnerability in the generated parsers. * Bug fixes Fix concurrent build issues (introduced in Bison 3.5). Push parsers always use YYMALLOC/YYFREE (no direct calls to malloc/free). Fix portability issues of the test suite, and of bison itself. Some unlikely crashes found by fuzzing have been fixed. This is only about bison itself, not the generated parsers. Noteworthy changes in release 3.7.1 (2020-08-02) [stable] * Bug fixes Crash when a token alias contains a NUL byte. Portability issues with libtextstyle. Portability issues of Bison itself with MSVC. * Changes Improvements and fixes in the documentation. More precise location about symbol type redefinitions. Noteworthy changes in release 3.7 (2020-07-23) [stable] * Deprecated features The YYPRINT macro, which works only with yacc.c and only for tokens, was obsoleted long ago by %printer, introduced in Bison 1.50 (November 2002). It is deprecated and its support will be removed eventually. In conformance with the recommendations of the Graphviz team, in the next version Bison the option `--graph` will generate a *.gv file by default, instead of *.dot. A transition started in Bison 3.4. * New features - Counterexample Generation Contributed by Vincent Imbimbo. When given `-Wcounterexamples`/`-Wcex`, bison will now output counterexamples for conflicts. . Unifying Counterexamples Unifying counterexamples are strings which can be parsed in two ways due to the conflict. For example on a grammar that contains the usual "dangling else" ambiguity: $ bison else.y else.y: warning: 1 shift/reduce conflict [-Wconflicts-sr] else.y: note: rerun with option '-Wcounterexamples' to generate conflict counterexamples $ bison else.y -Wcex else.y: warning: 1 shift/reduce conflict [-Wconflicts-sr] else.y: warning: shift/reduce conflict on token "else" [-Wcounterexamples] Example: "if" exp "then" "if" exp "then" exp • "else" exp Shift derivation exp ↳ "if" exp "then" exp ↳ "if" exp "then" exp • "else" exp Example: "if" exp "then" "if" exp "then" exp • "else" exp Reduce derivation exp ↳ "if" exp "then" exp "else" exp ↳ "if" exp "then" exp • When text styling is enabled, colors are used in the examples and the derivations to highlight the structure of both analyses. In this case, "if" exp "then" [ "if" exp "then" exp • ] "else" exp vs. "if" exp "then" [ "if" exp "then" exp • "else" exp ] The counterexamples are "focused", in two different ways. First, they do not clutter the output with all the derivations from the start symbol, rather they start on the "conflicted nonterminal". They go straight to the point. Second, they don't "expand" nonterminal symbols uselessly. . Nonunifying Counterexamples In the case of the dangling else, Bison found an example that can be parsed in two ways (therefore proving that the grammar is ambiguous). When it cannot find such an example, it instead generates two examples that are the same up until the dot: $ bison foo.y foo.y: warning: 1 shift/reduce conflict [-Wconflicts-sr] foo.y: note: rerun with option '-Wcounterexamples' to generate conflict counterexamples foo.y:4.4-7: warning: rule useless in parser due to conflicts [-Wother] 4 | a: expr | ^~~~ $ bison -Wcex foo.y foo.y: warning: 1 shift/reduce conflict [-Wconflicts-sr] foo.y: warning: shift/reduce conflict on token ID [-Wcounterexamples] First example: expr • ID ',' ID $end Shift derivation $accept ↳ s $end ↳ a ID ↳ expr ↳ expr • ID ',' Second example: expr • ID $end Reduce derivation $accept ↳ s $end ↳ a ID ↳ expr • foo.y:4.4-7: warning: rule useless in parser due to conflicts [-Wother] 4 | a: expr | ^~~~ In these cases, the parser usually doesn't have enough lookahead to differentiate the two given examples. . Reports Counterexamples are also included in the report when given `--report=counterexamples`/`-rcex` (or `--report=all`), with more technical details: State 7 1 exp: "if" exp "then" exp • [$end, "then", "else"] 2 | "if" exp "then" exp • "else" exp "else" shift, and go to state 8 "else" [reduce using rule 1 (exp)] $default reduce using rule 1 (exp) shift/reduce conflict on token "else": 1 exp: "if" exp "then" exp • 2 exp: "if" exp "then" exp • "else" exp Example: "if" exp "then" "if" exp "then" exp • "else" exp Shift derivation exp ↳ "if" exp "then" exp ↳ "if" exp "then" exp • "else" exp Example: "if" exp "then" "if" exp "then" exp • "else" exp Reduce derivation exp ↳ "if" exp "then" exp "else" exp ↳ "if" exp "then" exp • - File prefix mapping Contributed by Joshua Watt. Bison learned a new argument, `--file-prefix-map OLD=NEW`. Any file path in the output (specifically `#line` directives and `#ifdef` header guards) that begins with the prefix OLD will have it replaced with the prefix NEW, similar to the `-ffile-prefix-map` in GCC. This option can be used to make bison output reproducible. * Changes - Diagnostics When text styling is enabled and the terminal supports it, the warnings now include hyperlinks to the documentation. - Relocatable installation When installed to be relocatable (via `configure --enable-relocatable`), bison will now also look for a relocated m4. - C++ file names The `filename_type` %define variable was renamed `api.filename.type`. Instead of %define filename_type "symbol" write %define api.filename.type {symbol} (Or let `bison --update` do it for you). It now defaults to `const std::string` instead of `std::string`. - Deprecated %define variable names The following variables have been renamed for consistency. Backward compatibility is ensured, but upgrading is recommended. filename_type -> api.filename.type package -> api.package - Push parsers no longer clear their state when parsing is finished Previously push-parsers cleared their state when parsing was finished (on success and on failure). This made it impossible to check if there were parse errors, since `yynerrs` was also reset. This can be especially troublesome when used in autocompletion, since a parser with error recovery would suggest (irrelevant) expected tokens even if there were failures. Now the parser state can be examined when parsing is finished. The parser state is reset when starting a new parse. * Documentation - Examples The bistromathic demonstrates %param and how to quote sources in the error messages: > 123 456 1.5-7: syntax error: expected end of file or + or - or * or / or ^ before number 1 | 123 456 | ^~~ * Bug fixes - Include the generated header (yacc.c) Historically, when --defines was used, bison generated a header and pasted an exact copy of it into the generated parser implementation file. Since Bison 3.4 it is possible to specify that the header should be `#include`d, and how. For instance %define api.header.include {"parse.h"} or %define api.header.include {} Now api.header.include defaults to `"header-basename"`, as was intended in Bison 3.4, where `header-basename` is the basename of the generated header. This is disabled when the generated header is `y.tab.h`, to comply with Automake's ylwrap. - String aliases are faithfully propagated Bison used to interpret user strings (i.e., decoding backslash escapes) when reading them, and to escape them (i.e., issue non-printable characters as backslash escapes, taking the locale into account) when outputting them. As a consequence non-ASCII strings (say in UTF-8) ended up "ciphered" as sequences of backslash escapes. This happened not only in the generated sources (where the compiler will reinterpret them), but also in all the generated reports (text, xml, html, dot, etc.). Reports were therefore not readable when string aliases were not pure ASCII. Worse yet: the output depended on the user's locale. Now Bison faithfully treats the string aliases exactly the way the user spelled them. This fixes all the aforementioned problems. However, now, string aliases semantically equivalent but syntactically different (e.g., "A", "\x41", "\101") are considered to be different. - Crash when generating IELR An old, well hidden, bug in the generation of IELR parsers was fixed. Noteworthy changes in release 3.6.4 (2020-06-15) [stable] * Bug fixes In glr.cc some internal macros leaked in the user's code, and could damage access to the token kinds. Noteworthy changes in release 3.6.3 (2020-06-03) [stable] * Bug fixes Incorrect comments in the generated parsers. Warnings in push parsers (yacc.c). Incorrect display of gotos in LAC traces (lalr1.cc). Noteworthy changes in release 3.6.2 (2020-05-17) [stable] * Bug fixes Some tests were fixed. When token aliases contain comment delimiters: %token FOO "/* foo */" bison used to emit "nested" comments, which is invalid C. Noteworthy changes in release 3.6.1 (2020-05-10) [stable] * Bug fixes Restored ANSI-C compliance in yacc.c. GNU readline portability issues. In C++, yy::parser::symbol_name is now a public member, as was intended. * New features In C++, yy::parser::symbol_type now has a public name() member function. Noteworthy changes in release 3.6 (2020-05-08) [stable] * Backward incompatible changes TL;DR: replace "#define YYERROR_VERBOSE 1" by "%define parse.error verbose". The YYERROR_VERBOSE macro is no longer supported; the parsers that still depend on it will now produce Yacc-like error messages (just "syntax error"). It was superseded by the "%error-verbose" directive in Bison 1.875 (2003-01-01). Bison 2.6 (2012-07-19) clearly announced that support for YYERROR_VERBOSE would be removed. Note that since Bison 3.0 (2013-07-25), "%error-verbose" is deprecated in favor of "%define parse.error verbose". * Deprecated features The YYPRINT macro, which works only with yacc.c and only for tokens, was obsoleted long ago by %printer, introduced in Bison 1.50 (November 2002). It is deprecated and its support will be removed eventually. * New features - Improved syntax error messages Two new values for the %define parse.error variable offer more control to the user. Available in all the skeletons (C, C++, Java). . %define parse.error detailed The behavior of "%define parse.error detailed" is closely resembling that of "%define parse.error verbose" with a few exceptions. First, it is safe to use non-ASCII characters in token aliases (with 'verbose', the result depends on the locale with which bison was run). Second, a yysymbol_name function is exposed to the user, instead of the yytnamerr function and the yytname table. Third, token internationalization is supported (see below). . %define parse.error custom With this directive, the user forges and emits the syntax error message herself by defining the yyreport_syntax_error function. A new type, yypcontext_t, captures the circumstances of the error, and provides the user with functions to get details, such as yypcontext_expected_tokens to get the list of expected token kinds. A possible implementation of yyreport_syntax_error is: int yyreport_syntax_error (const yypcontext_t *ctx) { int res = 0; YY_LOCATION_PRINT (stderr, *yypcontext_location (ctx)); fprintf (stderr, ": syntax error"); // Report the tokens expected at this point. { enum { TOKENMAX = 10 }; yysymbol_kind_t expected[TOKENMAX]; int n = yypcontext_expected_tokens (ctx, expected, TOKENMAX); if (n < 0) // Forward errors to yyparse. res = n; else for (int i = 0; i < n; ++i) fprintf (stderr, "%s %s", i == 0 ? ": expected" : " or", yysymbol_name (expected[i])); } // Report the unexpected token. { yysymbol_kind_t lookahead = yypcontext_token (ctx); if (lookahead != YYSYMBOL_YYEMPTY) fprintf (stderr, " before %s", yysymbol_name (lookahead)); } fprintf (stderr, "\n"); return res; } . Token aliases internationalization When the %define variable parse.error is set to `custom` or `detailed`, one may specify which token aliases are to be translated using _(). For instance %token PLUS "+" MINUS "-" NUM _("number") FUN _("function") VAR _("variable") In that case the user must define _() and N_(), and yysymbol_name returns the translated symbol (i.e., it returns '_("variable")' rather that '"variable"'). In Java, the user must provide an i18n() function. - List of expected tokens (yacc.c) Push parsers may invoke yypstate_expected_tokens at any point during parsing (including even before submitting the first token) to get the list of possible tokens. This feature can be used to propose autocompletion (see below the "bistromathic" example). It makes little sense to use this feature without enabling LAC (lookahead correction). - Returning the error token When the scanner returns an invalid token or the undefined token (YYUNDEF), the parser generates an error message and enters error recovery. Because of that error message, most scanners that find lexical errors generate an error message, and then ignore the invalid input without entering the error-recovery. The scanners may now return YYerror, the error token, to enter the error-recovery mode without triggering an additional error message. See the bistromathic for an example. - Deep overhaul of the symbol and token kinds To avoid the confusion with types in programming languages, we now refer to token and symbol "kinds" instead of token and symbol "types". The documentation and error messages have been revised. All the skeletons have been updated to use dedicated enum types rather than integral types. Special symbols are now regular citizens, instead of being declared in ad hoc ways. . Token kinds The "token kind" is what is returned by the scanner, e.g., PLUS, NUMBER, LPAREN, etc. While backward compatibility is of course ensured, users are nonetheless invited to replace their uses of "enum yytokentype" by "yytoken_kind_t". This type now also includes tokens that were previously hidden: YYEOF (end of input), YYUNDEF (undefined token), and YYerror (error token). They now have string aliases, internationalized when internationalization is enabled. Therefore, by default, error messages now refer to "end of file" (internationalized) rather than the cryptic "$end", or to "invalid token" rather than "$undefined". Therefore in most cases it is now useless to define the end-of-line token as follows: %token T_EOF 0 "end of file" Rather simply use "YYEOF" in your scanner. . Symbol kinds The "symbol kinds" is what the parser actually uses. (Unless the api.token.raw %define variable is used, the symbol kind of a terminal differs from the corresponding token kind.) They are now exposed as a enum, "yysymbol_kind_t". This allows users to tailor the error messages the way they want, or to process some symbols in a specific way in autocompletion (see the bistromathic example below). - Modernize display of explanatory statements in diagnostics Since Bison 2.7, output was indented four spaces for explanatory statements. For example: input.y:2.7-13: error: %type redeclaration for exp input.y:1.7-11: previous declaration Since the introduction of caret-diagnostics, it became less clear. This indentation has been removed and submessages are displayed similarly as in GCC: input.y:2.7-13: error: %type redeclaration for exp 2 | %type exp | ^~~~~~~ input.y:1.7-11: note: previous declaration 1 | %type exp | ^~~~~ Contributed by Victor Morales Cayuela. - C++ The token and symbol kinds are yy::parser::token_kind_type and yy::parser::symbol_kind_type. The symbol_type::kind() member function allows to get the kind of a symbol. This can be used to write unit tests for scanners, e.g., yy::parser::symbol_type t = make_NUMBER ("123"); assert (t.kind () == yy::parser::symbol_kind::S_NUMBER); assert (t.value.as () == 123); * Documentation - User Manual In order to avoid ambiguities with "type" as in "typing", we now refer to the "token kind" (e.g., `PLUS`, `NUMBER`, etc.) rather than the "token type". We now also refer to the "symbol type" (e.g., `PLUS`, `expr`, etc.). - Examples There are now examples/java: a very simple calculator, and a more complete one (push-parser, location tracking, and debug traces). The lexcalc example (a simple example in C based on Flex and Bison) now also demonstrates location tracking. A new C example, bistromathic, is a fully featured interactive calculator using many Bison features: pure interface, push parser, autocompletion based on the current parser state (using yypstate_expected_tokens), location tracking, internationalized custom error messages, lookahead correction, rich debug traces, etc. It shows how to depend on the symbol kinds to tailor autocompletion. For instance it recognizes the symbol kind "VARIABLE" to propose autocompletion on the existing variables, rather than of the word "variable". Noteworthy changes in release 3.5.4 (2020-04-05) [stable] * WARNING: Future backward-incompatibilities! TL;DR: replace "#define YYERROR_VERBOSE 1" by "%define parse.error verbose". Bison 3.6 will no longer support the YYERROR_VERBOSE macro; the parsers that still depend on it will produce Yacc-like error messages (just "syntax error"). It was superseded by the "%error-verbose" directive in Bison 1.875 (2003-01-01). Bison 2.6 (2012-07-19) clearly announced that support for YYERROR_VERBOSE would be removed. Note that since Bison 3.0 (2013-07-25), "%error-verbose" is deprecated in favor of "%define parse.error verbose". * Bug fixes Fix portability issues of the package itself on old compilers. Fix api.token.raw support in Java. Noteworthy changes in release 3.5.3 (2020-03-08) [stable] * Bug fixes Error messages could quote lines containing zero-width characters (such as \005) with incorrect styling. Fixes for similar issues with unexpectedly short lines (e.g., the file was changed between parsing and diagnosing). Some unlikely crashes found by fuzzing have been fixed. This is only about bison itself, not the generated parsers. Noteworthy changes in release 3.5.2 (2020-02-13) [stable] * Bug fixes Portability issues and minor cosmetic issues. The lalr1.cc skeleton properly rejects unsupported values for parse.lac (as yacc.c does). Noteworthy changes in release 3.5.1 (2020-01-19) [stable] * Bug fixes Portability fixes. Fix compiler warnings. Noteworthy changes in release 3.5 (2019-12-11) [stable] * Backward incompatible changes Lone carriage-return characters (aka \r or ^M) in the grammar files are no longer treated as end-of-lines. This changes the diagnostics, and in particular their locations. In C++, line numbers and columns are now represented as 'int' not 'unsigned', so that integer overflow on positions is easily checkable via 'gcc -fsanitize=undefined' and the like. This affects the API for positions. The default position and location classes now expose 'counter_type' (int), used to define line and column numbers. * Deprecated features The YYPRINT macro, which works only with yacc.c and only for tokens, was obsoleted long ago by %printer, introduced in Bison 1.50 (November 2002). It is deprecated and its support will be removed eventually. * New features - Lookahead correction in C++ Contributed by Adrian Vogelsgesang. The C++ deterministic skeleton (lalr1.cc) now supports LAC, via the %define variable parse.lac. - Variable api.token.raw: Optimized token numbers (all skeletons) In the generated parsers, tokens have two numbers: the "external" token number as returned by yylex (which starts at 257), and the "internal" symbol number (which starts at 3). Each time yylex is called, a table lookup maps the external token number to the internal symbol number. When the %define variable api.token.raw is set, tokens are assigned their internal number, which saves one table lookup per token, and also saves the generation of the mapping table. The gain is typically moderate, but in extreme cases (very simple user actions), a 10% improvement can be observed. - Generated parsers use better types for states Stacks now use the best integral type for state numbers, instead of always using 15 bits. As a result "small" parsers now have a smaller memory footprint (they use 8 bits), and there is support for large automata (16 bits), and extra large (using int, i.e., typically 31 bits). - Generated parsers prefer signed integer types Bison skeletons now prefer signed to unsigned integer types when either will do, as the signed types are less error-prone and allow for better checking with 'gcc -fsanitize=undefined'. Also, the types chosen are now portable to unusual machines where char, short and int are all the same width. On non-GNU platforms this may entail including and (if available) to define integer types and constants. - A skeleton for the D programming language For the last few releases, Bison has shipped a stealth experimental skeleton: lalr1.d. It was first contributed by Oliver Mangold, based on Paolo Bonzini's lalr1.java, and was cleaned and improved thanks to H. S. Teoh. However, because nobody has committed to improving, testing, and documenting this skeleton, it is not clear that it will be supported in the future. The lalr1.d skeleton *is functional*, and works well, as demonstrated in examples/d/calc.d. Please try it, enjoy it, and... commit to support it. - Debug traces in Java The Java backend no longer emits code and data for parser tracing if the %define variable parse.trace is not defined. * Diagnostics - New diagnostic: -Wdangling-alias String literals, which allow for better error messages, are (too) liberally accepted by Bison, which might result in silent errors. For instance %type cond "condition" does not define "condition" as a string alias to 'cond' (nonterminal symbols do not have string aliases). It is rather equivalent to %nterm cond %token "condition" i.e., it gives the type 'exVal' to the "condition" token, which was clearly not the intention. Also, because string aliases need not be defined, typos such as "baz" instead of "bar" will be not reported. The option -Wdangling-alias catches these situations. On %token BAR "bar" %type foo "foo" %% foo: "baz" {} bison -Wdangling-alias reports warning: string literal not attached to a symbol | %type foo "foo" | ^~~~~ warning: string literal not attached to a symbol | foo: "baz" {} | ^~~~~ The -Wall option does not (yet?) include -Wdangling-alias. - Better POSIX Yacc compatibility diagnostics POSIX Yacc restricts %type to nonterminals. This is now diagnosed by -Wyacc. %token TOKEN1 %type TOKEN1 TOKEN2 't' %token TOKEN2 %% expr: gives with -Wyacc input.y:2.15-20: warning: POSIX yacc reserves %type to nonterminals [-Wyacc] 2 | %type TOKEN1 TOKEN2 't' | ^~~~~~ input.y:2.29-31: warning: POSIX yacc reserves %type to nonterminals [-Wyacc] 2 | %type TOKEN1 TOKEN2 't' | ^~~ input.y:2.22-27: warning: POSIX yacc reserves %type to nonterminals [-Wyacc] 2 | %type TOKEN1 TOKEN2 't' | ^~~~~~ - Diagnostics with insertion The diagnostics now display the suggestion below the underlined source. Replacement for undeclared symbols are now also suggested. $ cat /tmp/foo.y %% list: lis '.' | $ bison -Wall foo.y foo.y:2.7-9: error: symbol 'lis' is used, but is not defined as a token and has no rules; did you mean 'list'? 2 | list: lis '.' | | ^~~ | list foo.y:2.16: warning: empty rule without %empty [-Wempty-rule] 2 | list: lis '.' | | ^ | %empty foo.y: warning: fix-its can be applied. Rerun with option '--update'. [-Wother] - Diagnostics about long lines Quoted sources may now be truncated to fit the screen. For instance, on a 30-column wide terminal: $ cat foo.y %token FOO FOO FOO %% exp: FOO $ bison foo.y foo.y:1.34-36: warning: symbol FOO redeclared [-Wother] 1 | … FOO … | ^~~ foo.y:1.8-10: previous declaration 1 | %token FOO … | ^~~ foo.y:1.62-64: warning: symbol FOO redeclared [-Wother] 1 | … FOO | ^~~ foo.y:1.8-10: previous declaration 1 | %token FOO … | ^~~ * Changes - Debugging glr.c and glr.cc The glr.c skeleton always had asserts to check its own behavior (not the user's). These assertions are now under the control of the parse.assert %define variable (disabled by default). - Clean up Several new compiler warnings in the generated output have been avoided. Some unused features are no longer emitted. Cleaner generated code in general. * Bug Fixes Portability issues in the test suite. In theory, parsers using %nonassoc could crash when reporting verbose error messages. This unlikely bug has been fixed. In Java, %define api.prefix was ignored. It now behaves as expected. Noteworthy changes in release 3.4.2 (2019-09-12) [stable] * Bug fixes In some cases, when warnings are disabled, bison could emit tons of white spaces as diagnostics. When running out of memory, bison could crash (found by fuzzing). When defining twice the EOF token, bison would crash. New warnings from recent compilers have been addressed in the generated parsers (yacc.c, glr.c, glr.cc). When lone carriage-return characters appeared in the input file, diagnostics could hang forever. Noteworthy changes in release 3.4.1 (2019-05-22) [stable] * Bug fixes Portability fixes. Noteworthy changes in release 3.4 (2019-05-19) [stable] * Deprecated features The %pure-parser directive is deprecated in favor of '%define api.pure' since Bison 2.3b (2008-05-27), but no warning was issued; there is one now. Note that since Bison 2.7 you are strongly encouraged to use '%define api.pure full' instead of '%define api.pure'. * New features - Colored diagnostics As an experimental feature, diagnostics are now colored, controlled by the new options --color and --style. To use them, install the libtextstyle library before configuring Bison. It is available from https://alpha.gnu.org/gnu/gettext/ for instance https://alpha.gnu.org/gnu/gettext/libtextstyle-0.8.tar.gz The option --color supports the following arguments: - always, yes: Enable colors. - never, no: Disable colors. - auto, tty (default): Enable colors if the output device is a tty. To customize the styles, create a CSS file similar to /* bison-bw.css */ .warning { } .error { font-weight: 800; text-decoration: underline; } .note { } then invoke bison with --style=bison-bw.css, or set the BISON_STYLE environment variable to "bison-bw.css". - Disabling output When given -fsyntax-only, the diagnostics are reported, but no output is generated. The name of this option is somewhat misleading as bison does more than just checking the syntax: every stage is run (including checking for conflicts for instance), except the generation of the output files. - Include the generated header (yacc.c) Before, when --defines is used, bison generated a header, and pasted an exact copy of it into the generated parser implementation file. If the header name is not "y.tab.h", it is now #included instead of being duplicated. To use an '#include' even if the header name is "y.tab.h" (which is what happens with --yacc, or when using the Autotools' ylwrap), define api.header.include to the exact argument to pass to #include. For instance: %define api.header.include {"parse.h"} or %define api.header.include {} - api.location.type is now supported in C (yacc.c, glr.c) The %define variable api.location.type defines the name of the type to use for locations. When defined, Bison no longer defines YYLTYPE. This can be used in programs with several parsers to factor their definition of locations: let one of them generate them, and the others just use them. * Changes - Graphviz output In conformance with the recommendations of the Graphviz team, if %require "3.4" (or better) is specified, the option --graph generates a *.gv file by default, instead of *.dot. - Diagnostics overhaul Column numbers were wrong with multibyte characters, which would also result in skewed diagnostics with carets. Beside, because we were indenting the quoted source with a single space, lines with tab characters were incorrectly underlined. To address these issues, and to be clearer, Bison now issues diagnostics as GCC9 does. For instance it used to display (there's a tab before the opening brace): foo.y:3.37-38: error: $2 of ‘expr’ has no declared type expr: expr '+' "number" { $$ = $1 + $2; } ^~ It now reports foo.y:3.37-38: error: $2 of ‘expr’ has no declared type 3 | expr: expr '+' "number" { $$ = $1 + $2; } | ^~ Other constructs now also have better locations, resulting in more precise diagnostics. - Fix-it hints for %empty Running Bison with -Wempty-rules and --update will remove incorrect %empty annotations, and add the missing ones. - Generated reports The format of the reports (parse.output) was improved for readability. - Better support for --no-line. When --no-line is used, the generated files are now cleaner: no lines are generated instead of empty lines. Together with using api.header.include, that should help people saving the generated files into version control systems get smaller diffs. * Documentation A new example in C shows an simple infix calculator with a hand-written scanner (examples/c/calc). A new example in C shows a reentrant parser (capable of recursive calls) built with Flex and Bison (examples/c/reccalc). There is a new section about the history of Yaccs and Bison. * Bug fixes A few obscure bugs were fixed, including the second oldest (known) bug in Bison: it was there when Bison was entered in the RCS version control system, in December 1987. See the NEWS of Bison 3.3 for the previous oldest bug. Noteworthy changes in release 3.3.2 (2019-02-03) [stable] * Bug fixes Bison 3.3 failed to generate parsers for grammars with unused nonterminal symbols. Noteworthy changes in release 3.3.1 (2019-01-27) [stable] * Changes The option -y/--yacc used to imply -Werror=yacc, which turns uses of Bison extensions into errors. It now makes them simple warnings (-Wyacc). Noteworthy changes in release 3.3 (2019-01-26) [stable] A new mailing list was created, Bison Announce. It is low traffic, and is only about announcing new releases and important messages (e.g., polls about major decisions to make). https://lists.gnu.org/mailman/listinfo/bison-announce * Backward incompatible changes Support for DJGPP, which has been unmaintained and untested for years, is removed. * Deprecated features A new feature, --update (see below) helps adjusting existing grammars to deprecations. - Deprecated directives The %error-verbose directive is deprecated in favor of '%define parse.error verbose' since Bison 3.0, but no warning was issued. The '%name-prefix "xx"' directive is deprecated in favor of '%define api.prefix {xx}' since Bison 3.0, but no warning was issued. These directives are slightly different, you might need to adjust your code. %name-prefix renames only symbols with external linkage, while api.prefix also renames types and macros, including YYDEBUG, YYTOKENTYPE, yytokentype, YYSTYPE, YYLTYPE, etc. Users of Flex that move from '%name-prefix "xx"' to '%define api.prefix {xx}' will typically have to update YY_DECL from #define YY_DECL int xxlex (YYSTYPE *yylval, YYLTYPE *yylloc) to #define YY_DECL int xxlex (XXSTYPE *yylval, XXLTYPE *yylloc) - Deprecated %define variable names The following variables, mostly related to parsers in Java, have been renamed for consistency. Backward compatibility is ensured, but upgrading is recommended. abstract -> api.parser.abstract annotations -> api.parser.annotations extends -> api.parser.extends final -> api.parser.final implements -> api.parser.implements parser_class_name -> api.parser.class public -> api.parser.public strictfp -> api.parser.strictfp * New features - Generation of fix-its for IDEs/Editors When given the new option -ffixit (aka -fdiagnostics-parseable-fixits), bison now generates machine readable editing instructions to fix some issues. Currently, this is mostly limited to updating deprecated directives and removing duplicates. For instance: $ cat foo.y %error-verbose %define parser_class_name "Parser" %define api.parser.class "Parser" %% exp:; See the "fix-it:" lines below: $ bison -ffixit foo.y foo.y:1.1-14: warning: deprecated directive, use '%define parse.error verbose' [-Wdeprecated] %error-verbose ^~~~~~~~~~~~~~ fix-it:"foo.y":{1:1-1:15}:"%define parse.error verbose" foo.y:2.1-34: warning: deprecated directive, use '%define api.parser.class {Parser}' [-Wdeprecated] %define parser_class_name "Parser" ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ fix-it:"foo.y":{2:1-2:35}:"%define api.parser.class {Parser}" foo.y:3.1-33: error: %define variable 'api.parser.class' redefined %define api.parser.class "Parser" ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ foo.y:2.1-34: previous definition %define parser_class_name "Parser" ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ fix-it:"foo.y":{3:1-3:34}:"" foo.y: warning: fix-its can be applied. Rerun with option '--update'. [-Wother] This uses the same output format as GCC and Clang. - Updating grammar files Fixes can be applied on the fly. The previous example ends with the suggestion to re-run bison with the option -u/--update, which results in a cleaner grammar file. $ bison --update foo.y [...] bison: file 'foo.y' was updated (backup: 'foo.y~') $ cat foo.y %define parse.error verbose %define api.parser.class {Parser} %% exp:; - Bison is now relocatable If you pass '--enable-relocatable' to 'configure', Bison is relocatable. A relocatable program can be moved or copied to a different location on the file system. It can also be used through mount points for network sharing. It is possible to make symbolic links to the installed and moved programs, and invoke them through the symbolic link. - %expect and %expect-rr modifiers on individual rules One can now document (and check) which rules participate in shift/reduce and reduce/reduce conflicts. This is particularly important GLR parsers, where conflicts are a normal occurrence. For example, %glr-parser %expect 1 %% ... argument_list: arguments %expect 1 | arguments ',' | %empty ; arguments: expression | argument_list ',' expression ; ... Looking at the output from -v, one can see that the shift/reduce conflict here is due to the fact that the parser does not know whether to reduce arguments to argument_list until it sees the token _after_ the following ','. By marking the rule with %expect 1 (because there is a conflict in one state), we document the source of the 1 overall shift/reduce conflict. In GLR parsers, we can use %expect-rr in a rule for reduce/reduce conflicts. In this case, we mark each of the conflicting rules. For example, %glr-parser %expect-rr 1 %% stmt: target_list '=' expr ';' | expr_list ';' ; target_list: target | target ',' target_list ; target: ID %expect-rr 1 ; expr_list: expr | expr ',' expr_list ; expr: ID %expect-rr 1 | ... ; In a statement such as x, y = 3, 4; the parser must reduce x to a target or an expr, but does not know which until it sees the '='. So we notate the two possible reductions to indicate that each conflicts in one rule. This feature needs user feedback, and might evolve in the future. - C++: Actual token constructors When variants and token constructors are enabled, in addition to the type-safe named token constructors (make_ID, make_INT, etc.), we now generate genuine constructors for symbol_type. For instance with these declarations %token ':' ID INT; you may use these constructors: symbol_type (int token, const std::string&); symbol_type (int token, const int&); symbol_type (int token); Correct matching between token types and value types is checked via 'assert'; for instance, 'symbol_type (ID, 42)' would abort. Named constructors are preferable, as they offer better type safety (for instance 'make_ID (42)' would not even compile), but symbol_type constructors may help when token types are discovered at run-time, e.g., [a-z]+ { if (auto i = lookup_keyword (yytext)) return yy::parser::symbol_type (i); else return yy::parser::make_ID (yytext); } - C++: Variadic emplace If your application requires C++11 and you don't use symbol constructors, you may now use a variadic emplace for semantic values: %define api.value.type variant %token > PAIR in your scanner: int yylex (parser::semantic_type *lvalp) { lvalp->emplace > (1, 2); return parser::token::PAIR; } - C++: Syntax error exceptions in GLR The glr.cc skeleton now supports syntax_error exceptions thrown from user actions, or from the scanner. - More POSIX Yacc compatibility warnings More Bison specific directives are now reported with -y or -Wyacc. This change was ready since the release of Bison 3.0 in September 2015. It was delayed because Autoconf used to define YACC as `bison -y`, which resulted in numerous warnings for Bison users that use the GNU Build System. If you still experience that problem, either redefine YACC as `bison -o y.tab.c`, or pass -Wno-yacc to Bison. - The tables yyrhs and yyphrs are back Because no Bison skeleton uses them, these tables were removed (no longer passed to the skeletons, not even computed) in 2008. However, some users have expressed interest in being able to use them in their own skeletons. * Bug fixes - Incorrect number of reduce/reduce conflicts On a grammar such as exp: "num" | "num" | "num" bison used to report a single RR conflict, instead of two. This is now fixed. This was the oldest (known) bug in Bison: it was there when Bison was entered in the RCS version control system, in December 1987. Some grammar files might have to adjust their %expect-rr. - Parser directives that were not careful enough Passing invalid arguments to %nterm, for instance character literals, used to result in unclear error messages. * Documentation The examples/ directory (installed in .../share/doc/bison/examples) has been restructured per language for clarity. The examples come with a README and a Makefile. Not only can they be used to toy with Bison, they can also be starting points for your own grammars. There is now a Java example, and a simple example in C based on Flex and Bison (examples/c/lexcalc/). * Changes - Parsers in C++ They now use noexcept and constexpr. Please, report missing annotations. - Symbol Declarations The syntax of the variation directives to declare symbols was overhauled for more consistency, and also better POSIX Yacc compliance (which, for instance, allows "%type" without actually providing a type). The %nterm directive, supported by Bison since its inception, is now documented and officially supported. The syntax is now as follows: %token TAG? ( ID NUMBER? STRING? )+ ( TAG ( ID NUMBER? STRING? )+ )* %left TAG? ( ID NUMBER? )+ ( TAG ( ID NUMBER? )+ )* %type TAG? ( ID | CHAR | STRING )+ ( TAG ( ID | CHAR | STRING )+ )* %nterm TAG? ID+ ( TAG ID+ )* where TAG denotes a type tag such as ‘’, ID denotes an identifier such as ‘NUM’, NUMBER a decimal or hexadecimal integer such as ‘300’ or ‘0x12d’, CHAR a character literal such as ‘'+'’, and STRING a string literal such as ‘"number"’. The post-fix quantifiers are ‘?’ (zero or one), ‘*’ (zero or more) and ‘+’ (one or more). Noteworthy changes in release 3.2.4 (2018-12-24) [stable] * Bug fixes Fix the move constructor of symbol_type. Always provide a copy constructor for symbol_type, even in modern C++. Noteworthy changes in release 3.2.3 (2018-12-18) [stable] * Bug fixes Properly support token constructors in C++ with types that include commas (e.g., std::pair). A regression introduced in Bison 3.2. Noteworthy changes in release 3.2.2 (2018-11-21) [stable] * Bug fixes C++ portability issues. Noteworthy changes in release 3.2.1 (2018-11-09) [stable] * Bug fixes Several portability issues have been fixed in the build system, in the test suite, and in the generated parsers in C++. Noteworthy changes in release 3.2 (2018-10-29) [stable] * Backward incompatible changes Support for DJGPP, which has been unmaintained and untested for years, is obsolete. Unless there is activity to revive it, it will be removed. * Changes %printers should use yyo rather than yyoutput to denote the output stream. Variant-based symbols in C++ should use emplace() rather than build(). In C++ parsers, parser::operator() is now a synonym for the parser::parse. * Documentation A new section, "A Simple C++ Example", is a tutorial for parsers in C++. A comment in the generated code now emphasizes that users should not depend upon non-documented implementation details, such as macros starting with YY_. * New features - C++: Support for move semantics (lalr1.cc) The lalr1.cc skeleton now fully supports C++ move semantics, while maintaining compatibility with C++98. You may now store move-only types when using Bison's variants. For instance: %code { #include #include } %skeleton "lalr1.cc" %define api.value.type variant %% %token INT "int"; %type > int; %type >> list; list: %empty {} | list int { $$ = std::move($1); $$.emplace_back(std::move($2)); } int: "int" { $$ = std::make_unique($1); } - C++: Implicit move of right-hand side values (lalr1.cc) In modern C++ (C++11 and later), you should always use 'std::move' with the values of the right-hand side symbols ($1, $2, etc.), as they will be popped from the stack anyway. Using 'std::move' is mandatory for move-only types such as unique_ptr, and it provides a significant speedup for large types such as std::string, or std::vector, etc. If '%define api.value.automove' is set, every occurrence '$n' is replaced by 'std::move ($n)'. The second rule in the previous grammar can be simplified to: list: list int { $$ = $1; $$.emplace_back($2); } With automove enabled, the semantic values are no longer lvalues, so do not use the swap idiom: list: list int { std::swap($$, $1); $$.emplace_back($2); } This idiom is anyway obsolete: it is preferable to move than to swap. A warning is issued when automove is enabled, and a value is used several times. input.yy:16.31-32: warning: multiple occurrences of $2 with api.value.automove enabled [-Wother] exp: "twice" exp { $$ = $2 + $2; } ^^ Enabling api.value.automove does not require support for modern C++. The generated code is valid C++98/03, but will use copies instead of moves. The new examples/c++/variant-11.yy shows these features in action. - C++: The implicit default semantic action is always run When variants are enabled, the default action was not run, so exp: "number" was equivalent to exp: "number" {} It now behaves like in all the other cases, as exp: "number" { $$ = $1; } possibly using std::move if automove is enabled. We do not expect backward compatibility issues. However, beware of forward compatibility issues: if you rely on default actions with variants, be sure to '%require "3.2"' to avoid older versions of Bison to generate incorrect parsers. - C++: Renaming location.hh When both %defines and %locations are enabled, Bison generates a location.hh file. If you don't use locations outside of the parser, you may avoid its creation with: %define api.location.file none However this file is useful if, for instance, your parser builds an AST decorated with locations: you may use Bison's location independently of Bison's parser. You can now give it another name, for instance: %define api.location.file "my-location.hh" This name can have directory components, and even be absolute. The name under which the location file is included is controlled by api.location.include. This way it is possible to have several parsers share the same location file. For instance, in src/foo/parser.hh, generate the include/ast/loc.hh file: %locations %define api.namespace {foo} %define api.location.file "include/ast/loc.hh" %define api.location.include {} and use it in src/bar/parser.hh: %locations %define api.namespace {bar} %code requires {#include } %define api.location.type {bar::location} Absolute file names are supported, so in your Makefile, passing the flag -Dapi.location.file='"$(top_srcdir)/include/ast/location.hh"' to bison is safe. - C++: stack.hh and position.hh are deprecated When asked to generate a header file (%defines), the lalr1.cc skeleton generates a stack.hh file. This file had no interest for users; it is now made useless: its content is included in the parser definition. It is still generated for backward compatibility. When in addition to %defines, location support is requested (%locations), the file position.hh is also generated. It is now also useless: its content is now included in location.hh. These files are no longer generated when your grammar file requires at least Bison 3.2 (%require "3.2"). * Bug fixes Portability issues on MinGW and VS2015. Portability issues in the test suite. Portability/warning issues with Flex. Noteworthy changes in release 3.1 (2018-08-27) [stable] * Backward incompatible changes Compiling Bison now requires a C99 compiler---as announced during the release of Bison 3.0, five years ago. Generated parsers do not require a C99 compiler. Support for DJGPP, which has been unmaintained and untested for years, is obsolete. Unless there is activity to revive it, the next release of Bison will have it removed. * New features - Typed midrule actions Because their type is unknown to Bison, the values of midrule actions are not treated like the others: they don't have %printer and %destructor support. It also prevents C++ (Bison) variants to handle them properly. Typed midrule actions address these issues. Instead of: exp: { $$ = 1; } { $$ = 2; } { $$ = $1 + $2; } write: exp: { $$ = 1; } { $$ = 2; } { $$ = $1 + $2; } - Reports include the type of the symbols The sections about terminal and nonterminal symbols of the '*.output' file now specify their declared type. For instance, for: %token NUM the report now shows '': Terminals, with rules where they appear NUM (258) 5 - Diagnostics about useless rules In the following grammar, the 'exp' nonterminal is trivially useless. So, of course, its rules are useless too. %% input: '0' | exp exp: exp '+' exp | exp '-' exp | '(' exp ')' Previously all the useless rules were reported, including those whose left-hand side is the 'exp' nonterminal: warning: 1 nonterminal useless in grammar [-Wother] warning: 4 rules useless in grammar [-Wother] 2.14-16: warning: nonterminal useless in grammar: exp [-Wother] input: '0' | exp ^^^ 2.14-16: warning: rule useless in grammar [-Wother] input: '0' | exp ^^^ 3.6-16: warning: rule useless in grammar [-Wother] exp: exp '+' exp | exp '-' exp | '(' exp ')' ^^^^^^^^^^^ 3.20-30: warning: rule useless in grammar [-Wother] exp: exp '+' exp | exp '-' exp | '(' exp ')' ^^^^^^^^^^^ 3.34-44: warning: rule useless in grammar [-Wother] exp: exp '+' exp | exp '-' exp | '(' exp ')' ^^^^^^^^^^^ Now, rules whose left-hand side symbol is useless are no longer reported as useless. The locations of the errors have also been adjusted to point to the first use of the nonterminal as a left-hand side of a rule: warning: 1 nonterminal useless in grammar [-Wother] warning: 4 rules useless in grammar [-Wother] 3.1-3: warning: nonterminal useless in grammar: exp [-Wother] exp: exp '+' exp | exp '-' exp | '(' exp ')' ^^^ 2.14-16: warning: rule useless in grammar [-Wother] input: '0' | exp ^^^ - C++: Generated parsers can be compiled with -fno-exceptions (lalr1.cc) When compiled with exceptions disabled, the generated parsers no longer uses try/catch clauses. Currently only GCC and Clang are supported. * Documentation - A demonstration of variants A new example was added (installed in .../share/doc/bison/examples), 'variant.yy', which shows how to use (Bison) variants in C++. The other examples were made nicer to read. - Some features are no longer 'experimental' The following features, mature enough, are no longer flagged as experimental in the documentation: push parsers, default %printer and %destructor (typed: <*> and untyped: <>), %define api.value.type union and variant, Java parsers, XML output, LR family (lr, ielr, lalr), and semantic predicates (%?). * Bug fixes - GLR: Predicates support broken by #line directives Predicates (%?) in GLR such as widget: %? {new_syntax} 'w' id new_args | %?{!new_syntax} 'w' id old_args were issued with #lines in the middle of C code. - Printer and destructor with broken #line directives The #line directives were not properly escaped when emitting the code for %printer/%destructor, which resulted in compiler errors if there are backslashes or double-quotes in the grammar file name. - Portability on ICC The Intel compiler claims compatibility with GCC, yet rejects its _Pragma. Generated parsers now work around this. - Various There were several small fixes in the test suite and in the build system, many warnings in bison and in the generated parsers were eliminated. The documentation also received its share of minor improvements. Useless code was removed from C++ parsers, and some of the generated constructors are more 'natural'. Noteworthy changes in release 3.0.5 (2018-05-27) [stable] * Bug fixes - C++: Fix support of 'syntax_error' One incorrect 'inline' resulted in linking errors about the constructor of the syntax_error exception. - C++: Fix warnings GCC 7.3 (with -O1 or -O2 but not -O0 or -O3) issued null-dereference warnings about yyformat being possibly null. It also warned about the deprecated implicit definition of copy constructors when there's a user-defined (copy) assignment operator. - Location of errors In C++ parsers, out-of-bounds errors can happen when a rule with an empty ride-hand side raises a syntax error. The behavior of the default parser (yacc.c) in such a condition was undefined. Now all the parsers match the behavior of glr.c: @$ is used as the location of the error. This handles gracefully rules with and without rhs. - Portability fixes in the test suite On some platforms, some Java and/or C++ tests were failing. --===============1444346346172439217== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline -- Problem reports: https://cygwin.com/problems.html FAQ: https://cygwin.com/faq/ Documentation: https://cygwin.com/docs.html Unsubscribe info: https://cygwin.com/ml/#unsubscribe-simple --===============1444346346172439217==--