Syntax: bf(%default-actions) tt(off|quiet|warn|std)

By default, production rules without final action blocks are augmented by the
bf(bison)(1) parser generator with tt($$ = $1) action blocks: the semantic
value of the first component is returned as the rule's semantic value. Its
manual also states that for empty rules there is no meaningful default
action. However, it could be argued that empty production rules could return
default semantic values, resulting in every matched rule having a defined
semantic value.

When multiple semantic value types are used, the semantic value type returned
by a tt($$ = $1) action is not uniquely defined. For one rule tt($1) might be
an tt(int) field in a union, for another rule it might be a tt(std::string
*). With polymorphic semantic values comparable situations are encountered.

By default, b() mimics bison's behavior in that it adds a tt($$ = $1) action
block to rules not having final action blocks, but not to empty production
rules. This default behavior can also explicitly be configured using the
tt(default-actions std) option or directive. 

B() also supports alternate ways of handling rules not having final action
blocks.  When tt(off) is specified, b() does not add tt($$ = $1) action
blocks; when polymorphic semantic values are used, then specifying
    itemization(
    it() tt(warn) adds specialized action blocks, using the semantic types of
the first elements of the production rules, while issuing a warning;
    it() tt(quiet) adds these action blocks without issuing warnings.
    )    
When either tt(warn) or tt(quiet) are specified the types of $$ and $1 must
match. When b() detects a type mismatches it issues errors. 

When polymorphic semantic values are used then the default tt($$ = $1) action
probably is less useful than when, e.g., plain tt(%stype) semantic values are
used. After all, no semantic values are associated with tt($$). Furthermore,
once the production rule has been recognized, the production rule is reduced
to the rule's left-hand side non-terminal. Thus, tt($1) ceases to exists,
immediately following the tt($$ = $1) statement. Therefore, em(if) default
actions are used in combination with polymorphic semantic value types they are
implemented using move-operations: tt($$ = std::move($1)). However, in this
situation default actions can frequently be suppressed, slightly improving the
efficency of the generated parser.

When a default action block can be added to a production rule and either
tt(warn) or tt(quiet) was specified,  b() compares the types associated with
rule's nonterminal, and with the production rule's first element. The tt(warn)
and tt(quiet) specifications make identical decisions about the action
blocks to add, but in addition tt(warn) also shows a warning message that the
action block is added to the production rule.
    itemization(
    it() If no type is associated with the rule then no default action block
        is added if no type was associated with the production rule's first
        element either; otherwise an error is issued.
    it() If the rule's type is tt(STYPE_) then, if no type is associated
        with the production rule's first element it is initialized to
        tt(STYPE_); otherwise it is initialized with the first element's
        semantic value.
    it() If the rule is associated with a polymorphic tag then, if the same
        tag was associated with production rule's first element it is
        initialized with the first element's semantic value. Otherwise an
        error is issued.
    )

