Basic math interpretation & tests

Author: mdbrnowski

interpreter.py

@@ -1,93 +1,104 @@
-# from antlr4 import ParserRuleContext
 from generated.MyParser import MyParser
 from generated.MyParserVisitor import MyParserVisitor
+from utils.values import Int, Float, String
 
 
 class Interpreter(MyParserVisitor):
     def visitProgram(self, ctx: MyParser.ProgramContext):
-        print("Program")
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitScopeStatement(self, ctx: MyParser.ScopeStatementContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitSimpleStatement(self, ctx: MyParser.SimpleStatementContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitIfThenElse(self, ctx: MyParser.IfThenElseContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitIf(self, ctx: MyParser.IfContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitThen(self, ctx: MyParser.ThenContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitElse(self, ctx: MyParser.ElseContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitForLoop(self, ctx: MyParser.ForLoopContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitRange(self, ctx: MyParser.RangeContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitWhileLoop(self, ctx: MyParser.WhileLoopContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitComparison(self, ctx: MyParser.ComparisonContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitSimpleAssignment(self, ctx: MyParser.SimpleAssignmentContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitCompoundAssignment(self, ctx: MyParser.CompoundAssignmentContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitPrint(self, ctx: MyParser.PrintContext):
-        return self.visitChildren(ctx)
+        for i in range(1, len(ctx.children) - 1, 2):
+            print(self.visit(ctx.children[i]).value)
 
     def visitReturn(self, ctx: MyParser.ReturnContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitBinaryExpression(self, ctx: MyParser.BinaryExpressionContext):
-        return self.visitChildren(ctx)
+        a = self.visit(ctx.getChild(0))
+        b = self.visit(ctx.getChild(2))
+        match ctx.op.type:
+            case MyParser.PLUS:
+                return a + b
+            case MyParser.MINUS:
+                return a - b
+            case MyParser.MULTIPLY:
+                return a * b
+            case MyParser.DIVIDE:
+                return a / b
+            # todo: MAT_* operations
 
     def visitParenthesesExpression(self, ctx: MyParser.ParenthesesExpressionContext):
-        return self.visitChildren(ctx)
+        return self.visit(ctx.getChild(1))
 
     def visitTransposeExpression(self, ctx: MyParser.TransposeExpressionContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitMinusExpression(self, ctx: MyParser.MinusExpressionContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitSingleExpression(self, ctx: MyParser.SingleExpressionContext):
-        return self.visitChildren(ctx)
+        return self.visit(ctx.getChild(0))
 
     def visitSpecialMatrixFunction(self, ctx: MyParser.SpecialMatrixFunctionContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitBreak(self, ctx: MyParser.BreakContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitContinue(self, ctx: MyParser.ContinueContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitVector(self, ctx: MyParser.VectorContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitElementReference(self, ctx: MyParser.ElementReferenceContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitId(self, ctx: MyParser.IdContext):
-        return self.visitChildren(ctx)
+        return self.visitChildren(ctx)  # todo
 
     def visitInt(self, ctx: MyParser.IntContext):
-        return self.visitChildren(ctx)
+        return Int(ctx.getText())
 
     def visitFloat(self, ctx: MyParser.FloatContext):
-        return self.visitChildren(ctx)
+        return Float(ctx.getText())
 
     def visitString(self, ctx: MyParser.StringContext):
-        return self.visitChildren(ctx)
+        return String(ctx.getText())

test_main.py

@@ -63,3 +63,15 @@ def test_sem_errors(name: str, line_numbers: list[int], additional: str):
     assert result.stdout.lower().count("line") == len(line_numbers)
     if additional:
         assert result.stdout.lower().count(additional) == len(line_numbers)
+
+
+@pytest.mark.parametrize(
+    "name,output",
+    [
+        ("simple_math", [23, 35, 1, 1.0, 1]),
+    ]
+)
+def test_interpreter(name: str, output: str):
+    result = runner.invoke(app, ["run", f"tests/interpreter/{name}.txt"])
+    assert result.exit_code == 0
+    assert result.stdout.strip() == "\n".join(map(str, output))

tests/interpreter/simple_math.txt

@@ -0,0 +1,2 @@
+print 3 + 4 * 5, (3 + 4) * 5;
+print 2 / 2, 1.0 * 1.0, 2 - 1;

utils/values.py

@@ -0,0 +1,60 @@
+class Value:
+    def __init__(self, value):
+        self.value = value
+
+
+class Int(Value):
+    def __init__(self, value):
+        super().__init__(int(value))
+
+    def __add__(self, other):
+        if isinstance(other, Int):
+            return Int(self.value + other.value)
+        raise TypeError()
+
+    def __sub__(self, other):
+        if isinstance(other, Int):
+            return Int(self.value - other.value)
+        raise TypeError()
+
+    def __mul__(self, other):
+        if isinstance(other, Int):
+            return Int(self.value * other.value)
+        raise TypeError()
+
+    def __truediv__(self, other):
+        if isinstance(other, Int):
+            if self.value % other.value == 0:
+                return Int(self.value // other.value)
+            return Float(self.value / other.value)
+        raise TypeError()
+
+
+class Float(Value):
+    def __init__(self, value):
+        super().__init__(float(value))
+
+    def __add__(self, other):
+        if isinstance(other, Float):
+            return Float(self.value + other.value)
+        raise TypeError()
+
+    def __sub__(self, other):
+        if isinstance(other, Float):
+            return Float(self.value - other.value)
+        raise TypeError()
+
+    def __mul__(self, other):
+        if isinstance(other, Float):
+            return Float(self.value * other.value)
+        raise TypeError()
+
+    def __truediv__(self, other):
+        if isinstance(other, Float):
+            return Float(self.value / other.value)
+        raise TypeError()
+
+
+class String(Value):
+    def __init__(self, value):
+        super().__init__(value)