* NEWS: Bison-generated parsers no longer default to using the

[bison.git] / doc / bison.texinfo

diff --git a/doc/bison.texinfo b/doc/bison.texinfo
index dd2407a39c8c17585a2fdd4e6dd666ad8030df8e..f026012707bdf775e34c15928cb5b87357bcfe42 100644 (file)
--- a/doc/bison.texinfo
+++ b/doc/bison.texinfo
@@ -228,6 +228,7 @@ Bison Declarations
 * Precedence Decl::   Declaring terminals with precedence and associativity.
 * Union Decl::        Declaring the set of all semantic value types.
 * Type Decl::         Declaring the choice of type for a nonterminal symbol.
 * Precedence Decl::   Declaring terminals with precedence and associativity.
 * Union Decl::        Declaring the set of all semantic value types.
 * Type Decl::         Declaring the choice of type for a nonterminal symbol.

+* Initial Action Decl::  Code run before parsing starts.

 * Destructor Decl::   Declaring how symbols are freed.
 * Expect Decl::       Suppressing warnings about parsing conflicts.
 * Start Decl::        Specifying the start symbol.
 * Destructor Decl::   Declaring how symbols are freed.
 * Expect Decl::       Suppressing warnings about parsing conflicts.
 * Start Decl::        Specifying the start symbol.


@@ -479,7 +480,7 @@ Here is a simple C function subdivided into tokens:
 @ifinfo
 @example
 int             /* @r{keyword `int'} */
 @ifinfo
 @example
 int             /* @r{keyword `int'} */

-square (int x)  /* @r{identifier, open-paren, identifier,}
+square (int x)  /* @r{identifier, open-paren, keyword `int',}

                    @r{identifier, close-paren} */
 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk,
                    @r{identifier, close-paren} */
 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk,


@@ -490,7 +491,7 @@ square (int x)  /* @r{identifier, open-paren, identifier,}
 @ifnotinfo
 @example
 int             /* @r{keyword `int'} */
 @ifnotinfo
 @example
 int             /* @r{keyword `int'} */

-square (int x)  /* @r{identifier, open-paren, identifier, identifier, close-paren} */
+square (int x)  /* @r{identifier, open-paren, keyword `int', identifier, close-paren} */

 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk, identifier, semicolon} */
 @}               /* @r{close-brace} */
 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk, identifier, semicolon} */
 @}               /* @r{close-brace} */


@@ -3445,38 +3446,40 @@ 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).  When a
 
 The @code{YYLLOC_DEFAULT} macro takes three parameters.  The first one is
 the location of the grouping (the result of the computation).  When a

-rule is matched, the second parameter is an array holding locations of
+rule is matched, the second parameter identifies locations of

 all right hand side elements of the rule being matched, and the third
 parameter is the size of the rule's right hand side.  When processing
 all right hand side elements of the rule being matched, and the third
 parameter is the size of the rule's right hand side.  When processing

-a syntax error, the second parameter is an array holding locations of
+a syntax error, the second parameter identifies locations of

 the symbols that were discarded during error processing, and the third
 parameter is the number of discarded symbols.
 
 the symbols that were discarded during error processing, and the third
 parameter is the number of discarded symbols.
 

-By default, @code{YYLLOC_DEFAULT} is defined this way for simple
-@acronym{LALR}(1) parsers:
+By default, @code{YYLLOC_DEFAULT} is defined this way:

 
 

-@example
+@smallexample

 @group
 @group

