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;

EvalValue* Evaluator::Evaluate(const BoundScriptStatement *statement) {
    this->_evaluationScope = make_shared<EvaluationScope>(this->_scriptData->_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 ::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::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;
        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);
        }
    }
}

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

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

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 ::LiteralString:
        case BoundExpressionKind ::LiteralBool:
        case BoundExpressionKind ::Bad:
        case BoundExpressionKind::NumericalTable:
        case BoundExpressionKind::Table:
            throw;
    }
}

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::Bad:
        case BoundExpressionKind::LiteralInteger:
        case BoundExpressionKind::LiteralFloat:
        case BoundExpressionKind::LiteralString:
        case BoundExpressionKind::NumericalTable:
        case BoundExpressionKind::Table:
            throw;

    }
}

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::Bad:
        case BoundExpressionKind::LiteralInteger:
        case BoundExpressionKind::LiteralFloat:
        case BoundExpressionKind::LiteralBool:
        case BoundExpressionKind::Unary:
        case BoundExpressionKind::NumericalTable:
        case BoundExpressionKind::Table:
            throw;

    }
}

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




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

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

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

shared_ptr<EvalValue> Evaluator::EvaluateNumericTableExpression(const BoundExpression *expression) {
    auto tableExpression = (BoundNumericalTableExpression*)expression;
    auto valueExpressions = tableExpression->GetExpressions();
    auto values = new unordered_map<size_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<size_t, shared_ptr<EvalValue>>>(values);
    return make_shared<TableEvalValue>(valuesPointer);
}

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