mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-04-24 10:39:38 +00:00
Akim Demaille
6deb44470e
* src/lex.c (percent_table): Also accept `%yacc', `%fixed_output_files', `%defines', `%no_parser', `%verbose', and `%debug'. Handle the actions for `%semantic_parser' and `%pure_parser' here, instead of returning a token. * src/lex.h (SEMANTIC_PARSER, PURE_PARSER): Remove, unused. * src/reader.c (read_declarations): Adjust. * src/files.c (open_files): Don't call `compute_base_names', don't compute `attrsfile' since they depend upon data which might be *in* the input file now. (output_files): Do it here. * src/output.c (output_headers): Document the fact that this patch introduces a guaranteed SEGV for semantic parsers. * doc/bison.texinfo: Document them. * tests/suite.at: Exercise these %options.
409 lines
18 KiB
Plaintext
409 lines
18 KiB
Plaintext
Ceci est le fichier Info bison.info, produit par Makeinfo version 4.0 à
|
|
partir bison.texinfo.
|
|
|
|
START-INFO-DIR-ENTRY
|
|
* bison: (bison). GNU Project parser generator (yacc replacement).
|
|
END-INFO-DIR-ENTRY
|
|
|
|
This file documents the Bison parser generator.
|
|
|
|
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1998, 1999,
|
|
2000 Free Software Foundation, Inc.
|
|
|
|
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: Table of 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::.
|
|
|
|
Literal string token
|
|
A token which consists of two or more fixed characters. *Note
|
|
Symbols::.
|
|
|
|
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::.
|
|
|
|
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 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.
|
|
* 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.
|
|
* BISON_HAIRY: Environment Variables.
|
|
* BISON_SIMPLE: Environment Variables.
|
|
* BNF: Language and Grammar.
|
|
* C code, section for additional: C Code.
|
|
* C declarations section: C Declarations.
|
|
* C-language interface: Interface.
|
|
* calc: Infix Calc.
|
|
* 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 literal string tokens: Token Decl.
|
|
* declaring operator precedence: Precedence Decl.
|
|
* declaring the start symbol: Start 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.
|
|
* else, dangling: Shift/Reduce.
|
|
* environment variables: Environment Variables.
|
|
* 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.
|
|
* mfcalc: Multi-function Calc.
|
|
* mid-rule actions: Mid-Rule Actions.
|
|
* multi-function calculator: Multi-function Calc.
|
|
* multicharacter 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.
|
|
* rpcalc: RPN Calc.
|
|
* 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.
|
|
* syntactic grouping: Language and Grammar.
|
|
* syntax error: Error Reporting.
|
|
* syntax of grammar rules: Rules.
|
|
* terminal symbol: Symbols.
|
|
* 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.
|
|
* YYLEX_PARAM: Pure Calling.
|
|
* yylloc: Token Positions.
|
|
* YYLTYPE: Token Positions.
|
|
* yylval: Token Values.
|
|
* YYMAXDEPTH: Stack Overflow.
|
|
* yynerrs: Error Reporting.
|
|
* yyparse: Parser Function.
|
|
* YYPARSE_PARAM: Pure Calling.
|
|
* YYPRINT: Debugging.
|
|
* YYRECOVERING: Error Recovery.
|
|
* |: Rules.
|
|
|
|
|