-# define YYLLOC_DEFAULT(Current, Rhs, N)               \
-   ((Current).first_line   = (Rhs)[1].first_line,      \
-    (Current).first_column = (Rhs)[1].first_column,    \
-    (Current).last_line    = (Rhs)[N].last_line,       \
-    (Current).last_column  = (Rhs)[N].last_column)
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (N)                                                            \
+        @{                                                               \
+          (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;         \
+          (Current).first_column = YYRHSLOC(Rhs, 1).first_column;       \
+          (Current).last_line    = YYRHSLOC(Rhs, N).last_line;          \
+          (Current).last_column  = YYRHSLOC(Rhs, N).last_column;        \
+        @}                                                               \
+      else                                                              \
+        @{                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC(Rhs, 0).last_line;                                 \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC(Rhs, 0).last_column;                               \
+        @}                                                               \
+    while (0)

 @end group
 @end group

-@end example
-
-@noindent
-and like this for @acronym{GLR} parsers:
+@end smallexample

 
 

-@example
-@group
-# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)                 \
-   ((yyCurrent).first_line = YYRHSLOC(yyRhs, 1).first_line,    \
-    (yyCurrent).first_column = YYRHSLOC(yyRhs, 1).first_column,        \
-    (yyCurrent).last_line = YYRHSLOC(yyRhs, YYN).last_line,    \
-    (yyCurrent).last_column  = YYRHSLOC(yyRhs, YYN).last_column)
-@end group
-@end example
+where @code{YYRHSLOC (rhs, k)} is the location of the @var{k}th symbol
+in @var{rhs} when @var{k} is positive, and the location of the symbol
+just before the reduction when @var{k} and @var{n} are both zero.

 
 When defining @code{YYLLOC_DEFAULT}, you should consider that:
 
 
 When defining @code{YYLLOC_DEFAULT}, you should consider that:
 


@@ -3486,8 +3489,10 @@ All arguments are free of side-effects.  However, only the first one (the
 result) should be modified by @code{YYLLOC_DEFAULT}.
 
 @item
 result) should be modified by @code{YYLLOC_DEFAULT}.
 
 @item

-For consistency with semantic actions, valid indexes for the location
-array range from 1 to @var{n}.
+For consistency with semantic actions, valid indexes within the
+right hand side range from 1 to @var{n}.  When @var{n} is zero, only 0 is a
+valid index, and it refers to the symbol just before the reduction.
+During error processing @var{n} is always positive.

 
 @item
 Your macro should parenthesize its arguments, if need be, since the
 
 @item
 Your macro should parenthesize its arguments, if need be, since the


@@ -3520,6 +3525,7 @@ Grammars}).
 * Precedence Decl::   Declaring terminals with precedence and associativity.
 * Union Decl::        Declaring the set of all semantic value types.
 * Type Decl::         Declaring the choice of type for a nonterminal symbol.
 * Precedence Decl::   Declaring terminals with precedence and associativity.
 * Union Decl::        Declaring the set of all semantic value types.
 * Type Decl::         Declaring the choice of type for a nonterminal symbol.

+* Initial Action Decl::  Code run before parsing starts.

 * Destructor Decl::   Declaring how symbols are freed.
 * Expect Decl::       Suppressing warnings about parsing conflicts.
 * Start Decl::        Specifying the start symbol.
 * Destructor Decl::   Declaring how symbols are freed.
 * Expect Decl::       Suppressing warnings about parsing conflicts.
 * Start Decl::        Specifying the start symbol.


@@ -3729,6 +3735,33 @@ use the same @code{<@var{type}>} construction in a declaration for the
 terminal symbol.  All kinds of token declarations allow
 @code{<@var{type}>}.
 
 terminal symbol.  All kinds of token declarations allow
 @code{<@var{type}>}.
 

+@node Initial Action Decl
+@subsection Performing Actions before Parsing
+@findex %initial-action
+
+Sometimes your parser needs to perform some initializations before
+parsing.  The @code{%initial-action} directive allows for such arbitrary
+code.
+
+@deffn {Directive} %initial-action @{ @var{code} @}
+@findex %initial-action
+Declare that the @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{%parse-param}.
+@end deffn
+
+For instance, if your locations use a file name, you may use
+
+@example
+%parse-param @{ const char *filename @};
+%initial-action
+@{
+  @@$.begin.filename = @@$.end.filename = filename;
+@};
+@end example
+
+

 @node Destructor Decl
 @subsection Freeing Discarded Symbols
 @cindex freeing discarded symbols
 @node Destructor Decl
 @subsection Freeing Discarded Symbols
 @cindex freeing discarded symbols


@@ -3804,7 +3837,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 lookahead when the parser aborts (either via an explicit
+the current look-ahead when the parser aborts (either via an explicit

 call to @code{YYABORT}, or as a consequence of a failed error recovery).
 @end itemize
 
 call to @code{YYABORT}, or as a consequence of a failed error recovery).
 @end itemize
 


