Add non static evaluation for simple expressions

src/Parser/Parsing/Impl/DefinesStreamProxy.cpp

@@ -327,7 +327,7 @@ bool DefinesStreamProxy::MatchIfDirective(const ParserLine& line, const unsigned
     if (!expression)
         throw ParsingException(CreatePos(line, currentPos), "Failed to parse if expression");
 
-    m_modes.push(expression->Evaluate().IsTruthy() ? BlockMode::IN_BLOCK : BlockMode::NOT_IN_BLOCK);
+    m_modes.push(expression->EvaluateStatic().IsTruthy() ? BlockMode::IN_BLOCK : BlockMode::NOT_IN_BLOCK);
 
     return true;
 }
@@ -369,7 +369,7 @@ bool DefinesStreamProxy::MatchElIfDirective(const ParserLine& line, const unsign
     if (!expression)
         throw ParsingException(CreatePos(line, currentPos), "Failed to parse elif expression");
 
-    m_modes.top() = expression->Evaluate().IsTruthy() ? BlockMode::IN_BLOCK : BlockMode::NOT_IN_BLOCK;
+    m_modes.top() = expression->EvaluateStatic().IsTruthy() ? BlockMode::IN_BLOCK : BlockMode::NOT_IN_BLOCK;
 
     return true;
 }

src/Parser/Parsing/Simple/Expression/ISimpleExpression.h

@@ -1,8 +1,24 @@
 #pragma once
 
+#include <string>
+
 #include "Utils/ClassUtils.h"
 
 class SimpleExpressionValue;
+class ISimpleExpressionScopeValues
+{
+protected:
+    ISimpleExpressionScopeValues() = default;
+public:
+    virtual ~ISimpleExpressionScopeValues() = default;
+    ISimpleExpressionScopeValues(const ISimpleExpressionScopeValues& other) = default;
+    ISimpleExpressionScopeValues(ISimpleExpressionScopeValues&& other) noexcept = default;
+    ISimpleExpressionScopeValues& operator=(const ISimpleExpressionScopeValues& other) = default;
+    ISimpleExpressionScopeValues& operator=(ISimpleExpressionScopeValues&& other) noexcept = default;
+
+    _NODISCARD virtual SimpleExpressionValue ValueByName(const std::string& name) const = 0;
+};
+
 class ISimpleExpression
 {
 protected:
@@ -16,7 +32,8 @@ public:
 
     _NODISCARD virtual bool Equals(const ISimpleExpression* other) const = 0;
     _NODISCARD virtual bool IsStatic() const = 0;
-    _NODISCARD virtual SimpleExpressionValue Evaluate() const = 0;
+    _NODISCARD virtual SimpleExpressionValue EvaluateStatic() const = 0;
+    _NODISCARD virtual SimpleExpressionValue EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const = 0;
 };
 
 // Include SimpleExpressionValue after definition to avoid "base class not defined"

src/Parser/Parsing/Simple/Expression/SimpleExpressionBinaryOperation.cpp

@@ -460,7 +460,12 @@ bool SimpleExpressionBinaryOperation::IsStatic() const
     return m_operand1->IsStatic() && m_operand2->IsStatic();
 }
 
-SimpleExpressionValue SimpleExpressionBinaryOperation::Evaluate() const
+SimpleExpressionValue SimpleExpressionBinaryOperation::EvaluateStatic() const
 {
-    return m_operation_type->m_evaluation_function(m_operand1->Evaluate(), m_operand2->Evaluate());
+    return m_operation_type->m_evaluation_function(m_operand1->EvaluateStatic(), m_operand2->EvaluateStatic());
+}
+
+SimpleExpressionValue SimpleExpressionBinaryOperation::EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const
+{
+    return m_operation_type->m_evaluation_function(m_operand1->EvaluateNonStatic(scopeValues), m_operand2->EvaluateNonStatic(scopeValues));
 }

src/Parser/Parsing/Simple/Expression/SimpleExpressionBinaryOperation.h

@@ -95,5 +95,6 @@ public:
 
     _NODISCARD bool Equals(const ISimpleExpression* other) const override;
     _NODISCARD bool IsStatic() const override;
-    _NODISCARD SimpleExpressionValue Evaluate() const override;
+    _NODISCARD SimpleExpressionValue EvaluateStatic() const override;
+    _NODISCARD SimpleExpressionValue EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const override;
 };

src/Parser/Parsing/Simple/Expression/SimpleExpressionConditionalOperator.cpp

@@ -26,7 +26,14 @@ bool SimpleExpressionConditionalOperator::IsStatic() const
     return m_condition->IsStatic() && m_true_value->IsStatic() && m_false_value->IsStatic();
 }
 
-SimpleExpressionValue SimpleExpressionConditionalOperator::Evaluate() const
+SimpleExpressionValue SimpleExpressionConditionalOperator::EvaluateStatic() const
 {
-    return m_condition->Evaluate().IsTruthy() ? m_true_value->Evaluate() : m_false_value->Evaluate();
+    return m_condition->EvaluateStatic().IsTruthy() ? m_true_value->EvaluateStatic() : m_false_value->EvaluateStatic();
+}
+
+SimpleExpressionValue SimpleExpressionConditionalOperator::EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const
+{
+    return m_condition->EvaluateNonStatic(scopeValues).IsTruthy()
+               ? m_true_value->EvaluateNonStatic(scopeValues)
+               : m_false_value->EvaluateNonStatic(scopeValues);
 }

