When b() is run, it processes a grammar file. If the grammar is error-free b() produces a bf(C++) em(class), in which several em(members) have already been defined. Therefore, b()'s em(output) consists of em(header files) and a bf(C++) source file, defining a member (tt(parse)) that parses the language described by the grammar. The class and its implementation is called a b() em(parser class). Keep in mind that the b() utility and the produced parser classes are distinct pieces of software: the b() utility is a program whose output is the b() parser class that is used by your program. More specifically, b() generates the following files from a b() grammar file: itemization( it() A em(baseclass header), which can be included by em(lexical scanners) (see below), primarily defining the em(lexical tokens) that the parser expects the lexical scanner to return; it() A em(class header), defining the b() parser class interface; it() An em(implementation header), which is used to declare all entities which are em(only) used by b()'s parser class em(implementation) (and not required by the remaining parts of your program); it() The em(parsing member), actually performing the parsing of a provided input according to the rules of the defined b() grammar (that you, as b()'s user, defined). ) The task of b()'s tt(parse) member is to group tokens according to rules defined in the grammar -- for example, to combine identifiers and operators into expressions. As it does this, it executes the actions of the grammar rules it has recognized. The tokens processed by the parser produced by b() are made available by an object called the em(lexical analyzer) or em(lexical scanner). The scanner is not produced by b(), but must somehow be supplied (e.g., by writing it yourself). The tt(parse) member requests the next token from the lexical analyzer whenever it needs another token. The parser itself doesn't know the semantic values of the received tokens. Typically the lexical scanner produces tokens by parsing the characters of the program's input text. This, however, is not something that b() concerns itself with. See also section ref(LEX). B()'s parsing function is a member function named tt(parse). This parsing function nor the parser object for which it is called defines a complete bf(C++) program: you must supply some additional details. One `detail' to be supplied is is the lexical analyzer. The parser class itself declares several additional members which can easily be redefined to fit your needs. One of these additional members is the error-reporting function called by tt(parse) to report errors. By default b() provides simple, but sensible, implementations for such members. Having constructed a parser class and a lexical scanner class, em(objects) of those classes must be defined in a complete bf(C++) program. Usually such objects are defined in tt(main); you have to provide this function, and arrange for it to call the parser's tt(parse) function, lest the parser never run. See chapter ref(INTERFACE). Note that, different from conventions used by Bison and Bison++, b() does not impose a particular name convention. In particular, there is em(no) need to begin all variable and function names used in the b() parser with `yy' or `YY'. However, some name restrictions on symbolic tokens exist. See section ref(IMPROPER) for details.