✨

ast_nodes.py

@@ -0,0 +1,181 @@
+from rply.token import BaseBox
+
+def rep_join(l):
+    format_string = ',\n'.join(
+        [repr(i) if not isinstance(i, str) else i for i in l]
+    ).replace('\n', '\n  ')
+
+    if format_string != "":
+        format_string = f"\n  {format_string}\n"
+
+    return format_string
+
+class ExpressionStatement(BaseBox):
+    def __init__(self, expression) -> None:
+        self.expression = expression
+
+    def __repr__(self) -> str:
+        return self.expression.__repr__()
+
+    def eval(self, vtable, ftable, modules):
+        self.expression.eval(vtable, ftable, modules)
+        return vtable, ftable
+
+class String(BaseBox):
+    def __init__(self, value) -> None:
+        self.value = value
+
+    def __repr__(self):
+        return f"String({self.value})"
+
+class Numeral(BaseBox):
+    def __init__(self, value) -> None:
+        self.value = value
+
+    def __repr__(self):
+        return f"Numeral({self.value})"
+
+class Bool(BaseBox):
+    def __init__(self, value) -> None:
+        self.value = value
+
+    def __repr__(self):
+        return f"Bool({self.value})"
+
+class ModuleCall(BaseBox):
+    def __init__(self, module_name) -> None:
+        self.module_name = module_name
+
+    def __repr__(self) -> str:
+        return f"{self.module_name}"
+
+class ID(BaseBox):
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __repr__(self) -> str:
+        return f"ID({self.name})"
+
+class Designa(BaseBox):
+    def __init__(self, variable: ID, value) -> None:
+        self.id = variable
+        self.value = value
+
+    def __repr__(self) -> str:
+        id_string = repr(self.id).replace('\n', '\n  ')
+        value_string = repr(self.value).replace('\n', '\n  ')
+        return f"Designa(\n  {id_string},\n  {value_string}\n)"
+
+    def eval(self, vtable, ftable, modules):
+        vtable[self.id.name] = self.value.eval(vtable, ftable, modules)
+        return vtable, ftable
+
+class Defini(BaseBox):
+    def __init__(self, name, parameters, statements) -> None:
+        self.name = name
+        self.parameters = parameters
+        self.statements = statements
+
+    def __repr__(self) -> str:
+        parameter_string = f"parameters([{rep_join(self.parameters)}])"
+        statements_string = f"statements([{rep_join(self.statements)}])"
+        def_string = rep_join(
+            [f"{repr(self.name)}", parameter_string, statements_string]
+        )
+        return f"Defini({def_string})"
+
+class Redi(BaseBox):
+    def __init__(self, values) -> None:
+        self.values = values
+
+    def __repr__(self) -> str:
+        values_string = f"[{rep_join(self.values)}]"
+        return f"Redi({values_string})"
+
+class Nullus(BaseBox):
+    def __repr__(self) -> str:
+        return "Nullus()"
+
+    def eval(self, *_):
+        return 0
+
+class BinOp(BaseBox):
+    def __init__(self, left, right, op) -> None:
+        self.left = left
+        self.right = right
+        self.op = op
+
+    def __repr__(self) -> str:
+        binop_string = rep_join([self.left, self.right, self.op])
+        return f"BinOp({binop_string})"
+
+class SiStatement(BaseBox):
+    def __init__(self, test, statements, else_part) -> None:
+        self.test = test
+        self.statements = statements
+        self.else_part = else_part
+
+    def __repr__(self) -> str:
+        test = repr(self.test)
+        statements = f"statements([{rep_join(self.statements)}])"
+        else_part = f"statements([{rep_join(self.else_part)}])"
+        si_string = rep_join([test, statements, else_part])
+        return f"Si({si_string})"
+
+class DumStatement(BaseBox):
+    def __init__(self, test, statements) -> None:
+        self.test = test
+        self.statements = statements
+
+    def __repr__(self) -> str:
+        test = repr(self.test)
+        statements = f"statements([{rep_join(self.statements)}])"
+        dum_string = rep_join([test, statements])
+        return f"Dum({dum_string})"
+
+    def eval(self, vtable, ftable, modules):
+        while not self.test.eval(vtable, ftable, modules):
+            pass
+
+        return vtable, ftable
+
+class Invoca(BaseBox):
+    def __init__(self, name, parameters) -> None:
+        self.name = name
+        self.parameters = parameters
+
+    def __repr__(self) -> str:
+        parameters_string = f"parameters([{rep_join(self.parameters)}])"
+        invoca_string = rep_join([self.name, parameters_string])
+        return f"Invoca({invoca_string})"
+
+class BuiltIn(BaseBox):
+    def __init__(self, builtin, parameters) -> None:
+        self.builtin = builtin
+        self.parameters = parameters
+
+    def __repr__(self) -> str:
+        parameter_string = f"parameters([{rep_join(self.parameters)}])"
+        builtin_string = rep_join([self.builtin, parameter_string])
+        return f"Builtin({builtin_string})"
+
+    def eval(self, vtable, ftable, _):
+        return None
+
+class Program(BaseBox):
+    def __init__(self, module_calls: list[ModuleCall], statements) -> None:
+        self.modules = module_calls
+        self.statements = statements
+
+    def __repr__(self) -> str:
+        modules_string = f"modules([{rep_join(self.modules)}])"
+        statements_string = f"statements([{rep_join(self.statements)}])"
+        return f"{modules_string},\n{statements_string}"
+
+    def eval(self):
+        vtable = {}
+        ftable = {}
+        modules = [module.module_name for module in self.modules]
+
+        for statement in self.statements:
+            vtable, ftable = statement.eval(vtable, ftable, modules)