"""Interface to the compiler's internal symbol tables""" | |
import _symtable | |
from _symtable import (USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, | |
DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC, | |
SCOPE_OFF, SCOPE_MASK, FREE, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL, LOCAL) | |
import weakref | |
__all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"] | |
def symtable(code, filename, compile_type): | |
raw = _symtable.symtable(code, filename, compile_type) | |
for top in raw.itervalues(): | |
if top.name == 'top': | |
break | |
return _newSymbolTable(top, filename) | |
class SymbolTableFactory: | |
def __init__(self): | |
self.__memo = weakref.WeakValueDictionary() | |
def new(self, table, filename): | |
if table.type == _symtable.TYPE_FUNCTION: | |
return Function(table, filename) | |
if table.type == _symtable.TYPE_CLASS: | |
return Class(table, filename) | |
return SymbolTable(table, filename) | |
def __call__(self, table, filename): | |
key = table, filename | |
obj = self.__memo.get(key, None) | |
if obj is None: | |
obj = self.__memo[key] = self.new(table, filename) | |
return obj | |
_newSymbolTable = SymbolTableFactory() | |
class SymbolTable(object): | |
def __init__(self, raw_table, filename): | |
self._table = raw_table | |
self._filename = filename | |
self._symbols = {} | |
def __repr__(self): | |
if self.__class__ == SymbolTable: | |
kind = "" | |
else: | |
kind = "%s " % self.__class__.__name__ | |
if self._table.name == "global": | |
return "<{0}SymbolTable for module {1}>".format(kind, self._filename) | |
else: | |
return "<{0}SymbolTable for {1} in {2}>".format(kind, | |
self._table.name, | |
self._filename) | |
def get_type(self): | |
if self._table.type == _symtable.TYPE_MODULE: | |
return "module" | |
if self._table.type == _symtable.TYPE_FUNCTION: | |
return "function" | |
if self._table.type == _symtable.TYPE_CLASS: | |
return "class" | |
assert self._table.type in (1, 2, 3), \ | |
"unexpected type: {0}".format(self._table.type) | |
def get_id(self): | |
return self._table.id | |
def get_name(self): | |
return self._table.name | |
def get_lineno(self): | |
return self._table.lineno | |
def is_optimized(self): | |
return bool(self._table.type == _symtable.TYPE_FUNCTION | |
and not self._table.optimized) | |
def is_nested(self): | |
return bool(self._table.nested) | |
def has_children(self): | |
return bool(self._table.children) | |
def has_exec(self): | |
"""Return true if the scope uses exec""" | |
return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC)) | |
def has_import_star(self): | |
"""Return true if the scope uses import *""" | |
return bool(self._table.optimized & OPT_IMPORT_STAR) | |
def get_identifiers(self): | |
return self._table.symbols.keys() | |
def lookup(self, name): | |
sym = self._symbols.get(name) | |
if sym is None: | |
flags = self._table.symbols[name] | |
namespaces = self.__check_children(name) | |
sym = self._symbols[name] = Symbol(name, flags, namespaces) | |
return sym | |
def get_symbols(self): | |
return [self.lookup(ident) for ident in self.get_identifiers()] | |
def __check_children(self, name): | |
return [_newSymbolTable(st, self._filename) | |
for st in self._table.children | |
if st.name == name] | |
def get_children(self): | |
return [_newSymbolTable(st, self._filename) | |
for st in self._table.children] | |
class Function(SymbolTable): | |
# Default values for instance variables | |
__params = None | |
__locals = None | |
__frees = None | |
__globals = None | |
def __idents_matching(self, test_func): | |
return tuple([ident for ident in self.get_identifiers() | |
if test_func(self._table.symbols[ident])]) | |
def get_parameters(self): | |
if self.__params is None: | |
self.__params = self.__idents_matching(lambda x:x & DEF_PARAM) | |
return self.__params | |
def get_locals(self): | |
if self.__locals is None: | |
locs = (LOCAL, CELL) | |
test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs | |
self.__locals = self.__idents_matching(test) | |
return self.__locals | |
def get_globals(self): | |
if self.__globals is None: | |
glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT) | |
test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob | |
self.__globals = self.__idents_matching(test) | |
return self.__globals | |
def get_frees(self): | |
if self.__frees is None: | |
is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE | |
self.__frees = self.__idents_matching(is_free) | |
return self.__frees | |
class Class(SymbolTable): | |
__methods = None | |
def get_methods(self): | |
if self.__methods is None: | |
d = {} | |
for st in self._table.children: | |
d[st.name] = 1 | |
self.__methods = tuple(d) | |
return self.__methods | |
class Symbol(object): | |
def __init__(self, name, flags, namespaces=None): | |
self.__name = name | |
self.__flags = flags | |
self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope() | |
self.__namespaces = namespaces or () | |
def __repr__(self): | |
return "<symbol {0!r}>".format(self.__name) | |
def get_name(self): | |
return self.__name | |
def is_referenced(self): | |
return bool(self.__flags & _symtable.USE) | |
def is_parameter(self): | |
return bool(self.__flags & DEF_PARAM) | |
def is_global(self): | |
return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)) | |
def is_declared_global(self): | |
return bool(self.__scope == GLOBAL_EXPLICIT) | |
def is_local(self): | |
return bool(self.__flags & DEF_BOUND) | |
def is_free(self): | |
return bool(self.__scope == FREE) | |
def is_imported(self): | |
return bool(self.__flags & DEF_IMPORT) | |
def is_assigned(self): | |
return bool(self.__flags & DEF_LOCAL) | |
def is_namespace(self): | |
"""Returns true if name binding introduces new namespace. | |
If the name is used as the target of a function or class | |
statement, this will be true. | |
Note that a single name can be bound to multiple objects. If | |
is_namespace() is true, the name may also be bound to other | |
objects, like an int or list, that does not introduce a new | |
namespace. | |
""" | |
return bool(self.__namespaces) | |
def get_namespaces(self): | |
"""Return a list of namespaces bound to this name""" | |
return self.__namespaces | |
def get_namespace(self): | |
"""Returns the single namespace bound to this name. | |
Raises ValueError if the name is bound to multiple namespaces. | |
""" | |
if len(self.__namespaces) != 1: | |
raise ValueError, "name is bound to multiple namespaces" | |
return self.__namespaces[0] | |
if __name__ == "__main__": | |
import os, sys | |
src = open(sys.argv[0]).read() | |
mod = symtable(src, os.path.split(sys.argv[0])[1], "exec") | |
for ident in mod.get_identifiers(): | |
info = mod.lookup(ident) | |
print info, info.is_local(), info.is_namespace() |