This is flex.info, produced by makeinfo version 4.13 from flex.texi.

INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* flex: (flex).      Fast lexical analyzer generator (lex replacement).
END-INFO-DIR-ENTRY

   The flex manual is placed under the same licensing conditions as the
rest of flex:

   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2012 The
Flex Project.

   Copyright (C) 1990, 1997 The Regents of the University of California.
All rights reserved.

   This code is derived from software contributed to Berkeley by Vern
Paxson.

   The United States Government has rights in this work pursuant to
contract no. DE-AC03-76SF00098 between the United States Department of
Energy and the University of California.

   Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

  1.  Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.

  2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the
     distribution.

   Neither the name of the University nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.

   THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.


File: flex.info,  Node: Concept Index,  Next: Index of Functions and Macros,  Prev: Indices,  Up: Indices

Concept Index
=============

 [index ]
* Menu:

* $ as normal character in patterns:     Patterns.            (line 274)
* %array, advantages of:                 Matching.            (line  43)
* %array, use of:                        Matching.            (line  29)
* %array, with C++:                      Matching.            (line  65)
* %option noyywrapp:                     Generated Scanner.   (line  93)
* %pointer, and unput():                 Actions.             (line 163)
* %pointer, use of:                      Matching.            (line  29)
* %top:                                  Definitions Section. (line  44)
* %{ and %}, in Definitions Section:     Definitions Section. (line  40)
* %{ and %}, in Rules Section:           Actions.             (line  26)
* <<EOF>>, use of:                       EOF.                 (line  33)
* [] in patterns:                        Patterns.            (line  15)
* ^ as non-special character in patterns: Patterns.           (line 274)
* accessor functions, use of:            Accessor Methods.    (line  18)
* actions:                               Actions.             (line   6)
* actions, embedded C strings:           Actions.             (line  26)
* actions, redefining YY_BREAK:          Misc Macros.         (line  49)
* actions, use of { and }:               Actions.             (line  26)
* aliases, how to define:                Definitions Section. (line  10)
* arguments, command-line:               Scanner Options.     (line   6)
* array, default size for yytext:        User Values.         (line  13)
* backing up, eliminating:               Performance.         (line  54)
* backing up, eliminating by adding error rules: Performance. (line 104)
* backing up, eliminating with catch-all rule: Performance.   (line 118)
* backing up, example of eliminating:    Performance.         (line  49)
* BEGIN:                                 Actions.             (line  58)
* BEGIN, explanation:                    Start Conditions.    (line  84)
* beginning of line, in patterns:        Patterns.            (line 127)
* bison, bridging with flex:             Bison Bridge.        (line   6)
* bison, parser:                         Bison Bridge.        (line  54)
* bison, scanner to be called from bison: Bison Bridge.       (line  35)
* BOL, checking the BOL flag:            Misc Macros.         (line  46)
* BOL, in patterns:                      Patterns.            (line 127)
* BOL, setting it:                       Misc Macros.         (line  40)
* braces in patterns:                    Patterns.            (line  42)
* bugs, reporting:                       Reporting Bugs.      (line   6)
* C code in flex input:                  Definitions Section. (line  40)
* C++:                                   Cxx.                 (line   9)
* C++ and %array:                        User Values.         (line  23)
* C++ I/O, customizing:                  How do I use my own I/O classes in a C++ scanner?.
                                                              (line   9)
* C++ scanners, including multiple scanners: Cxx.             (line 189)
* C++ scanners, use of:                  Cxx.                 (line 122)
* c++, experimental form of scanner class: Cxx.               (line   6)
* C++, multiple different scanners:      Cxx.                 (line 183)
* C-strings, in actions:                 Actions.             (line  26)
* case-insensitive, effect on character classes: Patterns.    (line 216)
* character classes in patterns:         Patterns.            (line 186)
* character classes in patterns, syntax of: Patterns.         (line  15)
* character classes, equivalence of:     Patterns.            (line 205)
* clearing an input buffer:              Multiple Input Buffers.
                                                              (line  66)
* command-line options:                  Scanner Options.     (line   6)
* comments in flex input:                Definitions Section. (line  37)
* comments in the input:                 Comments in the Input.
                                                              (line  25)
* comments, discarding:                  Actions.             (line 177)
* comments, example of scanning C comments: Start Conditions. (line 140)
* comments, in actions:                  Actions.             (line  26)
* comments, in rules section:            Comments in the Input.
                                                              (line  11)
* comments, syntax of:                   Comments in the Input.
                                                              (line   6)
