gnu1987/bison-1.22-A2.3/bison-A2.3/bison.info-5

This is Info file bison.info, produced by Makeinfo-1.55 from the input
file bison.texinfo.

   This file documents the Bison parser generator.

   Copyright (C) 1988, 1989, 1990, 1991, 1992 Free Software Foundation,
Inc.  Modified (1993) from bison-1.22 by 			Wilfred J. Hansen
(wjh+@cmu.edu), 			Andrew Consortium, Carnegie Mellon University

   CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and "Conditions
for Using Bison" are included exactly as in the original, and provided
that the entire resulting derived work is distributed under the terms
of a permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License", "Conditions for Using Bison" and this permission notice may be
included in translations approved by the Free Software Foundation
instead of in the original English.


File: bison.info,  Node: Glossary,  Next: Index,  Prev: Parser Symbols,  Up: Top

Glossary
********

Backus-Naur Form (BNF)
     Formal method of specifying context-free grammars.  BNF was first
     used in the `ALGOL-60' report, 1963.  *Note Languages and
     Context-Free Grammars: Language and Grammar.

Context-free grammars
     Grammars specified as rules that can be applied regardless of
     context.  Thus, if there is a rule which says that an integer can
     be used as an expression, integers are allowed *anywhere* an
     expression is permitted.  *Note Languages and Context-Free
     Grammars: Language and Grammar.

Dynamic allocation
     Allocation of memory that occurs during execution, rather than at
     compile time or on entry to a function.

Empty string
     Analogous to the empty set in set theory, the empty string is a
     character string of length zero.

Finite-state stack machine
     A "machine" that has discrete states in which it is said to exist
     at each instant in time.  As input to the machine is processed, the
     machine moves from state to state as specified by the logic of the
     machine.  In the case of the parser, the input is the language
     being parsed, and the states correspond to various stages in the
     grammar rules.  *Note The Bison Parser Algorithm: Algorithm.

Grouping
     A language construct that is (in general) grammatically divisible;
     for example, `expression' or `declaration' in C.  *Note Languages
     and Context-Free Grammars: Language and Grammar.

Infix operator
     An arithmetic operator that is placed between the operands on
     which it performs some operation.

Input stream
     A continuous flow of data between devices or programs.

Language construct
     One of the typical usage schemas of the language.  For example,
     one of the constructs of the C language is the `if' statement.
     *Note Languages and Context-Free Grammars: Language and Grammar.

Left associativity
     Operators having left associativity are analyzed from left to
     right: `a+b+c' first computes `a+b' and then combines with `c'.
     *Note Operator Precedence: Precedence.

Left recursion
     A rule whose result symbol is also its first component symbol; for
     example, `expseq1 : expseq1 ',' exp;'.  *Note Recursive Rules:
     Recursion.

Left-to-right parsing
     Parsing a sentence of a language by analyzing it token by token
     from left to right.  *Note The Bison Parser Algorithm: Algorithm.

Lexical analyzer (scanner)
     A function that reads an input stream and returns tokens one by
     one.  *Note The Lexical Analyzer Function `yylex': Lexical.

Lexical tie-in
     A flag, set by actions in the grammar rules, which alters the way
     tokens are parsed.  *Note Lexical Tie-ins::.

Look-ahead token
     A token already read but not yet shifted.  *Note Look-Ahead
     Tokens: Look-Ahead.

LALR(1)
     The class of context-free grammars that Bison (like most other
     parser generators) can handle; a subset of LR(1).  *Note
     Mysterious Reduce/Reduce Conflicts: Mystery Conflicts.

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.

Nonterminal symbol
     A grammar symbol standing for a grammatical construct that can be
     expressed through rules in terms of smaller constructs; in other
     words, a construct that is not a token.  *Note Symbols - Terminal
     and Nonterminal: Symbols.

Parse error
     An error encountered during parsing of an input stream due to
     invalid syntax.  *Note Error Recovery::.

Parser
     A function that recognizes valid sentences of a language by
     analyzing the syntax structure of a set of tokens passed to it
     from a lexical analyzer.

Postfix operator
     An arithmetic operator that is placed after the operands upon
     which it performs some operation.

Reduction
     Replacing a string of nonterminals and/or terminals with a single
     nonterminal, according to a grammar rule.  *Note The Bison Parser
     Algorithm: Algorithm.

Reentrant
     A reentrant subprogram is a subprogram which can be in invoked any
     number of times in parallel, without interference between the
     various invocations.  *Note A Pure (Reentrant) Parser: Pure Decl.

Reverse polish notation
     A language in which all operators are postfix operators.

Right recursion
     A rule whose result symbol is also its last component symbol; for
     example, `expseq1: exp ',' expseq1;'.  *Note Recursive Rules:
     Recursion.

Semantics
     In computer languages, the semantics are specified by the actions
     taken for each instance of the language, i.e., the meaning of each
     statement.  *Note Defining Language Semantics: Semantics.

