operations.cpp

#include <limits>
#include <cmath>

#include "operations.h"
#include "helpers.h"
#include "scheme.h"

std::map<std::string, Operation> operations = {{"+", Add},
                                               {"-", Sub},
                                               {"*", Mul},
                                               {"/", Div},
                                               {"=", Eq},
                                               {"<", Less},
                                               {">", Greater},
                                               {"<=", LessEq},
                                               {">=", GreaterEq},
                                               {"max", Max},
                                               {"min", Min},
                                               {"abs", Abs},
                                               {"number?", IsNum},
                                               {"boolean?", IsBool},
                                               {"and", And},
                                               {"or", Or},
                                               {"not", Not},
                                               {"quote", Quote},
                                               {"list", List},
                                               {"car", Car},
                                               {"cdr", Cdr},
                                               {"cons", Cons},
                                               {"pair?", IsPair},
                                               {"null?", IsNull},
                                               {"list?", IsList},
                                               {"list-ref", ListRef},
                                               {"list-tail", ListTail}};

void CheckArgCount(const std::vector<std::shared_ptr<Object>>& args, size_t expected) {
    if (args.size() != expected) {
        throw RuntimeError("Expected " + std::to_string(expected) + " arguments.");
    }
}

std::shared_ptr<Number> EvaluateNumber(const std::shared_ptr<Object>& obj,
                                       Interpreter* interpreter) {
    auto num = As<Number>(interpreter->Evaluate(obj));
    if (!num) {
        throw RuntimeError("Expected integer argument");
    }
    return num;
}

int64_t GetNumberValue(const std::shared_ptr<Object>& obj, Interpreter* interpreter) {
    return EvaluateNumber(obj, interpreter)->GetValue();
}

std::shared_ptr<Object> Add(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    int64_t sm = 0;
    for (const auto& arg : args) {
        sm += GetNumberValue(arg, interpreter);
    }
    return std::make_shared<Number>(sm);
}

std::shared_ptr<Object> Sub(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    if (args.empty()) {
        throw RuntimeError("Expected at least one argument");
    }
    int64_t diff = GetNumberValue(args[0], interpreter);
    for (size_t i = 1; i < args.size(); ++i) {
        diff -= GetNumberValue(args[i], interpreter);
    }
    return std::make_shared<Number>(diff);
}

std::shared_ptr<Object> Mul(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    int64_t prod = 1;
    for (const auto& arg : args) {
        prod *= GetNumberValue(arg, interpreter);
    }
    return std::make_shared<Number>(prod);
}

std::shared_ptr<Object> Div(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    if (args.empty()) {
        throw RuntimeError("Expected at least one argument");
    }
    int64_t quotient = GetNumberValue(args[0], interpreter);
    for (size_t i = 1; i < args.size(); ++i) {
        int64_t divisor = GetNumberValue(args[i], interpreter);
        if (divisor == 0) {
            throw RuntimeError("Division by zero");
        }
        quotient /= divisor;
    }
    return std::make_shared<Number>(quotient);
}

std::shared_ptr<Object> Eq(const std::vector<std::shared_ptr<Object>>& args,
                           Interpreter* interpreter) {
    if (args.empty()) {
        return std::make_shared<Boolean>(true);
    }
    int64_t first_val = GetNumberValue(args[0], interpreter);
    for (size_t i = 1; i < args.size(); ++i) {
        if (GetNumberValue(args[i], interpreter) != first_val) {
            return std::make_shared<Boolean>(false);
        }
    }
    return std::make_shared<Boolean>(true);
}

std::shared_ptr<Object> Less(const std::vector<std::shared_ptr<Object>>& args,
                             Interpreter* interpreter) {
    for (size_t i = 1; i < args.size(); ++i) {
        if (GetNumberValue(args[i - 1], interpreter) >= GetNumberValue(args[i], interpreter)) {
            return std::make_shared<Boolean>(false);
        }
    }
    return std::make_shared<Boolean>(true);
}