* comments, valid uses of:               Comments in the Input.
                                                              (line  25)
* compressing whitespace:                Actions.             (line  22)
* concatenation, in patterns:            Patterns.            (line 111)
* copyright of flex:                     Copyright.           (line   6)
* counting characters and lines:         Simple Examples.     (line  24)
* customizing I/O in C++ scanners:       How do I use my own I/O classes in a C++ scanner?.
                                                              (line   9)
* default rule <1>:                      Matching.            (line  20)
* default rule:                          Simple Examples.     (line  15)
* defining pattern aliases:              Definitions Section. (line  21)
* Definitions, in flex input:            Definitions Section. (line   6)
* deleting lines from input:             Actions.             (line  13)
* discarding C comments:                 Actions.             (line 177)
* distributing flex:                     Copyright.           (line   6)
* ECHO:                                  Actions.             (line  55)
* ECHO, and yyout:                       Generated Scanner.   (line 101)
* embedding C code in flex input:        Definitions Section. (line  40)
* end of file, in patterns:              Patterns.            (line 150)
* end of line, in negated character classes: Patterns.        (line 237)
* end of line, in patterns:              Patterns.            (line 131)
* end-of-file, and yyrestart():          Generated Scanner.   (line  42)
* EOF and yyrestart():                   Generated Scanner.   (line  42)
* EOF in patterns, syntax of:            Patterns.            (line 150)
* EOF, example using multiple input buffers: Multiple Input Buffers.
                                                              (line  81)
* EOF, explanation:                      EOF.                 (line   6)
* EOF, pushing back:                     Actions.             (line 171)
* EOL, in negated character classes:     Patterns.            (line 237)
* EOL, in patterns:                      Patterns.            (line 131)
* error messages, end of buffer missed:  Lex and Posix.       (line  50)
* error reporting, diagnostic messages:  Diagnostics.         (line   6)
* error reporting, in C++:               Cxx.                 (line 106)
* error rules, to eliminate backing up:  Performance.         (line 102)
* escape sequences in patterns, syntax of: Patterns.          (line  57)
* exiting with yyterminate():            Actions.             (line 213)
* experimental form of c++ scanner class: Cxx.                (line   6)
* extended scope of start conditions:    Start Conditions.    (line 270)
* file format:                           Format.              (line   6)
* file format, serialized tables:        Tables File Format.  (line   6)
* flushing an input buffer:              Multiple Input Buffers.
                                                              (line  66)
* flushing the internal buffer:          Actions.             (line 207)
* format of flex input:                  Format.              (line   6)
* format of input file:                  Format.              (line   9)
* freeing tables:                        Loading and Unloading Serialized Tables.
                                                              (line   6)
* getting current start state with YY_START: Start Conditions.
                                                              (line 189)
* halting with yyterminate():            Actions.             (line 213)
* handling include files with multiple input buffers: Multiple Input Buffers.
                                                              (line  87)
* header files, with C++:                Cxx.                 (line 189)
* include files, with C++:               Cxx.                 (line 189)
* input file, Definitions section:       Definitions Section. (line   6)
* input file, Rules Section:             Rules Section.       (line   6)
* input file, user code Section:         User Code Section.   (line   6)
* input():                               Actions.             (line 174)
* input(), and C++:                      Actions.             (line 203)
* input, format of:                      Format.              (line   6)
* input, matching:                       Matching.            (line   6)
* keywords, for performance:             Performance.         (line 200)
* lex (traditional) and POSIX:           Lex and Posix.       (line   6)
* LexerInput, overriding:                How do I use my own I/O classes in a C++ scanner?.
                                                              (line   9)
* LexerOutput, overriding:               How do I use my own I/O classes in a C++ scanner?.
                                                              (line   9)
* limitations of flex:                   Limitations.         (line   6)
* literal text in patterns, syntax of:   Patterns.            (line  54)
* loading tables at runtime:             Loading and Unloading Serialized Tables.
                                                              (line   6)
* m4:                                    M4 Dependency.       (line   6)
* Makefile, example of implicit rules:   Makefiles and Flex.  (line  21)
* Makefile, explicit example:            Makefiles and Flex.  (line  32)
* Makefile, syntax:                      Makefiles and Flex.  (line   6)
* matching C-style double-quoted strings: Start Conditions.   (line 203)
* matching, and trailing context:        Matching.            (line   6)
* matching, length of:                   Matching.            (line   6)
* matching, multiple matches:            Matching.            (line   6)
* member functions, C++:                 Cxx.                 (line   9)
* memory management:                     Memory Management.   (line   6)
* memory, allocating input buffers:      Multiple Input Buffers.
                                                              (line  19)
