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