Вычислить значение введенного выражения

#include <iostream>
#include <string>
#include <map>
 
enum Token_value
{
    NAME,        NUMBER,       END,
    PLUS = '+',  MINUS = '-',  MUL = '*', DIV = '/',
    PRINT = ';', ASSIGN = '=', LP = '(',  RP = ')'
};
Token_value curr_tok = PRINT;
 
Token_value get_token();
 
std::map<std::string, double> table;
int no_of_errors;
 
double expr(bool);
 
int main()
{
    table["pi"] = 3.1415926535897932385;
    table["e"] = 2.7182818284590452354;
 
    while(std::cin)
    {
        get_token();
        if(curr_tok == END) break;
        if(curr_tok == PRINT) continue;
        std::cout << expr(false) << '\n';
    }
 
    return no_of_errors;
};
 
double term(bool);
 
double expr(bool get)
{
    double left = term(get);
 
    for( ; ; )
    {
        switch(curr_tok)
        {
        case PLUS:
            left += term(true);
            break;
 
        case MINUS:
            left -= term(true);
            break;
 
        default: return left;
        }
    };
}
 
double prim(bool);
int error(char*);
 
double term(bool get)
{
    double left = prim(get);
 
    for( ; ; )
    {
        switch(curr_tok)
        {
        case MUL:
            left *= prim(true);
            break;
 
        case DIV:
            if(double d = prim(true) )
            {
                left /= d;
                break;
            }
            return error("divide by 0");
 
        default: return left;
        }
    }
}
 
double number_value;
std::string string_value;
 
double prim(bool get)
{
    if(get) get_token();
 
    switch(curr_tok)
    {
    case NUMBER:
    {
        double d = number_value;
        get_token();
        return d;
    }
    case NAME:
    {
        double& d = table[string_value];
        if(get_token() == ASSIGN) d = expr(true);
 
        return d;
    }
 
    case MINUS: return -prim(true);
 
    case LP:
    {
        double d = expr(true);
        if(curr_tok != RP) return error("')' expected");
        get_token();
        return d;
    }
 
    default: return error("primary expected");
    }
}
 
Token_value get_token()
{
    char ch;
 
    do
    {
        if(!std::cin.get(ch) ) return curr_tok = END;
    } while(ch != '\n' && isspace(ch) );
 
    switch(ch)
    {
    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 '.':
        std::cin.putback(ch);
        std::cin >> number_value;
        return curr_tok = NUMBER;
 
    default:
        if(isalpha(ch) )
        {
            string_value = ch;
            while(std::cin.get(ch) && isalnum(ch) )string_value.push_back(ch);
            std::cin.putback(ch);
            return curr_tok = NAME;
        }
 
        error("bad token");
        return curr_tok = PRINT;
    }
}
 
int error(char* s)
{
    no_of_errors++;
 
    std::cerr << "error: " << s << '\n';
 
    return 1;
}

/* Простой калькулятор v2.5
Реализует основные выражения калькулятора (+, -, *, /, %, sqrt, pow, sin, cos) и выражения записанные переменными
Имеется заранее определенные математические константы: pi, e, k == 1000.
Существует возможность определять константы пользователем
 
Ввод осуществляется из потока cin; вывод в поток cout
 
 
Грамматика для ввода:
 
Вычисление:
    Инструкция
    Помощь
    Вывод
    Выход
    Вычисление Инструкция
 
Вывод: клавиша Enter
Выход: q, exit, quit
 
Инструкция:
    Объявление
    Объявление константы
    Выражение
 
Объявление:
    "#"/"let" Имя "=" Выражение
 
Объявление константы:
    "const" Имя "=" Выражение
 
Выражение:
    Терм
    Выражение + Терм
    Выражение - Терм
 
Терм:
    Первичное_выражение
    Терм*Первичное_выражение
    Терм/Первичное_выражение
    Терм%Первичное_выражение
 
Первичное_выражение
    Число
    ( Выражение )
    -Первичное_выражение
    +Первичное_выражение
    sqrt( Выражение )
    pow( Выражение, Выражение )
    sin( Выражение )
    cos( Выражение )
 
 
*/
#include <iostream>
#include <windows.h>
#include <vector>
#include <stdexcept>
#include <cmath>
#include <ctype.h>
using namespace std;
// Функция ошибки
void error(const string& s)
{
    throw runtime_error(s);
}
void error(const string& s1, const string& s2)
{
    error(s1+s2);
}
// Класс лексем
class Token
{
public:
    char kind;
    double value;
    string name;
    Token(char ch):
        kind(ch), value(0) { }
    Token(char ch, double val):
        kind(ch), value(val) { }
    Token(char ch, string s):
        kind(ch), name(s) { }
};
// Класс потока лексем
class Token_stream
{
public:
    Token_stream();
    Token get();
    void putback(Token t);
    void ignore(char c);
 
private:
    bool full;
    Token buffer;
};
 
Token_stream::Token_stream():
    full(false), buffer(0) { }
 
