@copying
-This manual is for GNU Bison (version @value{VERSION}, @value{UPDATED}),
-the GNU parser generator.
+This manual is for @acronym{GNU} Bison (version @value{VERSION},
+@value{UPDATED}), the @acronym{GNU} parser generator.
Copyright @copyright{} 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1998,
1999, 2000, 2001, 2002 Free Software Foundation, Inc.
@quotation
Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.1 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, with the Front-Cover texts being ``A GNU Manual,''
-and with the Back-Cover Texts as in (a) below. A copy of the
-license is included in the section entitled ``GNU Free Documentation
-License.''
-
-(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
-this GNU Manual, like GNU software. Copies published by the Free
-Software Foundation raise funds for GNU development.''
+under the terms of the @acronym{GNU} Free Documentation License,
+Version 1.1 or any later version published by the Free Software
+Foundation; with no Invariant Sections, with the Front-Cover texts
+being ``A @acronym{GNU} Manual,'' and with the Back-Cover Texts as in
+(a) below. A copy of the license is included in the section entitled
+``@acronym{GNU} Free Documentation License.''
+
+(a) The @acronym{FSF}'s Back-Cover Text is: ``You have freedom to copy
+and modify this @acronym{GNU} Manual, like @acronym{GNU} software.
+Copies published by the Free Software Foundation raise funds for
+@acronym{GNU} development.''
@end quotation
@end copying
@dircategory GNU programming tools
@direntry
-* bison: (bison). GNU parser generator (yacc replacement).
+* bison: (bison). @acronym{GNU} parser generator (Yacc replacement).
@end direntry
@ifset shorttitlepage-enabled
@end ifset
@titlepage
@title Bison
-@subtitle The YACC-compatible Parser Generator
+@subtitle The Yacc-compatible Parser Generator
@subtitle @value{UPDATED}, Bison Version @value{VERSION}
@author by Charles Donnelly and Richard Stallman
59 Temple Place, Suite 330 @*
Boston, MA 02111-1307 USA @*
Printed copies are available from the Free Software Foundation.@*
-ISBN 1-882114-44-2
+@acronym{ISBN} 1-882114-44-2
@sp 2
Cover art by Etienne Suvasa.
@end titlepage
@menu
* Introduction::
* Conditions::
-* Copying:: The GNU General Public License says
+* Copying:: The @acronym{GNU} General Public License says
how you can copy and share Bison
Tutorial sections:
Invoking Bison
* Bison Options:: All the options described in detail,
- in alphabetical order by short options.
+ in alphabetical order by short options.
* Option Cross Key:: Alphabetical list of long options.
-* VMS Invocation:: Bison command syntax on VMS.
+* VMS Invocation:: Bison command syntax on @acronym{VMS}.
Frequently Asked Questions
@cindex introduction
@dfn{Bison} is a general-purpose parser generator that converts a
-grammar description for an LALR(1) context-free grammar into a C
+grammar description for an @acronym{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.
As of Bison version 1.24, we have changed the distribution terms for
@code{yyparse} to permit using Bison's output in nonfree programs when
-Bison is generating C code for LALR(1) parsers. Formerly, these
+Bison is generating C code for @acronym{LALR}(1) parsers. Formerly, these
parsers could be used only in programs that were free software.
-The other GNU programming tools, such as the GNU C compiler, have never
+The other @acronym{GNU} programming tools, such as the @acronym{GNU} C
+compiler, have never
had such a requirement. They could always be used for nonfree
software. The reason Bison was different was not due to a special
policy decision; it resulted from applying the usual General Public
verbatim copy of a sizable piece of Bison, which is the code for the
@code{yyparse} function. (The actions from your grammar are inserted
into this function at one point, but the rest of the function is not
-changed.) When we applied the GPL terms to the code for @code{yyparse},
+changed.) When we applied the @acronym{GPL} terms to the code for
+@code{yyparse},
the effect was to restrict the use of Bison output to free software.
We didn't change the terms because of sympathy for people who want to
concluded that limiting Bison's use to free software was doing little to
encourage people to make other software free. So we decided to make the
practical conditions for using Bison match the practical conditions for
-using the other GNU tools.
+using the other @acronym{GNU} tools.
This exception applies only when Bison is generating C code for a
-LALR(1) parser; otherwise, the GPL terms operate as usual. You can
+@acronym{LALR}(1) parser; otherwise, the @acronym{GPL} terms operate
+as usual. You can
tell whether the exception applies to your @samp{.c} output file by
inspecting it to see whether it says ``As a special exception, when
this file is copied by Bison into a Bison output file, you may use
recursive, but there must be at least one rule which leads out of the
recursion.
-@cindex BNF
+@cindex @acronym{BNF}
@cindex Backus-Naur form
The most common formal system for presenting such rules for humans to read
-is @dfn{Backus-Naur Form} or ``BNF'', which was developed in order to
-specify the language Algol 60. Any grammar expressed in BNF is a
-context-free grammar. The input to Bison is essentially machine-readable
-BNF.
+is @dfn{Backus-Naur Form} or ``@acronym{BNF}'', which was developed in
+order to specify the language Algol 60. Any grammar expressed in
+@acronym{BNF} is a context-free grammar. The input to Bison is
+essentially machine-readable @acronym{BNF}.
-@cindex LALR(1) grammars
-@cindex LR(1) grammars
+@cindex @acronym{LALR}(1) grammars
+@cindex @acronym{LR}(1) grammars
There are various important subclasses of context-free grammar. Although it
can handle almost all context-free grammars, Bison is optimized for what
-are called LALR(1) grammars.
+are called @acronym{LALR}(1) grammars.
In brief, in these grammars, it must be possible to
tell how to parse any portion of an input string with just a single
token of look-ahead. Strictly speaking, that is a description of an
-LR(1) grammar, and LALR(1) involves additional restrictions that are
+@acronym{LR}(1) grammar, and @acronym{LALR}(1) involves additional
+restrictions that are
hard to explain simply; but it is rare in actual practice to find an
-LR(1) grammar that fails to be LALR(1). @xref{Mystery Conflicts, ,
-Mysterious Reduce/Reduce Conflicts}, for more information on this.
+@acronym{LR}(1) grammar that fails to be @acronym{LALR}(1).
+@xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}, for
+more information on this.
-@cindex GLR parsing
-@cindex generalized LR (GLR) parsing
+@cindex @acronym{GLR} parsing
+@cindex generalized @acronym{LR} (@acronym{GLR}) parsing
@cindex ambiguous grammars
@cindex non-deterministic parsing
-Parsers for LALR(1) grammars are @dfn{deterministic}, meaning roughly that
+Parsers for @acronym{LALR}(1) grammars are @dfn{deterministic},
+meaning roughly that
the next grammar rule to apply at any point in the input is uniquely
determined by the preceding input and a fixed, finite portion (called
a @dfn{look-ahead}) of the remaining input.
Even unambiguous grammars can be @dfn{non-deterministic}, meaning that no
fixed look-ahead always suffices to determine the next grammar rule to apply.
With the proper declarations, Bison is also able to parse these more general
-context-free grammars, using a technique known as GLR parsing (for
-Generalized LR). Bison's GLR parsers are able to handle any context-free
+context-free grammars, using a technique known as @acronym{GLR} parsing (for
+Generalized @acronym{LR}). Bison's @acronym{GLR} parsers are able to
+handle any context-free
grammar for which the number of possible parses of any given string
is finite.
a @dfn{Bison grammar} file. @xref{Grammar File, ,Bison Grammar Files}.
A nonterminal symbol in the formal grammar is represented in Bison input
-as an identifier, like an identifier in C. By convention, it should be
+as an identifier, like an identifier in C@. By convention, it should be
in lower case, such as @code{expr}, @code{stmt} or @code{declaration}.
The Bison representation for a terminal symbol is also called a @dfn{token
But the precise value is very important for what the input means once it is
parsed. A compiler is useless if it fails to distinguish between 4, 1 and
3989 as constants in the program! Therefore, each token in a Bison grammar
-has both a token type and a @dfn{semantic value}. @xref{Semantics, ,Defining Language Semantics},
+has both a token type and a @dfn{semantic value}. @xref{Semantics,
+,Defining Language Semantics},
for details.
The token type is a terminal symbol defined in the grammar, such as
from the values of the two subexpressions.
@node GLR Parsers
-@section Writing GLR Parsers
-@cindex GLR parsing
-@cindex generalized LR (GLR) parsing
+@section Writing @acronym{GLR} Parsers
+@cindex @acronym{GLR} parsing
+@cindex generalized @acronym{LR} (@acronym{GLR}) parsing
@findex %glr-parser
@cindex conflicts
@cindex shift/reduce conflicts
-In some grammars, there will be cases where Bison's standard LALR(1)
+In some grammars, there will be cases where Bison's standard @acronym{LALR}(1)
parsing algorithm cannot decide whether to apply a certain grammar rule
at a given point. That is, it may not be able to decide (on the basis
of the input read so far) which of two possible reductions (applications
respectively as @dfn{reduce/reduce} conflicts (@pxref{Reduce/Reduce}),
and @dfn{shift/reduce} conflicts (@pxref{Shift/Reduce}).
-To use a grammar that is not easily modified to be LALR(1), a more
+To use a grammar that is not easily modified to be @acronym{LALR}(1), a more
general parsing algorithm is sometimes necessary. If you include
@code{%glr-parser} among the Bison declarations in your file
-(@pxref{Grammar Outline}), the result will be a Generalized LR (GLR)
+(@pxref{Grammar Outline}), the result will be a Generalized
+@acronym{LR} (@acronym{GLR})
parser. These parsers handle Bison grammars that contain no unresolved
conflicts (i.e., after applying precedence declarations) identically to
-LALR(1) parsers. However, when faced with unresolved shift/reduce and
-reduce/reduce conflicts, GLR parsers use the simple expedient of doing
+@acronym{LALR}(1) parsers. However, when faced with unresolved
+shift/reduce and reduce/reduce conflicts, @acronym{GLR} parsers use
+the simple expedient of doing
both, effectively cloning the parser to follow both possibilities. Each
of the resulting parsers can again split, so that at any given time,
there can be any number of possible parses being explored. The parsers
user-defined function on the resulting values to produce an arbitrary
merged result.
-Let's consider an example, vastly simplified from C++.
+Let's consider an example, vastly simplified from a C++ grammar.
@example
%@{
| decl %dprec 2
;
-expr : ID @{ printf ("%s ", $$); @}
+expr : ID @{ printf ("%s ", $$); @}
| TYPENAME '(' expr ')'
- @{ printf ("%s <cast> ", $1); @}
- | expr '+' expr @{ printf ("+ "); @}
- | expr '=' expr @{ printf ("= "); @}
+ @{ printf ("%s <cast> ", $1); @}
+ | expr '+' expr @{ printf ("+ "); @}
+ | expr '=' expr @{ printf ("= "); @}
;
decl : TYPENAME declarator ';'
- @{ printf ("%s <declare> ", $1); @}
+ @{ printf ("%s <declare> ", $1); @}
| TYPENAME declarator '=' expr ';'
- @{ printf ("%s <init-declare> ", $1); @}
+ @{ printf ("%s <init-declare> ", $1); @}
;
-declarator : ID @{ printf ("\"%s\" ", $1); @}
+declarator : ID @{ printf ("\"%s\" ", $1); @}
| '(' declarator ')'
;
@end example
@noindent
parses as either an @code{expr} or a @code{stmt}
-(assuming that @samp{T} is recognized as a TYPENAME and @samp{x} as an ID).
+(assuming that @samp{T} is recognized as a @code{TYPENAME} and
+@samp{x} as an @code{ID}).
Bison detects this as a reduce/reduce conflict between the rules
@code{expr : ID} and @code{declarator : ID}, which it cannot resolve at the
time it encounters @code{x} in the example above. The two @code{%dprec}
@cindex position, textual
Many applications, like interpreters or compilers, have to produce verbose
-and useful error messages. To achieve this, one must be able to keep track of
+and useful error messages. To achieve this, one must be able to keep track of
the @dfn{textual position}, or @dfn{location}, of each syntactic construct.
Bison provides a mechanism for handling these locations.
-Each token has a semantic value. In a similar fashion, each token has an
+Each token has a semantic value. In a similar fashion, each token has an
associated location, but the type of locations is the same for all tokens and
-groupings. Moreover, the output parser is equipped with a default data
+groupings. Moreover, the output parser is equipped with a default data
structure for storing locations (@pxref{Locations}, for more details).
Like semantic values, locations can be reached in actions using a dedicated
-set of constructs. In the example above, the location of the whole grouping
+set of constructs. In the example above, the location of the whole grouping
is @code{@@$}, while the locations of the subexpressions are @code{@@1} and
@code{@@3}.
When a rule is matched, a default action is used to compute the semantic value
-of its left hand side (@pxref{Actions}). In the same way, another default
-action is used for locations. However, the action for locations is general
+of its left hand side (@pxref{Actions}). In the same way, another default
+action is used for locations. However, the action for locations is general
enough for most cases, meaning there is usually no need to describe for each
-rule how @code{@@$} should be formed. When building a new location for a given
+rule how @code{@@$} should be formed. When building a new location for a given
grouping, the default behavior of the output parser is to take the beginning
of the first symbol, and the end of the last symbol.
In some cases the Bison parser file includes system headers, and in
those cases your code should respect the identifiers reserved by those
-headers. On some non-@
sc{gnu} hosts, @code{<alloca.h>},
+headers. On some non-@
acronym{GNU} hosts, @code{<alloca.h>},
@code{<stddef.h>}, and @code{<stdlib.h>} are included as needed to
declare memory allocators and related types. Other system headers may
be included if you define @code{YYDEBUG} to a nonzero value
The @samp{%%}, @samp{%@{} and @samp{%@}} are punctuation that appears
in every Bison grammar file to separate the sections.
-The prologue may define types and variables used in the actions. You can
+The prologue may define types and variables used in the actions. You can
also use preprocessor commands to define macros used there, and use
@code{#include} to include header files that do any of these things.
The grammar rules define how to construct each nonterminal symbol from its
parts.
-The epilogue can contain any code you want to use. Often the definition of
+The epilogue can contain any code you want to use. Often the definition of
the lexical analyzer @code{yylex} goes here, plus subroutines called by the
actions in the grammar rules. In a simple program, all the rest of the
program can go here.
calculator. As in C, comments are placed between @samp{/*@dots{}*/}.
@example
-/* Reverse polish notation calculator. */
+/* Reverse polish notation calculator. */
%@{
#define YYSTYPE double
%token NUM
-%% /* Grammar rules and actions follow */
+%% /* Grammar rules and actions follow. */
@end example
The declarations section (@pxref{Prologue, , The prologue}) contains two
The parser function @code{yyparse} continues to process input until a
grammatical error is seen or the lexical analyzer says there are no more
-input tokens; we will arrange for the latter to happen at end of file.
+input tokens; we will arrange for the latter to happen at end-of-input.
@node Rpcalc Line
@subsubsection Explanation of @code{line}
This is what happens in the first rule (the one that uses @code{NUM}).
The formatting shown here is the recommended convention, but Bison does
-not require it. You can add or change whitespace as much as you wish.
+not require it. You can add or change white space as much as you wish.
For example, this:
@example
tokens by calling the lexical analyzer. @xref{Lexical, ,The Lexical
Analyzer Function @code{yylex}}.
-Only a simple lexical analyzer is needed for the RPN calculator. This
+Only a simple lexical analyzer is needed for the @acronym{RPN}
+calculator. This
lexical analyzer skips blanks and tabs, then reads in numbers as
@code{double} and returns them as @code{NUM} tokens. Any other character
that isn't part of a number is a separate token. Note that the token-code
defined at the beginning of the grammar; @pxref{Rpcalc Decls,
,Declarations for @code{rpcalc}}.)
-A token type code of zero is returned if the end-of-file is encountered.
-(Bison recognizes any nonpositive value as indicating the end of the
-input.)
+A token type code of zero is returned if the end-of-input is encountered.
+(Bison recognizes any nonpositive value as indicating end-of-input.)
Here is the code for the lexical analyzer:
@example
@group
-/* Lexical analyzer returns a double floating point
+/* The lexical analyzer returns a double floating point
number on the stack and the token NUM, or the numeric code
- of the character read if not a number. Skips all blanks
- and tabs, returns 0 for EOF. */
+ of the character read if not a number. It skips all blanks
+ and tabs, and returns 0 for end-of-input. */
#include <ctype.h>
@end group
@{
int c;
- /* skip white space */
+ /* Skip white space. */
while ((c = getchar ()) == ' ' || c == '\t')
;
@end group
@group
- /* process numbers */
+ /* Process numbers. */
if (c == '.' || isdigit (c))
@{
ungetc (c, stdin);
@}
@end group
@group
- /* return end-of-file */
+ /* Return end-of-input. */
if (c == EOF)
return 0;
- /* return single chars */
+ /* Return a single char. */
return c;
@}
@end group
#include <stdio.h>
void
-yyerror (const char *s) /* Called by yyparse on error */
+yyerror (const char *s) /* Called by yyparse on error. */
@{
printf ("%s\n", s);
@}
@noindent
In this example the file was called @file{rpcalc.y} (for ``Reverse Polish
-CALCulator''). Bison produces a file named @file{@var{file_name}.tab.c},
-removing the @samp{.y} from the original file name. The file output by
+@sc{calc}ulator''). Bison produces a file named @file{@var{file_name}.tab.c},
+removing the @samp{.y} from the original file name. The file output by
Bison contains the source code for @code{yyparse}. The additional
functions in the input file (@code{yylex}, @code{yyerror} and @code{main})
are copied verbatim to the output.
@group
# @r{Compile the Bison parser.}
# @r{@samp{-lm} tells compiler to search math library for @code{pow}.}
-$ @kbd{cc rpcalc.tab.c -lm -o rpcalc}
+$ @kbd{cc -lm -o rpcalc rpcalc.tab.c}
@end group
@group
#include <math.h>
%@}
-/* BISON Declarations */
+/* Bison Declarations */
%token NUM
%left '-' '+'
%left '*' '/'
tracking. This feature will be used to improve the error messages. For
the sake of clarity, this example is a simple integer calculator, since
most of the work needed to use locations will be done in the lexical
-analyser.
+analyzer.
@menu
* Decls: Ltcalc Decls. Bison and C declarations for ltcalc.
@subsection The @code{ltcalc} Lexical Analyzer.
Until now, we relied on Bison's defaults to enable location
-tracking. The next step is to rewrite the lexical analyser, and make it
+tracking. The next step is to rewrite the lexical analyzer, and make it
able to feed the parser with the token locations, as it already does for
semantic values.
@{
int c;
- /* skip white space */
+ /* Skip white space. */
while ((c = getchar ()) == ' ' || c == '\t')
++yylloc.last_column;
- /* step */
+ /* Step. */
yylloc.first_line = yylloc.last_line;
yylloc.first_column = yylloc.last_column;
@end group
@group
- /* process numbers */
+ /* Process numbers. */
if (isdigit (c))
@{
yylval = c - '0';
@}
@end group
- /* return end-of-file */
+ /* Return end-of-input. */
if (c == EOF)
return 0;
- /* return single chars and update location */
+ /* Return a single char, and update location. */
if (c == '\n')
@{
++yylloc.last_line;
@code{YYLTYPE}) containing the token's location.
Now, each time this function returns a token, the parser has its number
-as well as its semantic value, and its location in the text. The last
+as well as its semantic value, and its location in the text. The last
needed change is to initialize @code{yylloc}, for example in the
controlling function:
@smallexample
%@{
-#include <math.h> /* For math functions, cos(), sin(), etc. */
+#include <math.h> /* For math functions, cos(), sin(), etc. */
#include "calc.h" /* Contains definition of `symrec' */
%@}
%union @{
@smallexample
@group
-/* Fonctions type. */
+/* Function type. */
typedef double (*func_t) (double);
/* Data type for links in the chain of symbols. */
@group
void
-yyerror (const char *s) /* Called by yyparse on error */
+yyerror (const char *s) /* Called by yyparse on error. */
@{
printf ("%s\n", s);
@}
@end group
@group
-/* Put arithmetic functions in table. */
+/* Put arithmetic functions in table. */
void
init_table (void)
@{
ptr->name = (char *) malloc (strlen (sym_name) + 1);
strcpy (ptr->name,sym_name);
ptr->type = sym_type;
- ptr->value.var = 0; /* set value to 0 even if fctn. */
+ ptr->value.var = 0; /* Set value to 0 even if fctn. */
ptr->next = (struct symrec *)sym_table;
sym_table = ptr;
return ptr;
@{
int c;
- /* Ignore whitespace, get first nonwhite character. */
+ /* Ignore white space, get first nonwhite character. */
while ((c = getchar ()) == ' ' || c == '\t');
if (c == EOF)
@}
@end group
@group
- while (c != EOF && isalnum (c));
+ while (isalnum (c));
ungetc (c, stdin);
symbuf[i] = '\0';
@end group
@end smallexample
-This program is both powerful and flexible. You may easily add new
+This program is both powerful and flexible. You may easily add new
functions, and it is a simple job to modify this code to install
predefined variables such as @code{pi} or @code{e} as well.
@end example
Comments enclosed in @samp{/* @dots{} */} may appear in any of the sections.
+As a @acronym{GNU} extension, @samp{//} introduces a comment that
+continues until end of line.
@menu
* Prologue:: Syntax and usage of the prologue.
@itemize @bullet
@item
A @dfn{named token type} is written with an identifier, like an
-identifier in C. By convention, it should be all upper case. Each
+identifier in C@. By convention, it should be all upper case. Each
such name must be defined with a Bison declaration such as
@code{%token}. @xref{Token Decl, ,Token Type Names}.
All the usual escape sequences used in character literals in C can be
used in Bison as well, but you must not use the null character as a
-character literal because its numeric code, zero, is the code @code{yylex}
-returns for end-of-input (@pxref{Calling Convention, ,Calling Convention
-for @code{yylex}}).
+character literal because its numeric code, zero, signifies
+end-of-input (@pxref{Calling Convention, ,Calling Convention
+for @code{yylex}}). Also, unlike standard C, trigraphs have no
+special meaning in Bison character literals, nor is backslash-newline
+allowed.
@item
@cindex string token
retrieve the token number for the literal string token from the
@code{yytname} table (@pxref{Calling Convention}).
-@strong{WARNING}: literal string tokens do not work in Yacc.
+@strong{Warning}: literal string tokens do not work in Yacc.
By convention, a literal string token is used only to represent a token
that consists of that particular string. Thus, you should use the token
read your program will be confused.
All the escape sequences used in string literals in C can be used in
-Bison as well. A literal string token must contain two or more
-characters; for a token containing just one character, use a character
-token (see above).
+Bison as well. However, unlike Standard C, trigraphs have no special
+meaning in Bison string literals, nor is backslash-newline allowed. A
+literal string token must contain two or more characters; for a token
+containing just one character, use a character token (see above).
@end itemize
How you choose to write a terminal symbol has no effect on its
grammatical meaning. That depends only on where it appears in rules and
on when the parser function returns that symbol.
-The value returned by @code{yylex} is always one of the terminal symbols
-(or 0 for end-of-input). Whichever way you write the token type in the
-grammar rules, you write it the same way in the definition of @code{yylex}.
-The numeric code for a character token type is simply the numeric code of
-the character, so @code{yylex} can use the identical character constant to
-generate the requisite code. Each named token type becomes a C macro in
+The value returned by @code{yylex} is always one of the terminal
+symbols, except that a zero or negative value signifies end-of-input.
+Whichever way you write the token type in the grammar rules, you write
+it the same way in the definition of @code{yylex}. The numeric code
+for a character token type is simply the positive numeric code of the
+character, so @code{yylex} can use the identical value to generate the
+requisite code, though you may need to convert it to @code{unsigned
+char} to avoid sign-extension on hosts where @code{char} is signed.
+Each named token type becomes a C macro in
the parser file, so @code{yylex} can use the name to stand for the code.
(This is why periods don't make sense in terminal symbols.)
@xref{Calling Convention, ,Calling Convention for @code{yylex}}.
into a separate header file @file{@var{name}.tab.h} which you can include
in the other source files that need it. @xref{Invocation, ,Invoking Bison}.
-The @code{yylex} function must use the same character set and encoding
-that was used by Bison. For example, if you run Bison in an
-@sc{ascii} environment, but then compile and run the resulting program
+If you want to write a grammar that is portable to any Standard C
+host, you must use only non-null character tokens taken from the basic
+execution character set of Standard C@. This set consists of the ten
+digits, the 52 lower- and upper-case English letters, and the
+characters in the following C-language string:
+
+@example
+"\a\b\t\n\v\f\r !\"#%&'()*+,-./:;<=>?[\\]^_@{|@}~"
+@end example
+
+The @code{yylex} function and Bison must use a consistent character
+set and encoding for character tokens. For example, if you run Bison in an
+@acronym{ASCII} environment, but then compile and run the resulting program
in an environment that uses an incompatible character set like
-@sc{ebcdic}, the resulting program will probably not work because the
-tables generated by Bison will assume @sc{ascii} numeric values for
-character tokens. Portable grammars should avoid non-@sc{ascii}
-character tokens, as implementations in practice often use different
-and incompatible extensions in this area. However, it is standard
+@acronym{EBCDIC}, the resulting program may not work because the
+tables generated by Bison will assume @acronym{ASCII} numeric values for
+character tokens. It is standard
practice for software distributions to contain C source files that
-were generated by Bison in an @sc{ascii} environment, so installers on
-platforms that are incompatible with @sc{ascii} must rebuild those
+were generated by Bison in an @acronym{ASCII} environment, so installers on
+platforms that are incompatible with @acronym{ASCII} must rebuild those
files before compiling them.
The symbol @code{error} is a terminal symbol reserved for error recovery
says that two groupings of type @code{exp}, with a @samp{+} token in between,
can be combined into a larger grouping of type @code{exp}.
-Whitespace in rules is significant only to separate symbols. You can add
-extra whitespace as you wish.
+White space in rules is significant only to separate symbols. You can add
+extra white space as you wish.
Scattered among the components can be @var{actions} that determine
the semantics of the rule. An action looks like this:
In a simple program it may be sufficient to use the same data type for
the semantic values of all language constructs. This was true in the
-RPN and infix calculator examples (@pxref{RPN Calc, ,Reverse Polish
+@acronym{RPN} and infix calculator examples (@pxref{RPN Calc, ,Reverse Polish
Notation Calculator}).
Bison's default is to use type @code{int} for all semantic values. To
semantic values associated with tokens or smaller groupings.
An action consists of C statements surrounded by braces, much like a
-compound statement in C. It can be placed at any position in the rule;
+compound statement in C@. An action can contain any sequence of C
+statements. Bison does not look for trigraphs, though, so if your C
+code uses trigraphs you should ensure that they do not affect the
+nesting of braces or the boundaries of comments, strings, or character
+literals.
+
+An action can be placed at any position in the rule;
it is executed at that position. Most rules have just one action at the
end of the rule, following all the components. Actions in the middle of
a rule are tricky and used only for special purposes (@pxref{Mid-Rule
@cindex position, textual
Though grammar rules and semantic actions are enough to write a fully
-functional parser, it can be useful to process some additionnal informations,
+functional parser, it can be useful to process some additional information,
especially symbol locations.
@c (terminal or not) ?
describing the behavior of the output parser with locations.
The most obvious way for building locations of syntactic groupings is very
-similar to the way semantic values are computed. In a given rule, several
+similar to the way semantic values are computed. In a given rule, several
constructs can be used to access the locations of the elements being matched.
The location of the @var{n}th component of the right hand side is
@code{@@@var{n}}, while the location of the left hand side grouping is
@end example
As for semantic values, there is a default action for locations that is
-run each time a rule is matched. It sets the beginning of @code{@@$} to the
+run each time a rule is matched. It sets the beginning of @code{@@$} to the
beginning of the first symbol, and the end of @code{@@$} to the end of the
last symbol.
-With this default action, the location tracking can be fully automatic. The
+With this default action, the location tracking can be fully automatic. The
example above simply rewrites this way:
@example
@subsection Default Action for Locations
@vindex YYLLOC_DEFAULT
-Actually, actions are not the best place to compute locations. Since
+Actually, actions are not the best place to compute locations. Since
locations are much more general than semantic values, there is room in
the output parser to redefine the default action to take for each
-rule. The @code{YYLLOC_DEFAULT} macro is invoked each time a rule is
+rule. The @code{YYLLOC_DEFAULT} macro is invoked each time a rule is
matched, before the associated action is run.
Most of the time, this macro is general enough to suppress location
dedicated code from semantic actions.
-The @code{YYLLOC_DEFAULT} macro takes three parameters. The first one is
-the location of the grouping (the result of the computation). The second one
+The @code{YYLLOC_DEFAULT} macro takes three parameters. The first one is
+the location of the grouping (the result of the computation). The second one
is an array holding locations of all right hand side elements of the rule
-being matched. The last one is the size of the right hand side rule.
+being matched. The last one is the size of the right hand side rule.
-By default, it is defined this way for simple LALR(1) parsers:
+By default, it is defined this way for simple @acronym{LALR}(1) parsers:
@example
@group
@end example
@noindent
-and like this for GLR parsers:
+and like this for @acronym{GLR} parsers:
@example
@group
@itemize @bullet
@item
-All arguments are free of side-effects. However, only the first one (the
+All arguments are free of side-effects. However, only the first one (the
result) should be modified by @code{YYLLOC_DEFAULT}.
@item
program must be called only within interlocks.
Normally, Bison generates a parser which is not reentrant. This is
-suitable for most uses, and it permits compatibility with YACC. (The
-standard YACC interfaces are inherently nonreentrant, because they use
+suitable for most uses, and it permits compatibility with Yacc. (The
+standard Yacc interfaces are inherently nonreentrant, because they use
statically allocated variables for communication with @code{yylex},
including @code{yylval} and @code{yylloc}.)
Rename the external symbols used in the parser so that they start with
@var{prefix} instead of @samp{yy}. The precise list of symbols renamed
is @code{yyparse}, @code{yylex}, @code{yyerror}, @code{yynerrs},
-@code{yylval}, @code{yychar}, @code{yydebug}, and possible
-@code{yylloc}. For example, if you use @samp{%name-prefix="c_"}, the
-names become @code{c_parse}, @code{c_lex}, and so on. @xref{Multiple
-Parsers, ,Multiple Parsers in the Same Program}.
+@code{yylval}, @code{yylloc}, @code{yychar}, @code{yydebug}, and
+possible @code{yylloc}. For example, if you use
+@samp{%name-prefix="c_"}, the names become @code{c_parse}, @code{c_lex},
+and so on. @xref{Multiple Parsers, ,Multiple Parsers in the Same
+Program}.
@item %no-parser
Do not include any C code in the parser file; generate tables only. The
@item %verbose
Write an extra output file containing verbose descriptions of the
parser states and what is done for each type of look-ahead token in
-that state. @xref{Understanding, , Understanding Your Parser}, for more
+that state. @xref{Understanding, , Understanding Your Parser}, for more
information.
names that do not conflict.
The precise list of symbols renamed is @code{yyparse}, @code{yylex},
-@code{yyerror}, @code{yynerrs}, @code{yylval}, @code{yychar} and
-@code{yydebug}. For example, if you use @samp{-p c}, the names become
-@code{cparse}, @code{clex}, and so on.
+@code{yyerror}, @code{yynerrs}, @code{yylval}, @code{yylloc},
+@code{yychar} and @code{yydebug}. For example, if you use @samp{-p c},
+the names become @code{cparse}, @code{clex}, and so on.
@strong{All the other variables and macros associated with Bison are not
renamed.} These others are not global; there is no conflict if the same
write an action which directs @code{yyparse} to return immediately
without reading further.
+
+@deftypefun int yyparse (void)
The value returned by @code{yyparse} is 0 if parsing was successful (return
is due to end-of-input).
The value is 1 if parsing failed (return is due to a syntax error).
+@end deftypefun
In an action, you can cause immediate return from @code{yyparse} by using
these macros:
-@table @code
-@item YYACCEPT
+@defmac YYACCEPT
@findex YYACCEPT
Return immediately with value 0 (to report success).
+@end defmac
-@item YYABORT
+@defmac YYABORT
@findex YYABORT
Return immediately with value 1 (to report failure).
-@end table
+@end defmac
+
+If you use a reentrant parser, you can optionally pass additional
+parameter information to it in a reentrant way. To do so, use the
+declaration @code{%parse-param}:
+
+@deffn {Directive} %parse-param @var{argument-declaration} @var{argument-name}
+@findex %parse-param
+Declare that @code{argument-name} is an additional @code{yyparse}
+argument. This argument is also passed to @code{yyerror}. The
+@var{argument-declaration} is used when declaring functions or
+prototypes.
+@end deffn
+
+Here's an example. Write this in the parser:
+
+@example
+%parse-param "int *nastiness" "nastiness"
+%parse-param "int *randomness" "randomness"
+@end example
+
+@noindent
+Then call the parser like this:
+
+@example
+@{
+ int nastiness, randomness;
+ @dots{} /* @r{Store proper data in @code{nastiness} and @code{randomness}.} */
+ value = yyparse (&nastiness, &randomness);
+ @dots{}
+@}
+@end example
+
+@noindent
+In the grammar actions, use expressions like this to refer to the data:
+
+@example
+exp: @dots{} @{ @dots{}; *randomness += 1; @dots{} @}
+@end example
+
@node Lexical
@section The Lexical Analyzer Function @code{yylex}
@node Calling Convention
@subsection Calling Convention for @code{yylex}
-The value that @code{yylex} returns must be the numeric code for the type
-of token it has just found, or 0 for end-of-input.
+The value that @code{yylex} returns must be the positive numeric code
+for the type of token it has just found; a zero or negative value
+signifies end-of-input.
When a token is referred to in the grammar rules by a name, that name
in the parser file becomes a C macro whose definition is the proper
When a token is referred to in the grammar rules by a character literal,
the numeric code for that character is also the code for the token type.
-So @code{yylex} can simply return that character code. The null character
-must not be used this way, because its code is zero and that is what
+So @code{yylex} can simply return that character code, possibly converted
+to @code{unsigned char} to avoid sign-extension. The null character
+must not be used this way, because its code is zero and that
signifies end-of-input.
Here is an example showing these things:
yylex (void)
@{
@dots{}
- if (c == EOF) /* Detect end of file. */
+ if (c == EOF) /* Detect end-of-input. */
return 0;
@dots{}
if (c == '+' || c == '-')
- return c; /* Assume token type for `+' is '+'. */
+ return c; /* Assume token type for `+' is '+'. */
@dots{}
- return INT; /* Return the type of the token. */
+ return INT; /* Return the type of the token. */
@dots{}
@}
@end example
@{
if (yytname[i] != 0
&& yytname[i][0] == '"'
- && strncmp (yytname[i] + 1, token_buffer,
- strlen (token_buffer))
+ && ! strncmp (yytname[i] + 1, token_buffer,
+ strlen (token_buffer))
&& yytname[i][strlen (token_buffer) + 1] == '"'
&& yytname[i][strlen (token_buffer) + 2] == 0)
break;
@example
@group
@dots{}
- yylval = value; /* Put value onto Bison stack. */
- return INT; /* Return the type of the token. */
+ yylval = value; /* Put value onto Bison stack. */
+ return INT; /* Return the type of the token. */
@dots{}
@end group
@end example
@example
@group
@dots{}
- yylval.intval = value; /* Put value onto Bison stack. */
- return INT; /* Return the type of the token. */
+ yylval.intval = value; /* Put value onto Bison stack. */
+ return INT; /* Return the type of the token. */
@dots{}
@end group
@end example
this case, omit the second argument; @code{yylex} will be called with
only one argument.
-@vindex YYPARSE_PARAM
-If you use a reentrant parser, you can optionally pass additional
-parameter information to it in a reentrant way. To do so, define the
-macro @code{YYPARSE_PARAM} as a variable name. This modifies the
-@code{yyparse} function to accept one argument, of type @code{void *},
-with that name.
-
-When you call @code{yyparse}, pass the address of an object, casting the
-address to @code{void *}. The grammar actions can refer to the contents
-of the object by casting the pointer value back to its proper type and
-then dereferencing it. Here's an example. Write this in the parser:
-@example
-%@{
-struct parser_control
-@{
- int nastiness;
- int randomness;
-@};
+If you wish to pass the additional parameter data to @code{yylex}, use
+@code{%lex-param} just like @code{%parse-param} (@pxref{Parser
+Function}).
-#define YYPARSE_PARAM parm
-%@}
-@end example
+@deffn {Directive} lex-param @var{argument-declaration} @var{argument-name}
+@findex %lex-param
+Declare that @code{argument-name} is an additional @code{yylex}
+argument.
+@end deffn
-@noindent
-Then call the parser like this:
+For instance:
@example
-struct parser_control
-@{
- int nastiness;
- int randomness;
-@};
-
-@dots{}
-
-@{
- struct parser_control foo;
- @dots{} /* @r{Store proper data in @code{foo}.} */
- value = yyparse ((void *) &foo);
- @dots{}
-@}
+%parse-param "int *nastiness" "nastiness"
+%lex-param "int *nastiness" "nastiness"
+%parse-param "int *randomness" "randomness"
@end example
@noindent
-In the grammar actions, use expressions like this to refer to the data:
+results in the following signature:
@example
-((struct parser_control *) parm)->randomness
+int yylex (int *nastiness);
+int yyparse (int *nastiness, int *randomness);
@end example
-@vindex YYLEX_PARAM
-If you wish to pass the additional parameter data to @code{yylex},
-define the macro @code{YYLEX_PARAM} just like @code{YYPARSE_PARAM}, as
-shown here:
+If @code{%pure-parser} is added:
@example
-%@{
-struct parser_control
-@{
- int nastiness;
- int randomness;
-@};
-
-#define YYPARSE_PARAM parm
-#define YYLEX_PARAM parm
-%@}
+int yylex (YYSTYPE *lvalp, int *nastiness);
+int yyparse (int *nastiness, int *randomness);
@end example
-You should then define @code{yylex} to accept one additional
-argument---the value of @code{parm}. (This makes either two or three
-arguments in total, depending on whether an argument of type
-@code{YYLTYPE} is passed.) You can declare the argument as a pointer to
-the proper object type, or you can declare it as @code{void *} and
-access the contents as shown above.
+@noindent
+and finally, if both @code{%pure-parser} and @code{%locations} are used:
-You can use @samp{%pure-parser} to request a reentrant parser without
-also using @code{YYPARSE_PARAM}. Then you should call @code{yyparse}
-with no arguments, as usual.
+@example
+int yylex (YYSTYPE *lvalp, YYLTYPE *llocp, int *nastiness);
+int yyparse (int *nastiness, int *randomness);
+@end example
@node Error Reporting
@section The Error Reporting Function @code{yyerror}
receives one argument. For a parse error, the string is normally
@w{@code{"parse error"}}.
-@findex YYERROR_VERBOSE
-If you define the macro @code{YYERROR_VERBOSE} in the Bison declarations
-section (@pxref{Bison Declarations, ,The Bison Declarations Section}),
-then Bison provides a more verbose and specific error message string
-instead of just plain @w{@code{"parse error"}}. It doesn't matter what
-definition you use for @code{YYERROR_VERBOSE}, just whether you define
-it.
+@findex %error-verbose
+If you invoke the directive @code{%error-verbose} in the Bison
+declarations section (@pxref{Bison Declarations, ,The Bison Declarations
+Section}), then Bison provides a more verbose and specific error message
+string instead of just plain @w{@code{"parse error"}}.
The parser can detect one other kind of error: stack overflow. This
happens when the input contains constructions that are very deeply
@example
@group
void
-yyerror (char *s)
+yyerror (const char *s)
@{
@end group
@group
(@pxref{Error Recovery}). If recovery is impossible, @code{yyparse} will
immediately return 1.
+Obviously, in location tracking pure parsers, @code{yyerror} should have
+an access to the current location. This is indeed the case for the GLR
+parsers, but not for the Yacc parser, for historical reasons. I.e., if
+@samp{%locations %pure-parser} is passed then the prototypes for
+@code{yyerror} are:
+
+@example
+void yyerror (const char *msg); /* Yacc parsers. */
+void yyerror (YYLTYPE *locp, const char *msg); /* GLR parsers. */
+@end example
+
+If @samp{%parse-param "int *nastiness" "nastiness"} is used, then:
+
+@example
+void yyerror (int *randomness, const char *msg); /* Yacc parsers. */
+void yyerror (int *randomness, const char *msg); /* GLR parsers. */
+@end example
+
+Finally, GLR and Yacc parsers share the same @code{yyerror} calling
+convention for absolutely pure parsers, i.e., when the calling
+convention of @code{yylex} @emph{and} the calling convention of
+@code{%pure-parser} are pure. I.e.:
+
+@example
+/* Location tracking. */
+%locations
+/* Pure yylex. */
+%pure-parser
+%lex-param "int *nastiness" "nastiness"
+/* Pure yyparse. */
+%parse-param "int *nastiness" "nastiness"
+%parse-param "int *randomness" "randomness"
+@end example
+
+@noindent
+results in the following signatures for all the parser kinds:
+
+@example
+int yylex (YYSTYPE *lvalp, YYLTYPE *llocp, int *nastiness);
+int yyparse (int *nastiness, int *randomness);
+void yyerror (YYLTYPE *locp,
+ int *nastiness, int *randomness,
+ const char *msg);
+@end example
+
+@noident
+Please, note that the prototypes are only indications of how the code
+produced by Bison will use @code{yyerror}, but you still have freedom
+and the exit value, and even on making @code{yyerror} a variadic
+function. It is precisely to enable this that the message is passed
+last.
+
@vindex yynerrs
The variable @code{yynerrs} contains the number of syntax errors
encountered so far. Normally this variable is global; but if you
@findex YYBACKUP
Unshift a token. This macro is allowed only for rules that reduce
a single value, and only when there is no look-ahead token.
-It is also disallowed in GLR parsers.
+It is also disallowed in @acronym{GLR} parsers.
It installs a look-ahead token with token type @var{token} and
semantic value @var{value}; then it discards the value that was
going to be reduced by this rule.
It would seem that this grammar can be parsed with only a single token
of look-ahead: when a @code{param_spec} is being read, an @code{ID} is
a @code{name} if a comma or colon follows, or a @code{type} if another
-@code{ID} follows. In other words, this grammar is LR(1).
+@code{ID} follows. In other words, this grammar is @acronym{LR}(1).
-@cindex LR(1)
-@cindex LALR(1)
+@cindex @acronym{LR}(1)
+@cindex @acronym{LALR}(1)
However, Bison, like most parser generators, cannot actually handle all
-LR(1) grammars. In this grammar, two contexts, that after an @code{ID}
+@acronym{LR}(1) grammars. In this grammar, two contexts, that after
+an @code{ID}
at the beginning of a @code{param_spec} and likewise at the beginning of
a @code{return_spec}, are similar enough that Bison assumes they are the
same. They appear similar because the same set of rules would be
that the rules would require different look-ahead tokens in the two
contexts, so it makes a single parser state for them both. Combining
the two contexts causes a conflict later. In parser terminology, this
-occurrence means that the grammar is not LALR(1).
+occurrence means that the grammar is not @acronym{LALR}(1).
In general, it is better to fix deficiencies than to document them. But
this particular deficiency is intrinsically hard to fix; parser
-generators that can handle LR(1) grammars are hard to write and tend to
+generators that can handle @acronym{LR}(1) grammars are hard to write
+and tend to
produce parsers that are very large. In practice, Bison is more useful
as it is now.
@end example
@node Generalized LR Parsing
-@section Generalized LR (GLR) Parsing
-@cindex GLR parsing
-@cindex generalized LR (GLR) parsing
+@section Generalized @acronym{LR} (@acronym{GLR}) Parsing
+@cindex @acronym{GLR} parsing
+@cindex generalized @acronym{LR} (@acronym{GLR}) parsing
@cindex ambiguous grammars
@cindex non-deterministic parsing
When you use the @samp{%glr-parser} declaration in your grammar file,
Bison generates a parser that uses a different algorithm, called
-Generalized LR (or GLR). A Bison GLR parser uses the same basic
+Generalized @acronym{LR} (or @acronym{GLR}). A Bison @acronym{GLR}
+parser uses the same basic
algorithm for parsing as an ordinary Bison parser, but behaves
differently in cases where there is a shift-reduce conflict that has not
been resolved by precedence rules (@pxref{Precedence}) or a
-reduce-reduce conflict. When a GLR parser encounters such a situation, it
+reduce-reduce conflict. When a @acronym{GLR} parser encounters such a
+situation, it
effectively @emph{splits} into a several parsers, one for each possible
shift or reduction. These parsers then proceed as usual, consuming
tokens in lock-step. Some of the stacks may encounter other conflicts
and split further, with the result that instead of a sequence of states,
-a Bison GLR parsing stack is what is in effect a tree of states.
+a Bison @acronym{GLR} parsing stack is what is in effect a tree of states.
In effect, each stack represents a guess as to what the proper parse
is. Additional input may indicate that a guess was wrong, in which case
stream.
Whenever the parser makes a transition from having multiple
-states to having one, it reverts to the normal LALR(1) parsing
+states to having one, it reverts to the normal @acronym{LALR}(1) parsing
algorithm, after resolving and executing the saved-up actions.
At this transition, some of the states on the stack will have semantic
values that are sets (actually multisets) of possible actions. The
Bison resolves and evaluates both and then calls the merge function on
the result. Otherwise, it reports an ambiguity.
-It is possible to use a data structure for the GLR parsing tree that
-permits the processing of any LALR(1) grammar in linear time (in the
-size of the input), any unambiguous (not necessarily LALR(1)) grammar in
+It is possible to use a data structure for the @acronym{GLR} parsing tree that
+permits the processing of any @acronym{LALR}(1) grammar in linear time (in the
+size of the input), any unambiguous (not necessarily
+@acronym{LALR}(1)) grammar in
quadratic worst-case time, and any general (possibly ambiguous)
context-free grammar in cubic worst-case time. However, Bison currently
uses a simpler data structure that requires time proportional to the
behaving examples, however, are not generally of practical interest.
Usually, non-determinism in a grammar is local---the parser is ``in
doubt'' only for a few tokens at a time. Therefore, the current data
-structure should generally be adequate. On LALR(1) portions of a
+structure should generally be adequate. On @acronym{LALR}(1) portions of a
grammar, in particular, it is only slightly slower than with the default
Bison parser.
returns a nonzero value, pausing only to call @code{yyerror} to report
the overflow.
-Becaue Bison parsers have growing stacks, hitting the upper limit
+Because Bison parsers have growing stacks, hitting the upper limit
usually results from using a right recursion instead of a left
recursion, @xref{Recursion, ,Recursive Rules}.
constant integer. The default is 200.
@c FIXME: C++ output.
-Because of semantical differences between C and C++, the LALR(1) parsers
+Because of semantical differences between C and C++, the
+@acronym{LALR}(1) parsers
in C produced by Bison by compiled as C++ cannot grow. In this precise
case (compiling a C parser as C++) you are suggested to grow
@code{YYINITDEPTH}. In the near future, a C++ output output will be
the current input line or current statement if an error is detected:
@example
-stmnt: error ';' /* on error, skip until ';' is read */
+stmnt: error ';' /* On error, skip until ';' is read. */
@end example
It is also useful to recover to the matching close-delimiter of an
name, then this is actually a declaration of @code{x}. How can a Bison
parser for C decide how to parse this input?
-The method used in GNU C is to have two different token types,
+The method used in @acronym{GNU} C is to have two different token types,
@code{IDENTIFIER} and @code{TYPENAME}. When @code{yylex} finds an
identifier, it looks up the current declaration of the identifier in order
to decide which token type to return: @code{TYPENAME} if the identifier is
Bison parsers are @dfn{shift/reduce automata}. In some cases (much more
frequent than one would hope), looking at this automaton is required to
tune or simply fix a parser. Bison provides two different
-representation of it, either textually or graphically (as a @sc{vcg}
+representation of it, either textually or graphically (as a @acronym{VCG}
file).
The textual file is generated when the options @option{--report} or
$accept -> . exp $ (rule 0)
- NUM shift, and go to state 1
+ NUM shift, and go to state 1
- exp go to state 2
+ exp go to state 2
@end example
This reads as follows: ``state 0 corresponds to being at the very
exp -> NUM . (rule 5)
- $default reduce using rule 5 (exp)
+ $default reduce using rule 5 (exp)
@end example
@noindent
exp -> exp . '*' exp (rule 3)
exp -> exp . '/' exp (rule 4)
- $ shift, and go to state 3
- '+' shift, and go to state 4
- '-' shift, and go to state 5
- '*' shift, and go to state 6
- '/' shift, and go to state 7
+ $ shift, and go to state 3
+ '+' shift, and go to state 4
+ '-' shift, and go to state 5
+ '*' shift, and go to state 6
+ '/' shift, and go to state 7
@end example
@noindent
$accept -> exp $ . (rule 0)
- $default accept
+ $default accept
@end example
@noindent
exp -> exp '+' . exp (rule 1)
- NUM shift, and go to state 1
+ NUM shift, and go to state 1
- exp go to state 8
+ exp go to state 8
state 5
exp -> exp '-' . exp (rule 2)
- NUM shift, and go to state 1
+ NUM shift, and go to state 1
- exp go to state 9
+ exp go to state 9
state 6
exp -> exp '*' . exp (rule 3)
- NUM shift, and go to state 1
+ NUM shift, and go to state 1
- exp go to state 10
+ exp go to state 10
state 7
exp -> exp '/' . exp (rule 4)
- NUM shift, and go to state 1
+ NUM shift, and go to state 1
- exp go to state 11
+ exp go to state 11
@end example
As was announced in beginning of the report, @samp{State 8 contains 1
exp -> exp . '*' exp (rule 3)
exp -> exp . '/' exp (rule 4)
- '*' shift, and go to state 6
- '/' shift, and go to state 7
+ '*' shift, and go to state 6
+ '/' shift, and go to state 7
- '/' [reduce using rule 1 (exp)]
- $default reduce using rule 1 (exp)
+ '/' [reduce using rule 1 (exp)]
+ $default reduce using rule 1 (exp)
@end example
Indeed, there are two actions associated to the lookahead @samp{/}:
NUM)}, which corresponds to shifting @samp{/}, or as @samp{(NUM + NUM) /
NUM}, which corresponds to reducing rule 1.
-Because in LALR(1) parsing a single decision can be made, Bison
+Because in @acronym{LALR}(1) parsing a single decision can be made, Bison
arbitrarily chose to disable the reduction, see @ref{Shift/Reduce, ,
Shift/Reduce Conflicts}. Discarded actions are reported in between
square brackets.
exp -> exp . '*' exp (rule 3)
exp -> exp . '/' exp (rule 4)
- '*' shift, and go to state 6
- '/' shift, and go to state 7
+ '*' shift, and go to state 6
+ '/' shift, and go to state 7
- '/' [reduce using rule 2 (exp)]
- $default reduce using rule 2 (exp)
+ '/' [reduce using rule 2 (exp)]
+ $default reduce using rule 2 (exp)
state 10
exp -> exp '*' exp . (rule 3)
exp -> exp . '/' exp (rule 4)
- '/' shift, and go to state 7
+ '/' shift, and go to state 7
- '/' [reduce using rule 3 (exp)]
- $default reduce using rule 3 (exp)
+ '/' [reduce using rule 3 (exp)]
+ $default reduce using rule 3 (exp)
state 11
exp -> exp . '/' exp (rule 4)
exp -> exp '/' exp . (rule 4)
- '+' shift, and go to state 4
- '-' shift, and go to state 5
- '*' shift, and go to state 6
- '/' shift, and go to state 7
+ '+' shift, and go to state 4
+ '-' shift, and go to state 5
+ '*' shift, and go to state 6
+ '/' shift, and go to state 7
- '+' [reduce using rule 4 (exp)]
- '-' [reduce using rule 4 (exp)]
- '*' [reduce using rule 4 (exp)]
- '/' [reduce using rule 4 (exp)]
- $default reduce using rule 4 (exp)
+ '+' [reduce using rule 4 (exp)]
+ '-' [reduce using rule 4 (exp)]
+ '*' [reduce using rule 4 (exp)]
+ '/' [reduce using rule 4 (exp)]
+ $default reduce using rule 4 (exp)
@end example
@noindent
@item the macro @code{YYDEBUG}
@findex YYDEBUG
Define the macro @code{YYDEBUG} to a nonzero value when you compile the
-parser. This is compliant with POSIX Yacc. You could use
+parser. This is compliant with @acronym{POSIX} Yacc. You could use
@samp{-DYYDEBUG=1} as a compiler option or you could put @samp{#define
YYDEBUG 1} in the prologue of the grammar file (@pxref{Prologue, , The
Prologue}).
@item the option @option{-t}, @option{--debug}
Use the @samp{-t} option when you run Bison (@pxref{Invocation,
-,Invoking Bison}). This is POSIX compliant too.
+,Invoking Bison}). This is @acronym{POSIX} compliant too.
@item the directive @samp{%debug}
@findex %debug
Add the @code{%debug} directive (@pxref{Decl Summary, ,Bison
Declaration Summary}). This is a Bison extension, which will prove
useful when Bison will output parsers for languages that don't use a
-preprocessor. Useless POSIX and Yacc portability matter to you, this is
+preprocessor. Unless @acronym{POSIX} and Yacc portability matter to
+you, this is
the preferred solution.
@end table
@samp{.y}. The parser file's name is made by replacing the @samp{.y}
with @samp{.tab.c}. Thus, the @samp{bison foo.y} filename yields
@file{foo.tab.c}, and the @samp{bison hack/foo.y} filename yields
-@file{hack/foo.tab.c}. It's is also possible, in case you are writing
+@file{hack/foo.tab.c}. It's also possible, in case you are writing
C++ code instead of C in your grammar file, to name it @file{foo.ypp}
-or @file{foo.y++}. Then, the output files will take an extention like
-the given one as input (repectively @file{foo.tab.cpp} and @file{foo.tab.c++}).
+or @file{foo.y++}. Then, the output files will take an extension like
+the given one as input (respectively @file{foo.tab.cpp} and
+@file{foo.tab.c++}).
This feature takes effect with all options that manipulate filenames like
@samp{-o} or @samp{-d}.
bison -d @var{infile.yxx}
@end example
@noindent
-will produce @file{infile.tab.cxx} and @file{infile.tab.hxx}. and
+will produce @file{infile.tab.cxx} and @file{infile.tab.hxx}, and
@example
-bison -d @var{infile.y} -o @var{output.c++}
+bison -d -o @var{output.c++} @var{infile.y}
@end example
@noindent
will produce @file{output.c++} and @file{outfile.h++}.
@menu
* Bison Options:: All the options described in detail,
- in alphabetical order by short options.
+ in alphabetical order by short options.
* Option Cross Key:: Alphabetical list of long options.
-* VMS Invocation:: Bison command syntax on VMS.
+* VMS Invocation:: Bison command syntax on @acronym{VMS}.
@end menu
@node Bison Options
@item -b @var{file-prefix}
@itemx --file-prefix=@var{prefix}
Pretend that @code{%verbose} was specified, i.e, specify prefix to use
-for all Bison output file names. @xref{Decl Summary}.
+for all Bison output file names. @xref{Decl Summary}.
@item -r @var{things}
@itemx --report=@var{things}
@table @code
@item state
Description of the grammar, conflicts (resolved and unresolved), and
-LALR automaton.
+@acronym{LALR} automaton.
@item lookahead
Implies @code{state} and augments the description of the automaton with
@itemx --verbose
Pretend that @code{%verbose} was specified, i.e, write an extra output
file containing verbose descriptions of the grammar and
-parser. @xref{Decl Summary}.
+parser. @xref{Decl Summary}.
@item -o @var{filename}
@itemx --output=@var{filename}
described under the @samp{-v} and @samp{-d} options.
@item -g
-Output a VCG definition of the LALR(1) grammar automaton computed by
-Bison. If the grammar file is @file{foo.y}, the VCG output file will
+Output a @acronym{VCG} definition of the @acronym{LALR}(1) grammar
+automaton computed by Bison. If the grammar file is @file{foo.y}, the
+@acronym{VCG} output file will
be @file{foo.vcg}.
@item --graph=@var{graph-file}
-The behaviour of @var{--graph} is the same than @samp{-g}. The only
-difference is that it has an optionnal argument which is the name of
+The behavior of @var{--graph} is the same than @samp{-g}. The only
+difference is that it has an optional argument which is the name of
the output graph filename.
@end table
@end ifinfo
@node VMS Invocation
-@section Invoking Bison under VMS
-@cindex invoking Bison under VMS
-@cindex VMS
+@section Invoking Bison under @acronym{VMS}
+@cindex invoking Bison under @acronym{VMS}
+@cindex @acronym{VMS}
-The command line syntax for Bison on VMS is a variant of the usual
-Bison command syntax---adapted to fit VMS conventions.
+The command line syntax for Bison on @acronym{VMS} is a variant of the usual
+Bison command syntax---adapted to fit @acronym{VMS} conventions.
-To find the VMS equivalent for any Bison option, start with the long
+To find the @acronym{VMS} equivalent for any Bison option, start with the long
option, and substitute a @samp{/} for the leading @samp{--}, and
substitute a @samp{_} for each @samp{-} in the name of the long option.
-For example, the following invocation under VMS:
+For example, the following invocation under @acronym{VMS}:
@example
bison /debug/name_prefix=bar foo.y
@end example
@noindent
-is equivalent to the following command under POSIX.
+is equivalent to the following command under @acronym{POSIX}.
@example
bison --debug --name-prefix=bar foo.y
@end example
-The VMS file system does not permit filenames such as
+The @acronym{VMS} file system does not permit filenames such as
@file{foo.tab.c}. In the above example, the output file
would instead be named @file{foo_tab.c}.
token. @xref{Action Features, ,Special Features for Use in Actions}.
@item YYDEBUG
-Macro to define to equip the parser with tracing code. @xref{Tracing,
+Macro to define to equip the parser with tracing code. @xref{Tracing,
,Tracing Your Parser}.
@item YYERROR
@code{yyparse} return 1. @xref{Error Recovery}.
@item YYERROR_VERBOSE
-Macro that you define with @code{#define} in the Bison declarations
-section to request verbose, specific error message strings when
-@code{yyerror} is called.
+An obsolete macro that you define with @code{#define} in the Bison
+declarations section to request verbose, specific error message strings
+when @code{yyerror} is called. It doesn't matter what definition you
+use for @code{YYERROR_VERBOSE}, just whether you define it. Using
+@code{%error-verbose} is preferred.
@item YYINITDEPTH
Macro for specifying the initial size of the parser stack.
@xref{Stack Overflow}.
@item YYLEX_PARAM
-Macro for specifying an extra argument (or list of extra arguments) for
-@code{yyparse} to pass to @code{yylex}. @xref{Pure Calling,, Calling
-Conventions for Pure Parsers}.
+An obsolete macro for specifying an extra argument (or list of extra
+arguments) for @code{yyparse} to pass to @code{yylex}. he use of this
+macro is deprecated, and is supported only for Yacc like parsers.
+@xref{Pure Calling,, Calling Conventions for Pure Parsers}.
@item YYLTYPE
Macro for the data type of @code{yylloc}; a structure with four
@xref{Stack Overflow}.
@item YYPARSE_PARAM
-Macro for specifying the name of a parameter that @code{yyparse} should
-accept. @xref{Pure Calling,, Calling Conventions for Pure Parsers}.
+An obsolete macro for specifying the name of a parameter that
+@code{yyparse} should accept. The use of this macro is deprecated, and
+is supported only for Yacc like parsers. @xref{Pure Calling,, Calling
+Conventions for Pure Parsers}.
@item YYRECOVERING
Macro whose value indicates whether the parser is recovering from a
syntax error. @xref{Action Features, ,Special Features for Use in Actions}.
@item YYSTACK_USE_ALLOCA
-Macro used to control the use of @code{alloca}. If defined to @samp{0},
+Macro used to control the use of @code{alloca}. If defined to @samp{0},
the parser will not use @code{alloca} but @code{malloc} when trying to
-grow its internal stacks. Do @emph{not} define @code{YYSTACK_USE_ALLOCA}
+grow its internal stacks. Do @emph{not} define @code{YYSTACK_USE_ALLOCA}
to anything else.
@item YYSTYPE
@item %dprec
Bison declaration to assign a precedence to a rule that is used at parse
-time to resolve reduce/reduce conflicts. @xref{GLR Parsers}.
+time to resolve reduce/reduce conflicts. @xref{GLR Parsers, ,Writing
+@acronym{GLR} Parsers}.
+
+@item %error-verbose
+Bison declaration to request verbose, specific error message strings
+when @code{yyerror} is called.
@item %file-prefix="@var{prefix}"
-Bison declaration to set the prefix of the output files. @xref{Decl
+Bison declaration to set the prefix of the output files. @xref{Decl
Summary}.
@item %glr-parser
-Bison declaration to produce a GLR parser. @xref{GLR Parsers}.
+Bison declaration to produce a @acronym{GLR} parser. @xref{GLR
+Parsers, ,Writing @acronym{GLR} Parsers}.
@c @item %source-extension
@c Bison declaration to specify the generated parser output file extension.
@c
@c @item %header-extension
@c Bison declaration to specify the generated parser header file extension
-@c if required. @xref{Decl Summary}.
+@c if required. @xref{Decl Summary}.
@item %left
Bison declaration to assign left associativity to token(s).
@xref{Precedence Decl, ,Operator Precedence}.
+@item %lex-param "@var{argument-declaration}" "@var{argument-name}"
+Bison declaration to specifying an additional parameter that
+@code{yylex} should accept. @xref{Pure Calling,, Calling Conventions
+for Pure Parsers}.
+
@item %merge
Bison declaration to assign a merging function to a rule. If there is a
reduce/reduce conflict with a rule having the same merging function, the
function is applied to the two semantic values to get a single result.
-@xref{GLR Parsers}.
+@xref{GLR Parsers, ,Writing @acronym{GLR} Parsers}.
@item %name-prefix="@var{prefix}"
-Bison declaration to rename the external symbols. @xref{Decl Summary}.
+Bison declaration to rename the external symbols. @xref{Decl Summary}.
@item %no-lines
Bison declaration to avoid generating @code{#line} directives in the
@xref{Precedence Decl, ,Operator Precedence}.
@item %output="@var{filename}"
-Bison declaration to set the name of the parser file. @xref{Decl
+Bison declaration to set the name of the parser file. @xref{Decl
Summary}.
+@item %parse-param "@var{argument-declaration}" "@var{argument-name}"
+Bison declaration to specifying an additional parameter that
+@code{yyparse} should accept. @xref{Parser Function,, The Parser
+Function @code{yyparse}}.
+
@item %prec
Bison declaration to assign a precedence to a specific rule.
@xref{Contextual Precedence, ,Context-Dependent Precedence}.
@cindex glossary
@table @asis
-@item Backus-Naur Form (BNF)
-Formal method of specifying context-free grammars. BNF was first used
-in the @cite{ALGOL-60} report, 1963. @xref{Language and Grammar,
-,Languages and Context-Free Grammars}.
+@item Backus-Naur Form (@acronym{BNF}; also called ``Backus Normal Form'')
+Formal method of specifying context-free grammars originally proposed
+by John Backus, and slightly improved by Peter Naur in his 1960-01-02
+committee document contributing to what became the Algol 60 report.
+@xref{Language and Grammar, ,Languages and Context-Free Grammars}.
@item Context-free grammars
Grammars specified as rules that can be applied regardless of context.
machine moves from state to state as specified by the logic of the
machine. In the case of the parser, the input is the language being
parsed, and the states correspond to various stages in the grammar
-rules. @xref{Algorithm, ,The Bison Parser Algorithm }.
+rules. @xref{Algorithm, ,The Bison Parser Algorithm}.
-@item Generalized LR (GLR)
+@item Generalized @acronym{LR} (@acronym{GLR})
A parsing algorithm that can handle all context-free grammars, including those
-that are not LALR(1). It resolves situations that Bison's usual LALR(1)
+that are not @acronym{LALR}(1). It resolves situations that Bison's
+usual @acronym{LALR}(1)
algorithm cannot by effectively splitting off multiple parsers, trying all
possible parsers, and discarding those that fail in the light of additional
-right context. @xref{Generalized LR Parsing, ,Generalized LR Parsing}.
+right context. @xref{Generalized LR Parsing, ,Generalized
+@acronym{LR} Parsing}.
@item Grouping
A language construct that is (in general) grammatically divisible;
-for example, `expression' or `declaration' in C.
+for example, `expression' or `declaration' in C@.
@xref{Language and Grammar, ,Languages and Context-Free Grammars}.
@item Infix operator
@item Left-to-right parsing
Parsing a sentence of a language by analyzing it token by token from
-left to right. @xref{Algorithm, ,The Bison Parser Algorithm }.
+left to right. @xref{Algorithm, ,The Bison Parser Algorithm}.
@item Lexical analyzer (scanner)
A function that reads an input stream and returns tokens one by one.
A token already read but not yet shifted. @xref{Look-Ahead, ,Look-Ahead
Tokens}.
-@item LALR(1)
+@item @acronym{LALR}(1)
The class of context-free grammars that Bison (like most other parser
-generators) can handle; a subset of LR(1). @xref{Mystery Conflicts, ,
-Mysterious Reduce/Reduce Conflicts}.
+generators) can handle; a subset of @acronym{LR}(1). @xref{Mystery
+Conflicts, ,Mysterious Reduce/Reduce Conflicts}.
-@item LR(1)
+@item @acronym{LR}(1)
The class of context-free grammars in which at most one token of
look-ahead is needed to disambiguate the parsing of any piece of input.
@item Reduction
Replacing a string of nonterminals and/or terminals with a single
nonterminal, according to a grammar rule. @xref{Algorithm, ,The Bison
-Parser Algorithm }.
+Parser Algorithm}.
@item Reentrant
A reentrant subprogram is a subprogram which can be in invoked any
@item Shift
A parser is said to shift when it makes the choice of analyzing
further input from the stream rather than reducing immediately some
-already-recognized rule. @xref{Algorithm, ,The Bison Parser Algorithm }.
+already-recognized rule. @xref{Algorithm, ,The Bison Parser Algorithm}.
@item Single-character literal
A single character that is recognized and interpreted as is.
projects / bison.git / blobdiff