Shift
     A parser is said to shift when it makes the choice of analyzing
     further input from the stream rather than reducing immediately some
     already-recognized rule.  *Note The Bison Parser Algorithm:
     Algorithm.

Single-character literal
     A single character that is recognized and interpreted as is.
     *Note From Formal Rules to Bison Input: Grammar in Bison.

Start symbol
     The nonterminal symbol that stands for a complete valid utterance
     in the language being parsed.  The start symbol is usually listed
     as the first nonterminal symbol in a language specification.
     *Note The Start-Symbol: Start Decl.

Symbol table
     A data structure where symbol names and associated data are stored
     during parsing to allow for recognition and use of existing
     information in repeated uses of a symbol.  *Note Multi-function
     Calc::.

Token
     A basic, grammatically indivisible unit of a language.  The symbol
     that describes a token in the grammar is a terminal symbol.  The
     input of the Bison parser is a stream of tokens which comes from
     the lexical analyzer.  *Note Symbols - Terminal and Nonterminal:
     Symbols.

Terminal symbol
     A grammar symbol that has no rules in the grammar and therefore is
     grammatically indivisible.  The piece of text it represents is a
     token.  *Note Languages and Context-Free Grammars: Language and
     Grammar.


File: bison.info,  Node: Index,  Prev: Glossary,  Up: Top

Index
*****

* Menu:

* $$:                                   Actions.
* $N:                                   Actions.
* %expect:                              Expect Decl.
* %left:                                Using Precedence.
* %nonassoc:                            Using Precedence.
* %prec:                                Contextual Precedence.
* %pure_parser:                         Pure Decl.
* %right:                               Using Precedence.
* %start:                               Start Decl.
* %token:                               Token Decl.
* %type:                                Type Decl.
* %union:                               Union Decl.
* @N:                                   Action Features.
* calc:                                 Infix Calc.
* else, dangling:                       Shift/Reduce.
* mfcalc:                               Multi-function Calc.
* rpcalc:                               RPN Calc.
* action:                               Actions.
* action data types:                    Action Types.
* action features summary:              Action Features.
* actions in mid-rule:                  Mid-Rule Actions.
* actions, semantic:                    Semantic Actions.
* additional C code section:            C Code.
* algorithm of parser:                  Algorithm.
* associativity:                        Why Precedence.
* Backus-Naur form:                     Language and Grammar.
* Bison declaration summary:            Decl Summary.
* Bison declarations:                   Declarations.
* Bison declarations (introduction):    Bison Declarations.
* Bison grammar:                        Grammar in Bison.
* Bison invocation:                     Invocation.
* Bison parser:                         Bison Parser.
* Bison parser algorithm:               Algorithm.
* Bison symbols, table of:              Table of Symbols.
* Bison utility:                        Bison Parser.
* BNF:                                  Language and Grammar.
* C code, section for additional:       C Code.
* C declarations section:               C Declarations.
* C-language interface:                 Interface.
* calculator, infix notation:           Infix Calc.
* calculator, multi-function:           Multi-function Calc.
* calculator, simple:                   RPN Calc.
* character token:                      Symbols.
* compiling the parser:                 Rpcalc Compile.
* conflicts:                            Shift/Reduce.
* conflicts, reduce/reduce:             Reduce/Reduce.
* conflicts, suppressing warnings of:   Expect Decl.
* context-dependent precedence:         Contextual Precedence.
* context-free grammar:                 Language and Grammar.
* controlling function:                 Rpcalc Main.
* dangling else:                        Shift/Reduce.
* data types in actions:                Action Types.
* data types of semantic values:        Value Type.
* debugging:                            Debugging.
* declaration summary:                  Decl Summary.
* declarations, Bison:                  Declarations.
* declarations, Bison (introduction):   Bison Declarations.
* declarations, C:                      C Declarations.
* declaring operator precedence:        Precedence Decl.
* declaring string literal tokens:      Thong Decl.
* declaring the start symbol:           Start Decl.
* declaring thongs:                     Thong Decl.
* declaring token type names:           Token Decl.
* declaring value types:                Union Decl.
* declaring value types, nonterminals:  Type Decl.
* default action:                       Actions.
* default data type:                    Value Type.
* default stack limit:                  Stack Overflow.
* default start symbol:                 Start Decl.
* defining language semantics:          Semantics.
* error:                                Error Recovery.
* error recovery:                       Error Recovery.
* error recovery, simple:               Simple Error Recovery.
* error reporting function:             Error Reporting.
* error reporting routine:              Rpcalc Error.
* examples, simple:                     Examples.
* exercises:                            Exercises.
* file format:                          Grammar Layout.
* finite-state machine:                 Parser States.
* formal grammar:                       Grammar in Bison.
* format of grammar file:               Grammar Layout.
* glossary:                             Glossary.
* grammar file:                         Grammar Layout.
* grammar rule syntax:                  Rules.
* grammar rules section:                Grammar Rules.
* grammar, Bison:                       Grammar in Bison.
* grammar, context-free:                Language and Grammar.
* grouping, syntactic:                  Language and Grammar.
* infix notation calculator:            Infix Calc.
* interface:                            Interface.
* introduction:                         Introduction.
* invoking Bison:                       Invocation.
* invoking Bison under VMS:             VMS Invocation.
* LALR(1):                              Mystery Conflicts.
* language semantics, defining:         Semantics.
* layout of Bison grammar:              Grammar Layout.
* left recursion:                       Recursion.
* lexical analyzer:                     Lexical.
* lexical analyzer, purpose:            Bison Parser.
* lexical analyzer, writing:            Rpcalc Lexer.
* lexical tie-in:                       Lexical Tie-ins.
* literal string token:                 Symbols.
* literal token:                        Symbols.
* look-ahead token:                     Look-Ahead.
* LR(1):                                Mystery Conflicts.
* main function in simple example:      Rpcalc Main.
* mid-rule actions:                     Mid-Rule Actions.
* multi-character terminal symbols:     Thong Decl.
* multi-function calculator:            Multi-function Calc.
* multiple-character literal:           Symbols.
* mutual recursion:                     Recursion.
* nonterminal symbol:                   Symbols.
* operator precedence:                  Precedence.
* operator precedence, declaring:       Precedence Decl.
* options for invoking Bison:           Invocation.
* overflow of parser stack:             Stack Overflow.
* parse error:                          Error Reporting.
* parser:                               Bison Parser.
* parser stack:                         Algorithm.
* parser stack overflow:                Stack Overflow.
* parser state:                         Parser States.
* polish notation calculator:           RPN Calc.
* precedence declarations:              Precedence Decl.
* precedence of operators:              Precedence.
* precedence, context-dependent:        Contextual Precedence.
* precedence, unary operator:           Contextual Precedence.
* preventing warnings about conflicts:  Expect Decl.
* pure parser:                          Pure Decl.
* recovery from errors:                 Error Recovery.
* recursive rule:                       Recursion.
* reduce/reduce conflict:               Reduce/Reduce.
* reduction:                            Algorithm.
* reentrant parser:                     Pure Decl.
* reverse polish notation:              RPN Calc.
* right recursion:                      Recursion.
* rule syntax:                          Rules.
* rules section for grammar:            Grammar Rules.
* running Bison (introduction):         Rpcalc Gen.
* semantic actions:                     Semantic Actions.
* semantic value:                       Semantic Values.
* semantic value type:                  Value Type.
* shift/reduce conflicts:               Shift/Reduce.
* shifting:                             Algorithm.
* simple examples:                      Examples.
* single-character literal:             Symbols.
* stack overflow:                       Stack Overflow.
* stack, parser:                        Algorithm.
* stages in using Bison:                Stages.
* start symbol:                         Language and Grammar.
* start symbol, declaring:              Start Decl.
* state (of parser):                    Parser States.
* string token:                         Symbols.
* summary, action features:             Action Features.
* summary, Bison declaration:           Decl Summary.
* suppressing conflict warnings:        Expect Decl.
* symbol:                               Symbols.
* symbol table example:                 Mfcalc Symtab.
* symbols (abstract):                   Language and Grammar.
* symbols in Bison, table of:           Table of Symbols.
* symbols, parser:                      Parser Symbols.
* syntactic grouping:                   Language and Grammar.
* syntax error:                         Error Reporting.
* syntax of grammar rules:              Rules.
* terminal symbol:                      Symbols.
* thong declarations:                   Thong Decl.
* token:                                Language and Grammar.
* token type:                           Symbols.
* token type names, declaring:          Token Decl.
* tracing the parser:                   Debugging.
* unary operator precedence:            Contextual Precedence.
* using Bison:                          Stages.
* value type, semantic:                 Value Type.
* value types, declaring:               Union Decl.
* value types, nonterminals, declaring: Type Decl.
* value, semantic:                      Semantic Values.
* VMS:                                  VMS Invocation.
* warnings, preventing:                 Expect Decl.
* writing a lexical analyzer:           Rpcalc Lexer.
* YYABORT:                              Parser Function.
* YYACCEPT:                             Parser Function.
* YYBACKUP:                             Action Features.
* yychar:                               Look-Ahead.
* yyclearin:                            Error Recovery.
* YYDEBUG:                              Debugging.
* yydebug:                              Debugging.
* YYEMPTY:                              Action Features.
* yyerrok:                              Error Recovery.
* YYERROR:                              Action Features.
* yyerror:                              Error Reporting.
* YYERROR_VERBOSE:                      Error Reporting.
* YYINITDEPTH:                          Stack Overflow.
* yylex:                                Lexical.
* yylloc:                               Token Positions.
* YYLTYPE:                              Token Positions.
* yylval:                               Token Values.
* YYMAXDEPTH:                           Stack Overflow.
* yynerrs:                              Error Reporting.
* yyparse:                              Parser Function.
* YYPRINT:                              Debugging.
* YYRECOVERING:                         Error Recovery.
* |:                                    Rules.