void Token_stream::putback(Token t)
{
    buffer = t;
    full = true;
}
// Символьные константы
const char c_sqrt = 'S'; // Лексема квадратного корня
const char c_pow = 'P'; // Лексема возведение в степень
const char c_sin = 's'; // Лексема синуса
const char c_cos = 'c';
const char let = '#'; // Лексема начала объявления переменной
const char let_const = 'C'; // Лексема объявления константы
const char quit = 'q';
const char print = ';';
const char number = '8';
const char name = 'a';
const char assigned = '=';
const char help = 'h';
// Получение лексемы
Token Token_stream::get()
{
    if (full)
    {
        full = false;
        return buffer;
    }
    for (char ch; cin.get(ch);)
    {
        if (isspace(ch) && ch != '\n'); // "Съедает" пробельный символ, кроме символа перехода на след. строку
        if (ch == '\n') return Token(print);
        if (!isspace(ch))
            switch (ch)
            {
            case '(': case ')':
            case '+': case '-':
            case '*': case '/':
            case '%':
            case ',':
            case let:
            case print:
            case assigned:
            case quit:
                return Token(ch); // При вводе ',','(', ')', '+', '-', '*',
                          // '/', '%', ';', '=', 'q' возвращается сам символ классом Token
            case '.':
            case '0': case '1': case '2': case '3': case '4':
            case '5': case '6': case '7': case '8': case '9':
            {
                cin.putback(ch);
                double val;
                cin >> val;
                return Token(number,val); // При вводе цифр или десят. точки возвращается значение Token с типом "цифра" и значением
            }
 
            default:
                if (isalpha(ch)) // Проверка на соответствие символа алфавиту: переменная начинается с буквы (далее может иметь цифры)
                {
                    string s;
                    s += ch;
                    while(cin.get(ch) && (isalpha(ch) || isdigit(ch) || ch == '_')) s += ch;
                    cin.putback(ch);
                    if (s == "sqrt") return Token(c_sqrt);
                    if (s == "pow") return Token(c_pow);
                    if (s == "sin") return Token(c_sin);
                    if (s == "cos") return Token(c_cos);
                    if (s == "const") return Token(let_const);
                    if (s == "let") return Token(let);
                    if (s == "exit" || s == "quit") return Token(quit);
                    if (s == "h" || s == "H" || s == "help") return Token(help);
                    return Token(name,s);
                }
                error("Неверная лексема");
            }
    }
}
// Пропуск символов до символа c
void Token_stream::ignore(char c)
{
    // Проверка буффера
    if (full && c==buffer.kind)
    {
        full = false;
        return;
    }
    full = false;
 
    char ch;
    while (cin>>ch)
        if (ch==c) return;
}
// Класс переменных
class Variable
{
public:
    string name;
    string const_name;
    double value;
    Variable(string n, double v):
        name(n), value(v) { }
    Variable(double c_v, string c_n):
        value(c_v), const_name(c_n) { }
};
 
class Symbol_table
{
public:
    vector <Variable> names;
    double get (string s);
    void set (string s, double d);
    void set_const(string s, double d);
    bool is_declared(string s);
    bool is_declared_const(string s);
    double define(string var, double val);
};
// Получение значения из вектора переменных
double Symbol_table::get(string s)
{
    for (int i = 0; i<names.size(); ++i)
    {
        if (names[i].name == s || names[i].const_name == s)
            return names[i].value;
    }
 
    error("get: Неопределенная переменная ",s);
}
// Запись в вектор
void Symbol_table::set(string s, double d)
{
    for (int i = 0; i<names.size(); ++i)
        if (names[i].name == s)
        {
            names[i].value = d;
            return;
        }
    error("set: Неопределенная переменная ",s);
}
// Запись константы в вектор
void Symbol_table::set_const(string s, double d)
{
    for (int i = 0; i<names.size(); ++i)
        if (names[i].const_name == s)
        {
            names[i].value = d;
            return;
        }
}
// Есть ли переменная s в векторе names
bool Symbol_table::is_declared(string s)
{
    for (int i = 0; i<names.size(); ++i)
        if (names[i].name == s) return true;
    return false;
}
// Проверка есть ли константа s в векторе names
bool Symbol_table::is_declared_const(string s)
{
    for (int i = 0; i<names.size(); ++i)
        if (names[i].const_name == s) return true;
    return false;
}
 
double Symbol_table::define(string var, double val)
{
    names.push_back(Variable(val, var));
    return val;
}
 
