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_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE, \

     6      DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND, \

     7      OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC

     8 

     9 import weakref

    10 

    11 __all__ = ["symtable", "SymbolTable", "newSymbolTable", "Class",

    12            "Function", "Symbol"]

    13 

    14 def symtable(code, filename, compile_type):

    15     raw = _symtable.symtable(code, filename, compile_type)

    16     for top in raw.itervalues():

    17         if top.name == 'top':

    18             break

    19     return newSymbolTable(top, filename)

    20 

    21 class SymbolTableFactory:

    22     def __init__(self):

    23         self.__memo = weakref.WeakValueDictionary()

    24 

    25     def new(self, table, filename):

    26         if table.type == _symtable.TYPE_FUNCTION:

    27             return Function(table, filename)

    28         if table.type == _symtable.TYPE_CLASS:

    29             return Class(table, filename)

    30         return SymbolTable(table, filename)

    31 

    32     def __call__(self, table, filename):

    33         key = table, filename

    34         obj = self.__memo.get(key, None)

    35         if obj is None:

    36             obj = self.__memo[key] = self.new(table, filename)

    37         return obj

    38 

    39 newSymbolTable = SymbolTableFactory()

    40 

    41 def is_free(flags):

    42     if (flags & (USE | DEF_FREE)) \

    43        and (flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)):

    44         return True

    45     if flags & DEF_FREE_CLASS:

    46         return True

    47     return False

    48 

    49 class SymbolTable:

    50     def __init__(self, raw_table, filename):

    51         self._table = raw_table

    52         self._filename = filename

    53         self._symbols = {}

    54 

    55     def __repr__(self):

    56         if self.__class__ == SymbolTable:

    57             kind = ""

    58         else:

    59             kind = "%s " % self.__class__.__name__

    60 

    61         if self._table.name == "global":

    62             return "<%sSymbolTable for module %s>" % (kind, self._filename)

    63         else:

    64             return "<%sSymbolTable for %s in %s>" % (kind, self._table.name,

    65                                                      self._filename)

    66 

    67     def get_type(self):

    68         if self._table.type == _symtable.TYPE_MODULE:

    69             return "module"

    70         if self._table.type == _symtable.TYPE_FUNCTION:

    71             return "function"

    72         if self._table.type == _symtable.TYPE_CLASS:

    73             return "class"

    74         assert self._table.type in (1, 2, 3), \

    75                "unexpected type: %s" % self._table.type

    76 

    77     def get_id(self):

    78         return self._table.id

    79 

    80     def get_name(self):

    81         return self._table.name

    82 

    83     def get_lineno(self):

    84         return self._table.lineno

    85 

    86     def is_optimized(self):

    87         return bool(self._table.type == _symtable.TYPE_FUNCTION

    88                     and not self._table.optimized)

    89 

    90     def is_nested(self):

    91         return bool(self._table.nested)

    92 

    93     def has_children(self):

    94         return bool(self._table.children)

    95 

    96     def has_exec(self):

    97         """Return true if the scope uses exec"""

    98         return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))

    99 

   100     def has_import_star(self):

   101         """Return true if the scope uses import *"""

   102         return bool(self._table.optimized & OPT_IMPORT_STAR)

   103 

   104     def get_identifiers(self):

   105         return self._table.symbols.keys()

   106 

   107     def lookup(self, name):

   108         sym = self._symbols.get(name)

   109         if sym is None:

   110             flags = self._table.symbols[name]

   111             namespaces = self.__check_children(name)

   112             sym = self._symbols[name] = Symbol(name, flags, namespaces)

   113         return sym

   114 

   115     def get_symbols(self):

   116         return [self.lookup(ident) for ident in self.get_identifiers()]

   117 

   118     def __check_children(self, name):

   119         return [newSymbolTable(st, self._filename)

   120                 for st in self._table.children

   121                 if st.name == name]

   122 

   123     def get_children(self):

   124         return [newSymbolTable(st, self._filename)

   125                 for st in self._table.children]

   126 

   127 class Function(SymbolTable):

   128 

   129     # Default values for instance variables

   130     __params = None

   131     __locals = None

   132     __frees = None

   133     __globals = None

   134 

   135     def __idents_matching(self, test_func):

   136         return tuple([ident for ident in self.get_identifiers()

   137                       if test_func(self._table.symbols[ident])])

   138 

   139     def get_parameters(self):

   140         if self.__params is None:

   141             self.__params = self.__idents_matching(lambda x:x & DEF_PARAM)

   142         return self.__params

   143 

   144     def get_locals(self):

   145         if self.__locals is None:

   146             self.__locals = self.__idents_matching(lambda x:x & DEF_BOUND)

   147         return self.__locals

   148 

   149     def get_globals(self):

   150         if self.__globals is None:

   151             glob = DEF_GLOBAL | DEF_FREE_GLOBAL

   152             self.__globals = self.__idents_matching(lambda x:x & glob)

   153         return self.__globals

   154 

   155     def get_frees(self):

   156         if self.__frees is None:

   157             self.__frees = self.__idents_matching(is_free)

   158         return self.__frees

   159 

   160 class Class(SymbolTable):

   161 

   162     __methods = None

   163 

   164     def get_methods(self):

   165         if self.__methods is None:

   166             d = {}

   167             for st in self._table.children:

   168                 d[st.name] = 1

   169             self.__methods = tuple(d)

   170         return self.__methods

   171 

   172 class Symbol:

   173     def __init__(self, name, flags, namespaces=None):

   174         self.__name = name

   175         self.__flags = flags

   176         self.__namespaces = namespaces or ()

   177 

   178     def __repr__(self):

   179         return "<symbol '%s'>" % 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.__flags & DEF_GLOBAL)

   192                     or (self.__flags & DEF_FREE_GLOBAL))

   193 

   194     def is_vararg(self):

   195         return bool(self.__flags & DEF_STAR)

   196 

   197     def is_keywordarg(self):

   198         return bool(self.__flags & DEF_DOUBLESTAR)

   199 

   200     def is_local(self):

   201         return bool(self.__flags & DEF_BOUND)

   202 

   203     def is_free(self):

   204         if (self.__flags & (USE | DEF_FREE)) \

   205             and (self.__flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)):

   206             return True

   207         if self.__flags & DEF_FREE_CLASS:

   208             return True

   209         return False

   210 

   211     def is_imported(self):

   212         return bool(self.__flags & DEF_IMPORT)

   213 

   214     def is_assigned(self):

   215         return bool(self.__flags & DEF_LOCAL)

   216 

   217     def is_in_tuple(self):

   218         return bool(self.__flags & DEF_INTUPLE)

   219 

   220     def is_namespace(self):

   221         """Returns true if name binding introduces new namespace.

   222 

   223         If the name is used as the target of a function or class

   224         statement, this will be true.

   225 

   226         Note that a single name can be bound to multiple objects.  If

   227         is_namespace() is true, the name may also be bound to other

   228         objects, like an int or list, that does not introduce a new

   229         namespace.

   230         """

   231         return bool(self.__namespaces)

   232 

   233     def get_namespaces(self):

   234         """Return a list of namespaces bound to this name"""

   235         return self.__namespaces

   236 

   237     def get_namespace(self):

   238         """Returns the single namespace bound to this name.

   239 

   240         Raises ValueError if the name is bound to multiple namespaces.

   241         """

   242         if len(self.__namespaces) != 1:

   243             raise ValueError, "name is bound to multiple namespaces"

   244         return self.__namespaces[0]

   245 

   246 if __name__ == "__main__":

   247     import os, sys

   248     src = open(sys.argv[0]).read()

   249     mod = symtable(src, os.path.split(sys.argv[0])[1], "exec")

   250     for ident in mod.get_identifiers():

   251         info = mod.lookup(ident)

   252         print info, info.is_local(), info.is_namespace()