* memory, considerations for reentrant scanners: Init and Destroy Functions.
                                                              (line   6)
* memory, deleting input buffers:        Multiple Input Buffers.
                                                              (line  46)
* memory, for start condition stacks:    Start Conditions.    (line 301)
* memory, serialized tables <1>:         Loading and Unloading Serialized Tables.
                                                              (line   6)
* memory, serialized tables:             Serialized Tables.   (line   6)
* methods, c++:                          Cxx.                 (line   9)
* minimal scanner:                       Matching.            (line  24)
* multiple input streams:                Multiple Input Buffers.
                                                              (line   6)
* name definitions, not POSIX:           Lex and Posix.       (line  75)
* negating ranges in patterns:           Patterns.            (line  23)
* newline, matching in patterns:         Patterns.            (line 135)
* non-POSIX features of flex:            Lex and Posix.       (line 144)
* noyywrap, %option:                     Generated Scanner.   (line  93)
* NULL character in patterns, syntax of: Patterns.            (line  62)
* octal characters in patterns:          Patterns.            (line  65)
* options, command-line:                 Scanner Options.     (line   6)
* overriding LexerInput:                 How do I use my own I/O classes in a C++ scanner?.
                                                              (line   9)
* overriding LexerOutput:                How do I use my own I/O classes in a C++ scanner?.
                                                              (line   9)
* overriding the memory routines:        Overriding The Default Memory Management.
                                                              (line  42)
* Pascal-like language:                  Simple Examples.     (line  50)
* pattern aliases, defining:             Definitions Section. (line  21)
* pattern aliases, expansion of:         Patterns.            (line  51)
* pattern aliases, how to define:        Definitions Section. (line  10)
* pattern aliases, use of:               Definitions Section. (line  28)
* patterns and actions on different lines: Lex and Posix.     (line 101)
* patterns, character class equivalence: Patterns.            (line 205)
* patterns, common:                      Common Patterns.     (line   6)
* patterns, end of line:                 Patterns.            (line 299)
* patterns, grouping and precedence:     Patterns.            (line 167)
* patterns, in rules section:            Patterns.            (line   6)
* patterns, invalid trailing context:    Patterns.            (line 284)
* patterns, matching:                    Matching.            (line   6)
* patterns, precedence of operators:     Patterns.            (line 161)
* patterns, repetitions with grouping:   Patterns.            (line 184)
* patterns, special characters treated as non-special: Patterns.
                                                              (line 292)
* patterns, syntax:                      Patterns.            (line   9)
* patterns, tuning for performance:      Performance.         (line  49)
* patterns, valid character classes:     Patterns.            (line 192)
* performance optimization, matching longer tokens: Performance.
                                                              (line 167)
* performance optimization, recognizing keywords: Performance.
                                                              (line 205)
* performance, backing up:               Performance.         (line  49)
* performance, considerations:           Performance.         (line   6)
* performance, using keywords:           Performance.         (line 200)
* popping an input buffer:               Multiple Input Buffers.
                                                              (line  60)
* POSIX and lex:                         Lex and Posix.       (line   6)
* POSIX comp;compliance:                 Lex and Posix.       (line 144)
* POSIX, character classes in patterns, syntax of: Patterns.  (line  15)
* preprocessor macros, for use in actions: Actions.           (line  51)
* pushing an input buffer:               Multiple Input Buffers.
                                                              (line  52)
* pushing back characters with unput:    Actions.             (line 144)
* pushing back characters with unput():  Actions.             (line 148)
* pushing back characters with yyless:   Actions.             (line 132)
* pushing back EOF:                      Actions.             (line 171)
* ranges in patterns:                    Patterns.            (line  19)
* ranges in patterns, negating:          Patterns.            (line  23)
* recognizing C comments:                Start Conditions.    (line 143)
* reentrant scanners, multiple interleaved scanners: Reentrant Uses.
                                                              (line  10)
* reentrant scanners, recursive invocation: Reentrant Uses.   (line  30)
* reentrant, accessing flex variables:   Global Replacement.  (line   6)
* reentrant, accessor functions:         Accessor Methods.    (line   6)
* reentrant, API explanation:            Reentrant Overview.  (line   6)
* reentrant, calling functions:          Extra Reentrant Argument.
                                                              (line   6)
* reentrant, example of:                 Reentrant Example.   (line   6)
* reentrant, explanation:                Reentrant.           (line   6)
* reentrant, extra data:                 Extra Data.          (line   6)
* reentrant, initialization:             Init and Destroy Functions.
                                                              (line   6)