src/Parser/Parsing/Simple/Expression/SimpleExpressionConditionalOperator.h

@@ -10,7 +10,8 @@ public:
 
     _NODISCARD bool Equals(const ISimpleExpression* other) const override;
     _NODISCARD bool IsStatic() const override;
-    _NODISCARD SimpleExpressionValue Evaluate() const override;
+    _NODISCARD SimpleExpressionValue EvaluateStatic() const override;
+    _NODISCARD SimpleExpressionValue EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const override;
 
     SimpleExpressionConditionalOperator();
     SimpleExpressionConditionalOperator(std::unique_ptr<ISimpleExpression> condition, std::unique_ptr<ISimpleExpression> trueExpression, std::unique_ptr<ISimpleExpression> falseExpression);

src/Parser/Parsing/Simple/Expression/SimpleExpressionScopeValue.cpp

@@ -0,0 +1,28 @@
+#include "SimpleExpressionScopeValue.h"
+
+SimpleExpressionScopeValue::SimpleExpressionScopeValue(std::string valueName)
+    : m_value_name(std::move(valueName))
+{
+}
+
+bool SimpleExpressionScopeValue::Equals(const ISimpleExpression* other) const
+{
+    const auto* otherScopeValue = dynamic_cast<const SimpleExpressionScopeValue*>(other);
+
+    return otherScopeValue && otherScopeValue->m_value_name == m_value_name;
+}
+
+bool SimpleExpressionScopeValue::IsStatic() const
+{
+    return false;
+}
+
+SimpleExpressionValue SimpleExpressionScopeValue::EvaluateStatic() const
+{
+    return SimpleExpressionValue(0);
+}
+
+SimpleExpressionValue SimpleExpressionScopeValue::EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const
+{
+    return scopeValues->ValueByName(m_value_name);
+}

src/Parser/Parsing/Simple/Expression/SimpleExpressionScopeValue.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+
+#include "ISimpleExpression.h"
+#include "SimpleExpressionValue.h"
+
+class SimpleExpressionScopeValue final : public ISimpleExpression
+{
+public:
+    std::string m_value_name;
+
+    explicit SimpleExpressionScopeValue(std::string valueName);
+
+    _NODISCARD bool Equals(const ISimpleExpression* other) const override;
+    _NODISCARD bool IsStatic() const override;
+    _NODISCARD SimpleExpressionValue EvaluateStatic() const override;
+    _NODISCARD SimpleExpressionValue EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const override;
+};

src/Parser/Parsing/Simple/Expression/SimpleExpressionUnaryOperation.cpp

@@ -78,7 +78,12 @@ bool SimpleExpressionUnaryOperation::IsStatic() const
     return m_operand->IsStatic();
 }
 
-SimpleExpressionValue SimpleExpressionUnaryOperation::Evaluate() const
+SimpleExpressionValue SimpleExpressionUnaryOperation::EvaluateStatic() const
 {
-    return m_operation_type->m_evaluation_function(m_operand->Evaluate());
+    return m_operation_type->m_evaluation_function(m_operand->EvaluateStatic());
+}
+
+SimpleExpressionValue SimpleExpressionUnaryOperation::EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const
+{
+    return m_operation_type->m_evaluation_function(m_operand->EvaluateNonStatic(scopeValues));
 }

src/Parser/Parsing/Simple/Expression/SimpleExpressionUnaryOperation.h

@@ -48,5 +48,6 @@ public:
 
     _NODISCARD bool Equals(const ISimpleExpression* other) const override;
     _NODISCARD bool IsStatic() const override;
-    _NODISCARD SimpleExpressionValue Evaluate() const override;
+    _NODISCARD SimpleExpressionValue EvaluateStatic() const override;
+    _NODISCARD SimpleExpressionValue EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const override;
 };

src/Parser/Parsing/Simple/Expression/SimpleExpressionValue.cpp

@@ -46,7 +46,12 @@ bool SimpleExpressionValue::IsStatic() const
     return true;
 }
 
-SimpleExpressionValue SimpleExpressionValue::Evaluate() const
+SimpleExpressionValue SimpleExpressionValue::EvaluateStatic() const
+{
+    return *this;
+}
+
+SimpleExpressionValue SimpleExpressionValue::EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const
 {
     return *this;
 }

src/Parser/Parsing/Simple/Expression/SimpleExpressionValue.h

@@ -31,6 +31,7 @@ public:
 
     _NODISCARD bool Equals(const ISimpleExpression* other) const override;
     _NODISCARD bool IsStatic() const override;
-    _NODISCARD SimpleExpressionValue Evaluate() const override;
+    _NODISCARD SimpleExpressionValue EvaluateStatic() const override;
+    _NODISCARD SimpleExpressionValue EvaluateNonStatic(ISimpleExpressionScopeValues* scopeValues) const override;
     _NODISCARD bool IsTruthy() const;
 };