parser - AST for const, var decl. better AST printing

AST is not printed to a syntax_tree.txt file in the same directory.

Author: Samyak2

.gitignore

@@ -1,5 +1,7 @@
 env/
 *__pycache__*
+ply/__pycache__*
 tmp*
 parser.out
 .vim/
+syntax_tree.txt

go_parser.py

@@ -205,6 +205,10 @@ def p_Signature(p):
     """Signature : Parameters
     | Parameters Result
     """
+    if len(p) == 2:
+        p[0] = syntree.Signature(p[1])
+    else:
+        p[0] = syntree.Signature(p[1], p[2])
 
 
 def p_Parameters(p):
@@ -298,20 +302,19 @@ def p_IncDecStmt(p):
 
 
 def p_Assignment(p):
-    '''Assignment : ExpressionList assign_op ExpressionList
-    '''
+    """Assignment : ExpressionList assign_op ExpressionList"""
     p[0] = syntree.Assignment(p[2], p[1], p[3])
 
 
 def p_assign_op(p):
-    '''assign_op : '='
-                 | ADD_EQ
-                 | SUB_EQ
-                 | MUL_EQ
-                 | DIV_EQ
-                 | MOD_EQ
-    '''
-#     # TODO : Add |= ^= <<= >>= &= &^=
+    """assign_op : '='
+    | ADD_EQ
+    | SUB_EQ
+    | MUL_EQ
+    | DIV_EQ
+    | MOD_EQ
+    """
+    #     # TODO : Add |= ^= <<= >>= &= &^=
     p[0] = p[1]
 
 
@@ -324,12 +327,17 @@ def p_Declaration(p):
     | ConstDecl
     | TypeDecl
     """
+    p[0] = p[1]
 
 
 def p_VarDecl(p):
     """VarDecl : KW_VAR VarSpec
     | KW_VAR '(' VarSpecList ')'
     """
+    if len(p) == 3:
+        p[0] = syntree.List([p[2]])
+    elif len(p) == 5:
+        p[0] = p[3]
 
 
 def p_VarSpecList(p):
@@ -349,12 +357,22 @@ def p_VarSpec(p):
     | IdentifierList Type '=' ExpressionList
     | IdentifierList '=' ExpressionList
     """
+    if len(p) == 3:
+        p[0] = syntree.VariableDecl(p[1], p[2])
+    elif len(p) == 4:
+        p[0] = syntree.VariableDecl(p[1], expression_list=p[3])
+    elif len(p) == 5:
+        p[0] = syntree.VariableDecl(p[1], p[2], p[4])
 
 
 def p_ConstDecl(p):
     """ConstDecl : KW_CONST ConstSpec
     | KW_CONST '(' ConstSpecList ')'
     """
+    if len(p) == 3:
+        p[0] = syntree.List([p[2]])
+    elif len(p) == 5:
+        p[0] = p[3]
 
 
 def p_ConstSpecList(p):
