✨

plthy_impl/ast_nodes.py

@@ -16,10 +16,16 @@ class Exp(BaseBox):
     def eval(self, vtable, ftable):
         return vtable, ftable, None
 
-class ExpNumeral(Exp):
+    def __repr__(self) -> str:
+        return "exp()"
+
+class ExpInt(Exp):
     def __init__(self, value: int):
         self.value = value
 
+    def __repr__(self) -> str:
+        return f"exp_int({self.value})"
+
     def eval(self, vtable, ftable):
         return vtable, ftable, self.value
 
@@ -27,6 +33,9 @@ class ExpString(Exp):
     def __init__(self, value: str):
         self.value = value
 
+    def __repr__(self) -> str:
+        return f"exp_string({self.value})"
+
     def eval(self, vtable, ftable):
         return vtable, ftable, self.value
 
@@ -34,6 +43,9 @@ class ExpVariable(Exp):
     def __init__(self, variable_id: str):
         self.variable_name = variable_id
 
+    def __repr__(self) -> str:
+        return f"exp_variable({self.variable_name})"
+
     def eval(self, vtable, ftable):
         return vtable, ftable, vtable[self.variable_name]
 
@@ -43,34 +55,81 @@ class ExpABinop(Exp):
         self.exp1 = exp1
         self.exp2 = exp2
 
+    def __repr__(self) -> str:
+        return f"exp_a_binop({self.op}, {self.exp1}, {self.exp2})"
+
     def eval(self, vtable, ftable):
+        vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
+        if isinstance(r1,str):
+            if r1.isdigit():
+                r1 = int(r1)
+            else:
+                r1 = float(r1)
+        vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
+        if isinstance(r2,str):
+            if r2.isdigit():
+                r2 = int(r2)
+            else:
+                r2 = float(r2)
         if self.op == "+":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1+r2
         elif self.op == "-":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1-r2
         elif self.op == "*":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1*r2
         elif self.op == "/":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1/r2
         elif self.op == "=":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1 == r2
+        elif self.op == ">":
+            return vtable, ftable, r1 > r2
+        elif self.op == "<":
+            return vtable, ftable, r1 < r2
         else:
-            raise Exception(f"Binop {self.op} not implemented")
+            print(f"E007: Unknown binop {self.op}")
+            exit()
+
+class ExpList(Exp):
+    def __init__(self, expressions: list[Exp]):
+        self.list = expressions
+
+    def __repr__(self) -> str:
+        return f"exp_list([{rep_join(self.list)}])"
+
+    def eval(self, vtable, ftable):
+        results = []
+        for element in self.list:
+            vtable, ftable, result = element.eval(vtable, ftable)
+            results.append(result)
+
+        return vtable, ftable, results
+
+class ExpIndex(Exp):
+    def __init__(self, items: ExpList, index: Exp):
+        self.list = items
+        self.index = index
+
+    def __repr__(self) -> str:
+        return f"exp_index({self.list}, {self.index})"
+
+    def eval(self, vtable, ftable):
+        vtable, ftable, elements = self.list.eval(vtable, ftable)
+        vtable, ftable, index = self.index.eval(vtable, ftable)
+
+        if len(elements) > index:
+            result = elements[index]
+        else:
+            result = None
+
+        return vtable, ftable, result
 
 class ExpArg(Exp):
     def __init__(self, arg: int):
         self.arg = arg
 
+    def __repr__(self) -> str:
+        return f"exp_arg({self.arg})"
+
     def eval(self, vtable, ftable):
         n = vtable["#ARGS"] - self.arg
 
@@ -80,11 +139,17 @@ class Command(BaseBox):
     def eval(self, vtable, ftable):
         return vtable, ftable, None
 
+    def __repr__(self) -> str:
+        return f"command()"
+
 class Builtin(Command):
     def __init__(self, builtin: str, args: list[Exp]):
         self.builtin = builtin
         self.args = args
 
+    def __repr__(self) -> str:
+        return f"builtin({self.builtin}, {self.args})"
+
     def eval(self, vtable, ftable):
         if self.builtin == "print":
             prints = []
@@ -94,14 +159,41 @@ class Builtin(Command):
 
             print("   ".join(prints))
 
-            return vtable, ftable, None
+            return vtable, ftable, "   ".join(prints)
+        elif self.builtin == "input":
+            if not self.args == []:
+                prints = []
+                for arg in self.args:
+                    vtable, ftable, result = arg.eval(vtable, ftable)
+                    prints.append(str(result))
+
+                print("   ".join(prints), end="")
+            else:
+                print("> ", end="")
+
+            result = input()
+            return vtable, ftable, result
+        elif self.builtin == "random":
+            if not len(self.args) == 2:
+                print(f"E006: Wrong number of arguments for builtin '{self.builtin}' ({len(self.args)})")
+                exit()
+
+            vtable, ftable, r1 = self.args[0].eval(vtable, ftable)
+            vtable, ftable, r2 = self.args[1].eval(vtable, ftable)
+
+            r = random.randint(r1, r2)
+
+            return vtable, ftable, r
         else:
