* NEWS: The -g and --graph options now output graphs in Graphviz

[bison.git] / doc / bison.texinfo

diff --git a/doc/bison.texinfo b/doc/bison.texinfo
index 4b61b4012912f05e069bc6faacd2e67bfd1a4b80..576a2746e1fbf32bfb57f14c831a9006ca636fed 100644 (file)
--- a/doc/bison.texinfo
+++ b/doc/bison.texinfo
@@ -248,7 +248,7 @@ The Lexical Analyzer Function @code{yylex}
 
 The Bison Parser Algorithm
 
 
 The Bison Parser Algorithm
 

-* Look-Ahead::        Parser looks one token ahead when deciding what to do.
+* Lookahead::         Parser looks one token ahead when deciding what to do.

 * Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
 * Precedence::        Operator precedence works by resolving conflicts.
 * Contextual Precedence::  When an operator's precedence depends on context.
 * Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
 * Precedence::        Operator precedence works by resolving conflicts.
 * Contextual Precedence::  When an operator's precedence depends on context.


@@ -331,9 +331,9 @@ Copying This Manual
 @unnumbered Introduction
 @cindex introduction
 
 @unnumbered Introduction
 @cindex introduction
 

-@dfn{Bison} is a general-purpose parser generator that converts a grammar
-description for an @acronym{LALR}(1) or @acronym{GLR} context-free grammar
-into a C or C++ program to parse that grammar.  Once you are proficient with
+@dfn{Bison} is a general-purpose parser generator that converts an
+annotated context-free grammar into an @acronym{LALR}(1) or
+@acronym{GLR} parser for that grammar.  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, you can use it to develop a wide range of language parsers, from those
 used in simple desk calculators to complex programming languages.
 


@@ -445,7 +445,7 @@ can handle almost all context-free grammars, Bison is optimized for what
 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
 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
+token of lookahead.  Strictly speaking, that is a description of an

 @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
 @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


@@ -461,11 +461,11 @@ more information on this.
 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
 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.  A context-free
+(called a @dfn{lookahead}) of the remaining input.  A context-free

 grammar can be @dfn{ambiguous}, meaning that there are multiple ways to
 apply the grammar rules to get the same inputs.  Even unambiguous
 grammars can be @dfn{nondeterministic}, meaning that no fixed
 grammar can be @dfn{ambiguous}, meaning that there are multiple ways to
 apply the grammar rules to get the same inputs.  Even unambiguous
 grammars can be @dfn{nondeterministic}, meaning that no fixed

-look-ahead always suffices to determine the next grammar rule to apply.
+lookahead 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 @acronym{GLR}
 parsing (for Generalized @acronym{LR}).  Bison's @acronym{GLR} parsers
 With the proper declarations, Bison is also able to parse these more
 general context-free grammars, using a technique known as @acronym{GLR}
 parsing (for Generalized @acronym{LR}).  Bison's @acronym{GLR} parsers


@@ -746,7 +746,7 @@ merged result.
 
 In the simplest cases, you can use the @acronym{GLR} algorithm
 to parse grammars that are unambiguous, but fail to be @acronym{LALR}(1).
 
 In the simplest cases, you can use the @acronym{GLR} algorithm
 to parse grammars that are unambiguous, but fail to be @acronym{LALR}(1).

-Such grammars typically require more than one symbol of look-ahead,
+Such grammars typically require more than one symbol of lookahead,

 or (in rare cases) fall into the category of grammars in which the
 @acronym{LALR}(1) algorithm throws away too much information (they are in
 @acronym{LR}(1), but not @acronym{LALR}(1), @ref{Mystery Conflicts}).
 or (in rare cases) fall into the category of grammars in which the
 @acronym{LALR}(1) algorithm throws away too much information (they are in
 @acronym{LR}(1), but not @acronym{LALR}(1), @ref{Mystery Conflicts}).


@@ -786,7 +786,7 @@ type enum = (a);
 valid, and more-complicated cases can come up in practical programs.)
 
 These two declarations look identical until the @samp{..} token.
 valid, and more-complicated cases can come up in practical programs.)
 
 These two declarations look identical until the @samp{..} token.

-With normal @acronym{LALR}(1) one-token look-ahead it is not
+With normal @acronym{LALR}(1) one-token lookahead it is not

 possible to decide between the two forms when the identifier
 @samp{a} is parsed.  It is, however, desirable
 for a parser to decide this, since in the latter case
 possible to decide between the two forms when the identifier
 @samp{a} is parsed.  It is, however, desirable
 for a parser to decide this, since in the latter case


@@ -825,7 +825,7 @@ reports a syntax error as usual.
 
 The effect of all this is that the parser seems to ``guess'' the
 correct branch to take, or in other words, it seems to use more
 
 The effect of all this is that the parser seems to ``guess'' the
 correct branch to take, or in other words, it seems to use more

-look-ahead than the underlying @acronym{LALR}(1) algorithm actually allows
+lookahead than the underlying @acronym{LALR}(1) algorithm actually allows

 for.  In this example, @acronym{LALR}(2) would suffice, but also some cases
 that are not @acronym{LALR}(@math{k}) for any @math{k} can be handled this way.
 
 for.  In this example, @acronym{LALR}(2) would suffice, but also some cases
 that are not @acronym{LALR}(@math{k}) for any @math{k} can be handled this way.
 


@@ -1106,13 +1106,13 @@ action in a @acronym{GLR} parser.
 @vindex yylloc
 @cindex @acronym{GLR} parsers and @code{yylloc}
 In any semantic action, you can examine @code{yychar} to determine the type of
 @vindex yylloc
 @cindex @acronym{GLR} parsers and @code{yylloc}
 In any semantic action, you can examine @code{yychar} to determine the type of

-the look-ahead token present at the time of the associated reduction.
+the lookahead token present at the time of the associated reduction.

 After checking that @code{yychar} is not set to @code{YYEMPTY} or @code{YYEOF},
 you can then examine @code{yylval} and @code{yylloc} to determine the
 After checking that @code{yychar} is not set to @code{YYEMPTY} or @code{YYEOF},
 you can then examine @code{yylval} and @code{yylloc} to determine the

-look-ahead token's semantic value and location, if any.
+lookahead token's semantic value and location, if any.

 In a nondeferred semantic action, you can also modify any of these variables to
 influence syntax analysis.
 In a nondeferred semantic action, you can also modify any of these variables to
 influence syntax analysis.

-@xref{Look-Ahead, ,Look-Ahead Tokens}.
+@xref{Lookahead, ,Lookahead Tokens}.

 
 @findex yyclearin
 @cindex @acronym{GLR} parsers and @code{yyclearin}
 
 @findex yyclearin
 @cindex @acronym{GLR} parsers and @code{yyclearin}


@@ -1998,7 +1998,9 @@ type for storing locations is not needed: we will use the type provided
 by default (@pxref{Location Type, ,Data Types of Locations}), which is a
 four member structure with the following integer fields:
 @code{first_line}, @code{first_column}, @code{last_line} and
 by default (@pxref{Location Type, ,Data Types of Locations}), which is a
 four member structure with the following integer fields:
 @code{first_line}, @code{first_column}, @code{last_line} and

-@code{last_column}.
+@code{last_column}.  By conventions, and in accordance with the GNU
+Coding Standards and common practice, the line and column count both
+start at 1.

 
 @node Ltcalc Rules
 @subsection Grammar Rules for @code{ltcalc}
 
 @node Ltcalc Rules
 @subsection Grammar Rules for @code{ltcalc}


@@ -2633,7 +2635,7 @@ they precede the definition of @code{yyparse}.  You can use
 don't need any C declarations, you may omit the @samp{%@{} and
 @samp{%@}} delimiters that bracket this section.
 
 don't need any C declarations, you may omit the @samp{%@{} and
 @samp{%@}} delimiters that bracket this section.
 

-The @var{Prologue} section is terminated by the the first occurrence
+The @var{Prologue} section is terminated by the first occurrence

 of @samp{%@}} that is outside a comment, a string literal, or a
 character constant.
 
 of @samp{%@}} that is outside a comment, a string literal, or a
 character constant.
 


@@ -2647,6 +2649,7 @@ can be done with two @var{Prologue} blocks, one before and one after the
 
 @smallexample
 %@{
 
 @smallexample
 %@{

+  #define _GNU_SOURCE

   #include <stdio.h>
   #include "ptypes.h"
 %@}
   #include <stdio.h>
   #include "ptypes.h"
 %@}


@@ -2664,6 +2667,44 @@ can be done with two @var{Prologue} blocks, one before and one after the
 @dots{}
 @end smallexample
 
 @dots{}
 @end smallexample
 

