Desk Calculator in C++

Calculator.cpp

#include "Calculator.hpp"

#include <fstream>
#include <iostream>
#include <sstream>

#include "mps/str_util.hpp"
#include "mps/clipboard.hpp"
#include "mps/console_util.hpp"

#include "math_util.hpp"
#include "types.hpp"
#include "Warning.hpp"

using namespace std;

Calculator::Calculator()
    : parser{ symbolTable }
{
    register_commands();

    ifstream ifs{ "prompt.txt" };  // ommitted error handling, since there is a default prompt in place
    getline(ifs, prompt);

    if (ifstream ifs{ "intro.txt" }) {
        std::ostringstream s;
        s << ifs.rdbuf();
        intro = s.str();
    }

    parser.on_result([this](auto&& n) {
        parser.symbol_table().set_var("_", n);
        parser.symbol_table().set_var("ans", n);
        print_complex(cout, n);
        cout << '\n';
    });
}

void Calculator::run(int argc, char* argv[])
{
    switch (argc) {
    case 1:
        run_cli();
        break;
    case 2:
        if (string(argv[1]) == "-")
            run_cli();
        else if (!run_file(argv[1]))
            parser.parse(argv[1]);
        break;
    default:
        throw runtime_error{ "Invalid number of arguments" };
    }
}

bool Calculator::run_file(const string& path)
{
    ifstream ifs{ path };
    if (!ifs)
        return false;
    parser.parse(ifs);
    return true;
}

void Calculator::run_cli()
{
    show_intro();
    cout << prompt;

    for (string s; getline(cin, s); ) {
        s = mps::str::trim(s);
        try {
            if (s.size() && !handle_cmd(s))
                parser.parse(s);
        }
        catch (runtime_error& e) {
            cerr << e.what() << '\n';
        }
        cout << prompt;
    }
}

void Calculator::show_intro() const
{
    cout << intro;
    static Warning w{ "Copyright (C) 2017 Matthias Stauber\n"
                      "This program comes with ABSOLUTELY NO WARRANTY\n" };
}

bool Calculator::handle_cmd(const std::string& cmd)
{
    auto found = commands.find(mps::str::tolower(cmd));
    if (found != end(commands)) {
        found->second();
        return true;
    }
    return false;
}

void Calculator::register_commands()
{
    static const string helpText{
        "For a list of operators, commands and functions please view the readme file\n"
    };

    commands["help"] = [] { std::cout << helpText; };

    commands["clear"] = commands["cls"] = [this] {
        mps::cls();
        show_intro();
    };

    commands["clear all"] = [this] {
        parser.symbol_table().clear();
        mps::cls(); 
        show_intro();
    };
    commands["clear vars"] = [this] { parser.symbol_table().clear_vars(); };
    commands["clear funcs"] = [this] { parser.symbol_table().clear_funcs(); };
    commands["clear lists"] = [this] { parser.symbol_table().clear_lists(); };

    commands["hide vars"] = [this] { parser.set_vardef_is_res(false); };
    commands["show vars"] = [this] { parser.set_vardef_is_res(true); };

    commands["ls"] = [this] {
        auto&& vars = parser.symbol_table().vars();
        if (vars.size())
            cout << "Variables:\n~~~~~~~~~~\n";
        for (const auto& v : vars) {
            cout << "  " << v.first << " = ";
            print_complex(cout, v.second);
            cout << '\n';
        }
        
        auto&& funcs = parser.symbol_table().funcs();
        if (funcs.size())
            cout << "\nFunctions:\n~~~~~~~~~~\n";
        for (const auto& f : funcs)
            cout << "  " << f.second << '\n';

        auto&& lists = parser.symbol_table().lists();
        if (lists.size())
            cout << "\nLists:\n~~~~~~\n";
        for (const auto& l : lists) {
            cout << "  " << l.first << " = ";
            print_list(cout, l.second);
            cout << '\n';
        }
    };

    commands["run"] = [this] {
        string fname;
        if (cout << "file: " && getline(cin, fname))
            run_file(fname);
    };

    commands["copy"] = [this] {
        auto str = mps::str::to_string(parser.symbol_table().value_of("ans"));
        mps::set_clipboard_text(str);
    };

    commands["copy,"] = [this] {
        auto str = mps::str::to_string(parser.symbol_table().value_of("ans"));
        mps::set_clipboard_text(mps::str::format_number_EU(str));
    };

    commands["table"] = [this] {
        string func = mps::get_str("Function: ");
        double low = mps::get_num<double>("Low: ");
        double high = mps::get_num<double>("High: ");
        cout << "Sorry, table feature not implemented yet.\n";
    };

    commands["dec"] = [] {
        cout << "hex/bin (W/ leading 0): ";
        int val{};
        if (mps::read_hex(cin, val))
            cin.ignore();
        else if (!mps::read_bin(cin, val)) {
            mps::recover_line(cin);
            return;
        }
        std::cout << val << '\n';
    };

    commands["bin"] = [] {
        cout << "dec/hex: ";
        int val{};
        if (!mps::read_hex(cin, val) && !(cin >> val)) {
            mps::recover_line(cin);
            return;
        }
        cin.ignore();
        mps::print_binary(cout, val);
        cout << '\n';
    };

    commands["hex"] = [] {
        cout << "dec/bin (w/ leading 0): ";
        int val{};
        if (!mps::read_bin(cin, val)) {
            if (!(cin >> val)) {
                mps::recover_line(cin);
                return;
            }
            cin.ignore();
        }
        cout << "0x" << hex << val << dec << '\n';
    };

    commands["exp"] = [this] {
        if (!parser.has_result())
            return;
        auto && n = parser.result();
        cout << abs(n) << "*e^(" << deg(arg(n)) << "deg)i\n";
    };
}

