PorygonLang/src/Evaluator/BinaryEvaluation.cpp

#include "../Script.hpp"
#include "EvaluationException.hpp"
#include "Evaluator.hpp"
#include "EvalValues/NumericEvalValue.hpp"

NumericEvalValue* Evaluator::EvaluateIntegerBinary(BoundBinaryExpression *expression) {
    NumericEvalValue* leftValue = this -> EvaluateIntegerExpression(expression->GetLeft());
    NumericEvalValue* rightValue = this -> EvaluateIntegerExpression(expression->GetRight());

    NumericEvalValue* result;
    switch (expression->GetOperation()){
        case BoundBinaryOperation ::Addition:
            result = leftValue -> operator+ (rightValue);
            break;
        case BoundBinaryOperation::Subtraction:
            result = leftValue -> operator- (rightValue);
            break;
        case BoundBinaryOperation::Multiplication:
            result = leftValue -> operator* (rightValue);
            break;
        case BoundBinaryOperation::Division:
            result = leftValue -> operator/ (rightValue);
            break;
        default:
            delete leftValue;
            delete rightValue;
            throw EvaluationException("Can't evaluate operation to numeric");
    }
    delete leftValue;
    delete rightValue;
    return result;
}

BooleanEvalValue* Evaluator::EvaluateBooleanBinary(BoundBinaryExpression* expression){
    switch (expression->GetOperation()){
        case BoundBinaryOperation::Equality:
        {
            EvalValue* leftValue = this -> EvaluateExpression(expression->GetLeft());
            EvalValue* rightValue = this -> EvaluateExpression(expression->GetRight());
            bool equals = leftValue->operator==(rightValue);
            delete leftValue;
            delete rightValue;
            return new BooleanEvalValue(equals);
        }
        case BoundBinaryOperation::Inequality:
        {
            EvalValue* leftValue = this -> EvaluateExpression(expression->GetLeft());
            EvalValue* rightValue = this -> EvaluateExpression(expression->GetRight());
            bool equals = leftValue->operator!=(rightValue);
            delete leftValue;
            delete rightValue;
            return new BooleanEvalValue(equals);
        }
        case BoundBinaryOperation::LogicalAnd:
        {
            BooleanEvalValue* leftValue = this -> EvaluateBoolExpression(expression->GetLeft());
            if (!leftValue->EvaluateBool()) return leftValue;
            delete leftValue;
            BooleanEvalValue* rightValue = this -> EvaluateBoolExpression(expression->GetRight());
            return rightValue;
        }
        case BoundBinaryOperation::LogicalOr:
        {
            BooleanEvalValue* leftValue = this -> EvaluateBoolExpression(expression->GetLeft());
            if (leftValue->EvaluateBool()) return leftValue;
            delete leftValue;
            BooleanEvalValue* rightValue = this -> EvaluateBoolExpression(expression->GetRight());
            return rightValue;
        }
        default:
            throw EvaluationException("Can't evaluate operation to boolean");
    }
}