+When in doubt, it is usually safer to put prologue code before all
+Bison declarations, rather than after.  For example, any definitions
+of feature test macros like @code{_GNU_SOURCE} or
+@code{_POSIX_C_SOURCE} should appear before all Bison declarations, as
+feature test macros can affect the behavior of Bison-generated
+@code{#include} directives.
+
+@findex %before-header
+@findex %start-header
+@findex %after-header
+If you've instructed Bison to generate a header file (@pxref{Table of Symbols,
+,%defines}), you probably want @code{#include "ptypes.h"} to appear
+in that header file as well.
+In that case, use @code{%before-header}, @code{%start-header}, and
+@code{%after-header} instead of @var{Prologue} sections
+(@pxref{Table of Symbols, ,%start-header}):
+
+@smallexample
+%before-header @{
+  #include <stdio.h>
+@}
+
+%start-header @{
+  #include "ptypes.h"
+@}
+%union @{
+  long int n;
+  tree t;  /* @r{@code{tree} is defined in @file{ptypes.h}.} */
+@}
+
+%after-header @{
+  static void print_token_value (FILE *, int, YYSTYPE);
+  #define YYPRINT(F, N, L) print_token_value (F, N, L)
+@}
+
+@dots{}
+@end smallexample
+

 @node Bison Declarations
 @subsection The Bison Declarations Section
 @cindex Bison declarations (introduction)
 @node Bison Declarations
 @subsection The Bison Declarations Section
 @cindex Bison declarations (introduction)


@@ -3059,7 +3100,8 @@ the semantic values of all language constructs.  This was true in the
 @acronym{RPN} and infix calculator examples (@pxref{RPN Calc, ,Reverse Polish
 Notation Calculator}).
 
 @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
+Bison normally uses the type @code{int} for semantic values if your
+program uses the same data type for all language constructs.  To

 specify some other type, define @code{YYSTYPE} as a macro, like this:
 
 @example
 specify some other type, define @code{YYSTYPE} as a macro, like this:
 
 @example


@@ -3067,6 +3109,8 @@ specify some other type, define @code{YYSTYPE} as a macro, like this:
 @end example
 
 @noindent
 @end example
 
 @noindent

+@code{YYSTYPE}'s replacement list should be a type name
+that does not contain parentheses or square brackets.

 This macro definition must go in the prologue of the grammar file
 (@pxref{Grammar Outline, ,Outline of a Bison Grammar}).
 
 This macro definition must go in the prologue of the grammar file
 (@pxref{Grammar Outline, ,Outline of a Bison Grammar}).
 


@@ -3084,9 +3128,11 @@ requires you to do two things:
 
 @itemize @bullet
 @item
 
 @itemize @bullet
 @item

-Specify the entire collection of possible data types, with the
+Specify the entire collection of possible data types, either by using the

 @code{%union} Bison declaration (@pxref{Union Decl, ,The Collection of
 @code{%union} Bison declaration (@pxref{Union Decl, ,The Collection of

-Value Types}).
+Value Types}), or by using a @code{typedef} or a @code{#define} to
+define @code{YYSTYPE} to be a union type whose member names are
+the type tags.

 
 @item
 Choose one of those types for each symbol (terminal or nonterminal) for
 
 @item
 Choose one of those types for each symbol (terminal or nonterminal) for


@@ -3187,7 +3233,7 @@ always refers to the @code{expr} which precedes @code{bar} in the
 definition of @code{foo}.
 
 @vindex yylval
 definition of @code{foo}.
 
 @vindex yylval

-It is also possible to access the semantic value of the look-ahead token, if
+It is also possible to access the semantic value of the lookahead token, if

 any, from a semantic action.
 This semantic value is stored in @code{yylval}.
 @xref{Action Features, ,Special Features for Use in Actions}.
 any, from a semantic action.
 This semantic value is stored in @code{yylval}.
 @xref{Action Features, ,Special Features for Use in Actions}.


@@ -3310,8 +3356,8 @@ it might discard the previous semantic context @code{$<context>5} without
 restoring it.
 Thus, @code{$<context>5} needs a destructor (@pxref{Destructor Decl, , Freeing
 Discarded Symbols}).
 restoring it.
 Thus, @code{$<context>5} needs a destructor (@pxref{Destructor Decl, , Freeing
 Discarded Symbols}).

-However, Bison currently provides no means to declare a destructor for a
-mid-rule action's semantic value.
+However, Bison currently provides no means to declare a destructor specific to
+a particular mid-rule action's semantic value.

 
 One solution is to bury the mid-rule action inside a nonterminal symbol and to
 declare a destructor for that symbol:
 
 One solution is to bury the mid-rule action inside a nonterminal symbol and to
 declare a destructor for that symbol:


@@ -3375,8 +3421,8 @@ Now the parser is forced to decide whether to run the mid-rule action
 when it has read no farther than the open-brace.  In other words, it
 must commit to using one rule or the other, without sufficient
 information to do it correctly.  (The open-brace token is what is called
 when it has read no farther than the open-brace.  In other words, it
 must commit to using one rule or the other, without sufficient
 information to do it correctly.  (The open-brace token is what is called

-the @dfn{look-ahead} token at this time, since the parser is still
-deciding what to do about it.  @xref{Look-Ahead, ,Look-Ahead Tokens}.)
+the @dfn{lookahead} token at this time, since the parser is still
+deciding what to do about it.  @xref{Lookahead, ,Lookahead Tokens}.)

 
 You might think that you could correct the problem by putting identical
 actions into the two rules, like this:
 
 You might think that you could correct the problem by putting identical
 actions into the two rules, like this:


@@ -3463,7 +3509,9 @@ actions to take when rules are matched.
 Defining a data type for locations is much simpler than for semantic values,
 since all tokens and groupings always use the same type.
 
 Defining a data type for locations is much simpler than for semantic values,
 since all tokens and groupings always use the same type.
 

-The type of locations is specified by defining a macro called @code{YYLTYPE}.
+You can specify the type of locations by defining a macro called
+@code{YYLTYPE}, just as you can specify the semantic value type by
+defining a @code{YYSTYPE} macro (@pxref{Value Type}).

 When @code{YYLTYPE} is not defined, Bison uses a default structure type with
 four members:
 
 When @code{YYLTYPE} is not defined, Bison uses a default structure type with
 four members:
 


@@ -3477,6 +3525,9 @@ typedef struct YYLTYPE
 @} YYLTYPE;
 @end example
 
 @} YYLTYPE;
 @end example
 

+At the beginning of the parsing, Bison initializes all these fields to 1
+for @code{yylloc}.
+

 @node Actions and Locations
 @subsection Actions and Locations
 @cindex location actions
 @node Actions and Locations
 @subsection Actions and Locations
 @cindex location actions


@@ -3547,7 +3598,7 @@ exp:    @dots{}
 @end example
 
 @vindex yylloc
 @end example
 
 @vindex yylloc

-It is also possible to access the location of the look-ahead token, if any,
+It is also possible to access the location of the lookahead token, if any,

 from a semantic action.
 This location is stored in @code{yylloc}.
 @xref{Action Features, ,Special Features for Use in Actions}.
 from a semantic action.
 This location is stored in @code{yylloc}.
 @xref{Action Features, ,Special Features for Use in Actions}.


@@ -3855,6 +3906,35 @@ only the first @code{%union} declaration can specify a tag.
 Note that, unlike making a @code{union} declaration in C, you need not write
 a semicolon after the closing brace.
 
 Note that, unlike making a @code{union} declaration in C, you need not write
 a semicolon after the closing brace.
 

+Instead of @code{%union}, you can define and use your own union type
+@code{YYSTYPE} if your grammar contains at least one
+@samp{<@var{type}>} tag.  For example, you can put the following into
+a header file @file{parser.h}:
+
+@example
+@group
+union YYSTYPE @{
+  double val;
+  symrec *tptr;
+@};
+typedef union YYSTYPE YYSTYPE;
+@end group
+@end example
+
+@noindent
+and then your grammar can use the following
+instead of @code{%union}:
+
+@example
+@group
+%@{
+#include "parser.h"
+%@}
+%type <val> expr
+%token <tptr> ID
+@end group
+@end example
+

 @node Type Decl
 @subsection Nonterminal Symbols
 @cindex declaring value types, nonterminals
 @node Type Decl
 @subsection Nonterminal Symbols
 @cindex declaring value types, nonterminals


@@ -3895,7 +3975,7 @@ code.
 @findex %initial-action
 Declare that the braced @var{code} must be invoked before parsing each time
 @code{yyparse} is called.  The @var{code} may use @code{$$} and
 @findex %initial-action
 Declare that the braced @var{code} must be invoked before parsing each time
 @code{yyparse} is called.  The @var{code} may use @code{$$} and

-@code{@@$} --- initial value and location of the look-ahead --- and the
+@code{@@$} --- initial value and location of the lookahead --- and the

 @code{%parse-param}.
 @end deffn
 
 @code{%parse-param}.
 @end deffn
 


