First Results

doc/Readme.md

@@ -4,9 +4,8 @@
 
 **Nombre** | **Grupo** | **Github**
 --|--|--
-Nombre1 Apellido1 Apellido2 | C4xx | [@github_user](https://github.com/<user>)
-Nombre2 Apellido1 Apellido2 | C4xx | [@github_user](https://github.com/<user>)
-Nombre3 Apellido1 Apellido2 | C4xx | [@github_user](https://github.com/<user>)
+Juan David Menendez del Cueto | C412 | [@juandamdc](https://github.com/juandamdc)
+Karl Lewis Sosa Justiz        | C412 | [@BlackBeard98](https://github.com/BlackBeard98)
 
 ## Readme
 

requirements.txt

@@ -1,2 +1,3 @@
 pytest
 pytest-ordering
+ply

src/AstNodes.py

@@ -0,0 +1,169 @@
+# AST Classes
+class Node:
+    pass
+
+class ProgramNode(Node):
+    def __init__(self, declarations):
+        self.declarations = declarations
+        self.line = declarations[0].line
+        self.column = declarations[0].column
+
+class DeclarationNode(Node):
+    pass
+
+class ClassDeclarationNode(DeclarationNode):
+    def __init__(self, idx, features, parent=None):
+        self.id = idx
+        self.parent = parent
+        self.features = features
+        self.line = 0
+        self.column = 0
+
+class AttrDeclarationNode(DeclarationNode):
+    def __init__(self, idx, typex, expression=None):
+        self.id = idx
+        self.type = typex
+        self.expression = expression
+        self.line = 0
+        self.column = 0
+
+class FuncDeclarationNode(DeclarationNode):
+    def __init__(self, idx, params, return_type, body):
+        self.id = idx
+        self.params = params
+        self.type = return_type
+        self.body = body
+        self.line = 0
+        self.column = 0
+
+class ExpressionNode(Node):
+    pass
+
+class IfThenElseNode(ExpressionNode):
+    def __init__(self, condition, if_body, else_body):
+        self.condition = condition
+        self.if_body = if_body
+        self.else_body = else_body
+        self.line = condition.line
+        self.column = condition.column
+
+class WhileLoopNode(ExpressionNode):
+    def __init__(self, condition, body):
+        self.condition = condition
+        self.body = body
+        self.line = condition.line
+        self.column = condition.column
+
+
+class BlockNode(ExpressionNode):
+    def __init__(self, expressions):
+        self.expressions = expressions
+        self.line = expressions[-1].line
+        self.column = expressions[-1].column
+
+class LetInNode(ExpressionNode):
+    def __init__(self, let_body, in_body):
+        self.let_body = let_body
+        self.in_body = in_body
+        self.line = in_body.line
+        self.column = in_body.column
+
+class CaseOfNode(ExpressionNode):
+    def __init__(self, expression, branches):
+        self.expression = expression
+        self.branches = branches
+        self.line = expression.line
+        self.column = expression.column
+
+class AssignNode(ExpressionNode):
+    def __init__(self, idx, expression):
+        self.id = idx
+        self.expression = expression
+        self.line = 0
+        self.column = 0
+
+class UnaryNode(ExpressionNode):
+    def __init__(self, expression):
+        self.expression = expression
+        self.line = expression.line
+        self.column = expression.column
+
+class NotNode(UnaryNode):
+    pass
+
+class BinaryNode(ExpressionNode):
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+        self.line = left.line
+        self.column = left.column
+
+class LessEqualNode(BinaryNode):
+    pass
+
+class LessNode(BinaryNode):
+    pass
+
+class EqualNode(BinaryNode):
+    pass
+
+class ArithmeticNode(BinaryNode):
+    pass
+
+class PlusNode(ArithmeticNode):
+    pass
+
+class MinusNode(ArithmeticNode):
+    pass
+
+class StarNode(ArithmeticNode):
+    pass
+
+class DivNode(ArithmeticNode):
+    pass
+
+class IsVoidNode(UnaryNode):
+    pass
+
+class ComplementNode(UnaryNode):
+    pass
+
+class FunctionCallNode(ExpressionNode):
+    def __init__(self, obj, line, idx, args, typex=None):
+        self.obj = obj
+        self.id = idx
+        self.args = args
+        self.typex = typex
+        self.line = line
+        self.column = 0
+
+class MemberCallNode(ExpressionNode):
+    def __init__(self, idx, args):
+        self.id = idx
+        self.args = args
+        self.line = 0
+        self.column = 0
+
+class NewNode(ExpressionNode):
+    def __init__(self, typex):
+        self.type = typex
+        self.line = 0
+        self.column = 0
+
+class AtomicNode(ExpressionNode):
+    def __init__(self, token):
+        self.token = token
+        self.line = 0
+        self.column = 0
+
+class IntegerNode(AtomicNode):
+    pass
+
+class IdNode(AtomicNode):
+    pass
+
+class StringNode(AtomicNode):
+    pass
+
+class BoolNode(AtomicNode):
+    pass

src/BaseToCILVisitor.py

@@ -0,0 +1,156 @@
+import cil
+from semantic import VariableInfo, Scope
+import queue
+
+class BaseCOOLToCILVisitor:
+    def __init__(self, context):
+        self.dottypes = []
+        self.dotdata = [ cil.DataNode('_empty', '')]
+        self.dotcode = []
+        self.current_type = None
+        self.current_method = None
+        self.current_function = None
+        self.context = context
+        self.basic_types()
+
+    @property
+    def params(self):
+        return self.current_function.params
+
+    @property
+    def localvars(self):
+        return self.current_function.localvars
+
+    @property
+    def instructions(self):
+        return self.current_function.instructions
+
+    @property
+    def labels(self):
+        return self.current_function.labels
+
+    def basic_types(self):
+        for basicType in ['Int', 'String', 'Bool']:
+            cil_type = self.register_type(basicType)
+            cil_type.attributes.append(self.to_attribute_name('value', basicType))
+
+            for method , typeMethod in self.context.get_type(basicType).all_methods():
+                cil_type.methods.append((method.name, self.to_function_name(method.name, typeMethod.name)))
+
+        for basicType in ['Object', 'IO']:
+            cil_type = self.register_type(basicType)
+            for method , typeMethod in self.context.get_type(basicType).all_methods():
+                cil_type.methods.append((method.name, self.to_function_name(method.name, typeMethod.name)))
+
+
+    def register_param(self, vinfo):
+        vinfo.cilName = vinfo.name # f'param_{self.current_function.name[9:]}_{vinfo.name}_{len(self.params)}'
+        param_node = cil.ParamNode(vinfo.cilName)
+        self.params.append(param_node)
+        return vinfo.cilName
+
+    def register_local(self, vinfo):
+        vinfo.cilName = f'local_{self.current_function.name[9:]}_{vinfo.name}_{len(self.localvars)}'
+        local_node = cil.LocalNode(vinfo.cilName)
+        self.localvars.append(local_node)
+        return vinfo.cilName
+
+    def register_label(self):
+        name = f'label_{self.current_function.name[9:]}_{len(self.labels)}'
+        self.labels.append(name)
+        return name
+
+    def define_internal_local(self):
+        vinfo = VariableInfo('internal', None)
+        return self.register_local(vinfo)
+
+    def register_instruction(self, instruction):
+        self.instructions.append(instruction)
+        return instruction
+
+    def to_function_name(self, method_name, type_name):
+        return f'function_{method_name}_at_{type_name}'
+
+    def to_attribute_name(self, attr_name, attr_type):
+        return f'attribute_{attr_name}'
+
+    def register_function(self, function_name):
+        function_node = cil.FunctionNode(function_name, [], [], [], [])
+        self.dotcode.append(function_node)
+        return function_node
+
+    def register_type(self, name):
+        type_node = cil.TypeNode(name)
+        self.dottypes.append(type_node)
+        return type_node
+
+    def register_data(self, value):
+        for dataNode in self.dotdata:
+            if dataNode.value == value:
+                return dataNode
+
+        vname = f'data_{len(self.dotdata)}'
+        data_node = cil.DataNode(vname, value)
+        self.dotdata.append(data_node)
+        return data_node
+
+
+    def get_attr(self, function_name, attribute):
+        for dottype in self.dottypes:
+            if dottype.name == function_name:
+                break
+
+
+        # for attrib in dottype.attributes:
+        #     if self.to_attribute_name(attribute, None) == attrib:
+        #         break
+
+        return dottype.attributes.index(self.to_attribute_name(attribute,None))
+
+    def get_method(self, type_name, method_name):
+        for typeContext in self.context.types:
+            if typeContext == type_name:
+                break
+
+        methods = list(self.context.types[typeContext].all_methods())
+
+        for m in methods:
+            if m[0].name == method_name:
+                break
+
+        return methods.index(m)
+
+    def sort_types(self, types):
+        q = queue.deque()
+        lst = []
+        for tp1 in types:
+            if not any ([x for x in types if x!= tp1 and tp1.conforms_to(x) ]):
+                q.append(tp1)
+
+        while len(q) != 0:
+            tp = q.popleft()
+            if tp in types:
+                lst.append(tp)
+            for s in tp.sons:
+                q.append(s)
+        lst = list(reversed(lst))
+        return lst   
+
+    def get_preordenTypes(self, typex):
+        ret_lis = []
+
+        for son in typex.sons:
+            ret_lis.extend(self.get_preordenTypes(son))
+
+        ret_lis.append(typex)
+        return ret_lis
+
+
+    def box(self, typeName, value):
+        obj_internal = self.define_internal_local()
+        self.register_instruction(cil.AllocateNode(typeName, obj_internal))
+        self.register_instruction(cil.SetAttribNode(obj_internal, 0, value))
+        self.register_instruction(cil.LoadNode(obj_internal, f'{typeName}_name'))
+        self.register_instruction(cil.LoadIntNode(obj_internal, f'{typeName}_size', 4))
+        self.register_instruction(cil.LoadNode(obj_internal, f'__virtual_table__{typeName}', 8))
+        return obj_internal