PorygonLang/src/Evaluator/Evaluator.cpp

#include <utility>
#include <memory>
#include "Evaluator.hpp"
#include "EvaluationException.hpp"
#include "../Script.hpp"
#include "EvaluationScope/EvaluationScope.hpp"
#include "EvalValues/ScriptFunctionEvalValue.hpp"
#include "EvalValues/TableEvalValue.hpp"
#include "../Binder/BoundExpressions/BoundTableExpression.hpp"
#include "../TableScriptType.hpp"

using namespace std;
using namespace Porygon::Binder;

namespace Porygon::Evaluation {
    EvalValue *Evaluator::Evaluate(const BoundScriptStatement *statement) {
        this->_evaluationScope = make_shared<EvaluationScope>(this->_scriptVariables,
                                                              statement->GetLocalVariableCount());
        EvaluateBlockStatement(statement);
        return this->_returnValue.get();
    }

    void Evaluator::EvaluateStatement(const BoundStatement *statement) {
        if (this->_hasReturned)
            return;
        switch (statement->GetKind()) {
            case BoundStatementKind::Script:
                throw; // Should never happen
            case BoundStatementKind::Block:
                return this->EvaluateBlockStatement((BoundBlockStatement *) statement);
            case BoundStatementKind::Expression:
                return this->EvaluateExpressionStatement((BoundExpressionStatement *) statement);
            case BoundStatementKind::Assignment:
                return this->EvaluateAssignmentStatement((BoundAssignmentStatement *) statement);
            case BoundStatementKind::IndexAssignment:
                return this->EvaluateIndexAssignmentStatement((BoundIndexAssignmentStatement *) statement);
            case BoundStatementKind::FunctionDeclaration:
                return this->EvaluateFunctionDeclarationStatement((BoundFunctionDeclarationStatement *) statement);
            case BoundStatementKind::Return:
                return this->EvaluateReturnStatement((BoundReturnStatement *) statement);
            case BoundStatementKind::Conditional:
                return this->EvaluateConditionalStatement((BoundConditionalStatement *) statement);

            case BoundStatementKind::Bad:
                throw;
        }
    }

    void Evaluator::EvaluateBlockStatement(const BoundBlockStatement *statement) {
        for (auto s: *statement->GetStatements()) {
            this->EvaluateStatement(s);
            if (this->_hasReturned)
                break;
        }
    }

    void Evaluator::EvaluateExpressionStatement(const BoundExpressionStatement *statement) {
        // Save new value
        this->_lastValue = this->EvaluateExpression(statement->GetExpression());
    }

    void Evaluator::EvaluateAssignmentStatement(const BoundAssignmentStatement *statement) {
        auto value = this->EvaluateExpression(statement->GetExpression());
        auto key = statement->GetKey();
        if (key->IsCreation()) {
            this->_evaluationScope->CreateVariable(key, value);
        } else {
            this->_evaluationScope->SetVariable(key, value);
        }
    }

    void Evaluator::EvaluateIndexAssignmentStatement(const BoundIndexAssignmentStatement *statement) {
        auto indexExpression = statement->GetIndexExpression();
        auto value = this->EvaluateExpression(statement->GetValueExpression());
        auto index = ((BoundIndexExpression *) indexExpression);
        auto table = this->EvaluateExpression(index->GetIndexableExpression());
        auto key = this->EvaluateExpression(index->GetIndexExpression());
        table->SetIndexValue(key.get(), value);
    }

    void Evaluator::EvaluateFunctionDeclarationStatement(const BoundFunctionDeclarationStatement *statement) {
        auto type = statement->GetType();
        auto key = statement->GetKey();
        auto block = statement->GetBlock();
        auto value = make_shared<ScriptFunctionEvalValue>(block, this->_evaluationScope, type);
        if (key->IsCreation()) {
            this->_evaluationScope->CreateVariable(key, value);
        } else {
            this->_evaluationScope->SetVariable(key, value);
        }
    }