std::shared_ptr<Object> Greater(const std::vector<std::shared_ptr<Object>>& args,
                                Interpreter* interpreter) {
    for (size_t i = 1; i < args.size(); ++i) {
        if (GetNumberValue(args[i - 1], interpreter) <= GetNumberValue(args[i], interpreter)) {
            return std::make_shared<Boolean>(false);
        }
    }
    return std::make_shared<Boolean>(true);
}

std::shared_ptr<Object> LessEq(const std::vector<std::shared_ptr<Object>>& args,
                               Interpreter* interpreter) {
    for (size_t i = 1; i < args.size(); ++i) {
        if (GetNumberValue(args[i - 1], interpreter) > GetNumberValue(args[i], interpreter)) {
            return std::make_shared<Boolean>(false);
        }
    }
    return std::make_shared<Boolean>(true);
}

std::shared_ptr<Object> GreaterEq(const std::vector<std::shared_ptr<Object>>& args,
                                  Interpreter* interpreter) {
    for (size_t i = 1; i < args.size(); ++i) {
        if (GetNumberValue(args[i - 1], interpreter) < GetNumberValue(args[i], interpreter)) {
            return std::make_shared<Boolean>(false);
        }
    }
    return std::make_shared<Boolean>(true);
}

std::shared_ptr<Object> Max(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    if (args.empty()) {
        throw RuntimeError("Expected at least one argument");
    }
    int64_t mx_val = std::numeric_limits<int64_t>::min();
    for (const auto& arg : args) {
        int64_t val = GetNumberValue(arg, interpreter);
        if (val > mx_val) {
            mx_val = val;
        }
    }
    return std::make_shared<Number>(mx_val);
}

std::shared_ptr<Object> Min(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    if (args.empty()) {
        throw RuntimeError("Expected at least one argument");
    }
    int64_t mn_val = std::numeric_limits<int64_t>::max();
    for (const auto& arg : args) {
        int64_t val = GetNumberValue(arg, interpreter);
        if (val < mn_val) {
            mn_val = val;
        }
    }
    return std::make_shared<Number>(mn_val);
}

std::shared_ptr<Object> Abs(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    CheckArgCount(args, 1);
    int64_t val = GetNumberValue(args[0], interpreter);
    return std::make_shared<Number>(std::abs(val));
}

std::shared_ptr<Object> IsNum(const std::vector<std::shared_ptr<Object>>& args,
                              Interpreter* interpreter) {
    CheckArgCount(args, 1);
    return std::make_shared<Boolean>(Is<Number>(interpreter->Evaluate(args[0])));
}

std::shared_ptr<Object> IsBool(const std::vector<std::shared_ptr<Object>>& args,
                               Interpreter* interpreter) {
    CheckArgCount(args, 1);
    return std::make_shared<Boolean>(Is<Boolean>(interpreter->Evaluate(args[0])));
}

std::shared_ptr<Object> And(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    std::shared_ptr<Object> res = std::make_shared<Boolean>(true);
    for (const auto& arg : args) {
        res = interpreter->Evaluate(arg);
        if (!ToBooleanHelper(res)) {
            return res;
        }
    }
    return res;
}

std::shared_ptr<Object> Or(const std::vector<std::shared_ptr<Object>>& args,
                           Interpreter* interpreter) {
    for (const auto& arg : args) {
        auto res = interpreter->Evaluate(arg);
        if (ToBooleanHelper(res)) {
            return res;
        }
    }
    return std::make_shared<Boolean>(false);
}

std::shared_ptr<Object> Not(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    CheckArgCount(args, 1);
    return std::make_shared<Boolean>(!ToBooleanHelper(interpreter->Evaluate(args[0])));
}

std::shared_ptr<Object> Quote(const std::vector<std::shared_ptr<Object>>& args,
                              Interpreter* interpreter) {
    CheckArgCount(args, 1);
    return args[0];
}