Calculator.hpp

#pragma once

#include <functional>
#include <map>
#include <string>

#include "Parser.hpp"
#include "SymbolTable.hpp"

class Calculator {
public: 
    Calculator();
    void run(int argc, char* argv[]);

private:
    void show_intro() const;
    bool handle_cmd(const std::string& cmd);
    void register_commands();

    bool run_file(const std::string& path);
    void run_cli();

    SymbolTable symbolTable;
    Parser parser;
    std::string prompt{ "> " };
    std::string intro;
    std::map<std::string, std::function<void()>> commands;
};

Function.cpp

#include "Function.hpp"

#include <ostream>

#include "mps/str_util.hpp"

#include "Parser.hpp"
#include "SymbolGuard.hpp"
#include "SymbolTable.hpp"
#include "types.hpp"

Function::Function(const std::string& name, SymbolTable& table)
    : funcName{ name }, table{ table }
{
}

Complex Function::operator()(const List& args) const
{
    if (args.size() != vars.size())
        throw std::runtime_error{ funcName + " expects " + std::to_string(vars.size()) +
        " arguments (received " + std::to_string(args.size()) + ")" };
    Parser parser{ table };
    SymbolGuard guard{ table };
    for (std::size_t i = 0; i < vars.size(); ++i)
        guard.shadow_var(vars[i], args[i]);
    parser.parse(term);
    return parser.result();
}

std::ostream& operator<<(std::ostream& os, const Function& func)
{
    os << func.funcName << '(';
    std::string sep;
    for (const auto& v : func.vars) {
        os << sep << v;
        sep = ",";
    }
    return os << ") = " << func.term;
}

Function.hpp

#pragma once

#include <string>
#include <vector>

#include "types.hpp"

class SymbolTable;

class Function {
public:
    Function(const std::string& name, SymbolTable& table);

    Complex operator()(const List& args) const;

    void set_term(const std::string& t) { term = t; }
    void add_var(const std::string& v) { vars.push_back(v); }

    std::size_t numArgs() const { return vars.size(); }
    const std::string& name() const { return funcName; }

    friend std::ostream& operator<<(std::ostream& os, const Function& func);

private:
    SymbolTable& table;
    std::string funcName;
    std::string term;
    std::vector<std::string> vars;
};

Grammar

Start = {Statement} End

Statement = [Expression | FunctionDefinition | ListDefinition | Deletion] (';' | '\n')

FunctionDefinition = 'fn' Identifier ParamList '=' Expression

Deletion = 'del' Identifier {Identifier}

Expression = Term { ('+' | '-') Term }