@@ -3914,6 +3994,7 @@ For instance, if your locations use a file name, you may use
 @subsection Freeing Discarded Symbols
 @cindex freeing discarded symbols
 @findex %destructor
 @subsection Freeing Discarded Symbols
 @cindex freeing discarded symbols
 @findex %destructor

+@findex %symbol-default

 
 During error recovery (@pxref{Error Recovery}), symbols already pushed
 on the stack and tokens coming from the rest of the file are discarded
 
 During error recovery (@pxref{Error Recovery}), symbols already pushed
 on the stack and tokens coming from the rest of the file are discarded


@@ -3935,26 +4016,73 @@ symbol is automatically discarded.
 Invoke the braced @var{code} whenever the parser discards one of the
 @var{symbols}.
 Within @var{code}, @code{$$} designates the semantic value associated
 Invoke the braced @var{code} whenever the parser discards one of the
 @var{symbols}.
 Within @var{code}, @code{$$} designates the semantic value associated

-with the discarded symbol.  The additional parser parameters are also
-available (@pxref{Parser Function, , The Parser Function
-@code{yyparse}}).
+with the discarded symbol, and @code{@@$} designates its location.
+The additional parser parameters are also available (@pxref{Parser Function, ,
+The Parser Function @code{yyparse}}).
+
+When a symbol is listed among @var{symbols}, its @code{%destructor} is called a
+per-symbol @code{%destructor}.
+You may also define a per-type @code{%destructor} by listing a semantic type
+among @var{symbols}.
+In that case, the parser will invoke this @var{code} whenever it discards any
+grammar symbol that has that semantic type unless that symbol has its own
+per-symbol @code{%destructor}.
+
+Finally, you may define a default @code{%destructor} by placing
+@code{%symbol-default} in the @var{symbols} list of exactly one
+@code{%destructor} declaration in your grammar file.
+In that case, the parser will invoke the associated @var{code} whenever it
+discards any user-defined grammar symbol for which there is no per-type or
+per-symbol @code{%destructor}.

 @end deffn
 
 @end deffn
 

+@noindent

 For instance:
 
 @smallexample
 For instance:
 
 @smallexample

-%union
-@{
-  char *string;
-@}
-%token <string> STRING
-%type  <string> string
-%destructor @{ free ($$); @} STRING string
+%union @{ char *string; @}
+%token <string> STRING1
+%token <string> STRING2
+%type  <string> string1
+%type  <string> string2
+%union @{ char character; @}
+%token <character> CHR
+%type  <character> chr
+%destructor @{ free ($$); @} %symbol-default
+%destructor @{ free ($$); printf ("%d", @@$.first_line); @} STRING1 string1
+%destructor @{ @} <character>

 @end smallexample
 
 @noindent
 @end smallexample
 
 @noindent

-guarantees that when a @code{STRING} or a @code{string} is discarded,
-its associated memory will be freed.
+guarantees that, when the parser discards any user-defined symbol that has a
+semantic type tag other than @code{<character>}, it passes its semantic value
+to @code{free}.
+However, when the parser discards a @code{STRING1} or a @code{string1}, it also
+prints its line number to @code{stdout}.
+It performs only the second @code{%destructor} in this case, so it invokes
+@code{free} only once.
+
+Notice that a Bison-generated parser invokes the default @code{%destructor}
+only for user-defined as opposed to Bison-defined symbols.
+For example, the parser will not invoke it for the special Bison-defined
+symbols @code{$accept}, @code{$undefined}, or @code{$end} (@pxref{Table of
+Symbols, ,Bison Symbols}), none of which you can reference in your grammar.
+It also will not invoke it for the @code{error} token (@pxref{Table of Symbols,
+,error}), which is always defined by Bison regardless of whether you reference
+it in your grammar.
+However, it will invoke it for the end token (token 0) if you redefine it from
+@code{$end} to, for example, @code{END}:
+
+@smallexample
+%token END 0
+@end smallexample
+
+@ignore
+@noindent
+In the future, it may be possible to redefine the @code{error} token as a
+nonterminal that captures the discarded symbols.
+In that case, the parser will invoke the default destructor for it as well.
+@end ignore

 
 @sp 1
 
 
 @sp 1
 


@@ -3967,7 +4095,7 @@ stacked symbols popped during the first phase of error recovery,
 @item
 incoming terminals during the second phase of error recovery,
 @item
 @item
 incoming terminals during the second phase of error recovery,
 @item

-the current look-ahead and the entire stack (except the current
+the current lookahead and the entire stack (except the current

 right-hand side symbols) when the parser returns immediately, and
 @item
 the start symbol, when the parser succeeds.
 right-hand side symbols) when the parser returns immediately, and
 @item
 the start symbol, when the parser succeeds.


@@ -4172,10 +4300,13 @@ names defined in the grammar as well as a few other declarations.
 If the parser output file is named @file{@var{name}.c} then this file
 is named @file{@var{name}.h}.
 
 If the parser output file is named @file{@var{name}.c} then this file
 is named @file{@var{name}.h}.
 

-Unless @code{YYSTYPE} is already defined as a macro, the output header
-declares @code{YYSTYPE}.  Therefore, if you are using a @code{%union}
+For C parsers, the output header declares @code{YYSTYPE} unless
+@code{YYSTYPE} is already defined as a macro or you have used a
+@code{<@var{type}>} tag without using @code{%union}.
+Therefore, if you are using a @code{%union}

 (@pxref{Multiple Types, ,More Than One Value Type}) with components that
 require other definitions, or if you have defined a @code{YYSTYPE} macro
 (@pxref{Multiple Types, ,More Than One Value Type}) with components that
 require other definitions, or if you have defined a @code{YYSTYPE} macro

+or type definition

 (@pxref{Value Type, ,Data Types of Semantic Values}), you need to
 arrange for these definitions to be propagated to all modules, e.g., by
 putting them in a prerequisite header that is included both by your
 (@pxref{Value Type, ,Data Types of Semantic Values}), you need to
 arrange for these definitions to be propagated to all modules, e.g., by
 putting them in a prerequisite header that is included both by your


@@ -4187,7 +4318,7 @@ Parser}.
 
 If you have also used locations, the output header declares
 @code{YYLTYPE} and @code{yylloc} using a protocol similar to that of
 
 If you have also used locations, the output header declares
 @code{YYLTYPE} and @code{yylloc} using a protocol similar to that of

-@code{YYSTYPE} and @code{yylval}.  @xref{Locations, ,Tracking
+the @code{YYSTYPE} macro and @code{yylval}.  @xref{Locations, ,Tracking

 Locations}.
 
 This output file is normally essential if you wish to put the definition
 Locations}.
 
 This output file is normally essential if you wish to put the definition


@@ -4195,6 +4326,12 @@ of @code{yylex} in a separate source file, because @code{yylex}
 typically needs to be able to refer to the above-mentioned declarations
 and to the token type codes.  @xref{Token Values, ,Semantic Values of
 Tokens}.
 typically needs to be able to refer to the above-mentioned declarations
 and to the token type codes.  @xref{Token Values, ,Semantic Values of
 Tokens}.

+
+@findex %start-header
+@findex %end-header
+If you have declared @code{%start-header} or @code{%end-header}, the output
+header also contains their code.
+@xref{Table of Symbols, ,%start-header}.

 @end deffn
 
 @deffn {Directive} %destructor
 @end deffn
 
 @deffn {Directive} %destructor


@@ -4305,7 +4442,7 @@ The number of parser states (@pxref{Parser States}).
 
 @deffn {Directive} %verbose
 Write an extra output file containing verbose descriptions of the
 
 @deffn {Directive} %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
+parser states and what is done for each type of lookahead token in

 that state.  @xref{Understanding, , Understanding Your Parser}, for more
 information.
 @end deffn
 that state.  @xref{Understanding, , Understanding Your Parser}, for more
 information.
 @end deffn


@@ -4853,14 +4990,14 @@ Return immediately from @code{yyparse}, indicating success.
 @deffn {Macro} YYBACKUP (@var{token}, @var{value});
 @findex YYBACKUP
 Unshift a token.  This macro is allowed only for rules that reduce
 @deffn {Macro} YYBACKUP (@var{token}, @var{value});
 @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.
+a single value, and only when there is no lookahead token.

 It is also disallowed in @acronym{GLR} parsers.
 It is also disallowed in @acronym{GLR} parsers.

-It installs a look-ahead token with token type @var{token} and
+It installs a lookahead 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.
 
 If the macro is used when it is not valid, such as when there is
 semantic value @var{value}; then it discards the value that was
 going to be reduced by this rule.
 
 If the macro is used when it is not valid, such as when there is

