Flc() uses regular expressions to generically descibe textual patterns.  Often
a flc() specification file uses multiple `sub-languages' having specialized
tasks. A sub-language to describe the normal structure of the input, a
sub-language to describe comment, a sub-language to describe strings, etc.,
etc.

For flexible handling of these sub-languages flc(), like flex, offers em(start
conditions), a.k.a. em(mini scanners). A start condition can be declared in
the definition section of the lexer file:
    verb(
%x  string
%%
...
    ) 
    A tt(%x) is used to declare em(exclusive start conditions). Following
tt(%x) a list (no commas) of start condition names is expected. Rules
specified for exclusive start conditions only apply to that particular mini
scanner. It is also possible to define em(inclusive start condition) using
tt(%s). Rules not explicitly associated with a start condition (or with the
(default) start condition tt(StartCondition_::INITIAL) also apply to
inclusive start conditions.

A start condition is used in the rules section of the lexical scanner
specification file as indicated in section ref(patterns). Here is a concrete
example:
    verb(
%x string
%%

\"              {
                    more();
                    begin(StartCondition_::string);
                }

<string>{
    \"          {
                    begin(StartCondition_::INITIAL);
                    return Token::STRING;
                }
    \\.|.       more();
}
    )
    This tells flc() that the double quote starts (begins) the
tt(StartCondition_::string) start condition. The tt(string) start condition's
rules then define what happens to double quoted strings. All its characters
are collected, and eventually the string's content is returned by
tt(matched()).

By default, scanners generated by flc() start in the
tt(StartCondition_::INITIAL) start condition. When encountering a double
quote, the scanner switches to the tt(StartCondition_::string) mini
scanner. Now, only the rules that are defined for the tt(string) start
condition are active. Once flc() encounters an unescaped double quote, it
switches back to the tt(StartCondition_::INITIAL) start condition and returns
tt(Token::STRING) to its called, indicating that it has seen a bf(C) string.

There is nothing special to either the function tt(begin(StartCondition_)) or
to the tt(StartCondition_) enum itself. They can be used anywhere within the
Scanner class. E.g., after providing the Scanner class with a
tt(std::stack<StartCondition_> d_scStack) start conditions can be
stacked. Calling member tt(begin) could be embedded in a member
tt(Scanner::push(StartCondition_)) like this:
        verb(
    void Scanner::push(StartCondition_ next)
    {
        d_scStack.push(startCondition()); // push the current SC.
        begin(next);                      // switch to the next
    }
        )
    In addition, for returning to the start condition currently on top of the
stack simply call a member tt(Scanner::popStartCondition()), implemented like
this: 
        verb(
    void Scanner::popStartCondition()
    {
        begin(d_scStack.top());
        d_scStack.pop();
    }
        )
    tt(push) and tt(popStartCondition) should be given the same access rights
as tt(begin): they should be defined in the private section of the Scanner
class.
