Once tt(parser/inc/regexoreof) has recognized a pattern (whether or not a
LOP-expression) it is further processed by either tt(optMs_rule) (optional
start condition rule) in tt(parser/inc/optmsrule), or by tt(msCompound) (mini
scanner compound) in tt(parser/inc/mscompound). 

In both cases the actions that are associated with the regular expressions are
determined (they may be `or-actions', in which case the action consists of a
tt(|)-character, indicating that this rule uses the same action as the next
rule, or no actions may be defined, representing an empty action block).

Having determined a pattern and action block, the combination of pattern,
action, possibly a begin-of-line requirement (i.e., a rule starting with
tt(^)), and the pattern's type are passed to tt(d_rules.add), adding another
rule to the set of available rules.

Adding a rule (cf. tt(rules/add.cc)) means:
    itemization(
    it() Add the rule's information to the tt(Rules) object's tt(d_rules)
        vector of rules;
    it() associate its end-state with its index in tt(d_rules), so the DFA 
        construction knows which rule is matched when this state is
        reached. This rule-index is used as a case label in the scanner's
        tt(executeAction_) member;
    it() calling tt(setRule(pair.first, ruleIdx)) to associate the rule's
        states with the rule's index;
    it() adding the rule index to the currently active set of start
        conditions.
    )