Term = Sign { ('*' | '/' | '%' | 'mod' | 'div' | '||') Sign }

Sign = ['+' | '-'] Postfix

Postfix = Primary ( ('^' | '**') Sign | {'!'} | Variable | FunctionCall)

Primary = Number | Variable | VariableDefinition | FunctionCall | '(' Expression ')'

ListDefinition = Identifier '=' BracketList

FunctionCall = Identifier ArgList

BracketList = '[' ListElements ']'

ArgList = '(' (ListElements | List) ')'

ListElements = [Expression] {',' Expression}

ParamList = '(' Identifier {',' Identifier} ')'

VariableDefinition = Identifier '=' Expression

Variable = ? Identifier stored in symbol table as Number value ?

List = ? Identifier stored in symbol table as List of Numbers ?

Identifier = Letter {'_' | Letter | Digit}

Number = ? C++ double ?

Letter = a..z | A..Z

Digit = 0..9

Parser.cpp

#include "Parser.hpp"

#include <cmath>
#include <iostream>

#include "mps/stream_util.hpp"

#include "math_util.hpp"
#include "SymbolTable.hpp"

Parser::Parser(SymbolTable& table)
    : table{ table }  { }

void Parser::set_symbol_table(SymbolTable& t)
{
    table = t;
}

void Parser::parse(std::istream& is)
{
    ts.set_input(is);
    parse();
}

void Parser::parse(const std::string& str)
{
    ts.set_input(str);
    parse();
}

void Parser::parse()
{
    ts.get();
    while (!consume(Kind::End))
        stmt();
}

void Parser::stmt()
{
    hasResult = true;
    if (peek(Kind::FuncDef))
        func_def();
    else if (peek(Kind::Delete))
        deletion();
    else if (!peek(Kind::Print))
        res = expr();

    if (hasResult && onRes)
        onRes(res);

    if (!peek(Kind::End))
        expect(Kind::Print);
}

void Parser::func_def()
{
    expect(Kind::FuncDef);

    Function func{ ident(), table };
    parse_param_list(func);
    expect(Kind::Assign);
    parse_func_term(func);

    List test_args(func.numArgs(), 1);
    func(test_args);

    table.set_func(func.name(), func);
    hasResult = false;
}

void Parser::parse_param_list(Function& func)
{
    expect(Kind::LParen);
    do {
        func.add_var(ident());
    } while (consume(Kind::Comma));
    expect(Kind::RParen);
}

void Parser::parse_func_term(Function& func)
{
    std::ostringstream term;
    while (!peek(Kind::Print) && !peek(Kind::End) && !peek(Kind::RBracket)) {
        term << ts.current();
        ts.get();
    }
    func.set_term(term.str());
}

void Parser::deletion()
{
    expect(Kind::Delete);
    if (!peek(Kind::String))
        error("No arguments provided to delete");

    do {
        del_symbol();
    } while (peek(Kind::String));

    hasResult = false;
}

static bool is_const(const std::string& var)
{
    return var == "pi" || var == "e" || var == "i" || var == "deg";
}

void Parser::del_symbol()
{
    auto& name = ident();
    if (is_const(name))
        error(name, " is a constant");
    if (table.is_reserved_func(name))
        error(name, " is a built-in function");
    table.remove_symbol(name);
}

void Parser::list_def(const std::string& name)
{
    table.set_list(name, list());
}

Complex Parser::expr()
{
    auto left = term();
    for (;;) {
        if (consume(Kind::Plus)) 
            left += term();
        else if (consume(Kind::Minus)) 
            left -= term();
        else
            return left;
    }
}

Complex Parser::term()
{
    auto left = sign();
    for (;;) {
        if (consume(Kind::Mul))
            left *= sign();
        else if (consume(Kind::Div))
            left = safe_div(left, sign());
        else if (consume(Kind::FloorDiv))
            left = safe_floordiv(left, sign());
        else if (consume(Kind::Mod))
            left = safe_mod(left, sign());
        else if (consume(Kind::Parallel))
            left = impedance_parallel(left, sign());
        else 
            return left;
    }
}

Complex Parser::sign()
{
    if (consume(Kind::Minus)) 
        return -postfix();
    consume(Kind::Plus);
    return postfix();
}

