summaryrefslogtreecommitdiff
path: root/lib/python2.7/symtable.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/symtable.py')
-rw-r--r--lib/python2.7/symtable.py242
1 files changed, 0 insertions, 242 deletions
diff --git a/lib/python2.7/symtable.py b/lib/python2.7/symtable.py
deleted file mode 100644
index ca73f58..0000000
--- a/lib/python2.7/symtable.py
+++ /dev/null
@@ -1,242 +0,0 @@
-"""Interface to the compiler's internal symbol tables"""
-
-import _symtable
-from _symtable import (USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM,
- DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC,
- SCOPE_OFF, SCOPE_MASK, FREE, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL, LOCAL)
-
-import weakref
-
-__all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"]
-
-def symtable(code, filename, compile_type):
- raw = _symtable.symtable(code, filename, compile_type)
- for top in raw.itervalues():
- if top.name == 'top':
- break
- return _newSymbolTable(top, filename)
-
-class SymbolTableFactory:
- def __init__(self):
- self.__memo = weakref.WeakValueDictionary()
-
- def new(self, table, filename):
- if table.type == _symtable.TYPE_FUNCTION:
- return Function(table, filename)
- if table.type == _symtable.TYPE_CLASS:
- return Class(table, filename)
- return SymbolTable(table, filename)
-
- def __call__(self, table, filename):
- key = table, filename
- obj = self.__memo.get(key, None)
- if obj is None:
- obj = self.__memo[key] = self.new(table, filename)
- return obj
-
-_newSymbolTable = SymbolTableFactory()
-
-
-class SymbolTable(object):
-
- def __init__(self, raw_table, filename):
- self._table = raw_table
- self._filename = filename
- self._symbols = {}
-
- def __repr__(self):
- if self.__class__ == SymbolTable:
- kind = ""
- else:
- kind = "%s " % self.__class__.__name__
-
- if self._table.name == "global":
- return "<{0}SymbolTable for module {1}>".format(kind, self._filename)
- else:
- return "<{0}SymbolTable for {1} in {2}>".format(kind,
- self._table.name,
- self._filename)
-
- def get_type(self):
- if self._table.type == _symtable.TYPE_MODULE:
- return "module"
- if self._table.type == _symtable.TYPE_FUNCTION:
- return "function"
- if self._table.type == _symtable.TYPE_CLASS:
- return "class"
- assert self._table.type in (1, 2, 3), \
- "unexpected type: {0}".format(self._table.type)
-
- def get_id(self):
- return self._table.id
-
- def get_name(self):
- return self._table.name
-
- def get_lineno(self):
- return self._table.lineno
-
- def is_optimized(self):
- return bool(self._table.type == _symtable.TYPE_FUNCTION
- and not self._table.optimized)
-
- def is_nested(self):
- return bool(self._table.nested)
-
- def has_children(self):
- return bool(self._table.children)
-
- def has_exec(self):
- """Return true if the scope uses exec"""
- return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
-
- def has_import_star(self):
- """Return true if the scope uses import *"""
- return bool(self._table.optimized & OPT_IMPORT_STAR)
-
- def get_identifiers(self):
- return self._table.symbols.keys()
-
- def lookup(self, name):
- sym = self._symbols.get(name)
- if sym is None:
- flags = self._table.symbols[name]
- namespaces = self.__check_children(name)
- sym = self._symbols[name] = Symbol(name, flags, namespaces)
- return sym
-
- def get_symbols(self):
- return [self.lookup(ident) for ident in self.get_identifiers()]
-
- def __check_children(self, name):
- return [_newSymbolTable(st, self._filename)
- for st in self._table.children
- if st.name == name]
-
- def get_children(self):
- return [_newSymbolTable(st, self._filename)
- for st in self._table.children]
-
-
-class Function(SymbolTable):
-
- # Default values for instance variables
- __params = None
- __locals = None
- __frees = None
- __globals = None
-
- def __idents_matching(self, test_func):
- return tuple([ident for ident in self.get_identifiers()
- if test_func(self._table.symbols[ident])])
-
- def get_parameters(self):
- if self.__params is None:
- self.__params = self.__idents_matching(lambda x:x & DEF_PARAM)
- return self.__params
-
- def get_locals(self):
- if self.__locals is None:
- locs = (LOCAL, CELL)
- test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs
- self.__locals = self.__idents_matching(test)
- return self.__locals
-
- def get_globals(self):
- if self.__globals is None:
- glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
- test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob
- self.__globals = self.__idents_matching(test)
- return self.__globals
-
- def get_frees(self):
- if self.__frees is None:
- is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE
- self.__frees = self.__idents_matching(is_free)
- return self.__frees
-
-
-class Class(SymbolTable):
-
- __methods = None
-
- def get_methods(self):
- if self.__methods is None:
- d = {}
- for st in self._table.children:
- d[st.name] = 1
- self.__methods = tuple(d)
- return self.__methods
-
-
-class Symbol(object):
-
- def __init__(self, name, flags, namespaces=None):
- self.__name = name
- self.__flags = flags
- self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope()
- self.__namespaces = namespaces or ()
-
- def __repr__(self):
- return "<symbol {0!r}>".format(self.__name)
-
- def get_name(self):
- return self.__name
-
- def is_referenced(self):
- return bool(self.__flags & _symtable.USE)
-
- def is_parameter(self):
- return bool(self.__flags & DEF_PARAM)
-
- def is_global(self):
- return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT))
-
- def is_declared_global(self):
- return bool(self.__scope == GLOBAL_EXPLICIT)
-
- def is_local(self):
- return bool(self.__flags & DEF_BOUND)
-
- def is_free(self):
- return bool(self.__scope == FREE)
-
- def is_imported(self):
- return bool(self.__flags & DEF_IMPORT)
-
- def is_assigned(self):
- return bool(self.__flags & DEF_LOCAL)
-
- def is_namespace(self):
- """Returns true if name binding introduces new namespace.
-
- If the name is used as the target of a function or class
- statement, this will be true.
-
- Note that a single name can be bound to multiple objects. If
- is_namespace() is true, the name may also be bound to other
- objects, like an int or list, that does not introduce a new
- namespace.
- """
- return bool(self.__namespaces)
-
- def get_namespaces(self):
- """Return a list of namespaces bound to this name"""
- return self.__namespaces
-
- def get_namespace(self):
- """Returns the single namespace bound to this name.
-
- Raises ValueError if the name is bound to multiple namespaces.
- """
- if len(self.__namespaces) != 1:
- raise ValueError, "name is bound to multiple namespaces"
- return self.__namespaces[0]
-
-if __name__ == "__main__":
- import os, sys
- src = open(sys.argv[0]).read()
- mod = symtable(src, os.path.split(sys.argv[0])[1], "exec")
- for ident in mod.get_identifiers():
- info = mod.lookup(ident)
- print info, info.is_local(), info.is_namespace()
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-21 05:15:54 +0000