    void Evaluator::EvaluateReturnStatement(const BoundReturnStatement *statement) {
        auto expression = statement->GetExpression();
        if (expression == nullptr) {
            this->_hasReturned = true;
            this -> _returnValue = nullptr;
            return;
        }
        auto value = this->EvaluateExpression(expression);
        this->_hasReturned = true;
        this->_returnValue = value;
    }

    void Evaluator::EvaluateConditionalStatement(const BoundConditionalStatement *statement) {
        auto condition = statement->GetCondition();
        if (EvaluateBoolExpression(condition)->EvaluateBool()) {
            this->EvaluateStatement(statement->GetBlock());
        } else {
            auto elseStatement = statement->GetElseStatement();
            if (elseStatement != nullptr) {
                this->EvaluateStatement(elseStatement);
            }
        }
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateExpression(const BoundExpression *expression) {
        auto type = expression->GetType();
        switch (type->GetClass()) {
            case TypeClass::Number:
                return this->EvaluateIntegerExpression(expression);
            case TypeClass::Bool:
                return this->EvaluateBoolExpression(expression);
            case TypeClass::String:
                return this->EvaluateStringExpression(expression);
            case TypeClass::Function:
                return this->EvaluateFunctionExpression(expression);
            case TypeClass::Nil:
                return this->EvaluateNilExpression(expression);
            case TypeClass::Table:
                return this->EvaluateTableExpression(expression);
            case TypeClass::UserData:
                return this->EvaluateUserDataExpression(expression);
            default:
                throw;
        }
    }

    const shared_ptr<EvalValue> Evaluator::GetVariable(const BoundVariableExpression *expression) {
        auto variable = this->_evaluationScope->GetVariable(expression->GetKey());
        if (variable == nullptr) {
            throw EvaluationException("Variable not found");
        }
        return variable->Clone();
    }

    const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerExpression(const BoundExpression *expression) {
        switch (expression->GetKind()) {
            case BoundExpressionKind::LiteralInteger:
                return make_shared<IntegerEvalValue>(((BoundLiteralIntegerExpression *) expression)->GetValue());
            case BoundExpressionKind::LiteralFloat:
                return make_shared<FloatEvalValue>(((BoundLiteralFloatExpression *) expression)->GetValue());
            case BoundExpressionKind::Unary:
                return this->EvaluateIntegerUnary((BoundUnaryExpression *) expression);
            case BoundExpressionKind::Binary:
                return this->EvaluateIntegerBinary((BoundBinaryExpression *) expression);
            case BoundExpressionKind::Variable:
                return dynamic_pointer_cast<NumericEvalValue>(
                        this->GetVariable((BoundVariableExpression *) expression));
            case BoundExpressionKind::FunctionCall:
                return dynamic_pointer_cast<NumericEvalValue>(this->EvaluateFunctionCallExpression(expression));
            case BoundExpressionKind::Index:
                return dynamic_pointer_cast<NumericEvalValue>(this->EvaluateIndexExpression(expression));
            case BoundExpressionKind::PeriodIndex:
                return dynamic_pointer_cast<NumericEvalValue>(this->EvaluatePeriodIndexExpression(expression));

            case BoundExpressionKind::LiteralString:
            case BoundExpressionKind::LiteralBool:
            case BoundExpressionKind::Bad:
            case BoundExpressionKind::NumericalTable:
            case BoundExpressionKind::Table:
                throw;
        }
    }

    const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBoolExpression(const BoundExpression *expression) {
        switch (expression->GetKind()) {
            case BoundExpressionKind::LiteralBool:
                return make_shared<BooleanEvalValue>(((BoundLiteralBoolExpression *) expression)->GetValue());
            case BoundExpressionKind::Unary:
                return this->EvaluateBooleanUnary((BoundUnaryExpression *) expression);
            case BoundExpressionKind::Binary:
                return this->EvaluateBooleanBinary((BoundBinaryExpression *) expression);
            case BoundExpressionKind::Variable:
                return dynamic_pointer_cast<BooleanEvalValue>(
                        this->GetVariable((BoundVariableExpression *) expression));
            case BoundExpressionKind::FunctionCall:
                return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluateFunctionCallExpression(expression));
            case BoundExpressionKind::Index:
                return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluateIndexExpression(expression));
            case BoundExpressionKind::PeriodIndex:
                return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluatePeriodIndexExpression(expression));

