Refactoring operators to include priority

spf.py

@@ -52,72 +52,136 @@ class SPFInterpreter(lark.visitors.Interpreter):
         value = self.visit_children(el.children[2])[0]
         self.variables.assign(name, value)
 
-    def equal(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left == right
-
-    def unequal(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left != right
-
-    def and_op(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left and right
-
-    def or_op(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left or right
-
-    def not_op(self, el):
-        (sign, right) = self.visit_children(el)
-        return not right
-
-    def lt(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left < right
-
-    def le(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left <= right
-
-    def gt(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left > right
-
-    def ge(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left >= right
-
-
-    def plus(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left + right # Cool ça fonctionne pour les str
-
-    def minus(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left - right
-
-    def time(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left * right
-
-    def divide(self, el):
-        (left, sign, right) = self.visit_children(el)
-        return left / right
-
-    neg = lambda self, el:-self.visit_children(el)[1]
-
-    sizeof = lambda self, el:len(self.visit_children(el)[1])
-
-    def list_get(self, el):
-        (left, right) = self.visit_children(el)
-        return left[right-1]
-
+    # def and_op(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left and right
+    #
+    # def or_op(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left or right
+    #
+    #
+    # def equal(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left == right
+    #
+    # def unequal(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left != right
+    #
+    # def lt(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left < right
+    #
+    # def le(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left <= right
+    #
+    # def gt(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left > right
+    #
+    # def ge(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left >= right
+    #
+    #
+    # def plus(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left + right # Cool ça fonctionne pour les str
+    #
+    # def minus(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left - right
+    #
+    # def time(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left * right
+    #
+    # def divide(self, el):
+    #     (left, sign, right) = self.visit_children(el)
+    #     return left / right
+    #
+    # sizeof = lambda self, el:len(self.visit_children(el)[1])
+    # neg = lambda self, el:-self.visit_children(el)[1]
+    #
+    # def not_op(self, el):
+    #     (sign, right) = self.visit_children(el)
+    #     return not right
+    #
+    #
+    # def list_get(self, el):
+    #     (left, right) = self.visit_children(el)
+    #     return left[right-1]
 
     def expression(self, el):
         return self.visit_children(el)[0]
 
-    def expressionleft(self, el):
+    def logical(self, el):
+        result = self.visit_children(el)
+        if len(result) < 2:
+            return result[0]
+        if result[1][0].type == "AND_OP":
+            return result[0] and result[1][1]
+        elif result[1][0].type == "OR_OP":
+            return result[0] or result[1][1]
+        assert "Unreachable"
+
+    def comparison(self, el):
+        result = self.visit_children(el)
+        if len(result) < 2:
+            return result[0]
+        if result[1][0].type == "SAME_OP":
+            return result[0] == result[1][1]
+        elif result[1][0].type == "DIFF_OP":
+            return result[0] != result[1][1]
+        elif result[1][0].type == "LT_OP":
+            return result[0] < result[1][1]
+        elif result[1][0].type == "LE_OP":
+            return result[0] <= result[1][1]
+        elif result[1][0].type == "GT_OP":
+            return result[0] > result[1][1]
+        elif result[1][0].type == "GE_OP":
+            return result[0] >= result[1][1]
+        assert "Unreachable"
+
+    def sumterm(self, el):
+        result = self.visit_children(el)
+        if len(result) < 2:
+            return result[0]
+        if result[1][0].type == "PLUS_OP":
+            return result[0] + result[1][1]
+        elif result[1][0].type == "MINUS_OP":
+            return result[0] - result[1][1]
+        assert "Unreachable"
+
+    def multterm(self, el):
+        result = self.visit_children(el)
+        if len(result) < 2:
+            return result[0]
+        if result[1][0].type == "TIMES_OP":
+            return result[0] * result[1][1]
+        elif result[1][0].type == "DIVIDE_OP":
+            return result[0] / result[1][1]
+        assert "Unreachable"
+
+    def priority(self, el):
+        result = self.visit_children(el)
+        print(result)
+        if len(result) < 2:
+            return result[0]
+        elif result[0].type == "SIZE_OP":
+            return len(result[1])
+        elif result[0].type == "NEG_OP":
+            return -result[1]
+        elif result[0].type == "NOT_OP":
+            return not result[1]
+
+    def list_get(self, el):
+        result = self.visit_children(el)
+        return result[0][result[1] - 1] # Index start at 1 (like lua)
+
+    def finalterm(self, el):
         return self.visit_children(el)[0]
 
     def variable(self, el):