Lib/symtable.py

   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)
   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             self.__locals = self.__idents_matching(lambda x:x & DEF_BOUND)
 141         return self.__locals
 142
 143     def get_globals(self):
 144         if self.__globals is None:
 145             glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
 146             test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob
 147             self.__globals = self.__idents_matching(test)
 148         return self.__globals
 149
 150     def get_frees(self):
 151         if self.__frees is None:
 152             is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE
 153             self.__frees = self.__idents_matching(is_free)
 154         return self.__frees
 155
 156
 157 class Class(SymbolTable):
 158
 159     __methods = None
 160
 161     def get_methods(self):
 162         if self.__methods is None:
 163             d = {}
 164             for st in self._table.children:
 165                 d[st.name] = 1
 166             self.__methods = tuple(d)
 167         return self.__methods
 168
 169
 170 class Symbol(object):
 171
 172     def __init__(self, name, flags, namespaces=None):
 173         self.__name = name
 174         self.__flags = flags
 175         self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope()
 176         self.__namespaces = namespaces or ()
 177
 178     def __repr__(self):
 179         return "<symbol {0!r}>".format(self.__name)
 180
 181     def get_name(self):
 182         return self.__name
 183
 184     def is_referenced(self):
 185         return bool(self.__flags & _symtable.USE)
 186
 187     def is_parameter(self):
 188         return bool(self.__flags & DEF_PARAM)
 189
 190     def is_global(self):
 191         return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT))
 192
 193     def is_declared_global(self):
 194         return bool(self.__scope == GLOBAL_EXPLICIT)
 195
 196     def is_local(self):
 197         return bool(self.__flags & DEF_BOUND)
 198
 199     def is_free(self):
 200         return bool(self.__scope == FREE)
 201
 202     def is_imported(self):
 203         return bool(self.__flags & DEF_IMPORT)
 204
 205     def is_assigned(self):
 206         return bool(self.__flags & DEF_LOCAL)
 207
 208     def is_namespace(self):
 209         """Returns true if name binding introduces new namespace.
 210
 211         If the name is used as the target of a function or class
 212         statement, this will be true.
 213
 214         Note that a single name can be bound to multiple objects.  If
 215         is_namespace() is true, the name may also be bound to other
 216         objects, like an int or list, that does not introduce a new
 217         namespace.
 218         """
 219         return bool(self.__namespaces)
 220
 221     def get_namespaces(self):
 222         """Return a list of namespaces bound to this name"""
 223         return self.__namespaces
 224
 225     def get_namespace(self):
 226         """Returns the single namespace bound to this name.
 227
 228         Raises ValueError if the name is bound to multiple namespaces.
 229         """
 230         if len(self.__namespaces) != 1:
 231             raise ValueError, "name is bound to multiple namespaces"
 232         return self.__namespaces[0]
 233
 234 if __name__ == "__main__":
 235     import os, sys
 236     src = open(sys.argv[0]).read()
 237     mod = symtable(src, os.path.split(sys.argv[0])[1], "exec")
 238     for ident in mod.get_identifiers():
 239         info = mod.lookup(ident)
 240         print info, info.is_local(), info.is_namespace()