std::shared_ptr<Object> List(const std::vector<std::shared_ptr<Object>>& args,
                             Interpreter* interpreter) {
    if (args.empty()) {
        return nullptr;
    }
    auto head = std::make_shared<Cell>(interpreter->Evaluate(args[0]), nullptr);
    auto cur_cell = head;
    for (size_t i = 1; i < args.size(); ++i) {
        auto new_cell = std::make_shared<Cell>(interpreter->Evaluate(args[i]), nullptr);
        cur_cell->SetSecond(new_cell);
        cur_cell = new_cell;
    }
    return head;
}

std::shared_ptr<Object> Car(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    CheckArgCount(args, 1);
    auto cell = As<Cell>(interpreter->Evaluate(args[0]));
    if (!cell) {
        throw RuntimeError("Car expected a pair");
    }
    return cell->GetFirst();
}

std::shared_ptr<Object> Cdr(const std::vector<std::shared_ptr<Object>>& args,
                            Interpreter* interpreter) {
    CheckArgCount(args, 1);
    auto cell = As<Cell>(interpreter->Evaluate(args[0]));
    if (!cell) {
        throw RuntimeError("Cdr expected a pair");
    }
    return cell->GetSecond();
}

std::shared_ptr<Object> Cons(const std::vector<std::shared_ptr<Object>>& args,
                             Interpreter* interpreter) {
    CheckArgCount(args, 2);
    return std::make_shared<Cell>(interpreter->Evaluate(args[0]), interpreter->Evaluate(args[1]));
}

std::shared_ptr<Object> IsPair(const std::vector<std::shared_ptr<Object>>& args,
                               Interpreter* interpreter) {
    CheckArgCount(args, 1);
    return std::make_shared<Boolean>(Is<Cell>(interpreter->Evaluate(args[0])));
}

std::shared_ptr<Object> IsNull(const std::vector<std::shared_ptr<Object>>& args,
                               Interpreter* interpreter) {
    CheckArgCount(args, 1);
    return std::make_shared<Boolean>(interpreter->Evaluate(args[0]) == nullptr);
}

std::shared_ptr<Object> IsList(const std::vector<std::shared_ptr<Object>>& args,
                               Interpreter* interpreter) {
    CheckArgCount(args, 1);
    return std::make_shared<Boolean>(IsTrueList(interpreter->Evaluate(args[0])));
}

std::shared_ptr<Object> ListRef(const std::vector<std::shared_ptr<Object>>& args,
                                Interpreter* interpreter) {
    CheckArgCount(args, 2);
    auto list = interpreter->Evaluate(args[0]);
    auto index = As<Number>(interpreter->Evaluate(args[1]));
    if (!index) {
        throw RuntimeError("ListRef expected a number");
    }
    int idx = index->GetValue();
    while (idx > 0) {
        auto cell = As<Cell>(list);
        if (!cell) {
            throw RuntimeError("ListRef index out of bounds");
        }
        list = cell->GetSecond();
        --idx;
    }
    auto cell = As<Cell>(list);
    if (!cell) {
        throw RuntimeError("ListRef index out of bounds");
    }
    return cell->GetFirst();
}

std::shared_ptr<Object> ListTail(const std::vector<std::shared_ptr<Object>>& args,
                                 Interpreter* interpreter) {
    CheckArgCount(args, 2);
    auto list = interpreter->Evaluate(args[0]);
    auto index = As<Number>(interpreter->Evaluate(args[1]));
    if (!index) {
        throw RuntimeError("ListTail expected a number");
    }
    int index_val = index->GetValue();
    while (index_val > 0) {
        auto new_cell = As<Cell>(list);
        if (!new_cell) {
            throw RuntimeError("ListTail index out of bounds");
        }
        list = new_cell->GetSecond();
        --index_val;
    }
    return list;
}