-a look-ahead token already, then it reports a syntax error with
+a lookahead token already, then it reports a syntax error with

 a message @samp{cannot back up} and performs ordinary error
 recovery.
 
 a message @samp{cannot back up} and performs ordinary error
 recovery.
 


@@ -4869,12 +5006,12 @@ In either case, the rest of the action is not executed.
 
 @deffn {Macro} YYEMPTY
 @vindex YYEMPTY
 
 @deffn {Macro} YYEMPTY
 @vindex YYEMPTY

-Value stored in @code{yychar} when there is no look-ahead token.
+Value stored in @code{yychar} when there is no lookahead token.

 @end deffn
 
 @deffn {Macro} YYEOF
 @vindex YYEOF
 @end deffn
 
 @deffn {Macro} YYEOF
 @vindex YYEOF

-Value stored in @code{yychar} when the look-ahead is the end of the input
+Value stored in @code{yychar} when the lookahead is the end of the input

 stream.
 @end deffn
 
 stream.
 @end deffn
 


@@ -4888,22 +5025,23 @@ the @samp{YYERROR;} statement.  @xref{Error Recovery}.
 @end deffn
 
 @deffn {Macro} YYRECOVERING
 @end deffn
 
 @deffn {Macro} YYRECOVERING

-This macro stands for an expression that has the value 1 when the parser
-is recovering from a syntax error, and 0 the rest of the time.
+@findex YYRECOVERING
+The expression @code{YYRECOVERING ()} yields 1 when the parser
+is recovering from a syntax error, and 0 otherwise.

 @xref{Error Recovery}.
 @end deffn
 
 @deffn {Variable} yychar
 @xref{Error Recovery}.
 @end deffn
 
 @deffn {Variable} yychar

-Variable containing either the look-ahead token, or @code{YYEOF} when the
-look-ahead is the end of the input stream, or @code{YYEMPTY} when no look-ahead
+Variable containing either the lookahead token, or @code{YYEOF} when the
+lookahead is the end of the input stream, or @code{YYEMPTY} when no lookahead

 has been performed so the next token is not yet known.
 Do not modify @code{yychar} in a deferred semantic action (@pxref{GLR Semantic
 Actions}).
 has been performed so the next token is not yet known.
 Do not modify @code{yychar} in a deferred semantic action (@pxref{GLR Semantic
 Actions}).

-@xref{Look-Ahead, ,Look-Ahead Tokens}.
+@xref{Lookahead, ,Lookahead Tokens}.

 @end deffn
 
 @deffn {Macro} yyclearin;
 @end deffn
 
 @deffn {Macro} yyclearin;

-Discard the current look-ahead token.  This is useful primarily in
+Discard the current lookahead token.  This is useful primarily in

 error rules.
 Do not invoke @code{yyclearin} in a deferred semantic action (@pxref{GLR
 Semantic Actions}).
 error rules.
 Do not invoke @code{yyclearin} in a deferred semantic action (@pxref{GLR
 Semantic Actions}).


@@ -4917,7 +5055,7 @@ errors.  This is useful primarily in error rules.
 @end deffn
 
 @deffn {Variable} yylloc
 @end deffn
 
 @deffn {Variable} yylloc

-Variable containing the look-ahead token location when @code{yychar} is not set
+Variable containing the lookahead token location when @code{yychar} is not set

 to @code{YYEMPTY} or @code{YYEOF}.
 Do not modify @code{yylloc} in a deferred semantic action (@pxref{GLR Semantic
 Actions}).
 to @code{YYEMPTY} or @code{YYEOF}.
 Do not modify @code{yylloc} in a deferred semantic action (@pxref{GLR Semantic
 Actions}).


@@ -4925,7 +5063,7 @@ Actions}).
 @end deffn
 
 @deffn {Variable} yylval
 @end deffn
 
 @deffn {Variable} yylval

-Variable containing the look-ahead token semantic value when @code{yychar} is
+Variable containing the lookahead token semantic value when @code{yychar} is

 not set to @code{YYEMPTY} or @code{YYEOF}.
 Do not modify @code{yylval} in a deferred semantic action (@pxref{GLR Semantic
 Actions}).
 not set to @code{YYEMPTY} or @code{YYEOF}.
 Do not modify @code{yylval} in a deferred semantic action (@pxref{GLR Semantic
 Actions}).


@@ -5106,7 +5244,7 @@ to a single grouping whose symbol is the grammar's start-symbol
 This kind of parser is known in the literature as a bottom-up parser.
 
 @menu
 This kind of parser is known in the literature as a bottom-up parser.
 
 @menu

-* Look-Ahead::        Parser looks one token ahead when deciding what to do.
+* Lookahead::         Parser looks one token ahead when deciding what to do.

 * Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
 * Precedence::        Operator precedence works by resolving conflicts.
 * Contextual Precedence::  When an operator's precedence depends on context.
 * Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
 * Precedence::        Operator precedence works by resolving conflicts.
 * Contextual Precedence::  When an operator's precedence depends on context.


@@ -5117,9 +5255,9 @@ This kind of parser is known in the literature as a bottom-up parser.
 * Memory Management:: What happens when memory is exhausted.  How to avoid it.
 @end menu
 
 * Memory Management:: What happens when memory is exhausted.  How to avoid it.
 @end menu
 

-@node Look-Ahead
-@section Look-Ahead Tokens
-@cindex look-ahead token
+@node Lookahead
+@section Lookahead Tokens
+@cindex lookahead token

 
 The Bison parser does @emph{not} always reduce immediately as soon as the
 last @var{n} tokens and groupings match a rule.  This is because such a
 
 The Bison parser does @emph{not} always reduce immediately as soon as the
 last @var{n} tokens and groupings match a rule.  This is because such a


@@ -5128,15 +5266,15 @@ reduction is possible, the parser sometimes ``looks ahead'' at the next
 token in order to decide what to do.
 
 When a token is read, it is not immediately shifted; first it becomes the
 token in order to decide what to do.
 
 When a token is read, it is not immediately shifted; first it becomes the

-@dfn{look-ahead token}, which is not on the stack.  Now the parser can
+@dfn{lookahead token}, which is not on the stack.  Now the parser can

 perform one or more reductions of tokens and groupings on the stack, while
 perform one or more reductions of tokens and groupings on the stack, while

-the look-ahead token remains off to the side.  When no more reductions
-should take place, the look-ahead token is shifted onto the stack.  This
+the lookahead token remains off to the side.  When no more reductions
+should take place, the lookahead token is shifted onto the stack.  This

 does not mean that all possible reductions have been done; depending on the
 does not mean that all possible reductions have been done; depending on the

-token type of the look-ahead token, some rules may choose to delay their
+token type of the lookahead token, some rules may choose to delay their

 application.
 
 application.
 

-Here is a simple case where look-ahead is needed.  These three rules define
+Here is a simple case where lookahead is needed.  These three rules define

 expressions which contain binary addition operators and postfix unary
 factorial operators (@samp{!}), and allow parentheses for grouping.
 
 expressions which contain binary addition operators and postfix unary
 factorial operators (@samp{!}), and allow parentheses for grouping.
 


@@ -5171,7 +5309,7 @@ doing so would produce on the stack the sequence of symbols @code{expr
 @vindex yychar
 @vindex yylval
 @vindex yylloc
 @vindex yychar
 @vindex yylval
 @vindex yylloc

-The look-ahead token is stored in the variable @code{yychar}.
+The lookahead token is stored in the variable @code{yychar}.

 Its semantic value and location, if any, are stored in the variables
 @code{yylval} and @code{yylloc}.
 @xref{Action Features, ,Special Features for Use in Actions}.
 Its semantic value and location, if any, are stored in the variables
 @code{yylval} and @code{yylloc}.
 @xref{Action Features, ,Special Features for Use in Actions}.


@@ -5199,7 +5337,7 @@ if_stmt:
 Here we assume that @code{IF}, @code{THEN} and @code{ELSE} are
 terminal symbols for specific keyword tokens.
 
 Here we assume that @code{IF}, @code{THEN} and @code{ELSE} are
 terminal symbols for specific keyword tokens.
 

-When the @code{ELSE} token is read and becomes the look-ahead token, the
+When the @code{ELSE} token is read and becomes the lookahead token, the

 contents of the stack (assuming the input is valid) are just right for
 reduction by the first rule.  But it is also legitimate to shift the
 @code{ELSE}, because that would lead to eventual reduction by the second
 contents of the stack (assuming the input is valid) are just right for
 reduction by the first rule.  But it is also legitimate to shift the
 @code{ELSE}, because that would lead to eventual reduction by the second


@@ -5333,7 +5471,7 @@ operators we prefer the former, which is called @dfn{left association}.
 The latter alternative, @dfn{right association}, is desirable for
 assignment operators.  The choice of left or right association is a
 matter of whether the parser chooses to shift or reduce when the stack
 The latter alternative, @dfn{right association}, is desirable for
 assignment operators.  The choice of left or right association is a
 matter of whether the parser chooses to shift or reduce when the stack

-contains @w{@samp{1 - 2}} and the look-ahead token is @samp{-}: shifting
+contains @w{@samp{1 - 2}} and the lookahead token is @samp{-}: shifting

 makes right-associativity.
 
 @node Using Precedence
 makes right-associativity.
 
 @node Using Precedence


@@ -5394,7 +5532,7 @@ specify explicitly the precedence of a rule.  @xref{Contextual
 Precedence, ,Context-Dependent Precedence}.)
 
 Finally, the resolution of conflicts works by comparing the precedence
 Precedence, ,Context-Dependent Precedence}.)
 
 Finally, the resolution of conflicts works by comparing the precedence