@@ -5541,7 +5574,6 @@ By defining the macro @code{YYMAXDEPTH}, you can control how deep the
 parser stack can become before a stack overflow occurs.  Define the
 macro with a value that is an integer.  This value is the maximum number
 of tokens that can be shifted (and not reduced) before overflow.
 parser stack can become before a stack overflow occurs.  Define the
 macro with a value that is an integer.  This value is the maximum number
 of tokens that can be shifted (and not reduced) before overflow.

-It must be a constant expression whose value is known at compile time.

 
 The stack space allowed is not necessarily allocated.  If you specify a
 large value for @code{YYMAXDEPTH}, the parser actually allocates a small
 
 The stack space allowed is not necessarily allocated.  If you specify a
 large value for @code{YYMAXDEPTH}, the parser actually allocates a small


@@ -5550,22 +5582,33 @@ increasing allocation happens automatically and silently.  Therefore,
 you do not need to make @code{YYMAXDEPTH} painfully small merely to save
 space for ordinary inputs that do not need much stack.
 
 you do not need to make @code{YYMAXDEPTH} painfully small merely to save
 space for ordinary inputs that do not need much stack.
 

+However, do not allow @code{YYMAXDEPTH} to be a value so large that
+arithmetic overflow could occur when calculating the size of the stack
+space.  Also, do not allow @code{YYMAXDEPTH} to be less than
+@code{YYINITDEPTH}.
+

 @cindex default stack limit
 The default value of @code{YYMAXDEPTH}, if you do not define it, is
 10000.
 
 @vindex YYINITDEPTH
 You can control how much stack is allocated initially by defining the
 @cindex default stack limit
 The default value of @code{YYMAXDEPTH}, if you do not define it, is
 10000.
 
 @vindex YYINITDEPTH
 You can control how much stack is allocated initially by defining the

-macro @code{YYINITDEPTH}.  This value too must be a compile-time
-constant integer.  The default is 200.
+macro @code{YYINITDEPTH} to a positive integer.  For the C
+@acronym{LALR}(1) parser, this value must be a compile-time constant
+unless you are assuming C99 or some other target language or compiler
+that allows variable-length arrays.  The default is 200.
+
+Do not allow @code{YYINITDEPTH} to be a value so large that arithmetic
+overflow would occur when calculating the size of the stack space.
+Also, do not allow @code{YYINITDEPTH} to be greater than
+@code{YYMAXDEPTH}.

 
 @c FIXME: C++ output.
 Because of semantical differences between C and C++, the
 
 @c FIXME: C++ output.
 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
-provided which addresses this issue.
+@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 provided which addresses this issue.

 
 @node Error Recovery
 @chapter Error Recovery
 
 @node Error Recovery
 @chapter Error Recovery


@@ -6869,19 +6912,18 @@ $ @kbd{printf 'one\ntwo\n' | ./split-lines}
 How can I generate parsers in C++?
 @end display
 
 How can I generate parsers in C++?
 @end display
 

-We are working on a C++ output for Bison, but unfortunately, for lack
-of time, the skeleton is not finished.  It is functional, but in
-numerous respects, it will require additional work which @emph{might}
-break backward compatibility.  Since the skeleton for C++ is not
-documented, we do not consider ourselves bound to this interface,
-nevertheless, as much as possible we will try to keep compatibility.
+We are working on a C++ output for Bison, but unfortunately, for lack of
+time, the skeleton is not finished.  It is functional, but in numerous
+respects, it will require additional work which @emph{might} break
+backward compatibility.  Since the skeleton for C++ is not documented,
+we do not consider ourselves bound to this interface, nevertheless, as
+much as possible we will try to keep compatibility.

 
 

-Another possibility is to use the regular C parsers, and to compile
-them with a C++ compiler.  This works properly, provided that you bear
-some simple C++ rules in mind, such as not including ``real classes''
-(i.e., structure with constructors) in unions.  Therefore, in the
-@code{%union}, use pointers to classes, or better yet, a single
-pointer type to the root of your lexical/syntactic hierarchy.
+Another possibility is to use the regular C parsers, and to compile them
+with a C++ compiler.  This works properly, provided that you bear some
+simple C++ rules in mind, such as not including ``real classes'' (i.e.,
+structure with constructors) in unions.  Therefore, in the
+@code{%union}, use pointers to classes.

 
 
 @node Implementing Gotos/Loops
 
 
 @node Implementing Gotos/Loops


