    The following members can be used by members of parser classes generated
by bic(). When prefixed by tt(Base::) they are actually protected members
inherited from the parser's base class.  Members for which the phrase ``Used
internally'' is used should not be called by user-defined code.
    itemization(
    it() bf(Base::ParserBase()):nl()
       Used internally.
    it() bf(void Base::ABORT() const throw(Return__)):nl()
       This member can be called from any member function (called from any of
        the parser's action blocks) to indicate a failure while parsing thus
        terminating the parsing function with an error value 1. Note that this
        offers a marked extension and improvement of the macro tt(YYABORT)
        defined by bf(bison++) in that tt(YYABORT) could not be called from
        outside of the parsing member function.
    it() bf(void Base::ACCEPT() const throw(Return__)):nl()
       This member can be called from any member function (called from any of
        the parser's action blocks) to indicate successful parsing and thus
        terminating the parsing function. Note that this offers a marked
        extension and improvement of the macro tt(YYACCEPT) defined by
        bf(bison++) in that tt(YYACCEPT) could not be called from outside of
        the parsing member function.
    it() bf(void Base::clearin+nop()()):nl()
       This member replaces bf(bison)(++)'s macro tt(yyclearin) and causes
        bf(bisonc++) to request another token from its tt(lex+nop()()) member,
        even if the current token has not yet been processed. It is a useful
        member when the parser should be reset to its initial state, e.g.,
        between successive calls of tt(parse). In this situation the scanner
        must probably be reloaded with new information as well.
    it() bf(bool Base::debug() const):nl()
       This member returns the current value of the debug variable.
    it() bf(void Base::ERROR+nop()() const throw(ErrorRecovery__)):nl()
       This member can be called from any member function (called from any of
        the parser's action blocks) to generate an error, and results in the
        parser executing its error recovery code. Note that this offers a
        marked extension and improvement of the macro tt(YYERROR) defined by
        bf(bison++) in that tt(YYERROR) could not be called from outside of
        the parsing member function.
    it() bf(void error(char const *msg)):nl()
      By default implemented inline in the tt(parser.ih) internal header file,
       it writes a simple message to the standard error stream. It is called
       when a syntactic error is encountered, and its default implementation
       may safely be altered.
    it() bf(void errorRecovery__+nop()()):nl()
       Used internally.
    it() bf(void Base::errorVerbose__+nop()()):nl()
       Used internally.
    it() bf(void exceptionHandler__(std::exception const &exc)):nl()
       This member's default implementation is provided inline in the
        tt(parser.ih) internal header file. It consists of a mere tt(throw)
        statement, rethrowing a caught exception.

       The tt(parse) member function's body essentially consists of a
        tt(while) statement, in which the next token is obtained via the
        parser's tt(lex) member. This token is then processed according to the
        current state of the parsing process. This may result in executing
        actions over which the parsing process has no control and which may
        result in exceptions being thrown.

       Such exceptions do not necessarily have to terminate the parsing
        process: they could be thrown by code, linked to the parser, that
        simply checks for semantic errors (like divisions by zero) 
        throwing exceptions if such errors are observed.

       The member tt(exceptionHandler__) receives and may handle such
        exceptions without necessarily ending the parsing process. It receives
        any tt(std::exception) thrown by the parser's actions, as though the
        action block itself was surrounded by a tt(try ... catch) statement.
        It is of course still possible to use an explicit tt(try ... catch)
        statement within action blocks. However, tt(exceptionHandler__) can
        be used to factor out code that is common to various action blocks.

        The next example shows an explicit implementation of
        tt(exceptionHandler__): any tt(std::exception) thrown by the parser's
        action blocks is caught, showing the exception's message, and
        increasing the parser's error count. After this parsing continues as
        if no exception had been thrown:
        verb(
    void Parser::exceptionHandler__(std::exception const &exc)
    {
        std::cout << exc.what() << '\n';
        ++d_nErrors__;
    }
            )

        bf(Note:) Parser-class header files (e.g., Parser.h) and parser-class
    internal header files (e.g., Parser.ih) generated with bic() < 4.02.00
    require two hand-modifications when using bic() >= 4.02.00:

    In Parser.h, just below the declaration 
        verb(
    void print__();
        )
    add:
        verb(
    void exceptionHandler__(std::exception const &exc);
        )

    In Parser.ih, assuming the name of the generated class is `Parser', add the
    following member definition (if a namespace is used: within the
    namespace's scope):
        verb(
    inline void Parser::exceptionHandler__(std::exception const &exc)
    {
        throw;  // re-implement to handle exceptions thrown by actions
    }
        )
    it() bf(void executeAction+nop()(int)):nl()
       Used internally.
    it() bf(int lex()):nl()
      By default implemented inline in the tt(parser.ih) internal header file,
       it can be pre-implemented by bic() using the tt(scanner) option or
       directive (see above); alternatively it em(must) be implemented by the
       programmer. It interfaces to the lexical scanner, and should return the
       next token produced by the lexical scanner, either as a plain character
       or as one of the symbolic tokens defined in the tt(Parser::Tokens__)
       enumeration. Zero or negative token values are interpreted as `end of
       input'.
    it() bf(int lookup+nop()(bool)):nl()
       Used internally.
    it() bf(void nextToken+nop()()):nl()
       Used internally.
    it() bf(void Base::pop__+nop()()):nl()
       Used internally.
    it() bf(void Base::popToken__+nop()()):nl()
       Used internally.
    it() bf(void print__()()):nl()
       Used internally.
    it() bf(void print()):nl()
      By default implemented inline in the tt(parser.ih) internal header file,
       this member calls tt(print__) to display the last received token and
       corrseponding matched text. The tt(print__) member is only implemented
       if the tt(--print-tokens) option or tt(%print-tokens) directive was
       used when the parsing function was generated. Calling tt(print__) from
       tt(print) is unconditional, but can easily be controlled by the using
       program, by defining, e.g., a command-line option.
    it() bf(void Base::push__+nop()()):nl()
       Used internally.
    it() bf(void Base::pushToken__+nop()()):nl()
       Used internally.
    it() bf(void Base::reduce__+nop()()):nl()
       Used internally.
    it() bf(void Base::symbol__+nop()()):nl()
       Used internally.
    it() bf(void Base::top__+nop()()):nl()
       Used internally.
    )