Complex Parser::postfix()
{
    auto left = prim();
    for (;;) {
        if (consume(Kind::Pow))
            return pretty_pow(left, sign());
        else if (peek(Kind::String))
            return left * postfix();
        else if (peek(Kind::LParen))
            return left * prim();
        else if (consume(Kind::Fac))
            left = factorial(left);
        else
            return left;
    }
}

Complex Parser::prim()
{
    if (consume(Kind::Number)) 
        return prevTok.num;
    if (peek(Kind::String))
        return resolve_str_tok();
    if (consume(Kind::LParen)) {
        auto val = expr();
        expect(Kind::RParen);
        return val;
    }
    error("Unexpected Token ", ts.current());
    throw std::logic_error{ "Fall through prim()" }; // silence C4715
}

Complex Parser::resolve_str_tok()
{
    auto name = ident();
    if (peek(Kind::LParen))
        return table.call_func(name, arg_list());
    else if (consume(Kind::Assign)) {
        if (peek(Kind::LBracket)) {
            list_def(name);
            return no_result();
        }
        return var_def(name);
    }
    else if (table.has_list(name)) {
        if (!peek(Kind::Print) && !peek(Kind::End))
            error("Unexpected Token ", ts.current());
        print_list(std::cout, table.list(name));
        std::cout << '\n';
        return no_result();
    }
    return table.value_of(name);
}

Complex Parser::var_def(const std::string& name)
{
    if (is_const(name))
        error("Cannot override constant ", name);
    if (peek(Kind::LBracket)) {
        table.set_list(name, list());
        return no_result();
    }
    if (table.isset(name) && !table.has_var(name))
        error(name, " is already defined");
    auto val = expr();
    table.set_var(name, val);
    return varDefIsRes ? val : no_result();
}

Complex Parser::no_result()
{
    hasResult = false;
    return 0; // dummy value
}

List Parser::list()
{
    expect(Kind::LBracket);
    List l;
    if (consume(Kind::For)) { // [for var=start, end:step loopExpression]
        auto var = ident();
        expect(Kind::Assign);
        auto start = prim().real();

        expect(Kind::Comma);
        auto end = prim().real();
        double step{ 1 };
        if (consume(Kind::Colon))
            step = prim().real();

        Function f{ "__internal__", table };
        f.add_var(var);
        parse_func_term(f);
        if (start < end && step <= 0 || start > end && step >= 0)
            error("Infinite loop");
        for (auto i = start; i <= end; i += step)
            l.emplace_back(f({ Complex(i) }));
    }
    else
        l = list_elem();
    expect(Kind::RBracket);
    return l;
}

List Parser::arg_list()
{
    expect(Kind::LParen);
    List args;

    if (peek(Kind::String) && table.has_list(ts.current().str))
        args = table.list(ident());
    else if (peek(Kind::LBracket))
        args = list();
    else
        args = list_elem();

    expect(Kind::RParen);
    if (args.empty())
        error("Invalid empty argument list");
    return args;
}

List Parser::list_elem()
{
    List list;
    if (!peek(Kind::RParen) && !peek(Kind::RBracket)) {
        do {
            list.emplace_back(expr());
        } while (consume(Kind::Comma));
    }
    return list;
}

const std::string& Parser::ident()
{
    expect(Kind::String);
    return prevTok.str;
}

bool Parser::consume(Kind kind)
{
    if (ts.current().kind == kind) {
        prevTok = ts.current();
        ts.get();
        return true;
    }
    return false;
}

bool Parser::peek(Kind kind) const
{
    return ts.current().kind == kind;
}

void Parser::expect(Kind kind)
{
    if (!consume(kind))
        error("Expected Token ", kind);
}

Parser.hpp

#pragma once

#include <istream>
#include <map>
#include <string>

#include "ErrorReporter.hpp"
#include "Function.hpp"
#include "TokenStream.hpp"
#include "types.hpp"

class SymbolTable;

class Parser {
public:
    Parser(SymbolTable& table);

    void parse(std::istream& is);
    void parse(const std::string& input);

    Complex result() const { return res; }
    bool has_result() const { return hasResult; }

    SymbolTable& symbol_table() { return table; }
    void set_symbol_table(SymbolTable& t);