@@ -6942,178 +6984,42 @@ In an action, the semantic value of the @var{n}-th symbol of the
 right-hand side of the rule.  @xref{Actions}.
 @end deffn
 
 right-hand side of the rule.  @xref{Actions}.
 @end deffn
 

-@deffn {Symbol} $accept
-The predefined nonterminal whose only rule is @samp{$accept: @var{start}
-$end}, where @var{start} is the start symbol.  @xref{Start Decl, , The
-Start-Symbol}.  It cannot be used in the grammar.
-@end deffn
-
-@deffn {Symbol} $end
-The predefined token marking the end of the token stream.  It cannot be
-used in the grammar.
-@end deffn
-
-@deffn {Symbol} $undefined
-The predefined token onto which all undefined values returned by
-@code{yylex} are mapped.  It cannot be used in the grammar, rather, use
-@code{error}.
-@end deffn
-
-@deffn {Symbol} error
-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
-token @code{error} becomes the current look-ahead token.  Actions
-corresponding to @code{error} are then executed, and the look-ahead
-token is reset to the token that originally caused the violation.
-@xref{Error Recovery}.
-@end deffn
-
-@deffn {Macro} YYABORT
-Macro to pretend that an unrecoverable syntax error has occurred, by
-making @code{yyparse} return 1 immediately.  The error reporting
-function @code{yyerror} is not called.  @xref{Parser Function, ,The
-Parser Function @code{yyparse}}.
-@end deffn
-
-@deffn {Macro} YYACCEPT
-Macro to pretend that a complete utterance of the language has been
-read, by making @code{yyparse} return 0 immediately.
-@xref{Parser Function, ,The Parser Function @code{yyparse}}.
-@end deffn
-
-@deffn {Macro} YYBACKUP
-Macro to discard a value from the parser stack and fake a look-ahead
-token.  @xref{Action Features, ,Special Features for Use in Actions}.
-@end deffn
-
-@deffn {Macro} YYDEBUG
-Macro to define to equip the parser with tracing code.  @xref{Tracing,
-,Tracing Your Parser}.
-@end deffn
-
-@deffn {Macro} YYERROR
-Macro to pretend that a syntax error has just been detected: call
-@code{yyerror} and then perform normal error recovery if possible
-(@pxref{Error Recovery}), or (if recovery is impossible) make
-@code{yyparse} return 1.  @xref{Error Recovery}.
-@end deffn
-
-@deffn {Macro} YYERROR_VERBOSE
-An obsolete macro that you define with @code{#define} in the prologue
-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.
-@end deffn
-
-@deffn {Macro} YYINITDEPTH
-Macro for specifying the initial size of the parser stack.
-@xref{Stack Overflow}.
-@end deffn
-
-@deffn {Macro} YYLEX_PARAM
-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}.
-@end deffn
-
-@deffn {Type} YYLTYPE
-Data type of @code{yylloc}; by default, a structure with four
-members.  @xref{Location Type, , Data Types of Locations}.
-@end deffn
-
-@deffn {Macro} YYMAXDEPTH
-Macro for specifying the maximum size of the parser stack.  @xref{Stack
-Overflow}.
-@end deffn
-
-@deffn {Macro} YYPARSE_PARAM
-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}.
-@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}.
-@end deffn
-
-@deffn {Macro} YYSTACK_USE_ALLOCA
-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}
-to anything else.
-@end deffn
-
-@deffn {Type} YYSTYPE
-Data type of semantic values; @code{int} by default.
-@xref{Value Type, ,Data Types of Semantic Values}.
-@end deffn
-
-@deffn {Variable} yychar
-External integer variable that contains the integer value of the current
-look-ahead 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
-look-ahead token.  @xref{Error Recovery}.
-@end deffn
-
-@deffn {Variable} yydebug
-External integer variable set to zero by default.  If @code{yydebug}
-is given a nonzero value, the parser will output information on input
-symbols and parser action.  @xref{Tracing, ,Tracing Your Parser}.
-@end deffn
-
-@deffn {Macro} yyerrok
-Macro to cause parser to recover immediately to its normal mode
-after a syntax error.  @xref{Error Recovery}.
+@deffn {Delimiter} %%
+Delimiter used to separate the grammar rule section from the
+Bison declarations section or the epilogue.
+@xref{Grammar Layout, ,The Overall Layout of a Bison Grammar}.

 @end deffn
 
 @end deffn
 

