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