(flex.info)Concept Index


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

[index]

$ as normal character in patterns: Patterns. (line 275)
%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 162)
%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 275)
|, in actions: Actions. (line 33)
|, use of: Actions. (line 83)
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 57)
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 53)
bison, scanner to be called from bison: Bison Bridge. (line 34)
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?.
C++ scanners, including multiple scanners: Cxx. (line 197)
C++ scanners, use of: Cxx. (line 128)
c++, experimental form of scanner class: Cxx. (line 6)
C++, multiple different scanners: Cxx. (line 192)
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.
command-line options: Scanner Options. (line 6)
comments in flex input: Definitions Section. (line 37)
comments in the input: Comments in the Input.
comments, discarding: Actions. (line 176)
comments, example of scanning C comments: Start Conditions. (line 140)
comments, in actions: Actions. (line 26)
comments, in rules section: Comments in the Input.
comments, syntax of: Comments in the Input.
comments, valid uses of: Comments in the Input.
compressing whitespace: Actions. (line 22)
concatenation, in patterns: Patterns. (line 111)
copyright of flex: Copyright. (line 6)
counting characters and lines: Simple Examples. (line 23)
customizing I/O in C++ scanners: How do I use my own I/O classes in a C++ scanner?.
default rule: Simple Examples. (line 15)
default rule <1>: Matching. (line 20)
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 176)
distributing flex: Copyright. (line 6)
ECHO: Actions. (line 54)
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.
EOF, explanation: EOF. (line 6)
EOF, pushing back: Actions. (line 170)
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 112)
error rules, to eliminate backing up: Performance. (line 102)
escape sequences in patterns, syntax of: Patterns. (line 57)
exiting with yyterminate(): Actions. (line 212)
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.
flushing the internal buffer: Actions. (line 206)
format of flex input: Format. (line 6)
format of input file: Format. (line 9)
freeing tables: Loading and Unloading Serialized Tables.
getting current start state with YY_START: Start Conditions.
halting with yyterminate(): Actions. (line 212)
handling include files with multiple input buffers: Multiple Input Buffers.
handling include files with multiple input buffers <1>: Multiple Input Buffers.
header files, with C++: Cxx. (line 197)
include files, with C++: Cxx. (line 197)
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 173)
input(), and C++: Actions. (line 202)
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?.
LexerOutput, overriding: How do I use my own I/O classes in a C++ scanner?.
limitations of flex: Limitations. (line 6)
literal text in patterns, syntax of: Patterns. (line 54)
loading tables at runtime: Loading and Unloading Serialized Tables.
m4: M4 Dependency. (line 6)
Makefile, example of implicit rules: Makefiles and Flex. (line 21)
Makefile, explicit example: Makefiles and Flex. (line 33)
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.
memory, considerations for reentrant scanners: Init and Destroy Functions.
memory, deleting input buffers: Multiple Input Buffers.
memory, for start condition stacks: Start Conditions. (line 301)
memory, serialized tables: Serialized Tables. (line 6)
memory, serialized tables <1>: Loading and Unloading Serialized Tables.
methods, c++: Cxx. (line 9)
minimal scanner: Matching. (line 24)
multiple input streams: Multiple Input Buffers.
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 142)
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?.
overriding LexerOutput: How do I use my own I/O classes in a C++ scanner?.
overriding the memory routines: Overriding The Default Memory Management.
Pascal-like language: Simple Examples. (line 49)
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 300)
patterns, grouping and precedence: Patterns. (line 167)
patterns, in rules section: Patterns. (line 6)
patterns, invalid trailing context: Patterns. (line 285)
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.
patterns, syntax: Patterns. (line 9)
patterns, syntax <1>: Patterns. (line 9)
patterns, tuning for performance: Performance. (line 49)
patterns, valid character classes: Patterns. (line 192)
performance optimization, matching longer tokens: Performance.
performance optimization, recognizing keywords: Performance.
performance, backing up: Performance. (line 49)
performance, considerations: Performance. (line 6)
performance, using keywords: Performance. (line 200)
popping an input buffer: Multiple Input Buffers.
POSIX and lex: Lex and Posix. (line 6)
POSIX comp;compliance: Lex and Posix. (line 142)
POSIX, character classes in patterns, syntax of: Patterns. (line 15)
preprocessor macros, for use in actions: Actions. (line 50)
pushing an input buffer: Multiple Input Buffers.
pushing back characters with unput: Actions. (line 143)
pushing back characters with unput(): Actions. (line 147)
pushing back characters with yyless: Actions. (line 131)
pushing back EOF: Actions. (line 170)
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.
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.
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.
regular expressions, in patterns: Patterns. (line 6)
REJECT: Actions. (line 61)
REJECT, calling multiple times: Actions. (line 83)
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.
serialized tables, multiple scanners: Creating Serialized Tables.
stack, input buffer pop: Multiple Input Buffers.
stack, input buffer push: Multiple Input Buffers.
stacks, routines for manipulating: Start Conditions. (line 286)
start condition, applying to multiple patterns: Start Conditions.
start conditions: Start Conditions. (line 6)
start conditions, behavior of default rule: Start Conditions.
start conditions, exclusive: Start Conditions. (line 53)
start conditions, for different interpretations of same input: Start Conditions.
start conditions, in patterns: Patterns. (line 140)
start conditions, inclusive: Start Conditions. (line 44)
start conditions, inclusive v.s. exclusive: Start Conditions.
start conditions, integer values: Start Conditions. (line 163)
start conditions, multiple: Start Conditions. (line 17)
start conditions, special wildcard condition: Start Conditions.
start conditions, use of a stack: Start Conditions. (line 286)
start conditions, use of wildcard condition (<*>): Start Conditions.
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.
tables, creating serialized: Creating Serialized Tables.
tables, file format: Tables File Format. (line 6)
tables, freeing: Loading and Unloading Serialized Tables.
tables, loading and unloading: Loading and Unloading Serialized Tables.
terminating with yyterminate(): Actions. (line 212)
token: Matching. (line 14)
trailing context, in patterns: Patterns. (line 118)
trailing context, limits of: Patterns. (line 275)
trailing context, matching: Matching. (line 6)
trailing context, performance costs: Performance. (line 12)
trailing context, variable length: Performance. (line 141)
unput(): Actions. (line 143)
unput(), and %pointer: Actions. (line 162)
unput(), pushing back characters: Actions. (line 147)
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.
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)
yyalloc, overriding: Overriding The Default Memory Management.
yyfree, overriding: Overriding The Default Memory Management.
yyin: Generated Scanner. (line 37)
yyinput(): Actions. (line 202)
yyleng: Matching. (line 14)
yyleng, modification of: Actions. (line 47)
yyless(): Actions. (line 125)
yyless(), pushing back characters: Actions. (line 131)
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 104)
yymore() to append token to previous token: Actions. (line 110)
yymore(), mega-kludge: Actions. (line 110)
yymore, and yyleng: Actions. (line 47)
yymore, performance penalty of: Actions. (line 119)
yyout: Generated Scanner. (line 101)
yyrealloc, overriding: Overriding The Default Memory Management.
yyrestart(): Generated Scanner. (line 42)
yyterminate(): Actions. (line 212)
yytext: Matching. (line 14)
yytext, default array size: User Values. (line 13)
yytext, memory considerations: A Note About yytext And Memory.
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)
YY_CURRENT_BUFFER, and multiple buffers Finally, the macro: Multiple Input Buffers.
YY_EXTRA_TYPE, defining your own type: Extra Data. (line 33)
YY_FLUSH_BUFFER: Actions. (line 206)
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.

automatically generated by info2www version 1.2.2.9