-@deffn {Function} yyerror
-User-supplied function to be called by @code{yyparse} on error.
-@xref{Error Reporting, ,The Error
-Reporting Function @code{yyerror}}.
+@c Don't insert spaces, or check the DVI output.
+@deffn {Delimiter} %@{@var{code}%@}
+All code listed between @samp{%@{} and @samp{%@}} is copied directly to
+the output file uninterpreted.  Such code forms the prologue of the input
+file.  @xref{Grammar Outline, ,Outline of a Bison
+Grammar}.

 @end deffn
 
 @end deffn
 

-@deffn {Function} yylex
-User-supplied lexical analyzer function, called with no arguments to get
-the next token.  @xref{Lexical, ,The Lexical Analyzer Function
-@code{yylex}}.
+@deffn {Construct} /*@dots{}*/
+Comment delimiters, as in C.

 @end deffn
 
 @end deffn
 

-@deffn {Variable} yylval
-External variable in which @code{yylex} should place the semantic
-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}.
+@deffn {Delimiter} :
+Separates a rule's result from its components.  @xref{Rules, ,Syntax of
+Grammar Rules}.

 @end deffn
 
 @end deffn
 

-@deffn {Variable} yylloc
-External variable in which @code{yylex} should place the line and column
-numbers associated with a token.  (In a pure parser, it is a local
-variable within @code{yyparse}, and its address is passed to
-@code{yylex}.)  You can ignore this variable if you don't use the
-@samp{@@} feature in the grammar actions.  @xref{Token Locations,
-,Textual Locations of Tokens}.
+@deffn {Delimiter} ;
+Terminates a rule.  @xref{Rules, ,Syntax of Grammar Rules}.

 @end deffn
 
 @end deffn
 

-@deffn {Variable} yynerrs
-Global variable which Bison increments each time there is a syntax error.
-(In a pure parser, it is a local variable within @code{yyparse}.)
-@xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
+@deffn {Delimiter} |
+Separates alternate rules for the same result nonterminal.
+@xref{Rules, ,Syntax of Grammar Rules}.

 @end deffn
 
 @end deffn
 

-@deffn {Function} yyparse
-The parser function produced by Bison; call this function to start
-parsing.  @xref{Parser Function, ,The Parser Function @code{yyparse}}.
+@deffn {Symbol} $accept
+The predefined nonterminal whose only rule is @samp{$accept: @var{start}
+$end}, where @var{start} is the start symbol.  @xref{Start Decl, , The
+Start-Symbol}.  It cannot be used in the grammar.

 @end deffn
 
 @deffn {Directive} %debug
 @end deffn
 
 @deffn {Directive} %debug


@@ -7144,6 +7050,22 @@ time to resolve reduce/reduce conflicts.  @xref{GLR Parsers, ,Writing
 @acronym{GLR} Parsers}.
 @end deffn
 
 @acronym{GLR} Parsers}.
 @end deffn
 

+@deffn {Symbol} $end
+The predefined token marking the end of the token stream.  It cannot be
+used in the grammar.
+@end deffn
+
+@deffn {Symbol} error
+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
+token @code{error} becomes the current look-ahead token.  Actions
+corresponding to @code{error} are then executed, and the look-ahead
+token is reset to the token that originally caused the violation.
+@xref{Error Recovery}.
+@end deffn
+

 @deffn {Directive} %error-verbose
 Bison declaration to request verbose, specific error message strings
 when @code{yyerror} is called.
 @deffn {Directive} %error-verbose
 Bison declaration to request verbose, specific error message strings
 when @code{yyerror} is called.


