Create evaluator for relation operators

smnp/audio/sound.py

@@ -10,6 +10,9 @@ class Sound:
     def play(self):
         sd.play(self.data, self.fs, blocking=True)
 
+    def __eq__(self, other):
+        return self.file == other.file and self.data == other.data
+
     def __str__(self):
         return f"sound[{self.file}]"
 

smnp/runtime/evaluators/expression.py

@@ -1,4 +1,4 @@
-from smnp.ast.node.expression import Sum
+from smnp.ast.node.expression import Sum, Relation
 from smnp.ast.node.factor import NotOperator, Power, Loop
 from smnp.ast.node.identifier import FunctionCall, Assignment
 from smnp.ast.node.term import Product
@@ -21,6 +21,7 @@ def expressionEvaluator(doAssert=False):
         from smnp.runtime.evaluators.product import ProductEvaluator
 
         from smnp.runtime.evaluators.sum import SumEvaluator
+        from smnp.runtime.evaluators.relation import RelationEvaluator
         result = Evaluator.oneOf(
             Evaluator.forNodes(FunctionCallEvaluator.evaluate, FunctionCall),
             Evaluator.forNodes(MinusEvaluator.evaluate, MinusOperator),
@@ -31,6 +32,7 @@ def expressionEvaluator(doAssert=False):
             Evaluator.forNodes(AssignmentEvaluator.evaluate, Assignment),
             Evaluator.forNodes(ProductEvaluator.evaluate, Product),
             Evaluator.forNodes(SumEvaluator.evaluate, Sum),
+            Evaluator.forNodes(RelationEvaluator.evaluate, Relation),
             AtomEvaluator.evaluate
         )(node, environment)
 

smnp/runtime/evaluators/relation.py

@@ -0,0 +1,46 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class RelationEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        left = expressionEvaluator(doAssert=True)(node.left, environment).value
+        right = expressionEvaluator(doAssert=True)(node.right, environment).value
+
+        if node.operator.value == "==":
+            return cls.equalOperatorEvaluator(left, node.operator, right)
+
+        if node.operator.value == "!=":
+            return cls.notEqualOperatorEvaluator(left, node.operator, right)
+
+        return cls.otherRelationOperatorsEvaluator(left, node.operator, right)
+
+    @classmethod
+    def equalOperatorEvaluator(cls, left, operator, right):
+        return Type.bool(left.value == right.value)
+
+    @classmethod
+    def notEqualOperatorEvaluator(cls, left, operator, right):
+        return Type.bool(left.value != right.value)
+
+    @classmethod
+    def otherRelationOperatorsEvaluator(cls, left, operator, right):
+        if left.type == right.type == Type.INTEGER:
+            if operator.value == ">":
+                return Type.bool(left.value > right.value)
+
+            if operator.value == ">=":
+                return Type.bool(left.value >= right.value)
+
+            if operator.value == "<":
+                return Type.bool(left.value < right.value)
+
+            if operator.value == "<=":
+                return Type.bool(left.value < right.value)
+
+        raise RuntimeException(f"Operator {operator.value} is not supported by {left.type.name.lower()} and {right.type.name.lower()} types", operator.pos)
+