doc/flex.info-2

   1 This is flex.info, produced by makeinfo version 4.8 from flex.texi.
   2
   3 INFO-DIR-SECTION Programming
   4 START-INFO-DIR-ENTRY
   5 * flex: (flex).      Fast lexical analyzer generator (lex replacement).
   6 END-INFO-DIR-ENTRY
   7
   8    The flex manual is placed under the same licensing conditions as the
   9 rest of flex:
  10
  11    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 The Flex
  12 Project.
  13
  14    Copyright (C) 1990, 1997 The Regents of the University of California.
  15 All rights reserved.
  16
  17    This code is derived from software contributed to Berkeley by Vern
  18 Paxson.
  19
  20    The United States Government has rights in this work pursuant to
  21 contract no. DE-AC03-76SF00098 between the United States Department of
  22 Energy and the University of California.
  23
  24    Redistribution and use in source and binary forms, with or without
  25 modification, are permitted provided that the following conditions are
  26 met:
  27
  28   1.  Redistributions of source code must retain the above copyright
  29      notice, this list of conditions and the following disclaimer.
  30
  31   2. Redistributions in binary form must reproduce the above copyright
  32      notice, this list of conditions and the following disclaimer in the
  33      documentation and/or other materials provided with the
  34      distribution.
  35
  36    Neither the name of the University nor the names of its contributors
  37 may be used to endorse or promote products derived from this software
  38 without specific prior written permission.
  39
  40    THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
  41 WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  42 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  43
  44 \1f
  45 File: flex.info,  Node: Concept Index,  Next: Index of Functions and Macros,  Prev: Indices,  Up: Indices
  46
  47 Concept Index
  48 =============
  49
  50 \0\b[index\0\b]
  51 * Menu:
  52
  53 * $ as normal character in patterns:     Patterns.            (line 282)
  54 * %array, advantages of:                 Matching.            (line  44)
  55 * %array, use of:                        Matching.            (line  30)
  56 * %array, with C++:                      Matching.            (line  67)
  57 * %option nowrap:                        Generated Scanner.   (line  96)
  58 * %pointer, and unput():                 Actions.             (line 170)
  59 * %pointer, use of:                      Matching.            (line  30)
  60 * %top:                                  Definitions Section. (line  48)
  61 * %{ and %}, in Definitions Section:     Definitions Section. (line  44)
  62 * %{ and %}, in Rules Section:           Actions.             (line  28)
  63 * <<EOF>>, use of:                       EOF.                 (line  34)
  64 * [] in patterns:                        Patterns.            (line  15)
  65 * ^ as non-special character in patterns: Patterns.           (line 282)
  66 * accessor functions, use of:            Accessor Methods.    (line  18)
  67 * actions:                               Actions.             (line   6)
  68 * actions, embedded C strings:           Actions.             (line  28)
  69 * actions, redefining YY_BREAK:          Misc Macros.         (line  51)
  70 * actions, use of { and }:               Actions.             (line  28)
  71 * aliases, how to define:                Definitions Section. (line  10)
  72 * arguments, command-line:               Scanner Options.     (line   6)
  73 * array, default size for yytext:        User Values.         (line  13)
  74 * backing up, eliminating:               Performance.         (line  56)
  75 * backing up, eliminating by adding error rules: Performance. (line 108)
  76 * backing up, eliminating with catch-all rule: Performance.   (line 123)
  77 * backing up, example of eliminating:    Performance.         (line  51)
  78 * BEGIN:                                 Actions.             (line  60)
  79 * BEGIN, explanation:                    Start Conditions.    (line  90)
  80 * beginning of line, in patterns:        Patterns.            (line 128)
  81 * bison, bridging with flex:             Bison Bridge.        (line   6)
  82 * bison, parser:                         Bison Bridge.        (line  57)
  83 * bison, scanner to be called from bison: Bison Bridge.       (line  37)
  84 * BOL, checking the BOL flag:            Misc Macros.         (line  48)
  85 * BOL, in patterns:                      Patterns.            (line 128)
  86 * BOL, setting it:                       Misc Macros.         (line  42)
  87 * braces in patterns:                    Patterns.            (line  42)
  88 * bugs, reporting:                       Reporting Bugs.      (line   6)
  89 * C code in flex input:                  Definitions Section. (line  44)
  90 * C++:                                   Cxx.                 (line   9)
  91 * C++ and %array:                        User Values.         (line  23)
  92 * C++ I/O, customizing:                  How do I use my own I/O classes in a C++ scanner?.
  93                                                               (line   9)
  94 * C++ scanners, including multiple scanners: Cxx.             (line 186)
  95 * C++ scanners, use of:                  Cxx.                 (line 122)
  96 * c++, experimental form of scanner class: Cxx.               (line   6)
  97 * C++, multiple different scanners:      Cxx.                 (line 180)
  98 * C-strings, in actions:                 Actions.             (line  28)
  99 * case-insensitive, effect on character classes: Patterns.    (line 223)
 100 * character classes in patterns:         Patterns.            (line 191)
 101 * character classes in patterns, syntax of: Patterns.         (line  15)
 102 * character classes, equivalence of:     Patterns.            (line 211)
 103 * clearing an input buffer:              Multiple Input Buffers.
 104                                                               (line  66)
 105 * command-line options:                  Scanner Options.     (line   6)
 106 * comments in flex input:                Definitions Section. (line  41)
 107 * comments in the input:                 Comments in the Input.
 108                                                               (line  25)
 109 * comments, discarding:                  Actions.             (line 184)
 110 * comments, example of scanning C comments: Start Conditions. (line 148)
 111 * comments, in actions:                  Actions.             (line  28)
 112 * comments, in rules section:            Comments in the Input.
 113                                                               (line  11)
 114 * comments, syntax of:                   Comments in the Input.
 115                                                               (line   6)
 116 * comments, valid uses of:               Comments in the Input.
 117                                                               (line  25)
 118 * compressing whitespace:                Actions.             (line  23)
 119 * concatenation, in patterns:            Patterns.            (line 112)
 120 * copyright of flex:                     Copyright.           (line   6)
 121 * counting characters and lines:         Simple Examples.     (line  25)
 122 * customizing I/O in C++ scanners:       How do I use my own I/O classes in a C++ scanner?.
 123                                                               (line   9)
 124 * default rule <1>:                      Matching.            (line  20)
 125 * default rule:                          Simple Examples.     (line  16)
 126 * defining pattern aliases:              Definitions Section. (line  22)
 127 * Definitions, in flex input:            Definitions Section. (line   6)
 128 * deleting lines from input:             Actions.             (line  13)
 129 * discarding C comments:                 Actions.             (line 184)
 130 * distributing flex:                     Copyright.           (line   6)
 131 * ECHO:                                  Actions.             (line  57)
 132 * ECHO, and yyout:                       Generated Scanner.   (line 104)
 133 * embedding C code in flex input:        Definitions Section. (line  44)
 134 * end of file, in patterns:              Patterns.            (line 151)
 135 * end of line, in negated character classes: Patterns.        (line 244)
 136 * end of line, in patterns:              Patterns.            (line 132)
 137 * end-of-file, and yyrestart():          Generated Scanner.   (line  44)
 138 * EOF and yyrestart():                   Generated Scanner.   (line  44)
 139 * EOF in patterns, syntax of:            Patterns.            (line 151)
 140 * EOF, example using multiple input buffers: Multiple Input Buffers.
 141                                                               (line  81)
 142 * EOF, explanation:                      EOF.                 (line   6)
 143 * EOF, pushing back:                     Actions.             (line 178)
 144 * EOL, in negated character classes:     Patterns.            (line 244)
 145 * EOL, in patterns:                      Patterns.            (line 132)
 146 * error messages, end of buffer missed:  Lex and Posix.       (line  50)
 147 * error reporting, diagnostic messages:  Diagnostics.         (line   6)
 148 * error reporting, in C++:               Cxx.                 (line 106)
 149 * error rules, to eliminate backing up:  Performance.         (line 106)
 150 * escape sequences in patterns, syntax of: Patterns.          (line  57)
 151 * exiting with yyterminate():            Actions.             (line 221)
 152 * experimental form of c++ scanner class: Cxx.                (line   6)
 153 * extended scope of start conditions:    Start Conditions.    (line 283)
 154 * file format:                           Format.              (line   6)
 155 * file format, serialized tables:        Tables File Format.  (line   6)
 156 * flushing an input buffer:              Multiple Input Buffers.
 157                                                               (line  66)
 158 * flushing the internal buffer:          Actions.             (line 215)
 159 * format of flex input:                  Format.              (line   6)
 160 * format of input file:                  Format.              (line   9)
 161 * freeing tables:                        Loading and Unloading Serialized Tables.
 162                                                               (line   6)
 163 * getting current start state with YY_START: Start Conditions.
 164                                                               (line 199)
 165 * halting with yyterminate():            Actions.             (line 221)
 166 * handling include files with multiple input buffers: Multiple Input Buffers.
 167                                                               (line  87)
 168 * header files, with C++:                Cxx.                 (line 186)
 169 * include files, with C++:               Cxx.                 (line 186)
 170 * input file, Definitions section:       Definitions Section. (line   6)
 171 * input file, Rules Section:             Rules Section.       (line   6)
 172 * input file, user code Section:         User Code Section.   (line   6)
 173 * input():                               Actions.             (line 181)
 174 * input(), and C++:                      Actions.             (line 211)
 175 * input, format of:                      Format.              (line   6)
 176 * input, matching:                       Matching.            (line   6)
 177 * keywords, for performance:             Performance.         (line 211)
 178 * lex (traditional) and POSIX:           Lex and Posix.       (line   6)
 179 * LexerInput, overriding:                How do I use my own I/O classes in a C++ scanner?.
 180                                                               (line   9)
 181 * LexerOutput, overriding:               How do I use my own I/O classes in a C++ scanner?.
 182                                                               (line   9)
 183 * limitations of flex:                   Limitations.         (line   6)
 184 * literal text in patterns, syntax of:   Patterns.            (line  54)
 185 * loading tables at runtime:             Loading and Unloading Serialized Tables.
 186                                                               (line   6)
 187 * m4:                                    M4 Dependency.       (line   6)
 188 * Makefile, example of implicit rules:   Makefiles and Flex.  (line  21)
 189 * Makefile, explicit example:            Makefiles and Flex.  (line  33)
 190 * Makefile, syntax:                      Makefiles and Flex.  (line   6)
 191 * matching C-style double-quoted strings: Start Conditions.   (line 214)
 192 * matching, and trailing context:        Matching.            (line   6)
 193 * matching, length of:                   Matching.            (line   6)
 194 * matching, multiple matches:            Matching.            (line   6)
 195 * member functions, C++:                 Cxx.                 (line   9)
 196 * memory management:                     Memory Management.   (line   6)
 197 * memory, allocating input buffers:      Multiple Input Buffers.
 198                                                               (line  19)
 199 * memory, considerations for reentrant scanners: Init and Destroy Functions.
 200                                                               (line   6)
 201 * memory, deleting input buffers:        Multiple Input Buffers.
 202                                                               (line  46)
 203 * memory, for start condition stacks:    Start Conditions.    (line 316)
 204 * memory, serialized tables <1>:         Loading and Unloading Serialized Tables.
 205                                                               (line   6)
 206 * memory, serialized tables:             Serialized Tables.   (line   6)
 207 * methods, c++:                          Cxx.                 (line   9)
 208 * minimal scanner:                       Matching.            (line  24)
 209 * multiple input streams:                Multiple Input Buffers.
 210                                                               (line   6)
 211 * name definitions, not POSIX:           Lex and Posix.       (line  77)
 212 * negating ranges in patterns:           Patterns.            (line  23)
 213 * newline, matching in patterns:         Patterns.            (line 136)
 214 * non-POSIX features of flex:            Lex and Posix.       (line 148)
 215 * nowrap, %option:                       Generated Scanner.   (line  96)
 216 * NULL character in patterns, syntax of: Patterns.            (line  62)
 217 * octal characters in patterns:          Patterns.            (line  65)
 218 * options, command-line:                 Scanner Options.     (line   6)
 219 * overriding LexerInput:                 How do I use my own I/O classes in a C++ scanner?.
 220                                                               (line   9)
 221 * overriding LexerOutput:                How do I use my own I/O classes in a C++ scanner?.
 222                                                               (line   9)
 223 * overriding the memory routines:        Overriding The Default Memory Management.
 224                                                               (line  43)
 225 * Pascal-like language:                  Simple Examples.     (line  51)
 226 * pattern aliases, defining:             Definitions Section. (line  22)
 227 * pattern aliases, expansion of:         Patterns.            (line  51)
 228 * pattern aliases, how to define:        Definitions Section. (line  10)
 229 * pattern aliases, use of:               Definitions Section. (line  30)
 230 * patterns and actions on different lines: Lex and Posix.     (line 104)
 231 * patterns, character class equivalence: Patterns.            (line 211)
 232 * patterns, common:                      Common Patterns.     (line   6)
 233 * patterns, end of line:                 Patterns.            (line 309)
 234 * patterns, grouping and precedence:     Patterns.            (line 168)
 235 * patterns, in rules section:            Patterns.            (line   6)
 236 * patterns, invalid trailing context:    Patterns.            (line 292)
 237 * patterns, matching:                    Matching.            (line   6)
 238 * patterns, precedence of operators:     Patterns.            (line 162)
 239 * patterns, repetitions with grouping:   Patterns.            (line 188)
 240 * patterns, special characters treated as non-special: Patterns.
 241                                                               (line 301)
 242 * patterns, syntax:                      Patterns.            (line   9)
 243 * patterns, tuning for performance:      Performance.         (line  51)
 244 * patterns, valid character classes:     Patterns.            (line 197)
 245 * performance optimization, matching longer tokens: Performance.
 246                                                               (line 176)
 247 * performance optimization, recognizing keywords: Performance.
 248                                                               (line 216)
 249 * performance, backing up:               Performance.         (line  51)
 250 * performance, considerations:           Performance.         (line   6)
 251 * performance, using keywords:           Performance.         (line 211)
 252 * popping an input buffer:               Multiple Input Buffers.
 253                                                               (line  60)
 254 * POSIX and lex:                         Lex and Posix.       (line   6)
 255 * POSIX comp;compliance:                 Lex and Posix.       (line 148)
 256 * POSIX, character classes in patterns, syntax of: Patterns.  (line  15)
 257 * preprocessor macros, for use in actions: Actions.           (line  53)
 258 * pushing an input buffer:               Multiple Input Buffers.
 259                                                               (line  52)
 260 * pushing back characters with unput:    Actions.             (line 150)
 261 * pushing back characters with unput():  Actions.             (line 154)
 262 * pushing back characters with yyless:   Actions.             (line 137)
 263 * pushing back EOF:                      Actions.             (line 178)
 264 * ranges in patterns:                    Patterns.            (line  19)
 265 * ranges in patterns, negating:          Patterns.            (line  23)
 266 * recognizing C comments:                Start Conditions.    (line 151)
 267 * reentrant scanners, multiple interleaved scanners: Reentrant Uses.
 268                                                               (line  10)
 269 * reentrant scanners, recursive invocation: Reentrant Uses.   (line  31)
 270 * reentrant, accessing flex variables:   Global Replacement.  (line   6)
 271 * reentrant, accessor functions:         Accessor Methods.    (line   6)
 272 * reentrant, API explanation:            Reentrant Overview.  (line   6)
 273 * reentrant, calling functions:          Extra Reentrant Argument.
 274                                                               (line   6)
 275 * reentrant, example of:                 Reentrant Example.   (line   6)
 276 * reentrant, explanation:                Reentrant.           (line   6)
 277 * reentrant, extra data:                 Extra Data.          (line   6)
 278 * reentrant, initialization:             Init and Destroy Functions.
 279                                                               (line   6)
 280 * regular expressions, in patterns:      Patterns.            (line   6)
 281 * REJECT:                                Actions.             (line  64)
 282 * REJECT, calling multiple times:        Actions.             (line  87)
 283 * REJECT, performance costs:             Performance.         (line  12)
 284 * reporting bugs:                        Reporting Bugs.      (line   6)
 285 * restarting the scanner:                Lex and Posix.       (line  55)
 286 * RETURN, within actions:                Generated Scanner.   (line  59)
 287 * rules, default:                        Simple Examples.     (line  16)
 288 * rules, in flex input:                  Rules Section.       (line   6)
 289 * scanner, definition of:                Introduction.        (line   6)
 290 * sections of flex input:                Format.              (line   6)
 291 * serialization:                         Serialized Tables.   (line   6)
 292 * serialization of tables:               Creating Serialized Tables.
 293                                                               (line   6)
 294 * serialized tables, multiple scanners:  Creating Serialized Tables.
 295                                                               (line  27)
 296 * stack, input buffer pop:               Multiple Input Buffers.
 297                                                               (line  60)
 298 * stack, input buffer push:              Multiple Input Buffers.
 299                                                               (line  52)
 300 * stacks, routines for manipulating:     Start Conditions.    (line 301)
 301 * start condition, applying to multiple patterns: Start Conditions.
 302                                                               (line 270)
 303 * start conditions:                      Start Conditions.    (line   6)
 304 * start conditions, behavior of default rule: Start Conditions.
 305                                                               (line  87)
 306 * start conditions, exclusive:           Start Conditions.    (line  56)
 307 * start conditions, for different interpretations of same input: Start Conditions.
 308                                                               (line 119)
 309 * start conditions, in patterns:         Patterns.            (line 141)
 310 * start conditions, inclusive:           Start Conditions.    (line  46)
 311 * start conditions, inclusive v.s. exclusive: Start Conditions.
 312                                                               (line  26)
 313 * start conditions, integer values:      Start Conditions.    (line 172)
 314 * start conditions, multiple:            Start Conditions.    (line  18)
 315 * start conditions, special wildcard condition: Start Conditions.
 316                                                               (line  72)
 317 * start conditions, use of a stack:      Start Conditions.    (line 301)
 318 * start conditions, use of wildcard condition (<*>): Start Conditions.
 319                                                               (line  76)
 320 * start conditions, using BEGIN:         Start Conditions.    (line 101)
 321 * stdin, default for yyin:               Generated Scanner.   (line  39)
 322 * stdout, as default for yyout:          Generated Scanner.   (line 104)
 323 * strings, scanning strings instead of files: Multiple Input Buffers.
 324                                                               (line 177)
 325 * tables, creating serialized:           Creating Serialized Tables.
 326                                                               (line   6)
 327 * tables, file format:                   Tables File Format.  (line   6)
 328 * tables, freeing:                       Loading and Unloading Serialized Tables.
 329                                                               (line   6)
 330 * tables, loading and unloading:         Loading and Unloading Serialized Tables.
 331                                                               (line   6)
 332 * terminating with yyterminate():        Actions.             (line 221)
 333 * token:                                 Matching.            (line  14)
 334 * trailing context, in patterns:         Patterns.            (line 119)
 335 * trailing context, limits of:           Patterns.            (line 282)
 336 * trailing context, matching:            Matching.            (line   6)
 337 * trailing context, performance costs:   Performance.         (line  12)
 338 * trailing context, variable length:     Performance.         (line 147)
 339 * unput():                               Actions.             (line 150)
 340 * unput(), and %pointer:                 Actions.             (line 170)
 341 * unput(), pushing back characters:      Actions.             (line 154)
 342 * user code, in flex input:              User Code Section.   (line   6)
 343 * username expansion:                    Simple Examples.     (line   8)
 344 * using integer values of start condition names: Start Conditions.
 345                                                               (line 172)
 346 * verbatim text in patterns, syntax of:  Patterns.            (line  54)
 347 * warning, dangerous trailing context:   Limitations.         (line  20)
 348 * warning, rule cannot be matched:       Diagnostics.         (line  14)
 349 * warnings, diagnostic messages:         Diagnostics.         (line   6)
 350 * whitespace, compressing:               Actions.             (line  23)
 351 * yacc interface:                        Yacc.                (line  17)
 352 * yacc, interface:                       Yacc.                (line   6)
 353 * YY_CURRENT_BUFFER, and multiple buffers Finally, the macro: Multiple Input Buffers.
 354                                                               (line  78)
 355 * YY_EXTRA_TYPE, defining your own type: Extra Data.          (line  34)
 356 * YY_FLUSH_BUFFER():                     Actions.             (line 215)
 357 * YY_INPUT:                              Generated Scanner.   (line  63)
 358 * YY_INPUT, overriding:                  Generated Scanner.   (line  73)
 359 * YY_START, example:                     Start Conditions.    (line 195)
 360 * YY_USER_ACTION to track each time a rule is matched: Misc Macros.
 361                                                               (line  14)
 362 * yyalloc, overriding:                   Overriding The Default Memory Management.
 363                                                               (line   6)
 364 * yyfree, overriding:                    Overriding The Default Memory Management.
 365                                                               (line   6)
 366 * yyin:                                  Generated Scanner.   (line  39)
 367 * yyinput():                             Actions.             (line 211)
 368 * yyleng:                                Matching.            (line  14)
 369 * yyleng, modification of:               Actions.             (line  50)
 370 * yyless():                              Actions.             (line 131)
 371 * yyless(), pushing back characters:     Actions.             (line 137)
 372 * yylex(), in generated scanner:         Generated Scanner.   (line   6)
 373 * yylex(), overriding:                   Generated Scanner.   (line  17)
 374 * yylex, overriding the prototype of:    Generated Scanner.   (line  21)
 375 * yylineno, in a reentrant scanner:      Reentrant Functions. (line  38)
 376 * yylineno, performance costs:           Performance.         (line  12)
 377 * yymore():                              Actions.             (line 109)
 378 * yymore() to append token to previous token: Actions.        (line 115)
 379 * yymore(), mega-kludge:                 Actions.             (line 115)
 380 * yymore, and yyleng:                    Actions.             (line  50)
 381 * yymore, performance penalty of:        Actions.             (line 125)
 382 * yyout:                                 Generated Scanner.   (line 104)
 383 * yyrealloc, overriding:                 Overriding The Default Memory Management.
 384                                                               (line   6)
 385 * yyrestart():                           Generated Scanner.   (line  44)
 386 * yyterminate():                         Actions.             (line 221)
 387 * yytext:                                Matching.            (line  14)
 388 * yytext, default array size:            User Values.         (line  13)
 389 * yytext, memory considerations:         A Note About yytext And Memory.
 390                                                               (line   6)
 391 * yytext, modification of:               Actions.             (line  44)
 392 * yytext, two types of:                  Matching.            (line  30)
 393 * yywrap():                              Generated Scanner.   (line  88)
 394 * yywrap, default for:                   Generated Scanner.   (line  96)
 395 * |, in actions:                         Actions.             (line  35)
 396 * |, use of:                             Actions.             (line  87)
 397
 398 \1f
 399 File: flex.info,  Node: Index of Functions and Macros,  Next: Index of Variables,  Prev: Concept Index,  Up: Indices
 400
 401 Index of Functions and Macros
 402 =============================
 403
 404 This is an index of functions and preprocessor macros that look like
 405 functions.  For macros that expand to variables or constants, see *Note
 406 Index of Variables::.
 407
 408 \0\b[index\0\b]
 409 * Menu:
 410
 411 * BEGIN:                                 Start Conditions.    (line  90)
 412 * debug (C++ only):                      Cxx.                 (line  48)
 413 * LexerError (C++ only):                 Cxx.                 (line 106)
 414 * LexerInput (C++ only):                 Cxx.                 (line  91)
 415 * LexerOutput (C++ only):                Cxx.                 (line 101)
 416 * lineno (C++ only):                     Cxx.                 (line  38)
 417 * set_debug (C++ only):                  Cxx.                 (line  42)
 418 * switch_streams (C++ only):             Cxx.                 (line  78)
 419 * YY_AT_BOL:                             Misc Macros.         (line  48)
 420 * yy_create_buffer:                      Multiple Input Buffers.
 421                                                               (line  20)
 422 * yy_delete_buffer:                      Multiple Input Buffers.
 423                                                               (line  47)
 424 * yy_flush_buffer:                       Multiple Input Buffers.
 425                                                               (line  67)
 426 * yy_new_buffer:                         Multiple Input Buffers.
 427                                                               (line  73)
 428 * YY_NEW_FILE  (now obsolete):           EOF.                 (line  11)
 429 * yy_pop_state:                          Start Conditions.    (line 311)
 430 * yy_push_state:                         Start Conditions.    (line 305)
 431 * yy_scan_buffer:                        Multiple Input Buffers.
 432                                                               (line 200)
 433 * yy_scan_bytes:                         Multiple Input Buffers.
 434                                                               (line 190)
 435 * yy_scan_string:                        Multiple Input Buffers.
 436                                                               (line 186)
 437 * yy_set_bol:                            Misc Macros.         (line  42)
 438 * yy_set_interactive:                    Misc Macros.         (line  30)
 439 * yy_switch_to_buffer:                   Multiple Input Buffers.
 440                                                               (line  36)
 441 * yy_top_state:                          Start Conditions.    (line 314)
 442 * yyFlexLexer constructor (C++ only):    Cxx.                 (line  61)
 443 * yyget_debug:                           Reentrant Functions. (line   8)
 444 * yyget_extra <1>:                       Reentrant Functions. (line   8)
 445 * yyget_extra:                           Extra Data.          (line  20)
 446 * yyget_in:                              Reentrant Functions. (line   8)
 447 * yyget_leng:                            Reentrant Functions. (line   8)
 448 * yyget_lineno:                          Reentrant Functions. (line   8)
 449 * yyget_out:                             Reentrant Functions. (line   8)
 450 * yyget_text:                            Reentrant Functions. (line   8)
 451 * YYLeng (C++ only):                     Cxx.                 (line  34)
 452 * yylex (C++ version):                   Cxx.                 (line  66)
 453 * yylex (reentrant version):             Bison Bridge.        (line  23)
 454 * yylex_destroy:                         Init and Destroy Functions.
 455                                                               (line   6)
 456 * yylex_init:                            Init and Destroy Functions.
 457                                                               (line   6)
 458 * yypop_buffer_state:                    Multiple Input Buffers.
 459                                                               (line  61)
 460 * yypush_buffer_state:                   Multiple Input Buffers.
 461                                                               (line  53)
 462 * yyrestart:                             User Values.         (line  39)
 463 * yyset_debug:                           Reentrant Functions. (line   8)
 464 * yyset_extra <1>:                       Reentrant Functions. (line   8)
 465 * yyset_extra:                           Extra Data.          (line  20)
 466 * yyset_in:                              Reentrant Functions. (line   8)
 467 * yyset_lineno:                          Reentrant Functions. (line   8)
 468 * yyset_out:                             Reentrant Functions. (line   8)
 469 * yytables_destroy:                      Loading and Unloading Serialized Tables.
 470                                                               (line  24)
 471 * yytables_fload:                        Loading and Unloading Serialized Tables.
 472                                                               (line  11)
 473 * YYText (C++ only):                     Cxx.                 (line  30)
 474
 475 \1f
 476 File: flex.info,  Node: Index of Variables,  Next: Index of Data Types,  Prev: Index of Functions and Macros,  Up: Indices
 477
 478 Index of Variables
 479 ==================
 480
 481 This is an index of variables, constants, and preprocessor macros that
 482 expand to variables or constants.
 483
 484 \0\b[index\0\b]
 485 * Menu:
 486
 487 * INITIAL:                               Start Conditions.    (line  90)
 488 * YY_CURRENT_BUFFER:                     User Values.         (line  50)
 489 * YY_END_OF_BUFFER_CHAR:                 Multiple Input Buffers.
 490                                                               (line 198)
 491 * YY_NUM_RULES:                          Misc Macros.         (line  17)
 492 * YY_START <1>:                          User Values.         (line  53)
 493 * YY_START:                              Start Conditions.    (line 202)
 494 * yyextra:                               Extra Data.          (line   6)
 495 * yyin:                                  User Values.         (line  29)
 496 * yyleng:                                User Values.         (line  26)
 497 * yylloc:                                Bison Bridge.        (line   6)
 498 * YYLMAX:                                User Values.         (line  13)
 499 * yylval:                                Bison Bridge.        (line   6)
 500 * yylval, with yacc:                     Yacc.                (line   6)
 501 * yyout:                                 User Values.         (line  46)
 502 * yyscanner (reentrant only):            Extra Reentrant Argument.
 503                                                               (line   6)
 504 * yytext <1>:                            User Values.         (line   9)
 505 * yytext:                                Matching.            (line  30)
 506
 507 \1f
 508 File: flex.info,  Node: Index of Data Types,  Next: Index of Hooks,  Prev: Index of Variables,  Up: Indices
 509
 510 Index of Data Types
 511 ===================
 512
 513 \0\b[index\0\b]
 514 * Menu:
 515
 516 * FlexLexer (C++ only):                  Cxx.                 (line  57)
 517 * YY_BUFFER_STATE:                       Multiple Input Buffers.
 518                                                               (line  25)
 519 * YY_EXTRA_TYPE (reentrant only):        Extra Data.          (line  20)
 520 * yy_size_t:                             Multiple Input Buffers.
 521                                                               (line 211)
 522 * yyFlexLexer (C++ only):                Cxx.                 (line  57)
 523 * YYLTYPE:                               Bison Bridge.        (line   6)
 524 * yyscan_t (reentrant only):             About yyscan_t.      (line   6)
 525 * YYSTYPE:                               Bison Bridge.        (line   6)
 526
 527 \1f
 528 File: flex.info,  Node: Index of Hooks,  Next: Index of Scanner Options,  Prev: Index of Data Types,  Up: Indices
 529
 530 Index of Hooks
 531 ==============
 532
 533 This is an index of "hooks" that the user may define. These hooks
 534 typically  correspond to specific locations in the generated scanner,
 535 and may be used to insert arbitrary code.
 536
 537 \0\b[index\0\b]
 538 * Menu:
 539
 540 * YY_BREAK:                              Misc Macros.          (line 51)
 541 * YY_USER_ACTION:                        Misc Macros.          (line  6)
 542 * YY_USER_INIT:                          Misc Macros.          (line 25)
 543
 544 \1f
 545 File: flex.info,  Node: Index of Scanner Options,  Prev: Index of Hooks,  Up: Indices
 546
 547 Index of Scanner Options
 548 ========================
 549
 550 \0\b[index\0\b]
 551 * Menu:
 552
 553 * -+:                                    Code-Level And API Options.
 554                                                               (line  50)
 555 * --7bit:                                Options Affecting Scanner Behavior.
 556                                                               (line  57)
 557 * --8bit:                                Options Affecting Scanner Behavior.
 558                                                               (line  81)
 559 * --align:                               Options for Scanner Speed and Size.
 560                                                               (line  15)
 561 * --always-interactive:                  Options Affecting Scanner Behavior.
 562                                                               (line  93)
 563 * --array:                               Code-Level And API Options.
 564                                                               (line  54)
 565 * --backup:                              Debugging Options.   (line   6)
 566 * --batch:                               Options Affecting Scanner Behavior.
 567                                                               (line  23)
 568 * --bison-bridge:                        Code-Level And API Options.
 569                                                               (line  17)
 570 * --bison-locations:                     Code-Level And API Options.
 571                                                               (line  24)
 572 * --c++:                                 Code-Level And API Options.
 573                                                               (line  50)
 574 * --case-insensitive:                    Options Affecting Scanner Behavior.
 575                                                               (line   6)
 576 * --debug:                               Debugging Options.   (line  16)
 577 * --default:                             Options Affecting Scanner Behavior.
 578                                                               (line  90)
 579 * --ecs:                                 Options for Scanner Speed and Size.
 580                                                               (line  24)
 581 * --fast:                                Options for Scanner Speed and Size.
 582                                                               (line 101)
 583 * --full:                                Options for Scanner Speed and Size.
 584                                                               (line  96)
 585 * --header-file:                         Options for Specifying Filenames.
 586                                                               (line   6)
 587 * --help:                                Miscellaneous Options.
 588                                                               (line   9)
 589 * --interactive:                         Options Affecting Scanner Behavior.
 590                                                               (line  33)
 591 * --lex-compat:                          Options Affecting Scanner Behavior.
 592                                                               (line  14)
 593 * --main:                                Code-Level And API Options.
 594                                                               (line 101)
 595 * --meta-ecs:                            Options for Scanner Speed and Size.
 596                                                               (line  45)
 597 * --never-interactive:                   Options Affecting Scanner Behavior.
 598                                                               (line 101)
 599 * --nodefault:                           Debugging Options.   (line  44)
 600 * --noline:                              Code-Level And API Options.
 601                                                               (line  29)
 602 * --nounistd:                            Code-Level And API Options.
 603                                                               (line 106)
 604 * --nowarn:                              Debugging Options.   (line  56)
 605 * --option-ansi-definitions:             Code-Level And API Options.
 606                                                               (line   6)
 607 * --option-ansi-prototypes:              Code-Level And API Options.
 608                                                               (line  12)
 609 * --outfile:                             Options for Specifying Filenames.
 610                                                               (line  21)
 611 * --perf-report:                         Debugging Options.   (line  32)
 612 * --pointer:                             Code-Level And API Options.
 613                                                               (line  57)
 614 * --posix:                               Options Affecting Scanner Behavior.
 615                                                               (line 105)
 616 * --prefix:                              Code-Level And API Options.
 617                                                               (line  61)
 618 * --read:                                Options for Scanner Speed and Size.
 619                                                               (line  54)
 620 * --reentrant:                           Code-Level And API Options.
 621                                                               (line  38)
 622 * --skel:                                Options for Specifying Filenames.
 623                                                               (line  31)
 624 * --stack:                               Options Affecting Scanner Behavior.
 625                                                               (line 125)
 626 * --stdinit:                             Options Affecting Scanner Behavior.
 627                                                               (line 129)
 628 * --stdout:                              Options for Specifying Filenames.
 629                                                               (line  27)
 630 * --tables-file:                         Options for Specifying Filenames.
 631                                                               (line  36)
 632 * --tables-verify:                       Options for Specifying Filenames.
 633                                                               (line  41)
 634 * --trace:                               Debugging Options.   (line  50)
 635 * --verbose:                             Debugging Options.   (line  59)
 636 * --version:                             Miscellaneous Options.
 637                                                               (line  16)
 638 * --warn:                                Debugging Options.   (line  67)
 639 * --yyclass:                             Code-Level And API Options.
 640                                                               (line 115)
 641 * --yylineno:                            Options Affecting Scanner Behavior.
 642                                                               (line 138)
 643 * --yywrap:                              Options Affecting Scanner Behavior.
 644                                                               (line 146)
 645 * -7:                                    Options Affecting Scanner Behavior.
 646                                                               (line  57)
 647 * -8:                                    Options Affecting Scanner Behavior.
 648                                                               (line  81)
 649 * -b:                                    Debugging Options.   (line   6)
 650 * -B:                                    Options Affecting Scanner Behavior.
 651                                                               (line  23)
 652 * -c:                                    Miscellaneous Options.
 653                                                               (line   6)
 654 * -C:                                    Options for Scanner Speed and Size.
 655                                                               (line  10)
 656 * -Ca:                                   Options for Scanner Speed and Size.
 657                                                               (line  15)
 658 * -Ce:                                   Options for Scanner Speed and Size.
 659                                                               (line  24)
 660 * -CF:                                   Options for Scanner Speed and Size.
 661                                                               (line  40)
 662 * -Cf:                                   Options for Scanner Speed and Size.
 663                                                               (line  35)
 664 * -Cm:                                   Options for Scanner Speed and Size.
 665                                                               (line  45)
 666 * -Cr:                                   Options for Scanner Speed and Size.
 667                                                               (line  54)
 668 * -d:                                    Debugging Options.   (line  16)
 669 * -F:                                    Options for Scanner Speed and Size.
 670                                                               (line 101)
 671 * -f:                                    Options for Scanner Speed and Size.
 672                                                               (line  96)
 673 * -h:                                    Miscellaneous Options.
 674                                                               (line   9)
 675 * -I:                                    Options Affecting Scanner Behavior.
 676                                                               (line  33)
 677 * -i:                                    Options Affecting Scanner Behavior.
 678                                                               (line   6)
 679 * -L:                                    Code-Level And API Options.
 680                                                               (line  29)
 681 * -l:                                    Options Affecting Scanner Behavior.
 682                                                               (line  14)
 683 * -n:                                    Miscellaneous Options.
 684                                                               (line  13)
 685 * -o:                                    Options for Specifying Filenames.
 686                                                               (line  21)
 687 * -p:                                    Debugging Options.   (line  32)
 688 * -P:                                    Code-Level And API Options.
 689                                                               (line  61)
 690 * -R:                                    Code-Level And API Options.
 691                                                               (line  38)
 692 * -s:                                    Debugging Options.   (line  44)
 693 * -T:                                    Debugging Options.   (line  50)
 694 * -t:                                    Options for Specifying Filenames.
 695                                                               (line  27)
 696 * -V:                                    Miscellaneous Options.
 697                                                               (line  16)
 698 * -v:                                    Debugging Options.   (line  59)
 699 * -w:                                    Debugging Options.   (line  56)
 700 * -X:                                    Options Affecting Scanner Behavior.
 701                                                               (line 105)
 702 * 7bit:                                  Options Affecting Scanner Behavior.
 703                                                               (line  57)
 704 * 8bit:                                  Options Affecting Scanner Behavior.
 705                                                               (line  81)
 706 * align:                                 Options for Scanner Speed and Size.
 707                                                               (line  15)
 708 * always-interactive:                    Options Affecting Scanner Behavior.
 709                                                               (line  93)
 710 * ansi-definitions:                      Code-Level And API Options.
 711                                                               (line   6)
 712 * ansi-prototypes:                       Code-Level And API Options.
 713                                                               (line  12)
 714 * array:                                 Code-Level And API Options.
 715                                                               (line  54)
 716 * backup:                                Debugging Options.   (line   6)
 717 * batch:                                 Options Affecting Scanner Behavior.
 718                                                               (line  23)
 719 * bison-bridge:                          Code-Level And API Options.
 720                                                               (line  17)
 721 * bison-locations:                       Code-Level And API Options.
 722                                                               (line  24)
 723 * c++:                                   Code-Level And API Options.
 724                                                               (line  50)
 725 * case-insensitive:                      Options Affecting Scanner Behavior.
 726                                                               (line   6)
 727 * debug:                                 Debugging Options.   (line  16)
 728 * default:                               Options Affecting Scanner Behavior.
 729                                                               (line  90)
 730 * ecs:                                   Options for Scanner Speed and Size.
 731                                                               (line  24)
 732 * fast:                                  Options for Scanner Speed and Size.
 733                                                               (line 101)
 734 * full:                                  Options for Scanner Speed and Size.
 735                                                               (line  96)
 736 * header-file:                           Options for Specifying Filenames.
 737                                                               (line   6)
 738 * interactive:                           Options Affecting Scanner Behavior.
 739                                                               (line  33)
 740 * lex-compat:                            Options Affecting Scanner Behavior.
 741                                                               (line  14)
 742 * main:                                  Code-Level And API Options.
 743                                                               (line 101)
 744 * meta-ecs:                              Options for Scanner Speed and Size.
 745                                                               (line  45)
 746 * nodefault:                             Debugging Options.   (line  44)
 747 * noline:                                Code-Level And API Options.
 748                                                               (line  29)
 749 * nounistd:                              Code-Level And API Options.
 750                                                               (line 106)
 751 * nowarn:                                Debugging Options.   (line  56)
 752 * noyyalloc:                             Overriding The Default Memory Management.
 753                                                               (line  17)
 754 * outfile:                               Options for Specifying Filenames.
 755                                                               (line  21)
 756 * perf-report:                           Debugging Options.   (line  32)
 757 * pointer:                               Code-Level And API Options.
 758                                                               (line  57)
 759 * posix:                                 Options Affecting Scanner Behavior.
 760                                                               (line 105)
 761 * prefix:                                Code-Level And API Options.
 762                                                               (line  61)
 763 * read:                                  Options for Scanner Speed and Size.
 764                                                               (line  54)
 765 * reentrant:                             Code-Level And API Options.
 766                                                               (line  38)
 767 * stack:                                 Options Affecting Scanner Behavior.
 768                                                               (line 125)
 769 * stdinit:                               Options Affecting Scanner Behavior.
 770                                                               (line 129)
 771 * stdout:                                Options for Specifying Filenames.
 772                                                               (line  27)
 773 * tables-file:                           Options for Specifying Filenames.
 774                                                               (line  36)
 775 * tables-verify:                         Options for Specifying Filenames.
 776                                                               (line  41)
 777 * trace:                                 Debugging Options.   (line  50)
 778 * verbose:                               Debugging Options.   (line  59)
 779 * warn:                                  Debugging Options.   (line  67)
 780 * yyclass:                               Code-Level And API Options.
 781                                                               (line 115)
 782 * yylineno:                              Options Affecting Scanner Behavior.
 783                                                               (line 138)
 784 * yywrap:                                Options Affecting Scanner Behavior.
 785                                                               (line 146)
 786
 787