doc/bison.info-5

   1 Ceci est le fichier Info bison.info, produit par Makeinfo version 4.0 à
   2 partir bison.texinfo.
   3
   4 START-INFO-DIR-ENTRY
   5 * bison: (bison).       GNU Project parser generator (yacc replacement).
   6 END-INFO-DIR-ENTRY
   7
   8    This file documents the Bison parser generator.
   9
  10    Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1998, 1999,
  11 2000 Free Software Foundation, Inc.
  12
  13    Permission is granted to make and distribute verbatim copies of this
  14 manual provided the copyright notice and this permission notice are
  15 preserved on all copies.
  16
  17    Permission is granted to copy and distribute modified versions of
  18 this manual under the conditions for verbatim copying, provided also
  19 that the sections entitled "GNU General Public License" and "Conditions
  20 for Using Bison" are included exactly as in the original, and provided
  21 that the entire resulting derived work is distributed under the terms
  22 of a permission notice identical to this one.
  23
  24    Permission is granted to copy and distribute translations of this
  25 manual into another language, under the above conditions for modified
  26 versions, except that the sections entitled "GNU General Public
  27 License", "Conditions for Using Bison" and this permission notice may be
  28 included in translations approved by the Free Software Foundation
  29 instead of in the original English.
  30
  31 \1f
  32 File: bison.info,  Node: Index,  Prev: Glossary,  Up: Top
  33
  34 Index
  35 *****
  36
  37 * Menu:
  38
  39 * $$:                                    Actions.
  40 * $N:                                    Actions.
  41 * %expect:                               Expect Decl.
  42 * %left:                                 Using Precedence.
  43 * %nonassoc:                             Using Precedence.
  44 * %prec:                                 Contextual Precedence.
  45 * %pure_parser:                          Pure Decl.
  46 * %right:                                Using Precedence.
  47 * %start:                                Start Decl.
  48 * %token:                                Token Decl.
  49 * %type:                                 Type Decl.
  50 * %union:                                Union Decl.
  51 * @N:                                    Action Features.
  52 * action:                                Actions.
  53 * action data types:                     Action Types.
  54 * action features summary:               Action Features.
  55 * actions in mid-rule:                   Mid-Rule Actions.
  56 * actions, semantic:                     Semantic Actions.
  57 * additional C code section:             C Code.
  58 * algorithm of parser:                   Algorithm.
  59 * associativity:                         Why Precedence.
  60 * Backus-Naur form:                      Language and Grammar.
  61 * Bison declaration summary:             Decl Summary.
  62 * Bison declarations:                    Declarations.
  63 * Bison declarations (introduction):     Bison Declarations.
  64 * Bison grammar:                         Grammar in Bison.
  65 * Bison invocation:                      Invocation.
  66 * Bison parser:                          Bison Parser.
  67 * Bison parser algorithm:                Algorithm.
  68 * Bison symbols, table of:               Table of Symbols.
  69 * Bison utility:                         Bison Parser.
  70 * BISON_HAIRY:                           Environment Variables.
  71 * BISON_SIMPLE:                          Environment Variables.
  72 * BNF:                                   Language and Grammar.
  73 * C code, section for additional:        C Code.
  74 * C declarations section:                C Declarations.
  75 * C-language interface:                  Interface.
  76 * calc:                                  Infix Calc.
  77 * calculator, infix notation:            Infix Calc.
  78 * calculator, multi-function:            Multi-function Calc.
  79 * calculator, simple:                    RPN Calc.
  80 * character token:                       Symbols.
  81 * compiling the parser:                  Rpcalc Compile.
  82 * conflicts:                             Shift/Reduce.
  83 * conflicts, reduce/reduce:              Reduce/Reduce.
  84 * conflicts, suppressing warnings of:    Expect Decl.
  85 * context-dependent precedence:          Contextual Precedence.
  86 * context-free grammar:                  Language and Grammar.
  87 * controlling function:                  Rpcalc Main.
  88 * dangling else:                         Shift/Reduce.
  89 * data types in actions:                 Action Types.
  90 * data types of semantic values:         Value Type.
  91 * debugging:                             Debugging.
  92 * declaration summary:                   Decl Summary.
  93 * declarations, Bison:                   Declarations.
  94 * declarations, Bison (introduction):    Bison Declarations.
  95 * declarations, C:                       C Declarations.
  96 * declaring literal string tokens:       Token Decl.
  97 * declaring operator precedence:         Precedence Decl.
  98 * declaring the start symbol:            Start Decl.
  99 * declaring token type names:            Token Decl.
 100 * declaring value types:                 Union Decl.
 101 * declaring value types, nonterminals:   Type Decl.
 102 * default action:                        Actions.
 103 * default data type:                     Value Type.
 104 * default stack limit:                   Stack Overflow.
 105 * default start symbol:                  Start Decl.
 106 * defining language semantics:           Semantics.
 107 * else, dangling:                        Shift/Reduce.
 108 * environment variables:                 Environment Variables.
 109 * error:                                 Error Recovery.
 110 * error recovery:                        Error Recovery.
 111 * error recovery, simple:                Simple Error Recovery.
 112 * error reporting function:              Error Reporting.
 113 * error reporting routine:               Rpcalc Error.
 114 * examples, simple:                      Examples.
 115 * exercises:                             Exercises.
 116 * file format:                           Grammar Layout.
 117 * finite-state machine:                  Parser States.
 118 * formal grammar:                        Grammar in Bison.
 119 * format of grammar file:                Grammar Layout.
 120 * glossary:                              Glossary.
 121 * grammar file:                          Grammar Layout.
 122 * grammar rule syntax:                   Rules.
 123 * grammar rules section:                 Grammar Rules.
 124 * grammar, Bison:                        Grammar in Bison.
 125 * grammar, context-free:                 Language and Grammar.
 126 * grouping, syntactic:                   Language and Grammar.
 127 * infix notation calculator:             Infix Calc.
 128 * interface:                             Interface.
 129 * introduction:                          Introduction.
 130 * invoking Bison:                        Invocation.
 131 * invoking Bison under VMS:              VMS Invocation.
 132 * LALR(1):                               Mystery Conflicts.
 133 * language semantics, defining:          Semantics.
 134 * layout of Bison grammar:               Grammar Layout.
 135 * left recursion:                        Recursion.
 136 * lexical analyzer:                      Lexical.
 137 * lexical analyzer, purpose:             Bison Parser.
 138 * lexical analyzer, writing:             Rpcalc Lexer.
 139 * lexical tie-in:                        Lexical Tie-ins.
 140 * literal string token:                  Symbols.
 141 * literal token:                         Symbols.
 142 * look-ahead token:                      Look-Ahead.
 143 * LR(1):                                 Mystery Conflicts.
 144 * main function in simple example:       Rpcalc Main.
 145 * mfcalc:                                Multi-function Calc.
 146 * mid-rule actions:                      Mid-Rule Actions.
 147 * multi-function calculator:             Multi-function Calc.
 148 * multicharacter literal:                Symbols.
 149 * mutual recursion:                      Recursion.
 150 * nonterminal symbol:                    Symbols.
 151 * operator precedence:                   Precedence.
 152 * operator precedence, declaring:        Precedence Decl.
 153 * options for invoking Bison:            Invocation.
 154 * overflow of parser stack:              Stack Overflow.
 155 * parse error:                           Error Reporting.
 156 * parser:                                Bison Parser.
 157 * parser stack:                          Algorithm.
 158 * parser stack overflow:                 Stack Overflow.
 159 * parser state:                          Parser States.
 160 * polish notation calculator:            RPN Calc.
 161 * precedence declarations:               Precedence Decl.
 162 * precedence of operators:               Precedence.
 163 * precedence, context-dependent:         Contextual Precedence.
 164 * precedence, unary operator:            Contextual Precedence.
 165 * preventing warnings about conflicts:   Expect Decl.
 166 * pure parser:                           Pure Decl.
 167 * recovery from errors:                  Error Recovery.
 168 * recursive rule:                        Recursion.
 169 * reduce/reduce conflict:                Reduce/Reduce.
 170 * reduction:                             Algorithm.
 171 * reentrant parser:                      Pure Decl.
 172 * reverse polish notation:               RPN Calc.
 173 * right recursion:                       Recursion.
 174 * rpcalc:                                RPN Calc.
 175 * rule syntax:                           Rules.
 176 * rules section for grammar:             Grammar Rules.
 177 * running Bison (introduction):          Rpcalc Gen.
 178 * semantic actions:                      Semantic Actions.
 179 * semantic value:                        Semantic Values.
 180 * semantic value type:                   Value Type.
 181 * shift/reduce conflicts:                Shift/Reduce.
 182 * shifting:                              Algorithm.
 183 * simple examples:                       Examples.
 184 * single-character literal:              Symbols.
 185 * stack overflow:                        Stack Overflow.
 186 * stack, parser:                         Algorithm.
 187 * stages in using Bison:                 Stages.
 188 * start symbol:                          Language and Grammar.
 189 * start symbol, declaring:               Start Decl.
 190 * state (of parser):                     Parser States.
 191 * string token:                          Symbols.
 192 * summary, action features:              Action Features.
 193 * summary, Bison declaration:            Decl Summary.
 194 * suppressing conflict warnings:         Expect Decl.
 195 * symbol:                                Symbols.
 196 * symbol table example:                  Mfcalc Symtab.
 197 * symbols (abstract):                    Language and Grammar.
 198 * symbols in Bison, table of:            Table of Symbols.
 199 * syntactic grouping:                    Language and Grammar.
 200 * syntax error:                          Error Reporting.
 201 * syntax of grammar rules:               Rules.
 202 * terminal symbol:                       Symbols.
 203 * token:                                 Language and Grammar.
 204 * token type:                            Symbols.
 205 * token type names, declaring:           Token Decl.
 206 * tracing the parser:                    Debugging.
 207 * unary operator precedence:             Contextual Precedence.
 208 * using Bison:                           Stages.
 209 * value type, semantic:                  Value Type.
 210 * value types, declaring:                Union Decl.
 211 * value types, nonterminals, declaring:  Type Decl.
 212 * value, semantic:                       Semantic Values.
 213 * VMS:                                   VMS Invocation.
 214 * warnings, preventing:                  Expect Decl.
 215 * writing a lexical analyzer:            Rpcalc Lexer.
 216 * YYABORT:                               Parser Function.
 217 * YYACCEPT:                              Parser Function.
 218 * YYBACKUP:                              Action Features.
 219 * yychar:                                Look-Ahead.
 220 * yyclearin:                             Error Recovery.
 221 * yydebug:                               Debugging.
 222 * YYDEBUG:                               Debugging.
 223 * YYEMPTY:                               Action Features.
 224 * yyerrok:                               Error Recovery.
 225 * YYERROR:                               Action Features.
 226 * yyerror:                               Error Reporting.
 227 * YYERROR_VERBOSE:                       Error Reporting.
 228 * YYINITDEPTH:                           Stack Overflow.
 229 * yylex:                                 Lexical.
 230 * YYLEX_PARAM:                           Pure Calling.
 231 * yylloc:                                Token Positions.
 232 * YYLTYPE:                               Token Positions.
 233 * yylval:                                Token Values.
 234 * YYMAXDEPTH:                            Stack Overflow.
 235 * yynerrs:                               Error Reporting.
 236 * yyparse:                               Parser Function.
 237 * YYPARSE_PARAM:                         Pure Calling.
 238 * YYPRINT:                               Debugging.
 239 * YYRECOVERING:                          Error Recovery.
 240 * |:                                     Rules.
 241
 242