(bison.info)Table of Symbols


Next: Glossary Prev: Invocation Up: Top

Bison Symbols
*************

`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
     parse error, the token `error' becomes the current look-ahead
     token.  Actions corresponding to `error' are then executed, and
     the look-ahead token is reset to the token that originally caused
     the violation.  Note: Error Recovery.

`YYABORT'
     Macro to pretend that an unrecoverable syntax error has occurred,
     by making `yyparse' return 1 immediately.  The error reporting
     function `yyerror' is not called.  Note: The Parser Function
     `yyparse'.

`YYACCEPT'
     Macro to pretend that a complete utterance of the language has been
     read, by making `yyparse' return 0 immediately.  Note: The Parser
     Function `yyparse'.

`YYBACKUP'
     Macro to discard a value from the parser stack and fake a
     look-ahead token.  *Note Special Features for Use in Actions:
     Action Features.

`YYERROR'
     Macro to pretend that a syntax error has just been detected: call
     `yyerror' and then perform normal error recovery if possible
     (Note: Error Recovery.), or (if recovery is impossible) make
     `yyparse' return 1.  Note: Error Recovery.

`YYERROR_VERBOSE'
     Macro that you define with `#define' in the Bison declarations
     section to request verbose, specific error message strings when
     `yyerror' is called.

`YYINITDEPTH'
     Macro for specifying the initial size of the parser stack.  *Note
     Stack Overflow::.

`YYLTYPE'
     Macro for the data type of `yylloc'; a structure with four
     members.  Note: Textual Positions of Tokens.

`YYMAXDEPTH'
     Macro for specifying the maximum size of the parser stack.  *Note
     Stack Overflow::.

`YYRECOVERING'
     Macro whose value indicates whether the parser is recovering from a
     syntax error.  Note: Special Features for Use in Actions
     Features.

`YYSTYPE'
     Macro for the data type of semantic values; `int' by default.
     Note: Data Types of Semantic Values.

`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 `yyparse'.)  Error-recovery rule actions may
     examine this variable.  *Note Special Features for Use in Actions:
     Action Features.

`yyclearin'
     Macro used in error-recovery rule actions.  It clears the previous
     look-ahead token.  Note: Error Recovery.

`yydebug'
     External integer variable set to zero by default.  If `yydebug' is
     given a nonzero value, the parser will output information on input
     symbols and parser action.  Note: Debugging Your Parser.

`yyerrok'
     Macro to cause parser to recover immediately to its normal mode
     after a parse error.  Note: Error Recovery.

`yyerror'
     User-supplied function to be called by `yyparse' on error.  The
     function receives one argument, a pointer to a character string
     containing an error message.  Note: The Error Reporting Function
     `yyerror'.

`yylex'
     User-supplied lexical analyzer function, called with no arguments
     to get the next token.  Note: The Lexical Analyzer Function
     `yylex'.

`yylval'
     External variable in which `yylex' should place the semantic value
     associated with a token.  (In a pure parser, it is a local
     variable within `yyparse', and its address is passed to `yylex'.)
     Note: Semantic Values of Tokens.

`yylloc'
     External variable in which `yylex' should place the line and
     column numbers associated with a token.  (In a pure parser, it is a
     local variable within `yyparse', and its address is passed to
     `yylex'.)  You can ignore this variable if you don't use the `@'
     feature in the grammar actions.  Note: Textual Positions of
     Tokens.

`yynerrs'
     Global variable which Bison increments each time there is a parse
     error.  (In a pure parser, it is a local variable within
     `yyparse'.)  Note: The Error Reporting Function `yyerror'
     Reporting.

`yyparse'
     The parser function produced by Bison; call this function to start
     parsing.  Note: The Parser Function `yyparse'.

`%left'
     Bison declaration to assign left associativity to token(s).  *Note
     Operator Precedence: Precedence Decl.

`%nonassoc'
     Bison declaration to assign nonassociativity to token(s).  *Note
     Operator Precedence: Precedence Decl.

`%prec'
     Bison declaration to assign a precedence to a specific rule.
     Note: Context-Dependent Precedence.

`%pure_parser'
     Bison declaration to request a pure (reentrant) parser.  Note: A
     Pure (Reentrant) Parser.

`%right'
     Bison declaration to assign right associativity to token(s).
     Note: Operator Precedence.

`%start'
     Bison declaration to specify the start symbol.  Note: The
     Start-Symbol.

`%token'
     Bison declaration to declare token(s) without specifying
     precedence.  Note: Token Type Names.

`%type'
     Bison declaration to declare nonterminals.  Note: Nonterminal
     Symbols.

`%union'
     Bison declaration to specify several possible data types for
     semantic values.  Note: The Collection of Value Types.

   These are the punctuation and delimiters used in Bison input:

`%%'
     Delimiter used to separate the grammar rule section from the Bison
     declarations section or the additional C code section.  Note: The
     Overall Layout of a Bison Grammar.

`%{ %}'
     All code listed between `%{' and `%}' is copied directly to the
     output file uninterpreted.  Such code forms the "C declarations"
     section of the input file.  *Note Outline of a Bison Grammar:
     Grammar Outline.

`/*...*/'
     Comment delimiters, as in C.

`:'
     Separates a rule's result from its components.  Note: Syntax of
     Grammar Rules.

`;'
     Terminates a rule.  Note: Syntax of Grammar Rules.

`|'
     Separates alternate rules for the same result nonterminal.  *Note
     Syntax of Grammar Rules: Rules.


automatically generated by info2www