- Introduction: 
- Conditions: 
- Copying:            The GNU General Public License says
                        how you can copy and share Bison
Tutorial sections:
 
- Concepts:           Basic concepts for understanding Bison. 
- Examples:           Three simple explained examples of using Bison.
Reference sections:
 
- Grammar File:       Writing Bison declarations and rules. 
- Interface:          C-language interface to the parser function yyparse.
- Algorithm:          How the Bison parser works at run-time. 
- Error Recovery:     Writing rules for error recovery. 
- Context Dependency:   What to do if your language syntax is too
                        messy for Bison to handle straightforwardly. 
- Debugging:          Debugging Bison parsers that parse wrong. 
- Invocation:         How to run Bison (to produce the parser source file). 
- Table of Symbols:   All the keywords of the Bison language are explained. 
- Glossary:           Basic concepts are explained. 
- Copying This Manual:   License for copying this manual. 
- Index:              Cross-references to the text.
The Concepts of Bison
 
- Language and Grammar:   Languages and context-free grammars,
                            as mathematical ideas. 
- Grammar in Bison:   How we represent grammars for Bison's sake. 
- Semantic Values:    Each token or syntactic grouping can have
                        a semantic value (the value of an integer,
                        the name of an identifier, etc.). 
- Semantic Actions:   Each rule can have an action containing C code. 
- Bison Parser:       What are Bison's input and output,
                        how is the output used? 
- Stages:             Stages in writing and running Bison grammars. 
- Grammar Layout:     Overall structure of a Bison grammar file.
Examples
 
- RPN Calc:           Reverse polish notation calculator;
                        a first example with no operator precedence. 
- Infix Calc:         Infix (algebraic) notation calculator. 
                        Operator precedence is introduced. 
- Simple Error Recovery:   Continuing after syntax errors. 
- Location Tracking Calc:  Demonstrating the use of @n and @$. 
- Multi-function Calc:     Calculator with memory and trig functions. 
                        It uses multiple data-types for semantic values. 
- Exercises:          Ideas for improving the multi-function calculator.
Reverse Polish Notation Calculator
 
- Decls:   Bison and C declarations for rpcalc. 
- Rules:   Grammar Rules for rpcalc, with explanation. 
- Lexer:   The lexical analyzer. 
- Main:     The controlling function. 
- Error:   The error reporting function. 
- Gen:       Running Bison on the grammar file. 
- Comp:  Run the C compiler on the output code.
Grammar Rules for rpcalc
 
- Rpcalc Input: 
- Rpcalc Line: 
- Rpcalc Expr:
Location Tracking Calculator: ltcalc
 
- Decls:   Bison and C declarations for ltcalc. 
- Rules:   Grammar rules for ltcalc, with explanations. 
- Lexer:   The lexical analyzer.
Multi-Function Calculator: mfcalc
 
- Decl:       Bison declarations for multi-function calculator. 
- Rules:     Grammar rules for the calculator. 
- Symtab:   Symbol table management subroutines.
Bison Grammar Files
 
- Grammar Outline:    Overall layout of the grammar file. 
- Symbols:            Terminal and nonterminal symbols. 
- Rules:              How to write grammar rules. 
- Recursion:          Writing recursive rules. 
- Semantics:          Semantic values and actions. 
- Declarations:       All kinds of Bison declarations are described here. 
- Multiple Parsers:   Putting more than one Bison parser in one program.
Outline of a Bison Grammar
 
- C Declarations:     Syntax and usage of the C declarations section. 
- Bison Declarations:   Syntax and usage of the Bison declarations section. 
- Grammar Rules:      Syntax and usage of the grammar rules section. 
- C Code:             Syntax and usage of the additional C code section.
Defining Language Semantics
 
- Value Type:         Specifying one data type for all semantic values. 
- Multiple Types:     Specifying several alternative data types. 
- Actions:            An action is the semantic definition of a grammar rule. 
- Action Types:       Specifying data types for actions to operate on. 
- Mid-Rule Actions:   Most actions go at the end of a rule. 
                      This says when, why and how to use the exceptional
                        action in the middle of a rule.
Bison Declarations
 
- Token Decl:         Declaring terminal symbols. 
- 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. 
- Expect Decl:        Suppressing warnings about shift/reduce conflicts. 
- Start Decl:         Specifying the start symbol. 
- Pure Decl:          Requesting a reentrant parser. 
- Decl Summary:       Table of all Bison declarations.
Parser C-Language Interface
 
- Parser Function:    How to call yyparseand what it returns.
- Lexical:            You must supply a function yylexwhich reads tokens.
- Error Reporting:    You must supply a function yyerror.
- Action Features:    Special features for use in actions.
The Lexical Analyzer Function yylex
 
- Calling Convention:   How yyparsecallsyylex.
- Token Values:       How yylexmust return the semantic value
                        of the token it has read.
- Token Positions:    How yylexmust return the text position
                        (line number, etc.) of the token, if the
                         actions want that.
- Pure Calling:       How the calling convention differs
                        in a pure parser (see A Pure (Reentrant) Parser).
The Bison Parser Algorithm
 
- Look-Ahead:         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. 
- Parser States:      The parser is a finite-state-machine with stack. 
- Reduce/Reduce:      When two rules are applicable in the same situation. 
- Mystery Conflicts:   Reduce/reduce conflicts that look unjustified. 
- Stack Overflow:     What happens when stack gets full.  How to avoid it.
Operator Precedence
 
- Why Precedence:     An example showing why precedence is needed. 
- Using Precedence:   How to specify precedence in Bison grammars. 
- Precedence Examples:   How these features are used in the previous example. 
- How Precedence:     How they work.
Handling Context Dependencies
 
- Semantic Tokens:    Token parsing can depend on the semantic context. 
- Lexical Tie-ins:    Token parsing can depend on the syntactic context. 
- Tie-in Recovery:    Lexical tie-ins have implications for how
                        error recovery rules must be written.
Invoking Bison
 
- Bison Options:      All the options described in detail,
			in alphabetical order by short options. 
- Option Cross Key:   Alphabetical list of long options. 
- Extension Limitations Under DOS:   Bison output files extension differences
					depending on the DOS/Windows file system flavour used. 
- VMS Invocation:     Bison command syntax on VMS.
Copying This Manual
 
- GNU Free Documentation License:   License for copying this manual.