    Parser classes generated by b() offer the following public constructor,
enums, members and types (in the following overview parser class-name prefixes
(e.g., tt(Parser::)) prefixes were omitted):
    itemization(
    it() Constructors: the generated parser class merely defines the default
        constructor. Copy and move constructors are not available. The default
        constructor is a real default: it is declared as such in the parser's
        header file. Additional constructors can easily be added to the parser
        class's interface. Since the initialization of the parser's base class
        is performed by the parser base class's default constructor,
        constructors that are added to the generated parser class
        automatically call the base class constructor, so additional
        constructors do not have to explicitly initialize the parser's base
        class.

    it() bf(DebugMode_):nl() 
       The values of this tt(enum) are used to configure the type of debug
        information that will be displayed (assuming that the tt(debug)
        option/directive was specified when bic() generated the parser's
        code). It has three values:
            
        tt(OFF): no debug information is displayed when the generated
        parser's tt(parse) function is called;

        tt(ON): extensive debug information about the parsing process is
        displayed when the generated parser's tt(parse) function is called;

        tt(ACTIONCASES): just before executing the grammar's action blocks
        the action block number is written to the standard output
        stream. These action block numbers refer to  case labels of the switch
        that is defined in the parser's tt(executeAction) function. It is
        commonly used to find the action block where a fatal semantic value
        mismatch was observed.

        The tt(bit_or) operator can be used to combine tt(ON) and
        tt(ACTIONCASES) (see the member function tt(setDebug(DebugMode_
        mode)) below).

    it() bf(LTYPE_):nl() 
           The parser's location type (user-definable). Available only when
            either tt(%lsp-needed, %ltype) or tt(%locationstruct) has been
            declared. 

    it() bf(STYPE_):nl()
            The parser's stack-type (user-definable), defaults to bf(int).

    it() bf(Tokens_):nl()
       The enumeration type of all the symbolic tokens defined in the grammar
        file (i.e., bic()'s input file). The scanner should be prepared to
        return these symbolic tokens. Note that, since the symbolic tokens are
        defined in the parser's class and not in the scanner's class, the
        lexical scanner must prefix the parser's class name to the symbolic
        token names when they are returned. E.g., tt(return Parser::IDENT)
        should be used rather than tt(return IDENT).

    it() bf(int parse()):nl()
       The parser's parsing member function. It returns 0 when parsing was
        successfully completed; 1 if errors were encountered while parsing the
        input.

    it() bf(void setDebug(bool mode)):nl()
       This member can be used to activate or deactivate the debug-code
        compiled into the parsing function. It is always defined but is only
        operational if the tt(debug) directive option was specified when bic()
        generated the tt(parse) function. If so, it is em(not) active by
        default; to activate the debug output call tt(setDebug(true)), to
        suppress the debug output call tt(setDebug(false)).

    it() bf(void setDebug(DebugMode_ mode)):nl()
       This member can also be used to activate or deactivate the debug-code
        compiled into the parsing function. Like tt(setDebug(bool)) it is
        always defined but only operational if the tt(debug) directive option
        was specified when bic() generated the tt(parse) function. If so, it
        is em(not) active by default; to activate, call
        tt(setDebug(Parser::ON), setDebug(Parser::ACTIONCASES)), or 
        tt(setDebug(Parser::ON | Parser::ACTIONCASES)). To suppress the
        debug code output call tt(setDebug(Parser_::OFF)) or simply
        tt(setDebug(false)).
    )

When the tt(%polymorphic) directive is used:
    itemization(
    it() bf(Meta_):nl()
           Templates and classes that are required for implementing the
            polymorphic semantic values are all declared in the tt(Meta_)
            namespace. The tt(Meta_) namespace itself is nested under the
            namespace that may have been declared by the tt(%namespace)
            directive.
    
    it() bf(Tag_):nl()
           The (strongly typed) tt(enum class Tag_) contains all the
            tag-identifiers specified by the tt(%polymorphic) directive. It is
            declared outside of the Parser's class, but within the namespace
            that may have been declared by the tt(%namespace) directive.
    )