-of the rule being considered with that of the look-ahead token.  If the
+of the rule being considered with that of the lookahead token.  If the

 token's precedence is higher, the choice is to shift.  If the rule's
 precedence is higher, the choice is to reduce.  If they have equal
 precedence, the choice is made based on the associativity of that
 token's precedence is higher, the choice is to shift.  If the rule's
 precedence is higher, the choice is to reduce.  If they have equal
 precedence, the choice is made based on the associativity of that


@@ -5403,7 +5541,7 @@ precedence level.  The verbose output file made by @samp{-v}
 resolved.
 
 Not all rules and not all tokens have precedence.  If either the rule or
 resolved.
 
 Not all rules and not all tokens have precedence.  If either the rule or

-the look-ahead token has no precedence, then the default is to shift.
+the lookahead token has no precedence, then the default is to shift.

 
 @node Contextual Precedence
 @section Context-Dependent Precedence
 
 @node Contextual Precedence
 @section Context-Dependent Precedence


@@ -5497,9 +5635,9 @@ represent the entire sequence of terminal and nonterminal symbols at or
 near the top of the stack.  The current state collects all the information
 about previous input which is relevant to deciding what to do next.
 
 near the top of the stack.  The current state collects all the information
 about previous input which is relevant to deciding what to do next.
 

-Each time a look-ahead token is read, the current parser state together
-with the type of look-ahead token are looked up in a table.  This table
-entry can say, ``Shift the look-ahead token.''  In this case, it also
+Each time a lookahead token is read, the current parser state together
+with the type of lookahead token are looked up in a table.  This table
+entry can say, ``Shift the lookahead token.''  In this case, it also

 specifies the new parser state, which is pushed onto the top of the
 parser stack.  Or it can say, ``Reduce using rule number @var{n}.''
 This means that a certain number of tokens or groupings are taken off
 specifies the new parser state, which is pushed onto the top of the
 parser stack.  Or it can say, ``Reduce using rule number @var{n}.''
 This means that a certain number of tokens or groupings are taken off


@@ -5507,7 +5645,7 @@ the top of the stack, and replaced by one grouping.  In other words,
 that number of states are popped from the stack, and one new state is
 pushed.
 
 that number of states are popped from the stack, and one new state is
 pushed.
 

-There is one other alternative: the table can say that the look-ahead token
+There is one other alternative: the table can say that the lookahead token

 is erroneous in the current state.  This causes error processing to begin
 (@pxref{Error Recovery}).
 
 is erroneous in the current state.  This causes error processing to begin
 (@pxref{Error Recovery}).
 


@@ -5665,7 +5803,7 @@ name_list:
 @end example
 
 It would seem that this grammar can be parsed with only a single token
 @end example
 
 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
+of lookahead: 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 @acronym{LR}(1).
 
 a @code{name} if a comma or colon follows, or a @code{type} if another
 @code{ID} follows.  In other words, this grammar is @acronym{LR}(1).
 


@@ -5679,7 +5817,7 @@ 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
 active---the rule for reducing to a @code{name} and that for reducing to
 a @code{type}.  Bison is unable to determine at that stage of processing
 same.  They appear similar because the same set of rules would be
 active---the rule for reducing to a @code{name} and that for reducing to
 a @code{type}.  Bison is unable to determine at that stage of processing

-that the rules would require different look-ahead tokens in the two
+that the rules would require different lookahead 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 @acronym{LALR}(1).
 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 @acronym{LALR}(1).


