In tt(mfcalc), the parser's member function tt(lex()) must now recognize
variables, function names, numeric values, and the single-character arithmetic
operators. Strings of alphanumeric characters not starting with a digit are
recognized as either variables or functions depending on the table in which
they are found. By arranging tt(lex)'s logic such that the function table is
searched first it is simple to ensure that no variable can ever have the name
of a predefined function. The implementation used here, in which two
different tables are used for the arithmetic functions and the variable
symbols is appealing because it's simple to implement. However, it also has
the drawback of being difficult to scale to more generic calculators, using,
e.g., different data types and different types of functions. In such
situations a single symbol table is more preferable, where the keys are the
identifiers (variables, function names, predefined constants, etc.) while the
values are objects describing their characteristics. A re-implementation of
tt(mfcalc) using an integrated symbol table is suggested in one of the
exercises of the next section ref(EXERCISES).

The parser's tt(lex) member has these characteristics:
    itemization(
    it() All leading blanks and tabs are skipped
    it() If no (other) character could be obtained 0 is returned, indicating
        End-Of-File. 
    it() If the first non-blank character is a dot or number, a number is
        extracted from the standard input. Since the semantic value data
        member of tt(mfcalc)'s parser (tt(d_val)) is itself also a tt(union),
        the numerical value can be extracted into tt(d_val_.u_val), and a
        tt(NUM) token can be returned.
    it() If the first non-blank character is not a letter, then a
        single-character token was received and the character's value is
        returned as the next token.
    it() Otherwise the read character is a letter. This character and all
        subsequent alpha-numeric characters are extracted to construct the
        name of an identifier. Then this identifier is searched for in the
        tt(s_functions) map. If found, tt(d_val_.u_fun) is given the function's
        address, found as the value of the tt(s_functions) map element
        corresponding to the read identifier, and token tt(FNCT) is returned.
        If the symbol is not found in tt(s_functions) the address of the
        value ofn tt(d_symbols) associated with the received identifier is
        assigned to tt(d_val_.u_symbol) and token tt(VAR) is returned. Note
        that this automatically defines newly used variables, since
        tt(d_symbols[name]) automatically inserts a new element in a map if
        tt(d_symbol[name]) wasn't already there.
    )
    Here is the parser's tt(lex) member function:
        verbinclude(mfcalc/parser/lex.cc)
