#
# decompile.py - decompile Python code objects
#
# Copyright (c) 2001 Jonathan Patrick Giddy
#
# Permission is hereby granted, free of charge, to any person obtaining 
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
# 
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# Send comments to:
# Jonathan Giddy, jongiddy@pobox.co.uk

# version 0.9
# Date 21 January 2005
# - no code changes, added MIT licence, updated email address
# - there will be no v1.0 - try decompyle instead

# version 0.8
# Date 25 January 2001

__version__ = '0.9'

import dis, string, sys, types

VARARGS = 4
KWARGS = 8

PRECEDENCE_ATOM = 24
PRECEDENCE_POWER = 17
PRECEDENCE_UNARY = 16
PRECEDENCE_MULT = 15
PRECEDENCE_ADD = 14
PRECEDENCE_SHIFT = 13
PRECEDENCE_BAND = 12
PRECEDENCE_BXOR = 11
PRECEDENCE_BOR = 10
PRECEDENCE_CMP = 9
PRECEDENCE_IS = 8
PRECEDENCE_IN = 7
PRECEDENCE_NOT = 6
PRECEDENCE_AND = 5
PRECEDENCE_OR = 4
PRECEDENCE_LAMBDA = 3
PRECEDENCE_ARG = PRECEDENCE_LAMBDA
PRECEDENCE_COMMA = 1
PRECEDENCE_NONE = 0

def current_line(code, i):
    tab = code.co_lnotab
    line = code.co_firstlineno
    stopat = i
    addr = 0
    for i in range(0, len(tab), 2):
        addr = addr + ord(tab[i])
        if addr > stopat:
            break
        line = line + ord(tab[i+1])
    return line

class Expression:

    def __init__(self, value, precedence):
        self.value = value
        self.precedence = precedence

    def __repr__(self):
        return 'Expression(%s, %s)' % (`self.value`, `self.precedence`)
    
    def __str__(self):
        return str(self.value)

    def Precedence(self):
        return self.precedence
    
    def Value(self):
        return self.value

    def GetString(self, precedence):
        if self.Precedence() < precedence:
            return '(%s)' % self
        else:
            return str(self)

class Atom(Expression):

    def __init__(self, value):
        Expression.__init__(self, value, PRECEDENCE_ATOM)

class Constant(Atom):

    def __str__(self):
        if self.value is Ellipsis:
            return '...'
        else:
            return repr(self.value)
        
class Local(Atom):
    pass

class Global(Atom):
    pass

class Map(Atom):

    def __init__(self):
        Atom.__init__(self, [])

    def __str__(self):
        return '{%s}' % string.join(self.value, ', ')

    def SetAttr(self, name, value):
        self.value.append("%s: %s" % (name, value))

class Tuple(Atom):

    def __init__(self, values):
        Atom.__init__(self, values)

    def __str__(self):
        values = self.Value()
        if len(values) == 0:
            return '()'
        elif len(values) == 1:
            # This doesn't need the parens immediately, but
            # it emphasises the prescence of the comma, and
            # confirms that it is a 1-tuple
            return '(%s,)' % values[0]
        else:
            return string.join(values, ', ')

    def Precedence(self):
        if len(self.value) <= 1:
            return PRECEDENCE_ATOM
        else:
            return PRECEDENCE_COMMA

    def Value(self):
        return tuple(self.value)
            
class CodeCursor:

    def __init__(self, code):
        self.code = code  # code object
        self.i = 0        # instruction pointer
        self.extend = 0   # extended opcodes
        self.lineno = 1   # minimum possible line number
        self.lastop = 0   # pointer to last operator read
        self.stopi = [len(code.co_code)]

    def GetPosition(self):
        return self.i

    def AtEnd(self):
        return self.i == self.stopi[0]
    
    def GetLine(self):
        return max(self.lineno, current_line(self.code, self.lastop))

    def SetLine(self, lineno):
        assert lineno >= self.lineno, `lineno, self.lineno`
        self.lineno = lineno
        
    def PushStop(self, i):
        self.stopi.append(i)

    def PopStop(self):
        return self.stopi.pop()

    def NextOpcode(self):
        if self.i < self.stopi[-1]:
            c = self.code.co_code[self.i]
            op = ord(c)
            opcode = dis.opname[op]
            if opcode == 'EXTENDED_ARG':
                self.i = self.i + 1
                self.extend = self.ReadOperand()
                return self.NextOpcode()
        else:
            opcode = None
        return opcode

    def ReadOpcode(self, *args):
        opcode = self.NextOpcode()
        assert opcode is not None
        if args:
            assert opcode in args, `self.i, opcode`
        self.lastop = self.i
        self.i = self.i + 1
        return opcode

    def ReadOperand(self):
        assert self.i + 1 < self.stopi[-1], `self.i, self.stopi`
        co_code = self.code.co_code
        operand = ord(co_code[self.i]) + ord(co_code[self.i+1])*256 + \
                  (self.extend << 16)
        self.extend = 0
        self.i = self.i + 2
        return operand

    def GetConstant(self, n):
        return self.code.co_consts[n]

    def GetLocal(self, n):
        assert n < len(self.code.co_varnames), `n, self.code.co_varnames`
        return self.code.co_varnames[n]
    
    def GetName(self, n):
        assert n < len(self.code.co_names), `n, self.code.co_names`
        return self.code.co_names[n]
    
