1 """Interface to the compiler's internal symbol tables""" 2 3 import _symtable 4 from _symtable import (USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, 5 DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC, 6 SCOPE_OFF, SCOPE_MASK, FREE, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL, LOCAL) 7 8 import weakref 9 10 __all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"] 11 12 def symtable(code, filename, compile_type): 13 raw = _symtable.symtable(code, filename, compile_type) 14 for top in raw.itervalues(): 15 if top.name == 'top': 16 break 17 return _newSymbolTable(top, filename) 18 19 class SymbolTableFactory: 20 def __init__(self): 21 self.__memo = weakref.WeakValueDictionary() 22 23 def new(self, table, filename): 24 if table.type == _symtable.TYPE_FUNCTION: 25 return Function(table, filename) 26 if table.type == _symtable.TYPE_CLASS: 27 return Class(table, filename) 28 return SymbolTable(table, filename) 29 30 def __call__(self, table, filename): 31 key = table, filename 32 obj = self.__memo.get(key, None) 33 if obj is None: 34 obj = self.__memo[key] = self.new(table, filename) 35 return obj 36 37 _newSymbolTable = SymbolTableFactory() 38 39 40 class SymbolTable(object): 41 42 def __init__(self, raw_table, filename): 43 self._table = raw_table 44 self._filename = filename 45 self._symbols = {} 46 47 def __repr__(self): 48 if self.__class__ == SymbolTable: 49 kind = "" 50 else: 51 kind = "%s " % self.__class__.__name__ 52 53 if self._table.name == "global": 54 return "<{0}SymbolTable for module {1}>".format(kind, self._filename) 55 else: 56 return "<{0}SymbolTable for {1} in {2}>".format(kind, 57 self._table.name, 58 self._filename) 59 60 def get_type(self): 61 if self._table.type == _symtable.TYPE_MODULE: 62 return "module" 63 if self._table.type == _symtable.TYPE_FUNCTION: 64 return "function" 65 if self._table.type == _symtable.TYPE_CLASS: 66 return "class" 67 assert self._table.type in (1, 2, 3), \ 68 "unexpected type: {0}".format(self._table.type) 69 70 def get_id(self): 71 return self._table.id 72 73 def get_name(self): 74 return self._table.name 75 76 def get_lineno(self): 77 return self._table.lineno 78 79 def is_optimized(self): 80 return bool(self._table.type == _symtable.TYPE_FUNCTION 81 and not self._table.optimized) 82 83 def is_nested(self): 84 return bool(self._table.nested) 85 86 def has_children(self): 87 return bool(self._table.children) 88 89 def has_exec(self): 90 """Return true if the scope uses exec""" 91 return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC)) 92 93 def has_import_star(self): 94 """Return true if the scope uses import *""" 95 return bool(self._table.optimized & OPT_IMPORT_STAR) 96 97 def get_identifiers(self): 98 return self._table.symbols.keys() 99 100 def lookup(self, name): 101 sym = self._symbols.get(name) 102 if sym is None: 103 flags = self._table.symbols[name] 104 namespaces = self.__check_children(name) 105 sym = self._symbols[name] = Symbol(name, flags, namespaces) 106 return sym 107 108 def get_symbols(self): 109 return [self.lookup(ident) for ident in self.get_identifiers()] 110 111 def __check_children(self, name): 112 return [_newSymbolTable(st, self._filename) 113 for st in self._table.children 114 if st.name == name] 115 116 def get_children(self): 117 return [_newSymbolTable(st, self._filename) 118 for st in self._table.children] 119 120 121 class Function(SymbolTable): 122 123 # Default values for instance variables 124 __params = None 125 __locals = None 126 __frees = None 127 __globals = None 128 129 def __idents_matching(self, test_func): 130 return tuple([ident for ident in self.get_identifiers() 131 if test_func(self._table.symbols[ident])]) 132 133 def get_parameters(self): 134 if self.__params is None: 135 self.__params = self.__idents_matching(lambda x:x & DEF_PARAM) 136 return self.__params 137 138 def get_locals(self): 139 if self.__locals is None: 140 locs = (LOCAL, CELL) 141 test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs 142 self.__locals = self.__idents_matching(test) 143 return self.__locals 144 145 def get_globals(self): 146 if self.__globals is None: 147 glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT) 148 test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob 149 self.__globals = self.__idents_matching(test) 150 return self.__globals 151 152 def get_frees(self): 153 if self.__frees is None: 154 is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE 155 self.__frees = self.__idents_matching(is_free) 156 return self.__frees 157 158 159 class Class(SymbolTable): 160 161 __methods = None 162 163 def get_methods(self): 164 if self.__methods is None: 165 d = {} 166 for st in self._table.children: 167 d[st.name] = 1 168 self.__methods = tuple(d) 169 return self.__methods 170 171 172 class Symbol(object): 173 174 def __init__(self, name, flags, namespaces=None): 175 self.__name = name 176 self.__flags = flags 177 self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope() 178 self.__namespaces = namespaces or () 179 180 def __repr__(self): 181 return "<symbol {0!r}>".format(self.__name) 182 183 def get_name(self): 184 return self.__name 185 186 def is_referenced(self): 187 return bool(self.__flags & _symtable.USE) 188 189 def is_parameter(self): 190 return bool(self.__flags & DEF_PARAM) 191 192 def is_global(self): 193 return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)) 194 195 def is_declared_global(self): 196 return bool(self.__scope == GLOBAL_EXPLICIT) 197 198 def is_local(self): 199 return bool(self.__flags & DEF_BOUND) 200 201 def is_free(self): 202 return bool(self.__scope == FREE) 203 204 def is_imported(self): 205 return bool(self.__flags & DEF_IMPORT) 206 207 def is_assigned(self): 208 return bool(self.__flags & DEF_LOCAL) 209 210 def is_namespace(self): 211 """Returns true if name binding introduces new namespace. 212 213 If the name is used as the target of a function or class 214 statement, this will be true. 215 216 Note that a single name can be bound to multiple objects. If 217 is_namespace() is true, the name may also be bound to other 218 objects, like an int or list, that does not introduce a new 219 namespace. 220 """ 221 return bool(self.__namespaces) 222 223 def get_namespaces(self): 224 """Return a list of namespaces bound to this name""" 225 return self.__namespaces 226 227 def get_namespace(self): 228 """Returns the single namespace bound to this name. 229 230 Raises ValueError if the name is bound to multiple namespaces. 231 """ 232 if len(self.__namespaces) != 1: 233 raise ValueError, "name is bound to multiple namespaces" 234 return self.__namespaces[0] 235 236 if __name__ == "__main__": 237 import os, sys 238 src = open(sys.argv[0]).read() 239 mod = symtable(src, os.path.split(sys.argv[0])[1], "exec") 240 for ident in mod.get_identifiers(): 241 info = mod.lookup(ident) 242 print info, info.is_local(), info.is_namespace() 243