    void set_vardef_is_res(bool isRes) { varDefIsRes = isRes; }
    void on_result(std::function<void(Complex)> handler) { onRes = std::move(handler); }

private:
    void parse();
    void stmt();
    void func_def();
    void parse_param_list(Function& func);
    void parse_func_term(Function& func);
    void deletion();
    void del_symbol();
    void list_def(const std::string& name);

    Complex expr();
    Complex term();
    Complex sign();
    Complex postfix();
    Complex prim();
    Complex resolve_str_tok();
    Complex var_def(const std::string& name);
    Complex no_result();

    List list();
    List arg_list();
    List list_elem();

    const std::string& ident();

    bool peek(Kind kind) const;
    bool consume(Kind kind);
    void expect(Kind kind);

    Token prevTok;
    SymbolTable& table;
    TokenStream ts;
    ErrorReporter error;

    Complex res;
    bool hasResult{};
    bool varDefIsRes{ true };
    std::function<void(Complex)> onRes;
};

SymbolGuard.cpp

#include "SymbolGuard.hpp"

SymbolGuard::SymbolGuard(SymbolTable& table)
    : table{ table }
{
}

SymbolGuard::~SymbolGuard()
{
    for (const auto& var : shadowedVars)
        table.remove_var(var);

    for (const auto& pair : varCache)
        table.set_var(pair.first, pair.second);
}

void SymbolGuard::shadow_var(const std::string& name, Complex tempVal)
{
    if (table.has_var(name)) {
        auto val = table.value_of(name);
        varCache[name] = val;
        table.remove_var(name);
    }
    table.set_var(name, tempVal);
    shadowedVars.push_back(name);
}

SymbolGuard.hpp

#pragma once

#include <string>
#include <unordered_map>
#include <vector>

#include "SymbolTable.hpp"
#include "types.hpp"

class SymbolGuard {
public:
    SymbolGuard(SymbolTable& table);
    ~SymbolGuard();

    void shadow_var(const std::string& name, Complex value);

private:
    SymbolTable& table;
    std::unordered_map<std::string, Complex> varCache;
    std::vector<std::string> shadowedVars;
};

SymbolTable.cpp

#include "SymbolTable.hpp"

#include <cassert>
#include <iostream>
#include <numeric>
#include <stdexcept>

#include <mps/stl_util.hpp>

#include "math_util.hpp"

using namespace std;
using namespace temp;
using namespace mps::stl;

#define CHECK_SINGLE_ARG(f) \
    if (list.size() != 1) throw std::runtime_error{ #f " expects exactly 1 argument" };

#define MAKE_COMPLEX_FUNC(f) [] (const List& list) { \
    CHECK_SINGLE_ARG(f) \
    return (f)(list.front()); }

#define MAKE_PROXY_FUNC(f) [] (const Complex& c) { \
        if (c.imag()) \
            throw std::runtime_error{ #f " not defined for complex numbers" }; \
        return Complex{ (f)(c.real()) }; }

#define MAKE_REAL_FUNC(f) [] (const List& list) { \
    CHECK_SINGLE_ARG(f) \
    if (list.front().imag()) \
        throw std::runtime_error{ #f " not defined for complex numbers" }; \
    return Complex{ (f)(list.front().real()) }; }

SymbolTable::SymbolTable()
{
    add_constants();
}

bool SymbolTable::is_reserved_func(const std::string& name) const
{
    return contains(defaultFuncTable, name);
}
void SymbolTable::set_var(ConstStrRef name, Complex val)
{
    varTable[name] = val;
}

void SymbolTable::set_list(ConstStrRef name, List&& list)
{
    listTable[name] = list;
}

void SymbolTable::set_func(ConstStrRef name, Function func)
{
    funcTable.erase(name);
    funcTable.emplace(name, std::move(func));
}

Complex SymbolTable::value_of(ConstStrRef var) const
{
    return find_or_throw(varTable, var, "Variable " + var + " is undefined")->second;
}

const List& SymbolTable::list(ConstStrRef name) const
{
    return find_or_throw(listTable, name, "List " + name + " is undefined")->second;
}