* regular expressions, in patterns:      Patterns.            (line   6)
* REJECT:                                Actions.             (line  62)
* REJECT, calling multiple times:        Actions.             (line  84)
* REJECT, performance costs:             Performance.         (line  12)
* reporting bugs:                        Reporting Bugs.      (line   6)
* restarting the scanner:                Lex and Posix.       (line  54)
* RETURN, within actions:                Generated Scanner.   (line  57)
* rules, default:                        Simple Examples.     (line  15)
* rules, in flex input:                  Rules Section.       (line   6)
* scanner, definition of:                Introduction.        (line   6)
* sections of flex input:                Format.              (line   6)
* serialization:                         Serialized Tables.   (line   6)
* serialization of tables:               Creating Serialized Tables.
                                                              (line   6)
* serialized tables, multiple scanners:  Creating Serialized Tables.
                                                              (line  26)
* stack, input buffer pop:               Multiple Input Buffers.
                                                              (line  60)
* stack, input buffer push:              Multiple Input Buffers.
                                                              (line  52)
* stacks, routines for manipulating:     Start Conditions.    (line 286)
* start condition, applying to multiple patterns: Start Conditions.
                                                              (line 258)
* start conditions:                      Start Conditions.    (line   6)
* start conditions, behavior of default rule: Start Conditions.
                                                              (line  82)
* start conditions, exclusive:           Start Conditions.    (line  53)
* start conditions, for different interpretations of same input: Start Conditions.
                                                              (line 112)
* start conditions, in patterns:         Patterns.            (line 140)
* start conditions, inclusive:           Start Conditions.    (line  44)
* start conditions, inclusive v.s. exclusive: Start Conditions.
                                                              (line  24)
* start conditions, integer values:      Start Conditions.    (line 163)
* start conditions, multiple:            Start Conditions.    (line  17)
* start conditions, special wildcard condition: Start Conditions.
                                                              (line  68)
* start conditions, use of a stack:      Start Conditions.    (line 286)
* start conditions, use of wildcard condition (<*>): Start Conditions.
                                                              (line  72)
* start conditions, using BEGIN:         Start Conditions.    (line  95)
* stdin, default for yyin:               Generated Scanner.   (line  37)
* stdout, as default for yyout:          Generated Scanner.   (line 101)
* strings, scanning strings instead of files: Multiple Input Buffers.
                                                              (line 175)
* tables, creating serialized:           Creating Serialized Tables.
                                                              (line   6)
* tables, file format:                   Tables File Format.  (line   6)
* tables, freeing:                       Loading and Unloading Serialized Tables.
                                                              (line   6)
* tables, loading and unloading:         Loading and Unloading Serialized Tables.
                                                              (line   6)
* terminating with yyterminate():        Actions.             (line 213)
* token:                                 Matching.            (line  14)
* trailing context, in patterns:         Patterns.            (line 118)
* trailing context, limits of:           Patterns.            (line 274)
* trailing context, matching:            Matching.            (line   6)
* trailing context, performance costs:   Performance.         (line  12)
* trailing context, variable length:     Performance.         (line 141)
* unput():                               Actions.             (line 144)
* unput(), and %pointer:                 Actions.             (line 163)
* unput(), pushing back characters:      Actions.             (line 148)
* user code, in flex input:              User Code Section.   (line   6)
* username expansion:                    Simple Examples.     (line   8)
* using integer values of start condition names: Start Conditions.
                                                              (line 163)
* verbatim text in patterns, syntax of:  Patterns.            (line  54)
* warning, dangerous trailing context:   Limitations.         (line  20)
* warning, rule cannot be matched:       Diagnostics.         (line  14)
* warnings, diagnostic messages:         Diagnostics.         (line   6)
* whitespace, compressing:               Actions.             (line  22)
* yacc interface:                        Yacc.                (line  17)
* yacc, interface:                       Yacc.                (line   6)
* YY_CURRENT_BUFFER, and multiple buffers Finally, the macro: Multiple Input Buffers.
                                                              (line  78)
* YY_EXTRA_TYPE, defining your own type: Extra Data.          (line  33)
* YY_FLUSH_BUFFER:                       Actions.             (line 207)
* YY_INPUT:                              Generated Scanner.   (line  61)
* YY_INPUT, overriding:                  Generated Scanner.   (line  71)
* YY_START, example:                     Start Conditions.    (line 185)
* YY_USER_ACTION to track each time a rule is matched: Misc Macros.
                                                              (line  14)
