flex provides a mechanism for conditionally activating
rules. Any rule whose pattern is prefixed with "<sc>"
will only be active when the scanner is in the start
condition named "sc". For example,

<STRING>[^"]* { /* eat up the string body ... */
...
}

will be active only when the scanner is in the "STRING"
start condition, and

<INITIAL,STRING,QUOTE>\. { /* handle an escape ... */
...
}

will be active only when the current start condition is
either "INITIAL", "STRING", or "QUOTE".

Start conditions are declared in the definitions (first)
section of the input using unindented lines beginning with
either `%s' or `%x' followed by a list of names. The former
declares inclusive start conditions, the latter exclusive
start conditions. A start condition is activated using
the BEGIN action. Until the next BEGIN action is
executed, rules with the given start condition will be active
and rules with other start conditions will be inactive.
If the start condition is inclusive, then rules with no
start conditions at all will also be active. If it is
exclusive, then only rules qualified with the start
condition will be active. A set of rules contingent on the
same exclusive start condition describe a scanner which is
independent of any of the other rules in the flex input.
Because of this, exclusive start conditions make it easy
to specify "mini-scanners" which scan portions of the
input that are syntactically different from the rest
(e.g., comments).

If the distinction between inclusive and exclusive start
conditions is still a little vague, here's a simple
example illustrating the connection between the two. The set
of rules:

Without the `<INITIAL,example>' qualifier, the `bar' pattern
in the second example wouldn't be active (i.e., couldn't match) when
in start condition `example'. If we just used `<example>'
to qualify `bar', though, then it would only be active in
`example' and not in INITIAL, while in the first example
it's active in both, because in the first example the `example'
starting condition is an inclusive (`%s') start condition.

Also note that the special start-condition specifier `<*>'
matches every start condition. Thus, the above example
could also have been written;

`BEGIN(0)' returns to the original state where only the
rules with no start conditions are active. This state can
also be referred to as the start-condition "INITIAL", so
`BEGIN(INITIAL)' is equivalent to `BEGIN(0)'. (The
parentheses around the start condition name are not required but
are considered good style.)

BEGIN actions can also be given as indented code at the
beginning of the rules section. For example, the
following will cause the scanner to enter the "SPECIAL" start
condition whenever `yylex()' is called and the global
variable enter_special is true:

To illustrate the uses of start conditions, here is a
scanner which provides two different interpretations of a
string like "123.456". By default it will treat it as as
three tokens, the integer "123", a dot ('.'), and the
integer "456". But if the string is preceded earlier in
the line by the string "expect-floats" it will treat it as
a single token, the floating-point number 123.456:

This scanner goes to a bit of trouble to match as much
text as possible with each rule. In general, when
attempting to write a high-speed scanner try to match as
much possible in each rule, as it's a big win.

Note that start-conditions names are really integer values
and can be stored as such. Thus, the above could be
extended in the following fashion:

Often, such as in some of the examples above, you wind up
writing a whole bunch of rules all preceded by the same
start condition(s). Flex makes this a little easier and
cleaner by introducing a notion of start condition scope.
A start condition scope is begun with:

<SCs>{

where SCs is a list of one or more start conditions.
Inside the start condition scope, every rule automatically
has the prefix `<SCs>' applied to it, until a `}' which
matches the initial `{'. So, for example,