Complex SymbolTable::call_func(ConstStrRef func, const List& arg) const
{
    auto f = funcTable.find(func);
    if (f != end(funcTable))
        return f->second(arg);
    return find_or_throw(defaultFuncTable, func, "Function " + func + " is undefined")->second(arg);
}

bool SymbolTable::has_var(ConstStrRef name) const
{
    return contains(varTable, name);
}

bool SymbolTable::has_list(ConstStrRef name) const
{
    return contains(listTable, name);
}

bool SymbolTable::has_func(ConstStrRef name) const
{
    return contains(funcTable, name);
}

bool SymbolTable::isset(ConstStrRef name) const
{
    return has_var(name) || has_list(name) || has_func(name);
}

void SymbolTable::remove_var(ConstStrRef name)
{
    varTable.erase(name);
}

void SymbolTable::remove_list(ConstStrRef name)
{
    listTable.erase(name);
}

void SymbolTable::remove_func(ConstStrRef name)
{
    funcTable.erase(name);
}

void SymbolTable::remove_symbol(ConstStrRef name)
{
    if (!isset(name))
        throw runtime_error{ name + " is undefined" };
    if (has_func(name))
        remove_func(name);
    if (has_list(name))
        remove_list(name);
    if (has_var(name))
        remove_var(name);
}

void SymbolTable::clear()
{
    clear_vars();
    clear_funcs();
    clear_lists();
}

void SymbolTable::clear_vars()
{
    varTable.clear();
    add_constants();
}

void SymbolTable::clear_funcs()
{
    funcTable.clear();
}

void SymbolTable::clear_lists()
{
    listTable.clear();
}

void SymbolTable::add_constants()
{
    varTable["i"] = { 0, 1 };
    varTable["pi"] = pi;
    varTable["e"] = 2.7182818284590452354;
    varTable["deg"] = pi / 180;
}

const SymbolTable::FuncMap SymbolTable::defaultFuncTable{
    { "sin", MAKE_COMPLEX_FUNC(sin) },
    { "cos", MAKE_COMPLEX_FUNC(cos) },
    { "tan", MAKE_COMPLEX_FUNC(tan) },
    { "asin", MAKE_COMPLEX_FUNC(asin) },
    { "acos", MAKE_COMPLEX_FUNC(acos) },
    { "atan", MAKE_COMPLEX_FUNC(atan) },
    { "sinh", MAKE_COMPLEX_FUNC(sinh) },
    { "cosh", MAKE_COMPLEX_FUNC(cosh) },
    { "tanh", MAKE_COMPLEX_FUNC(tanh) },
    { "asinh", MAKE_COMPLEX_FUNC(asinh) },
    { "acosh", MAKE_COMPLEX_FUNC(acosh) },
    { "atanh", MAKE_COMPLEX_FUNC(atanh) },
    { "deg", MAKE_REAL_FUNC(deg) },
    { "rad", MAKE_REAL_FUNC(rad) },

    { "CtoK", MAKE_REAL_FUNC(CtoK) },
    { "KtoC", MAKE_REAL_FUNC(KtoC) },
    { "FtoC", MAKE_REAL_FUNC(FtoC) },
    { "CtoF", MAKE_REAL_FUNC(CtoF) },
    { "FtoK", MAKE_REAL_FUNC(FtoK) },
    { "KtoF", MAKE_REAL_FUNC(KtoF) },

    { "abs", MAKE_COMPLEX_FUNC(abs) },
    { "norm", MAKE_COMPLEX_FUNC(norm) },
    { "arg", MAKE_COMPLEX_FUNC(arg) },
    { "exp", MAKE_COMPLEX_FUNC(exp) },

    { "sqr", MAKE_COMPLEX_FUNC(sqr) },
    { "sqrt", MAKE_COMPLEX_FUNC(sqrt) },
    { "ln", MAKE_COMPLEX_FUNC(log) },
    { "log", MAKE_COMPLEX_FUNC(log10) },

    { "Re", MAKE_COMPLEX_FUNC(real) },
    { "Im", MAKE_COMPLEX_FUNC(imag) },

    { "floor", MAKE_REAL_FUNC(floor) },
    { "ceil", MAKE_REAL_FUNC(ceil) },
    { "round", MAKE_REAL_FUNC(round) },
    { "trunc", MAKE_REAL_FUNC(trunc) },

    { "cbrt", MAKE_REAL_FUNC(cbrt) },

    { "sum", sum },
    { "sum2", sqr_sum },
    { "avg", avg },
    { "len", len },
    { "sx", standard_deviation },
    { "ux", standard_uncertainty }
};

