Re: Bison 1.50 is now available

"Ralph Corderoy" <>
13 Oct 2002 16:28:44 -0400

          From comp.compilers

Related articles
Re: Bison 1.50 is now available (Ralph Corderoy) (2002-10-13)
| List of all articles for this month |

From: "Ralph Corderoy" <>
Newsgroups: comp.compilers
Date: 13 Oct 2002 16:28:44 -0400
Organization: InputPlus Ltd.
Keywords: yacc, parse, available
Posted-Date: 13 Oct 2002 16:28:44 EDT

Hi, Haven't seen this announcement grace comp.compilers yet, so here's
Paul's email. Ralph.

From: Paul Eggert <>
Subject: Bison 1.50 is now available
Date: Sat, 5 Oct 2002 21:30:47 -0700 (PDT)

Bison 1.50 is now available for download.

GNU Bison is a general-purpose parser generator that converts a
grammar description for an LALR(1) context-free grammar into a C
program to parse that grammar. Once you are proficient with Bison,
you may 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 programming in order to use Bison or to understand
this manual.

Because the changes within Bison were ambitious, and because some
people already need some of the new features to release their own
packages, we're making this release even though there is still work in
progress. Nevertheless, there is no known problem with the LALR
parsers: you can safely replace your old Bison copy with this release.

The most significant changes between Bison 1.35 and 1.50 are:

1. Many limitations on parser size have been removed.

2. A GLR parser output is available, which makes it possible to parse
      any context free grammar, included ambiguous grammars. This typically
      allows one to parse ``naturally'' contrived grammars such as C++'s.
      This is contributed by Paul Hilfinger.

3. The machinery has been revamped to ease the creation of new kinds of

This release is the result of the efforts from Robert Anisko, Akim
Demaille, Paul Eggert, Paul Hilfinger, and many others. Special
thanks to Hans Aberg for his support.

Work in progress includes:

1. a C++ LALR parser
2. a Java LALR parser
3. means to free semantic values during error recovery
4. YYPRINT replacement

and many other things.

You may find GNU Bison at the following location: (769,569 bytes) (964,656 bytes)

Soon it will also appear on the GNU mirrors listed here:

Here are the MD5 and SHA1 signatures for the compressed tar files:

deddd6f2277cdd8ca43bdf4125d67a87 bison-1.50.tar.bz2
698f7ccc47519a163c467695a726cc95 bison-1.50.tar.gz
df56fbe683a4901deb249a69a07bf477a01892d0 bison-1.50.tar.bz2
cce21237f220906c5af2a71b81db33308d37dcbe bison-1.50.tar.gz

Please report bugs by email to <>.

Here are the NEWS file entries for this release:

* GLR parsing
    The declaration
    causes Bison to produce a Generalized LR (GLR) parser, capable of handling
    almost any context-free grammar, ambiguous or not. The new declarations
    %dprec and %merge on grammar rules allow parse-time resolution of
    ambiguities. Contributed by Paul Hilfinger.

    Unfortunately GLR parsing does not yet work properly on 64-bit hosts
    like the Alpha, so please stick to 32-bit hosts for now.

* Output Directory
    When not in Yacc compatibility mode, when the output file was not
    specified, running `bison foo/bar.y' created `foo/bar.c'. It
    now creates `bar.c'.

* Undefined token
    The undefined token was systematically mapped to 2 which prevented
    the use of 2 by the user. This is no longer the case.

* Unknown token numbers
    If yylex returned an out of range value, yyparse could die. This is
    no longer the case.

* Error token
    According to POSIX, the error token must be 256.
    Bison extends this requirement by making it a preference: *if* the
    user specified that one of her tokens is numbered 256, then error
    will be mapped onto another number.

* Verbose error messages
    They no longer report `..., expecting error or...' for states where
    error recovery is possible.

* End token
    Defaults to `$end' instead of `$'.

* Error recovery now conforms to documentation and to POSIX
    When a Bison-generated parser encounters a syntax error, it now pops
    the stack until it finds a state that allows shifting the error
    token. Formerly, it popped the stack until it found a state that
    allowed some non-error action other than a default reduction on the
    error token. The new behavior has long been the documented behavior,
    and has long been required by POSIX. For more details, please see

* Traces
    Popped tokens and nonterminals are now reported.

* Larger grammars
    Larger grammars are now supported (larger token numbers, larger grammar
    size (= sum of the LHS and RHS lengths), larger LALR tables).
    Formerly, many of these numbers ran afoul of 16-bit limits;
    now these limits are 32 bits on most hosts.

* Explicit initial rule
    Bison used to play hacks with the initial rule, which the user does
    not write. It is now explicit, and visible in the reports and
    graphs as rule 0.

* Useless rules
    Before, Bison reported the useless rules, but, although not used,
    included them in the parsers. They are now actually removed.

* Useless rules, useless nonterminals
    They are now reported, as a warning, with their locations.

* Rules never reduced
    Rules that can never be reduced because of conflicts are now

* Incorrect `Token not used'
    On a grammar such as

                      %token useless useful
                      exp: '0' %prec useful;

    where a token was used to set the precedence of the last rule,
    bison reported both `useful' and `useless' as useless tokens.

* Revert the C++ namespace changes introduced in 1.31
    as they caused too many portability hassles.

* Default locations
    By an accident of design, the default computation of @$ was
    performed after another default computation was performed: @$ = @1.
    The latter is now removed: YYLLOC_DEFAULT is fully responsible of
    the computation of @$.

* Token end-of-file
    The token end of file may be specified by the user, in which case,
    the user symbol is used in the reports, the graphs, and the verbose
    error messages instead of `$end', which remains being the default.
    For instance
          %token YYEOF 0
          %token YYEOF 0 "end of file"

* Semantic parser
    This old option, which has been broken for ages, is removed.

* New translations
    Brazilian Portuguese, thanks to Alexandre Folle de Menezes.
    Croatian, thanks to Denis Lackovic.

* Incorrect token definitions
    When given `%token 'a' "A"', Bison used to output `#define 'a' 65'.

* Token definitions as enums
    Tokens are output both as the traditional #define's, and, provided
    the compiler supports ANSI C or is a C++ compiler, as enums.
    This lets debuggers display names instead of integers.

* Reports
    In addition to --verbose, bison supports --report=THINGS, which
    produces additional information:
    - itemset
        complete the core item sets with their closure
    - lookahead
        explicitly associate lookaheads to items
    - solved
        describe shift/reduce conflicts solving.
        Bison used to systematically output this information on top of
        the report. Solved conflicts are now attached to their states.

* Type clashes
    Previous versions don't complain when there is a type clash on
    the default action if the rule has a mid-rule action, such as in:

            %type <foo> bar
            bar: '0' {} '0';

    This is fixed.

* GNU M4 is now required when using Bison.

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.