Table of Symbols
Previous: <Invocation=>Invocation> * Next: <Glossary=>Glossary> * Up: <Top=>!Root>

#Wrap on
{fH2}Bison Symbols{f}

#Indent +4
#Indent
{fCode}error{f}
#Indent +4
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 parse error, the
token {fCode}error{f} becomes the current look-ahead token.  Actions
corresponding to {fCode}error{f} are then executed, and the look-ahead
token is reset to the token that originally caused the violation.
\*Note <Error Recovery=>ErrorRecov>.

#Indent
{fCode}YYABORT{f}
#Indent +4
Macro to pretend that an unrecoverable syntax error has occurred, by
making {fCode}yyparse{f} return 1 immediately.  The error reporting
function {fCode}yyerror{f} is not called.  \*Note <Parser Function=>ParserFunc>: The Parser Function {fCode}yyparse{f}.

#Indent
{fCode}YYACCEPT{f}
#Indent +4
Macro to pretend that a complete utterance of the language has been
read, by making {fCode}yyparse{f} return 0 immediately.  
\*Note <Parser Function=>ParserFunc>: The Parser Function {fCode}yyparse{f}.

#Indent
{fCode}YYBACKUP{f}
#Indent +4
Macro to discard a value from the parser stack and fake a look-ahead
token.  \*Note <Action Features=>ActionFeat>: Special Features for Use in Actions.

#Indent
{fCode}YYERROR{f}
#Indent +4
Macro to pretend that a syntax error has just been detected: call
{fCode}yyerror{f} and then perform normal error recovery if possible
(\*Note <Error Recovery=>ErrorRecov>), or (if recovery is impossible) make
{fCode}yyparse{f} return 1.  \*Note <Error Recovery=>ErrorRecov>.

#Indent
{fCode}YYERROR\_VERBOSE{f}
#Indent +4
Macro that you define with {fCode}\#define{f} in the Bison declarations
section to request verbose, specific error message strings when
{fCode}yyerror{f} is called.

#Indent
{fCode}YYINITDEPTH{f}
#Indent +4
Macro for specifying the initial size of the parser stack.
\*Note <Stack Overflow=>StackOverf>.

#Indent
{fCode}YYLEX\_PARAM{f}
#Indent +4
Macro for specifying an extra argument (or list of extra arguments) for
{fCode}yyparse{f} to pass to {fCode}yylex{f}.  \*Note <Pure Calling=>PureCallin>: Calling Conventions for Pure Parsers.

#Indent
{fCode}YYLTYPE{f}
#Indent +4
Macro for the data type of {fCode}yylloc{f}; a structure with four
members.  \*Note <Token Positions=>TokenPosit>: Textual Positions of Tokens.

#Indent
{fCode}YYMAXDEPTH{f}
#Indent +4
Macro for specifying the maximum size of the parser stack.
\*Note <Stack Overflow=>StackOverf>.

#Indent
{fCode}YYPARSE\_PARAM{f}
#Indent +4
Macro for specifying the name of a parameter that {fCode}yyparse{f} should
accept.  \*Note <Pure Calling=>PureCallin>: Calling Conventions for Pure Parsers.

#Indent
{fCode}YYRECOVERING{f}
#Indent +4
Macro whose value indicates whether the parser is recovering from a
syntax error.  \*Note <Action Features=>ActionFeat>: Special Features for Use in Actions.

#Indent
{fCode}YYSTYPE{f}
#Indent +4
Macro for the data type of semantic values; {fCode}int{f} by default.
\*Note <Value Type=>ValueType>: Data Types of Semantic Values.

#Indent
{fCode}yychar{f}
#Indent +4
External integer variable that contains the integer value of the
current look-ahead token.  (In a pure parser, it is a local variable
within {fCode}yyparse{f}.)  Error-recovery rule actions may examine this
variable.  \*Note <Action Features=>ActionFeat>: Special Features for Use in Actions.

#Indent
{fCode}yyclearin{f}
#Indent +4
Macro used in error-recovery rule actions.  It clears the previous
look-ahead token.  \*Note <Error Recovery=>ErrorRecov>.

#Indent
{fCode}yydebug{f}
#Indent +4
External integer variable set to zero by default.  If {fCode}yydebug{f}
is given a nonzero value, the parser will output information on input
symbols and parser action.  \*Note <Debugging=>Debugging>: Debugging Your Parser.

#Indent
{fCode}yyerrok{f}
#Indent +4
Macro to cause parser to recover immediately to its normal mode
after a parse error.  \*Note <Error Recovery=>ErrorRecov>.

#Indent
{fCode}yyerror{f}
#Indent +4
User-supplied function to be called by {fCode}yyparse{f} on error.  The
function receives one argument, a pointer to a character string
containing an error message.  \*Note <Error Reporting=>ErrorRepor>: The Error Reporting Function {fCode}yyerror{f}.

