home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_325 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  48.3 KB  |  1,633 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import imp
  5. import os
  6. import marshal
  7. import struct
  8. import sys
  9. from cStringIO import StringIO
  10. from compiler import ast, parse, walk, syntax
  11. from compiler import pyassem, misc, future, symbols
  12. from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL
  13. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS, CO_NEWLOCALS, CO_NESTED, CO_GENERATOR, CO_FUTURE_DIVISION, CO_FUTURE_ABSIMPORT, CO_FUTURE_WITH_STATEMENT, CO_FUTURE_PRINT_FUNCTION
  14. from compiler.pyassem import TupleArg
  15.  
  16. try:
  17.     VERSION = sys.version_info[0]
  18. except AttributeError:
  19.     VERSION = 1
  20.  
  21. callfunc_opcode_info = {
  22.     (0, 0): 'CALL_FUNCTION',
  23.     (1, 0): 'CALL_FUNCTION_VAR',
  24.     (0, 1): 'CALL_FUNCTION_KW',
  25.     (1, 1): 'CALL_FUNCTION_VAR_KW' }
  26. LOOP = 1
  27. EXCEPT = 2
  28. TRY_FINALLY = 3
  29. END_FINALLY = 4
  30.  
  31. def compileFile(filename, display = 0):
  32.     f = open(filename, 'U')
  33.     buf = f.read()
  34.     f.close()
  35.     mod = Module(buf, filename)
  36.     
  37.     try:
  38.         mod.compile(display)
  39.     except SyntaxError:
  40.         raise 
  41.  
  42.     f = open(filename + 'c', 'wb')
  43.     mod.dump(f)
  44.     f.close()
  45.  
  46.  
  47. def compile(source, filename, mode, flags = None, dont_inherit = None):
  48.     if flags is not None or dont_inherit is not None:
  49.         raise RuntimeError, 'not implemented yet'
  50.     dont_inherit is not None
  51.     if mode == 'single':
  52.         gen = Interactive(source, filename)
  53.     elif mode == 'exec':
  54.         gen = Module(source, filename)
  55.     elif mode == 'eval':
  56.         gen = Expression(source, filename)
  57.     else:
  58.         raise ValueError("compile() 3rd arg must be 'exec' or 'eval' or 'single'")
  59.     (mode == 'single').compile()
  60.     return gen.code
  61.  
  62.  
  63. class AbstractCompileMode:
  64.     mode = None
  65.     
  66.     def __init__(self, source, filename):
  67.         self.source = source
  68.         self.filename = filename
  69.         self.code = None
  70.  
  71.     
  72.     def _get_tree(self):
  73.         tree = parse(self.source, self.mode)
  74.         misc.set_filename(self.filename, tree)
  75.         syntax.check(tree)
  76.         return tree
  77.  
  78.     
  79.     def compile(self):
  80.         pass
  81.  
  82.     
  83.     def getCode(self):
  84.         return self.code
  85.  
  86.  
  87.  
  88. class Expression(AbstractCompileMode):
  89.     mode = 'eval'
  90.     
  91.     def compile(self):
  92.         tree = self._get_tree()
  93.         gen = ExpressionCodeGenerator(tree)
  94.         self.code = gen.getCode()
  95.  
  96.  
  97.  
  98. class Interactive(AbstractCompileMode):
  99.     mode = 'single'
  100.     
  101.     def compile(self):
  102.         tree = self._get_tree()
  103.         gen = InteractiveCodeGenerator(tree)
  104.         self.code = gen.getCode()
  105.  
  106.  
  107.  
  108. class Module(AbstractCompileMode):
  109.     mode = 'exec'
  110.     
  111.     def compile(self, display = 0):
  112.         tree = self._get_tree()
  113.         gen = ModuleCodeGenerator(tree)
  114.         if display:
  115.             import pprint
  116.             print pprint.pprint(tree)
  117.         
  118.         self.code = gen.getCode()
  119.  
  120.     
  121.     def dump(self, f):
  122.         f.write(self.getPycHeader())
  123.         marshal.dump(self.code, f)
  124.  
  125.     MAGIC = imp.get_magic()
  126.     
  127.     def getPycHeader(self):
  128.         mtime = os.path.getmtime(self.filename)
  129.         mtime = struct.pack('<i', mtime)
  130.         return self.MAGIC + mtime
  131.  
  132.  
  133.  
  134. class LocalNameFinder:
  135.     
  136.     def __init__(self, names = ()):
  137.         self.names = misc.Set()
  138.         self.globals = misc.Set()
  139.         for name in names:
  140.             self.names.add(name)
  141.         
  142.  
  143.     
  144.     def getLocals(self):
  145.         for elt in self.globals.elements():
  146.             if self.names.has_elt(elt):
  147.                 self.names.remove(elt)
  148.                 continue
  149.         
  150.         return self.names
  151.  
  152.     
  153.     def visitDict(self, node):
  154.         pass
  155.  
  156.     
  157.     def visitGlobal(self, node):
  158.         for name in node.names:
  159.             self.globals.add(name)
  160.         
  161.  
  162.     
  163.     def visitFunction(self, node):
  164.         self.names.add(node.name)
  165.  
  166.     
  167.     def visitLambda(self, node):
  168.         pass
  169.  
  170.     
  171.     def visitImport(self, node):
  172.         for name, alias in node.names:
  173.             if not alias:
  174.                 pass
  175.             self.names.add(name)
  176.         
  177.  
  178.     
  179.     def visitFrom(self, node):
  180.         for name, alias in node.names:
  181.             if not alias:
  182.                 pass
  183.             self.names.add(name)
  184.         
  185.  
  186.     
  187.     def visitClass(self, node):
  188.         self.names.add(node.name)
  189.  
  190.     
  191.     def visitAssName(self, node):
  192.         self.names.add(node.name)
  193.  
  194.  
  195.  
  196. def is_constant_false(node):
  197.     if isinstance(node, ast.Const):
  198.         if not node.value:
  199.             return 1
  200.     
  201.     return 0
  202.  
  203.  
  204. class CodeGenerator:
  205.     optimized = 0
  206.     __initialized = None
  207.     class_name = None
  208.     
  209.     def __init__(self):
  210.         if self._CodeGenerator__initialized is None:
  211.             self.initClass()
  212.             self.__class__._CodeGenerator__initialized = 1
  213.         
  214.         self.checkClass()
  215.         self.locals = misc.Stack()
  216.         self.setups = misc.Stack()
  217.         self.last_lineno = None
  218.         self._setupGraphDelegation()
  219.         self._div_op = 'BINARY_DIVIDE'
  220.         futures = self.get_module().futures
  221.         for feature in futures:
  222.             if feature == 'division':
  223.                 self.graph.setFlag(CO_FUTURE_DIVISION)
  224.                 self._div_op = 'BINARY_TRUE_DIVIDE'
  225.                 continue
  226.             if feature == 'absolute_import':
  227.                 self.graph.setFlag(CO_FUTURE_ABSIMPORT)
  228.                 continue
  229.             if feature == 'with_statement':
  230.                 self.graph.setFlag(CO_FUTURE_WITH_STATEMENT)
  231.                 continue
  232.             if feature == 'print_function':
  233.                 self.graph.setFlag(CO_FUTURE_PRINT_FUNCTION)
  234.                 continue
  235.         
  236.  
  237.     
  238.     def initClass(self):
  239.         pass
  240.  
  241.     
  242.     def checkClass(self):
  243.         
  244.         try:
  245.             pass
  246.         except AssertionError:
  247.             msg = None
  248.             intro = 'Bad class construction for %s' % self.__class__.__name__
  249.             raise AssertionError, intro
  250.  
  251.  
  252.     
  253.     def _setupGraphDelegation(self):
  254.         self.emit = self.graph.emit
  255.         self.newBlock = self.graph.newBlock
  256.         self.startBlock = self.graph.startBlock
  257.         self.nextBlock = self.graph.nextBlock
  258.         self.setDocstring = self.graph.setDocstring
  259.  
  260.     
  261.     def getCode(self):
  262.         return self.graph.getCode()
  263.  
  264.     
  265.     def mangle(self, name):
  266.         if self.class_name is not None:
  267.             return misc.mangle(name, self.class_name)
  268.         return name
  269.  
  270.     
  271.     def parseSymbols(self, tree):
  272.         s = symbols.SymbolVisitor()
  273.         walk(tree, s)
  274.         return s.scopes
  275.  
  276.     
  277.     def get_module(self):
  278.         raise RuntimeError, 'should be implemented by subclasses'
  279.  
  280.     
  281.     def isLocalName(self, name):
  282.         return self.locals.top().has_elt(name)
  283.  
  284.     
  285.     def storeName(self, name):
  286.         self._nameOp('STORE', name)
  287.  
  288.     
  289.     def loadName(self, name):
  290.         self._nameOp('LOAD', name)
  291.  
  292.     
  293.     def delName(self, name):
  294.         self._nameOp('DELETE', name)
  295.  
  296.     
  297.     def _nameOp(self, prefix, name):
  298.         name = self.mangle(name)
  299.         scope = self.scope.check_name(name)
  300.         if scope == SC_LOCAL:
  301.             if not self.optimized:
  302.                 self.emit(prefix + '_NAME', name)
  303.             else:
  304.                 self.emit(prefix + '_FAST', name)
  305.         elif scope == SC_GLOBAL:
  306.             if not self.optimized:
  307.                 self.emit(prefix + '_NAME', name)
  308.             else:
  309.                 self.emit(prefix + '_GLOBAL', name)
  310.         elif scope == SC_FREE or scope == SC_CELL:
  311.             self.emit(prefix + '_DEREF', name)
  312.         else:
  313.             raise RuntimeError, 'unsupported scope for var %s: %d' % (name, scope)
  314.         return scope == SC_CELL
  315.  
  316.     
  317.     def _implicitNameOp(self, prefix, name):
  318.         if self.optimized:
  319.             self.emit(prefix + '_FAST', name)
  320.         else:
  321.             self.emit(prefix + '_NAME', name)
  322.  
  323.     
  324.     def set_lineno(self, node, force = False):
  325.         lineno = getattr(node, 'lineno', None)
  326.         if lineno is not None:
  327.             if lineno != self.last_lineno or force:
  328.                 self.emit('SET_LINENO', lineno)
  329.                 self.last_lineno = lineno
  330.                 return True
  331.             return False
  332.  
  333.     NameFinder = LocalNameFinder
  334.     FunctionGen = None
  335.     ClassGen = None
  336.     
  337.     def visitModule(self, node):
  338.         self.scopes = self.parseSymbols(node)
  339.         self.scope = self.scopes[node]
  340.         self.emit('SET_LINENO', 0)
  341.         if node.doc:
  342.             self.emit('LOAD_CONST', node.doc)
  343.             self.storeName('__doc__')
  344.         
  345.         lnf = walk(node.node, self.NameFinder(), verbose = 0)
  346.         self.locals.push(lnf.getLocals())
  347.         self.visit(node.node)
  348.         self.emit('LOAD_CONST', None)
  349.         self.emit('RETURN_VALUE')
  350.  
  351.     
  352.     def visitExpression(self, node):
  353.         self.set_lineno(node)
  354.         self.scopes = self.parseSymbols(node)
  355.         self.scope = self.scopes[node]
  356.         self.visit(node.node)
  357.         self.emit('RETURN_VALUE')
  358.  
  359.     
  360.     def visitFunction(self, node):
  361.         self._visitFuncOrLambda(node, isLambda = 0)
  362.         if node.doc:
  363.             self.setDocstring(node.doc)
  364.         
  365.         self.storeName(node.name)
  366.  
  367.     
  368.     def visitLambda(self, node):
  369.         self._visitFuncOrLambda(node, isLambda = 1)
  370.  
  371.     
  372.     def _visitFuncOrLambda(self, node, isLambda = 0):
  373.         if not isLambda and node.decorators:
  374.             for decorator in node.decorators.nodes:
  375.                 self.visit(decorator)
  376.             
  377.             ndecorators = len(node.decorators.nodes)
  378.         else:
  379.             ndecorators = 0
  380.         gen = self.FunctionGen(node, self.scopes, isLambda, self.class_name, self.get_module())
  381.         walk(node.code, gen)
  382.         gen.finish()
  383.         self.set_lineno(node)
  384.         for default in node.defaults:
  385.             self.visit(default)
  386.         
  387.         self._makeClosure(gen, len(node.defaults))
  388.         for i in range(ndecorators):
  389.             self.emit('CALL_FUNCTION', 1)
  390.         
  391.  
  392.     
  393.     def visitClass(self, node):
  394.         gen = self.ClassGen(node, self.scopes, self.get_module())
  395.         walk(node.code, gen)
  396.         gen.finish()
  397.         self.set_lineno(node)
  398.         self.emit('LOAD_CONST', node.name)
  399.         for base in node.bases:
  400.             self.visit(base)
  401.         
  402.         self.emit('BUILD_TUPLE', len(node.bases))
  403.         self._makeClosure(gen, 0)
  404.         self.emit('CALL_FUNCTION', 0)
  405.         self.emit('BUILD_CLASS')
  406.         self.storeName(node.name)
  407.  
  408.     
  409.     def visitIf(self, node):
  410.         end = self.newBlock()
  411.         numtests = len(node.tests)
  412.         for i in range(numtests):
  413.             (test, suite) = node.tests[i]
  414.             if is_constant_false(test):
  415.                 continue
  416.             
  417.             self.set_lineno(test)
  418.             self.visit(test)
  419.             nextTest = self.newBlock()
  420.             self.emit('JUMP_IF_FALSE', nextTest)
  421.             self.nextBlock()
  422.             self.emit('POP_TOP')
  423.             self.visit(suite)
  424.             self.emit('JUMP_FORWARD', end)
  425.             self.startBlock(nextTest)
  426.             self.emit('POP_TOP')
  427.         
  428.         if node.else_:
  429.             self.visit(node.else_)
  430.         
  431.         self.nextBlock(end)
  432.  
  433.     
  434.     def visitWhile(self, node):
  435.         self.set_lineno(node)
  436.         loop = self.newBlock()
  437.         else_ = self.newBlock()
  438.         after = self.newBlock()
  439.         self.emit('SETUP_LOOP', after)
  440.         self.nextBlock(loop)
  441.         self.setups.push((LOOP, loop))
  442.         self.set_lineno(node, force = True)
  443.         self.visit(node.test)
  444.         if not else_:
  445.             pass
  446.         self.emit('JUMP_IF_FALSE', after)
  447.         self.nextBlock()
  448.         self.emit('POP_TOP')
  449.         self.visit(node.body)
  450.         self.emit('JUMP_ABSOLUTE', loop)
  451.         self.startBlock(else_)
  452.         self.emit('POP_TOP')
  453.         self.emit('POP_BLOCK')
  454.         self.setups.pop()
  455.         if node.else_:
  456.             self.visit(node.else_)
  457.         
  458.         self.nextBlock(after)
  459.  
  460.     
  461.     def visitFor(self, node):
  462.         start = self.newBlock()
  463.         anchor = self.newBlock()
  464.         after = self.newBlock()
  465.         self.setups.push((LOOP, start))
  466.         self.set_lineno(node)
  467.         self.emit('SETUP_LOOP', after)
  468.         self.visit(node.list)
  469.         self.emit('GET_ITER')
  470.         self.nextBlock(start)
  471.         self.set_lineno(node, force = 1)
  472.         self.emit('FOR_ITER', anchor)
  473.         self.visit(node.assign)
  474.         self.visit(node.body)
  475.         self.emit('JUMP_ABSOLUTE', start)
  476.         self.nextBlock(anchor)
  477.         self.emit('POP_BLOCK')
  478.         self.setups.pop()
  479.         if node.else_:
  480.             self.visit(node.else_)
  481.         
  482.         self.nextBlock(after)
  483.  
  484.     
  485.     def visitBreak(self, node):
  486.         if not self.setups:
  487.             raise SyntaxError, "'break' outside loop (%s, %d)" % (node.filename, node.lineno)
  488.         self.setups
  489.         self.set_lineno(node)
  490.         self.emit('BREAK_LOOP')
  491.  
  492.     
  493.     def visitContinue(self, node):
  494.         if not self.setups:
  495.             raise SyntaxError, "'continue' outside loop (%s, %d)" % (node.filename, node.lineno)
  496.         self.setups
  497.         (kind, block) = self.setups.top()
  498.         if kind == LOOP:
  499.             self.set_lineno(node)
  500.             self.emit('JUMP_ABSOLUTE', block)
  501.             self.nextBlock()
  502.         elif kind == EXCEPT or kind == TRY_FINALLY:
  503.             self.set_lineno(node)
  504.             top = len(self.setups)
  505.             while top > 0:
  506.                 top = top - 1
  507.                 (kind, loop_block) = self.setups[top]
  508.                 if kind == LOOP:
  509.                     break
  510.                     continue
  511.             if kind != LOOP:
  512.                 raise SyntaxError, "'continue' outside loop (%s, %d)" % (node.filename, node.lineno)
  513.             kind != LOOP
  514.             self.emit('CONTINUE_LOOP', loop_block)
  515.             self.nextBlock()
  516.         elif kind == END_FINALLY:
  517.             msg = "'continue' not allowed inside 'finally' clause (%s, %d)"
  518.             raise SyntaxError, msg % (node.filename, node.lineno)
  519.         
  520.  
  521.     
  522.     def visitTest(self, node, jump):
  523.         end = self.newBlock()
  524.         for child in node.nodes[:-1]:
  525.             self.visit(child)
  526.             self.emit(jump, end)
  527.             self.nextBlock()
  528.             self.emit('POP_TOP')
  529.         
  530.         self.visit(node.nodes[-1])
  531.         self.nextBlock(end)
  532.  
  533.     
  534.     def visitAnd(self, node):
  535.         self.visitTest(node, 'JUMP_IF_FALSE')
  536.  
  537.     
  538.     def visitOr(self, node):
  539.         self.visitTest(node, 'JUMP_IF_TRUE')
  540.  
  541.     
  542.     def visitIfExp(self, node):
  543.         endblock = self.newBlock()
  544.         elseblock = self.newBlock()
  545.         self.visit(node.test)
  546.         self.emit('JUMP_IF_FALSE', elseblock)
  547.         self.emit('POP_TOP')
  548.         self.visit(node.then)
  549.         self.emit('JUMP_FORWARD', endblock)
  550.         self.nextBlock(elseblock)
  551.         self.emit('POP_TOP')
  552.         self.visit(node.else_)
  553.         self.nextBlock(endblock)
  554.  
  555.     
  556.     def visitCompare(self, node):
  557.         self.visit(node.expr)
  558.         cleanup = self.newBlock()
  559.         for op, code in node.ops[:-1]:
  560.             self.visit(code)
  561.             self.emit('DUP_TOP')
  562.             self.emit('ROT_THREE')
  563.             self.emit('COMPARE_OP', op)
  564.             self.emit('JUMP_IF_FALSE', cleanup)
  565.             self.nextBlock()
  566.             self.emit('POP_TOP')
  567.         
  568.         if node.ops:
  569.             (op, code) = node.ops[-1]
  570.             self.visit(code)
  571.             self.emit('COMPARE_OP', op)
  572.         
  573.         if len(node.ops) > 1:
  574.             end = self.newBlock()
  575.             self.emit('JUMP_FORWARD', end)
  576.             self.startBlock(cleanup)
  577.             self.emit('ROT_TWO')
  578.             self.emit('POP_TOP')
  579.             self.nextBlock(end)
  580.         
  581.  
  582.     __list_count = 0
  583.     
  584.     def visitListComp(self, node):
  585.         self.set_lineno(node)
  586.         tmpname = '$list%d' % self._CodeGenerator__list_count
  587.         self._CodeGenerator__list_count = self._CodeGenerator__list_count + 1
  588.         self.emit('BUILD_LIST', 0)
  589.         self.emit('DUP_TOP')
  590.         self._implicitNameOp('STORE', tmpname)
  591.         stack = []
  592.         for i, for_ in zip(range(len(node.quals)), node.quals):
  593.             (start, anchor) = self.visit(for_)
  594.             cont = None
  595.             for if_ in for_.ifs:
  596.                 if cont is None:
  597.                     cont = self.newBlock()
  598.                 
  599.                 self.visit(if_, cont)
  600.             
  601.             stack.insert(0, (start, cont, anchor))
  602.         
  603.         self._implicitNameOp('LOAD', tmpname)
  604.         self.visit(node.expr)
  605.         self.emit('LIST_APPEND')
  606.         for start, cont, anchor in stack:
  607.             if cont:
  608.                 skip_one = self.newBlock()
  609.                 self.emit('JUMP_FORWARD', skip_one)
  610.                 self.startBlock(cont)
  611.                 self.emit('POP_TOP')
  612.                 self.nextBlock(skip_one)
  613.             
  614.             self.emit('JUMP_ABSOLUTE', start)
  615.             self.startBlock(anchor)
  616.         
  617.         self._implicitNameOp('DELETE', tmpname)
  618.         self._CodeGenerator__list_count = self._CodeGenerator__list_count - 1
  619.  
  620.     
  621.     def visitListCompFor(self, node):
  622.         start = self.newBlock()
  623.         anchor = self.newBlock()
  624.         self.visit(node.list)
  625.         self.emit('GET_ITER')
  626.         self.nextBlock(start)
  627.         self.set_lineno(node, force = True)
  628.         self.emit('FOR_ITER', anchor)
  629.         self.nextBlock()
  630.         self.visit(node.assign)
  631.         return (start, anchor)
  632.  
  633.     
  634.     def visitListCompIf(self, node, branch):
  635.         self.set_lineno(node, force = True)
  636.         self.visit(node.test)
  637.         self.emit('JUMP_IF_FALSE', branch)
  638.         self.newBlock()
  639.         self.emit('POP_TOP')
  640.  
  641.     
  642.     def _makeClosure(self, gen, args):
  643.         frees = gen.scope.get_free_vars()
  644.         if frees:
  645.             for name in frees:
  646.                 self.emit('LOAD_CLOSURE', name)
  647.             
  648.             self.emit('BUILD_TUPLE', len(frees))
  649.             self.emit('LOAD_CONST', gen)
  650.             self.emit('MAKE_CLOSURE', args)
  651.         else:
  652.             self.emit('LOAD_CONST', gen)
  653.             self.emit('MAKE_FUNCTION', args)
  654.  
  655.     
  656.     def visitGenExpr(self, node):
  657.         gen = GenExprCodeGenerator(node, self.scopes, self.class_name, self.get_module())
  658.         walk(node.code, gen)
  659.         gen.finish()
  660.         self.set_lineno(node)
  661.         self._makeClosure(gen, 0)
  662.         self.visit(node.code.quals[0].iter)
  663.         self.emit('GET_ITER')
  664.         self.emit('CALL_FUNCTION', 1)
  665.  
  666.     
  667.     def visitGenExprInner(self, node):
  668.         self.set_lineno(node)
  669.         stack = []
  670.         for i, for_ in zip(range(len(node.quals)), node.quals):
  671.             (start, anchor, end) = self.visit(for_)
  672.             cont = None
  673.             for if_ in for_.ifs:
  674.                 if cont is None:
  675.                     cont = self.newBlock()
  676.                 
  677.                 self.visit(if_, cont)
  678.             
  679.             stack.insert(0, (start, cont, anchor, end))
  680.         
  681.         self.visit(node.expr)
  682.         self.emit('YIELD_VALUE')
  683.         self.emit('POP_TOP')
  684.         for start, cont, anchor, end in stack:
  685.             if cont:
  686.                 skip_one = self.newBlock()
  687.                 self.emit('JUMP_FORWARD', skip_one)
  688.                 self.startBlock(cont)
  689.                 self.emit('POP_TOP')
  690.                 self.nextBlock(skip_one)
  691.             
  692.             self.emit('JUMP_ABSOLUTE', start)
  693.             self.startBlock(anchor)
  694.             self.emit('POP_BLOCK')
  695.             self.setups.pop()
  696.             self.startBlock(end)
  697.         
  698.         self.emit('LOAD_CONST', None)
  699.  
  700.     
  701.     def visitGenExprFor(self, node):
  702.         start = self.newBlock()
  703.         anchor = self.newBlock()
  704.         end = self.newBlock()
  705.         self.setups.push((LOOP, start))
  706.         self.emit('SETUP_LOOP', end)
  707.         if node.is_outmost:
  708.             self.loadName('.0')
  709.         else:
  710.             self.visit(node.iter)
  711.             self.emit('GET_ITER')
  712.         self.nextBlock(start)
  713.         self.set_lineno(node, force = True)
  714.         self.emit('FOR_ITER', anchor)
  715.         self.nextBlock()
  716.         self.visit(node.assign)
  717.         return (start, anchor, end)
  718.  
  719.     
  720.     def visitGenExprIf(self, node, branch):
  721.         self.set_lineno(node, force = True)
  722.         self.visit(node.test)
  723.         self.emit('JUMP_IF_FALSE', branch)
  724.         self.newBlock()
  725.         self.emit('POP_TOP')
  726.  
  727.     
  728.     def visitAssert(self, node):
  729.         pass
  730.  
  731.     
  732.     def visitRaise(self, node):
  733.         self.set_lineno(node)
  734.         n = 0
  735.         if node.expr1:
  736.             self.visit(node.expr1)
  737.             n = n + 1
  738.         
  739.         if node.expr2:
  740.             self.visit(node.expr2)
  741.             n = n + 1
  742.         
  743.         if node.expr3:
  744.             self.visit(node.expr3)
  745.             n = n + 1
  746.         
  747.         self.emit('RAISE_VARARGS', n)
  748.  
  749.     
  750.     def visitTryExcept(self, node):
  751.         body = self.newBlock()
  752.         handlers = self.newBlock()
  753.         end = self.newBlock()
  754.         if node.else_:
  755.             lElse = self.newBlock()
  756.         else:
  757.             lElse = end
  758.         self.set_lineno(node)
  759.         self.emit('SETUP_EXCEPT', handlers)
  760.         self.nextBlock(body)
  761.         self.setups.push((EXCEPT, body))
  762.         self.visit(node.body)
  763.         self.emit('POP_BLOCK')
  764.         self.setups.pop()
  765.         self.emit('JUMP_FORWARD', lElse)
  766.         self.startBlock(handlers)
  767.         last = len(node.handlers) - 1
  768.         for i in range(len(node.handlers)):
  769.             (expr, target, body) = node.handlers[i]
  770.             self.set_lineno(expr)
  771.             if expr:
  772.                 self.emit('DUP_TOP')
  773.                 self.visit(expr)
  774.                 self.emit('COMPARE_OP', 'exception match')
  775.                 next = self.newBlock()
  776.                 self.emit('JUMP_IF_FALSE', next)
  777.                 self.nextBlock()
  778.                 self.emit('POP_TOP')
  779.             
  780.             self.emit('POP_TOP')
  781.             if target:
  782.                 self.visit(target)
  783.             else:
  784.                 self.emit('POP_TOP')
  785.             self.emit('POP_TOP')
  786.             self.visit(body)
  787.             self.emit('JUMP_FORWARD', end)
  788.             if expr:
  789.                 self.nextBlock(next)
  790.             else:
  791.                 self.nextBlock()
  792.             if expr:
  793.                 self.emit('POP_TOP')
  794.                 continue
  795.         
  796.         self.emit('END_FINALLY')
  797.         if node.else_:
  798.             self.nextBlock(lElse)
  799.             self.visit(node.else_)
  800.         
  801.         self.nextBlock(end)
  802.  
  803.     
  804.     def visitTryFinally(self, node):
  805.         body = self.newBlock()
  806.         final = self.newBlock()
  807.         self.set_lineno(node)
  808.         self.emit('SETUP_FINALLY', final)
  809.         self.nextBlock(body)
  810.         self.setups.push((TRY_FINALLY, body))
  811.         self.visit(node.body)
  812.         self.emit('POP_BLOCK')
  813.         self.setups.pop()
  814.         self.emit('LOAD_CONST', None)
  815.         self.nextBlock(final)
  816.         self.setups.push((END_FINALLY, final))
  817.         self.visit(node.final)
  818.         self.emit('END_FINALLY')
  819.         self.setups.pop()
  820.  
  821.     __with_count = 0
  822.     
  823.     def visitWith(self, node):
  824.         body = self.newBlock()
  825.         final = self.newBlock()
  826.         valuevar = '$value%d' % self._CodeGenerator__with_count
  827.         self._CodeGenerator__with_count += 1
  828.         self.set_lineno(node)
  829.         self.visit(node.expr)
  830.         self.emit('DUP_TOP')
  831.         self.emit('LOAD_ATTR', '__exit__')
  832.         self.emit('ROT_TWO')
  833.         self.emit('LOAD_ATTR', '__enter__')
  834.         self.emit('CALL_FUNCTION', 0)
  835.         if node.vars is None:
  836.             self.emit('POP_TOP')
  837.         else:
  838.             self._implicitNameOp('STORE', valuevar)
  839.         self.emit('SETUP_FINALLY', final)
  840.         self.nextBlock(body)
  841.         self.setups.push((TRY_FINALLY, body))
  842.         if node.vars is not None:
  843.             self._implicitNameOp('LOAD', valuevar)
  844.             self._implicitNameOp('DELETE', valuevar)
  845.             self.visit(node.vars)
  846.         
  847.         self.visit(node.body)
  848.         self.emit('POP_BLOCK')
  849.         self.setups.pop()
  850.         self.emit('LOAD_CONST', None)
  851.         self.nextBlock(final)
  852.         self.setups.push((END_FINALLY, final))
  853.         self.emit('WITH_CLEANUP')
  854.         self.emit('END_FINALLY')
  855.         self.setups.pop()
  856.         self._CodeGenerator__with_count -= 1
  857.  
  858.     
  859.     def visitDiscard(self, node):
  860.         self.set_lineno(node)
  861.         self.visit(node.expr)
  862.         self.emit('POP_TOP')
  863.  
  864.     
  865.     def visitConst(self, node):
  866.         self.emit('LOAD_CONST', node.value)
  867.  
  868.     
  869.     def visitKeyword(self, node):
  870.         self.emit('LOAD_CONST', node.name)
  871.         self.visit(node.expr)
  872.  
  873.     
  874.     def visitGlobal(self, node):
  875.         pass
  876.  
  877.     
  878.     def visitName(self, node):
  879.         self.set_lineno(node)
  880.         self.loadName(node.name)
  881.  
  882.     
  883.     def visitPass(self, node):
  884.         self.set_lineno(node)
  885.  
  886.     
  887.     def visitImport(self, node):
  888.         self.set_lineno(node)
  889.         level = None if self.graph.checkFlag(CO_FUTURE_ABSIMPORT) else -1
  890.         for name, alias in node.names:
  891.             if VERSION > 1:
  892.                 self.emit('LOAD_CONST', level)
  893.                 self.emit('LOAD_CONST', None)
  894.             
  895.             self.emit('IMPORT_NAME', name)
  896.             mod = name.split('.')[0]
  897.             if alias:
  898.                 self._resolveDots(name)
  899.                 self.storeName(alias)
  900.                 continue
  901.             self.storeName(mod)
  902.         
  903.  
  904.     
  905.     def visitFrom(self, node):
  906.         self.set_lineno(node)
  907.         level = node.level
  908.         if level == 0 and not self.graph.checkFlag(CO_FUTURE_ABSIMPORT):
  909.             level = -1
  910.         
  911.         fromlist = map((lambda .0: (name, alias) = .0name), node.names)
  912.         if VERSION > 1:
  913.             self.emit('LOAD_CONST', level)
  914.             self.emit('LOAD_CONST', tuple(fromlist))
  915.         
  916.         self.emit('IMPORT_NAME', node.modname)
  917.         for name, alias in node.names:
  918.             if VERSION > 1:
  919.                 if name == '*':
  920.                     self.namespace = 0
  921.                     self.emit('IMPORT_STAR')
  922.                     return None
  923.                 self.emit('IMPORT_FROM', name)
  924.                 self._resolveDots(name)
  925.                 if not alias:
  926.                     pass
  927.                 self.storeName(name)
  928.                 continue
  929.             name == '*'
  930.             self.emit('IMPORT_FROM', name)
  931.         
  932.         self.emit('POP_TOP')
  933.  
  934.     
  935.     def _resolveDots(self, name):
  936.         elts = name.split('.')
  937.         if len(elts) == 1:
  938.             return None
  939.         for elt in elts[1:]:
  940.             self.emit('LOAD_ATTR', elt)
  941.         
  942.  
  943.     
  944.     def visitGetattr(self, node):
  945.         self.visit(node.expr)
  946.         self.emit('LOAD_ATTR', self.mangle(node.attrname))
  947.  
  948.     
  949.     def visitAssign(self, node):
  950.         self.set_lineno(node)
  951.         self.visit(node.expr)
  952.         dups = len(node.nodes) - 1
  953.         for i in range(len(node.nodes)):
  954.             elt = node.nodes[i]
  955.             if i < dups:
  956.                 self.emit('DUP_TOP')
  957.             
  958.             if isinstance(elt, ast.Node):
  959.                 self.visit(elt)
  960.                 continue
  961.         
  962.  
  963.     
  964.     def visitAssName(self, node):
  965.         if node.flags == 'OP_ASSIGN':
  966.             self.storeName(node.name)
  967.         elif node.flags == 'OP_DELETE':
  968.             self.set_lineno(node)
  969.             self.delName(node.name)
  970.         else:
  971.             print 'oops', node.flags
  972.  
  973.     
  974.     def visitAssAttr(self, node):
  975.         self.visit(node.expr)
  976.         if node.flags == 'OP_ASSIGN':
  977.             self.emit('STORE_ATTR', self.mangle(node.attrname))
  978.         elif node.flags == 'OP_DELETE':
  979.             self.emit('DELETE_ATTR', self.mangle(node.attrname))
  980.         else:
  981.             print 'warning: unexpected flags:', node.flags
  982.             print node
  983.  
  984.     
  985.     def _visitAssSequence(self, node, op = 'UNPACK_SEQUENCE'):
  986.         if findOp(node) != 'OP_DELETE':
  987.             self.emit(op, len(node.nodes))
  988.         
  989.         for child in node.nodes:
  990.             self.visit(child)
  991.         
  992.  
  993.     if VERSION > 1:
  994.         visitAssTuple = _visitAssSequence
  995.         visitAssList = _visitAssSequence
  996.     else:
  997.         
  998.         def visitAssTuple(self, node):
  999.             self._visitAssSequence(node, 'UNPACK_TUPLE')
  1000.  
  1001.         
  1002.         def visitAssList(self, node):
  1003.             self._visitAssSequence(node, 'UNPACK_LIST')
  1004.  
  1005.     
  1006.     def visitAugAssign(self, node):
  1007.         self.set_lineno(node)
  1008.         aug_node = wrap_aug(node.node)
  1009.         self.visit(aug_node, 'load')
  1010.         self.visit(node.expr)
  1011.         self.emit(self._augmented_opcode[node.op])
  1012.         self.visit(aug_node, 'store')
  1013.  
  1014.     _augmented_opcode = {
  1015.         '+=': 'INPLACE_ADD',
  1016.         '-=': 'INPLACE_SUBTRACT',
  1017.         '*=': 'INPLACE_MULTIPLY',
  1018.         '/=': 'INPLACE_DIVIDE',
  1019.         '//=': 'INPLACE_FLOOR_DIVIDE',
  1020.         '%=': 'INPLACE_MODULO',
  1021.         '**=': 'INPLACE_POWER',
  1022.         '>>=': 'INPLACE_RSHIFT',
  1023.         '<<=': 'INPLACE_LSHIFT',
  1024.         '&=': 'INPLACE_AND',
  1025.         '^=': 'INPLACE_XOR',
  1026.         '|=': 'INPLACE_OR' }
  1027.     
  1028.     def visitAugName(self, node, mode):
  1029.         if mode == 'load':
  1030.             self.loadName(node.name)
  1031.         elif mode == 'store':
  1032.             self.storeName(node.name)
  1033.         
  1034.  
  1035.     
  1036.     def visitAugGetattr(self, node, mode):
  1037.         if mode == 'load':
  1038.             self.visit(node.expr)
  1039.             self.emit('DUP_TOP')
  1040.             self.emit('LOAD_ATTR', self.mangle(node.attrname))
  1041.         elif mode == 'store':
  1042.             self.emit('ROT_TWO')
  1043.             self.emit('STORE_ATTR', self.mangle(node.attrname))
  1044.         
  1045.  
  1046.     
  1047.     def visitAugSlice(self, node, mode):
  1048.         if mode == 'load':
  1049.             self.visitSlice(node, 1)
  1050.         elif mode == 'store':
  1051.             slice = 0
  1052.             if node.lower:
  1053.                 slice = slice | 1
  1054.             
  1055.             if node.upper:
  1056.                 slice = slice | 2
  1057.             
  1058.             if slice == 0:
  1059.                 self.emit('ROT_TWO')
  1060.             elif slice == 3:
  1061.                 self.emit('ROT_FOUR')
  1062.             else:
  1063.                 self.emit('ROT_THREE')
  1064.             self.emit('STORE_SLICE+%d' % slice)
  1065.         
  1066.  
  1067.     
  1068.     def visitAugSubscript(self, node, mode):
  1069.         if mode == 'load':
  1070.             self.visitSubscript(node, 1)
  1071.         elif mode == 'store':
  1072.             self.emit('ROT_THREE')
  1073.             self.emit('STORE_SUBSCR')
  1074.         
  1075.  
  1076.     
  1077.     def visitExec(self, node):
  1078.         self.visit(node.expr)
  1079.         if node.locals is None:
  1080.             self.emit('LOAD_CONST', None)
  1081.         else:
  1082.             self.visit(node.locals)
  1083.         if node.globals is None:
  1084.             self.emit('DUP_TOP')
  1085.         else:
  1086.             self.visit(node.globals)
  1087.         self.emit('EXEC_STMT')
  1088.  
  1089.     
  1090.     def visitCallFunc(self, node):
  1091.         pos = 0
  1092.         kw = 0
  1093.         self.set_lineno(node)
  1094.         self.visit(node.node)
  1095.         for arg in node.args:
  1096.             self.visit(arg)
  1097.             if isinstance(arg, ast.Keyword):
  1098.                 kw = kw + 1
  1099.                 continue
  1100.             pos = pos + 1
  1101.         
  1102.         if node.star_args is not None:
  1103.             self.visit(node.star_args)
  1104.         
  1105.         if node.dstar_args is not None:
  1106.             self.visit(node.dstar_args)
  1107.         
  1108.         have_star = node.star_args is not None
  1109.         have_dstar = node.dstar_args is not None
  1110.         opcode = callfunc_opcode_info[(have_star, have_dstar)]
  1111.         self.emit(opcode, kw << 8 | pos)
  1112.  
  1113.     
  1114.     def visitPrint(self, node, newline = 0):
  1115.         self.set_lineno(node)
  1116.         if node.dest:
  1117.             self.visit(node.dest)
  1118.         
  1119.         for child in node.nodes:
  1120.             if node.dest:
  1121.                 self.emit('DUP_TOP')
  1122.             
  1123.             self.visit(child)
  1124.             if node.dest:
  1125.                 self.emit('ROT_TWO')
  1126.                 self.emit('PRINT_ITEM_TO')
  1127.                 continue
  1128.             self.emit('PRINT_ITEM')
  1129.         
  1130.         if node.dest and not newline:
  1131.             self.emit('POP_TOP')
  1132.         
  1133.  
  1134.     
  1135.     def visitPrintnl(self, node):
  1136.         self.visitPrint(node, newline = 1)
  1137.         if node.dest:
  1138.             self.emit('PRINT_NEWLINE_TO')
  1139.         else:
  1140.             self.emit('PRINT_NEWLINE')
  1141.  
  1142.     
  1143.     def visitReturn(self, node):
  1144.         self.set_lineno(node)
  1145.         self.visit(node.value)
  1146.         self.emit('RETURN_VALUE')
  1147.  
  1148.     
  1149.     def visitYield(self, node):
  1150.         self.set_lineno(node)
  1151.         self.visit(node.value)
  1152.         self.emit('YIELD_VALUE')
  1153.  
  1154.     
  1155.     def visitSlice(self, node, aug_flag = None):
  1156.         self.visit(node.expr)
  1157.         slice = 0
  1158.         if node.lower:
  1159.             self.visit(node.lower)
  1160.             slice = slice | 1
  1161.         
  1162.         if node.upper:
  1163.             self.visit(node.upper)
  1164.             slice = slice | 2
  1165.         
  1166.         if aug_flag:
  1167.             if slice == 0:
  1168.                 self.emit('DUP_TOP')
  1169.             elif slice == 3:
  1170.                 self.emit('DUP_TOPX', 3)
  1171.             else:
  1172.                 self.emit('DUP_TOPX', 2)
  1173.         
  1174.         if node.flags == 'OP_APPLY':
  1175.             self.emit('SLICE+%d' % slice)
  1176.         elif node.flags == 'OP_ASSIGN':
  1177.             self.emit('STORE_SLICE+%d' % slice)
  1178.         elif node.flags == 'OP_DELETE':
  1179.             self.emit('DELETE_SLICE+%d' % slice)
  1180.         else:
  1181.             print 'weird slice', node.flags
  1182.             raise 
  1183.         return node.flags == 'OP_APPLY'
  1184.  
  1185.     
  1186.     def visitSubscript(self, node, aug_flag = None):
  1187.         self.visit(node.expr)
  1188.         for sub in node.subs:
  1189.             self.visit(sub)
  1190.         
  1191.         if len(node.subs) > 1:
  1192.             self.emit('BUILD_TUPLE', len(node.subs))
  1193.         
  1194.         if aug_flag:
  1195.             self.emit('DUP_TOPX', 2)
  1196.         
  1197.         if node.flags == 'OP_APPLY':
  1198.             self.emit('BINARY_SUBSCR')
  1199.         elif node.flags == 'OP_ASSIGN':
  1200.             self.emit('STORE_SUBSCR')
  1201.         elif node.flags == 'OP_DELETE':
  1202.             self.emit('DELETE_SUBSCR')
  1203.         
  1204.  
  1205.     
  1206.     def binaryOp(self, node, op):
  1207.         self.visit(node.left)
  1208.         self.visit(node.right)
  1209.         self.emit(op)
  1210.  
  1211.     
  1212.     def visitAdd(self, node):
  1213.         return self.binaryOp(node, 'BINARY_ADD')
  1214.  
  1215.     
  1216.     def visitSub(self, node):
  1217.         return self.binaryOp(node, 'BINARY_SUBTRACT')
  1218.  
  1219.     
  1220.     def visitMul(self, node):
  1221.         return self.binaryOp(node, 'BINARY_MULTIPLY')
  1222.  
  1223.     
  1224.     def visitDiv(self, node):
  1225.         return self.binaryOp(node, self._div_op)
  1226.  
  1227.     
  1228.     def visitFloorDiv(self, node):
  1229.         return self.binaryOp(node, 'BINARY_FLOOR_DIVIDE')
  1230.  
  1231.     
  1232.     def visitMod(self, node):
  1233.         return self.binaryOp(node, 'BINARY_MODULO')
  1234.  
  1235.     
  1236.     def visitPower(self, node):
  1237.         return self.binaryOp(node, 'BINARY_POWER')
  1238.  
  1239.     
  1240.     def visitLeftShift(self, node):
  1241.         return self.binaryOp(node, 'BINARY_LSHIFT')
  1242.  
  1243.     
  1244.     def visitRightShift(self, node):
  1245.         return self.binaryOp(node, 'BINARY_RSHIFT')
  1246.  
  1247.     
  1248.     def unaryOp(self, node, op):
  1249.         self.visit(node.expr)
  1250.         self.emit(op)
  1251.  
  1252.     
  1253.     def visitInvert(self, node):
  1254.         return self.unaryOp(node, 'UNARY_INVERT')
  1255.  
  1256.     
  1257.     def visitUnarySub(self, node):
  1258.         return self.unaryOp(node, 'UNARY_NEGATIVE')
  1259.  
  1260.     
  1261.     def visitUnaryAdd(self, node):
  1262.         return self.unaryOp(node, 'UNARY_POSITIVE')
  1263.  
  1264.     
  1265.     def visitUnaryInvert(self, node):
  1266.         return self.unaryOp(node, 'UNARY_INVERT')
  1267.  
  1268.     
  1269.     def visitNot(self, node):
  1270.         return self.unaryOp(node, 'UNARY_NOT')
  1271.  
  1272.     
  1273.     def visitBackquote(self, node):
  1274.         return self.unaryOp(node, 'UNARY_CONVERT')
  1275.  
  1276.     
  1277.     def bitOp(self, nodes, op):
  1278.         self.visit(nodes[0])
  1279.         for node in nodes[1:]:
  1280.             self.visit(node)
  1281.             self.emit(op)
  1282.         
  1283.  
  1284.     
  1285.     def visitBitand(self, node):
  1286.         return self.bitOp(node.nodes, 'BINARY_AND')
  1287.  
  1288.     
  1289.     def visitBitor(self, node):
  1290.         return self.bitOp(node.nodes, 'BINARY_OR')
  1291.  
  1292.     
  1293.     def visitBitxor(self, node):
  1294.         return self.bitOp(node.nodes, 'BINARY_XOR')
  1295.  
  1296.     
  1297.     def visitEllipsis(self, node):
  1298.         self.emit('LOAD_CONST', Ellipsis)
  1299.  
  1300.     
  1301.     def visitTuple(self, node):
  1302.         self.set_lineno(node)
  1303.         for elt in node.nodes:
  1304.             self.visit(elt)
  1305.         
  1306.         self.emit('BUILD_TUPLE', len(node.nodes))
  1307.  
  1308.     
  1309.     def visitList(self, node):
  1310.         self.set_lineno(node)
  1311.         for elt in node.nodes:
  1312.             self.visit(elt)
  1313.         
  1314.         self.emit('BUILD_LIST', len(node.nodes))
  1315.  
  1316.     
  1317.     def visitSliceobj(self, node):
  1318.         for child in node.nodes:
  1319.             self.visit(child)
  1320.         
  1321.         self.emit('BUILD_SLICE', len(node.nodes))
  1322.  
  1323.     
  1324.     def visitDict(self, node):
  1325.         self.set_lineno(node)
  1326.         self.emit('BUILD_MAP', 0)
  1327.         for k, v in node.items:
  1328.             self.emit('DUP_TOP')
  1329.             self.visit(k)
  1330.             self.visit(v)
  1331.             self.emit('ROT_THREE')
  1332.             self.emit('STORE_SUBSCR')
  1333.         
  1334.  
  1335.  
  1336.  
  1337. class NestedScopeMixin:
  1338.     
  1339.     def initClass(self):
  1340.         self.__class__.NameFinder = LocalNameFinder
  1341.         self.__class__.FunctionGen = FunctionCodeGenerator
  1342.         self.__class__.ClassGen = ClassCodeGenerator
  1343.  
  1344.  
  1345.  
  1346. class ModuleCodeGenerator(NestedScopeMixin, CodeGenerator):
  1347.     __super_init = CodeGenerator.__init__
  1348.     scopes = None
  1349.     
  1350.     def __init__(self, tree):
  1351.         self.graph = pyassem.PyFlowGraph('<module>', tree.filename)
  1352.         self.futures = future.find_futures(tree)
  1353.         self._ModuleCodeGenerator__super_init()
  1354.         walk(tree, self)
  1355.  
  1356.     
  1357.     def get_module(self):
  1358.         return self
  1359.  
  1360.  
  1361.  
  1362. class ExpressionCodeGenerator(NestedScopeMixin, CodeGenerator):
  1363.     __super_init = CodeGenerator.__init__
  1364.     scopes = None
  1365.     futures = ()
  1366.     
  1367.     def __init__(self, tree):
  1368.         self.graph = pyassem.PyFlowGraph('<expression>', tree.filename)
  1369.         self._ExpressionCodeGenerator__super_init()
  1370.         walk(tree, self)
  1371.  
  1372.     
  1373.     def get_module(self):
  1374.         return self
  1375.  
  1376.  
  1377.  
  1378. class InteractiveCodeGenerator(NestedScopeMixin, CodeGenerator):
  1379.     __super_init = CodeGenerator.__init__
  1380.     scopes = None
  1381.     futures = ()
  1382.     
  1383.     def __init__(self, tree):
  1384.         self.graph = pyassem.PyFlowGraph('<interactive>', tree.filename)
  1385.         self._InteractiveCodeGenerator__super_init()
  1386.         self.set_lineno(tree)
  1387.         walk(tree, self)
  1388.         self.emit('RETURN_VALUE')
  1389.  
  1390.     
  1391.     def get_module(self):
  1392.         return self
  1393.  
  1394.     
  1395.     def visitDiscard(self, node):
  1396.         self.visit(node.expr)
  1397.         self.emit('PRINT_EXPR')
  1398.  
  1399.  
  1400.  
  1401. class AbstractFunctionCode:
  1402.     optimized = 1
  1403.     lambdaCount = 0
  1404.     
  1405.     def __init__(self, func, scopes, isLambda, class_name, mod):
  1406.         self.class_name = class_name
  1407.         self.module = mod
  1408.         if isLambda:
  1409.             klass = FunctionCodeGenerator
  1410.             name = '<lambda.%d>' % klass.lambdaCount
  1411.             klass.lambdaCount = klass.lambdaCount + 1
  1412.         else:
  1413.             name = func.name
  1414.         (args, hasTupleArg) = generateArgList(func.argnames)
  1415.         self.graph = pyassem.PyFlowGraph(name, func.filename, args, optimized = 1)
  1416.         self.isLambda = isLambda
  1417.         self.super_init()
  1418.         if not isLambda and func.doc:
  1419.             self.setDocstring(func.doc)
  1420.         
  1421.         lnf = walk(func.code, self.NameFinder(args), verbose = 0)
  1422.         self.locals.push(lnf.getLocals())
  1423.         if func.varargs:
  1424.             self.graph.setFlag(CO_VARARGS)
  1425.         
  1426.         if func.kwargs:
  1427.             self.graph.setFlag(CO_VARKEYWORDS)
  1428.         
  1429.         self.set_lineno(func)
  1430.         if hasTupleArg:
  1431.             self.generateArgUnpack(func.argnames)
  1432.         
  1433.  
  1434.     
  1435.     def get_module(self):
  1436.         return self.module
  1437.  
  1438.     
  1439.     def finish(self):
  1440.         self.graph.startExitBlock()
  1441.         if not self.isLambda:
  1442.             self.emit('LOAD_CONST', None)
  1443.         
  1444.         self.emit('RETURN_VALUE')
  1445.  
  1446.     
  1447.     def generateArgUnpack(self, args):
  1448.         for i in range(len(args)):
  1449.             arg = args[i]
  1450.             if isinstance(arg, tuple):
  1451.                 self.emit('LOAD_FAST', '.%d' % i * 2)
  1452.                 self.unpackSequence(arg)
  1453.                 continue
  1454.         
  1455.  
  1456.     
  1457.     def unpackSequence(self, tup):
  1458.         if VERSION > 1:
  1459.             self.emit('UNPACK_SEQUENCE', len(tup))
  1460.         else:
  1461.             self.emit('UNPACK_TUPLE', len(tup))
  1462.         for elt in tup:
  1463.             if isinstance(elt, tuple):
  1464.                 self.unpackSequence(elt)
  1465.                 continue
  1466.             self._nameOp('STORE', elt)
  1467.         
  1468.  
  1469.     unpackTuple = unpackSequence
  1470.  
  1471.  
  1472. class FunctionCodeGenerator(NestedScopeMixin, AbstractFunctionCode, CodeGenerator):
  1473.     super_init = CodeGenerator.__init__
  1474.     scopes = None
  1475.     __super_init = AbstractFunctionCode.__init__
  1476.     
  1477.     def __init__(self, func, scopes, isLambda, class_name, mod):
  1478.         self.scopes = scopes
  1479.         self.scope = scopes[func]
  1480.         self._FunctionCodeGenerator__super_init(func, scopes, isLambda, class_name, mod)
  1481.         self.graph.setFreeVars(self.scope.get_free_vars())
  1482.         self.graph.setCellVars(self.scope.get_cell_vars())
  1483.         if self.scope.generator is not None:
  1484.             self.graph.setFlag(CO_GENERATOR)
  1485.         
  1486.  
  1487.  
  1488.  
  1489. class GenExprCodeGenerator(NestedScopeMixin, AbstractFunctionCode, CodeGenerator):
  1490.     super_init = CodeGenerator.__init__
  1491.     scopes = None
  1492.     __super_init = AbstractFunctionCode.__init__
  1493.     
  1494.     def __init__(self, gexp, scopes, class_name, mod):
  1495.         self.scopes = scopes
  1496.         self.scope = scopes[gexp]
  1497.         self._GenExprCodeGenerator__super_init(gexp, scopes, 1, class_name, mod)
  1498.         self.graph.setFreeVars(self.scope.get_free_vars())
  1499.         self.graph.setCellVars(self.scope.get_cell_vars())
  1500.         self.graph.setFlag(CO_GENERATOR)
  1501.  
  1502.  
  1503.  
  1504. class AbstractClassCode:
  1505.     
  1506.     def __init__(self, klass, scopes, module):
  1507.         self.class_name = klass.name
  1508.         self.module = module
  1509.         self.graph = pyassem.PyFlowGraph(klass.name, klass.filename, optimized = 0, klass = 1)
  1510.         self.super_init()
  1511.         lnf = walk(klass.code, self.NameFinder(), verbose = 0)
  1512.         self.locals.push(lnf.getLocals())
  1513.         self.graph.setFlag(CO_NEWLOCALS)
  1514.         if klass.doc:
  1515.             self.setDocstring(klass.doc)
  1516.         
  1517.  
  1518.     
  1519.     def get_module(self):
  1520.         return self.module
  1521.  
  1522.     
  1523.     def finish(self):
  1524.         self.graph.startExitBlock()
  1525.         self.emit('LOAD_LOCALS')
  1526.         self.emit('RETURN_VALUE')
  1527.  
  1528.  
  1529.  
  1530. class ClassCodeGenerator(NestedScopeMixin, AbstractClassCode, CodeGenerator):
  1531.     super_init = CodeGenerator.__init__
  1532.     scopes = None
  1533.     __super_init = AbstractClassCode.__init__
  1534.     
  1535.     def __init__(self, klass, scopes, module):
  1536.         self.scopes = scopes
  1537.         self.scope = scopes[klass]
  1538.         self._ClassCodeGenerator__super_init(klass, scopes, module)
  1539.         self.graph.setFreeVars(self.scope.get_free_vars())
  1540.         self.graph.setCellVars(self.scope.get_cell_vars())
  1541.         self.set_lineno(klass)
  1542.         self.emit('LOAD_GLOBAL', '__name__')
  1543.         self.storeName('__module__')
  1544.         if klass.doc:
  1545.             self.emit('LOAD_CONST', klass.doc)
  1546.             self.storeName('__doc__')
  1547.         
  1548.  
  1549.  
  1550.  
  1551. def generateArgList(arglist):
  1552.     args = []
  1553.     extra = []
  1554.     count = 0
  1555.     for i in range(len(arglist)):
  1556.         elt = arglist[i]
  1557.         if isinstance(elt, str):
  1558.             args.append(elt)
  1559.             continue
  1560.         if isinstance(elt, tuple):
  1561.             args.append(TupleArg(i * 2, elt))
  1562.             extra.extend(misc.flatten(elt))
  1563.             count = count + 1
  1564.             continue
  1565.         raise ValueError, 'unexpect argument type:', elt
  1566.     
  1567.     return (args + extra, count)
  1568.  
  1569.  
  1570. def findOp(node):
  1571.     v = OpFinder()
  1572.     walk(node, v, verbose = 0)
  1573.     return v.op
  1574.  
  1575.  
  1576. class OpFinder:
  1577.     
  1578.     def __init__(self):
  1579.         self.op = None
  1580.  
  1581.     
  1582.     def visitAssName(self, node):
  1583.         if self.op is None:
  1584.             self.op = node.flags
  1585.         elif self.op != node.flags:
  1586.             raise ValueError, 'mixed ops in stmt'
  1587.         
  1588.  
  1589.     visitAssAttr = visitAssName
  1590.     visitSubscript = visitAssName
  1591.  
  1592.  
  1593. class Delegator:
  1594.     
  1595.     def __init__(self, obj):
  1596.         self.obj = obj
  1597.  
  1598.     
  1599.     def __getattr__(self, attr):
  1600.         return getattr(self.obj, attr)
  1601.  
  1602.  
  1603.  
  1604. class AugGetattr(Delegator):
  1605.     pass
  1606.  
  1607.  
  1608. class AugName(Delegator):
  1609.     pass
  1610.  
  1611.  
  1612. class AugSlice(Delegator):
  1613.     pass
  1614.  
  1615.  
  1616. class AugSubscript(Delegator):
  1617.     pass
  1618.  
  1619. wrapper = {
  1620.     ast.Getattr: AugGetattr,
  1621.     ast.Name: AugName,
  1622.     ast.Slice: AugSlice,
  1623.     ast.Subscript: AugSubscript }
  1624.  
  1625. def wrap_aug(node):
  1626.     return wrapper[node.__class__](node)
  1627.  
  1628. if __name__ == '__main__':
  1629.     for file in sys.argv[1:]:
  1630.         compileFile(file)
  1631.     
  1632.  
  1633.