* yyalloc, overriding:                   Overriding The Default Memory Management.
                                                              (line   6)
* yyfree, overriding:                    Overriding The Default Memory Management.
                                                              (line   6)
* yyin:                                  Generated Scanner.   (line  37)
* yyinput():                             Actions.             (line 203)
* yyleng:                                Matching.            (line  14)
* yyleng, modification of:               Actions.             (line  48)
* yyless():                              Actions.             (line 126)
* yyless(), pushing back characters:     Actions.             (line 132)
* yylex(), in generated scanner:         Generated Scanner.   (line   6)
* yylex(), overriding:                   Generated Scanner.   (line  16)
* yylex, overriding the prototype of:    Generated Scanner.   (line  20)
* yylineno, in a reentrant scanner:      Reentrant Functions. (line  36)
* yylineno, performance costs:           Performance.         (line  12)
* yymore():                              Actions.             (line 105)
* yymore() to append token to previous token: Actions.        (line 111)
* yymore(), mega-kludge:                 Actions.             (line 111)
* yymore, and yyleng:                    Actions.             (line  48)
* yymore, performance penalty of:        Actions.             (line 120)
* yyout:                                 Generated Scanner.   (line 101)
* yyrealloc, overriding:                 Overriding The Default Memory Management.
                                                              (line   6)
* yyrestart():                           Generated Scanner.   (line  42)
* yyterminate():                         Actions.             (line 213)
* yytext:                                Matching.            (line  14)
* yytext, default array size:            User Values.         (line  13)
* yytext, memory considerations:         A Note About yytext And Memory.
                                                              (line   6)
* yytext, modification of:               Actions.             (line  42)
* yytext, two types of:                  Matching.            (line  29)
* yywrap():                              Generated Scanner.   (line  85)
* yywrap, default for:                   Generated Scanner.   (line  93)
* |, in actions:                         Actions.             (line  33)
* |, use of:                             Actions.             (line  84)


File: flex.info,  Node: Index of Functions and Macros,  Next: Index of Variables,  Prev: Concept Index,  Up: Indices

Index of Functions and Macros
=============================

This is an index of functions and preprocessor macros that look like
functions.  For macros that expand to variables or constants, see *note
Index of Variables::.

 [index ]
* Menu:

* BEGIN:                                 Start Conditions.    (line  84)
* debug (C++ only):                      Cxx.                 (line  48)
* LexerError (C++ only):                 Cxx.                 (line 106)
* LexerInput (C++ only):                 Cxx.                 (line  91)
* LexerOutput (C++ only):                Cxx.                 (line 101)
* lineno (C++ only):                     Cxx.                 (line  38)
* set_debug (C++ only):                  Cxx.                 (line  42)
* switch_streams (C++ only):             Cxx.                 (line  78)
* YY_AT_BOL:                             Misc Macros.         (line  46)
* yy_create_buffer:                      Multiple Input Buffers.
                                                              (line  20)
* yy_delete_buffer:                      Multiple Input Buffers.
                                                              (line  47)
* yy_flush_buffer:                       Multiple Input Buffers.
                                                              (line  67)
* yy_new_buffer:                         Multiple Input Buffers.
                                                              (line  73)
* YY_NEW_FILE  (now obsolete):           EOF.                 (line  11)
* yy_pop_state:                          Start Conditions.    (line 296)
* yy_push_state:                         Start Conditions.    (line 290)
* yy_scan_buffer:                        Multiple Input Buffers.
                                                              (line 198)
* yy_scan_bytes:                         Multiple Input Buffers.
                                                              (line 188)
* yy_scan_string:                        Multiple Input Buffers.
                                                              (line 184)
* yy_set_bol:                            Misc Macros.         (line  40)
* yy_set_interactive:                    Misc Macros.         (line  28)
* yy_switch_to_buffer:                   Multiple Input Buffers.
                                                              (line  36)
* yy_top_state:                          Start Conditions.    (line 299)
* yyFlexLexer constructor (C++ only):    Cxx.                 (line  61)
* yyget_debug:                           Reentrant Functions. (line   8)
* yyget_extra <1>:                       Reentrant Functions. (line   8)
* yyget_extra:                           Extra Data.          (line  20)
* yyget_in:                              Reentrant Functions. (line   8)
* yyget_leng:                            Reentrant Functions. (line   8)
* yyget_lineno:                          Reentrant Functions. (line   8)
* yyget_out:                             Reentrant Functions. (line   8)
* yyget_text:                            Reentrant Functions. (line   8)
* YYLeng (C++ only):                     Cxx.                 (line  34)
* yylex (C++ version):                   Cxx.                 (line  66)
* yylex (reentrant version):             Bison Bridge.        (line  23)
* yylex_destroy:                         Init and Destroy Functions.
                                                              (line   6)
