Lines Matching refs:flex
3 @setfilename flex.info
13 * flex: (flex). Fast lexical analyzer generator (lex replacement).
19 The flex manual is placed under the same licensing conditions as the
20 rest of flex:
71 @top flex
73 This manual describes @code{flex}, a tool for generating programs that
77 This edition of @cite{The flex Manual} documents @code{flex} version
163 * When was flex born?::
165 * Why do flex scanners call fileno if it is not ANSI compatible?::
166 * Does flex support recursive pattern definitions?::
167 * How do I skip huge chunks of input (tens of megabytes) while using flex?::
176 * If I have a simple grammar cant I just parse it with flex?::
180 * Can I get the flex manual in another format?::
182 * How does flex compile the DFA so quickly?::
195 * Is there a way to make flex treat NULL like a regular character?::
196 * Whenever flex can not match the input it says "flex scanner jammed".::
197 * Why doesn't flex have non-greedy operators like perl does?::
207 * Can you discuss some flex internals?::
210 * Why can't flex understand this variable trailing context pattern?::
213 * Is flex GNU or not?::
219 * Is there a repository for flex scanners?::
220 * How can I conditionally compile or preprocess my flex input file?::
288 @cindex copyright of flex
289 @cindex distributing flex
298 If you find a bug in @code{flex}, please report it using
299 GitHub's issue tracking facility at @url{https://github.com/westes/flex/issues/}
305 @code{flex} is a tool for generating @dfn{scanners}. A scanner is a
306 program which recognizes lexical patterns in text. The @code{flex}
310 called @dfn{rules}. @code{flex} generates as output a C source file,
312 This file can be compiled and linked with the flex runtime library to
321 @code{flex}.
324 The following @code{flex} input specifies a scanner which, when it
337 By default, any text not matched by a @code{flex} scanner is copied to
443 @cindex format of flex input
446 @cindex sections of flex input
448 The @code{flex} input file consists of three sections, separated by a
473 @cindex Definitions, in flex input
526 @cindex comments in flex input
532 @cindex embedding C code in flex input
533 @cindex C code in flex input
543 generated file, before any flex definitions @footnote{Actually,
566 @cindex rules, in flex input
567 The @dfn{rules} section of the @code{flex} input contains a series of
597 @cindex user code, in flex input
609 considered a comment. Whenever flex encounters a comment, it copies the
616 Comments may not appear in the Rules Section wherever flex is expecting
802 @dfn{trailing context}. (There are some combinations of @samp{r/s} that flex
820 Note that @code{flex}'s notion of ``newline'' is exactly
821 whatever the C compiler used to compile @code{flex}
916 don't provide @code{isblank()}, so flex defines @samp{[:blank:]} as a
932 A word of caution. Character classes are expanded immediately when seen in the @code{flex} input.
933 This means the character classes are sensitive to the locale in which @code{flex}
949 no case folding). When in doubt, flex will assume that you meant the literal
991 without notice in future revisions of flex.
1075 the same length, the rule listed first in the @code{flex} input file is
1091 output. Thus, the simplest valid @code{flex} input is:
1109 control which definition @code{flex} uses by including one of the
1111 (definitions) section of your flex input. The default is
1141 value in the first section of your @code{flex} input. As mentioned
1197 @code{flex} knows about C strings and comments and won't be fooled by
1244 as the originally chosen rule but came later in the @code{flex} input
1350 Note that @code{yyless()} is a macro and can only be used in the flex
1462 The output of @code{flex} is the file @file{lex.yy.c}, which contains
1493 @code{flex} generates @samp{C99} function definitions by
1500 For this reason, current versions of @code{flex} generate standard C99 code
1522 @code{flex}, and because it can be used to switch input files in the
1597 @code{flex} provides a mechanism for conditionally activating rules.
1638 rules in the @code{flex} input. Because of this, exclusive start
1999 reading from several input streams. As @code{flex} scanners do a large
2007 To negotiate these sorts of problems, @code{flex} provides a mechanism
2059 state becomes the new current state. The stack is maintained by flex and will
2140 manages its own input buffer stack manually (instead of letting flex do it).
2256 @code{flex}, after doing the assignment you had to call the special
2416 is the file which by default @code{flex} reads from. It may be
2419 have unexpected results since @code{flex} buffers its input; use
2454 One of the main uses of @code{flex} is as a companion to the @code{yacc}
2458 value in the global @code{yylval}. To use @code{flex} with @code{yacc},
2462 included in the @code{flex} scanner. For example, if one of the tokens
2485 The various @code{flex} options are categorized by function in the following
2510 specifies that we are being careful. The third line asks flex to track line
2511 numbers. The last line tells flex what to name the files. (The options can be
2514 @code{flex} also provides a mechanism for controlling options within the
2515 scanner specification itself, rather than from the flex command-line.
2519 section of your flex input file.
2526 @code{flex} scans your rule actions to determine whether you use the
2564 instructs flex to write a C header to @file{FILE}. This file contains
2584 directs flex to write the scanner to the file @file{FILE} instead of
2597 instructs @code{flex} to write the scanner it generates to standard
2605 @code{flex}
2607 @code{flex}
2620 This option is for flex development. We document it here in case you stumble
2637 instructs @code{flex} to generate a @dfn{case-insensitive} scanner. The
2638 case of letters given in the @code{flex} input patterns will be ignored,
2665 instructs @code{flex} to generate a @dfn{batch} scanner, the opposite of
2681 instructs @code{flex} to generate an @i{interactive} scanner. An
2691 @code{flex} scanners default to @code{interactive} unless you use the
2695 didn't, @code{flex} assumes you'd rather trade off a bit of run-time
2713 instructs @code{flex} to generate a 7-bit scanner, i.e., one which can
2724 in which case @code{flex} defaults to generating 7-bit scanners unless
2726 often be the case with non-USA sites). You can tell whether flex
2730 Note that if you use @samp{-Cfe} or @samp{-CFe} @code{flex} still
2742 instructs @code{flex} to generate an 8-bit scanner, i.e., one which can
2744 generated using @samp{-Cf} or @samp{-CF}, as otherwise flex defaults to
2749 above for @code{flex}'s default behavior and the tradeoffs between 7-bit
2766 instructs flex to generate a scanner which always considers its input
2776 instructs flex to generate a scanner which never considers its input
2786 @code{lex}. Since @code{flex} was originally designed to implement the
2789 @code{flex} and the POSIX standard are:
2797 (which causes @samp{ab@{3@}} to yield @samp{abbb}). By default, @code{flex}
2800 @samp{--posix} or @samp{-l} are specified, @code{flex} will use the
2833 directs @code{flex} to generate a scanner
2838 value is not modified by @code{flex} unless @code{%option yylineno} is enabled.
2874 instructs flex to generate a C scanner that is
2889 instruct flex that
2902 @code{flex}
2906 @code{flex}
2910 @code{flex}
2914 @code{flex}'s
2925 instructs flex to generate a reentrant C scanner. The generated scanner
2929 reentrant and non-reentrant @code{flex} scanners, non-reentrant flex
2943 specifies that you want flex to generate a C++
2971 changes the default @samp{yy} prefix used by @code{flex} for all
3007 @code{flex}
3027 directs flex to provide a default @code{main()} program for the
3039 that certain options may cause flex to generate code that relies on functions
3052 informs @code{flex} that you have derived @code{NAME} as a subclass of
3053 @code{yyFlexLexer}, so @code{flex} will place your actions in the member
3082 (``align'') instructs flex to trade off larger tables in the
3094 directs @code{flex} to construct @dfn{equivalence classes}, i.e., sets
3096 the only appearance of digits in the @code{flex} input is in the
3106 @code{flex} should not compress the tables by taking advantages of
3121 @code{flex}
3152 The default setting is @samp{-Cem}, which specifies that @code{flex}
3260 the scanner (i.e., the file that was fed to flex). Messages are also
3274 comments regarding features of the @code{flex} input file which will
3303 makes @code{flex} run in @dfn{trace} mode. It will generate a lot of
3306 option is mostly for use in maintaining @code{flex}.
3324 specifies that @code{flex} should write to @file{stderr} a summary of
3326 are meaningless to the casual @code{flex} user, but the first line
3327 identifies the version of @code{flex} (same as reported by @samp{--version}),
3338 matched but no default rule has been given, the flex will warn you.
3354 generates a ``help'' summary of @code{flex}'s options to @file{stdout}
3374 The main design goal of @code{flex} is that it generate high-performance
3412 match newlines, since flex does not need to check them for newlines. In
3532 accidentally match a valid token. A possible future @code{flex} feature
3688 @code{flex}
3716 @code{flex} scanner to go for this particular problem.
3718 A final note: @code{flex} is slow when matching @code{NUL}s,
3742 @code{flex} provides two different ways to generate scanners for use
3744 @code{flex} using a C++ compiler instead of a C compiler. You should
3751 You can also use @code{flex} to generate a C++ scanner class, using the
3753 automatically specified if the name of the @code{flex} executable ends
3754 in a '+', such as @code{flex++}. When using this option, @code{flex}
3816 performs the same role is @code{yylex()} does for ordinary @code{flex}
3821 yyclass="S"} to inform @code{flex} that you will be using that subclass
3823 @code{yyFlexLexer::yylex()}, @code{flex} generates @code{S::yylex()}
3884 // An example of using the flex C++ scanner class.
3979 @code{flex} has the ability to generate a reentrant C scanner. This is
3984 @code{flex} scanner without the need for synchronization with other threads.
4075 @code{flex} variables.
4119 @code{flex}.
4138 @code{flex} would have happily generated a non-reentrant scanner without
4163 both functions. In fact, all @code{flex} functions in a reentrant
4177 @cindex reentrant, accessing flex variables
4178 All global variables in traditional flex have been replaced by macro equivalents.
4182 All of the familiar @code{flex} globals have been replaced by their macro
4260 A @code{flex} scanner (both reentrant and non-reentrant) may be
4289 @code{flex} variables.
4292 of your project will need access to @code{flex} values, such as
4295 global @code{flex} values. You can not access them directly. Instead,
4296 you must access @code{flex} values using accessor methods (get/set
4298 @code{yyset_NAME}, where @code{NAME} is the name of the @code{flex}
4475 @code{flex} unless @code{%option yylineno} is enabled. This is to allow
4476 the user to maintain the line count independently of @code{flex}.
4503 generated by @code{bison}, and are included in section 1 of the @code{flex}
4512 @code{flex} is a rewrite of the AT&T Unix @emph{lex} tool (the two
4515 write scanners acceptable to both implementations. @code{flex} is fully
4520 incompatibility between @code{flex}, AT&T @code{lex}, and the POSIX
4521 specification. @code{flex}'s @samp{-l} option turns on maximum
4525 option. @code{flex} is fully compatible with @code{lex} with the
4551 The @code{flex} restriction that @code{input()} cannot be redefined is
4561 @code{flex} scanners are not as reentrant as @code{lex} scanners. In
4569 fatal flex scanner internal error--end of buffer missed
4584 @code{flex}'s reentrant API.
4587 Also note that @code{flex} C++ scanner classes
4604 When definitions are expanded, @code{flex} encloses them in parentheses.
4620 @code{flex}, the rule will be expanded to @samp{foo([A-Z][A-Z0-9]*)?}
4628 cannot be used in a @code{flex} definition.
4650 @code{flex} does not support this feature.
4666 or three occurrences of @samp{abc}'', whereas @code{flex} interprets it
4674 line, or 'bar' anywhere'', whereas @code{flex} interprets it as ``match
4680 @code{lex} are not required by @code{flex} scanners.. @code{flex}
4684 written for use with either @code{flex} or @code{lex}. Scanners also
4687 indicating which version of @code{flex} generated the scanner. For
4689 respectively. If the version of @code{flex} being used is a beta
4700 @cindex non-POSIX features of flex
4701 The following @code{flex} features are not included in @code{lex} or the
4745 almost all of the @code{flex} command-line options
4749 refers to the fact that with @code{flex} you can put multiple actions on
4767 @code{flex} does not truncate the action. Actions that are not enclosed
4775 This chapter describes how flex handles dynamic memory, and how you can
4789 yylex(). Thereafter, flex may reallocate more memory if it needs to enlarge a
4795 compiler configuration, or due to future enhancements to flex.}
4803 flex consumes. This buffer will grow if necessary, doubling the size each time.
4833 that flex will delete the current buffer automatically when you call
4835 That way, flex will not try to delete the buffer a second time (possibly
4836 crashing your program!) At the time of this writing, flex does not provide a
4858 flex that you will provide your own implementations.
4943 When flex finds a match, @code{yytext} points to the first character of the
4953 use a yacc or bison parser, (commonly used with flex), you will discover that
4966 A @code{flex} scanner has the ability to save the DFA tables to a file, and
4998 These options instruct flex to save the DFA tables to the file @var{FILE}. The tables
5007 serialized tables into one file, and flex will find the correct set of tables,
5013 $ flex --tables-file --prefix=cpp cpp.l
5014 $ flex --tables-file --prefix=c c.l
5023 runtime, we will open the file and tell flex to load the tables from it. Flex
5069 This section defines the file format of serialized @code{flex} tables.
5139 the version of flex that was used to create the serialized tables.
5244 The following is a list of @code{flex} diagnostic messages:
5274 @code{yymore()} but that @code{flex} failed to notice the fact, meaning
5275 that @code{flex} scanned the first two sections looking for occurrences
5278 @code{%option yymore} to indicate to @code{flex} that you really do use
5282 @samp{flex scanner jammed}. a scanner compiled with
5290 #define'ing @code{YYLMAX} in the definitions section of your @code{flex}
5302 @samp{flex scanner push-back overflow}. you used @code{unput()} to push
5315 @samp{fatal flex scanner internal error--end of buffer missed}. This can
5335 @cindex limitations of flex
5367 with @code{flex} rules and expect it to work. Call @code{input()}
5375 The @code{flex} internal algorithms need documentation.
5399 pattern-matching techniques used by @code{flex} (deterministic finite
5405 From time to time, the @code{flex} maintainer receives certain
5410 * When was flex born?::
5412 * Why do flex scanners call fileno if it is not ANSI compatible?::
5413 * Does flex support recursive pattern definitions?::
5414 * How do I skip huge chunks of input (tens of megabytes) while using flex?::
5423 * If I have a simple grammar cant I just parse it with flex?::
5427 * Can I get the flex manual in another format?::
5429 * How does flex compile the DFA so quickly?::
5442 * Is there a way to make flex treat NULL like a regular character?::
5443 * Whenever flex can not match the input it says "flex scanner jammed".::
5444 * Why doesn't flex have non-greedy operators like perl does?::
5454 * Can you discuss some flex internals?::
5457 * Why can't flex understand this variable trailing context pattern?::
5460 * Is flex GNU or not?::
5466 * Is there a repository for flex scanners?::
5467 * How can I conditionally compile or preprocess my flex input file?::
5514 @node When was flex born?
5515 @unnumberedsec When was flex born?
5541 @node Why do flex scanners call fileno if it is not ANSI compatible?
5542 @unnumberedsec Why do flex scanners call fileno if it is not ANSI compatible?
5552 @node Does flex support recursive pattern definitions?
5553 @unnumberedsec Does flex support recursive pattern definitions?
5565 regular expressions in general (and therefore flex scanners, too) is
5572 @node How do I skip huge chunks of input (tens of megabytes) while using flex?
5573 @unnumberedsec How do I skip huge chunks of input (tens of megabytes) while using flex?
5580 @code{flex} picks the
5582 This is because @code{flex} uses an entirely different matching technique
5588 than one rule, @code{flex} scanners pick the rule that matched the @emph{most} text. This
5591 If you want @code{flex} to choose a shorter match, then you can work around this
5626 @code{flex} requires that the opening @samp{@{} of an action associated with a rule
5644 your scanner is free of backtracking (verified using @code{flex}'s @samp{-b} flag),
5671 interpreter I wrote that both reads keyboard input using a @code{flex} scanner and
5678 that @code{flex} block-buffers the input it reads from @code{yyin}. This means that the
5735 flex makes is that interactive applications are inherently slow (they're
5756 @node If I have a simple grammar cant I just parse it with flex?
5757 @unnumberedsec If I have a simple grammar can't I just parse it with flex?
5768 The second is that beginning with @code{flex} version 2.4, use of @code{yyrestart()} is no longer r…
5840 @node Can I get the flex manual in another format?
5841 @unnumberedsec Can I get the flex manual in another format?
5843 The @code{flex} source distribution includes a texinfo manual. You are
5855 @node How does flex compile the DFA so quickly?
5856 @unnumberedsec How does flex compile the DFA so quickly?
5858 There are two big speed wins that @code{flex} uses:
5878 If you need more than 8192 rules in your scanner, you'll have to recompile @code{flex}
5946 You can find the flex homepage on the web at
5947 @uref{http://flex.sourceforge.net/}. See that page for details about flex
5972 You can't, it's compiled into a static table when flex builds the scanner.
6029 first rule listed in the @code{flex} input wins, e.g.,
6042 @code{flex} scanner will pick the first rule listed in your scanner as the
6053 @code{flex}'s @code{unput()} function.
6055 @node Is there a way to make flex treat NULL like a regular character?
6056 @unnumberedsec Is there a way to make flex treat NULL like a regular character?
6059 version of @code{flex}. The latest release is version @value{VERSION}.
6061 @node Whenever flex can not match the input it says "flex scanner jammed".
6062 @unnumberedsec Whenever flex can not match the input it says "flex scanner jammed".
6079 @node Why doesn't flex have non-greedy operators like perl does?
6080 @unnumberedsec Why doesn't flex have non-greedy operators like perl does?
6085 is actually easier to implement than longest leftmost match (which flex does).
6105 UPDATED 2002-07-10: As of @code{flex} version 2.5.9, this leak means that you did not
6106 call @code{yylex_destroy()}. If you are using an earlier version of @code{flex}, then read
6112 scanner). Since @code{flex} doesn't know when you are done, the buffer is never freed.
6144 it's possible that @code{flex} will request less than @code{YY_READ_BUF_SIZE} during
6147 is that when refilling its internal buffer, @code{flex} keeps some characters
6169 When the flex C++ scanning class rewrite finally happens, then this sort of thing should become muc…
6234 When was flex born?
6254 [Note, the most recent flex release is 2.5.4, which you can get from
6261 > (in a very complicated flex program) caused the program to slow from
6286 variable length, which flex -p will tell you, then this reflects a basic
6380 Subject: Re: flex - multi-byte support?
6386 > range of expected character code values (in octal format), flex will
6406 have a very old version of flex. You can get the most recent, 2.5.4, from
6424 Unfortunately flex at the moment has a widespread assumption within it
6432 Fixing flex to handle wider characters is on the long-term to-do list.
6433 But since flex is a strictly spare-time project these days, this probably
6441 @node Can you discuss some flex internals?
6442 @unnumberedsec Can you discuss some flex internals?
6446 Subject: Re: translation of flex
6452 > working with flex. I have a few questions about some of the messages which
6455 All of the things you're wondering about, by the way, concerning flex
6518 > By the way I am using flex 2.5.2 and using the "-l".
6560 from your use of '|' later confusing flex.
6569 @node Why can't flex understand this variable trailing context pattern?
6570 @unnumberedsec Why can't flex understand this variable trailing context pattern?
6574 Subject: Re: flex-2.5.3 bug report
6580 > flex to process it. Could you try it and maybe point me in the right direction?
6587 option for AT&T lex compatibility. Without this option, flex automatically
6618 then it won't work, because flex pushes back macro definitions enclosed
6656 so flex's matching will be correct.
6663 @node Is flex GNU or not?
6664 @unnumberedsec Is flex GNU or not?
6676 Well, strictly speaking flex isn't part of the GNU project. They just
6695 use flex.
6750 have been on the to-do list for a while. As flex is a purely spare-time
6831 Subject: Re: flex limitations
6841 What version of flex are you using? If I feed this to 2.5.4, it complains:
6849 (With the introduction of start condition scopes, flex can't accommodate
6859 @node Is there a repository for flex scanners?
6860 @unnumberedsec Is there a repository for flex scanners?
6865 @node How can I conditionally compile or preprocess my flex input file?
6866 @unnumberedsec How can I conditionally compile or preprocess my flex input file?
6877 In the sources for flex and bison.
6900 > I took a quick look into the flex-sources and altered some #defines in
6967 > Can you explain to me what is ment by a long-jump in relation to flex?
6971 > what is the flex activation frame.
6976 > file and using flex++ isnot really an option!
7034 you are probably running into is that when flex expands a name definition,
7058 > works well when using LEX instead of flex. Do you have some ideas about the
7063 "extern char *yytext" (which is what flex uses). If it's not that, then
7076 Subject: Re: flex 2.5: c++ scanners & start conditions
7104 Subject: Re: current position in flex buffer
7109 > The problem is how to determine the current position in flex active
7115 The latest flex release, by the way, is 2.5.4, available from ftp.ee.lbl.gov.
7151 Subject: Re: flex: how to control start condition from parser?
7168 flex development has come to a virtual stand-still :-(, so a workaround
7181 Subject: Re: freebsd flex bug?
7189 it by using flex -L, so it doesn't generate #line directives in its
7191 name that is also a variable name, or something like that; flex spits
7205 since flex will put "#define foo 1" in the generated scanner.
7217 Subject: Re: Lost flex .l file
7256 A final note: flex is slow when matching NUL's, particularly
7334 Subject: Re: flex problem
7418 > flex 2.5.4 binary works.
7439 Subject: Re: flex output for static code portion
7444 > I would like to use flex under the hood to generate a binary file
7456 > I was wondering if you know of anyone who has used flex in this way.
7459 numerous other flex tweaks :-).
7479 Subject: "flex scanner push-back overflow"
7493 to include some lengthy lists into a .l file. Following is a flex macro
7498 The complete list contains about 10kB. When I try to "flex" this file
7499 (on a Solaris 2.6 machine, using a modified flex 2.5.4 (I only increased
7502 myflex/flex -8 sentag.tmp.l
7503 flex scanner push-back overflow
7527 Subject: Re: "flex scanner push-back overflow"
7532 > myflex/flex -8 sentag.tmp.l
7533 > flex scanner push-back overflow
7535 Flex itself uses a flex scanner. That scanner is running out of buffer
7541 perhaps there's another/better way to do it; or to rebuild flex's own
7603 Subject: Re: Problems with restarting flex-2.5.2-generated scanner
7608 > I am using flex-2.5.2 and bison 1.25 for Solaris and I am desperately
7630 Subject: Re: flex 2.5.4a
7697 Subject: Re: flex input buffer
7702 > In the flex.skl file the size of the default input buffers is set. Can you
7725 > "flex: input rules are too complicated (>= 32000 NFA states)"
7794 Subject: A question on flex C++ scanner
7802 I have been using flex for years.
7806 on C++ lanuage. Thanks to your enhancement, flex did
7827 as I checked the source. (flex 2.5.4)
7851 Subject: Re: A question on flex C++ scanner
7896 Subject: Re: flex - question
7940 > I tried compiling (gnu)flex on a Solaris 2.4 machine
7945 > ./flex -t -p ./scan.l >scan.c
7946 > sh: ./flex: not found
7952 > trying to install flex now. I then edited the Makefile to
7953 > and changed where it says "FLEX = flex" to "FLEX = lex"
7955 > the "-p" option. Is there any way I can compile flex without
7956 > using flex or lex?
7961 initscan.c to scan.c in order to build flex. Try fetching a fresh
7990 If this last tries to first build scan.c from scan.l using ./flex, then
8036 For flex, you can probably do the equivalent using a switch on YYSTATE.
8048 Subject: Re: Regarding distribution of flex and yacc based grammars
8055 > for the generated C files from flex and bison since they are generated by
8056 > flex and bison ?
8058 For flex, no. I don't know what the current state of this is for bison.
8061 > the grammar files which are fed into flex and bison ?
8063 Again, for flex, no.
8065 See the file "COPYING" in the flex distribution for the legalese.
8087 You can't do this - flex is *not* a parser like yacc (which does indeed
8128 YYLEX_PARAM is not a flex symbol. It is for Bison. It tells Bison to pass extra
8172 @code{flex}, however, the @file{.l} files are the sources, and the generated
8179 programs that provide implicit rules for flex-generated scanners.}@footnote{GNU @command{automake}
8180 may generate code to execute flex in lex-compatible mode, or to stdout. If this is not what you wan…
8192 LEX=flex
8210 LEX=flex
8232 Finally, we provide a realistic example of a @code{flex} scanner used with a
8234 There is a tricky problem we have to deal with. Since a @code{flex} scanner
8244 LEX = flex
8277 @cindex bison, bridging with flex
8283 This section describes the @code{flex} features useful when integrating
8284 @code{flex} with @code{GNU bison}@footnote{The features described here are
8285 purely optional, and are by no means the only way to use flex with bison.
8288 @code{bison} with your scanner. Here we discuss only the @code{flex}
8289 half of the @code{flex} and @code{bison} pair. We do not discuss
8294 bison-bridge} or by supplying @samp{--bison-bridge} when invoking @code{flex}
8295 from the command line. This instructs @code{flex} that the macro
8299 @code{flex} input file. For a list of functions and macros
8323 @code{flex} as well. The following is an example of a @code{flex} scanner that
8380 future revisions of flex. It is not part of the public API of flex. Do not depend on it.}
8381 must be installed wherever flex is installed.
8382 @code{flex} invokes @samp{m4}, found by searching the directories in the
8404 @code{m4} is only required at the time you run @code{flex}. The generated