SymbolTable.hpp

#pragma once

#include <map>
#include <string>

#include "mps/stl_util.hpp"

#include "Function.hpp"
#include "types.hpp"

class SymbolTable {
public:
    using ConstStrRef = const std::string&;
    using FuncMap = std::map<std::string, Func>;

    SymbolTable();

    bool is_reserved_func(const std::string& name) const;

    void set_var(ConstStrRef name, Complex value);
    void set_list(ConstStrRef name, List&& list);
    void set_func(ConstStrRef name, Function func);

    Complex value_of(ConstStrRef var) const;
    const List& list(ConstStrRef var) const;
    Complex call_func(ConstStrRef func, const List& args) const;

    bool has_var(ConstStrRef name) const;
    bool has_list(ConstStrRef name) const;
    bool has_func(ConstStrRef name) const;
    bool isset(ConstStrRef name) const;

    void remove_var(ConstStrRef name);
    void remove_list(ConstStrRef name);
    void remove_func(ConstStrRef name);
    void remove_symbol(ConstStrRef name);

    void clear();
    void clear_vars();
    void clear_funcs();
    void clear_lists();

    const std::map<std::string, Complex>& vars() const { return varTable; }
    const std::map<std::string, List>& lists() const { return listTable; }
    const std::map<std::string, Function>& funcs() const { return funcTable; }

private:
    void add_constants();

    static const FuncMap defaultFuncTable;

    std::map<std::string, Complex> varTable;
    std::map<std::string, List> listTable;
    std::map<std::string, Function> funcTable;
};

Token.hpp

#pragma once

#include <string>

enum class Kind : char {
    End,
    Invalid,
    Number,
    String,
    Parallel,
    Print,
    FloorDiv,
    Delete,
    FuncDef,
    For,

    Plus = '+', 
    Minus = '-',
    Mul = '*', 
    Div = '/',
    Mod = '%',
    Pow = '^',
    Fac = '!',
    Assign = '=',
    Comma = ',',
    Colon = ':',

    LParen = '(',
    RParen = ')',
    LBrace = '{', 
    RBrace = '}',
    LBracket = '[',
    RBracket = ']',
};

struct Token {
    Kind kind{};
    std::string str;
    double num{};
};

inline std::ostream& operator<<(std::ostream& os, Kind kind)
{
    switch (kind) {
    case Kind::End: return os << "END";
    case Kind::Invalid: return os << "INVALID";
    case Kind::Number: return os << "NUMBER";
    case Kind::String: return os << "STRING";
    case Kind::Parallel: return os << "PARALLEL";
    case Kind::Print: return os << "PRINT";
    case Kind::FloorDiv: return os << "div";
    default: return os << static_cast<char>(kind);
    }
}

inline std::ostream& operator<<(std::ostream& os, const Token& token)
{
    switch (token.kind) {
    case Kind::Number: return os << token.num;
    case Kind::String: return os << token.str;
    default: return os << token.kind;
    }
}

TokenStream.cpp

#include "TokenStream.hpp"

#include <cassert>
#include <cctype>
#include <iostream>
#include <map>
#include <sstream>

TokenStream::TokenStream(std::istream& is)
    : input{ &is } { }

TokenStream::TokenStream(std::istream* is)
    : input{ is }, ownsInput{ true } { }

TokenStream::TokenStream(const std::string& str)
    : input{ new std::istringstream{str} }, ownsInput{ true } { }

void TokenStream::set_input(std::istream& is)
{
    cleanup();
    input = &is;
}

void TokenStream::set_input(std::istream* is)
{
    cleanup();
    input = is;
    ownsInput = true;
}

void TokenStream::set_input(const std::string& str)
{
    set_input(new std::istringstream{ str });
}

static constexpr unsigned char uchar(char ch)
{   // for isalpha etc. which expect ch >= -1 and ch <= 255
    return static_cast<unsigned char>(ch);
}