@@ -5752,13 +5890,13 @@ pp.@: 615--649 @uref{http://doi.acm.org/10.1145/69622.357187}.
 
 Bison produces @emph{deterministic} parsers that choose uniquely
 when to reduce and which reduction to apply
 
 Bison produces @emph{deterministic} parsers that choose uniquely
 when to reduce and which reduction to apply

-based on a summary of the preceding input and on one extra token of look-ahead.
+based on a summary of the preceding input and on one extra token of lookahead.

 As a result, normal Bison handles a proper subset of the family of
 context-free languages.
 Ambiguous grammars, since they have strings with more than one possible
 sequence of reductions cannot have deterministic parsers in this sense.
 The same is true of languages that require more than one symbol of
 As a result, normal Bison handles a proper subset of the family of
 context-free languages.
 Ambiguous grammars, since they have strings with more than one possible
 sequence of reductions cannot have deterministic parsers in this sense.
 The same is true of languages that require more than one symbol of

-look-ahead, since the parser lacks the information necessary to make a
+lookahead, since the parser lacks the information necessary to make a

 decision at the point it must be made in a shift-reduce parser.
 Finally, as previously mentioned (@pxref{Mystery Conflicts}),
 there are languages where Bison's particular choice of how to
 decision at the point it must be made in a shift-reduce parser.
 Finally, as previously mentioned (@pxref{Mystery Conflicts}),
 there are languages where Bison's particular choice of how to


@@ -5935,7 +6073,7 @@ and objects from the stack until it gets back to a state in which the
 @code{error} token is acceptable.  (This means that the subexpressions
 already parsed are discarded, back to the last complete @code{stmnts}.)
 At this point the @code{error} token can be shifted.  Then, if the old
 @code{error} token is acceptable.  (This means that the subexpressions
 already parsed are discarded, back to the last complete @code{stmnts}.)
 At this point the @code{error} token can be shifted.  Then, if the old

-look-ahead token is not acceptable to be shifted next, the parser reads
+lookahead token is not acceptable to be shifted next, the parser reads

 tokens and discards them until it finds a token which is acceptable.  In
 this example, Bison reads and discards input until the next newline so
 that the fourth rule can apply.  Note that discarded symbols are
 tokens and discards them until it finds a token which is acceptable.  In
 this example, Bison reads and discards input until the next newline so
 that the fourth rule can apply.  Note that discarded symbols are


@@ -5986,7 +6124,7 @@ error messages will be suppressed.  This macro requires no arguments;
 @samp{yyerrok;} is a valid C statement.
 
 @findex yyclearin
 @samp{yyerrok;} is a valid C statement.
 
 @findex yyclearin

-The previous look-ahead token is reanalyzed immediately after an error.  If
+The previous lookahead token is reanalyzed immediately after an error.  If

 this is unacceptable, then the macro @code{yyclearin} may be used to clear
 this token.  Write the statement @samp{yyclearin;} in the error rule's
 action.
 this is unacceptable, then the macro @code{yyclearin} may be used to clear
 this token.  Write the statement @samp{yyclearin;} in the error rule's
 action.


@@ -5995,14 +6133,14 @@ action.
 For example, suppose that on a syntax error, an error handling routine is
 called that advances the input stream to some point where parsing should
 once again commence.  The next symbol returned by the lexical scanner is
 For example, suppose that on a syntax error, an error handling routine is
 called that advances the input stream to some point where parsing should
 once again commence.  The next symbol returned by the lexical scanner is

-probably correct.  The previous look-ahead token ought to be discarded
+probably correct.  The previous lookahead token ought to be discarded

 with @samp{yyclearin;}.
 
 @vindex YYRECOVERING
 with @samp{yyclearin;}.
 
 @vindex YYRECOVERING

-The macro @code{YYRECOVERING} stands for an expression that has the
-value 1 when the parser is recovering from a syntax error, and 0 the
-rest of the time.  A value of 1 indicates that error messages are
-currently suppressed for new syntax errors.
+The expression @code{YYRECOVERING ()} yields 1 when the parser
+is recovering from a syntax error, and 0 otherwise.
+Syntax error diagnostics are suppressed while recovering from a syntax
+error.

 
 @node Context Dependency
 @chapter Handling Context Dependencies
 
 @node Context Dependency
 @chapter Handling Context Dependencies


@@ -6236,8 +6374,7 @@ As documented elsewhere (@pxref{Algorithm, ,The Bison Parser Algorithm})
 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
 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 @acronym{VCG}
-file).
+representation of it, either textually or graphically (as a DOT file).

 
 The textual file is generated when the options @option{--report} or
 @option{--verbose} are specified, see @xref{Invocation, , Invoking
 
 The textual file is generated when the options @option{--report} or
 @option{--verbose} are specified, see @xref{Invocation, , Invoking


@@ -6383,16 +6520,16 @@ beginning of the parsing, in the initial rule, right before the start
 symbol (here, @code{exp}).  When the parser returns to this state right
 after having reduced a rule that produced an @code{exp}, the control
 flow jumps to state 2.  If there is no such transition on a nonterminal
 symbol (here, @code{exp}).  When the parser returns to this state right
 after having reduced a rule that produced an @code{exp}, the control
 flow jumps to state 2.  If there is no such transition on a nonterminal

-symbol, and the look-ahead is a @code{NUM}, then this token is shifted on
+symbol, and the lookahead is a @code{NUM}, then this token is shifted on

 the parse stack, and the control flow jumps to state 1.  Any other
 the parse stack, and the control flow jumps to state 1.  Any other

-look-ahead triggers a syntax error.''
+lookahead triggers a syntax error.''

 
 @cindex core, item set
 @cindex item set core
 @cindex kernel, item set
 @cindex item set core
 Even though the only active rule in state 0 seems to be rule 0, the
 
 @cindex core, item set
 @cindex item set core
 @cindex kernel, item set
 @cindex item set core
 Even though the only active rule in state 0 seems to be rule 0, the

-report lists @code{NUM} as a look-ahead token because @code{NUM} can be
+report lists @code{NUM} as a lookahead token because @code{NUM} can be

 at the beginning of any rule deriving an @code{exp}.  By default Bison
 reports the so-called @dfn{core} or @dfn{kernel} of the item set, but if
 you want to see more detail you can invoke @command{bison} with
 at the beginning of any rule deriving an @code{exp}.  By default Bison
 reports the so-called @dfn{core} or @dfn{kernel} of the item set, but if
 you want to see more detail you can invoke @command{bison} with


@@ -6426,7 +6563,7 @@ state 1
 @end example
 
 @noindent
 @end example
 
 @noindent

-the rule 5, @samp{exp: NUM;}, is completed.  Whatever the look-ahead token
+the rule 5, @samp{exp: NUM;}, is completed.  Whatever the lookahead token

 (@samp{$default}), the parser will reduce it.  If it was coming from
 state 0, then, after this reduction it will return to state 0, and will
 jump to state 2 (@samp{exp: go to state 2}).
 (@samp{$default}), the parser will reduce it.  If it was coming from
 state 0, then, after this reduction it will return to state 0, and will
 jump to state 2 (@samp{exp: go to state 2}).


@@ -6449,7 +6586,7 @@ state 2
 
 @noindent
 In state 2, the automaton can only shift a symbol.  For instance,
 
 @noindent
 In state 2, the automaton can only shift a symbol.  For instance,

-because of the item @samp{exp -> exp . '+' exp}, if the look-ahead if
+because of the item @samp{exp -> exp . '+' exp}, if the lookahead if

 @samp{+}, it will be shifted on the parse stack, and the automaton
 control will jump to state 4, corresponding to the item @samp{exp -> exp
 '+' . exp}.  Since there is no default action, any other token than
 @samp{+}, it will be shifted on the parse stack, and the automaton
 control will jump to state 4, corresponding to the item @samp{exp -> exp
 '+' . exp}.  Since there is no default action, any other token than


@@ -6526,7 +6663,7 @@ state 8
     $default    reduce using rule 1 (exp)
 @end example
 
     $default    reduce using rule 1 (exp)
 @end example
 

-Indeed, there are two actions associated to the look-ahead @samp{/}:
+Indeed, there are two actions associated to the lookahead @samp{/}:

 either shifting (and going to state 7), or reducing rule 1.  The
 conflict means that either the grammar is ambiguous, or the parser lacks
 information to make the right decision.  Indeed the grammar is
 either shifting (and going to state 7), or reducing rule 1.  The
 conflict means that either the grammar is ambiguous, or the parser lacks
 information to make the right decision.  Indeed the grammar is


@@ -6544,14 +6681,14 @@ Note that all the previous states had a single possible action: either
 shifting the next token and going to the corresponding state, or
 reducing a single rule.  In the other cases, i.e., when shifting
 @emph{and} reducing is possible or when @emph{several} reductions are
 shifting the next token and going to the corresponding state, or
 reducing a single rule.  In the other cases, i.e., when shifting
 @emph{and} reducing is possible or when @emph{several} reductions are

-possible, the look-ahead is required to select the action.  State 8 is
-one such state: if the look-ahead is @samp{*} or @samp{/} then the action
+possible, the lookahead is required to select the action.  State 8 is
+one such state: if the lookahead is @samp{*} or @samp{/} then the action

 is shifting, otherwise the action is reducing rule 1.  In other words,
 the first two items, corresponding to rule 1, are not eligible when the
 is shifting, otherwise the action is reducing rule 1.  In other words,
 the first two items, corresponding to rule 1, are not eligible when the

-look-ahead token is @samp{*}, since we specified that @samp{*} has higher
+lookahead token is @samp{*}, since we specified that @samp{*} has higher

 precedence than @samp{+}.  More generally, some items are eligible only
 precedence than @samp{+}.  More generally, some items are eligible only

-with some set of possible look-ahead tokens.  When run with
-@option{--report=look-ahead}, Bison specifies these look-ahead tokens:
+with some set of possible lookahead tokens.  When run with
+@option{--report=lookahead}, Bison specifies these lookahead tokens:

 
 @example
 state 8
 
 @example
 state 8


@@ -6668,7 +6805,7 @@ The trace facility outputs messages with macro calls of the form
 @var{format} and @var{args} are the usual @code{printf} format and
 arguments.  If you define @code{YYDEBUG} to a nonzero value but do not
 define @code{YYFPRINTF}, @code{<stdio.h>} is automatically included
 @var{format} and @var{args} are the usual @code{printf} format and
 arguments.  If you define @code{YYDEBUG} to a nonzero value but do not
 define @code{YYFPRINTF}, @code{<stdio.h>} is automatically included

-and @code{YYPRINTF} is defined to @code{fprintf}.
+and @code{YYFPRINTF} is defined to @code{fprintf}.

 
 Once you have compiled the program with trace facilities, the way to
 request a trace is to store a nonzero value in the variable @code{yydebug}.
 
 Once you have compiled the program with trace facilities, the way to
 request a trace is to store a nonzero value in the variable @code{yydebug}.


@@ -6825,9 +6962,12 @@ different diagnostics to be generated, and may change behavior in
 other minor ways.  Most importantly, imitate Yacc's output
 file name conventions, so that the parser output file is called
 @file{y.tab.c}, and the other outputs are called @file{y.output} and
 other minor ways.  Most importantly, imitate Yacc's output
 file name conventions, so that the parser output file is called
 @file{y.tab.c}, and the other outputs are called @file{y.output} and

-@file{y.tab.h}.  Thus, the following shell script can substitute
-for Yacc, and the Bison distribution contains such a script for
-compatibility with @acronym{POSIX}:
+@file{y.tab.h}.
+Also, if generating an @acronym{LALR}(1) parser in C, generate @code{#define}
+statements in addition to an @code{enum} to associate token numbers with token
+names.
+Thus, the following shell script can substitute for Yacc, and the Bison
+distribution contains such a script for compatibility with @acronym{POSIX}:

 
 @example
 #! /bin/sh
 
 @example
 #! /bin/sh


@@ -6896,7 +7036,7 @@ Same as above, but save in the file @var{defines-file}.
 
 @item -b @var{file-prefix}
 @itemx --file-prefix=@var{prefix}
 
 @item -b @var{file-prefix}
 @itemx --file-prefix=@var{prefix}

-Pretend that @code{%file-prefix} was specified, i.e, specify prefix to use
+Pretend that @code{%file-prefix} was specified, i.e., specify prefix to use

 for all Bison output file names.  @xref{Decl Summary}.
 
 @item -r @var{things}
 for all Bison output file names.  @xref{Decl Summary}.
 
 @item -r @var{things}


@@ -6909,9 +7049,9 @@ separated list of @var{things} among:
 Description of the grammar, conflicts (resolved and unresolved), and
 @acronym{LALR} automaton.
 
 Description of the grammar, conflicts (resolved and unresolved), and
 @acronym{LALR} automaton.
 

-@item look-ahead
+@item lookahead

 Implies @code{state} and augments the description of the automaton with
 Implies @code{state} and augments the description of the automaton with

-each rule's look-ahead set.
+each rule's lookahead set.

 
 @item itemset
 Implies @code{state} and augments the description of the automaton with
 
 @item itemset
 Implies @code{state} and augments the description of the automaton with


@@ -6920,7 +7060,7 @@ the full set of items for each state, instead of its core only.
 
 @item -v
 @itemx --verbose
 
 @item -v
 @itemx --verbose

-Pretend that @code{%verbose} was specified, i.e, write an extra output
+Pretend that @code{%verbose} was specified, i.e., write an extra output

 file containing verbose descriptions of the grammar and
 parser.  @xref{Decl Summary}.
 
 file containing verbose descriptions of the grammar and
 parser.  @xref{Decl Summary}.
 


@@ -6932,10 +7072,11 @@ The other output files' names are constructed from @var{file} as
 described under the @samp{-v} and @samp{-d} options.
 
 @item -g
 described under the @samp{-v} and @samp{-d} options.
 
 @item -g

-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}.
+Output a graphical representation of the @acronym{LALR}(1) grammar
+automaton computed by Bison, in @uref{http://www.graphviz.org/, Graphviz}
+@uref{http://www.graphviz.org/doc/info/lang.html, @acronym{DOT}} format.
+If the grammar file is @file{foo.y}, the output file will
+be @file{foo.dot}.

 
 @item --graph=@var{graph-file}
 The behavior of @var{--graph} is the same than @samp{-g}.  The only
 
 @item --graph=@var{graph-file}
 The behavior of @var{--graph} is the same than @samp{-g}.  The only


@@ -7290,8 +7431,8 @@ factor both as follows.
 
 @comment file: calc++-driver.hh
 @example
 
 @comment file: calc++-driver.hh
 @example

-// Announce to Flex the prototype we want for lexing function, ...
-# define YY_DECL                                       \
+// Tell Flex the lexer's prototype ...
+# define YY_DECL                                        \

   yy::calcxx_parser::token_type                         \
   yylex (yy::calcxx_parser::semantic_type* yylval,      \
          yy::calcxx_parser::location_type* yylloc,      \
   yy::calcxx_parser::token_type                         \
   yylex (yy::calcxx_parser::semantic_type* yylval,      \
          yy::calcxx_parser::location_type* yylloc,      \


@@ -7321,7 +7462,6 @@ public:
 @noindent
 To encapsulate the coordination with the Flex scanner, it is useful to
 have two members function to open and close the scanning phase.
 @noindent
 To encapsulate the coordination with the Flex scanner, it is useful to
 have two members function to open and close the scanning phase.

-members.

 
 @comment file: calc++-driver.hh
 @example
 
 @comment file: calc++-driver.hh
 @example


@@ -7420,19 +7560,21 @@ the grammar for.
 @end example
 
 @noindent
 @end example
 
 @noindent

+@findex %start-header

 Then come the declarations/inclusions needed to define the
 @code{%union}.  Because the parser uses the parsing driver and
 reciprocally, both cannot include the header of the other.  Because the
 driver's header needs detailed knowledge about the parser class (in
 particular its inner types), it is the parser's header which will simply
 use a forward declaration of the driver.
 Then come the declarations/inclusions needed to define the
 @code{%union}.  Because the parser uses the parsing driver and
 reciprocally, both cannot include the header of the other.  Because the
 driver's header needs detailed knowledge about the parser class (in
 particular its inner types), it is the parser's header which will simply
 use a forward declaration of the driver.

+@xref{Table of Symbols, ,%start-header}.

 
 @comment file: calc++-parser.yy
 @example
 
 @comment file: calc++-parser.yy
 @example

-%@{
+%start-header @{

 # include <string>
 class calcxx_driver;
 # include <string>
 class calcxx_driver;

-%@}
+@}

 @end example
 
 @noindent
 @end example
 
 @noindent


@@ -7488,15 +7630,15 @@ them.
 @end example
 
 @noindent
 @end example
 
 @noindent

-The code between @samp{%@{} and @samp{%@}} after the introduction of the
-@samp{%union} is output in the @file{*.cc} file; it needs detailed
-knowledge about the driver.
+@findex %after-header
+The code between @samp{%after-header @{} and @samp{@}} is output in the
+@file{*.cc} file; it needs detailed knowledge about the driver.

 
 @comment file: calc++-parser.yy
 @example
 
 @comment file: calc++-parser.yy
 @example

-%@{
+%after-header @{

 # include "calc++-driver.hh"
 # include "calc++-driver.hh"

-%@}
+@}

 @end example
 
 
 @end example
 
 


@@ -7541,7 +7683,9 @@ unit: assignments exp  @{ driver.result = $2; @};
 assignments: assignments assignment @{@}
            | /* Nothing.  */        @{@};
 
 assignments: assignments assignment @{@}
            | /* Nothing.  */        @{@};
 

-assignment: "identifier" ":=" exp @{ driver.variables[*$1] = $3; @};
+assignment:
+     "identifier" ":=" exp
+       @{ driver.variables[*$1] = $3; delete $1; @};

 
 %left '+' '-';
 %left '*' '/';
 
 %left '+' '-';
 %left '*' '/';


@@ -7549,7 +7693,7 @@ exp: exp '+' exp   @{ $$ = $1 + $3; @}
    | exp '-' exp   @{ $$ = $1 - $3; @}
    | exp '*' exp   @{ $$ = $1 * $3; @}
    | exp '/' exp   @{ $$ = $1 / $3; @}
    | exp '-' exp   @{ $$ = $1 - $3; @}
    | exp '*' exp   @{ $$ = $1 * $3; @}
    | exp '/' exp   @{ $$ = $1 / $3; @}

-   | "identifier"  @{ $$ = driver.variables[*$1]; @}
+   | "identifier"  @{ $$ = driver.variables[*$1]; delete $1; @}

    | "number"      @{ $$ = $1; @};
 %%
 @end example
    | "number"      @{ $$ = $1; @};
 %%
 @end example


@@ -7710,8 +7854,8 @@ main (int argc, char *argv[])
       driver.trace_scanning = true;
     else
       @{
       driver.trace_scanning = true;
     else
       @{

-       driver.parse (*argv);
-       std::cout << driver.result << std::endl;
+        driver.parse (*argv);
+        std::cout << driver.result << std::endl;

       @}
 @}
 @end example
       @}
 @}
 @end example


@@ -8164,6 +8308,86 @@ $end}, where @var{start} is the start symbol.  @xref{Start Decl, , The
 Start-Symbol}.  It cannot be used in the grammar.
 @end deffn
 
 Start-Symbol}.  It cannot be used in the grammar.
 @end deffn
 

