1 .\" $FreeBSD: src/usr.bin/lex/lex.1,v 1.10.2.6 2003/02/24 22:37:41 trhodes Exp $
2 .\" $DragonFly: src/usr.bin/lex/lex.1,v 1.2 2003/06/17 04:29:27 dillon Exp $
4 .TH FLEX 1 "April 1995" "Version 2.5"
6 flex \- fast lexical analyzer generator
9 .B [\-bcdfhilnpstvwBFILTV78+? \-C[aefFmr] \-ooutput \-Pprefix \-Sskeleton]
10 .B [\-\-help \-\-version]
15 a tool for generating programs that perform pattern-matching on text. The
16 manual includes both tutorial and reference sections:
20 a brief overview of the tool
24 Format Of The Input File
27 the extended regular expressions used by flex
29 How The Input Is Matched
30 the rules for determining what has been matched
33 how to specify what to do when a pattern is matched
36 details regarding the scanner that flex produces;
37 how to control the input source
40 introducing context into your scanners, and
41 managing "mini-scanners"
43 Multiple Input Buffers
44 how to manipulate multiple input sources; how to
45 scan from strings instead of files
48 special rules for matching the end of the input
51 a summary of macros available to the actions
53 Values Available To The User
54 a summary of values available to the actions
57 connecting flex scanners together with yacc parsers
60 flex command-line options, and the "%option"
63 Performance Considerations
64 how to make your scanner go as fast as possible
66 Generating C++ Scanners
67 the (experimental) facility for generating C++
70 Incompatibilities With Lex And POSIX
71 how flex differs from AT&T lex and the POSIX lex
75 those error messages produced by flex (or scanners
76 it generates) whose meanings might not be apparent
82 known problems with flex
85 other documentation, related tools
88 includes contact information
93 is a tool for generating
95 programs which recognize lexical patterns in text.
98 the given input files, or its standard input if no file names are given,
99 for a description of a scanner to generate. The description is in
101 of regular expressions and C code, called
103 generates as output a C source file,
105 which defines a routine
107 This file is compiled and linked with the
109 library to produce an executable. When the executable is run,
110 it analyzes its input for occurrences
111 of the regular expressions. Whenever it finds one, it executes
112 the corresponding C code.
113 .SH SOME SIMPLE EXAMPLES
114 First some simple examples to get the flavor of how one uses
118 input specifies a scanner which whenever it encounters the string
119 "username" will replace it with the user's login name:
123 username printf( "%s", getlogin() );
126 By default, any text not matched by a
129 is copied to the output, so the net effect of this scanner is
130 to copy its input file to its output with each occurrence
131 of "username" expanded.
132 In this input, there is just one rule. "username" is the
134 and the "printf" is the
136 The "%%" marks the beginning of the rules.
138 Here's another simple example:
142 int num_lines = 0, num_chars = 0;
146 \\n ++num_lines; ++num_chars;
153 printf( "# of lines = %d, # of chars = %d\\n",
154 num_lines, num_chars );
158 This scanner counts the number of characters and the number
159 of lines in its input (it produces no output other than the
160 final report on the counts). The first line
161 declares two globals, "num_lines" and "num_chars", which are accessible
166 routine declared after the second "%%". There are two rules, one
167 which matches a newline ("\\n") and increments both the line count and
168 the character count, and one which matches any character other than
169 a newline (indicated by the "." regular expression).
171 A somewhat more complicated example:
174 /* scanner for a toy Pascal-like language */
177 /* need this for the call to atof() below */
187 printf( "An integer: %s (%d)\\n", yytext,
191 {DIGIT}+"."{DIGIT}* {
192 printf( "A float: %s (%g)\\n", yytext,
196 if|then|begin|end|procedure|function {
197 printf( "A keyword: %s\\n", yytext );
200 {ID} printf( "An identifier: %s\\n", yytext );
202 "+"|"-"|"*"|"/" printf( "An operator: %s\\n", yytext );
204 "{"[^}\\n]*"}" /* eat up one-line comments */
206 [ \\t\\n]+ /* eat up whitespace */
208 . printf( "Unrecognized character: %s\\n", yytext );
216 ++argv, --argc; /* skip over program name */
218 yyin = fopen( argv[0], "r" );
226 This is the beginnings of a simple scanner for a language like
227 Pascal. It identifies different types of
229 and reports on what it has seen.
231 The details of this example will be explained in the following
233 .SH FORMAT OF THE INPUT FILE
236 input file consists of three sections, separated by a line with just
250 section contains declarations of simple
252 definitions to simplify the scanner specification, and declarations of
254 which are explained in a later section.
256 Name definitions have the form:
262 The "name" is a word beginning with a letter or an underscore ('_')
263 followed by zero or more letters, digits, '_', or '-' (dash).
264 The definition is taken to begin at the first non-white-space character
265 following the name and continuing to the end of the line.
266 The definition can subsequently be referred to using "{name}", which
267 will expand to "(definition)". For example,
274 defines "DIGIT" to be a regular expression which matches a
276 "ID" to be a regular expression which matches a letter
277 followed by zero-or-more letters-or-digits.
278 A subsequent reference to
290 and matches one-or-more digits followed by a '.' followed
291 by zero-or-more digits.
297 input contains a series of rules of the form:
303 where the pattern must be unindented and the action must begin
306 See below for a further description of patterns and actions.
308 Finally, the user code section is simply copied to
311 It is used for companion routines which call or are called
312 by the scanner. The presence of this section is optional;
313 if it is missing, the second
315 in the input file may be skipped, too.
317 In the definitions and rules sections, any
319 text or text enclosed in
323 is copied verbatim to the output (with the %{}'s removed).
324 The %{}'s must appear unindented on lines by themselves.
326 In the rules section,
327 any indented or %{} text appearing before the
328 first rule may be used to declare variables
329 which are local to the scanning routine and (after the declarations)
330 code which is to be executed whenever the scanning routine is entered.
331 Other indented or %{} text in the rule section is still copied to the output,
332 but its meaning is not well-defined and it may well cause compile-time
333 errors (this feature is present for
335 compliance; see below for other such features).
337 In the definitions section (but not in the rules section),
338 an unindented comment (i.e., a line
339 beginning with "/*") is also copied verbatim to the output up
342 The patterns in the input are written using an extended set of regular
343 expressions. These are:
346 x match the character 'x'
347 . any character (byte) except newline
348 [xyz] a "character class"; in this case, the pattern
349 matches either an 'x', a 'y', or a 'z'
350 [abj-oZ] a "character class" with a range in it; matches
351 an 'a', a 'b', any letter from 'j' through 'o',
353 [^A-Z] a "negated character class", i.e., any character
354 but those in the class. In this case, any
355 character EXCEPT an uppercase letter.
356 [^A-Z\\n] any character EXCEPT an uppercase letter or
358 r* zero or more r's, where r is any regular expression
360 r? zero or one r's (that is, "an optional r")
361 r{2,5} anywhere from two to five r's
362 r{2,} two or more r's
364 {name} the expansion of the "name" definition
367 the literal string: [xyz]"foo
368 \\X if X is an 'a', 'b', 'f', 'n', 'r', 't', or 'v',
369 then the ANSI-C interpretation of \\x.
370 Otherwise, a literal 'X' (used to escape
371 operators such as '*')
372 \\0 a NUL character (ASCII code 0)
373 \\123 the character with octal value 123
374 \\x2a the character with hexadecimal value 2a
375 (r) match an r; parentheses are used to override
376 precedence (see below)
379 rs the regular expression r followed by the
380 regular expression s; called "concatenation"
383 r|s either an r or an s
386 r/s an r but only if it is followed by an s. The
387 text matched by s is included when determining
388 whether this rule is the "longest match",
389 but is then returned to the input before
390 the action is executed. So the action only
391 sees the text matched by r. This type
392 of pattern is called trailing context".
393 (There are some combinations of r/s that flex
394 cannot match correctly; see notes in the
395 Deficiencies / Bugs section below regarding
396 "dangerous trailing context".)
397 ^r an r, but only at the beginning of a line (i.e.,
398 which just starting to scan, or right after a
399 newline has been scanned).
400 r$ an r, but only at the end of a line (i.e., just
401 before a newline). Equivalent to "r/\\n".
403 Note that flex's notion of "newline" is exactly
404 whatever the C compiler used to compile flex
405 interprets '\\n' as; in particular, on some DOS
406 systems you must either filter out \\r's in the
407 input yourself, or explicitly use r/\\r\\n for "r$".
410 <s>r an r, but only in start condition s (see
411 below for discussion of start conditions)
413 same, but in any of start conditions s1,
415 <*>r an r in any start condition, even an exclusive one.
418 <<EOF>> an end-of-file
420 an end-of-file when in start condition s1 or s2
423 Note that inside of a character class, all regular expression operators
424 lose their special meaning except escape ('\\') and the character class
425 operators, '-', ']', and, at the beginning of the class, '^'.
427 The regular expressions listed above are grouped according to
428 precedence, from highest precedence at the top to lowest at the bottom.
429 Those grouped together have equal precedence. For example,
441 since the '*' operator has higher precedence than concatenation,
442 and concatenation higher than alternation ('|'). This pattern
447 the string "ba" followed by zero-or-more r's.
448 To match "foo" or zero-or-more "bar"'s, use:
454 and to match zero-or-more "foo"'s-or-"bar"'s:
461 In addition to characters and ranges of characters, character classes
462 can also contain character class
464 These are expressions enclosed inside
468 delimiters (which themselves must appear between the '[' and ']' of the
469 character class; other elements may occur inside the character class, too).
470 The valid expressions are:
473 [:alnum:] [:alpha:] [:blank:]
474 [:cntrl:] [:digit:] [:graph:]
475 [:lower:] [:print:] [:punct:]
476 [:space:] [:upper:] [:xdigit:]
479 These expressions all designate a set of characters equivalent to
480 the corresponding standard C
482 function. For example,
484 designates those characters for which
486 returns true - i.e., any alphabetic or numeric.
487 Some systems don't provide
493 For example, the following character classes are all equivalent:
502 If your scanner is case-insensitive (the
511 Some notes on patterns:
513 A negated character class such as the example "[^A-Z]"
515 .I will match a newline
516 unless "\\n" (or an equivalent escape sequence) is one of the
517 characters explicitly present in the negated character class
518 (e.g., "[^A-Z\\n]"). This is unlike how many other regular
519 expression tools treat negated character classes, but unfortunately
520 the inconsistency is historically entrenched.
521 Matching newlines means that a pattern like [^"]* can match the entire
522 input unless there's another quote in the input.
524 A rule can have at most one instance of trailing context (the '/' operator
525 or the '$' operator). The start condition, '^', and "<<EOF>>" patterns
526 can only occur at the beginning of a pattern, and, as well as with '/' and '$',
527 cannot be grouped inside parentheses. A '^' which does not occur at
528 the beginning of a rule or a '$' which does not occur at the end of
529 a rule loses its special properties and is treated as a normal character.
531 The following are illegal:
538 Note that the first of these, can be written "foo/bar\\n".
540 The following will result in '$' or '^' being treated as a normal character:
547 If what's wanted is a "foo" or a bar-followed-by-a-newline, the following
548 could be used (the special '|' action is explained below):
552 bar$ /* action goes here */
555 A similar trick will work for matching a foo or a
556 bar-at-the-beginning-of-a-line.
557 .SH HOW THE INPUT IS MATCHED
558 When the generated scanner is run, it analyzes its input looking
559 for strings which match any of its patterns. If it finds more than
560 one match, it takes the one matching the most text (for trailing
561 context rules, this includes the length of the trailing part, even
562 though it will then be returned to the input). If it finds two
563 or more matches of the same length, the
564 rule listed first in the
566 input file is chosen.
568 Once the match is determined, the text corresponding to the match
571 is made available in the global character pointer
573 and its length in the global integer
577 corresponding to the matched pattern is then executed (a more
578 detailed description of actions follows), and then the remaining
579 input is scanned for another match.
581 If no match is found, then the
583 is executed: the next character in the input is considered matched and
584 copied to the standard output. Thus, the simplest legal
592 which generates a scanner that simply copies its input (one character
593 at a time) to its output.
597 can be defined in two different ways: either as a character
601 You can control which definition
603 uses by including one of the special directives
607 in the first (definitions) section of your flex input. The default is
611 lex compatibility option, in which case
614 The advantage of using
616 is substantially faster scanning and no buffer overflow when matching
617 very large tokens (unless you run out of dynamic memory). The disadvantage
618 is that you are restricted in how your actions can modify
620 (see the next section), and calls to the
622 function destroys the present contents of
624 which can be a considerable porting headache when moving between different
630 is that you can then modify
632 to your heart's content, and calls to
636 (see below). Furthermore, existing
638 programs sometimes access
640 externally using declarations of the form:
642 extern char yytext[];
644 This definition is erroneous when used with
654 characters, which defaults to a fairly large value. You can change
655 the size by simply #define'ing
657 to a different value in the first section of your
659 input. As mentioned above, with
661 yytext grows dynamically to accommodate large tokens. While this means your
663 scanner can accommodate very large tokens (such as matching entire blocks
664 of comments), bear in mind that each time the scanner must resize
666 it also must rescan the entire token from the beginning, so matching such
667 tokens can prove slow.
671 dynamically grow if a call to
673 results in too much text being pushed back; instead, a run-time error results.
675 Also note that you cannot use
677 with C++ scanner classes
682 Each pattern in a rule has a corresponding action, which can be any
683 arbitrary C statement. The pattern ends at the first non-escaped
684 whitespace character; the remainder of the line is its action. If the
685 action is empty, then when the pattern is matched the input token
686 is simply discarded. For example, here is the specification for a program
687 which deletes all occurrences of "zap me" from its input:
694 (It will copy all other characters in the input to the output since
695 they will be matched by the default rule.)
697 Here is a program which compresses multiple blanks and tabs down to
698 a single blank, and throws away whitespace found at the end of a line:
702 [ \\t]+ putchar( ' ' );
703 [ \\t]+$ /* ignore this token */
707 If the action contains a '{', then the action spans till the balancing '}'
708 is found, and the action may cross multiple lines.
710 knows about C strings and comments and won't be fooled by braces found
711 within them, but also allows actions to begin with
713 and will consider the action to be all the text up to the next
715 (regardless of ordinary braces inside the action).
717 An action consisting solely of a vertical bar ('|') means "same as
718 the action for the next rule." See below for an illustration.
720 Actions can include arbitrary C code, including
722 statements to return a value to whatever routine called
726 is called it continues processing tokens from where it last left
727 off until it either reaches
728 the end of the file or executes a return.
730 Actions are free to modify
732 except for lengthening it (adding
733 characters to its end--these will overwrite later characters in the
734 input stream). This however does not apply when using
736 (see above); in that case,
738 may be freely modified in any way.
740 Actions are free to modify
742 except they should not do so if the action also includes use of
746 There are a number of special directives which can be included within
750 copies yytext to the scanner's output.
753 followed by the name of a start condition places the scanner in the
754 corresponding start condition (see below).
757 directs the scanner to proceed on to the "second best" rule which matched the
758 input (or a prefix of the input). The rule is chosen as described
759 above in "How the Input is Matched", and
763 set up appropriately.
764 It may either be one which matched as much text
765 as the originally chosen rule but came later in the
767 input file, or one which matched less text.
768 For example, the following will both count the
769 words in the input and call the routine special() whenever "frob" is seen:
775 frob special(); REJECT;
776 [^ \\t\\n]+ ++word_count;
781 any "frob"'s in the input would not be counted as words, since the
782 scanner normally executes only one action per token.
785 are allowed, each one finding the next best choice to the currently
786 active rule. For example, when the following scanner scans the token
787 "abcd", it will write "abcdabcaba" to the output:
795 .|\\n /* eat up any unmatched character */
798 (The first three rules share the fourth's action since they use
799 the special '|' action.)
801 is a particularly expensive feature in terms of scanner performance;
804 of the scanner's actions it will slow down
806 of the scanner's matching. Furthermore,
808 cannot be used with the
814 Note also that unlike the other special actions,
818 code immediately following it in the action will
823 tells the scanner that the next time it matches a rule, the corresponding
826 onto the current value of
828 rather than replacing it. For example, given the input "mega-kludge"
829 the following will write "mega-mega-kludge" to the output:
833 mega- ECHO; yymore();
837 First "mega-" is matched and echoed to the output. Then "kludge"
838 is matched, but the previous "mega-" is still hanging around at the
843 for the "kludge" rule will actually write "mega-kludge".
845 Two notes regarding use of
849 depends on the value of
851 correctly reflecting the size of the current token, so you must not
856 Second, the presence of
858 in the scanner's action entails a minor performance penalty in the
859 scanner's matching speed.
862 returns all but the first
864 characters of the current token back to the input stream, where they
865 will be rescanned when the scanner looks for the next match.
869 are adjusted appropriately (e.g.,
873 ). For example, on the input "foobar" the following will write out
878 foobar ECHO; yyless(3);
884 will cause the entire current input string to be scanned again. Unless you've
885 changed how the scanner will subsequently process its input (using
887 for example), this will result in an endless loop.
891 is a macro and can only be used in the flex input file, not from
897 back onto the input stream. It will be the next character scanned.
898 The following action will take the current token and cause it
899 to be rescanned enclosed in parentheses.
904 /* Copy yytext because unput() trashes yytext */
905 char *yycopy = strdup( yytext );
907 for ( i = yyleng - 1; i >= 0; --i )
916 puts the given character back at the
918 of the input stream, pushing back strings must be done back-to-front.
920 An important potential problem when using
922 is that if you are using
924 (the default), a call to
929 starting with its rightmost character and devouring one character to
930 the left with each call. If you need the value of yytext preserved
933 (as in the above example),
934 you must either first copy it elsewhere, or build your scanner using
936 instead (see How The Input Is Matched).
938 Finally, note that you cannot put back
940 to attempt to mark the input stream with an end-of-file.
943 reads the next character from the input stream. For example,
944 the following is one way to eat up C comments:
953 while ( (c = input()) != '*' &&
955 ; /* eat up text of comment */
959 while ( (c = input()) == '*' )
962 break; /* found the end */
967 error( "EOF in comment" );
974 (Note that if the scanner is compiled using
978 is instead referred to as
980 in order to avoid a name clash with the
982 stream by the name of
986 flushes the scanner's internal buffer
987 so that the next time the scanner attempts to match a token, it will
988 first refill the buffer using
990 (see The Generated Scanner, below). This action is a special case
993 function, described below in the section Multiple Input Buffers.
996 can be used in lieu of a return statement in an action. It terminates
997 the scanner and returns a 0 to the scanner's caller, indicating "all done".
1000 is also called when an end-of-file is encountered. It is a macro and
1002 .SH THE GENERATED SCANNER
1007 which contains the scanning routine
1009 a number of tables used by it for matching tokens, and a number
1010 of auxiliary routines and macros. By default,
1012 is declared as follows:
1017 ... various definitions and the actions in here ...
1021 (If your environment supports function prototypes, then it will
1022 be "int yylex( void )".) This definition may be changed by defining
1023 the "YY_DECL" macro. For example, you could use:
1026 #define YY_DECL float lexscan( a, b ) float a, b;
1029 to give the scanning routine the name
1031 returning a float, and taking two floats as arguments. Note that
1032 if you give arguments to the scanning routine using a
1033 K&R-style/non-prototyped function declaration, you must terminate
1034 the definition with a semi-colon (;).
1038 is called, it scans tokens from the global input file
1040 (which defaults to stdin). It continues until it either reaches
1041 an end-of-file (at which point it returns the value 0) or
1042 one of its actions executes a
1046 If the scanner reaches an end-of-file, subsequent calls are undefined
1049 is pointed at a new input file (in which case scanning continues from
1054 takes one argument, a
1056 pointer (which can be nil, if you've set up
1058 to scan from a source other than
1062 for scanning from that file. Essentially there is no difference between
1065 to a new input file or using
1067 to do so; the latter is available for compatibility with previous versions
1070 and because it can be used to switch input files in the middle of scanning.
1071 It can also be used to throw away the current input buffer, by calling
1072 it with an argument of
1074 but better is to use
1081 reset the start condition to
1083 (see Start Conditions, below).
1087 stops scanning due to executing a
1089 statement in one of the actions, the scanner may then be called again and it
1090 will resume scanning where it left off.
1092 By default (and for purposes of efficiency), the scanner uses
1093 block-reads rather than simple
1095 calls to read characters from
1097 The nature of how it gets its input can be controlled by defining the
1100 YY_INPUT's calling sequence is "YY_INPUT(buf,result,max_size)". Its
1101 action is to place up to
1103 characters in the character array
1105 and return in the integer variable
1108 number of characters read or the constant YY_NULL (0 on Unix systems)
1109 to indicate EOF. The default YY_INPUT reads from the
1110 global file-pointer "yyin".
1112 A sample definition of YY_INPUT (in the definitions
1113 section of the input file):
1117 #define YY_INPUT(buf,result,max_size) \\
1119 int c = getchar(); \\
1120 result = (c == EOF) ? YY_NULL : (buf[0] = c, 1); \\
1125 This definition will change the input processing to occur
1126 one character at a time.
1128 When the scanner receives an end-of-file indication from YY_INPUT,
1133 returns false (zero), then it is assumed that the
1134 function has gone ahead and set up
1136 to point to another input file, and scanning continues. If it returns
1137 true (non-zero), then the scanner terminates, returning 0 to its
1138 caller. Note that in either case, the start condition remains unchanged;
1144 If you do not supply your own version of
1146 then you must either use
1148 (in which case the scanner behaves as though
1150 returned 1), or you must link with
1152 to obtain the default version of the routine, which always returns 1.
1154 Three routines are available for scanning from in-memory buffers rather
1156 .B yy_scan_string(), yy_scan_bytes(),
1158 .B yy_scan_buffer().
1159 See the discussion of them below in the section Multiple Input Buffers.
1161 The scanner writes its
1165 global (default, stdout), which may be redefined by the user simply
1166 by assigning it to some other
1169 .SH START CONDITIONS
1171 provides a mechanism for conditionally activating rules. Any rule
1172 whose pattern is prefixed with "<sc>" will only be active when
1173 the scanner is in the start condition named "sc". For example,
1176 <STRING>[^"]* { /* eat up the string body ... */
1181 will be active only when the scanner is in the "STRING" start
1185 <INITIAL,STRING,QUOTE>\\. { /* handle an escape ... */
1190 will be active only when the current start condition is
1191 either "INITIAL", "STRING", or "QUOTE".
1194 are declared in the definitions (first) section of the input
1195 using unindented lines beginning with either
1199 followed by a list of names.
1202 start conditions, the latter
1204 start conditions. A start condition is activated using the
1206 action. Until the next
1208 action is executed, rules with the given start
1209 condition will be active and
1210 rules with other start conditions will be inactive.
1211 If the start condition is
1213 then rules with no start conditions at all will also be active.
1218 rules qualified with the start condition will be active.
1219 A set of rules contingent on the same exclusive start condition
1220 describe a scanner which is independent of any of the other rules in the
1222 input. Because of this,
1223 exclusive start conditions make it easy to specify "mini-scanners"
1224 which scan portions of the input that are syntactically different
1225 from the rest (e.g., comments).
1227 If the distinction between inclusive and exclusive start conditions
1228 is still a little vague, here's a simple example illustrating the
1229 connection between the two. The set of rules:
1235 <example>foo do_something();
1237 bar something_else();
1246 <example>foo do_something();
1248 <INITIAL,example>bar something_else();
1252 .B <INITIAL,example>
1255 pattern in the second example wouldn't be active (i.e., couldn't match)
1256 when in start condition
1262 though, then it would only be active in
1266 while in the first example it's active in both, because in the first
1269 start condition is an
1274 Also note that the special start-condition specifier
1276 matches every start condition. Thus, the above example could also
1283 <example>foo do_something();
1285 <*>bar something_else();
1289 The default rule (to
1291 any unmatched character) remains active in start conditions. It
1300 returns to the original state where only the rules with
1301 no start conditions are active. This state can also be
1302 referred to as the start-condition "INITIAL", so
1306 (The parentheses around the start condition name are not required but
1307 are considered good style.)
1310 actions can also be given as indented code at the beginning
1311 of the rules section. For example, the following will cause
1312 the scanner to enter the "SPECIAL" start condition whenever
1314 is called and the global variable
1323 if ( enter_special )
1326 <SPECIAL>blahblahblah
1327 ...more rules follow...
1331 To illustrate the uses of start conditions,
1332 here is a scanner which provides two different interpretations
1333 of a string like "123.456". By default it will treat it as
1334 three tokens, the integer "123", a dot ('.'), and the integer "456".
1335 But if the string is preceded earlier in the line by the string
1337 it will treat it as a single token, the floating-point number
1347 expect-floats BEGIN(expect);
1349 <expect>[0-9]+"."[0-9]+ {
1350 printf( "found a float, = %f\\n",
1354 /* that's the end of the line, so
1355 * we need another "expect-number"
1356 * before we'll recognize any more
1363 printf( "found an integer, = %d\\n",
1367 "." printf( "found a dot\\n" );
1370 Here is a scanner which recognizes (and discards) C comments while
1371 maintaining a count of the current input line.
1378 "/*" BEGIN(comment);
1380 <comment>[^*\\n]* /* eat anything that's not a '*' */
1381 <comment>"*"+[^*/\\n]* /* eat up '*'s not followed by '/'s */
1382 <comment>\\n ++line_num;
1383 <comment>"*"+"/" BEGIN(INITIAL);
1386 This scanner goes to a bit of trouble to match as much
1387 text as possible with each rule. In general, when attempting to write
1388 a high-speed scanner try to match as much possible in each rule, as
1391 Note that start-conditions names are really integer values and
1392 can be stored as such. Thus, the above could be extended in the
1402 comment_caller = INITIAL;
1409 comment_caller = foo;
1413 <comment>[^*\\n]* /* eat anything that's not a '*' */
1414 <comment>"*"+[^*/\\n]* /* eat up '*'s not followed by '/'s */
1415 <comment>\\n ++line_num;
1416 <comment>"*"+"/" BEGIN(comment_caller);
1419 Furthermore, you can access the current start condition using
1422 macro. For example, the above assignments to
1424 could instead be written
1427 comment_caller = YY_START;
1434 (since that is what's used by AT&T
1437 Note that start conditions do not have their own name-space; %s's and %x's
1438 declare names in the same fashion as #define's.
1440 Finally, here's an example of how to match C-style quoted strings using
1441 exclusive start conditions, including expanded escape sequences (but
1442 not including checking for a string that's too long):
1448 char string_buf[MAX_STR_CONST];
1449 char *string_buf_ptr;
1452 \\" string_buf_ptr = string_buf; BEGIN(str);
1454 <str>\\" { /* saw closing quote - all done */
1456 *string_buf_ptr = '\\0';
1457 /* return string constant token type and
1463 /* error - unterminated string constant */
1464 /* generate error message */
1467 <str>\\\\[0-7]{1,3} {
1468 /* octal escape sequence */
1471 (void) sscanf( yytext + 1, "%o", &result );
1473 if ( result > 0xff )
1474 /* error, constant is out-of-bounds */
1476 *string_buf_ptr++ = result;
1480 /* generate error - bad escape sequence; something
1481 * like '\\48' or '\\0777777'
1485 <str>\\\\n *string_buf_ptr++ = '\\n';
1486 <str>\\\\t *string_buf_ptr++ = '\\t';
1487 <str>\\\\r *string_buf_ptr++ = '\\r';
1488 <str>\\\\b *string_buf_ptr++ = '\\b';
1489 <str>\\\\f *string_buf_ptr++ = '\\f';
1491 <str>\\\\(.|\\n) *string_buf_ptr++ = yytext[1];
1493 <str>[^\\\\\\n\\"]+ {
1494 char *yptr = yytext;
1497 *string_buf_ptr++ = *yptr++;
1502 Often, such as in some of the examples above, you wind up writing a
1503 whole bunch of rules all preceded by the same start condition(s). Flex
1504 makes this a little easier and cleaner by introducing a notion of
1507 A start condition scope is begun with:
1515 is a list of one or more start conditions. Inside the start condition
1516 scope, every rule automatically has the prefix
1518 applied to it, until a
1520 which matches the initial
1526 "\\\\n" return '\\n';
1527 "\\\\r" return '\\r';
1528 "\\\\f" return '\\f';
1529 "\\\\0" return '\\0';
1536 <ESC>"\\\\n" return '\\n';
1537 <ESC>"\\\\r" return '\\r';
1538 <ESC>"\\\\f" return '\\f';
1539 <ESC>"\\\\0" return '\\0';
1542 Start condition scopes may be nested.
1544 Three routines are available for manipulating stacks of start conditions:
1546 .B void yy_push_state(int new_state)
1547 pushes the current start condition onto the top of the start condition
1548 stack and switches to
1550 as though you had used
1552 (recall that start condition names are also integers).
1554 .B void yy_pop_state()
1555 pops the top of the stack and switches to it via
1558 .B int yy_top_state()
1559 returns the top of the stack without altering the stack's contents.
1561 The start condition stack grows dynamically and so has no built-in
1562 size limitation. If memory is exhausted, program execution aborts.
1564 To use start condition stacks, your scanner must include a
1566 directive (see Options below).
1567 .SH MULTIPLE INPUT BUFFERS
1568 Some scanners (such as those which support "include" files)
1569 require reading from several input streams. As
1571 scanners do a large amount of buffering, one cannot control
1572 where the next input will be read from by simply writing a
1574 which is sensitive to the scanning context.
1576 is only called when the scanner reaches the end of its buffer, which
1577 may be a long time after scanning a statement such as an "include"
1578 which requires switching the input source.
1580 To negotiate these sorts of problems,
1582 provides a mechanism for creating and switching between multiple
1583 input buffers. An input buffer is created by using:
1586 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1591 pointer and a size and creates a buffer associated with the given
1592 file and large enough to hold
1594 characters (when in doubt, use
1596 for the size). It returns a
1598 handle, which may then be passed to other routines (see below). The
1600 type is a pointer to an opaque
1601 .B struct yy_buffer_state
1602 structure, so you may safely initialize YY_BUFFER_STATE variables to
1603 .B ((YY_BUFFER_STATE) 0)
1604 if you wish, and also refer to the opaque structure in order to
1605 correctly declare input buffers in source files other than that
1606 of your scanner. Note that the
1608 pointer in the call to
1610 is only used as the value of
1616 so it no longer uses
1618 then you can safely pass a nil
1621 .B yy_create_buffer.
1622 You select a particular buffer to scan from using:
1625 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1628 switches the scanner's input buffer so subsequent tokens will
1632 .B yy_switch_to_buffer()
1633 may be used by yywrap() to set things up for continued scanning, instead
1634 of opening a new file and pointing
1636 at it. Note also that switching input sources via either
1637 .B yy_switch_to_buffer()
1642 change the start condition.
1645 void yy_delete_buffer( YY_BUFFER_STATE buffer )
1648 is used to reclaim the storage associated with a buffer. (
1650 can be nil, in which case the routine does nothing.)
1651 You can also clear the current contents of a buffer using:
1654 void yy_flush_buffer( YY_BUFFER_STATE buffer )
1657 This function discards the buffer's contents,
1658 so the next time the scanner attempts to match a token from the
1659 buffer, it will first fill the buffer anew using
1664 .B yy_create_buffer(),
1665 provided for compatibility with the C++ use of
1669 for creating and destroying dynamic objects.
1672 .B YY_CURRENT_BUFFER
1675 handle to the current buffer.
1677 Here is an example of using these features for writing a scanner
1678 which expands include files (the
1680 feature is discussed below):
1683 /* the "incl" state is used for picking up the name
1684 * of an include file
1689 #define MAX_INCLUDE_DEPTH 10
1690 YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
1691 int include_stack_ptr = 0;
1695 include BEGIN(incl);
1698 [^a-z\\n]*\\n? ECHO;
1700 <incl>[ \\t]* /* eat the whitespace */
1701 <incl>[^ \\t\\n]+ { /* got the include file name */
1702 if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
1704 fprintf( stderr, "Includes nested too deeply" );
1708 include_stack[include_stack_ptr++] =
1711 yyin = fopen( yytext, "r" );
1716 yy_switch_to_buffer(
1717 yy_create_buffer( yyin, YY_BUF_SIZE ) );
1723 if ( --include_stack_ptr < 0 )
1730 yy_delete_buffer( YY_CURRENT_BUFFER );
1731 yy_switch_to_buffer(
1732 include_stack[include_stack_ptr] );
1737 Three routines are available for setting up input buffers for
1738 scanning in-memory strings instead of files. All of them create
1739 a new input buffer for scanning the string, and return a corresponding
1741 handle (which you should delete with
1742 .B yy_delete_buffer()
1743 when done with it). They also switch to the new buffer using
1744 .B yy_switch_to_buffer(),
1747 will start scanning the string.
1749 .B yy_scan_string(const char *str)
1750 scans a NUL-terminated string.
1752 .B yy_scan_bytes(const char *bytes, int len)
1755 bytes (including possibly NUL's)
1756 starting at location
1759 Note that both of these functions create and scan a
1761 of the string or bytes. (This may be desirable, since
1763 modifies the contents of the buffer it is scanning.) You can avoid the
1766 .B yy_scan_buffer(char *base, yy_size_t size)
1767 which scans in place the buffer starting at
1771 bytes, the last two bytes of which
1774 .B YY_END_OF_BUFFER_CHAR
1776 These last two bytes are not scanned; thus, scanning
1783 If you fail to set up
1785 in this manner (i.e., forget the final two
1786 .B YY_END_OF_BUFFER_CHAR
1789 returns a nil pointer instead of creating a new input buffer.
1793 is an integral type to which you can cast an integer expression
1794 reflecting the size of the buffer.
1795 .SH END-OF-FILE RULES
1796 The special rule "<<EOF>>" indicates
1797 actions which are to be taken when an end-of-file is
1798 encountered and yywrap() returns non-zero (i.e., indicates
1799 no further files to process). The action must finish
1800 by doing one of four things:
1804 to a new input file (in previous versions of flex, after doing the
1805 assignment you had to call the special action
1807 this is no longer necessary);
1813 executing the special
1817 or, switching to a new buffer using
1818 .B yy_switch_to_buffer()
1819 as shown in the example above.
1821 <<EOF>> rules may not be used with other
1822 patterns; they may only be qualified with a list of start
1823 conditions. If an unqualified <<EOF>> rule is given, it
1826 start conditions which do not already have <<EOF>> actions. To
1827 specify an <<EOF>> rule for only the initial start condition, use
1834 These rules are useful for catching things like unclosed comments.
1841 ...other rules for dealing with quotes...
1844 error( "unterminated quote" );
1849 yyin = fopen( *filelist, "r" );
1855 .SH MISCELLANEOUS MACROS
1858 can be defined to provide an action
1859 which is always executed prior to the matched rule's action. For example,
1860 it could be #define'd to call a routine to convert yytext to lower-case.
1863 is invoked, the variable
1865 gives the number of the matched rule (rules are numbered starting with 1).
1866 Suppose you want to profile how often each of your rules is matched. The
1867 following would do the trick:
1870 #define YY_USER_ACTION ++ctr[yy_act]
1875 is an array to hold the counts for the different rules. Note that
1878 gives the total number of rules (including the default rule, even if
1881 so a correct declaration for
1886 int ctr[YY_NUM_RULES];
1892 may be defined to provide an action which is always executed before
1893 the first scan (and before the scanner's internal initializations are done).
1894 For example, it could be used to call a routine to read
1895 in a data table or open a logging file.
1898 .B yy_set_interactive(is_interactive)
1899 can be used to control whether the current buffer is considered
1901 An interactive buffer is processed more slowly,
1902 but must be used when the scanner's input source is indeed
1903 interactive to avoid problems due to waiting to fill buffers
1904 (see the discussion of the
1906 flag below). A non-zero value
1907 in the macro invocation marks the buffer as interactive, a zero
1908 value as non-interactive. Note that use of this macro overrides
1909 .B %option interactive ,
1910 .B %option always-interactive
1912 .B %option never-interactive
1913 (see Options below).
1914 .B yy_set_interactive()
1915 must be invoked prior to beginning to scan the buffer that is
1916 (or is not) to be considered interactive.
1919 .B yy_set_bol(at_bol)
1920 can be used to control whether the current buffer's scanning
1921 context for the next token match is done as though at the
1922 beginning of a line. A non-zero macro argument makes rules anchored with
1923 \&'^' active, while a zero argument makes '^' rules inactive.
1927 returns true if the next token scanned from the current buffer
1928 will have '^' rules active, false otherwise.
1930 In the generated scanner, the actions are all gathered in one large
1931 switch statement and separated using
1933 which may be redefined. By default, it is simply a "break", to separate
1934 each rule's action from the following rule's.
1937 allows, for example, C++ users to
1938 #define YY_BREAK to do nothing (while being very careful that every
1939 rule ends with a "break" or a "return"!) to avoid suffering from
1940 unreachable statement warnings where because a rule's action ends with
1944 .SH VALUES AVAILABLE TO THE USER
1945 This section summarizes the various values available to the user
1946 in the rule actions.
1949 holds the text of the current token. It may be modified but not lengthened
1950 (you cannot append characters to the end).
1952 If the special directive
1954 appears in the first section of the scanner description, then
1957 .B char yytext[YYLMAX],
1960 is a macro definition that you can redefine in the first section
1961 if you don't like the default value (generally 8KB). Using
1963 results in somewhat slower scanners, but the value of
1965 becomes immune to calls to
1969 which potentially destroy its value when
1971 is a character pointer. The opposite of
1975 which is the default.
1979 when generating C++ scanner classes
1985 holds the length of the current token.
1988 is the file which by default
1990 reads from. It may be redefined but doing so only makes sense before
1991 scanning begins or after an EOF has been encountered. Changing it in
1992 the midst of scanning will have unexpected results since
1994 buffers its input; use
1997 Once scanning terminates because an end-of-file
1998 has been seen, you can assign
2000 at the new input file and then call the scanner again to continue scanning.
2002 .B void yyrestart( FILE *new_file )
2003 may be called to point
2005 at the new input file. The switch-over to the new file is immediate
2006 (any previously buffered-up input is lost). Note that calling
2010 as an argument thus throws away the current input buffer and continues
2011 scanning the same input file.
2014 is the file to which
2016 actions are done. It can be reassigned by the user.
2018 .B YY_CURRENT_BUFFER
2021 handle to the current buffer.
2024 returns an integer value corresponding to the current start
2025 condition. You can subsequently use this value with
2027 to return to that start condition.
2028 .SH INTERFACING WITH YACC
2029 One of the main uses of
2031 is as a companion to the
2035 parsers expect to call a routine named
2037 to find the next input token. The routine is supposed to
2038 return the type of the next token as well as putting any associated
2049 to instruct it to generate the file
2051 containing definitions of all the
2055 input. This file is then included in the
2057 scanner. For example, if one of the tokens is "TOK_NUMBER",
2058 part of the scanner might look like:
2067 [0-9]+ yylval = atoi( yytext ); return TOK_NUMBER;
2072 has the following options:
2075 Generate backing-up information to
2077 This is a list of scanner states which require backing up
2078 and the input characters on which they do so. By adding rules one
2079 can remove backing-up states. If
2081 backing-up states are eliminated and
2085 is used, the generated scanner will run faster (see the
2087 flag). Only users who wish to squeeze every last cycle out of their
2088 scanners need worry about this option. (See the section on Performance
2089 Considerations below.)
2092 is a do-nothing, deprecated option included for POSIX compliance.
2095 makes the generated scanner run in
2097 mode. Whenever a pattern is recognized and the global
2099 is non-zero (which is the default),
2100 the scanner will write to
2105 --accepting rule at line 53 ("the matched text")
2108 The line number refers to the location of the rule in the file
2109 defining the scanner (i.e., the file that was fed to flex). Messages
2110 are also generated when the scanner backs up, accepts the
2111 default rule, reaches the end of its input buffer (or encounters
2112 a NUL; at this point, the two look the same as far as the scanner's concerned),
2113 or reaches an end-of-file.
2118 No table compression is done and stdio is bypassed.
2119 The result is large but fast. This option is equivalent to
2124 generates a "help" summary of
2140 scanner. The case of letters given in the
2143 be ignored, and tokens in the input will be matched regardless of case. The
2144 matched text given in
2146 will have the preserved case (i.e., it will not be folded).
2149 turns on maximum compatibility with the original AT&T
2151 implementation. Note that this does not mean
2153 compatibility. Use of this option costs a considerable amount of
2154 performance, and it cannot be used with the
2155 .B \-+, -f, -F, -Cf,
2158 options. For details on the compatibilities it provides, see the section
2159 "Incompatibilities With Lex And POSIX" below. This option also results
2161 .B YY_FLEX_LEX_COMPAT
2162 being #define'd in the generated scanner.
2165 is another do-nothing, deprecated option included only for
2169 generates a performance report to stderr. The report
2170 consists of comments regarding features of the
2172 input file which will cause a serious loss of performance in the resulting
2173 scanner. If you give the flag twice, you will also get comments regarding
2174 features that lead to minor performance losses.
2176 Note that the use of
2178 .B %option yylineno,
2179 and variable trailing context (see the Deficiencies / Bugs section below)
2180 entails a substantial performance penalty; use of
2187 flag entail minor performance penalties.
2192 (that unmatched scanner input is echoed to
2194 to be suppressed. If the scanner encounters input that does not
2195 match any of its rules, it aborts with an error. This option is
2196 useful for finding holes in a scanner's rule set.
2201 to write the scanner it generates to standard output instead
2210 a summary of statistics regarding the scanner it generates.
2211 Most of the statistics are meaningless to the casual
2213 user, but the first line identifies the version of
2215 (same as reported by
2217 and the next line the flags used when generating the scanner, including
2218 those that are on by default.
2221 suppresses warning messages.
2228 scanner, the opposite of
2230 scanners generated by
2232 (see below). In general, you use
2236 that your scanner will never be used interactively, and you want to
2239 more performance out of it. If your goal is instead to squeeze out a
2241 more performance, you should be using the
2245 options (discussed below), which turn on
2247 automatically anyway.
2253 scanner table representation should be used (and stdio
2254 bypassed). This representation is
2255 about as fast as the full table representation
2257 and for some sets of patterns will be considerably smaller (and for
2258 others, larger). In general, if the pattern set contains both "keywords"
2259 and a catch-all, "identifier" rule, such as in the set:
2262 "case" return TOK_CASE;
2263 "switch" return TOK_SWITCH;
2265 "default" return TOK_DEFAULT;
2266 [a-z]+ return TOK_ID;
2269 then you're better off using the full table representation. If only
2270 the "identifier" rule is present and you then use a hash table or some such
2271 to detect the keywords, you're better off using
2274 This option is equivalent to
2276 (see below). It cannot be used with
2284 scanner. An interactive scanner is one that only looks ahead to decide
2285 what token has been matched if it absolutely must. It turns out that
2286 always looking one extra character ahead, even if the scanner has already
2287 seen enough text to disambiguate the current token, is a bit faster than
2288 only looking ahead when necessary. But scanners that always look ahead
2289 give dreadful interactive performance; for example, when a user types
2290 a newline, it is not recognized as a newline token until they enter
2292 token, which often means typing in another whole line.
2301 table-compression options (see below). That's because if you're looking
2302 for high-performance you should be using one of these options, so if you
2305 assumes you'd rather trade off a bit of run-time performance for intuitive
2306 interactive behavior. Note also that you
2314 Thus, this option is not really needed; it is on by default for all those
2315 cases in which it is allowed.
2319 returns false for the scanner input, flex will revert to batch mode, even if
2321 was specified. To force interactive mode no matter what, use
2322 .B %option always-interactive
2323 (see Options below).
2325 You can force a scanner to
2327 be interactive by using
2336 directives. Without this option,
2338 peppers the generated scanner
2339 with #line directives so error messages in the actions will be correctly
2340 located with respect to either the original
2342 input file (if the errors are due to code in the input file), or
2346 fault -- you should report these sorts of errors to the email address
2354 mode. It will generate a lot of messages to
2357 the form of the input and the resultant non-deterministic and deterministic
2358 finite automata. This option is mostly for use in maintaining
2362 prints the version number to
2372 to generate a 7-bit scanner, i.e., one which can only recognize 7-bit
2373 characters in its input. The advantage of using
2375 is that the scanner's tables can be up to half the size of those generated
2378 option (see below). The disadvantage is that such scanners often hang
2379 or crash if their input contains an 8-bit character.
2381 Note, however, that unless you generate your scanner using the
2385 table compression options, use of
2387 will save only a small amount of table space, and make your scanner
2388 considerably less portable.
2390 default behavior is to generate an 8-bit scanner unless you use the
2396 defaults to generating 7-bit scanners unless your site was always
2397 configured to generate 8-bit scanners (as will often be the case
2398 with non-USA sites). You can tell whether flex generated a 7-bit
2399 or an 8-bit scanner by inspecting the flag summary in the
2401 output as described above.
2403 Note that if you use
2407 (those table compression options, but also using equivalence classes as
2408 discussed see below), flex still defaults to generating an 8-bit
2409 scanner, since usually with these compression options full 8-bit tables
2410 are not much more expensive than 7-bit tables.
2415 to generate an 8-bit scanner, i.e., one which can recognize 8-bit
2416 characters. This flag is only needed for scanners generated using
2420 as otherwise flex defaults to generating an 8-bit scanner anyway.
2422 See the discussion of
2424 above for flex's default behavior and the tradeoffs between 7-bit
2428 specifies that you want flex to generate a C++
2429 scanner class. See the section on Generating C++ Scanners below for
2433 controls the degree of table compression and, more generally, trade-offs
2434 between small scanners and fast scanners.
2437 ("align") instructs flex to trade off larger tables in the
2438 generated scanner for faster performance because the elements of
2439 the tables are better aligned for memory access and computation. On some
2440 RISC architectures, fetching and manipulating longwords is more efficient
2441 than with smaller-sized units such as shortwords. This option can
2442 double the size of the tables used by your scanner.
2448 .I equivalence classes,
2449 i.e., sets of characters
2450 which have identical lexical properties (for example, if the only
2451 appearance of digits in the
2453 input is in the character class
2454 "[0-9]" then the digits '0', '1', ..., '9' will all be put
2455 in the same equivalence class). Equivalence classes usually give
2456 dramatic reductions in the final table/object file sizes (typically
2457 a factor of 2-5) and are pretty cheap performance-wise (one array
2458 look-up per character scanned).
2463 scanner tables should be generated -
2465 should not compress the
2466 tables by taking advantages of similar transition functions for
2470 specifies that the alternate fast scanner representation (described
2474 should be used. This option cannot be used with
2481 .I meta-equivalence classes,
2482 which are sets of equivalence classes (or characters, if equivalence
2483 classes are not being used) that are commonly used together. Meta-equivalence
2484 classes are often a big win when using compressed tables, but they
2485 have a moderate performance impact (one or two "if" tests and one
2486 array look-up per character scanned).
2489 causes the generated scanner to
2491 use of the standard I/O library (stdio) for input. Instead of calling
2495 the scanner will use the
2497 system call, resulting in a performance gain which varies from system
2498 to system, but in general is probably negligible unless you are also using
2504 can cause strange behavior if, for example, you read from
2506 using stdio prior to calling the scanner (because the scanner will miss
2507 whatever text your previous reads left in the stdio input buffer).
2510 has no effect if you define
2512 (see The Generated Scanner above).
2516 specifies that the scanner tables should be compressed but neither
2517 equivalence classes nor meta-equivalence classes should be used.
2525 do not make sense together - there is no opportunity for meta-equivalence
2526 classes if the table is not being compressed. Otherwise the options
2527 may be freely mixed, and are cumulative.
2529 The default setting is
2531 which specifies that
2533 should generate equivalence classes
2534 and meta-equivalence classes. This setting provides the highest
2535 degree of table compression. You can trade off
2536 faster-executing scanners at the cost of larger tables with
2537 the following generally being true:
2551 Note that scanners with the smallest tables are usually generated and
2552 compiled the quickest, so
2553 during development you will usually want to use the default, maximal
2557 is often a good compromise between speed and size for production
2561 directs flex to write the scanner to the file
2569 option, then the scanner is written to
2575 option above) refer to the file
2583 for all globally-visible variable and function names to instead be
2591 It also changes the name of the default output file from
2595 Here are all of the names affected:
2603 yy_load_buffer_state
2615 (If you are using a C++ scanner, then only
2620 Within your scanner itself, you can still refer to the global variables
2621 and functions using either version of their name; but externally, they
2622 have the modified name.
2624 This option lets you easily link together multiple
2626 programs into the same executable. Note, though, that using this
2632 provide your own (appropriately-named) version of the routine for your
2634 .B %option noyywrap,
2637 no longer provides one for you by default.
2640 overrides the default skeleton file from which
2642 constructs its scanners. You'll never need this option unless you are doing
2644 maintenance or development.
2647 also provides a mechanism for controlling options within the
2648 scanner specification itself, rather than from the flex command-line.
2649 This is done by including
2651 directives in the first section of the scanner specification.
2652 You can specify multiple options with a single
2654 directive, and multiple directives in the first section of your flex input
2657 Most options are given simply as names, optionally preceded by the
2658 word "no" (with no intervening whitespace) to negate their meaning.
2659 A number are equivalent to flex flags or their negation:
2670 case-sensitive opposite of -i (default)
2676 default opposite of -s option
2680 interactive -I option
2681 lex-compat -l option
2683 perf-report -p option
2687 warn opposite of -w option
2688 (use "%option nowarn" for -w)
2690 array equivalent to "%array"
2691 pointer equivalent to "%pointer" (default)
2696 provide features otherwise not available:
2698 .B always-interactive
2699 instructs flex to generate a scanner which always considers its input
2700 "interactive". Normally, on each new input file the scanner calls
2702 in an attempt to determine whether
2703 the scanner's input source is interactive and thus should be read a
2704 character at a time. When this option is used, however, then no
2708 directs flex to provide a default
2710 program for the scanner, which simply calls
2716 .B never-interactive
2717 instructs flex to generate a scanner which never considers its input
2718 "interactive" (again, no call made to
2720 This is the opposite of
2721 .B always-interactive.
2724 enables the use of start condition stacks (see Start Conditions above).
2737 instead of the default of
2741 programs depend on this behavior, even though it is not compliant with
2742 ANSI C, which does not require
2746 to be compile-time constant.
2751 to generate a scanner that maintains the number of the current line
2752 read from its input in the global variable
2754 This option is implied by
2755 .B %option lex-compat.
2759 .B %option noyywrap),
2760 makes the scanner not call
2762 upon an end-of-file, but simply assume that there are no more
2763 files to scan (until the user points
2765 at a new file and calls
2770 scans your rule actions to determine whether you use the
2778 options are available to override its decision as to whether you use the
2779 options, either by setting them (e.g.,
2781 to indicate the feature is indeed used, or
2782 unsetting them to indicate it actually is not used
2784 .B %option noyymore).
2786 Three options take string-delimited values, offset with '=':
2789 %option outfile="ABC"
2797 %option prefix="XYZ"
2805 %option yyclass="foo"
2808 only applies when generating a C++ scanner (
2812 that you have derived
2818 will place your actions in the member function
2821 .B yyFlexLexer::yylex().
2823 .B yyFlexLexer::yylex()
2824 member function that emits a run-time error (by invoking
2825 .B yyFlexLexer::LexerError())
2827 See Generating C++ Scanners, below, for additional information.
2829 A number of options are available for lint purists who want to suppress
2830 the appearance of unneeded routines in the generated scanner. Each of the
2834 ), results in the corresponding routine not appearing in
2835 the generated scanner:
2839 yy_push_state, yy_pop_state, yy_top_state
2840 yy_scan_buffer, yy_scan_bytes, yy_scan_string
2845 and friends won't appear anyway unless you use
2847 .SH PERFORMANCE CONSIDERATIONS
2848 The main design goal of
2850 is that it generate high-performance scanners. It has been optimized
2851 for dealing well with large sets of rules. Aside from the effects on
2852 scanner speed of the table compression
2854 options outlined above,
2855 there are a number of options/actions which degrade performance. These
2856 are, from most expensive to least:
2861 arbitrary trailing context
2863 pattern sets that require backing up
2866 %option always-interactive
2868 '^' beginning-of-line operator
2872 with the first three all being quite expensive and the last two
2873 being quite cheap. Note also that
2875 is implemented as a routine call that potentially does quite a bit of
2878 is a quite-cheap macro; so if just putting back some excess text you
2883 should be avoided at all costs when performance is important.
2884 It is a particularly expensive option.
2886 Getting rid of backing up is messy and often may be an enormous
2887 amount of work for a complicated scanner. In principal, one begins
2892 file. For example, on the input
2896 foo return TOK_KEYWORD;
2897 foobar return TOK_KEYWORD;
2900 the file looks like:
2903 State #6 is non-accepting -
2904 associated rule line numbers:
2906 out-transitions: [ o ]
2907 jam-transitions: EOF [ \\001-n p-\\177 ]
2909 State #8 is non-accepting -
2910 associated rule line numbers:
2912 out-transitions: [ a ]
2913 jam-transitions: EOF [ \\001-` b-\\177 ]
2915 State #9 is non-accepting -
2916 associated rule line numbers:
2918 out-transitions: [ r ]
2919 jam-transitions: EOF [ \\001-q s-\\177 ]
2921 Compressed tables always back up.
2924 The first few lines tell us that there's a scanner state in
2925 which it can make a transition on an 'o' but not on any other
2926 character, and that in that state the currently scanned text does not match
2927 any rule. The state occurs when trying to match the rules found
2928 at lines 2 and 3 in the input file.
2929 If the scanner is in that state and then reads
2930 something other than an 'o', it will have to back up to find
2931 a rule which is matched. With
2932 a bit of headscratching one can see that this must be the
2933 state it's in when it has seen "fo". When this has happened,
2934 if anything other than another 'o' is seen, the scanner will
2935 have to back up to simply match the 'f' (by the default rule).
2937 The comment regarding State #8 indicates there's a problem
2938 when "foob" has been scanned. Indeed, on any character other
2939 than an 'a', the scanner will have to back up to accept "foo".
2940 Similarly, the comment for State #9 concerns when "fooba" has
2941 been scanned and an 'r' does not follow.
2943 The final comment reminds us that there's no point going to
2944 all the trouble of removing backing up from the rules unless
2949 since there's no performance gain doing so with compressed scanners.
2951 The way to remove the backing up is to add "error" rules:
2955 foo return TOK_KEYWORD;
2956 foobar return TOK_KEYWORD;
2961 /* false alarm, not really a keyword */
2967 Eliminating backing up among a list of keywords can also be
2968 done using a "catch-all" rule:
2972 foo return TOK_KEYWORD;
2973 foobar return TOK_KEYWORD;
2975 [a-z]+ return TOK_ID;
2978 This is usually the best solution when appropriate.
2980 Backing up messages tend to cascade.
2981 With a complicated set of rules it's not uncommon to get hundreds
2982 of messages. If one can decipher them, though, it often
2983 only takes a dozen or so rules to eliminate the backing up (though
2984 it's easy to make a mistake and have an error rule accidentally match
2985 a valid token. A possible future
2987 feature will be to automatically add rules to eliminate backing up).
2989 It's important to keep in mind that you gain the benefits of eliminating
2990 backing up only if you eliminate
2992 instance of backing up. Leaving just one means you gain nothing.
2995 trailing context (where both the leading and trailing parts do not have
2996 a fixed length) entails almost the same performance loss as
2998 (i.e., substantial). So when possible a rule like:
3002 mouse|rat/(cat|dog) run();
3009 mouse/cat|dog run();
3017 mouse|rat/cat run();
3018 mouse|rat/dog run();
3021 Note that here the special '|' action does
3023 provide any savings, and can even make things worse (see
3024 Deficiencies / Bugs below).
3026 Another area where the user can increase a scanner's performance
3027 (and one that's easier to implement) arises from the fact that
3028 the longer the tokens matched, the faster the scanner will run.
3029 This is because with long tokens the processing of most input
3030 characters takes place in the (short) inner scanning loop, and
3031 does not often have to go through the additional work of setting up
3032 the scanning environment (e.g.,
3034 for the action. Recall the scanner for C comments:
3041 "/*" BEGIN(comment);
3044 <comment>"*"+[^*/\\n]*
3045 <comment>\\n ++line_num;
3046 <comment>"*"+"/" BEGIN(INITIAL);
3049 This could be sped up by writing it as:
3056 "/*" BEGIN(comment);
3059 <comment>[^*\\n]*\\n ++line_num;
3060 <comment>"*"+[^*/\\n]*
3061 <comment>"*"+[^*/\\n]*\\n ++line_num;
3062 <comment>"*"+"/" BEGIN(INITIAL);
3065 Now instead of each newline requiring the processing of another
3066 action, recognizing the newlines is "distributed" over the other rules
3067 to keep the matched text as long as possible. Note that
3071 slow down the scanner! The speed of the scanner is independent
3072 of the number of rules or (modulo the considerations given at the
3073 beginning of this section) how complicated the rules are with
3074 regard to operators such as '*' and '|'.
3076 A final example in speeding up a scanner: suppose you want to scan
3077 through a file containing identifiers and keywords, one per line
3078 and with no other extraneous characters, and recognize all the
3079 keywords. A natural first approach is:
3088 while /* it's a keyword */
3090 .|\\n /* it's not a keyword */
3093 To eliminate the back-tracking, introduce a catch-all rule:
3102 while /* it's a keyword */
3105 .|\\n /* it's not a keyword */
3108 Now, if it's guaranteed that there's exactly one word per line,
3109 then we can reduce the total number of matches by a half by
3110 merging in the recognition of newlines with that of the other
3120 while\\n /* it's a keyword */
3123 .|\\n /* it's not a keyword */
3126 One has to be careful here, as we have now reintroduced backing up
3127 into the scanner. In particular, while
3129 know that there will never be any characters in the input stream
3130 other than letters or newlines,
3132 can't figure this out, and it will plan for possibly needing to back up
3133 when it has scanned a token like "auto" and then the next character
3134 is something other than a newline or a letter. Previously it would
3135 then just match the "auto" rule and be done, but now it has no "auto"
3136 rule, only an "auto\\n" rule. To eliminate the possibility of backing up,
3137 we could either duplicate all rules but without final newlines, or,
3138 since we never expect to encounter such an input and therefore don't
3139 how it's classified, we can introduce one more catch-all rule, this
3140 one which doesn't include a newline:
3149 while\\n /* it's a keyword */
3153 .|\\n /* it's not a keyword */
3158 this is about as fast as one can get a
3160 scanner to go for this particular problem.
3164 is slow when matching NUL's, particularly when a token contains
3166 It's best to write rules which match
3168 amounts of text if it's anticipated that the text will often include NUL's.
3170 Another final note regarding performance: as mentioned above in the section
3171 How the Input is Matched, dynamically resizing
3173 to accommodate huge tokens is a slow process because it presently requires that
3174 the (huge) token be rescanned from the beginning. Thus if performance is
3175 vital, you should attempt to match "large" quantities of text but not
3176 "huge" quantities, where the cutoff between the two is at about 8K
3178 .SH GENERATING C++ SCANNERS
3180 provides two different ways to generate scanners for use with C++. The
3181 first way is to simply compile a scanner generated by
3183 using a C++ compiler instead of a C compiler. You should not encounter
3184 any compilations errors (please report any you find to the email address
3185 given in the Author section below). You can then use C++ code in your
3186 rule actions instead of C code. Note that the default input source for
3187 your scanner remains
3189 and default echoing is still done to
3191 Both of these remain
3193 variables and not C++
3198 to generate a C++ scanner class, using the
3200 option (or, equivalently,
3202 which is automatically specified if the name of the flex
3203 executable ends in a '+', such as
3205 When using this option, flex defaults to generating the scanner to the file
3209 The generated scanner includes the header file
3211 which defines the interface to two C++ classes.
3215 provides an abstract base class defining the general scanner class
3216 interface. It provides the following member functions:
3218 .B const char* YYText()
3219 returns the text of the most recently matched token, the equivalent of
3223 returns the length of the most recently matched token, the equivalent of
3226 .B int lineno() const
3227 returns the current input line number
3229 .B %option yylineno),
3236 .B void set_debug( int flag )
3237 sets the debugging flag for the scanner, equivalent to assigning to
3239 (see the Options section above). Note that you must build the scanner
3242 to include debugging information in it.
3244 .B int debug() const
3245 returns the current setting of the debugging flag.
3247 Also provided are member functions equivalent to
3248 .B yy_switch_to_buffer(),
3249 .B yy_create_buffer()
3250 (though the first argument is an
3252 object pointer and not a
3254 .B yy_flush_buffer(),
3255 .B yy_delete_buffer(),
3258 (again, the first argument is a
3262 The second class defined in
3266 which is derived from
3268 It defines the following additional member functions:
3271 yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 )
3274 object using the given streams for input and output. If not specified,
3275 the streams default to
3281 .B virtual int yylex()
3282 performs the same role is
3284 does for ordinary flex scanners: it scans the input stream, consuming
3285 tokens, until a rule's action returns a value. If you derive a subclass
3289 and want to access the member functions and variables of
3293 then you need to use
3294 .B %option yyclass="S"
3297 that you will be using that subclass instead of
3299 In this case, rather than generating
3300 .B yyFlexLexer::yylex(),
3304 (and also generates a dummy
3305 .B yyFlexLexer::yylex()
3307 .B yyFlexLexer::LexerError()
3311 virtual void switch_streams(istream* new_in = 0,
3313 ostream* new_out = 0)
3323 (ditto), deleting the previous input buffer if
3328 int yylex( istream* new_in, ostream* new_out = 0 )
3329 first switches the input streams via
3330 .B switch_streams( new_in, new_out )
3331 and then returns the value of
3336 defines the following protected virtual functions which you can redefine
3337 in derived classes to tailor the scanner:
3340 virtual int LexerInput( char* buf, int max_size )
3345 and returns the number of characters read. To indicate end-of-input,
3346 return 0 characters. Note that "interactive" scanners (see the
3350 flags) define the macro
3354 and need to take different actions depending on whether or not
3355 the scanner might be scanning an interactive input source, you can
3356 test for the presence of this name via
3360 virtual void LexerOutput( const char* buf, int size )
3363 characters from the buffer
3365 which, while NUL-terminated, may also contain "internal" NUL's if
3366 the scanner's rules can match text with NUL's in them.
3369 virtual void LexerError( const char* msg )
3370 reports a fatal error message. The default version of this function
3371 writes the message to the stream
3379 scanning state. Thus you can use such objects to create reentrant
3380 scanners. You can instantiate multiple instances of the same
3382 class, and you can also combine multiple C++ scanner classes together
3383 in the same program using the
3385 option discussed above.
3387 Finally, note that the
3389 feature is not available to C++ scanner classes; you must use
3393 Here is an example of a simple C++ scanner:
3396 // An example of using the flex C++ scanner class.
3402 string \\"[^\\n"]+\\"
3408 name ({alpha}|{dig}|\\$)({alpha}|{dig}|[_.\\-/$])*
3409 num1 [-+]?{dig}+\\.?([eE][-+]?{dig}+)?
3410 num2 [-+]?{dig}*\\.{dig}+([eE][-+]?{dig}+)?
3411 number {num1}|{num2}
3415 {ws} /* skip blanks and tabs */
3420 while((c = yyinput()) != 0)
3427 if((c = yyinput()) == '/')
3435 {number} cout << "number " << YYText() << '\\n';
3439 {name} cout << "name " << YYText() << '\\n';
3441 {string} cout << "string " << YYText() << '\\n';
3445 int main( int /* argc */, char** /* argv */ )
3447 FlexLexer* lexer = new yyFlexLexer;
3448 while(lexer->yylex() != 0)
3453 If you want to create multiple (different) lexer classes, you use the
3457 option) to rename each
3461 You then can include
3463 in your other sources once per lexer class, first renaming
3469 #define yyFlexLexer xxFlexLexer
3470 #include <FlexLexer.h>
3473 #define yyFlexLexer zzFlexLexer
3474 #include <FlexLexer.h>
3477 if, for example, you used
3478 .B %option prefix="xx"
3479 for one of your scanners and
3480 .B %option prefix="zz"
3483 IMPORTANT: the present form of the scanning class is
3485 and may change considerably between major releases.
3486 .SH INCOMPATIBILITIES WITH LEX AND POSIX
3488 is a rewrite of the AT&T Unix
3490 tool (the two implementations do not share any code, though),
3491 with some extensions and incompatibilities, both of which
3492 are of concern to those who wish to write scanners acceptable
3493 to either implementation. Flex is fully compliant with the POSIX
3495 specification, except that when using
3497 (the default), a call to
3499 destroys the contents of
3501 which is counter to the POSIX specification.
3503 In this section we discuss all of the known areas of incompatibility
3504 between flex, AT&T lex, and the POSIX specification.
3508 option turns on maximum compatibility with the original AT&T
3510 implementation, at the cost of a major loss in the generated scanner's
3511 performance. We note below which incompatibilities can be overcome
3517 is fully compatible with
3519 with the following exceptions:
3523 scanner internal variable
3525 is not supported unless
3532 should be maintained on a per-buffer basis, rather than a per-scanner
3533 (single global variable) basis.
3536 is not part of the POSIX specification.
3540 routine is not redefinable, though it may be called to read characters
3541 following whatever has been matched by a rule. If
3543 encounters an end-of-file the normal
3545 processing is done. A ``real'' end-of-file is returned by
3550 Input is instead controlled by defining the
3558 cannot be redefined is in accordance with the POSIX specification,
3559 which simply does not specify any way of controlling the
3560 scanner's input other than by making an initial assignment to
3565 routine is not redefinable. This restriction is in accordance with POSIX.
3568 scanners are not as reentrant as
3570 scanners. In particular, if you have an interactive scanner and
3571 an interrupt handler which long-jumps out of the scanner, and
3572 the scanner is subsequently called again, you may get the following
3576 fatal flex scanner internal error--end of buffer missed
3579 To reenter the scanner, first use
3585 Note that this call will throw away any buffered input; usually this
3586 isn't a problem with an interactive scanner.
3588 Also note that flex C++ scanner classes
3590 reentrant, so if using C++ is an option for you, you should use
3591 them instead. See "Generating C++ Scanners" above for details.
3597 macro is done to the file-pointer
3603 is not part of the POSIX specification.
3606 does not support exclusive start conditions (%x), though they
3607 are in the POSIX specification.
3609 When definitions are expanded,
3611 encloses them in parentheses.
3612 With lex, the following:
3617 foo{NAME}? printf( "Found it\\n" );
3621 will not match the string "foo" because when the macro
3622 is expanded the rule is equivalent to "foo[A-Z][A-Z0-9]*?"
3623 and the precedence is such that the '?' is associated with
3626 the rule will be expanded to
3627 "foo([A-Z][A-Z0-9]*)?" and so the string "foo" will match.
3629 Note that if the definition begins with
3635 expanded with parentheses, to allow these operators to appear in
3636 definitions without losing their special meanings. But the
3640 operators cannot be used in a
3648 behavior of no parentheses around the definition.
3650 The POSIX specification is that the definition be enclosed in parentheses.
3652 Some implementations of
3654 allow a rule's action to begin on a separate line, if the rule's pattern
3655 has trailing whitespace:
3660 { foobar_action(); }
3664 does not support this feature.
3669 (generate a Ratfor scanner) option is not supported. It is not part
3670 of the POSIX specification.
3675 is undefined until the next token is matched, unless the scanner
3678 This is not the case with
3680 or the POSIX specification. The
3682 option does away with this incompatibility.
3684 The precedence of the
3686 (numeric range) operator is different.
3688 interprets "abc{1,3}" as "match one, two, or
3689 three occurrences of 'abc'", whereas
3691 interprets it as "match 'ab'
3692 followed by one, two, or three occurrences of 'c'". The latter is
3693 in agreement with the POSIX specification.
3695 The precedence of the
3697 operator is different.
3699 interprets "^foo|bar" as "match either 'foo' at the beginning of a line,
3700 or 'bar' anywhere", whereas
3702 interprets it as "match either 'foo' or 'bar' if they come at the beginning
3703 of a line". The latter is in agreement with the POSIX specification.
3705 The special table-size declarations such as
3717 is #define'd so scanners may be written for use with either
3721 Scanners also include
3722 .B YY_FLEX_MAJOR_VERSION
3724 .B YY_FLEX_MINOR_VERSION
3725 indicating which version of
3727 generated the scanner
3728 (for example, for the 2.5 release, these defines would be 2 and 5
3733 features are not included in
3735 or the POSIX specification:
3740 start condition scopes
3741 start condition stacks
3742 interactive/non-interactive scanners
3743 yy_scan_string() and friends
3745 yy_set_interactive()
3755 %{}'s around actions
3756 multiple actions on a line
3759 plus almost all of the flex flags.
3760 The last feature in the list refers to the fact that with
3762 you can put multiple actions on the same line, separated with
3763 semi-colons, while with
3768 foo handle_foo(); ++num_foos_seen;
3771 is (rather surprisingly) truncated to
3778 does not truncate the action. Actions that are not enclosed in
3779 braces are simply terminated at the end of the line.
3781 .I warning, rule cannot be matched
3782 indicates that the given rule
3783 cannot be matched because it follows other rules that will
3784 always match the same text as it. For
3785 example, in the following "foo" cannot be matched because it comes after
3786 an identifier "catch-all" rule:
3789 [a-z]+ got_identifier();
3795 in a scanner suppresses this warning.
3800 option given but default rule can be matched
3801 means that it is possible (perhaps only in a particular start condition)
3802 that the default rule (match any single character) is the only one
3803 that will match a particular input. Since
3805 was given, presumably this is not intended.
3807 .I reject_used_but_not_detected undefined
3809 .I yymore_used_but_not_detected undefined -
3810 These errors can occur at compile time. They indicate that the
3817 failed to notice the fact, meaning that
3819 scanned the first two sections looking for occurrences of these actions
3820 and failed to find any, but somehow you snuck some in (via a #include
3821 file, for example). Use
3825 to indicate to flex that you really do use these features.
3827 .I flex scanner jammed -
3828 a scanner compiled with
3830 has encountered an input string which wasn't matched by
3831 any of its rules. This error can also occur due to internal problems.
3833 .I token too large, exceeds YYLMAX -
3836 and one of its rules matched a string longer than the
3838 constant (8K bytes by default). You can increase the value by
3841 in the definitions section of your
3845 .I scanner requires \-8 flag to
3846 .I use the character 'x' -
3847 Your scanner specification includes recognizing the 8-bit character
3849 and you did not specify the \-8 flag, and your scanner defaulted to 7-bit
3850 because you used the
3854 table compression options. See the discussion of the
3858 .I flex scanner push-back overflow -
3861 to push back so much text that the scanner's buffer could not hold
3862 both the pushed-back text and the current token in
3864 Ideally the scanner should dynamically resize the buffer in this case, but at
3865 present it does not.
3868 input buffer overflow, can't enlarge buffer because scanner uses REJECT -
3869 the scanner was working on matching an extremely large token and needed
3870 to expand the input buffer. This doesn't work with scanners that use
3875 fatal flex scanner internal error--end of buffer missed -
3876 This can occur in a scanner which is reentered after a long-jump
3877 has jumped out (or over) the scanner's activation frame. Before
3878 reentering the scanner, use:
3884 or, as noted above, switch to using the C++ scanner class.
3886 .I too many start conditions in <> construct! -
3887 you listed more start conditions in a <> construct than exist (so
3888 you must have listed at least one of them twice).
3892 library with which scanners must be linked.
3895 generated scanner (called
3900 generated C++ scanner class, when using
3904 header file defining the C++ scanner base class,
3906 and its derived class,
3910 skeleton scanner. This file is only used when building flex, not when
3914 backing-up information for
3919 .SH DEFICIENCIES / BUGS
3920 Some trailing context
3921 patterns cannot be properly matched and generate
3922 warning messages ("dangerous trailing context"). These are
3923 patterns where the ending of the
3924 first part of the rule matches the beginning of the second
3925 part, such as "zx*/xy*", where the 'x*' matches the 'x' at
3926 the beginning of the trailing context. (Note that the POSIX draft
3927 states that the text matched by such patterns is undefined.)
3929 For some trailing context rules, parts which are actually fixed-length are
3930 not recognized as such, leading to the above mentioned performance loss.
3931 In particular, parts using '|' or {n} (such as "foo{3}") are always
3932 considered variable-length.
3934 Combining trailing context with the special '|' action can result in
3936 trailing context being turned into the more expensive
3938 trailing context. For example, in the following:
3949 invalidates yytext and yyleng, unless the
3954 option has been used.
3956 Pattern-matching of NUL's is substantially slower than matching other
3959 Dynamic resizing of the input buffer is slow, as it entails rescanning
3960 all the text matched so far by the current (generally huge) token.
3962 Due to both buffering of input and read-ahead, you cannot intermix
3963 calls to <stdio.h> routines, such as, for example,
3967 rules and expect it to work. Call
3971 The total table entries listed by the
3973 flag excludes the number of table entries needed to determine
3974 what rule has been matched. The number of entries is equal
3975 to the number of DFA states if the scanner does not use
3977 and somewhat greater than the number of states if it does.
3980 cannot be used with the
3988 internal algorithms need documentation.
3990 lex(1), yacc(1), sed(1), awk(1).
3992 John Levine, Tony Mason, and Doug Brown,
3994 O'Reilly and Associates. Be sure to get the 2nd edition.
3996 M. E. Lesk and E. Schmidt,
3997 .I LEX \- Lexical Analyzer Generator
3999 Alfred Aho, Ravi Sethi and Jeffrey Ullman,
4000 .I Compilers: Principles, Techniques and Tools,
4001 Addison-Wesley (1986). Describes the pattern-matching techniques used by
4003 (deterministic finite automata).
4005 Vern Paxson, with the help of many ideas and much inspiration from
4006 Van Jacobson. Original version by Jef Poskanzer. The fast table
4007 representation is a partial implementation of a design done by Van
4008 Jacobson. The implementation was done by Kevin Gong and Vern Paxson.
4012 beta-testers, feedbackers, and contributors, especially Francois Pinard,
4015 Stan Adermann, Terry Allen, David Barker-Plummer, John Basrai,
4016 Neal Becker, Nelson H.F. Beebe, benson@odi.com,
4017 Karl Berry, Peter A. Bigot, Simon Blanchard,
4018 Keith Bostic, Frederic Brehm, Ian Brockbank, Kin Cho, Nick Christopher,
4019 Brian Clapper, J.T. Conklin,
4020 Jason Coughlin, Bill Cox, Nick Cropper, Dave Curtis, Scott David
4021 Daniels, Chris G. Demetriou, Theo Deraadt,
4022 Mike Donahue, Chuck Doucette, Tom Epperly, Leo Eskin,
4023 Chris Faylor, Chris Flatters, Jon Forrest, Jeffrey Friedl,
4024 Joe Gayda, Kaveh R. Ghazi, Wolfgang Glunz,
4025 Eric Goldman, Christopher M. Gould, Ulrich Grepel, Peer Griebel,
4026 Jan Hajic, Charles Hemphill, NORO Hideo,
4027 Jarkko Hietaniemi, Scott Hofmann,
4028 Jeff Honig, Dana Hudes, Eric Hughes, John Interrante,
4029 Ceriel Jacobs, Michal Jaegermann, Sakari Jalovaara, Jeffrey R. Jones,
4030 Henry Juengst, Klaus Kaempf, Jonathan I. Kamens, Terrence O Kane,
4031 Amir Katz, ken@ken.hilco.com, Kevin B. Kenny,
4032 Steve Kirsch, Winfried Koenig, Marq Kole, Ronald Lamprecht,
4033 Greg Lee, Rohan Lenard, Craig Leres, John Levine, Steve Liddle,
4034 David Loffredo, Mike Long,
4035 Mohamed el Lozy, Brian Madsen, Malte, Joe Marshall,
4036 Bengt Martensson, Chris Metcalf,
4037 Luke Mewburn, Jim Meyering, R. Alexander Milowski, Erik Naggum,
4038 G.T. Nicol, Landon Noll, James Nordby, Marc Nozell,
4039 Richard Ohnemus, Karsten Pahnke,
4040 Sven Panne, Roland Pesch, Walter Pelissero, Gaumond
4041 Pierre, Esmond Pitt, Jef Poskanzer, Joe Rahmeh, Jarmo Raiha,
4042 Frederic Raimbault, Pat Rankin, Rick Richardson,
4043 Kevin Rodgers, Kai Uwe Rommel, Jim Roskind, Alberto Santini,
4044 Andreas Scherer, Darrell Schiebel, Raf Schietekat,
4045 Doug Schmidt, Philippe Schnoebelen, Andreas Schwab,
4046 Larry Schwimmer, Alex Siegel, Eckehard Stolz, Jan-Erik Strvmquist,
4047 Mike Stump, Paul Stuart, Dave Tallman, Ian Lance Taylor,
4048 Chris Thewalt, Richard M. Timoney, Jodi Tsai,
4049 Paul Tuinenga, Gary Weik, Frank Whaley, Gerhard Wilhelms, Kent Williams, Ken
4050 Yap, Ron Zellar, Nathan Zelle, David Zuhn,
4051 and those whose names have slipped my marginal
4052 mail-archiving skills but whose contributions are appreciated all the
4055 Thanks to Keith Bostic, Jon Forrest, Noah Friedman,
4056 John Gilmore, Craig Leres, John Levine, Bob Mulcahy, G.T.
4057 Nicol, Francois Pinard, Rich Salz, and Richard Stallman for help with various
4058 distribution headaches.
4060 Thanks to Esmond Pitt and Earle Horton for 8-bit character support; to
4061 Benson Margulies and Fred Burke for C++ support; to Kent Williams and Tom
4062 Epperly for C++ class support; to Ove Ewerlid for support of NUL's; and to
4063 Eric Hughes for support of multiple buffers.
4065 This work was primarily done when I was with the Real Time Systems Group
4066 at the Lawrence Berkeley Laboratory in Berkeley, CA. Many thanks to all there
4067 for the support I received.
4069 Send comments to vern@ee.lbl.gov.
projects / dragonfly.git / blob