class Decompiler:

    def __init__(self, version):
        self.version = version
        self.stack = []
        self.lines = {}
        self.global_decl = {}
        self.loop = None
    
    def decompile(self, code, *termop):
        try:
            self.code = code
            opcode = code.NextOpcode()
            while opcode is not None and opcode not in termop:
                opcode = string.replace(opcode, '+', '_')
                method = getattr(self, opcode)
                apply(method, (code,))
                opcode = code.NextOpcode()
        except:
            dis.dis(code.code)
            print
            raise

    def getstack(self):
        return self.stack
    
    def getsource(self, indent):
        assert not self.stack, `self.stack`
        lines = {}
        if not self.lines:
            self.lines[self.code.GetLine()] = 'pass'
        for key, value in self.lines.items():
            lines[key] = '    ' * indent + value
        return lines

    def addline(self, lineno, line):
        assert type(line) == type(''), `line`
        prev = self.lines.get(lineno)
        if prev is None:
            self.lines[lineno] = line
        else:
            self.lines[lineno] = '%s; %s' % (prev, line)

    def addclause(self, lineno, head, body):
        if body.has_key(lineno):
            if 0:
                assert len(body) == 1, `body`
                self.addline(lineno, "%s %s" % (head, string.strip(body[lineno])))
            else:
                line = body[lineno]
                self.addline(lineno, "%s %s" % (head, string.strip(line)))
                del body[lineno]
                self.lines.update(body)
                body[lineno] = line
        else:
            self.addline(lineno, head)
            self.lines.update(body)
        self.code.SetLine(max(body.keys()) + 1)

    def SET_LINENO(self, code):
        code.ReadOpcode('SET_LINENO')
        code.ReadOperand()

    def BINARY_ADD(self, code):
        code.ReadOpcode('BINARY_ADD')
        y = self.stack.pop().GetString(PRECEDENCE_ADD+1)
        x = self.stack.pop().GetString(PRECEDENCE_ADD)
        self.stack.append(Expression('%s + %s' % (x, y), PRECEDENCE_ADD))

    def BINARY_AND(self, code):
        code.ReadOpcode('BINARY_AND')
        y = self.stack.pop().GetString(PRECEDENCE_BAND+1)
        x = self.stack.pop().GetString(PRECEDENCE_BAND)
        self.stack.append(Expression('%s & %s' % (x, y), PRECEDENCE_BAND))

    def BINARY_DIVIDE(self, code):
        code.ReadOpcode('BINARY_DIVIDE')
        y = self.stack.pop().GetString(PRECEDENCE_MULT+1)
        x = self.stack.pop().GetString(PRECEDENCE_MULT)
        self.stack.append(Expression('%s / %s' % (x, y), PRECEDENCE_MULT))

    def BINARY_LSHIFT(self, code):
        code.ReadOpcode('BINARY_LSHIFT')
        y = self.stack.pop().GetString(PRECEDENCE_SHIFT+1)
        x = self.stack.pop().GetString(PRECEDENCE_SHIFT)
        self.stack.append(Expression('%s << %s' % (x, y), PRECEDENCE_SHIFT))

    def BINARY_MODULO(self, code):
        code.ReadOpcode('BINARY_MODULO')
        y = self.stack.pop().GetString(PRECEDENCE_MULT+1)
        x = self.stack.pop().GetString(PRECEDENCE_MULT)
        self.stack.append(Expression('%s %% %s' % (x, y), PRECEDENCE_MULT))

    def BINARY_MULTIPLY(self, code):
        code.ReadOpcode('BINARY_MULTIPLY')
        y = self.stack.pop().GetString(PRECEDENCE_MULT+1)
        x = self.stack.pop().GetString(PRECEDENCE_MULT)
        self.stack.append(Expression('%s * %s' % (x, y), PRECEDENCE_MULT))

    def BINARY_OR(self, code):
        code.ReadOpcode('BINARY_OR')
        y = self.stack.pop().GetString(PRECEDENCE_BOR+1)
        x = self.stack.pop().GetString(PRECEDENCE_BOR)
        self.stack.append(Expression('%s | %s' % (x, y), PRECEDENCE_BOR))

    def BINARY_POWER(self, code):
        code.ReadOpcode('BINARY_POWER')
        y = self.stack.pop()
        if y.Precedence() == PRECEDENCE_POWER:
            # include ** in parentheses because the correct order is poorly
            # understood, and is the opposite of the other binary operators
            y = y.GetString(PRECEDENCE_ATOM)
        else:
            y = y.GetString(PRECEDENCE_UNARY)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('%s ** %s' % (x, y), PRECEDENCE_POWER))

    def BINARY_RSHIFT(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_SHIFT+1)
        x = self.stack.pop().GetString(PRECEDENCE_SHIFT)
        self.stack.append(Expression('%s >> %s' % (x, y), PRECEDENCE_SHIFT))

    def BINARY_SUBSCR(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_NONE)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('%s[%s]' % (x, y), PRECEDENCE_ATOM))

    def BINARY_SUBTRACT(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_ADD+1)
        x = self.stack.pop().GetString(PRECEDENCE_ADD)
        self.stack.append(Expression('%s - %s' % (x, y), PRECEDENCE_ADD))

    def BINARY_XOR(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_BXOR+1)
        x = self.stack.pop().GetString(PRECEDENCE_BXOR)
        self.stack.append(Expression('%s ^ %s' % (x, y), PRECEDENCE_BXOR))

    def BREAK_LOOP(self, code):
        code.ReadOpcode('BREAK_LOOP')
        self.addline(code.GetLine(), 'break')
        
    def BUILD_LIST(self, code):
        code.ReadOpcode('BUILD_LIST')
        oparg = code.ReadOperand()
        values = []
        for i in range(oparg):
            value = self.stack.pop()
            if value.Precedence() < PRECEDENCE_ARG:
                value = '(%s)' % value
            values.append(str(value))
        values.reverse()
        valuelist = string.join(values, ', ')
        self.stack.append(Expression('[%s]' % valuelist, PRECEDENCE_ATOM))

    def BUILD_MAP(self, code):
        code.ReadOpcode('BUILD_MAP')
        code.ReadOperand()
        self.stack.append(Map())

    def BUILD_SLICE(self, code):
        code.ReadOpcode()
        code.ReadOperand()
        z = self.stack.pop()
        if isinstance(z, Constant) and z.Value() is None:
            z = ''
        else:
            z = z.GetString(PRECEDENCE_ARG)
        y = self.stack.pop()
        if isinstance(y, Constant) and y.Value() is None:
            y = ''
        else:
            y = y.GetString(PRECEDENCE_ARG)
        x = self.stack.pop()
        if isinstance(x, Constant) and x.Value() is None:
            x = ''
        else:
            x = x.GetString(PRECEDENCE_ARG)
        # always goes into BINARY_SUBSCR, so precedence is irrelevant
        self.stack.append(Expression('%s:%s:%s' % (x, y, z), PRECEDENCE_NONE))
        
    def BUILD_TUPLE(self, code):
        code.ReadOpcode()
        oparg = code.ReadOperand()
        values = []
        for i in range(oparg):
            value = self.stack.pop().GetString(PRECEDENCE_ARG)
            values.append(value)
        values.reverse()
        self.stack.append(Tuple(values))

    def CALL_FUNCTION(self, code):
        opcode = code.ReadOpcode('CALL_FUNCTION', 'CALL_FUNCTION_VAR',
                                 'CALL_FUNCTION_KW', 'CALL_FUNCTION_VAR_KW')
        oparg = code.ReadOperand()
        nkw, nargs = divmod(oparg, 256)
        args = []
        if opcode in ('CALL_FUNCTION_KW', 'CALL_FUNCTION_VAR_KW'):
            name = self.stack.pop()
            args.append('**%s' % name)
        if opcode in ('CALL_FUNCTION_VAR', 'CALL_FUNCTION_VAR_KW'):
            name = self.stack.pop()
            args.append('*%s' % name)
        for i in range(nkw):
            value = self.stack.pop().GetString(PRECEDENCE_ARG)
            name = self.stack.pop().Value()
            args.append('%s=%s' % (name, value))
        for i in range(nargs):
            arg = self.stack.pop().GetString(PRECEDENCE_ARG)
            args.append(str(arg))
        args.reverse()
        arglist = string.join(args, ', ')
        func = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('%s(%s)' % (func, arglist),
                                     PRECEDENCE_ATOM))

    CALL_FUNCTION_VAR = CALL_FUNCTION
    CALL_FUNCTION_KW = CALL_FUNCTION
    CALL_FUNCTION_VAR_KW = CALL_FUNCTION
    
    def COMPARE_OP(self, code):
        code.ReadOpcode()
        oparg = code.ReadOperand()
        if len(self.stack) == 1:
            y = self.stack.pop()
            x = None
        else:
            y = self.stack.pop()
            x = self.stack.pop()
        op = dis.cmp_op[oparg]
        if op[0] in '!<=>':
            prec = PRECEDENCE_CMP
        elif op[-2:] == 'in':
            prec = PRECEDENCE_IN
        else:
            assert op[:2] == 'is', `op`
            prec = PRECEDENCE_IS
        if y.Precedence() <= prec:
            y = '(%s)' % y
        if x is None:
            self.stack.append(Chain('%s %s' % (op, y)))
        else:
            if x.Precedence() < prec:
                x = '(%s)' % x
            self.stack.append(Expression('%s %s %s' % (x, op, y), prec))

    def DELETE_ATTR(self, code):
        code.ReadOpcode()
        oparg = code.ReadOperand()
        attr = code.GetName(oparg)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.addline(code.GetLine(), 'del %s.%s' % (x, attr))
        
    def DELETE_FAST(self, code):
        names = []
        lastlineno = -1
        while code.NextOpcode() in ('DELETE_FAST', 'DELETE_GLOBAL',
                                    'DELETE_NAME'):
            opcode = code.ReadOpcode()
            if lastlineno == -1:
                lineno = lastlineno = code.GetLine()
            else:
                lineno = code.GetLine()
            if lineno != lastlineno:
                self.addline(lastlineno, 'del %s' % string.join(names, ', '))
                names = []
                lastlineno = lineno
            oparg = code.ReadOperand()
            if opcode == 'DELETE_FAST':
                names.append(code.GetLocal(oparg))
            elif opcode == 'DELETE_GLOBAL':
                names.append(code.GetName(oparg))
            else:
                assert opcode == 'DELETE_NAME', `opcode`
                names.append(code.GetName(oparg))
        self.addline(lastlineno, 'del %s' % string.join(names, ', '))

    DELETE_GLOBAL = DELETE_FAST
    DELETE_NAME = DELETE_FAST

    def DELETE_SLICE_0(self, code):
        code.ReadOpcode()
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.addline(code.GetLine(), 'del %s[:]' % x)

    def DELETE_SLICE_1(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.addline(code.GetLine(), 'del %s[%s:]' % (x, y))

    def DELETE_SLICE_2(self, code):
        code.ReadOpcode()
        z = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.addline(code.GetLine(), 'del %s[:%s]' % (x, z))
        
    def DELETE_SLICE_3(self, code):
        code.ReadOpcode()
        z = self.stack.pop().GetString(PRECEDENCE_ARG)
        y = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.addline(code.GetLine(), 'del %s[%s:%s]' % (x, y, z))
        
    def DELETE_SUBSCR(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_NONE)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.addline(code.GetLine(), 'del %s[%s]' % (x, y))

    def DUP_TOP(self, code):
        code.ReadOpcode('DUP_TOP')
        self.stack.append(self.stack[-1])
        
    def DUP_TOPX(self, code):
        code.ReadOpcode('DUP_TOPX')
        n = code.ReadOperand()
        self.stack = self.stack + self.stack[-n:]
        
    def EXEC_STMT(self, code):
        code.ReadOpcode('EXEC_STMT')
        lineno = code.GetLine()
        locals = self.stack.pop()
        globals = self.stack.pop()
        stmt = self.stack.pop().GetString(PRECEDENCE_IN)
        if isinstance(globals, Constant) and globals.Value() is None:
            self.addline(lineno, 'exec %s' % stmt)
        else:
            if locals is globals:
                globals = globals.GetString(PRECEDENCE_ARG)
                self.addline(lineno, 'exec %s in %s' % (stmt, globals))
            else:
                globals = globals.GetString(PRECEDENCE_ARG)
                locals = locals.GetString(PRECEDENCE_ARG)
                self.addline(lineno,
                             'exec %s in %s, %s' % (stmt, globals, locals))

    def FOR_LOOP(self, code):
        code.ReadOpcode('FOR_LOOP')
        leap = code.ReadOperand()
        loopcleanup = code.GetPosition() + leap
        self.stack.pop()  # sequence index
        forlist = self.stack.pop()
        forvar = self.build_target(code).GetString(PRECEDENCE_NONE)
        head = "for %s in %s:" % (forvar, forlist)
        lineno = code.GetLine()
        d = Decompiler(self.version)
        d.decompile(code, 'JUMP_ABSOLUTE')
        self.addclause(lineno, head, d.getsource(1))
        code.ReadOpcode('JUMP_ABSOLUTE')
        oparg = code.ReadOperand()  # to FOR_LOOP (or SET_LINENO)
        assert code.GetPosition() == loopcleanup
        code.ReadOpcode('POP_BLOCK')
        end = self.loop[1]
        self.loop = None
        if code.GetPosition() < end:
            lineno = code.GetLine()
            code.PushStop(end)
            d = Decompiler(self.version)
            d.decompile(code)
            code.PopStop()
            self.addclause(lineno, "else:", d.getsource(1))
        assert code.GetPosition() == end
        
    def IMPORT_NAME(self, code):
        names = []
        while code.NextOpcode() == 'IMPORT_NAME':
            code.ReadOpcode('IMPORT_NAME')
            if self.version >= (2, 0):
                self.stack.pop()
            oparg = code.ReadOperand()
            module = code.GetName(oparg)
            opname = code.ReadOpcode('IMPORT_FROM', 'IMPORT_STAR',
                                     'STORE_FAST', 'STORE_NAME')
            if opname in ('IMPORT_FROM', 'IMPORT_STAR'):
                if names:
                    self.addline('import %s' % string.join(names, ', '))
                    names = []
                if opname == 'IMPORT_STAR':
                    objs = '*'
                else:
                    while opname == 'IMPORT_FROM':
                        oparg = code.ReadOperand()
                        name1 = code.GetName(oparg)
                        if self.version >= (2, 0):
                            opname = code.ReadOpcode('STORE_FAST', 'STORE_NAME')
                            oparg = code.ReadOperand()
                            if opname == 'STORE_FAST':
                                name2 = code.GetLocal(oparg)
                            else:
                                name2 = code.GetName(oparg)
                        else:
                            name2 = name1
                        if name1 == name2:
                            names.append(name1)
                        else:
                            names.append('%s as %s' % (name1, name2))
                        opname = code.ReadOpcode('IMPORT_FROM', 'POP_TOP')
                    objs = string.join(names, ', ')
                self.addline(code.GetLine(),
                             'from %s import %s' %
                             (module, objs))
                names = []
            else:
                assert opname in ('STORE_FAST', 'STORE_NAME'), `opname`
                oparg = code.ReadOperand()
                if opname == 'STORE_FAST':
                    name = code.GetLocal(oparg)
                else:
                    name = code.GetName(oparg)
                if module == name:
                    names.append(module)
                else:
                    names.append("%s as %s" % (module, name))
        if names:
            self.addline(code.GetLine(),
                         'import %s' % string.join(names, ', '))

    def INPLACE_ADD(self, code):
        opcode = code.ReadOpcode(
            'INPLACE_ADD', 'INPLACE_AND', 'INPLACE_DIVIDE', 'INPLACE_LSHIFT',
            'INPLACE_MODULO', 'INPLACE_MULTIPLY', 'INPLACE_OR', 'INPLACE_POWER',
            'INPLACE_RSHIFT', 'INPLACE_SUBTRACT', 'INPLACE_XOR')
        if opcode == 'INPLACE_ADD':
            op = '+='
        elif opcode == 'INPLACE_AND':
            op = '&='
        elif opcode == 'INPLACE_DIVIDE':
            op = '/='
        elif opcode == 'INPLACE_LSHIFT':
            op = '<<='
        elif opcode == 'INPLACE_MODULO':
            op = '%='
        elif opcode == 'INPLACE_MULTIPLY':
            op = '*='
        elif opcode == 'INPLACE_OR':
            op = '|='
        elif opcode == 'INPLACE_POWER':
            op = '**='
        elif opcode == 'INPLACE_RSHIFT':
            op = '>>='
        elif opcode == 'INPLACE_SUBTRACT':
            op = '-='
        else:
            assert opcode == 'INPLACE_XOR', `opcode`
            op = '^='
        y = self.stack.pop().GetString(PRECEDENCE_NONE)
        x = self.stack.pop().GetString(PRECEDENCE_NONE)
        opcode = code.ReadOpcode('ROT_THREE', 'ROT_TWO', 'STORE_FAST',
                                 'STORE_GLOBAL')
        if opcode == 'STORE_FAST':
            code.ReadOperand()
        elif opcode == 'STORE_GLOBAL':
            code.ReadOperand()
        elif opcode == 'STORE_NAME':
            code.ReadOperand()
        elif opcode == 'ROT_THREE':
            code.ReadOpcode('STORE_SUBSCR')
            self.stack.pop()
            self.stack.pop()
        elif opcode == 'ROT_TWO':
            code.ReadOpcode('STORE_ATTR')
            code.ReadOperand()
            self.stack.pop()
        self.addline(code.GetLine(), '%s %s %s' % (x, op, y))

    INPLACE_AND = INPLACE_ADD
    INPLACE_DIVIDE = INPLACE_ADD
    INPLACE_LSHIFT = INPLACE_ADD
    INPLACE_MODULO = INPLACE_ADD
    INPLACE_MULTIPLY = INPLACE_ADD
    INPLACE_OR = INPLACE_ADD
    INPLACE_POWER = INPLACE_ADD
    INPLACE_RSHIFT = INPLACE_ADD
    INPLACE_SUBTRACT = INPLACE_ADD
    INPLACE_XOR = INPLACE_ADD
    
    def JUMP_ABSOLUTE(self, code):
        code.ReadOpcode('JUMP_ABSOLUTE')
        code.ReadOperand()
        self.addline(code.GetLine(), 'continue')
        
    def JUMP_IF_FALSE(self, code):
        code.ReadOpcode('JUMP_IF_FALSE')
        leap = code.ReadOperand()
        endcond = code.GetPosition() + leap
        opcode = code.ReadOpcode('POP_TOP')
        assert opcode == 'POP_TOP', `opcode`
        lineno = code.GetLine()
        code.PushStop(endcond)
        d = Decompiler(self.version)
        if self.loop is None:
            d.decompile(code, 'JUMP_FORWARD')
        else:
            d.decompile(code, 'JUMP_ABSOLUTE')
        code.PopStop()
        stack = d.getstack()
        if stack:
            if len(stack) == 1:
                assert code.GetPosition() == endcond
                # and
                x = self.stack.pop().GetString(PRECEDENCE_AND+1)
                y = stack.pop().GetString(PRECEDENCE_AND)
                self.stack.append(
                    Expression('%s and %s' % (x, y), PRECEDENCE_AND))
            else:
                # assert
                self.stack.pop()
                test = stack.pop().GetString(PRECEDENCE_ARG)
                value = stack.pop()
                if value is None:
                    self.addline(lineno, 'assert %s' % test)
                else:
                    value = value.GetString(PRECEDENCE_ARG)
                    self.addline(lineno, 'assert %s, %s' % (test, value))
                code.ReadOpcode('POP_TOP')
        else:
            condition = self.stack.pop()
            body = d.getsource(1)
            if self.loop is None:
                # if
                self.addclause(lineno, 'if %s:' % condition, body)
                code.ReadOpcode('JUMP_FORWARD')
                leap = code.ReadOperand()
                end = code.GetPosition() + leap
                code.ReadOpcode('POP_TOP')
                while code.GetPosition() < end:
                    lineno = code.GetLine()
                    code.PushStop(end)
                    d = Decompiler(self.version)
                    d.decompile(code, 'JUMP_FORWARD')
                    code.PopStop()
                    body = d.getsource(1)
                    if body.has_key(lineno):
                        if body[lineno][-1] == ':':
                            # elif
                            body = d.getsource(0)
                            body[lineno] = 'el' + body[lineno]
                            self.lines.update(body)
                        else:
                            #assert len(body) == 1, `body`
                            line = body[lineno]
                            self.addline(lineno, "else: %s" %
                                         string.strip(line))
                            del body[lineno]
                            self.lines.update(body)
                            body[lineno] = line
                    else:
                        self.addline(lineno, "else:")
                        self.lines.update(body)
                    code.SetLine(max(body.keys()) + 1)
            else:
                # while
                self.addclause(lineno, "while %s:" % condition, body)
                code.ReadOpcode('JUMP_ABSOLUTE')
                oparg = code.ReadOperand()
                assert oparg == self.loop[0], `(oparg, self.loop)`
                code.ReadOpcode('POP_TOP')
                code.ReadOpcode('POP_BLOCK')
                end = self.loop[1]
                self.loop = None
                if code.GetPosition() < end:
                    lineno = code.GetLine()
                    code.PushStop(end)
                    d = Decompiler(self.version)
                    d.decompile(code)
                    code.PopStop()
                    self.addclause(lineno, "else:", d.getsource(1))
            assert code.GetPosition() == end

    def JUMP_IF_TRUE(self, code):
        code.ReadOpcode('JUMP_IF_TRUE')
        leap = code.ReadOperand()
        end = code.GetPosition() + leap
        code.ReadOpcode('POP_TOP')
        code.PushStop(end)
        d = Decompiler(self.version)
        d.decompile(code, 'RAISE_VARARGS')
        code.PopStop()
        stack = d.getstack()
        assert stack
        if code.GetPosition() == end:
            # or expression
            x = self.stack.pop().GetString(PRECEDENCE_OR+1)
            y = stack.pop().GetString(PRECEDENCE_OR)
            self.stack.append(Expression('%s or %s' % (x, y), PRECEDENCE_OR))
        else:
            # raise AssertionError, exp
            test = self.stack.pop()
            code.ReadOpcode('RAISE_VARARGS')
            oparg = code.ReadOperand()
            if oparg == 1:
                self.stack.append(None)
            else:
                value = stack.pop()
                self.stack.append(value)
            self.stack.append(test)
            assert len(self.stack) == 2, `self.stack`
        assert code.GetPosition() == end

    def LOAD_ATTR(self, code):
        code.ReadOpcode('LOAD_ATTR')
        oparg = code.ReadOperand()
        attr = code.GetName(oparg)
        x = self.stack.pop()
        if x.Precedence() < PRECEDENCE_ATOM:
            x = '(%s)' % x
        self.stack.append(Expression('%s.%s' % (x, attr), PRECEDENCE_ATOM))
        
    def LOAD_CONST(self, code):
        code.ReadOpcode('LOAD_CONST')
        oparg = code.ReadOperand()
        self.stack.append(Constant(code.GetConstant(oparg)))

    def LOAD_FAST(self, code):
        code.ReadOpcode('LOAD_FAST')
        oparg = code.ReadOperand()
        self.stack.append(Local(code.GetLocal(oparg)))
        
    def LOAD_GLOBAL(self, code):
        code.ReadOpcode('LOAD_GLOBAL')
        oparg = code.ReadOperand()
        self.stack.append(Global(code.GetName(oparg)))

    def LOAD_LOCALS(self, code):
        code.ReadOpcode('LOAD_LOCALS')
        self.stack.append(Constant(None))
        
    def LOAD_NAME(self, code):
        code.ReadOpcode('LOAD_NAME')
        oparg = code.ReadOperand()
        self.stack.append(Local(code.GetName(oparg)))

    def MAKE_FUNCTION(self, code):
        code.ReadOpcode('MAKE_FUNCTION')
        defaultcount = code.ReadOperand()
        co = self.stack.pop().Value()
        if co.co_name == '<lambda>':
            # lambda
            # Get the function def part
            params = []
            argcount = co.co_argcount
            while argcount:
                argcount = argcount - 1
                name = co.co_varnames[argcount]
                if defaultcount:
                    defaultcount = defaultcount - 1
                    default = self.stack.pop().GetString(PRECEDENCE_ARG)
                    params.append('%s=%s' % (name, default))
                else:
                    params.append(name)
            params.reverse()
            argcount = co.co_argcount
            if co.co_flags & VARARGS:
                params.append('*' + co.co_varnames[argcount])
                argcount = argcount + 1
            if co.co_flags & KWARGS:
                params.append('**' + co.co_varnames[argcount])
            paramlist = string.join(params, ', ')
            # get the function body
            d = Decompiler(self.version)
            d.decompile(CodeCursor(co), 'RETURN_VALUE')
            stack = d.getstack()
            assert len(stack) == 1, `stack`
            y = stack.pop().GetString(PRECEDENCE_LAMBDA)
            self.stack.append(
                Expression('lambda %s: %s' % (paramlist, y), PRECEDENCE_LAMBDA))
        else:
            opcode = code.ReadOpcode('CALL_FUNCTION', 'STORE_FAST',
                                     'STORE_NAME')
            if opcode == 'CALL_FUNCTION':
                # class
                oparg = code.ReadOperand()
                assert oparg == 0, `oparg`
                code.ReadOpcode('BUILD_CLASS')
                super = self.stack.pop().Value()
                name = self.stack.pop().Value()
                opcode = code.ReadOpcode('STORE_FAST', 'STORE_NAME')
                oparg = code.ReadOperand()
                if opcode == 'STORE_FAST':
                    classname = code.GetLocal(oparg)
                else:
                    classname = code.GetName(oparg)
                assert name == classname, `name, classname`
                if super:
                    classname = '%s(%s)' % (classname, string.join(super, ', '))
                lineno = code.GetLine()
                d = Decompiler(self.version)
                d.decompile(CodeCursor(co))
                body = d.getsource(1)
                if body.has_key(lineno):
                    if len(body) == 1:
                        self.addline(lineno, "class %s: %s" % (classname,
                                      string.strip(body[lineno])))
                    else:
                        assert 0
                        # __doc__ string appears in 0th row
                        assert not body.has_key(lineno+1), `body`
                        body[lineno+1] = body[lineno]
                        del body[lineno]
                        self.addline(lineno, "class %s:" % classname)
                        self.lines.update(body)
                else:
                    self.addline(lineno, "class %s:" % classname)
                    self.lines.update(body)
                code.SetLine(max(body.keys()) + 1)
            else:
                assert opcode in ('STORE_FAST', 'STORE_NAME'), `opcode`
                # def
                oparg = code.ReadOperand()
                if opcode == 'STORE_FAST':
                    funcname = code.GetLocal(oparg)
                else:
                    funcname = code.GetName(oparg)
                # Get the function def part
                params = []
                argcount = co.co_argcount
                while argcount:
                    argcount = argcount - 1
                    name = co.co_varnames[argcount]
                    if defaultcount:
                        defaultcount = defaultcount - 1
                        default = self.stack.pop()
                        if default.Precedence() < PRECEDENCE_ARG:
                            default = '(%s)' % default
                        params.append('%s=%s' % (name, default))
                    else:
                        params.append(name)
                params.reverse()
                argcount = co.co_argcount
                if co.co_flags & VARARGS:
                    params.append('*' + co.co_varnames[argcount])
                    argcount = argcount + 1
                if co.co_flags & KWARGS:
                    params.append('**' + co.co_varnames[argcount])
                paramlist = string.join(params, ', ')
                head = "def %s(%s):" % (funcname, paramlist)
                # get the function body
                lineno = code.GetLine()
                d = Decompiler(self.version)
                d.decompile(CodeCursor(co))
                self.addclause(lineno, head, d.getsource(1))

    def PRINT_ITEM(self, code):
        code.ReadOpcode('PRINT_ITEM')
        x = self.stack.pop().GetString(PRECEDENCE_ARG)
        if code.NextOpcode() == 'PRINT_NEWLINE':
            code.ReadOpcode('PRINT_NEWLINE')
            self.addline(code.GetLine(), 'print %s' % x)
        else:
            self.addline(code.GetLine(), 'print %s,' % x)

    def PRINT_ITEM_TO(self, code):
        # XXX - if file is an expression, it gets evaluated multiple times.
        code.ReadOpcode('PRINT_ITEM_TO')
        file = self.stack.pop()
        x = self.stack.pop().GetString(PRECEDENCE_ARG)
        if code.NextOpcode() == 'PRINT_NEWLINE_TO' and self.stack[-1] is file:
            code.ReadOpcode('PRINT_NEWLINE_TO')
            self.stack.pop()
            if file.Precedence() < PRECEDENCE_ARG:
                file = '(%s)' % file
            self.addline('print >> %s, %s' % (file, x))
        else:
            if file.Precedence() < PRECEDENCE_ARG:
                file = '(%s)' % file
            self.addline('print >> %s, %s,' % (file, x))

    def PRINT_NEWLINE(self, code):
        code.ReadOpcode('PRINT_NEWLINE')
        self.addline(code.GetLine(), 'print')
        
    def PRINT_NEWLINE_TO(self, code):
        code.ReadOpcode('PRINT_NEWLINE')
        file = self.stack.pop().GetString(PRECEDENCE_ARG)
        self.addline(code.GetLine(), 'print >> %s' % file)
        
    def POP_TOP(self, code):
        code.ReadOpcode('POP_TOP')
        self.addline(code.GetLine(),
                     self.stack.pop().GetString(PRECEDENCE_NONE))

    def RAISE_VARARGS(self, code):
        code.ReadOpcode('RAISE_VARARGS')
        argcount = code.ReadOperand()
        args = []
        for i in range(argcount):
            arg = self.stack.pop().GetString(PRECEDENCE_ARG)
            args.append(arg)
        args.reverse()
        self.addline(code.GetLine(), 'raise %s' % string.join(args, ', '))
        
    def RETURN_VALUE(self, code):
        code.ReadOpcode()
        y = self.stack.pop()
        if isinstance(y, Constant) and y.Value() is None:
            if not code.AtEnd():
                self.addline(code.GetLine(), 'return')
        else:
            value = y.GetString(PRECEDENCE_NONE)
            self.addline(code.GetLine(), 'return %s' % value)

    def ROT_THREE(self, code):
        code.ReadOpcode('ROT_THREE')
        assert len(self.stack) >= 3, `code.GetPosition(), self.stack`
        self.stack.pop()  # duplicate of y
        y = self.stack.pop().GetString(PRECEDENCE_CMP+1)
        x = self.stack.pop().GetString(PRECEDENCE_CMP+1)
        code.ReadOpcode('COMPARE_OP')
        oparg = code.ReadOperand()
        op = dis.cmp_op[oparg]
        chain = '%s %s %s' % (x, op, y)
        opcode = code.ReadOpcode('JUMP_IF_FALSE')
        leap = code.ReadOperand()
        stop1 = code.GetPosition() + leap
        while opcode == 'JUMP_IF_FALSE':
            assert code.GetPosition() + leap == stop1, \
                   `code.GetPosition(), leap, stop1`
            code.ReadOpcode('POP_TOP')
            code.PushStop(stop1 - 6)
            d = Decompiler(self.version)
            d.decompile(code, 'ROT_THREE')
            code.PopStop()
            stack = d.getstack()
            y = stack.pop().GetString(PRECEDENCE_CMP+1)
            opcode = code.ReadOpcode('COMPARE_OP', 'ROT_THREE')
            if opcode == 'ROT_THREE':
                opcode = code.ReadOpcode('COMPARE_OP')
            oparg = code.ReadOperand()
            op = dis.cmp_op[oparg]
            chain = '%s %s %s' % (chain, op, y)
            opcode = code.ReadOpcode('JUMP_IF_FALSE', 'JUMP_FORWARD')
            leap = code.ReadOperand()
        assert leap == 2, `leap`
        assert code.GetPosition() == stop1, `code.GetPosition(), stop1`
        code.ReadOpcode('ROT_TWO')
        code.ReadOpcode('POP_TOP')
        self.stack.append(Expression(chain, PRECEDENCE_CMP))

    def ROT_TWO(self, code):
        code.ReadOpcode('ROT_TWO')
        n1 = self.stack.pop()
        n2 = self.stack.pop()
        self.stack.append(n1)
        self.stack.append(n2)

    def handle_except_clause(self, code):
        opcode = code.ReadOpcode('DUP_TOP', 'POP_TOP', 'SET_LINENO')
        if opcode == 'SET_LINENO':
            code.ReadOperand()
            opcode = code.ReadOpcode('DUP_TOP', 'POP_TOP')
        lineno = code.GetLine()
        if opcode == 'DUP_TOP':
            d = Decompiler(self.version)
            d.decompile(code, 'COMPARE_OP')
            stack = d.getstack()
            exc_type = stack.pop().GetString(PRECEDENCE_ARG)
            code.ReadOpcode('COMPARE_OP')
            oparg = code.ReadOperand()
            assert oparg == 10, `oparg`  # 10 -> exception match
            code.ReadOpcode('JUMP_IF_FALSE')
            leap = code.ReadOperand()
            nextclause = code.GetPosition() + leap
            code.ReadOpcode('POP_TOP')  # result of test
            code.ReadOpcode('POP_TOP')  # exc_type
            opcode = code.NextOpcode()
            if opcode == 'POP_TOP':  # exc_value
                code.ReadOpcode('POP_TOP')
                head = 'except %s:' % exc_type
            else:
                exc_value = self.build_target(code).GetString(PRECEDENCE_ARG)
                head = 'except %s, %s:' % (exc_type, exc_value)
        else:
            code.ReadOpcode('POP_TOP')  # exc_value
            head = 'except:'
            nextclause = None
        code.ReadOpcode('POP_TOP')  # exc_tb
        d = Decompiler(self.version)
        d.decompile(code, 'JUMP_FORWARD')
        self.addclause(lineno, head, d.getsource(1))
        code.ReadOpcode('JUMP_FORWARD')
        leap = code.ReadOperand()
        end = code.GetPosition() + leap
        if nextclause is not None:
            assert code.GetPosition() == nextclause
            code.ReadOpcode('POP_TOP')
        return end
        
    def SETUP_EXCEPT(self, code):
        code.ReadOpcode('SETUP_EXCEPT')
        leap = code.ReadOperand()
        firstexceptclause = code.GetPosition() + leap
        lineno = code.GetLine()
        d = Decompiler(self.version)
        d.decompile(code, 'POP_BLOCK')
        self.addclause(lineno, "try:", d.getsource(1))
        code.ReadOpcode('POP_BLOCK')
        code.ReadOpcode('JUMP_FORWARD')
        leap = code.ReadOperand()
        elseclause = code.GetPosition() + leap
        assert code.GetPosition() == firstexceptclause
        end = self.handle_except_clause(code)
        while code.NextOpcode() != 'END_FINALLY':
            end1 = self.handle_except_clause(code)
            assert end1 == end, `end1, end`
        code.ReadOpcode('END_FINALLY')
        assert code.GetPosition() == elseclause, \
               `code.GetPosition(), elseclause`
        if elseclause < end:
            lineno = code.GetLine()
            code.PushStop(end)
            d = Decompiler(self.version)
            d.decompile(code)
            code.PopStop()
            self.addclause(lineno, "else:", d.getsource(1))
        assert code.GetPosition() == end
        
    def SETUP_FINALLY(self, code):
        code.ReadOpcode('SETUP_FINALLY')
        leap = code.ReadOperand()
        finallyclause = code.GetPosition() + leap
        lineno = code.GetLine()
        d = Decompiler(self.version)
        d.decompile(code, 'POP_BLOCK')
        body = d.getsource(1)
        self.addclause(lineno, "try:", body)
        code.ReadOpcode('POP_BLOCK')
        code.ReadOpcode('LOAD_CONST')
        oparg = code.ReadOperand()
        assert oparg == 0, `oparg`
        assert code.GetPosition() == finallyclause
        lineno = code.GetLine()
        d = Decompiler(self.version)
        d.decompile(code, 'END_FINALLY')
        body = d.getsource(1)
        self.addclause(lineno, "finally:", body)
        code.ReadOpcode('END_FINALLY')
       
    def SETUP_LOOP(self, code):
        code.ReadOpcode('SETUP_LOOP')
        leap = code.ReadOperand()
        assert self.loop is None, `self.loop`
        i = code.GetPosition()
        self.loop = i, i + leap

    def SLICE_0(self, code):
        code.ReadOpcode()
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('%s[:]' % x, PRECEDENCE_ATOM))

    def SLICE_1(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('%s[%s:]' % (x, y), PRECEDENCE_ATOM))

    def SLICE_2(self, code):
        code.ReadOpcode()
        z = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('%s[:%s]' % (x, z), PRECEDENCE_ATOM))
        
    def SLICE_3(self, code):
        code.ReadOpcode()
        z = self.stack.pop().GetString(PRECEDENCE_ARG)
        y = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('%s[%s:%s]' % (x, y, z), PRECEDENCE_ATOM))
        
    def STORE_ATTR(self, code):
        code.ReadOpcode()
        oparg = code.ReadOperand()
        attr = code.GetName(oparg)
        name = self.stack.pop().GetString(PRECEDENCE_ATOM)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s.%s = %s' % (name, attr, value))

    def STORE_FAST(self, code):
        code.ReadOpcode()
        oparg = code.ReadOperand()
        name = code.GetLocal(oparg)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s = %s' % (name, value))

    def STORE_GLOBAL(self, code):
        # XXX - need to put in global statement
        code.ReadOpcode()
        oparg = code.ReadOperand()
        name = code.GetName(oparg)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s = %s' % (name, value))

    def STORE_NAME(self, code):
        code.ReadOpcode()
        oparg = code.ReadOperand()
        name = code.GetName(oparg)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s = %s' % (name, value))

    def STORE_SLICE_0(self, code):
        code.ReadOpcode()
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s[:] = %s' % (x, value))

    def STORE_SLICE_1(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s[%s:] = %s' % (x, y, value))

    def STORE_SLICE_2(self, code):
        code.ReadOpcode()
        z = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s[:%s] = %s' % (x, z, value))
        
    def STORE_SLICE_3(self, code):
        code.ReadOpcode()
        z = self.stack.pop().GetString(PRECEDENCE_ARG)
        y = self.stack.pop().GetString(PRECEDENCE_ARG)
        x = self.stack.pop().GetString(PRECEDENCE_ATOM)
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s[%s:%s] = %s' % (x, y, z, value))
        
    def STORE_SUBSCR(self, code):
        code.ReadOpcode()
        key = self.stack.pop()
        obj = self.stack.pop()
        if isinstance(obj, Map):
            value = self.stack.pop().GetString(PRECEDENCE_ARG)
            if key.Precedence() < PRECEDENCE_ARG:
                key = '(%s)' % key
            obj.SetAttr(key, value)
        else:
            obj = obj.GetString(PRECEDENCE_ATOM)
            value = self.stack.pop().GetString(PRECEDENCE_NONE)
            self.addline(code.GetLine(),
                         '%s[%s] = %s' % (obj, key, value))

    def UNARY_CONVERT(self, code):
        code.ReadOpcode()
        value = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.stack.append(Expression('`%s`' % value, PRECEDENCE_ATOM))
        
    def UNARY_INVERT(self, code):
        code.ReadOpcode()
        # only requires PRECEDENCE_UNARY, but both powers and other
        # unary operators are confusing without parentheses
        y = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('~%s' % y, PRECEDENCE_UNARY))

    def UNARY_NEGATIVE(self, code):
        code.ReadOpcode()
        # only requires PRECEDENCE_UNARY, but both powers and other
        # unary operators are confusing without parentheses
        y = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('-%s' % y, PRECEDENCE_UNARY))

    def UNARY_NOT(self, code):
        code.ReadOpcode()
        y = self.stack.pop().GetString(PRECEDENCE_NOT)
        self.stack.append(Expression('not %s' % y, PRECEDENCE_NOT))

    def UNARY_POSITIVE(self, code):
        code.ReadOpcode()
        # only requires PRECEDENCE_UNARY, but both powers and other
        # unary operators are confusing without parentheses
        y = self.stack.pop().GetString(PRECEDENCE_ATOM)
        self.stack.append(Expression('+%s' % y, PRECEDENCE_UNARY))

    def build_target(self, code):
        if code.NextOpcode() not in ('STORE_FAST', 'STORE_GLOBAL', 'STORE_NAME',
                                     'UNPACK_SEQUENCE', 'UNPACK_TUPLE'):
            d = Decompiler(self.version)
            d.decompile(code, 'STORE_ATTR', 'STORE_SLICE+0', 'STORE_SLICE+1',\
                        'STORE_SLICE+2', 'STORE_SLICE+3', 'STORE_SUBSCR')
        opcode = code.ReadOpcode()
        if opcode == 'STORE_ATTR':
            stack = d.getstack()
            assert len(stack) == 1, `stack`
            name = stack.pop().GetString(PRECEDENCE_ATOM)
            oparg = code.ReadOperand()
            attr = code.GetName(oparg)
            target = Expression('%s.%s' % (name, attr), PRECEDENCE_ATOM)
        elif opcode == 'STORE_FAST':
            oparg = code.ReadOperand()
            target = Local(code.GetLocal(oparg))
        elif opcode == 'STORE_GLOBAL':
            oparg = code.ReadOperand()
            target = Global(code.GetName(oparg))
        elif opcode == 'STORE_NAME':
            oparg = code.ReadOperand()
            target = Local(code.GetName(oparg))
        elif opcode == 'STORE_SLICE+0':
            stack = d.getstack()
            assert len(stack) == 1, `stack`
            x = stack.pop().GetString(PRECEDENCE_ATOM)
            target = Expression('%s[:]' % x, PRECEDENCE_ATOM)
        elif opcode == 'STORE_SLICE+1':
            stack = d.getstack()
            assert len(stack) == 2, `stack`
            y = stack.pop().GetString(PRECEDENCE_ARG)
            x = stack.pop().GetString(PRECEDENCE_ATOM)
            target = Expression('%s[%s:]' % (x, y), PRECEDENCE_ATOM)
        elif opcode == 'STORE_SLICE+2':
            stack = d.getstack()
            assert len(stack) == 2, `stack`
            z = stack.pop().GetString(PRECEDENCE_ARG)
            x = stack.pop().GetString(PRECEDENCE_ATOM)
            target = Expression('%s[:%s]' % (x, z), PRECEDENCE_ATOM)
        elif opcode == 'STORE_SLICE+3':
            stack = d.getstack()
            assert len(stack) == 3, `stack`
            z = stack.pop().GetString(PRECEDENCE_ARG)
            y = stack.pop().GetString(PRECEDENCE_ARG)
            x = stack.pop().GetString(PRECEDENCE_ATOM)
            target = Expression('%s[%s:%s]' % (x, y, z), PRECEDENCE_ATOM)
        elif opcode == 'STORE_SUBSCR':
            stack = d.getstack()
            assert len(stack) == 2, `stack`
            key = stack.pop().GetString(PRECEDENCE_NONE)
            name = stack.pop().GetString(PRECEDENCE_ATOM)
            target = Expression('%s[%s]' % (name, key), PRECEDENCE_ATOM)
        else:
            assert opcode in ('UNPACK_SEQUENCE', 'UNPACK_TUPLE'), `opcode`
            count = code.ReadOperand()
            values = []
            while count > 0:
                value = self.build_target(code).GetString(PRECEDENCE_ARG)
                values.append(value)
                count = count - 1
            target = Tuple(values)
        return target

    def UNPACK_SEQUENCE(self, code):
        seq = self.build_target(code).GetString(PRECEDENCE_NONE)
        rhs = self.stack.pop().GetString(PRECEDENCE_NONE)
        self.addline(code.GetLine(), '%s = %s' % (seq, rhs))
    
    UNPACK_TUPLE = UNPACK_SEQUENCE

