Parser: support more grammatical rules. Added empty parsing rules for the rest of grammar.

Author: aalhour

docs/CFG.md

@@ -52,7 +52,7 @@ A preliminary note on the meaning of postfixes in left-hand-side symbols:
 <exprns-ne>      ::= <expr>
                  |   <expr>, <exprns-ne>
 
-<expr>           ::= <assignment>
+<expr>           ::= ID <- <expr>
                  |   <expr><at-type>.ID( <exprns> )
                  |   <if-then-else>
                  |   <while>
@@ -77,8 +77,6 @@ A preliminary note on the meaning of postfixes in left-hand-side symbols:
                  |   true
                  |   false
 
-<assignment>     ::= ID <- <expr>
-
 <at-type>        ::= @TYPE
                  |   ""
 

pycoolc/ast.py

@@ -8,7 +8,7 @@
 # -----------------------------------------------------------------------------
 
 
-class Base:
+class BaseNode:
     def __init__(self):
         pass
 
@@ -22,22 +22,22 @@ def __str__(self):
         return str(self.to_tuple())
 
 
-class Program(Base):
+class ProgramNode(BaseNode):
     NODE_NAME = "PROGRAM"
 
     def __init__(self, classes):
-        super(Program, self).__init__()
+        super(ProgramNode, self).__init__()
         self.classes = classes
 
     def to_tuple(self):
         return tuple([self.NODE_NAME, self.classes])
 
 
-class Class(Base):
+class ClassNode(BaseNode):
     NODE_NAME = "CLASS"
 
     def __init__(self, name, inherits, features):
-        super(Class, self).__init__()
+        super(ClassNode, self).__init__()
         self.name = name
         self.inherits = inherits
         self.features = features
@@ -46,13 +46,68 @@ def to_tuple(self):
         return tuple([self.NODE_NAME, self.name, self.inherits, self.features])
 
 
-class Inheritance(Base):
+class InheritanceNode(BaseNode):
     NODE_NAME = "INHERITS"
 
     def __init__(self, inheritance_type=None):
-        super(Inheritance, self).__init__()
+        super(InheritanceNode, self).__init__()
         self.inheritance_type = inheritance_type
 
     def to_tuple(self):
         return tuple([self.NODE_NAME, self.inheritance_type])
 
+    def is_empty(self):
+        return self.inheritance_type is None
+
+
+class FeaturesNode(BaseNode):
+    NODE_NAME = "FEATURES"
+
+    def __init__(self, features):
+        super(FeaturesNode, self).__init__()
+        if features is None:
+            self.features = tuple()
+        else:
+            self.features = features
+
+    def to_tuple(self):
+        return tuple([self.NODE_NAME, self.features])
+
+    def is_empty(self):
+        return len(self.features) == 0
+
+
+class AttributeNode(BaseNode):
+    NODE_NAME = "FORMAL"
+
+    def __init__(self, identifier, attr_type, formals, expression):
+        super(AttributeNode, self).__init__()
+        self.identifier = identifier
+        self.type = attr_type
+        self.expression = expression
+        self.formals = formals
+
+    def to_tuple(self):
+        return tuple([self.NODE_NAME, self.identifier, self.type, self.expression, self.formals])
+
+
+class FormalNode(BaseNode):
+    NODE_NAME = "FORMAL"
+
+    def __init__(self, identifier, formal_type, assignment):
+        super(FormalNode, self).__init__()
+        self.identifier = identifier
+        self.type = formal_type
+        self.assignment = assignment
+
+    def to_tuple(self):
+        return tuple([self.NODE_NAME, self.identifier, self.type, self.assignment])
+
+
+class Expr(BaseNode):
+    NODE_NAME = "EXPRESSION"
+
+    def __init__(self, expression):
+        super(Expr, self).__init__()
+        self.expression = expression
+