Symbol_table st;
// Предоставляет доступ к потоку лексем
Token_stream ts;
// Прототип функции Выражение
double expression();
// Функция Первичное выражение
double primary()
{
    Token t = ts.get(); // Считываем лексему из потока лексем
    switch (t.kind)
    {
    case '(':
    {
        double d = expression();
        t = ts.get();
        if (t.kind != ')') error("Отсутствует ')'");
        return d;
    }
    case '-':
        return -primary();
 
    case number:
        return t.value;
 
    case name:
        return st.get(t.name);
 
    case c_sqrt:
    {
        t = ts.get();
        if (t.kind != '(') error("Отсутствует '('");
        double d = expression();
        if (d < 0) error("Корень из отрицательного числа запрещен");
        t = ts.get();
        if (t.kind != ')') error("Отсутствует ')'");
        return sqrt(d);
    }
 
    case c_pow:
    {
        t = ts.get();
        if (t.kind != '(') error("Отсутствует '('");
        double d1 = expression();
        t = ts.get();
        if (t.kind != ',') error("Отсутсвует ','");
        double d2 = expression();
        t = ts.get();
        if (t.kind != ')') error("Отсутствует ')'");
        return pow(d1,d2);
    }
 
    case c_sin:
    {
        t = ts.get();
        if (t.kind != '(') error("Отсутствует '('");
        double d = expression();
        t = ts.get();
        if (t.kind != ')') error("Отсутствует ')'");
        return sin(d);
    }
 
    case c_cos:
    {
        t = ts.get();
        if (t.kind != '(') error("Отсутствует '('");
        double d = expression();
        t = ts.get();
        if (t.kind != ')') error("Отсутствует ')'");
        return cos(d);
    }
 
    default:
        error("Требуется первичное значение");
    }
}
// Функция Терм
double term()
{
    double left = primary();
    Token t = ts.get();
    while(true)
    {
        switch(t.kind)
        {
        case '*':
            left *= primary();
            t = ts.get();
            break;
 
        case '/':
        {
            double d = primary();
            if (d == 0) error("Деление на ноль");
            left /= d;
            t = ts.get();
            break;
        }
        case '%':
        {
            double d = primary();
            if (d == 0) error("%: Деление на ноль");
            left = fmod(left, d);
            t = ts.get();
            break;
        }
 
        default:
            ts.putback(t);
            return left;
        }
    }
}
// Функция Выражение
double expression()
{
    double left = term();
    Token t = ts.get();
    while(true)
    {
        switch(t.kind)
        {
        case '+':
            left += term();
            t = ts.get();
            break;
 
        case '-':
            left -= term();
            t = ts.get();
            break;
 
        default:
            ts.putback(t);
            return left;
        }
    }
}
 
// Функция объявления переменной
double declaration()
{
    Token t = ts.get();
    if (t.kind != name) error ("В объявлении ожидается имя переменной");
    string var_name = t.name;
    if (st.is_declared_const(var_name)) error(var_name, " зарезервирован");
 
    Token t2 = ts.get();
    if (t2.kind != assigned) error("Пропущен символ = в объявлении " ,var_name);
    double d = expression();
    if (!st.is_declared(var_name))
        st.names.push_back(Variable(var_name,d));
    else
        st.set(var_name, d);
    return d;
}
// Функция объявления константы
double declaration_const()
{
    Token t = ts.get();
    if (t.kind != name) error ("В объявлении ожидается имя переменной");
    string const_name = t.name;
 
    Token t2 = ts.get();
    if (t2.kind != assigned) error("Пропущен символ = в объявлении " ,const_name);
    double d = expression();
    if(!st.is_declared_const(const_name))
        st.names.push_back(Variable(d, const_name));
    else
        st.set_const(const_name, d);
    return d;
}
// Функция Инструкцией
double statement()
{
    Token t = ts.get();
    switch(t.kind)
    {
    case let:
        return declaration();
 
    case let_const:
        return declaration_const();
 
    default:
        ts.putback(t);
        return expression();
    }
}
 
void clean_up_mess()
{
    ts.ignore(print);
}
 
const string prompt = "> ";
const string result = "= ";
// Помощь
void get_help()
{
    cout << "Помощь: \n"
         << "Строковый калькулятор v2.5 \n"
         << "Разрешенные математические операции: +, -, *, /, sqrt(x), pow(x,y), sin(x), cos(x) \n"
         << "Действия с переменными: \n"
         << "Объявление переменной: # (или ключевое слово 'let') Имя_Перем = Выражение \n"
         << "Объявление константы: const Имя_Конст = Выражение \n"
         << "В программе заранее определены следующие константы: \n"
         << "pi = 3.14159265; \ne = 2.71828183; \nk = 1000 \n"
         << "Для выхода: q, quit, exit \n";
}
// Функция Вычисление
void calculate()
{
    while(true)
    try
    {
        cout << prompt;
        Token t = ts.get();
        while (t.kind == print) t=ts.get();
        if (t.kind == quit) return;
        if (t.kind == help)
        {
            get_help();
            continue;
        }
        ts.putback(t);
        cout << result << statement() << endl;
    }
    catch(runtime_error& e)
    {
        cerr << e.what() << endl;
        clean_up_mess();
    }
}
 
int main()
try
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    st.define("pi", 3.14159265);
    st.define("e", 2.71828183);
    st.define("k", 1000);
 
    calculate();
    return 0;
}
catch (exception& e)
{
    cerr << "Исключение: " << e.what() << endl;
    char c;
    while (cin >> c && c!=';');
    return 1;
}
catch (...)
{
    cerr << "Исключение\n";
    char c;
    while (cin >> c && c!=';');
    return 2;
}