@@ -7159,6 +7081,10 @@ Bison declaration to produce a @acronym{GLR} parser.  @xref{GLR
 Parsers, ,Writing @acronym{GLR} Parsers}.
 @end deffn
 
 Parsers, ,Writing @acronym{GLR} Parsers}.
 @end deffn
 

+@deffn {Directive} %initial-action
+Run user code before parsing.  @xref{Initial Action Decl, , Performing Actions before Parsing}.
+@end deffn
+

 @deffn {Directive} %left
 Bison declaration to assign left associativity to token(s).
 @xref{Precedence Decl, ,Operator Precedence}.
 @deffn {Directive} %left
 Bison declaration to assign left associativity to token(s).
 @xref{Precedence Decl, ,Operator Precedence}.


@@ -7245,45 +7171,174 @@ Bison declaration to declare nonterminals.  @xref{Type Decl,
 ,Nonterminal Symbols}.
 @end deffn
 
 ,Nonterminal Symbols}.
 @end deffn
 

+@deffn {Symbol} $undefined
+The predefined token onto which all undefined values returned by
+@code{yylex} are mapped.  It cannot be used in the grammar, rather, use
+@code{error}.
+@end deffn
+

 @deffn {Directive} %union
 Bison declaration to specify several possible data types for semantic
 values.  @xref{Union Decl, ,The Collection of Value Types}.
 @end deffn
 
 @deffn {Directive} %union
 Bison declaration to specify several possible data types for semantic
 values.  @xref{Union Decl, ,The Collection of Value Types}.
 @end deffn
 

-@sp 1
+@deffn {Macro} YYABORT
+Macro to pretend that an unrecoverable syntax error has occurred, by
+making @code{yyparse} return 1 immediately.  The error reporting
+function @code{yyerror} is not called.  @xref{Parser Function, ,The
+Parser Function @code{yyparse}}.
+@end deffn
+
+@deffn {Macro} YYACCEPT
+Macro to pretend that a complete utterance of the language has been
+read, by making @code{yyparse} return 0 immediately.
+@xref{Parser Function, ,The Parser Function @code{yyparse}}.
+@end deffn

 
 

-These are the punctuation and delimiters used in Bison input:
+@deffn {Macro} YYBACKUP
+Macro to discard a value from the parser stack and fake a look-ahead
+token.  @xref{Action Features, ,Special Features for Use in Actions}.
+@end deffn

 
 

-@deffn {Delimiter} %%
-Delimiter used to separate the grammar rule section from the
-Bison declarations section or the epilogue.
-@xref{Grammar Layout, ,The Overall Layout of a Bison Grammar}.
+@deffn {Variable} yychar
+External integer variable that contains the integer value of the current
+look-ahead 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
 
 @end deffn
 

-@c Don't insert spaces, or check the DVI output.
-@deffn {Delimiter} %@{@var{code}%@}
-All code listed between @samp{%@{} and @samp{%@}} is copied directly to
-the output file uninterpreted.  Such code forms the prologue of the input
-file.  @xref{Grammar Outline, ,Outline of a Bison
-Grammar}.
+@deffn {Variable} yyclearin
+Macro used in error-recovery rule actions.  It clears the previous
+look-ahead token.  @xref{Error Recovery}.

 @end deffn
 
 @end deffn
 

-@deffn {Construct} /*@dots{}*/
-Comment delimiters, as in C.
+@deffn {Macro} YYDEBUG
+Macro to define to equip the parser with tracing code.  @xref{Tracing,
+,Tracing Your Parser}.

 @end deffn
 
 @end deffn
 

-@deffn {Delimiter} :
-Separates a rule's result from its components.  @xref{Rules, ,Syntax of
-Grammar Rules}.
+@deffn {Variable} yydebug
+External integer variable set to zero by default.  If @code{yydebug}
+is given a nonzero value, the parser will output information on input
+symbols and parser action.  @xref{Tracing, ,Tracing Your Parser}.

 @end deffn
 
 @end deffn
 

-@deffn {Delimiter} ;
-Terminates a rule.  @xref{Rules, ,Syntax of Grammar Rules}.
+@deffn {Macro} yyerrok
+Macro to cause parser to recover immediately to its normal mode
+after a syntax error.  @xref{Error Recovery}.

 @end deffn
 
 @end deffn
 

