The regular expression patterns define non-finite state automata (NFA) which
must be converted to deterministic finite state automata (DFA). Each mini
scanner has its own DFA and the class tt(DFAs) builds the various DFAs for
each of the mini scanners. The DFA construction needs access to the rules,
states and character ranges, which are available to the tt(DFAs) object)
(cf. figure ref(DFASFIG))

    figure(images/dfas)(The DFAs class organization)(DFASFIG)

The tt(DFAs) object's real work is performed by its tt(build) member. The
tt(build) member visits all the elements of tt(Rules), passing each of the
start conditions (stored in the tt(Rules) object) to tt(buildDFA). For each of
the start conditions, holding the indices of the rules that are defined for
the various start conditions, a DFA is constructed for all of the rules of
that start condition (i.e., mini-scanner) (cf. figure ref(STARTCOND)).

The function tt(buildDFA) performs two tasks:
    itemization(
    it() It adds another element to its tt(d_dfa) vector. Each element of
tt(d_dfa)  contains
        itemization(
            it() the name of the mini scanner (obtained from the tt(Rules)'s
                tt(NameVector)), and 
            it() an initialized tt(DFA) object (see section ref(DFA))
        )
    it() Next it calls the tt(DFA) function tt(build) for the just initialized
tt(DFA), passing it the vector of indices of the start states for that mini
scanner. tt(Build) will construct the mini scanner's DFA, see section
ref(DFA).
    )