Token TokenStream::get()
{
    char ch;
    do {
        if (!input || !input->get(ch)) 
            return ct = { Kind::End };
    } while (std::isspace(uchar(ch)) && ch != '\n');

    switch (ch) {
    case ';':
    case '\n':
        return ct = { Kind::Print };
    case '+':
    case '-':
    case '%':
    case '!':
    case '^':
    case ',':
    case '=':
    case ':':
    case '(': case ')':
    case '[': case ']':
    case '{': case '}':
        return ct = { static_cast<Kind>(ch) };
    case '*':
        return ct = parse_double_op('*', Kind::Pow, Kind::Mul);
    case '/':
        return ct = parse_double_op('/', Kind::FloorDiv, Kind::Div);
    case '|':
        return ct = parse_double_op('|', Kind::Parallel, Kind::Invalid);
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
    case '.':
        input->unget();
        *input >> ct.num;
        ct.kind = Kind::Number;
        return ct;
    default:
        return ct = parse_identifier(ch);
    }
}

Token TokenStream::parse_double_op(char next, Kind onMatch, Kind onFailure)
{
    char c;
    if (input->get(c) && c == next) 
        return { onMatch };
    else {
        input->unget();
        if (onFailure != Kind::Invalid) 
            return { onFailure };
        error("Expected Token: ", next);
    }
    return { Kind::Invalid };
}

Token TokenStream::parse_identifier(char ch)
{
    if (std::isalpha(uchar(ch)) || ch == '_') {
        std::string s{ ch };
        while (input->get(ch) && (std::isalnum(uchar(ch)) || ch == '_'))
            s += ch;
        input->unget();
        return identifier_to_token(s);
    }
    error("Bad Token ", ch);
    return { Kind::Invalid };
}

static const std::map<std::string, Kind> strTokens{
    { "div", Kind::FloorDiv },
    { "mod", Kind::Mod },
    { "del", Kind::Delete },
    { "fn", Kind::FuncDef },
    { "for", Kind::For }
};

Token TokenStream::identifier_to_token(const std::string& str) const
{
    auto found = strTokens.find(str);
    if (found != cend(strTokens))
        return { found->second };
    return { Kind::String, str };
}

void TokenStream::cleanup()
{
    if (ownsInput) {
        delete input;
        ownsInput = false;
    }
}

TokenStream.hpp

#pragma once

#include <istream>

#include "ErrorReporter.hpp"
#include "Token.hpp"

class TokenStream {
public:
    TokenStream() = default;
    explicit TokenStream(std::istream& input);
    explicit TokenStream(std::istream* input);
    explicit TokenStream(const std::string& input);

    TokenStream(const TokenStream&) = delete;
    TokenStream& operator=(const TokenStream&) = delete;

    void set_input(std::istream& input);
    void set_input(std::istream* input);
    void set_input(const std::string& input);

    Token get();
    const Token& current() const { return ct; }

private:
    Token parse_identifier(char firstChar);
    Token parse_double_op(char expected, Kind onSuccess, Kind onFailure);
    Token identifier_to_token(const std::string& str) const;
    void cleanup();

    Token ct{ Kind::End };
    std::istream* input{};
    bool ownsInput{};
    ErrorReporter error;
};

types.hpp

#pragma once

#include <complex>
#include <functional>
#include <iostream>
#include <vector>

using Complex = std::complex<double>;
using List = std::vector<Complex>;
using Func = std::function<Complex(const List&)>;

template<class T>
void print_complex(std::ostream& os, const std::complex<T>& n)
{
    using std::cout;

    if (n.imag()) {
        if (n.real()) {
            cout << n.real();
            if (n.imag() > 0)
                cout << '+';
        }
        if (std::abs(n.imag()) != 1)
            cout << n.imag();
        cout << (n.imag() == -1 ? "-" : "") << 'i';
    }
    else
        cout << n.real();
}

template<class T>
void print_list(std::ostream& os, const std::vector<T>& v)
{
    std::cout << '[';
    std::string sep;
    for (const auto& item : v) {
        std::cout << sep;
        print_complex(std::cout, item);
        sep = ", ";
    }
    std::cout << ']';
}