-@deffn {Delimiter} |
-Separates alternate rules for the same result nonterminal.
-@xref{Rules, ,Syntax of Grammar Rules}.
+@deffn {Macro} YYERROR
+Macro to pretend that a syntax error has just been detected: call
+@code{yyerror} and then perform normal error recovery if possible
+(@pxref{Error Recovery}), or (if recovery is impossible) make
+@code{yyparse} return 1.  @xref{Error Recovery}.
+@end deffn
+
+@deffn {Function} yyerror
+User-supplied function to be called by @code{yyparse} on error.
+@xref{Error Reporting, ,The Error
+Reporting Function @code{yyerror}}.
+@end deffn
+
+@deffn {Macro} YYERROR_VERBOSE
+An obsolete macro that you define with @code{#define} in the prologue
+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.
+@end deffn
+
+@deffn {Macro} YYINITDEPTH
+Macro for specifying the initial size of the parser stack.
+@xref{Stack Overflow}.
+@end deffn
+
+@deffn {Function} yylex
+User-supplied lexical analyzer function, called with no arguments to get
+the next token.  @xref{Lexical, ,The Lexical Analyzer Function
+@code{yylex}}.
+@end deffn
+
+@deffn {Macro} YYLEX_PARAM
+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}.
+@end deffn
+
+@deffn {Variable} yylloc
+External variable in which @code{yylex} should place the line and column
+numbers associated with a token.  (In a pure parser, it is a local
+variable within @code{yyparse}, and its address is passed to
+@code{yylex}.)  You can ignore this variable if you don't use the
+@samp{@@} feature in the grammar actions.  @xref{Token Locations,
+,Textual Locations of Tokens}.
+@end deffn
+
+@deffn {Type} YYLTYPE
+Data type of @code{yylloc}; by default, a structure with four
+members.  @xref{Location Type, , Data Types of Locations}.
+@end deffn
+
+@deffn {Variable} yylval
+External variable in which @code{yylex} should place the semantic
+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}.
+@end deffn
+
+@deffn {Macro} YYMAXDEPTH
+Macro for specifying the maximum size of the parser stack.  @xref{Stack
+Overflow}.
+@end deffn
+
+@deffn {Variable} yynerrs
+Global variable which Bison increments each time there is a syntax error.
+(In a pure parser, it is a local variable within @code{yyparse}.)
+@xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
+@end deffn
+
+@deffn {Function} yyparse
+The parser function produced by Bison; call this function to start
+parsing.  @xref{Parser Function, ,The Parser Function @code{yyparse}}.
+@end deffn
+
+@deffn {Macro} YYPARSE_PARAM
+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}.
+@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}.
+@end deffn
+
+@deffn {Macro} YYSTACK_USE_ALLOCA
+Macro used to control the use of @code{alloca} when the C
+@acronym{LALR}(1) parser needs to extend its stacks.  If defined to 0,
+the parser will use @code{malloc} to extend its stacks.  If defined to
+1, the parser will use @code{alloca}.  Values other than 0 and 1 are
+reserved for future Bison extensions.  If not defined,
+@code{YYSTACK_USE_ALLOCA} defaults to 0.
+
+If you define @code{YYSTACK_USE_ALLOCA} to 1, it is your
+responsibility to make sure that @code{alloca} is visible, e.g., by
+using @acronym{GCC} or by including @code{<stdlib.h>}.  Furthermore,
+in the all-too-common case where your code may run on a host with a
+limited stack and with unreliable stack-overflow checking, you should
+set @code{YYMAXDEPTH} to a value that cannot possibly result in
+unchecked stack overflow on any of your target hosts when
+@code{alloca} is called.  You can inspect the code that Bison
+generates in order to determine the proper numeric values.  This will
+require some expertise in low-level implementation details.
+@end deffn
+
+@deffn {Type} YYSTYPE
+Data type of semantic values; @code{int} by default.
+@xref{Value Type, ,Data Types of Semantic Values}.

 @end deffn
 
 @node Glossary
 @end deffn
 
 @node Glossary