* yylex_init:                            Init and Destroy Functions.
                                                              (line   6)
* yypop_buffer_state:                    Multiple Input Buffers.
                                                              (line  61)
* yypush_buffer_state:                   Multiple Input Buffers.
                                                              (line  53)
* yyrestart:                             User Values.         (line  39)
* yyset_debug:                           Reentrant Functions. (line   8)
* yyset_extra <1>:                       Reentrant Functions. (line   8)
* yyset_extra:                           Extra Data.          (line  20)
* yyset_in:                              Reentrant Functions. (line   8)
* yyset_lineno:                          Reentrant Functions. (line   8)
* yyset_out:                             Reentrant Functions. (line   8)
* yytables_destroy:                      Loading and Unloading Serialized Tables.
                                                              (line  24)
* yytables_fload:                        Loading and Unloading Serialized Tables.
                                                              (line  11)
* YYText (C++ only):                     Cxx.                 (line  30)


File: flex.info,  Node: Index of Variables,  Next: Index of Data Types,  Prev: Index of Functions and Macros,  Up: Indices

Index of Variables
==================

This is an index of variables, constants, and preprocessor macros that
expand to variables or constants.

 [index ]
* Menu:

* INITIAL:                               Start Conditions.    (line  84)
* YY_CURRENT_BUFFER:                     User Values.         (line  50)
* YY_END_OF_BUFFER_CHAR:                 Multiple Input Buffers.
                                                              (line 196)
* YY_NUM_RULES:                          Misc Macros.         (line  16)
* YY_START <1>:                          User Values.         (line  53)
* YY_START:                              Start Conditions.    (line 191)
* yyextra:                               Extra Data.          (line   6)
* yyin:                                  User Values.         (line  29)
* yyleng:                                User Values.         (line  26)
* yylloc:                                Bison Bridge.        (line   6)
* YYLMAX:                                User Values.         (line  13)
* yylval:                                Bison Bridge.        (line   6)
* yylval, with yacc:                     Yacc.                (line   6)
* yyout:                                 User Values.         (line  46)
* yyscanner (reentrant only):            Extra Reentrant Argument.
                                                              (line   6)
* yytext <1>:                            User Values.         (line   9)
* yytext:                                Matching.            (line  29)


File: flex.info,  Node: Index of Data Types,  Next: Index of Hooks,  Prev: Index of Variables,  Up: Indices

Index of Data Types
===================

 [index ]
* Menu:

* FlexLexer (C++ only):                  Cxx.                 (line  57)
* YY_BUFFER_STATE:                       Multiple Input Buffers.
                                                              (line  25)
* YY_EXTRA_TYPE (reentrant only):        Extra Data.          (line  20)
* yy_size_t:                             Multiple Input Buffers.
                                                              (line 209)
* yyFlexLexer (C++ only):                Cxx.                 (line  57)
* YYLTYPE:                               Bison Bridge.        (line   6)
* yyscan_t (reentrant only):             About yyscan_t.      (line   6)
* YYSTYPE:                               Bison Bridge.        (line   6)


File: flex.info,  Node: Index of Hooks,  Next: Index of Scanner Options,  Prev: Index of Data Types,  Up: Indices

Index of Hooks
==============

This is an index of "hooks" that the user may define. These hooks
typically  correspond to specific locations in the generated scanner,
and may be used to insert arbitrary code.

 [index ]
* Menu:

* YY_BREAK:                              Misc Macros.          (line 49)
* YY_USER_ACTION:                        Misc Macros.          (line  6)
* YY_USER_INIT:                          Misc Macros.          (line 23)


File: flex.info,  Node: Index of Scanner Options,  Prev: Index of Hooks,  Up: Indices

Index of Scanner Options
========================

 [index ]
* Menu:

* -+:                                    Code-Level And API Options.
                                                              (line  50)
* --7bit:                                Options Affecting Scanner Behavior.
                                                              (line  57)
* --8bit:                                Options Affecting Scanner Behavior.
                                                              (line  81)
* --align:                               Options for Scanner Speed and Size.
                                                              (line  15)
* --always-interactive:                  Options Affecting Scanner Behavior.
                                                              (line  93)
* --array:                               Code-Level And API Options.
                                                              (line  54)