#Indent
{fCode}yylex{f}
#Indent +4
User-supplied lexical analyzer function, called with no arguments
to get the next token.  \*Note <Lexical=>Lexical>: The Lexical Analyzer Function {fCode}yylex{f}.

#Indent
{fCode}yylval{f}
#Indent +4
External variable in which {fCode}yylex{f} should place the semantic
value associated with a token.  (In a pure parser, it is a local
variable within {fCode}yyparse{f}, and its address is passed to
{fCode}yylex{f}.)  \*Note <Token Values=>TokenValue>: Semantic Values of Tokens.

#Indent
{fCode}yylloc{f}
#Indent +4
External variable in which {fCode}yylex{f} should place the line and
column numbers associated with a token.  (In a pure parser, it is a
local variable within {fCode}yyparse{f}, and its address is passed to
{fCode}yylex{f}.)  You can ignore this variable if you don't use the
{fEmphasis}@{f} feature in the grammar actions.  \*Note <Token Positions=>TokenPosit>: Textual Positions of Tokens.

#Indent
{fCode}yynerrs{f}
#Indent +4
Global variable which Bison increments each time there is a parse
error.  (In a pure parser, it is a local variable within
{fCode}yyparse{f}.)  \*Note <Error Reporting=>ErrorRepor>: The Error Reporting Function {fCode}yyerror{f}.

#Indent
{fCode}yyparse{f}
#Indent +4
The parser function produced by Bison; call this function to start
parsing.  \*Note <Parser Function=>ParserFunc>: The Parser Function {fCode}yyparse{f}.

#Indent
{fCode}%left{f}
#Indent +4
Bison declaration to assign left associativity to token(s).
\*Note <Precedence Decl=>Precedence>: Operator Precedence.

#Indent
{fCode}%nonassoc{f}
#Indent +4
Bison declaration to assign nonassociativity to token(s).
\*Note <Precedence Decl=>Precedence>: Operator Precedence.

#Indent
{fCode}%prec{f}
#Indent +4
Bison declaration to assign a precedence to a specific rule.
\*Note <Contextual Precedence=>Contextual>: Context-Dependent Precedence.

#Indent
{fCode}%pure\_parser{f}
#Indent +4
Bison declaration to request a pure (reentrant) parser.
\*Note <Pure Decl=>PureDecl>: A Pure (Reentrant) Parser.

#Indent
{fCode}%right{f}
#Indent +4
Bison declaration to assign right associativity to token(s).
\*Note <Precedence Decl=>Precedence>: Operator Precedence.

#Indent
{fCode}%start{f}
#Indent +4
Bison declaration to specify the start symbol.  \*Note <Start Decl=>StartDecl>: The Start-Symbol.

#Indent
{fCode}%token{f}
#Indent +4
Bison declaration to declare token(s) without specifying precedence.
\*Note <Token Decl=>TokenDecl>: Token Type Names.

#Indent
{fCode}%type{f}
#Indent +4
Bison declaration to declare nonterminals.  \*Note <Type Decl=>TypeDecl>: Nonterminal Symbols.

#Indent
{fCode}%union{f}
#Indent +4
Bison declaration to specify several possible data types for semantic
values.  \*Note <Union Decl=>UnionDecl>: The Collection of Value Types.

#Indent

These are the punctuation and delimiters used in Bison input:

#Indent +4
#Indent
{fEmphasis}%%{f}
#Indent +4
Delimiter used to separate the grammar rule section from the
Bison declarations section or the additional C code section.
\*Note <Grammar Layout=>GrammarLay>: The Overall Layout of a Bison Grammar.

#Indent
{fEmphasis}%\{ %\}{f}
#Indent +4
All code listed between {fEmphasis}%\{{f} and {fEmphasis}%\}{f} is copied directly
to the output file uninterpreted.  Such code forms the ``C
declarations'' section of the input file.  \*Note <Grammar Outline=>GrammarOut>: Outline of a Bison Grammar.

#Indent
{fEmphasis}\/\*\*\/{f}
#Indent +4
Comment delimiters, as in C.

#Indent
{fEmphasis}:{f}
#Indent +4
Separates a rule's result from its components.  \*Note <Rules=>Rules>: Syntax of Grammar Rules.

#Indent
{fEmphasis};{f}
#Indent +4
Terminates a rule.  \*Note <Rules=>Rules>: Syntax of Grammar Rules.

#Indent
{fEmphasis}|{f}
#Indent +4
Separates alternate rules for the same result nonterminal.
\*Note <Rules=>Rules>: Syntax of Grammar Rules.

#Indent