+@deffn {Directive} %after-header @{@var{code}@}
+Specifies code to be inserted into the code file after the contents of the
+header file.
+@xref{Table of Symbols, ,%start-header}.
+@end deffn
+
+@deffn {Directive} %before-header @{@var{code}@}
+Specifies code to be inserted into the code file before the contents of the
+header file.
+@xref{Table of Symbols, ,%start-header}.
+@end deffn
+
+@deffn {Directive} %end-header @{@var{code}@}
+Specifies code to be inserted both into the header file (if generated;
+@pxref{Table of Symbols, ,%defines}) and into the code file after any
+Bison-generated definitions.
+@xref{Table of Symbols, ,%start-header}.
+@end deffn
+
+@deffn {Directive} %start-header @{@var{code}@}
+Specifies code to be inserted both into the header file (if generated;
+@pxref{Table of Symbols, ,%defines}) and into the code file before any
+Bison-generated definitions.
+
+@cindex Prologue
+@findex %before-header
+@findex %union
+@findex %end-header
+@findex %after-header
+For example, the following declaration order in the grammar file reflects the
+order in which Bison will output these code blocks.  However, you are free to
+declare these code blocks in your grammar file in whatever order is most
+convenient for you:
+
+@smallexample
+%before-header @{
+  /* Bison treats this block like a pre-prologue block: it inserts it
+   * into the code file before the contents of the header file.  It
+   * does *not* insert it into the header file.  This is a good place
+   * to put #include's that you want at the top of your code file.  A
+   * common example is `#include "system.h"'.  */
+@}
+%start-header @{
+  /* Bison inserts this block into both the header file and the code
+   * file.  In both files, the point of insertion is before any
+   * Bison-generated token, semantic type, location type, and class
+   * definitions.  This is a good place to define %union
+   * dependencies, for example.  */
+@}
+%union @{
+  /* Unlike the traditional Yacc prologue blocks, the output order
+   * for the %*-header blocks is not affected by their declaration
+   * position relative to any %union in the grammar file.  */
+@}
+%end-header @{
+  /* Bison inserts this block into both the header file and the code
+   * file.  In both files, the point of insertion is after the
+   * Bison-generated definitions.  This is a good place to declare or
+   * define public functions or data structures that depend on the
+   * Bison-generated definitions.  */
+@}
+%after-header @{
+  /* Bison treats this block like a post-prologue block: it inserts
+   * it into the code file after the contents of the header file.  It
+   * does *not* insert it into the header file.  This is a good place
+   * to declare or define internal functions or data structures that
+   * depend on the Bison-generated definitions.  */
+@}
+@end smallexample
+
+If you have multiple occurrences of any one of the above declarations, Bison
+will concatenate the contents in declaration order.
+
+@xref{Prologue, ,The Prologue}.
+@end deffn
+
+@deffn {Directive} %debug
+Equip the parser for debugging.  @xref{Decl Summary}.
+@end deffn
+

 @deffn {Directive} %debug
 Equip the parser for debugging.  @xref{Decl Summary}.
 @end deffn
 @deffn {Directive} %debug
 Equip the parser for debugging.  @xref{Decl Summary}.
 @end deffn