* --backup:                              Debugging Options.   (line   6)
* --batch:                               Options Affecting Scanner Behavior.
                                                              (line  23)
* --bison-bridge:                        Code-Level And API Options.
                                                              (line  17)
* --bison-locations:                     Code-Level And API Options.
                                                              (line  24)
* --c++:                                 Code-Level And API Options.
                                                              (line  50)
* --case-insensitive:                    Options Affecting Scanner Behavior.
                                                              (line   6)
* --debug:                               Debugging Options.   (line  16)
* --default:                             Options Affecting Scanner Behavior.
                                                              (line  90)
* --ecs:                                 Options for Scanner Speed and Size.
                                                              (line  24)
* --fast:                                Options for Scanner Speed and Size.
                                                              (line 100)
* --full:                                Options for Scanner Speed and Size.
                                                              (line  95)
* --header-file:                         Options for Specifying Filenames.
                                                              (line   6)
* --help:                                Miscellaneous Options.
                                                              (line   9)
* --interactive:                         Options Affecting Scanner Behavior.
                                                              (line  33)
* --lex-compat:                          Options Affecting Scanner Behavior.
                                                              (line  14)
* --main:                                Code-Level And API Options.
                                                              (line 100)
* --meta-ecs:                            Options for Scanner Speed and Size.
                                                              (line  45)
* --never-interactive:                   Options Affecting Scanner Behavior.
                                                              (line 101)
* --nodefault:                           Debugging Options.   (line  43)
* --noline:                              Code-Level And API Options.
                                                              (line  29)
* --nounistd:                            Code-Level And API Options.
                                                              (line 105)
* --nowarn:                              Debugging Options.   (line  55)
* --option-ansi-definitions:             Code-Level And API Options.
                                                              (line   6)
* --option-ansi-prototypes:              Code-Level And API Options.
                                                              (line  12)
* --outfile:                             Options for Specifying Filenames.
                                                              (line  21)
* --perf-report:                         Debugging Options.   (line  31)
* --pointer:                             Code-Level And API Options.
                                                              (line  57)
* --posix:                               Options Affecting Scanner Behavior.
                                                              (line 105)
* --prefix:                              Code-Level And API Options.
                                                              (line  61)
* --read:                                Options for Scanner Speed and Size.
                                                              (line  54)
* --reentrant:                           Code-Level And API Options.
                                                              (line  38)
* --skel:                                Options for Specifying Filenames.
                                                              (line  31)
* --stack:                               Options Affecting Scanner Behavior.
                                                              (line 125)
* --stdinit:                             Options Affecting Scanner Behavior.
                                                              (line 129)
* --stdout:                              Options for Specifying Filenames.
                                                              (line  27)
* --tables-file:                         Options for Specifying Filenames.
                                                              (line  36)
* --tables-verify:                       Options for Specifying Filenames.
                                                              (line  41)
* --trace:                               Debugging Options.   (line  49)
* --verbose:                             Debugging Options.   (line  58)
* --version:                             Miscellaneous Options.
                                                              (line  16)
* --warn:                                Debugging Options.   (line  66)
* --yyclass:                             Code-Level And API Options.
                                                              (line 114)
* --yylineno:                            Options Affecting Scanner Behavior.
                                                              (line 138)
* --yywrap:                              Options Affecting Scanner Behavior.
                                                              (line 146)
* -7:                                    Options Affecting Scanner Behavior.
                                                              (line  57)
* -8:                                    Options Affecting Scanner Behavior.
                                                              (line  81)
* -b:                                    Debugging Options.   (line   6)
* -B:                                    Options Affecting Scanner Behavior.
                                                              (line  23)
* -c:                                    Miscellaneous Options.
                                                              (line   6)
* -C:                                    Options for Scanner Speed and Size.
                                                              (line  10)
* -Ca:                                   Options for Scanner Speed and Size.
                                                              (line  15)
* -Ce:                                   Options for Scanner Speed and Size.
                                                              (line  24)
* -CF:                                   Options for Scanner Speed and Size.
                                                              (line  40)
* -Cf:                                   Options for Scanner Speed and Size.
                                                              (line  35)
* -Cm:                                   Options for Scanner Speed and Size.
                                                              (line  45)
* -Cr:                                   Options for Scanner Speed and Size.
                                                              (line  54)
* -d:                                    Debugging Options.   (line  16)
* -F:                                    Options for Scanner Speed and Size.
                                                              (line 100)
* -f:                                    Options for Scanner Speed and Size.
                                                              (line  95)
* -h:                                    Miscellaneous Options.
                                                              (line   9)
