Environment

AST.py

@@ -16,13 +16,15 @@ class ASTNode():
     #   call the same method in each class and its children recursively
     #   the methods that represent an action would return arguments to be used in
     #   the child nodes' method if neccessary
-    def recurseAction(self, actionName, args):
-        func = self.getattr(actionName)
+    def recurseAction(self, actionName, args=None):
+        func = getattr(self, actionName)
         result = None
-        if func:
+        if func and args:
             result = func(args)
+        elif func:
+            result = func()
         for c in self.children:
-            c.recurseAction(result)
+            c.recurseAction(actionName, result)
 
     # use the parse tree to populate current AST node and construct child AST nodes
     def buildASTNodeRecursive(self):
@@ -35,8 +37,10 @@ class ASTNode():
         pp.pprint(vars(self))
         pp.pprint("-----children-----")
         prefix += 1
-        for c in self.children:
-            c.printNodePretty(prefix)
+        return prefix
+
+    def printTree(self):
+        self.recurseAction('printNodePretty')
 
 # Utils ######################################################
 

AstBuilding.py

 from CompNode import CompNode
+from pprpint import pprint
+from Env import GlobalEnv
 
 # tree: (filename, parseTree)
 def astBuild(trees):
@@ -7,6 +9,27 @@ def astBuild(trees):
         ASTs.append((n, CompNode(t)))
     return ASTs
 
+def buildEnvAndLink(ASTs):
+    # build env
+    globalEnv = GlobalEnv()
+    for t in ASTs:
+        globalEnv.addtoEnv(t)
+        # build Env inside each class / interface
+        t.typeDcl.recurseAction("buildEnv")
+
+    # type Linking
+    for t in ASTs:
+        t.buildEnvFromImports(globalEnv)
+        # t.typeDcl.recurseAction("linkType")
+
+    print ("\n\n###################### global Env ####################")
+    pprint(GlobalEnv)
+    for t in ASTs:
+        printt ("\n\n###################### Comp Unit Env ####################")
+        t.recurseAction("printEnv")
+
+#######################################################
+
 # # ast: Node
 # def weed(ast):
 #     res = ast.weed()

Environment.py

-from ASTNode import ScopeNode, Environment
+class Env:
+    nodeToNamespace = dict({
+        'FieldNode': 'field',
+        'InterNode': 'interface',
+        'ClassNode': 'class',
+        'MethodNode': 'method'
+    })
 
-##################################################################
+    def __init__(self, parentEnv):
+        self.parentEnv = parentEnv
+        self.map = {} # {(name, namespace) -> node}
 
-# give a list of parseTrees, returns the global Environemnt object and
-#   a list of classNodes with globalEnv attached to them
-def buildGlobalEnv(parseTrees):
-	gEnv = Environment(None)
-	ASTs = []
+    def addtoEnv(node):
+        # use node.__class__.__name__ to get namespace
+        nodeType = node.__class__.__name__
+        if not self.nodeToNamespace.contains(nodeType):
+            namespace = 'local'
+        namespace = self.nodeToNamespace.get(nodeType)
+        # Add to Env
+        key = (node.name, namespace)
+        if self.map.contains(key):
+            raise Exception('ERROR: Declaration of {} is already in current Environment'.format(node.name))
+        self.map[key] = node
 
-	for t in parseTrees:
-		# add imports
-		imports = getParseTreeNodes(['importDcl'], t)
-		for i in imports:
-			importNames = getParseTreeNodes(['ID', 'COMPID', 'IMPORTALL'], i)
-			for n in importNames:
-				gEnv.addName(n.lex, 'package', None)
+    def getNode(name, namespace):
+        key = (name, namespace)
 
-		# TODO: figure out package name
-		packages = getParseTreeNodes('packageDcl', t)
-		pNames = []
-		for p in packages:
-			pNames.extend(getParseTreeNodes(['ID', 'COMPID'], p))
-		if pNames:
-			pNames = pNames[0]
-		else:
-			pNames = 'no packageName'
+        if self.map.contains(key):
+            return self.map.get(key)
+        elif namespace == 'local':
+            key2 = (name, 'field')
+            if self.map.contains(key2):
+                return self.map.get(key2)
+        elif parentEnv:
+            return parentEnv.getNode(name, namespace)
+        raise Exception("ERROR: Can't find definition of {} in the Environment".format(name))
 
-		# add class to global Env
-		classDcl = getParseTreeNodes('classDcl', t)
-		interfaceDcl = getParseTreeNodes('interfaceDcl', t)
+###################################
 
-		if not classDcl:
-			intNode = ScopeNode(interfaceDcl[0], gEnv)
-			ASTs.append(intNode)
-			gEnv.addName(pNames+ " " + intNode.name, 'interface', intNode)
-		else:
-			classNode = ScopeNode(classDcl[0], gEnv)
-			ASTs.append(classNode)
-			gEnv.addName(pNames+ " " + classNode.name, 'class', classNode)
+class GlobalEnv(Env):
+    def __init__(self):
+        super().__init__(None)
+        #self.map = {} # {(Canonical name, namespace) -> node}
+        self.pacakgeMap = {} # {packageName -> {(simpleName, namespace) -> node}}
+                            #   A map of maps
+                            #   contains duplicate info as self.map for easy searching
 
-	#prints
+        # input: Compiliation Unit Node (CompNode)
+        def addtoEnv(node):
+            pName = node.packageName
+            typeDcl = node.typeDcl
+            typeDclType = typeDcl.__class__.__name__
+            # at global level there are only class and interface
+            namespace = self.nodeToNamespace.get(typeDclType)
 
-	print('----------- global env ------------')
-	for g in gEnv.map:
-		print(g)
-		for gg in gEnv.map[g]:
-			print(gg)
-	print('----------- ASTs  -----------------')
-	for a in ASTs:
-		print(a.name)
-	return gEnv, ASTs
+            # Add to map
+            mapKey = (pName + '.'  + typeDclType.name, namespace)
+            if self.map.contains(mapKey):
+                raise Exception('ERROR: Declaration of {} is already in current Environment'.format(pName + '.'  + typeDclType.name))
+            self.map[mapKey] = typeDcl
 
-# Utils: given a parseTree and a list of names, traverse the tree
-#        to return a list of tree nodes(on the same level) that
-#        has one of those names
-def getParseTreeNodes(names, tree):
-	result = []
-	if tree.name in names:
-		return result.append(tree)
-	if not tree.children:
-		return []
-	for n in tree.children:
-		if n.name in names:
-			result.append(n)
-		else:
-			result.extend(getParseTreeNodes(names, n))
-	return result
+            # Add to packageMap
+            pMapKey = (typeDclType.name, namespace)
+            if not self.pacakgeMap.contains(pName):
+                self.pacakgeMap[pName] = {}
+
+            if not self.pacakgeMap[pName].contains(pMapKey):
+                raise Exception('ERROR: Declaration of {} is already in current Environment'.format(pName + '.'  + typeDclType.name))
+            self.pacakgeMap[pName][pMapKey] = typeDcl
+
+        # Use getNode() from base class to get node using Canonical Name (full name)
+
+        # method for getting all the nodes under a package (import All)
+        # returns a dict of types under that package name
+        def getNodesByPackage(pName):
+            if not self.pacakgeMap.contains(pName):
+                raise Exception("ERROR: Can't find definition of package {} in the Environment".format(pName))
+            return self.pacakgeMap.get(pName)

Test.py

@@ -103,7 +103,7 @@ def run(testFiles):
     for (n, t) in ASTs:
         print(n)
         print("--------------------")
-        t.printNodePretty()
+        t.printTree()
         print("\n \n\n \n")