Add preliminary module symbol table constructor

1 files changed, 193 insertions, 0 deletions

diff --git a/Lib/compiler/symbols.py b/Lib/compiler/symbols.py
new file mode 100644
index 0000000..1f107fe
--- /dev/null
+++ b/Lib/compiler/symbols.py
@@ -0,0 +1,193 @@
+"""Module symbol-table generator"""
+
+from compiler import ast
+
+module_scope = None
+
+class Scope:
+    # XXX how much information do I need about each name?
+    def __init__(self, name):
+        self.name = name
+        self.defs = {}
+        self.uses = {}
+        self.globals = {}
+        self.params = {}
+
+    def __repr__(self):
+        return "<%s: %s>" % (self.__class__.__name__, self.name)
+
+    def add_def(self, name):
+        self.defs[name] = 1
+
+    def add_use(self, name):
+        self.uses[name] = 1
+
+    def add_global(self, name):
+        if self.uses.has_key(name) or self.defs.has_key(name):
+            pass # XXX warn about global following def/use
+        if self.params.has_key(name):
+            raise SyntaxError, "%s in %s is global and parameter" % \
+                  (name, self.name)
+        self.globals[name] = 1
+        module_scope.add_def(name)
+
+    def add_param(self, name):
+        self.defs[name] = 1
+        self.params[name] = 1
+
+    def get_names(self):
+        d = {}
+        d.update(self.defs)
+        d.update(self.uses)
+        return d.keys()
+
+class ModuleScope(Scope):
+    __super_init = Scope.__init__
+    
+    def __init__(self):
+        self.__super_init("global")
+        global module_scope
+        assert module_scope is None 
+        module_scope = self
+
+class LambdaScope(Scope):
+    __super_init = Scope.__init__
+
+    __counter = 1
+    
+    def __init__(self):
+        i = self.__counter
+        self.__counter += 1
+        self.__super_init("lambda.%d" % i)
+
+class FunctionScope(Scope):
+    pass
+
+class ClassScope(Scope):
+    pass
+
+class SymbolVisitor:
+    def __init__(self):
+        self.scopes = {}
+
+    # node that define new scopes
+
+    def visitModule(self, node):
+        scope = self.scopes[node] = ModuleScope()
+        self.visit(node.node, scope)
+
+    def visitFunction(self, node, parent):
+        parent.add_def(node.name)
+        for n in node.defaults:
+            self.visit(n, parent)
+        scope = FunctionScope(node.name)
+        self.scopes[node] = scope
+        for name in node.argnames:
+            scope.add_param(name)
+        self.visit(node.code, scope)
+
+    def visitLambda(self, node, parent):
+        for n in node.defaults:
+            self.visit(n, parent)
+        scope = LambdaScope()
+        self.scopes[node] = scope
+        for name in node.argnames:
+            scope.add_param(name)
+        self.visit(node.code, scope)
+
+    def visitClass(self, node, parent):
+        parent.add_def(node.name)
+        for n in node.bases:
+            self.visit(n, parent)
+        scope = ClassScope(node.name)
+        self.scopes[node] = scope
+        self.visit(node.code, scope)
+
+    # name can be a def or a use
+
+    # XXX a few calls and nodes expect a third "assign" arg that is
+    # true if the name is being used as an assignment.  only
+    # expressions contained within statements may have the assign arg.
+
+    def visitName(self, node, scope, assign=0):
+        if assign:
+            scope.add_def(node.name)
+        else:
+            scope.add_use(node.name)
+
+    # operations that bind new names
+
+    def visitFor(self, node, scope):
+        self.visit(node.assign, scope, 1)
+        self.visit(node.list, scope)
+        self.visit(node.body, scope)
+        if node.else_:
+            self.visit(node.else_, scope)
+
+    def visitFrom(self, node, scope):
+        for name, asname in node.names:
+            if name == "*":
+                continue
+            scope.add_def(asname or name)
+
+    def visitImport(self, node, scope):
+        for name, asname in node.names:
+            i = name.find(".")
+            if i > -1:
+                name = name[:i]
+            scope.add_def(asname or name)
+
+    def visitAssName(self, node, scope, assign=1):
+        scope.add_def(node.name)
+
+    def visitAugAssign(self, node, scope):
+        # basically, the node is referenced and defined by the same expr
+        self.visit(node.node, scope)
+        self.visit(node.node, scope, 1)
+        self.visit(node.expr, scope)
+
+    def visitAssign(self, node, scope):
+        for n in node.nodes:
+            self.visit(n, scope, 1)
+        self.visit(node.expr, scope)
+
+    def visitGlobal(self, node, scope):
+        for name in node.names:
+            scope.add_global(name)
+
+def sort(l):
+    l = l[:]
+    l.sort()
+    return l
+
+def list_eq(l1, l2):
+    return sort(l1) == sort(l2)
+
+if __name__ == "__main__":
+    import sys
+    from compiler import parseFile, walk
+    import symtable
+
+    for file in sys.argv[1:]:
+        print file
+        f = open(file)
+        buf = f.read()
+        f.close()
+        syms = symtable.symtable(buf, file, "exec")
+        mod_names = [s for s in [s.get_name()
+                                 for s in syms.get_symbols()]
+                     if not s.startswith('_[')]
+        tree = parseFile(file)
+        s = SymbolVisitor()
+        walk(tree, s)
+        for node, scope in s.scopes.items():
+            print node.__class__.__name__, id(node)
+            print scope
+            print scope.get_names()
+
+        names2 = s.scopes[tree].get_names()
+        if not list_eq(mod_names, names2):
+            print "oops", file
+            print sort(mod_names)
+            print sort(names2)
+            sys.exit(-1)