* -I:                                    Options Affecting Scanner Behavior.
                                                              (line  33)
* -i:                                    Options Affecting Scanner Behavior.
                                                              (line   6)
* -L:                                    Code-Level And API Options.
                                                              (line  29)
* -l:                                    Options Affecting Scanner Behavior.
                                                              (line  14)
* -n:                                    Miscellaneous Options.
                                                              (line  13)
* -o:                                    Options for Specifying Filenames.
                                                              (line  21)
* -p:                                    Debugging Options.   (line  31)
* -P:                                    Code-Level And API Options.
                                                              (line  61)
* -R:                                    Code-Level And API Options.
                                                              (line  38)
* -s:                                    Debugging Options.   (line  43)
* -T:                                    Debugging Options.   (line  49)
* -t:                                    Options for Specifying Filenames.
                                                              (line  27)
* -V:                                    Miscellaneous Options.
                                                              (line  16)
* -v:                                    Debugging Options.   (line  58)
* -w:                                    Debugging Options.   (line  55)
* -X:                                    Options Affecting Scanner Behavior.
                                                              (line 105)
* 7bit:                                  Options Affecting Scanner Behavior.
                                                              (line  57)
* 8bit:                                  Options Affecting Scanner Behavior.
                                                              (line  81)
* align:                                 Options for Scanner Speed and Size.
                                                              (line  15)
* always-interactive:                    Options Affecting Scanner Behavior.
                                                              (line  93)
* ansi-definitions:                      Code-Level And API Options.
                                                              (line   6)
* ansi-prototypes:                       Code-Level And API Options.
                                                              (line  12)
* array:                                 Code-Level And API Options.
                                                              (line  54)
* backup:                                Debugging Options.   (line   6)
* batch:                                 Options Affecting Scanner Behavior.
                                                              (line  23)
* bison-bridge:                          Code-Level And API Options.
                                                              (line  17)
* bison-locations:                       Code-Level And API Options.
                                                              (line  24)
* c++:                                   Code-Level And API Options.
                                                              (line  50)
* case-insensitive:                      Options Affecting Scanner Behavior.
                                                              (line   6)
* debug:                                 Debugging Options.   (line  16)
* default:                               Options Affecting Scanner Behavior.
                                                              (line  90)
* ecs:                                   Options for Scanner Speed and Size.
                                                              (line  24)
* fast:                                  Options for Scanner Speed and Size.
                                                              (line 100)
* full:                                  Options for Scanner Speed and Size.
                                                              (line  95)
* header-file:                           Options for Specifying Filenames.
                                                              (line   6)
* interactive:                           Options Affecting Scanner Behavior.
                                                              (line  33)
* lex-compat:                            Options Affecting Scanner Behavior.
                                                              (line  14)
* main:                                  Code-Level And API Options.
                                                              (line 100)
* meta-ecs:                              Options for Scanner Speed and Size.
                                                              (line  45)
* nodefault:                             Debugging Options.   (line  43)
* noline:                                Code-Level And API Options.
                                                              (line  29)
* nounistd:                              Code-Level And API Options.
                                                              (line 105)
* nowarn:                                Debugging Options.   (line  55)
* noyyalloc:                             Overriding The Default Memory Management.
                                                              (line  17)
* outfile:                               Options for Specifying Filenames.
                                                              (line  21)
* perf-report:                           Debugging Options.   (line  31)
* pointer:                               Code-Level And API Options.
                                                              (line  57)
* posix:                                 Options Affecting Scanner Behavior.
                                                              (line 105)
* prefix:                                Code-Level And API Options.
                                                              (line  61)
* read:                                  Options for Scanner Speed and Size.
                                                              (line  54)
* reentrant:                             Code-Level And API Options.
                                                              (line  38)
* stack:                                 Options Affecting Scanner Behavior.
                                                              (line 125)
* stdinit:                               Options Affecting Scanner Behavior.
                                                              (line 129)
* stdout:                                Options for Specifying Filenames.
                                                              (line  27)
* tables-file:                           Options for Specifying Filenames.
                                                              (line  36)
* tables-verify:                         Options for Specifying Filenames.
                                                              (line  41)
* trace:                                 Debugging Options.   (line  49)
* verbose:                               Debugging Options.   (line  58)
* warn:                                  Debugging Options.   (line  66)
* yyclass:                               Code-Level And API Options.
                                                              (line 114)
* yylineno:                              Options Affecting Scanner Behavior.
                                                              (line 138)
* yywrap:                                Options Affecting Scanner Behavior.
                                                              (line 146)