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