home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_326 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  14.8 KB  |  451 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from compiler import ast
  5. from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL, SC_UNKNOWN
  6. from compiler.misc import mangle
  7. import types
  8. import sys
  9. MANGLE_LEN = 256
  10.  
  11. class Scope:
  12.     
  13.     def __init__(self, name, module, klass = None):
  14.         self.name = name
  15.         self.module = module
  16.         self.defs = { }
  17.         self.uses = { }
  18.         self.globals = { }
  19.         self.params = { }
  20.         self.frees = { }
  21.         self.cells = { }
  22.         self.children = []
  23.         self.nested = None
  24.         self.generator = None
  25.         self.klass = None
  26.         if klass is not None:
  27.             for i in range(len(klass)):
  28.                 if klass[i] != '_':
  29.                     self.klass = klass[i:]
  30.                     break
  31.                     continue
  32.             
  33.         
  34.  
  35.     
  36.     def __repr__(self):
  37.         return '<%s: %s>' % (self.__class__.__name__, self.name)
  38.  
  39.     
  40.     def mangle(self, name):
  41.         if self.klass is None:
  42.             return name
  43.         return mangle(name, self.klass)
  44.  
  45.     
  46.     def add_def(self, name):
  47.         self.defs[self.mangle(name)] = 1
  48.  
  49.     
  50.     def add_use(self, name):
  51.         self.uses[self.mangle(name)] = 1
  52.  
  53.     
  54.     def add_global(self, name):
  55.         name = self.mangle(name)
  56.         if name in self.uses or name in self.defs:
  57.             pass
  58.         
  59.         if name in self.params:
  60.             raise SyntaxError, '%s in %s is global and parameter' % (name, self.name)
  61.         name in self.params
  62.         self.globals[name] = 1
  63.         self.module.add_def(name)
  64.  
  65.     
  66.     def add_param(self, name):
  67.         name = self.mangle(name)
  68.         self.defs[name] = 1
  69.         self.params[name] = 1
  70.  
  71.     
  72.     def get_names(self):
  73.         d = { }
  74.         d.update(self.defs)
  75.         d.update(self.uses)
  76.         d.update(self.globals)
  77.         return d.keys()
  78.  
  79.     
  80.     def add_child(self, child):
  81.         self.children.append(child)
  82.  
  83.     
  84.     def get_children(self):
  85.         return self.children
  86.  
  87.     
  88.     def DEBUG(self):
  89.         print >>sys.stderr, self.name,
  90.         if not self.nested or 'nested':
  91.             pass
  92.         print >>sys.stderr, ''
  93.         print >>sys.stderr, '\tglobals: ', self.globals
  94.         print >>sys.stderr, '\tcells: ', self.cells
  95.         print >>sys.stderr, '\tdefs: ', self.defs
  96.         print >>sys.stderr, '\tuses: ', self.uses
  97.         print >>sys.stderr, '\tfrees:', self.frees
  98.  
  99.     
  100.     def check_name(self, name):
  101.         if name in self.globals:
  102.             return SC_GLOBAL
  103.         if name in self.cells:
  104.             return SC_CELL
  105.         if name in self.defs:
  106.             return SC_LOCAL
  107.         if self.nested:
  108.             if name in self.frees or name in self.uses:
  109.                 return SC_FREE
  110.             if self.nested:
  111.                 return SC_UNKNOWN
  112.             return SC_GLOBAL
  113.         return self.nested
  114.  
  115.     
  116.     def get_free_vars(self):
  117.         if not self.nested:
  118.             return ()
  119.         free = { }
  120.         free.update(self.frees)
  121.         for name in self.uses.keys():
  122.             if name not in self.defs and name not in self.globals:
  123.                 free[name] = 1
  124.                 continue
  125.             self.nested
  126.         
  127.         return free.keys()
  128.  
  129.     
  130.     def handle_children(self):
  131.         for child in self.children:
  132.             frees = child.get_free_vars()
  133.             globals = self.add_frees(frees)
  134.             for name in globals:
  135.                 child.force_global(name)
  136.             
  137.         
  138.  
  139.     
  140.     def force_global(self, name):
  141.         self.globals[name] = 1
  142.         if name in self.frees:
  143.             del self.frees[name]
  144.         
  145.         for child in self.children:
  146.             if child.check_name(name) == SC_FREE:
  147.                 child.force_global(name)
  148.                 continue
  149.         
  150.  
  151.     
  152.     def add_frees(self, names):
  153.         child_globals = []
  154.         for name in names:
  155.             sc = self.check_name(name)
  156.             if self.nested:
  157.                 if sc == SC_UNKNOWN and sc == SC_FREE or isinstance(self, ClassScope):
  158.                     self.frees[name] = 1
  159.                 elif sc == SC_GLOBAL:
  160.                     child_globals.append(name)
  161.                 elif isinstance(self, FunctionScope) and sc == SC_LOCAL:
  162.                     self.cells[name] = 1
  163.                 elif sc != SC_CELL:
  164.                     child_globals.append(name)
  165.                 
  166.             sc == SC_LOCAL
  167.             if sc == SC_LOCAL:
  168.                 self.cells[name] = 1
  169.                 continue
  170.             if sc != SC_CELL:
  171.                 child_globals.append(name)
  172.                 continue
  173.         
  174.         return child_globals
  175.  
  176.     
  177.     def get_cell_vars(self):
  178.         return self.cells.keys()
  179.  
  180.  
  181.  
  182. class ModuleScope(Scope):
  183.     __super_init = Scope.__init__
  184.     
  185.     def __init__(self):
  186.         self._ModuleScope__super_init('global', self)
  187.  
  188.  
  189.  
  190. class FunctionScope(Scope):
  191.     pass
  192.  
  193.  
  194. class GenExprScope(Scope):
  195.     __super_init = Scope.__init__
  196.     __counter = 1
  197.     
  198.     def __init__(self, module, klass = None):
  199.         i = self._GenExprScope__counter
  200.         self._GenExprScope__counter += 1
  201.         self._GenExprScope__super_init('generator expression<%d>' % i, module, klass)
  202.         self.add_param('.0')
  203.  
  204.     
  205.     def get_names(self):
  206.         keys = Scope.get_names(self)
  207.         return keys
  208.  
  209.  
  210.  
  211. class LambdaScope(FunctionScope):
  212.     __super_init = Scope.__init__
  213.     __counter = 1
  214.     
  215.     def __init__(self, module, klass = None):
  216.         i = self._LambdaScope__counter
  217.         self._LambdaScope__counter += 1
  218.         self._LambdaScope__super_init('lambda.%d' % i, module, klass)
  219.  
  220.  
  221.  
  222. class ClassScope(Scope):
  223.     __super_init = Scope.__init__
  224.     
  225.     def __init__(self, name, module):
  226.         self._ClassScope__super_init(name, module, name)
  227.  
  228.  
  229.  
  230. class SymbolVisitor:
  231.     
  232.     def __init__(self):
  233.         self.scopes = { }
  234.         self.klass = None
  235.  
  236.     
  237.     def visitModule(self, node):
  238.         scope = self.module = self.scopes[node] = ModuleScope()
  239.         self.visit(node.node, scope)
  240.  
  241.     visitExpression = visitModule
  242.     
  243.     def visitFunction(self, node, parent):
  244.         if node.decorators:
  245.             self.visit(node.decorators, parent)
  246.         
  247.         parent.add_def(node.name)
  248.         for n in node.defaults:
  249.             self.visit(n, parent)
  250.         
  251.         scope = FunctionScope(node.name, self.module, self.klass)
  252.         if parent.nested or isinstance(parent, FunctionScope):
  253.             scope.nested = 1
  254.         
  255.         self.scopes[node] = scope
  256.         self._do_args(scope, node.argnames)
  257.         self.visit(node.code, scope)
  258.         self.handle_free_vars(scope, parent)
  259.  
  260.     
  261.     def visitGenExpr(self, node, parent):
  262.         scope = GenExprScope(self.module, self.klass)
  263.         if parent.nested and isinstance(parent, FunctionScope) or isinstance(parent, GenExprScope):
  264.             scope.nested = 1
  265.         
  266.         self.scopes[node] = scope
  267.         self.visit(node.code, scope)
  268.         self.handle_free_vars(scope, parent)
  269.  
  270.     
  271.     def visitGenExprInner(self, node, scope):
  272.         for genfor in node.quals:
  273.             self.visit(genfor, scope)
  274.         
  275.         self.visit(node.expr, scope)
  276.  
  277.     
  278.     def visitGenExprFor(self, node, scope):
  279.         self.visit(node.assign, scope, 1)
  280.         self.visit(node.iter, scope)
  281.         for if_ in node.ifs:
  282.             self.visit(if_, scope)
  283.         
  284.  
  285.     
  286.     def visitGenExprIf(self, node, scope):
  287.         self.visit(node.test, scope)
  288.  
  289.     
  290.     def visitLambda(self, node, parent, assign = 0):
  291.         for n in node.defaults:
  292.             self.visit(n, parent)
  293.         
  294.         scope = LambdaScope(self.module, self.klass)
  295.         if parent.nested or isinstance(parent, FunctionScope):
  296.             scope.nested = 1
  297.         
  298.         self.scopes[node] = scope
  299.         self._do_args(scope, node.argnames)
  300.         self.visit(node.code, scope)
  301.         self.handle_free_vars(scope, parent)
  302.  
  303.     
  304.     def _do_args(self, scope, args):
  305.         for name in args:
  306.             if type(name) == types.TupleType:
  307.                 self._do_args(scope, name)
  308.                 continue
  309.             scope.add_param(name)
  310.         
  311.  
  312.     
  313.     def handle_free_vars(self, scope, parent):
  314.         parent.add_child(scope)
  315.         scope.handle_children()
  316.  
  317.     
  318.     def visitClass(self, node, parent):
  319.         parent.add_def(node.name)
  320.         for n in node.bases:
  321.             self.visit(n, parent)
  322.         
  323.         scope = ClassScope(node.name, self.module)
  324.         if parent.nested or isinstance(parent, FunctionScope):
  325.             scope.nested = 1
  326.         
  327.         if node.doc is not None:
  328.             scope.add_def('__doc__')
  329.         
  330.         scope.add_def('__module__')
  331.         self.scopes[node] = scope
  332.         prev = self.klass
  333.         self.klass = node.name
  334.         self.visit(node.code, scope)
  335.         self.klass = prev
  336.         self.handle_free_vars(scope, parent)
  337.  
  338.     
  339.     def visitName(self, node, scope, assign = 0):
  340.         if assign:
  341.             scope.add_def(node.name)
  342.         else:
  343.             scope.add_use(node.name)
  344.  
  345.     
  346.     def visitFor(self, node, scope):
  347.         self.visit(node.assign, scope, 1)
  348.         self.visit(node.list, scope)
  349.         self.visit(node.body, scope)
  350.         if node.else_:
  351.             self.visit(node.else_, scope)
  352.         
  353.  
  354.     
  355.     def visitFrom(self, node, scope):
  356.         for name, asname in node.names:
  357.             if name == '*':
  358.                 continue
  359.             
  360.             if not asname:
  361.                 pass
  362.             scope.add_def(name)
  363.         
  364.  
  365.     
  366.     def visitImport(self, node, scope):
  367.         for name, asname in node.names:
  368.             i = name.find('.')
  369.             if i > -1:
  370.                 name = name[:i]
  371.             
  372.             if not asname:
  373.                 pass
  374.             scope.add_def(name)
  375.         
  376.  
  377.     
  378.     def visitGlobal(self, node, scope):
  379.         for name in node.names:
  380.             scope.add_global(name)
  381.         
  382.  
  383.     
  384.     def visitAssign(self, node, scope):
  385.         for n in node.nodes:
  386.             self.visit(n, scope, 1)
  387.         
  388.         self.visit(node.expr, scope)
  389.  
  390.     
  391.     def visitAssName(self, node, scope, assign = 1):
  392.         scope.add_def(node.name)
  393.  
  394.     
  395.     def visitAssAttr(self, node, scope, assign = 0):
  396.         self.visit(node.expr, scope, 0)
  397.  
  398.     
  399.     def visitSubscript(self, node, scope, assign = 0):
  400.         self.visit(node.expr, scope, 0)
  401.         for n in node.subs:
  402.             self.visit(n, scope, 0)
  403.         
  404.  
  405.     
  406.     def visitSlice(self, node, scope, assign = 0):
  407.         self.visit(node.expr, scope, 0)
  408.         if node.lower:
  409.             self.visit(node.lower, scope, 0)
  410.         
  411.         if node.upper:
  412.             self.visit(node.upper, scope, 0)
  413.         
  414.  
  415.     
  416.     def visitAugAssign(self, node, scope):
  417.         self.visit(node.node, scope)
  418.         if isinstance(node.node, ast.Name):
  419.             self.visit(node.node, scope, 1)
  420.         
  421.         self.visit(node.expr, scope)
  422.  
  423.     _const_types = (types.StringType, types.IntType, types.FloatType)
  424.     
  425.     def visitIf(self, node, scope):
  426.         for test, body in node.tests:
  427.             if isinstance(test, ast.Const):
  428.                 if type(test.value) in self._const_types:
  429.                     if not test.value:
  430.                         continue
  431.                     
  432.                 
  433.             
  434.             self.visit(test, scope)
  435.             self.visit(body, scope)
  436.         
  437.         if node.else_:
  438.             self.visit(node.else_, scope)
  439.         
  440.  
  441.     
  442.     def visitYield(self, node, scope):
  443.         scope.generator = 1
  444.         self.visit(node.value, scope)
  445.  
  446.  
  447.  
  448. def list_eq(l1, l2):
  449.     return sorted(l1) == sorted(l2)
  450.  
  451.