Support for object-oriented design features in Chiron Framework

ChironCore/ChironAST/ChironAST.py

@@ -12,6 +12,14 @@ class Instruction(AST):
     pass
 
 
+class PrintCommand(Instruction):
+    def __init__(self, expr):
+        self.expr = expr
+
+    def __str__(self):
+        return self.expr.__str__()
+
+
 class AssignmentCommand(Instruction):
     def __init__(self, leftvar, rexpr):
         self.lvar = leftvar
@@ -21,6 +29,20 @@ def __str__(self):
         return self.lvar.__str__() + " = " + self.rexpr.__str__()
 
 
+class ClassDeclarationCommand(Instruction):
+
+    def __init__(self, className, baseClasses, attributes, objectAttributes):
+        self.className = className  # Class name as a string
+        self.attributes = attributes  # List of AssignmentCommand objects
+        self.objectAttributes = objectAttributes
+        self.baseClasses = baseClasses
+
+    def __str__(self):
+        attr_str = "\n    ".join(str(attr) for attr in self.attributes)
+        obj_attr_str = "\n    ".join(str(attr[0]) for attr in self.objectAttributes)
+        return f"class {self.className} {{\n    {attr_str if attr_str else '    // No attributes'}\n\n    {obj_attr_str if obj_attr_str else '    // No object attributes'}\n}}"
+
+
 class ConditionCommand(Instruction):
     def __init__(self, condition):
         self.cond = condition
@@ -29,13 +51,16 @@ def __str__(self):
         return self.cond.__str__()
 
 # Not Implemented Yet.
+
+
 class AssertCommand(Instruction):
     def __init__(self, condition):
         self.cond = condition
 
     def __str__(self):
         return self.cond.__str__()
 
+
 class MoveCommand(Instruction):
     def __init__(self, motion, expr):
         self.direction = motion
@@ -52,6 +77,7 @@ def __init__(self, penstat):
     def __str__(self):
         return self.status
 
+
 class GotoCommand(Instruction):
     def __init__(self, x, y):
         self.xcor = x
@@ -60,26 +86,76 @@ def __init__(self, x, y):
     def __str__(self):
         return "goto " + str(self.xcor) + " " + str(self.ycor)
 
+
 class NoOpCommand(Instruction):
     def __init__(self):
         pass
 
     def __str__(self):
         return "NOP"
 
+
 class PauseCommand(Instruction):
     def __init__(self):
         pass
 
     def __str__(self):
         return "pause"
 
+
+class FunctionDeclarationCommand(Instruction):
+    def __init__(self, fname, params=None, body=None):
+        self.name = fname
+        self.params = params if params is not None else []
+        self.body = body if body is not None else []
+
+    def __str__(self):
+        params_str = ", ".join(self.params)
+        body_str = "\n    ".join(str(stmt) for stmt in self.body)
+        return f"def {self.name}({params_str}):\n    {body_str}"
+
+
+class FunctionCallCommand(Instruction):
+    def __init__(self, fname, arguments=None, caller = None):
+        self.name = fname
+        self.args = arguments if arguments is not None else []
+        self.caller = caller
+
+    def __str__(self):
+        args_str = ", ".join(str(arg) for arg in self.args)
+        if self.caller:
+            return f"{self.caller}.{self.name}({args_str})"
+        else:
+            return f"{self.name}({args_str})"
+
+
+class ReturnCommand(Instruction):
+    def __init__(self, returnValues):
+        self.returnValues = returnValues
+    def __str__(self):
+        return f"return {self.returnValues}"
+
+class ReadReturnCommand(Instruction):
+    def __init__(self, returnValues):
+        self.returnValues = returnValues
+    def __str__(self):
+        return f"read {self.returnValues}"
+
+
+class ParametersPassingCommand(Instruction):
+    def __init__(self, parameters):
+        self.params = parameters
+
+    def __str__(self):
+        return ", ".join(str(param) for param in self.params)
+
+
 class Expression(AST):
     pass
 
-
 # --Arithmetic Expressions--------------------------------------------
 
+
 class ArithExpr(Expression):
     pass
 
@@ -122,6 +198,7 @@ class Mult(BinArithOp):
     def __init__(self, lexpr, rexpr):
         super().__init__(lexpr, rexpr, "*")
 
+
 class Div(BinArithOp):
     def __init__(self, lexpr, rexpr):
         super().__init__(lexpr, rexpr, "/")
@@ -147,6 +224,7 @@ class AND(BinCondOp):
     def __init__(self, expr1, expr2):
         super().__init__(expr1, expr2, "and")
 
+
 class OR(BinCondOp):
     def __init__(self, expr1, expr2):
         super().__init__(expr1, expr2, "or")
@@ -226,10 +304,73 @@ def __init__(self, v):
     def __str__(self):
         return str(self.val)
 
+class Real(Value):
+    def __init__(self, v):
+        self.val = float(v)
+
+    def __str__(self):
+        return str(self.val)
+
 
 class Var(Value):
     def __init__(self, vname):
         self.varname = vname
 
     def __str__(self):
         return self.varname
+
+
+class Array(Value):
+    def __init__(self, vname):
+        self.arr = vname
+
+    def __str__(self):
+        return self.arr
+
+# class ArrayAccess(Value):
+#     def __init__(self, var, index):
+#         self.var = var
+#         self.idx = index
+
+#     def __str__(self):
+#         indices_str = "".join(f"[{idx}]" for idx in self.idx)  # Format multiple indices
+#         return f"{self.var}{indices_str}"
+#     #     return self.var.__str__() + "[" + self.idx.__str__() + "]"
+
+
+class DataLocationAccess(Value):
+    def __init__(self, var, access_chain):
+        self.var = var
+        self.access_chain = access_chain  # List of attribute names or indices
+
+    def __str__(self):
+        result = str(self.var)
+        for access in self.access_chain:
+            if isinstance(access, list):  # Array indexing
+                indices_str = "".join(f"[{idx}]" for idx in access)
+                result += indices_str
+            else:  # Object attribute access
+                result += f".{access}"
+        return result
+
+class MethodCaller:
+    def __init__(self, access_chain):
+        self.access_chain = access_chain
+
+    def __str__(self):
+        result = ""
+        for access in self.access_chain:
+            if isinstance(access, list):  # Array indexing
+                indices_str = "".join(f"[{idx}]" for idx in access)
+                result += indices_str
+            else:  # Object attribute access
+                result += f".{access}"
+        return result[1:]
+
+class ObjectInstantiationCommand(Instruction):
+    def __init__(self, target, class_name):
+        self.target = target  # Variable name or Object/Array Access
+        self.class_name = class_name  # The class being instantiated
+
+    def __str__(self):
+        return f"{self.target} = new {self.class_name}()"