Entrega funcional

.gitignore

@@ -394,7 +394,8 @@ dmypy.json
 .pyre/
 
 ### VisualStudioCode ###
-.vscode/*
+.vs/
+.vscode/
 !.vscode/settings.json
 !.vscode/tasks.json
 !.vscode/launch.json

doc/Gramatica.md

@@ -0,0 +1,72 @@
+# Gramática usada
+En lo siguiente mostraremos la gramática BNF usada para la realización de nuestro compilador:
+```
+program : classdec program
+        | classdec
+classdec : class type lbracket featurelist rbracket pcoma
+         | class type inherits type lbracket featurelist rbracket pcoma
+featurelist : feature featurelist
+            | empty
+feature : attribute pcoma
+        | methoddef pcoma
+methoddef : id lparen rparen dpoint type lbracket expression rbracket
+          | id lparen param paramslistdef rparen dpoint type lbracket expression rbracket
+paramslistdef : coma param paramslistdef
+              | empty
+param : id dpoint type
+attribute : id dpoint type
+          | id dpoint type assign expression
+empty :
+expression  : constantexp
+            | identifier
+            | assignment
+            | dispatch
+            | conditional
+            | loopexp
+            | blockexp
+            | letexp
+            | caseexp
+            | newexp
+            | isvoidexp
+            | aritmetica
+            | comparison
+            |parenexpression
+dispatch : id lparen rparen
+         | id lparen expression expressionparams rparen
+         | expression point id lparen rparen
+         | expression point id lparen expression expressionparams rparen
+         | expression arroba type point id lparen rparen
+         | expression arroba type point id lparen expression expressionparams rparen
+expressionparams : coma expression expressionparams
+                 | empty
+conditional : if expression then expression else expression fi
+loopexp : while expression loop expression pool
+blockexp : lbracket expressionlist rbracket
+expressionlist : expression pcoma expressionlist
+               | empty
+letexp : let attribute letattributelist in expression
+letattributelist : coma attribute letattributelist
+                 | empty
+caseexp : case expression of subcase listcase esac
+listcase : subcase listcase
+         | empty
+subcase : id dpoint type implica expression pcoma
+newexp : new type
+isvoidexp : isvoid expression
+aritmetica : expression plus expression
+           | expression minus expression
+           | expression mult expression
+           | expression div expression
+           | intnot expression
+comparison  : expression less expression
+            | expression lesse expression
+            | expression equal expression
+            | not expression
+parenexpression : lparen expression rparen
+constantexp : number
+            | string
+            | true
+            | false
+identifier : id
+assignment : id assign expression
+```

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>)
+José Gabriel Navarro Comabella | C412 | [@TTigre](https://github.com/TTigre)
+Alberto Helguera Fleitas | C412 | [@Al3ERT](https://github.com/Al3ERT)
 
 ## Readme
 

requirements.txt

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

src/AST.py

@@ -0,0 +1,177 @@
+class Node:
+    index=0
+    line=0
+
+class ProgramNode(Node):
+    def __init__(self, classes):
+        self.classes = classes
+
+class ClassNode(Node):
+    def __init__(self, name, parent, features):
+        self.name = name
+        self.parent = parent
+        self.methods = []
+        self.attributes = []
+        if features is not []:
+            for foo in features:
+                if isinstance(foo,AttributeNode):
+                    self.attributes.append(foo)
+                else:
+                    self.methods.append(foo)
+
+class ClassFeatureNode(Node):
+    pass
+
+class MethodNode(ClassFeatureNode):
+    def __init__(self, name, parameters, return_type, body):
+        self.name = name
+        self.parameters = parameters
+        self.return_type = return_type
+        self.body = body
+
+class AttributeNode(ClassFeatureNode):
+    def __init__(self, name, attr_type, value):
+        self.name = name
+        self.type = attr_type
+        self.value = value
+
+class ParameterNode(ClassFeatureNode):
+    def __init__(self, name, param_type):
+        self.name = name
+        self.type = param_type
+
+class ExpressionNode(Node):
+    pass
+
+
+class AssignNode(ExpressionNode):
+    def __init__(self, variable, expr):
+        self.variable = variable
+        self.expression = expr
+
+class ConditionalNode(ExpressionNode):
+    def __init__(self, predicate, then_body, else_body):
+        self.predicate = predicate
+        self.then_body = then_body
+        self.else_body = else_body
+
+class LoopNode(ExpressionNode):
+    def __init__(self, predicate, body):
+        self.predicate = predicate
+        self.body = body
+
+class LetNode(ExpressionNode):
+    def __init__(self, declarations, in_body):
+        self.declarations = declarations
+        self.body = in_body 
+
+class AtomicNode(ExpressionNode):
+    pass
+
+class ConstantNode(AtomicNode):
+    pass
+
+class StringNode(ConstantNode):
+    def __init__(self, value):
+        self.value = value
+
+class IntegerNode(ConstantNode):
+    def __init__(self, value):
+        self.value = value
+
+class BoolNode(ConstantNode):
+    def __init__(self, value):
+        self.value = value
+
+class NewNode(AtomicNode):
+    def __init__(self, new_type):
+        self.type = new_type
+
+class BlockNode(AtomicNode):
+    def __init__(self, expressions):
+        self.expressions = expressions
+
+class CaseNode(AtomicNode):
+    def __init__(self, expression, subcases):
+        self.expression = expression
+        self.subcases = subcases
+
+class SubCaseNode:
+    def __init__(self, name, sub_type, expression):
+        self.name = name
+        self.type = sub_type
+        self.expression = expression 
+
+class DispatchNode(AtomicNode):
+    def __init__(self, func_id, parameters, left_expr, left_type=None):
+        self.func_id = func_id
+        self.parameters = parameters
+        self.left_expression = left_expr
+        self.left_type=left_type
+
+class StaticDispatchNode(AtomicNode):
+    def __init__(self, func_id, parent_id ,parameters, left_expr):
+        self.func_id = func_id
+        self.parent_id = parent_id
+        self.parameters = parameters
+        self.left_expression = left_expr
+
+class VariableNode(AtomicNode):
+    def __init__(self, var_id):
+        self.id = var_id
+
+class UnaryOperatorNode(ExpressionNode):
+    operator = ""
+    pass
+
+class IsVoidNode(UnaryOperatorNode):
+    def __init__(self, expr, tipo="Class"):
+        self.expression = expr
+        self.tipo=tipo
+
+class IntComplementNode(UnaryOperatorNode):
+    def __init__(self, right):
+        self.right = right
+
+class BoolComplementNode(UnaryOperatorNode):
+    def __init__(self, right):
+        self.right = right
+
+class BinaryOperatorNode(ExpressionNode):
+    operator=""
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+class ComparisonNode(BinaryOperatorNode):
+    pass
+
+class LesserNode(ComparisonNode):
+    pass
+
+class LesserEqualNode(ComparisonNode):
+    pass
+
+class EqualNode(ComparisonNode):
+    def __init__(self,left,right, isString=False):
+        self.left = left
+        self.right = right
+        self.isString = isString
+
+class ArithmeticNode(BinaryOperatorNode):
+    pass
+
+class PlusNode(ArithmeticNode):
+    pass
+
+class MinusNode(ArithmeticNode):
+    pass
+
+class MultNode(ArithmeticNode):
+    pass
+
+class DivNode(ArithmeticNode):
+    pass
+
+
+