-            raise Exception(f"Unknown builtin {self.builtin}")
+            raise Exception(f"E005: Unknown builtin {self.builtin}")
 
 class Do(BaseBox):
     def __init__(self, command: Command):
         self.command = command
 
+    def __repr__(self) -> str:
+        return f"do({self.command})"
+
     def eval(self, vtable, ftable):
         return self.command.eval(vtable, ftable)
 
@@ -109,17 +201,23 @@ class Statement(BaseBox):
     def eval(self, vtable, ftable):
         return vtable, ftable, None
 
+    def __repr__(self) -> str:
+        return f"statement()"
+
 class StatementSet(Statement):
     def __init__(self, expression: Exp, variable: str):
         self.expression = expression
         self.variable_name = variable
 
+    def __repr__(self) -> str:
+        return f"set({self.expression}, {self.variable_name})"
+
     def eval(self, vtable, ftable):
         vtable, ftable, result = self.expression.eval(
             vtable, ftable
         )
         vtable[self.variable_name] = result
-        return vtable, ftable, None
+        return vtable, ftable, result
 
 class StatementDefine(Statement):
     def __init__(self, function_name : str, parameters: int, statement: Statement):
@@ -127,14 +225,20 @@ class StatementDefine(Statement):
         self.statement = statement
         self.parameters = parameters
 
+    def __repr__(self) -> str:
+        return f"define({self.function_name}, {self.statement}, {self.parameters})"
+
     def eval(self, vtable, ftable):
         ftable[self.function_name] = (self.parameters, self.statement)
-        return vtable, ftable, None
+        return vtable, ftable, (self.parameters, self.statement)
 
 class StatementReturn(Statement):
     def __init__(self, expression: Exp):
         self.value = expression
 
+    def __repr__(self) -> str:
+        return f"return({self.value})"
+
     def eval(self, vtable, ftable):
         vtable, ftable, result = self.value.eval(vtable, ftable)
         vtable["#return"] = result
@@ -144,6 +248,9 @@ class Scope(Statement):
     def __init__(self, statements: list[Statement]):
         self.statements = statements
 
+    def __repr__(self) -> str:
+        return f"scope([{rep_join(self.statements)}])"
+
     def eval(self, vtable, ftable):
         result = None
         for statement in self.statements:
@@ -160,6 +267,9 @@ class Call(Statement):
         self.function_name = function_name
         self.arguments = arguments
 
+    def __repr__(self) -> str:
+        return f"call({self.function_name}, {self.arguments})"
+
     def eval(self, vtable, ftable):
         assert len(self.arguments) == ftable[self.function_name][0]
 
@@ -189,29 +299,61 @@ class StatementIf(Statement):
         self.statement = statement
         self.condition = condition
 
+    def __repr__(self) -> str:
+        return f"if({self.statement}, {self.condition})"
+
     def eval(self, vtable, ftable):
         vtable, ftable, result = self.condition.eval(vtable, ftable)
         if result:
             return self.statement.eval(vtable, ftable)
         else:
-            return vtable, ftable, None
+            return vtable, ftable, result
+
+class StatementUntil(Statement):
+    def __init__(self, statement: Statement, condition):
+        self.statement = statement
+        self.condition = condition
+
+    def __repr__(self) -> str:
+        return f"until({self.statement}, {self.condition})"
+
+    def eval(self, vtable, ftable):
+        while True:
+            vtable, ftable, result = self.condition.eval(vtable, ftable)
+            if not result:
+                vtable, ftable, _ = self.statement.eval(vtable, ftable)
+                if "#return" in vtable:
+                    result = vtable["#return"]
+                    del vtable["#return"]
+                    return vtable, ftable, result
+            else:
+                return vtable, ftable, result
 
 class Maybe(BaseBox):
     def __init__(self, statement : Statement):
         self.statement = statement
 
+    def __repr__(self) -> str:
+        return f"maybe({self.statement})"
+
     def eval(self, vtable, ftable):
         if random.randint(0,1) == 1:
             return self.statement.eval(vtable,ftable)
         else:
-            return vtable, ftable, None
+            return vtable, ftable, False
 
 class Program(BaseBox):
     def __init__(self, statements: list[Statement]) -> None:
         self.statements = statements
+        random.seed(str(self))
+        r = random.randint(1,20)
+        if r == 1:
+            print("E004: Random compiler error")
+            exit()
+        random.seed()
 
     def __repr__(self) -> str:
-        statements_string = f"statements([{rep_join(self.statements)}])"
+        statements_string = f"program([{rep_join(self.statements)}])"
         return statements_string
 
     def eval(self, *_):