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 warnings

     9 import weakref

    10 

    11 __all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"]

    12 

    13 def symtable(code, filename, compile_type):

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

    15     for top in raw.itervalues():

    16         if top.name == 'top':

    17             break

    18     return _newSymbolTable(top, filename)

    19 

    20 class SymbolTableFactory:

    21     def __init__(self):

    22         self.__memo = weakref.WeakValueDictionary()

    23 

    24     def new(self, table, filename):

    25         if table.type == _symtable.TYPE_FUNCTION:

    26             return Function(table, filename)

    27         if table.type == _symtable.TYPE_CLASS:

    28             return Class(table, filename)

    29         return SymbolTable(table, filename)

    30 

    31     def __call__(self, table, filename):

    32         key = table, filename

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

    34         if obj is None:

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

    36         return obj

    37 

    38 _newSymbolTable = SymbolTableFactory()

    39 

    40 

    41 class SymbolTable(object):

    42 

    43     def __init__(self, raw_table, filename):

    44         self._table = raw_table

    45         self._filename = filename

    46         self._symbols = {}

    47 

    48     def __repr__(self):

    49         if self.__class__ == SymbolTable:

    50             kind = ""

    51         else:

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

    53 

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

    55             return "<{0}SymbolTable for module {1}>".format(kind, self._filename)

    56         else:

    57             return "<{0}SymbolTable for {1} in {2}>".format(kind,

    58                                                             self._table.name,

    59                                                             self._filename)

    60 

    61     def get_type(self):

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

    63             return "module"

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

    65             return "function"

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

    67             return "class"

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

    69                "unexpected type: {0}".format(self._table.type)

    70 

    71     def get_id(self):

    72         return self._table.id

    73 

    74     def get_name(self):

    75         return self._table.name

    76 

    77     def get_lineno(self):

    78         return self._table.lineno

    79 

    80     def is_optimized(self):

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

    82                     and not self._table.optimized)

    83 

    84     def is_nested(self):

    85         return bool(self._table.nested)

    86 

    87     def has_children(self):

    88         return bool(self._table.children)

    89 

    90     def has_exec(self):

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

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

    93 

    94     def has_import_star(self):

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

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

    97 

    98     def get_identifiers(self):

    99         return self._table.symbols.keys()

   100 

   101     def lookup(self, name):

   102         sym = self._symbols.get(name)

   103         if sym is None:

   104             flags = self._table.symbols[name]

   105             namespaces = self.__check_children(name)

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

   107         return sym

   108 

   109     def get_symbols(self):

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

   111 

   112     def __check_children(self, name):

   113         return [_newSymbolTable(st, self._filename)

   114                 for st in self._table.children

   115                 if st.name == name]

   116 

   117     def get_children(self):

   118         return [_newSymbolTable(st, self._filename)

   119                 for st in self._table.children]

   120 

   121 

   122 class Function(SymbolTable):

   123 

   124     # Default values for instance variables

   125     __params = None

   126     __locals = None

   127     __frees = None

   128     __globals = None

   129 

   130     def __idents_matching(self, test_func):

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

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

   133 

   134     def get_parameters(self):

   135         if self.__params is None:

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

   137         return self.__params

   138 

   139     def get_locals(self):

   140         if self.__locals is None:

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

   142         return self.__locals

   143 

   144     def get_globals(self):

   145         if self.__globals is None:

   146             glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)

   147             test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob

   148             self.__globals = self.__idents_matching(test)

   149         return self.__globals

   150 

   151     def get_frees(self):

   152         if self.__frees is None:

   153             is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE

   154             self.__frees = self.__idents_matching(is_free)

   155         return self.__frees

   156 

   157 

   158 class Class(SymbolTable):

   159 

   160     __methods = None

   161 

   162     def get_methods(self):

   163         if self.__methods is None:

   164             d = {}

   165             for st in self._table.children:

   166                 d[st.name] = 1

   167             self.__methods = tuple(d)

   168         return self.__methods

   169 

   170 

   171 class Symbol(object):

   172 

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

   174         self.__name = name

   175         self.__flags = flags

   176         self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope()

   177         self.__namespaces = namespaces or ()

   178 

   179     def __repr__(self):

   180         return "<symbol {0!r}>".format(self.__name)

   181 

   182     def get_name(self):

   183         return self.__name

   184 

   185     def is_referenced(self):

   186         return bool(self.__flags & _symtable.USE)

   187 

   188     def is_parameter(self):

   189         return bool(self.__flags & DEF_PARAM)

   190 

   191     def is_global(self):

   192         return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT))

   193 

   194     def is_vararg(self):

   195         warnings.warn("is_vararg() is obsolete and will be removed",

   196                       DeprecationWarning, 2)

   197         return False

   198 

   199     def is_keywordarg(self):

   200         warnings.warn("is_keywordarg() is obsolete and will be removed",

   201                       DeprecationWarning, 2)

   202         return False

   203 

   204     def is_local(self):

   205         return bool(self.__flags & DEF_BOUND)

   206 

   207     def is_free(self):

   208         return bool(self.__scope == FREE)

   209 

   210     def is_imported(self):

   211         return bool(self.__flags & DEF_IMPORT)

   212 

   213     def is_assigned(self):

   214         return bool(self.__flags & DEF_LOCAL)

   215 

   216     def is_in_tuple(self):

   217         warnings.warn("is_in_tuple() is obsolete and will be removed",

   218                       DeprecationWarning, 2)

   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()