Калькулятор Страуструпа (C++)

// The desk calulator
 
// reads from standard input or command line 
// uses namespaces and no exceptions
 
// pp 190-1921, sec 8.3.3, Exceptions in Calculator
 
 
// uses += rather than push_back() for string
// to work around standard library bug
 
// uses istrstream from <strstream> rather than istringstream from <sstream>
// to work around standard library bug
 
// No guarantees offered. Constructive comments to [email]bs@research.att.com[/email]
 
 
#include <map>
#include<iostream>
#include<cctype>
#include<string>
 
using namespace std;
 
namespace Error {
 
    struct Zero_divide { };
 
    struct Syntax_error {
        const char* p;
        Syntax_error(const char* q) { p = q; }
    };
}
 
namespace Lexer {
 
    enum Token_value {
        NAME,       NUMBER,     END,
        PLUS='+',   MINUS='-',  MUL='*',    DIV='/',
        PRINT=';',  ASSIGN='=', LP='(',     RP=')'
    };
 
    Token_value curr_tok;
    double number_value;
    string string_value;
 
    Token_value get_token();
}
 
namespace Parser {
    double prim(bool get);      // handle primaries
    double term(bool get);      // multiply and divide
    double expr(bool get);      // add and subtract
 
    using namespace Lexer;
    using namespace Error;
}
 
namespace Symbol_table {
    map<string,double> table;
}
 
namespace Driver {
    int no_of_errors;
    std::istream* input;
 
    void skip();
}
 
Lexer::Token_value Lexer::get_token()
{
    char ch;
 
    do {    // skip whitespace except '\n'
        if(!Driver::input->get(ch)) return curr_tok = END;
    } while (ch!='\n' && isspace(ch));
 
    switch (ch) {
    case 0:
        return END;
    case ';':
    case '\n':
        return curr_tok=PRINT;
    case '*':
    case '/':
    case '+':
    case '-':
    case '(':
    case ')':
    case '=':
        return curr_tok=Token_value(ch);
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
    case '.':
        Driver::input->putback(ch);
        *Driver::input >> number_value;
        return curr_tok=NUMBER;
    default:            // NAME, NAME =, or error
        if (isalpha(ch)) {
            string_value = ch;
            while (Driver::input->get(ch) && isalnum(ch))
                string_value += ch; // string_value.push_back(ch);
                                                        // to work around library bug
            Driver::input->putback(ch);
            return curr_tok=NAME;
        }
        throw Error::Syntax_error("bad token");
    }
}
 
 
double Parser::prim(bool get)       // handle primaries
{
    if (get) get_token();
 
    switch (curr_tok) {
    case Lexer::NUMBER: // floating point constant
        get_token();
        return number_value;
    case Lexer::NAME:
    {   double& v = Symbol_table::table[string_value];
        if (get_token() == ASSIGN) v = expr(1);
        return v;
    }
    case Lexer::MINUS:      // unary minus
        return -prim(1);
    case Lexer::LP:
    {   double e = expr(1);
        if (curr_tok != RP) throw Error::Syntax_error("`)' expected");
        get_token();              // eat ')'
        return e;
    }
    case Lexer::END:
        return 1;
    default:
        throw Error::Syntax_error("primary expected");
    }
}
 
double Parser::term(bool get)       // multiply and divide
{
    double left = prim(get);
 
    for (;;)            // ``forever''
        switch (curr_tok) {
        case Lexer::MUL:
            left *= prim(true);
            break;
        case Lexer::DIV:
            if (double d = prim(true)) {
                left /= d;
                break;
            }   
            throw Error::Zero_divide();
        default:
            return left;
        }
}
 
double Parser::expr(bool get)       // add and subtract
{
    double left = term(get);    
 
    for(;;)             // ``forever''
        switch (curr_tok) {
        case Lexer::PLUS:
            left += term(true);
            break;
        case Lexer::MINUS:
            left -= term(true);
            break;
        default:
            return left;
        }
}
 
void Driver::skip()
{
    no_of_errors++;
 
    while (*input) {    // discard characters until newline or semicolon
                // note: skip doesn't know the state of the parser
                //       so if the erro rwas caused by a newline
                //       or a semicolon, we need to look for
                //       yet another terminator
        char ch;
        input->get(ch);
 
        switch (ch) {
        case '\n':
        case ';':
            return;
        }
    }
}
 
#include <strstream.h>
 
int main(int argc, char* argv[])
{
    using namespace Driver;
 
    switch (argc) {
    case 1:          // read from standard input
        input = &cin;
        break;
    case 2:          // read argument string
        input = new istrstream(argv[1],strlen(argv[1]));
        break;
    default:
        cerr << "too many arguments\n";
        return 1;
    }
 
    // insert pre-defined names:
    Symbol_table::table["pi"] = 3.1415926535897932385;
    Symbol_table::table["e"]  = 2.7182818284590452354;
 
    while (*input) {
        cout<<"new expression:\n";
        try {
            Lexer::get_token();
            if (Lexer::curr_tok == Lexer::END) break;
            if (Lexer::curr_tok == Lexer::PRINT) continue;
            cout << Parser::expr(false) << '\n';
        }
        catch(Error::Zero_divide) {
            cerr << "attempt to divide by zero\n";
            skip();
        }
        catch(Error::Syntax_error e) {
            cerr << "syntax error:" << e.p << "\n";
            skip();
        }
    }
 
    if (input != &std::cin) delete input;
    return no_of_errors;
}

for(;;)             // ``forever''
        switch (curr_tok) {
        case Lexer::PLUS:
            left += term(true);
            break;
        case Lexer::MINUS:
            left -= term(true);
            break;
        default:
            return left;
        }