# These tests need to be more complete, however, the things that are
# known to be broken are represented
tests = [
    '3\n'           # constant expression
    'a\n'           # name expression
    'a[3][4]\n'     # subscr expression
    'a.b.c\n'       # attr expression
    'a(b, c, d=3, e="d")\n', # function call
    'a = b\n',      # simple assignment
    'a.b.c.d = 2\n',  # attr target
    'a[b][c][d] = 3\n', # subscr target
    'a[:] = 4\n',  # slice targets
    'a[b:] = 5\n',
    'a[:b] = 6\n',
    'a[b:c] = 7\n',
    'a, b, c.d, e[f], g[:], h[i:], j[:k], l[m:n] = z\n', # tuple target
    '(a, b), (c, (d, e)) = t\n', # nested tuple target
    'import spam',
    'import string, spam as ham, sys',
    'from spam import ham, eggs',
    'import spam.ham',    # BROKEN: this type of import
    'from package.spam import ham, eggs as milk',
    'from string import *',
    'def f(a, (b, c)):\n    del f\n', # BROKEN: tuple func args
    'a = b.d = c[3] = a, b = f()',    # BROKEN: chained assignment
    'print >> file, a, b',
    'a = [2*i for i in x]',           # BROKEN: list comprehension
    'if 1:\n  pass\nelif 2: pass\nelse: 3', # BROKEN, swap conditions JUMP_IF_FALSE
    
##    for i in r:
##        print
##    print hello, b
##    a &= 3; b^=9
##    c|=8 ; d <<=2
##    def g(a, b, c=5, d=10, *args, **kw):
##        pass
##    class G(foo):
##        def __init__(self, b=5):
##            "hello"
##            x.k = x.k & (7 * (3 + 4))
##            return x
##    x, y[5][g+4], z.x = 1, 2, 3
##    f(a, b, x=1, **args)
##    try: 1
##    finally: 2
##    if a < b*2 <= c > d:
##        print
##    x = lambda y: (2 * y, 3)
##    class C: pass
##    if 3:
##        print
##    elif 5:
##        del e
##    else:
##        print
##    import sys
##    if 3:
##        print
##    else:
##        i = j + -2 ** -3 ** -2
##        if stuff[0] == '!':
##            stuff = '[^' + stuff[1:] + ']'
##        elif stuff == 'g':
##            stuff = '\\^'
##        else:
##            while stuff[0] == '^':
##                stuff = stuff[1:] + stuff[0]
##            stuff = ('[' + stuff + ']'),
##            
##    a, b, c.b, a[p] = c
##    x = 1 - 2 + 3 - (4 + 5) - 6, 6
##    try:
##        print 2
##    except RuntimeError, exc:
##        del a
##    except IOError:
##        del g
##    except:
##        del b
##    else:
##        del elses
##    if a and b and c:
##        del a
##    if (a and b) and c:
##        del b
##    if a and (b and c):
##        del c
    ]