@@ -374,6 +392,12 @@ def p_ConstSpec(p):
     | IdentifierList '=' ExpressionList
     | IdentifierList Type '=' ExpressionList
     """
+    if len(p) == 2:
+        p[0] = syntree.VariableDecl(p[1], const=True)
+    elif len(p) == 4:
+        p[0] = syntree.VariableDecl(p[1], expression_list=p[3], const=True)
+    elif len(p) == 5:
+        p[0] = syntree.VariableDecl(p[1], p[2], p[4], const=True)
 
 
 def p_TypeDecl(p):
@@ -412,12 +436,22 @@ def p_IdentifierList(p):
     """IdentifierList : IDENTIFIER
     | IDENTIFIER ',' IdentifierList %prec WALRUS
     """
+    if len(p) == 2:
+        p[0] = syntree.List([syntree.Identifier(p[1])])
+    elif len(p) == 4:
+        p[3].append(syntree.Identifier(p[1]))
+        p[0] = p[3]
 
 
 def p_ExpressionList(p):
     """ExpressionList : Expression
     | Expression ',' ExpressionList
     """
+    if len(p) == 4:
+        p[3].append(p[1])
+        p[0] = p[3]
+    elif len(p) == 2:
+        p[0] = syntree.List([p[1]])
 
 
 def p_Expression(p):
@@ -450,8 +484,9 @@ def p_UnaryExpr(p):
     if len(p) == 3:
         p[0] = syntree.UnaryOp(p[1], p[2])
     else:
-        # TODO : handle PrimaryExpr
-        pass
+        # TODO : handle more stuff in PrimaryExpr
+        # also change the PrimaryExpr class in syntree when doing so
+        p[0] = syntree.UnaryOp(None, p[1])
 
 
 def p_UnaryOp(p):
@@ -465,7 +500,7 @@ def p_UnaryOp(p):
 def p_PrimaryExpr(p):
     """PrimaryExpr : Operand"""
     # TODO : This is too less! Many more to add
-    p[0] = p[1]
+    p[0] = syntree.PrimaryExpr(p[1])
 
 
 def p_Operand(p):
@@ -488,7 +523,7 @@ def p_OperandName(p):
 
 def p_QualifiedIdent(p):
     """QualifiedIdent : PackageName '.' IDENTIFIER"""
-    # TODO : AST for this
+    p[0] = syntree.QualifiedIdent(p[1], p[3])
 
 
 def p_Literal(p):
@@ -930,7 +965,10 @@ def p_error(p: lex.LexToken):
         go_lexer.lines = lines
         result = parser.parse(input_code, tracking=True)
         # print(result)
-        print_tree(ast, nameattr=None)
+        with open("syntax_tree.txt", "wt") as ast_file:
+            sys.stdout = ast_file
+            print_tree(ast, nameattr=None, horizontal=False)
+            sys.stdout = sys.__stdout__
         print("Finished Parsing!")
         print("Symbol Table: ")
         print(symtab)

ply/__pycache__/__init__.cpython-39.pyc

@@ -17,10 +17,10 @@ def balanced_branches(current_node):
         size_branch = {child: nb_children(child) for child in children(current_node)}
 
         """ Creation of balanced lists for "a" branch and "b" branch. """
-        a = sorted(children(current_node), key=lambda node: nb_children(node))
+        a = children(current_node)
         b = []
         while a and sum(size_branch[node] for node in b) < sum(size_branch[node] for node in a):
-            b.append(a.pop())
+            b.insert(0, a.pop())
 
         return a, b
 

ply/__pycache__/lex.cpython-39.pyc

@@ -7,10 +7,13 @@ def __init__(self, name, **kwargs):
         self.data = kwargs.get("data", None)
 
     def __repr__(self):
-        return f"<Node: {self.name}; {self.data}; {self.children}>"
+        return str(self)
 
     def __str__(self):
-        return f"<Node: {self.name}; {self.data}; {len(self.children)} child(s)>"
+        if self.data is not None:
+            return f"<{self.name}: {str(self.data)}>"
+        else:
+            return f"<{self.name}>"
 
     def add_child(self, child):
         if child is not None:
@@ -41,6 +44,8 @@ class UnaryOp(Node):
     """Node for unary operations"""
 
     def __init__(self, operator, operand):
+        if isinstance(operand, UnaryOp) and operand.operator is None:
+            operand = operand.operand
         super().__init__(f"Unary {operator}", children=[operand], data=operator)
 
     @property
@@ -52,6 +57,16 @@ def operand(self):
         return self.children[0]
 
 
+class PrimaryExpr(Node):
+    """Node for PrimaryExpr
+
+    Ref: https://golang.org/ref/spec#PrimaryExpr
+    """
+
+    def __init__(self, operand):
+        super().__init__("PrimaryExpr", children=[], data=operand)
+
+
 class Literal(Node):
     """Node to store literals"""
 
@@ -75,13 +90,31 @@ def __init__(self, children):
         super().__init__("LIST", children=children)
         self.append = self.add_child
 
+    def __iter__(self):
+        return iter(self.children)
+
+
+class Signature(Node):
+    """Node to store function signature"""
+
+    def __init__(self, parameters, result=None):
+        super().__init__("signature", children=[parameters, result])
+
+    @property
+    def parameters(self):
+        return self.children[0]
+
+    @property
+    def result(self):
+        return self.children[1]
+
 
 class Function(Node):
     """Node to store function declaration"""
 
     def __init__(self, name, signature, body=None):
         super().__init__("FUNCTION", children=[signature, body], data=name)
-        self.name = name
+        self.fn_name = name
 
     @property
     def signature(self):
@@ -96,7 +129,7 @@ def body(self):
 
 
 class Type(Node):
-    "Parent class for all types"""
+    """Parent class for all types"""
 
 
 class Array(Type):
@@ -110,6 +143,48 @@ def __init__(self, eltype, length):
     def length(self):
         return self.children[0]
 
+
+class Identifier(Node):
+    """Node for identifiers"""
+
+    def __init__(self, ident_tuple):
+        super().__init__("IDENTIFIER", children=[], data=ident_tuple[1])
+
+
+class QualifiedIdent(Node):
+    """Node for qualified identifiers"""
+
+    def __init__(self, package_name, identifier):
+        super().__init__("IDENTIFIER", children=[], data=(package_name, identifier))
+
+
+class VariableDecl(Node):
+    """Node to store variable and constant declarations"""
+
+    def __init__(self, identifier_list, type_=None, expression_list=None, const=False):
+        super().__init__(
+            "DECL",
+            children=[identifier_list, expression_list],
+            data=(type_, const),
+        )
+
+    @property
+    def expression_list(self):
+        return self.children[1]
+
+    @property
+    def identifier_list(self):
+        return self.children[0]
+
+    @property
+    def type_(self):
+        return self.data[0]
+
+    @property
+    def is_const(self):
+        return self.data[1]
+
+
 # class OldNode:
 #     """Class to store a node of the AST"""
 
@@ -166,5 +241,3 @@ def length(self):
 #                 self.children.append(Node(type(child), node=child))
 #             else:
 #                 self.children.append(child)
-
-

pptree_mod.py

@@ -6,13 +6,9 @@ const (
 	size int = 1024
 	eof        = -1  // untyped integer constant
 )
-const a, b, c = 3, 4, "foo
-askdhas
-alksdhsal
-asdasdsa"  // a = 3, b = 4, c = "foo", untyped integer and string constants
+const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", untyped integer and string constants
 const u, v float64 = 0, 3    // u = 0.0, v = 3.0
 const zero = 0
-asldas */
 const some = 5 * 3
 const somemore = 5.0 - 5
 const added = Pi + size

syntree.py

@@ -0,0 +1,18 @@
+package main
+
+const Pi float64 = 3.14159265358979323846
+const zero = 0.0 
+const ( 
+	size int = 1024
+	eof        = -1  // untyped integer constant
+)
+const a, b, c = 3, 4, "foo
+askdhas
+alksdhsal
+asdasdsa"  // a = 3, b = 4, c = "foo", untyped integer and string constants
+const u, v float64 = 0, 3    // u = 0.0, v = 3.0
+const zero = 0
+asldas */
+const some = 5 * 3
+const somemore = 5.0 - 5
+const added = Pi + size