@@ -8202,8 +8426,8 @@ A token name reserved for error recovery.  This token may be used in
 grammar rules so as to allow the Bison parser to recognize an error in
 the grammar without halting the process.  In effect, a sentence
 containing an error may be recognized as valid.  On a syntax error, the
 grammar rules so as to allow the Bison parser to recognize an error in
 the grammar without halting the process.  In effect, a sentence
 containing an error may be recognized as valid.  On a syntax error, the

-token @code{error} becomes the current look-ahead token.  Actions
-corresponding to @code{error} are then executed, and the look-ahead
+token @code{error} becomes the current lookahead token.  Actions
+corresponding to @code{error} are then executed, and the lookahead

 token is reset to the token that originally caused the violation.
 @xref{Error Recovery}.
 @end deffn
 token is reset to the token that originally caused the violation.
 @xref{Error Recovery}.
 @end deffn


@@ -8303,6 +8527,11 @@ Bison declaration to specify the start symbol.  @xref{Start Decl, ,The
 Start-Symbol}.
 @end deffn
 
 Start-Symbol}.
 @end deffn
 

+@deffn {Directive} %symbol-default
+Used to declare a default @code{%destructor} or default @code{%printer}.
+@xref{Destructor Decl, , Freeing Discarded Symbols}.
+@end deffn
+

 @deffn {Directive} %token
 Bison declaration to declare token(s) without specifying precedence.
 @xref{Token Decl, ,Token Type Names}.
 @deffn {Directive} %token
 Bison declaration to declare token(s) without specifying precedence.
 @xref{Token Decl, ,Token Type Names}.


@@ -8343,20 +8572,20 @@ read, by making @code{yyparse} return 0 immediately.
 @end deffn
 
 @deffn {Macro} YYBACKUP
 @end deffn
 
 @deffn {Macro} YYBACKUP

-Macro to discard a value from the parser stack and fake a look-ahead
+Macro to discard a value from the parser stack and fake a lookahead

 token.  @xref{Action Features, ,Special Features for Use in Actions}.
 @end deffn
 
 @deffn {Variable} yychar
 External integer variable that contains the integer value of the
 token.  @xref{Action Features, ,Special Features for Use in Actions}.
 @end deffn
 
 @deffn {Variable} yychar
 External integer variable that contains the integer value of the

-look-ahead token.  (In a pure parser, it is a local variable within
+lookahead token.  (In a pure parser, it is a local variable within

 @code{yyparse}.)  Error-recovery rule actions may examine this variable.
 @xref{Action Features, ,Special Features for Use in Actions}.
 @end deffn
 
 @deffn {Variable} yyclearin
 Macro used in error-recovery rule actions.  It clears the previous
 @code{yyparse}.)  Error-recovery rule actions may examine this variable.
 @xref{Action Features, ,Special Features for Use in Actions}.
 @end deffn
 
 @deffn {Variable} yyclearin
 Macro used in error-recovery rule actions.  It clears the previous

-look-ahead token.  @xref{Error Recovery}.
+lookahead token.  @xref{Error Recovery}.

 @end deffn
 
 @deffn {Macro} YYDEBUG
 @end deffn
 
 @deffn {Macro} YYDEBUG


@@ -8422,7 +8651,7 @@ variable within @code{yyparse}, and its address is passed to
 You can ignore this variable if you don't use the @samp{@@} feature in the
 grammar actions.
 @xref{Token Locations, ,Textual Locations of Tokens}.
 You can ignore this variable if you don't use the @samp{@@} feature in the
 grammar actions.
 @xref{Token Locations, ,Textual Locations of Tokens}.

-In semantic actions, it stores the location of the look-ahead token.
+In semantic actions, it stores the location of the lookahead token.

 @xref{Actions and Locations, ,Actions and Locations}.
 @end deffn
 
 @xref{Actions and Locations, ,Actions and Locations}.
 @end deffn
 


@@ -8437,7 +8666,7 @@ value associated with a token.  (In a pure parser, it is a local
 variable within @code{yyparse}, and its address is passed to
 @code{yylex}.)
 @xref{Token Values, ,Semantic Values of Tokens}.
 variable within @code{yyparse}, and its address is passed to
 @code{yylex}.)
 @xref{Token Values, ,Semantic Values of Tokens}.

-In semantic actions, it stores the semantic value of the look-ahead token.
+In semantic actions, it stores the semantic value of the lookahead token.

 @xref{Actions, ,Actions}.
 @end deffn
 
 @xref{Actions, ,Actions}.
 @end deffn
 


@@ -8465,8 +8694,9 @@ Conventions for Pure Parsers}.
 @end deffn
 
 @deffn {Macro} YYRECOVERING
 @end deffn
 
 @deffn {Macro} YYRECOVERING

-Macro whose value indicates whether the parser is recovering from a
-syntax error.  @xref{Action Features, ,Special Features for Use in Actions}.
+The expression @code{YYRECOVERING ()} yields 1 when the parser
+is recovering from a syntax error, and 0 otherwise.
+@xref{Action Features, ,Special Features for Use in Actions}.

 @end deffn
 
 @deffn {Macro} YYSTACK_USE_ALLOCA
 @end deffn
 
 @deffn {Macro} YYSTACK_USE_ALLOCA


@@ -8576,8 +8806,8 @@ tokens are parsed.  @xref{Lexical Tie-ins}.
 @item Literal string token
 A token which consists of two or more fixed characters.  @xref{Symbols}.
 
 @item Literal string token
 A token which consists of two or more fixed characters.  @xref{Symbols}.
 

-@item Look-ahead token
-A token already read but not yet shifted.  @xref{Look-Ahead, ,Look-Ahead
+@item Lookahead token
+A token already read but not yet shifted.  @xref{Lookahead, ,Lookahead

 Tokens}.
 
 @item @acronym{LALR}(1)
 Tokens}.
 
 @item @acronym{LALR}(1)


@@ -8587,7 +8817,7 @@ Conflicts, ,Mysterious Reduce/Reduce Conflicts}.
 
 @item @acronym{LR}(1)
 The class of context-free grammars in which at most one token of
 
 @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.
+lookahead is needed to disambiguate the parsing of any piece of input.

 
 @item Nonterminal symbol
 A grammar symbol standing for a grammatical construct that can
 
 @item Nonterminal symbol
 A grammar symbol standing for a grammatical construct that can


@@ -8701,9 +8931,9 @@ grammatically indivisible.  The piece of text it represents is a token.
 @c LocalWords: strncmp intval tindex lvalp locp llocp typealt YYBACKUP
 @c LocalWords: YYEMPTY YYEOF YYRECOVERING yyclearin GE def UMINUS maybeword
 @c LocalWords: Johnstone Shamsa Sadaf Hussain Tomita TR uref YYMAXDEPTH
 @c LocalWords: strncmp intval tindex lvalp locp llocp typealt YYBACKUP
 @c LocalWords: YYEMPTY YYEOF YYRECOVERING yyclearin GE def UMINUS maybeword
 @c LocalWords: Johnstone Shamsa Sadaf Hussain Tomita TR uref YYMAXDEPTH

-@c LocalWords: YYINITDEPTH stmnts ref stmnt initdcl maybeasm VCG notype
+@c LocalWords: YYINITDEPTH stmnts ref stmnt initdcl maybeasm notype

 @c LocalWords: hexflag STR exdent itemset asis DYYDEBUG YYFPRINTF args
 @c LocalWords: hexflag STR exdent itemset asis DYYDEBUG YYFPRINTF args

-@c LocalWords: YYPRINTF infile ypp yxx outfile itemx vcg tex leaderfill
+@c LocalWords: infile ypp yxx outfile itemx tex leaderfill

 @c LocalWords: hbox hss hfill tt ly yyin fopen fclose ofirst gcc ll
 @c LocalWords: yyrestart nbar yytext fst snd osplit ntwo strdup AST
 @c LocalWords: YYSTACK DVI fdl printindex
 @c LocalWords: hbox hss hfill tt ly yyin fopen fclose ofirst gcc ll
 @c LocalWords: yyrestart nbar yytext fst snd osplit ntwo strdup AST
 @c LocalWords: YYSTACK DVI fdl printindex