def test():
    import traceback
    for osrc in tests:
        code1 = compile(osrc, '<string>', 'exec')
        d = Decompiler((2, 0))
        try:
            d.decompile(CodeCursor(code1))
        except:
            print osrc
            print 'FAILS'
            traceback.print_exc(file=sys.stdout)
            print '---'
            continue
        source = d.getsource(0)
        lastline = max(source.keys())
        lines = []
        for lineno in range(1, lastline+2):
            lines.append(source.get(lineno, ''))
        dsrc = string.join(lines, '\n')
        if dsrc == osrc:
            continue
        try:
            code2 = compile(dsrc, '<string>', 'exec')
        except SyntaxError:
            code2 = None
        if code2 and code2.co_code == code1.co_code:
            continue
        print osrc
        print 'BECOMES'
        print dsrc
        print '---'

def f():
    a(b=3, d=3)
    a[x:], b[:] = 1
    # don't work:
##    import spam.ham
##    def f(a, (b, c)):
##        del f
##    a = b.d = c[3] = a, b = f()
##    a = [2*i for i in x]
    
##    import string, x as y
##    from spam.ham import eggs, foo as bar
##    from d import *
##    for i in r:
##        print
    print hello, b
##    a &= 3; b^=9
##    c|=8 ; d <<=2
##    def g(a, b, c=5, d=10, *args, **kw):
##        pass
##    class G(foo):
##        def __init__(self, b=5):
##            "hello"
##            x.k = x.k & (7 * (3 + 4))
##            return x
##    x, y[5][g+4], z.x = 1, 2, 3
##    f(a, b, x=1, **args)
##    try: 1
##    finally: 2
##    if a < b*2 <= c > d:
##        print
##    x = lambda y: (2 * y, 3)
##    class C: pass
##    if 3:
##        print
##    elif 5:
##        del e
##    else:
##        print
##    import sys
##    if 3:
##        print
##    else:
##        i = j + -2 ** -3 ** -2
##        if stuff[0] == '!':
##            stuff = '[^' + stuff[1:] + ']'
##        elif stuff == 'g':
##            stuff = '\\^'
##        else:
##            while stuff[0] == '^':
##                stuff = stuff[1:] + stuff[0]
##            stuff = ('[' + stuff + ']'),
##            
##    a, b, c.b, a[p] = c
##    x = 1 - 2 + 3 - (4 + 5) - 6, 6
##    try:
##        print 2
##    except RuntimeError, exc:
##        del a
##    except IOError:
##        del g
##    except:
##        del b
##    else:
##        del elses
##    if a and b and c:
##        del a
##    if (a and b) and c:
##        del b
##    if a and (b and c):
##        del c
        
if __name__ == '__main__':
  if 1:
    test()
  else:
    out = open(r'E:\output.txt', 'wt')
    try:
        stdout = sys.stdout
        sys.stdout = out
        if 1:
            import marshal
            m = open(r'C:\Python20\Lib\code.pyc', 'rb')
            magic = m.read(4)
            if magic == '\207\306\015\012':
                version = (2, 0)
            elif magic == '\231N\015\012':
                version = (1, 5, 2)
            else:
                raise RuntimeError, 'unrecognised magic: %s' % `magic`
            timestamp = m.read(4)
            s = m.read()
            code = marshal.loads(s)
            m.close()
        else:
            version = (2, 0)
            print f.func_code.co_names
            print f.func_code.co_varnames
            print f.func_code.co_consts
            code = f.func_code
        c = CodeCursor(code)
        d = Decompiler(version)
        d.decompile(c)
        lines = d.getsource(0)
        keys = lines.keys()
        keys.sort()
        for lineno in range(keys[0], keys[-1] + 1):
            print '%4d %s' % (lineno, lines.get(lineno, ''))
        print
        sys.stdout = stdout
    finally:
        out.close()
    sys.stderr.write('DONE\n')