B() generates a bf(C++) parser em(class), rather than a parsing em(function),
like Bison.  B()'s class is a plain bf(C++) class and not a fairly complex
macro-based class as generated by Bison++. 

The bf(C++) class generated by b() does not require em(virtual) members
(when polymorphic semantic values are used (cf. section ref(POLYMORPHIC) a
polymorphic base class em(is) used, but that class has no further implications
for the parser class generated by bic()); in this case polymorphism is merely
used internally, inaccessible to bic()'s user, to define a common interface
for the various polymorphic data types).

The generated parser class's essential member (the member tt(parse)) is
generated from the grammar specification and so the software engineer will
therefore hardly ever feel the need to modify that function. All but a few of
the remaining predefined members have very clear definitions and meanings as
well, making it unlikely that they should ever require overriding.

It is likely that members like tt(lex) and/or tt(error) need dedicated
definitions with different parsers generated by bic(); but then again: while
defining the grammar the definition of the associated support members is a
natural extension of defining the grammar, and can be realized em(in parallel)
with defining the grammar, in practice not requiring any virtual members. By
not requiring virtual members the parser's class organization is simplified,
and calling non-virtual members will be just a trifle faster than calling
these member functions as virtual functions.

In this chapter all available members and features of the generated parser
class are discussed. Having read this chapter you should be able to use the
generated parser class in your program (using its public members) and to use
its facilities in the actions defined for the various production rules and/or
use these facilities in additional class members that you might have defined
yourself. 

In the remainder of this chapter the class's public members are first
discussed, to be followed by the class's private members. While constructing
the grammar all private members are available in the action parts of the
grammar's production rules. Furthermore, any member (and so not just from the
action blocks) may generate errors (thus initiating error recovery procedures)
and may flag the (un)successful parsing of the information given to the parser
(terminating the parsing function tt(parse)).

Symbols defined in the generated parser and parser base class usually end in
an underscore character. Such symbols should not be masked or
redefined. Some members have names not ending in an underscore
character. Those names have either historically been used (like tt(parse) and
tt(ERROR)) or they can be redefined by the user (like tt(int lex()) and
tt(void print())). Their specific requirements are documented below.