            case BoundExpressionKind::Bad:
            case BoundExpressionKind::LiteralInteger:
            case BoundExpressionKind::LiteralFloat:
            case BoundExpressionKind::LiteralString:
            case BoundExpressionKind::NumericalTable:
            case BoundExpressionKind::Table:
                throw;

        }
    }

    const shared_ptr<StringEvalValue> Evaluator::EvaluateStringExpression(const BoundExpression *expression) {
        switch (expression->GetKind()) {
            case BoundExpressionKind::LiteralString:
                return make_shared<StringEvalValue>(((BoundLiteralStringExpression *) expression)->GetValue());
            case BoundExpressionKind::Binary:
                return this->EvaluateStringBinary((BoundBinaryExpression *) expression);
            case BoundExpressionKind::Variable:
                return dynamic_pointer_cast<StringEvalValue>(this->GetVariable((BoundVariableExpression *) expression));
            case BoundExpressionKind::FunctionCall:
                return dynamic_pointer_cast<StringEvalValue>(this->EvaluateFunctionCallExpression(expression));
            case BoundExpressionKind::Index:
                return dynamic_pointer_cast<StringEvalValue>(this->EvaluateIndexExpression(expression));
            case BoundExpressionKind::PeriodIndex:
                return dynamic_pointer_cast<StringEvalValue>(this->EvaluatePeriodIndexExpression(expression));

            case BoundExpressionKind::Bad:
            case BoundExpressionKind::LiteralInteger:
            case BoundExpressionKind::LiteralFloat:
            case BoundExpressionKind::LiteralBool:
            case BoundExpressionKind::Unary:
            case BoundExpressionKind::NumericalTable:
            case BoundExpressionKind::Table:
                throw;

        }
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateFunctionExpression(const BoundExpression *expression) {
        switch (expression->GetKind()) {
            case BoundExpressionKind::Variable:
                return this->GetVariable((BoundVariableExpression *) expression);
            case BoundExpressionKind::Index:
                return this->EvaluateIndexExpression(expression);
            case BoundExpressionKind::PeriodIndex:
                return this->EvaluatePeriodIndexExpression(expression);
            default:
                throw;
        }
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateNilExpression(const BoundExpression *expression) {
        switch (expression->GetKind()) {
            case BoundExpressionKind::FunctionCall:
                return this->EvaluateFunctionCallExpression(expression);
            default:
                return nullptr;
        }
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateTableExpression(const BoundExpression *expression) {
        switch (expression->GetKind()) {
            case BoundExpressionKind::FunctionCall:
                return this->EvaluateFunctionCallExpression(expression);
            case BoundExpressionKind::Variable:
                return this->GetVariable((BoundVariableExpression *) expression);
            case BoundExpressionKind::Index:
                return this->EvaluateIndexExpression(expression);
            case BoundExpressionKind::NumericalTable:
                return this->EvaluateNumericTableExpression(expression);
            case BoundExpressionKind::Table:
                return this->EvaluateComplexTableExpression(expression);
            case BoundExpressionKind::PeriodIndex:
                return this->EvaluatePeriodIndexExpression(expression);
            default:
                throw;
        }
    }


    const shared_ptr<EvalValue> Evaluator::EvaluateFunctionCallExpression(const BoundExpression *expression) {
        auto functionCall = (BoundFunctionCallExpression *) expression;
        auto function = dynamic_pointer_cast<ScriptFunctionEvalValue>(
                this->EvaluateExpression(functionCall->GetFunctionExpression()));

        auto boundParameters = functionCall->GetParameters();
        auto parameters = vector<shared_ptr<EvalValue>>(boundParameters->size());
        for (int i = 0; i < boundParameters->size(); i++) {
            parameters[i] = this->EvaluateExpression(boundParameters->at(i));
        }

        auto type = std::dynamic_pointer_cast<FunctionScriptType>(function->GetType());
        auto parameterTypes = type->GetParameterTypes();
        auto parameterKeys = type->GetParameterKeys();
        auto originalScope = this->_evaluationScope;
        this->_evaluationScope = function->GetScope();

        for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++) {
            auto parameter = parameters[i];
            auto key = parameterKeys.at(i);
            this->_evaluationScope->CreateVariable(key.get(), parameter->Clone());
        }
        this->EvaluateBlockStatement(function->GetInnerBlock().get());
        this->_evaluationScope = originalScope;

        this->_hasReturned = false;
        auto r = this->_returnValue;
        this->_returnValue = nullptr;
        return r;
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateFunction(const ScriptFunctionEvalValue *function,
                                                            const vector<EvalValue *> &parameters) {
        auto type = std::dynamic_pointer_cast<FunctionScriptType>(function->GetType());
        auto parameterTypes = type->GetParameterTypes();
        auto parameterKeys = type->GetParameterKeys();

        auto originalScope = this->_evaluationScope;
        this->_evaluationScope = function->GetScope();

        for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++) {
            auto parameter = parameters[i];
            auto key = parameterKeys.at(i);
            this->_evaluationScope->CreateVariable(key.get(), parameter->Clone());
        }
        this->EvaluateBlockStatement(function->GetInnerBlock().get());
        this->_evaluationScope = originalScope;
        this->_hasReturned = false;
        auto r = this->_returnValue;
        this->_returnValue = nullptr;
        return r;
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateIndexExpression(const BoundExpression *expression) {
        auto indexExpression = (BoundIndexExpression *) expression;
        auto index = this->EvaluateExpression(indexExpression->GetIndexExpression());
        auto indexable = this->EvaluateExpression(indexExpression->GetIndexableExpression());
        return indexable->IndexValue(index.get())->Clone();
    }

    const shared_ptr<EvalValue> Evaluator::EvaluatePeriodIndexExpression(const BoundExpression *expression) {
        auto indexExpression = (BoundPeriodIndexExpression *) expression;
        auto index = indexExpression->GetIndex().GetHash();
        auto indexable = this->EvaluateExpression(indexExpression->GetIndexableExpression());
        return indexable->IndexValue(index)->Clone();
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateNumericTableExpression(const BoundExpression *expression) {
        auto tableExpression = (BoundNumericalTableExpression *) expression;
        auto valueExpressions = tableExpression->GetExpressions();
        auto values = new unordered_map<uint32_t, shared_ptr<EvalValue>>(valueExpressions->size());
        for (int i = 0; i < valueExpressions->size(); i++) {
            auto val = this->EvaluateExpression(valueExpressions->at(i));
            values->insert({i + 1, val});
        }
        auto valuesPointer = shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>>(values);
        return make_shared<TableEvalValue>(valuesPointer);
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateComplexTableExpression(const BoundExpression *expression) {
        auto tableExpression = (BoundTableExpression *) expression;
        auto type = dynamic_pointer_cast<TableScriptType>(tableExpression->GetType());
        auto declaredVars = type->GetValues();
        auto variables = make_shared<unordered_map<uint32_t, shared_ptr<EvalValue>>>(declaredVars->size());
        for (auto i : *declaredVars) {
            variables->insert({i.first, nullptr});
        }
        auto evaluator = make_shared<EvaluationScope>(variables.get(), type->GetLocalVariableCount());
        auto currentEvaluator = this->_evaluationScope;
        this->_evaluationScope = evaluator;
        this->EvaluateBlockStatement(tableExpression->GetBlock());
        this->_evaluationScope = currentEvaluator;
        return make_shared<TableEvalValue>(variables);
    }

    const shared_ptr<EvalValue> Evaluator::EvaluateUserDataExpression(const BoundExpression *expression) {
        switch (expression->GetKind()) {
            case BoundExpressionKind::Variable:
                return this->GetVariable((BoundVariableExpression *) expression);
            case BoundExpressionKind::Index:
                return this->EvaluateIndexExpression(expression);
            default:
                throw;
        }
    }
}