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"
#include "../UserData/UserDataFunction.hpp"
#include "../Utilities/StringUtils.hpp"
#include "EvalValues/NumericalTableEvalValue.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::NumericalFor:
                return this->EvaluateNumericalForStatement((BoundNumericalForStatement*)statement);
            case BoundStatementKind::GenericFor:
                return this-> EvaluateGenericForStatement((BoundGenericForStatement*)statement);
            case BoundStatementKind::While:
                return this-> EvaluateWhileStatement((BoundWhileStatement*)statement);

            case BoundStatementKind::Break:
                this -> _hasBroken = true;
                return;
            case BoundStatementKind::Bad:
                throw;
        }
        throw EvaluationException("Evaluating this statement is not supported");
    }

    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);
            }
        }
    }

    void Evaluator::EvaluateNumericalForStatement(const BoundNumericalForStatement *statement) {
        long start = this->EvaluateIntegerExpression(statement -> GetStart()) -> EvaluateInteger();
        long end = this->EvaluateIntegerExpression(statement -> GetEnd()) -> EvaluateInteger();
        long step = 1;
        auto stepExp = statement -> GetStep();
        if (stepExp != nullptr){
            step = this -> EvaluateIntegerExpression(stepExp) -> EvaluateInteger();
        }
        auto identifier = statement -> GetIdentifier();
        this -> _evaluationScope -> CreateVariable(identifier, nullptr);
        auto block = (BoundBlockStatement*)statement -> GetBlock();
        auto statements = *block -> GetStatements();
        if (step >= 0){
            for (long i = start; i <= end; i += step){
                this -> _evaluationScope -> SetVariable(identifier, make_shared<IntegerEvalValue>(i));
                for (auto s: statements) {
                    this->EvaluateStatement(s);
                    if (this->_hasReturned || this -> _hasBroken)
                        break;
                }
                if (this->_hasReturned || this -> _hasBroken)
                    break;
            }
        } else{
            for (long i = start; i >= end; i += step){
                this -> _evaluationScope -> SetVariable(identifier, make_shared<IntegerEvalValue>(i));
                for (auto s: statements) {
                    this->EvaluateStatement(s);
                    if (this->_hasReturned || this -> _hasBroken)
                        break;
                }
                if (this->_hasReturned || this -> _hasBroken)
                    break;
            }
        }
        this -> _hasBroken = false;
    }

    void Evaluator::EvaluateGenericForStatement(const BoundGenericForStatement *statement) {
        auto iteratorVal = EvaluateExpression(statement -> GetIterator());
        auto iterator = iteratorVal -> GetKeyIterator();
        auto keyVariable = statement ->GetKeyIdentifier();
        auto valueVariable = statement ->GetValueIdentifier();

        this -> _evaluationScope -> CreateVariable(keyVariable, nullptr);
        if (valueVariable != nullptr)
            this -> _evaluationScope -> CreateVariable(valueVariable, nullptr);
        auto block = (BoundBlockStatement*)statement -> GetBlock();
        auto statements = *block -> GetStatements();
        while (iterator->MoveNext()){
            auto currentKey = iterator->GetCurrent();
            this -> _evaluationScope -> SetVariable(keyVariable, currentKey);
            if (valueVariable != nullptr){
                auto currentValue = iteratorVal -> IndexValue(currentKey.get());
                this -> _evaluationScope -> SetVariable(valueVariable, currentValue);
            }
            for (auto s: statements) {
                this->EvaluateStatement(s);
                if (this->_hasReturned || this -> _hasBroken)
                    break;
            }
            if (this->_hasReturned || this -> _hasBroken)
                break;
        }
        this -> _hasBroken = false;
        delete iterator;
    }

    void Evaluator::EvaluateWhileStatement(const BoundWhileStatement *statement) {
        auto condition = statement -> GetCondition();
        auto block = (BoundBlockStatement*)statement -> GetBlock();
        auto statements = *block -> GetStatements();
        while (this->EvaluateBoolExpression(condition)->EvaluateBool()){
            for (auto s: statements) {
                this->EvaluateStatement(s);
                if (this->_hasReturned || this -> _hasBroken)
                    break;
            }
            if (this->_hasReturned || this -> _hasBroken)
                break;
        }
        this -> _hasBroken = false;
    }

    /////////////////
    // Expressions //
    /////////////////

    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));

            default:
                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));

            default:
                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));

            default:
                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<GenericFunctionEvalValue>(
                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<GenericFunctionScriptType>(function->GetType());
        if (type -> IsScriptFunction()){
            auto parameterTypes = type->GetParameterTypes();
            auto scriptFunctionType = std::dynamic_pointer_cast<FunctionScriptType>(type);
            auto parameterKeys = scriptFunctionType->GetParameterKeys();
            auto originalScope = this->_evaluationScope;
            auto scriptFunction = dynamic_pointer_cast<ScriptFunctionEvalValue>(function);
            this->_evaluationScope = scriptFunction->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(scriptFunction->GetInnerBlock().get());
            this->_evaluationScope = originalScope;

            this->_hasReturned = false;
            auto r = this->_returnValue;
            this->_returnValue = nullptr;
            return r;
        } else{
            auto userDataFunction = dynamic_pointer_cast<UserData::UserDataFunction>(function);
            EvalValue* arr[parameters.size()];
            for (int i = 0; i < parameters.size(); i++){
                arr[i] = parameters[i].get();
            }
            return shared_ptr<EvalValue>(userDataFunction -> Call(arr, parameters.size()));
        }
    }

    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 vector<shared_ptr<EvalValue>>(valueExpressions->size());
        for (int i = 0; i < valueExpressions->size(); i++) {
            auto val = this->EvaluateExpression(valueExpressions->at(i));
            values->at(i) = val;
        }
        auto valuesPointer = shared_ptr<vector<shared_ptr<EvalValue>>>(values);
        return make_shared<NumericalTableEvalValue>(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<map<Utilities::HashedString, shared_ptr<EvalValue>>>();
        for (const 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;
        }
    }
}