home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / symtable.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  9.7 KB  |  265 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import _symtable
  5. 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
  6. import weakref
  7. __all__ = [
  8.     'symtable',
  9.     'SymbolTable',
  10.     'Class',
  11.     'Function',
  12.     '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.             continue
  20.     return _newSymbolTable(top, filename)
  21.  
  22.  
  23. class SymbolTableFactory:
  24.     
  25.     def __init__(self):
  26.         self._SymbolTableFactory__memo = weakref.WeakValueDictionary()
  27.  
  28.     
  29.     def new(self, table, filename):
  30.         if table.type == _symtable.TYPE_FUNCTION:
  31.             return Function(table, filename)
  32.         if None.type == _symtable.TYPE_CLASS:
  33.             return Class(table, filename)
  34.         return None(table, filename)
  35.  
  36.     
  37.     def __call__(self, table, filename):
  38.         key = (table, filename)
  39.         obj = self._SymbolTableFactory__memo.get(key, None)
  40.         if obj is None:
  41.             obj = self._SymbolTableFactory__memo[key] = self.new(table, filename)
  42.         return obj
  43.  
  44.  
  45. _newSymbolTable = SymbolTableFactory()
  46.  
  47. class SymbolTable(object):
  48.     
  49.     def __init__(self, raw_table, filename):
  50.         self._table = raw_table
  51.         self._filename = filename
  52.         self._symbols = { }
  53.  
  54.     
  55.     def __repr__(self):
  56.         if self.__class__ == SymbolTable:
  57.             kind = ''
  58.         else:
  59.             kind = '%s ' % self.__class__.__name__
  60.         if self._table.name == 'global':
  61.             return '<{0}SymbolTable for module {1}>'.format(kind, self._filename)
  62.         return None.format(kind, self._table.name, self._filename)
  63.  
  64.     
  65.     def get_type(self):
  66.         if self._table.type == _symtable.TYPE_MODULE:
  67.             return 'module'
  68.         if None._table.type == _symtable.TYPE_FUNCTION:
  69.             return 'function'
  70.         if None._table.type == _symtable.TYPE_CLASS:
  71.             return 'class'
  72.  
  73.     
  74.     def get_id(self):
  75.         return self._table.id
  76.  
  77.     
  78.     def get_name(self):
  79.         return self._table.name
  80.  
  81.     
  82.     def get_lineno(self):
  83.         return self._table.lineno
  84.  
  85.     
  86.     def is_optimized(self):
  87.         if self._table.type == _symtable.TYPE_FUNCTION:
  88.             pass
  89.         return bool(not (self._table.optimized))
  90.  
  91.     
  92.     def is_nested(self):
  93.         return bool(self._table.nested)
  94.  
  95.     
  96.     def has_children(self):
  97.         return bool(self._table.children)
  98.  
  99.     
  100.     def has_exec(self):
  101.         return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
  102.  
  103.     
  104.     def has_import_star(self):
  105.         return bool(self._table.optimized & OPT_IMPORT_STAR)
  106.  
  107.     
  108.     def get_identifiers(self):
  109.         return self._table.symbols.keys()
  110.  
  111.     
  112.     def lookup(self, name):
  113.         sym = self._symbols.get(name)
  114.         if sym is None:
  115.             flags = self._table.symbols[name]
  116.             namespaces = self._SymbolTable__check_children(name)
  117.             sym = self._symbols[name] = Symbol(name, flags, namespaces)
  118.         return sym
  119.  
  120.     
  121.     def get_symbols(self):
  122.         return [ self.lookup(ident) for ident in self.get_identifiers() ]
  123.  
  124.     
  125.     def __check_children(self, name):
  126.         return [ _newSymbolTable(st, self._filename) for st in self._table.children if st.name == name ]
  127.  
  128.     
  129.     def get_children(self):
  130.         return [ _newSymbolTable(st, self._filename) for st in self._table.children ]
  131.  
  132.  
  133.  
  134. class Function(SymbolTable):
  135.     __params = None
  136.     __locals = None
  137.     __frees = None
  138.     __globals = None
  139.     
  140.     def __idents_matching(self, test_func):
  141.         return tuple([ ident for ident in self.get_identifiers() if test_func(self._table.symbols[ident]) ])
  142.  
  143.     
  144.     def get_parameters(self):
  145.         if self._Function__params is None:
  146.             self._Function__params = self._Function__idents_matching((lambda x: x & DEF_PARAM))
  147.         return self._Function__params
  148.  
  149.     
  150.     def get_locals(self):
  151.         if self._Function__locals is None:
  152.             locs = (LOCAL, CELL)
  153.             
  154.             test = lambda x: x >> SCOPE_OFF & SCOPE_MASK in locs
  155.             self._Function__locals = self._Function__idents_matching(test)
  156.         return self._Function__locals
  157.  
  158.     
  159.     def get_globals(self):
  160.         if self._Function__globals is None:
  161.             glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
  162.             
  163.             test = lambda x: x >> SCOPE_OFF & SCOPE_MASK in glob
  164.             self._Function__globals = self._Function__idents_matching(test)
  165.         return self._Function__globals
  166.  
  167.     
  168.     def get_frees(self):
  169.         if self._Function__frees is None:
  170.             
  171.             is_free = lambda x: x >> SCOPE_OFF & SCOPE_MASK == FREE
  172.             self._Function__frees = self._Function__idents_matching(is_free)
  173.         return self._Function__frees
  174.  
  175.  
  176.  
  177. class Class(SymbolTable):
  178.     __methods = None
  179.     
  180.     def get_methods(self):
  181.         if self._Class__methods is None:
  182.             d = { }
  183.             for st in self._table.children:
  184.                 d[st.name] = 1
  185.             
  186.             self._Class__methods = tuple(d)
  187.         return self._Class__methods
  188.  
  189.  
  190.  
  191. class Symbol(object):
  192.     
  193.     def __init__(self, name, flags, namespaces = None):
  194.         self._Symbol__name = name
  195.         self._Symbol__flags = flags
  196.         self._Symbol__scope = flags >> SCOPE_OFF & SCOPE_MASK
  197.         if not namespaces:
  198.             pass
  199.         self._Symbol__namespaces = ()
  200.  
  201.     
  202.     def __repr__(self):
  203.         return '<symbol {0!r}>'.format(self._Symbol__name)
  204.  
  205.     
  206.     def get_name(self):
  207.         return self._Symbol__name
  208.  
  209.     
  210.     def is_referenced(self):
  211.         return bool(self._Symbol__flags & _symtable.USE)
  212.  
  213.     
  214.     def is_parameter(self):
  215.         return bool(self._Symbol__flags & DEF_PARAM)
  216.  
  217.     
  218.     def is_global(self):
  219.         return bool(self._Symbol__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT))
  220.  
  221.     
  222.     def is_declared_global(self):
  223.         return bool(self._Symbol__scope == GLOBAL_EXPLICIT)
  224.  
  225.     
  226.     def is_local(self):
  227.         return bool(self._Symbol__flags & DEF_BOUND)
  228.  
  229.     
  230.     def is_free(self):
  231.         return bool(self._Symbol__scope == FREE)
  232.  
  233.     
  234.     def is_imported(self):
  235.         return bool(self._Symbol__flags & DEF_IMPORT)
  236.  
  237.     
  238.     def is_assigned(self):
  239.         return bool(self._Symbol__flags & DEF_LOCAL)
  240.  
  241.     
  242.     def is_namespace(self):
  243.         return bool(self._Symbol__namespaces)
  244.  
  245.     
  246.     def get_namespaces(self):
  247.         return self._Symbol__namespaces
  248.  
  249.     
  250.     def get_namespace(self):
  251.         if len(self._Symbol__namespaces) != 1:
  252.             raise ValueError, 'name is bound to multiple namespaces'
  253.         return self._Symbol__namespaces[0]
  254.  
  255.  
  256. if __name__ == '__main__':
  257.     import os
  258.     import sys
  259.     src = open(sys.argv[0]).read()
  260.     mod = symtable(src, os.path.split(sys.argv[0])[1], 'exec')
  261.     for ident in mod.get_identifiers():
  262.         info = mod.lookup(ident)
  263.         print info, info.is_local(), info.is_namespace()
  264.     
  265.