Lib/dis.py

   1 """Disassembler of Python byte code into mnemonics."""
   2
   3 import sys
   4 import types
   5
   6 from opcode import *
   7 from opcode import __all__ as _opcodes_all
   8
   9 __all__ = ["dis","disassemble","distb","disco"] + _opcodes_all
  10 del _opcodes_all
  11
  12 def dis(x=None):
  13     """Disassemble classes, methods, functions, or code.
  14
  15     With no argument, disassemble the last traceback.
  16
  17     """
  18     if x is None:
  19         distb()
  20         return
  21     if type(x) is types.InstanceType:
  22         x = x.__class__
  23     if hasattr(x, 'im_func'):
  24         x = x.im_func
  25     if hasattr(x, 'func_code'):
  26         x = x.func_code
  27     if hasattr(x, '__dict__'):
  28         items = x.__dict__.items()
  29         items.sort()
  30         for name, x1 in items:
  31             if type(x1) in (types.MethodType,
  32                             types.FunctionType,
  33                             types.CodeType,
  34                             types.ClassType):
  35                 print "Disassembly of %s:" % name
  36                 try:
  37                     dis(x1)
  38                 except TypeError, msg:
  39                     print "Sorry:", msg
  40                 print
  41     elif hasattr(x, 'co_code'):
  42         disassemble(x)
  43     elif isinstance(x, str):
  44         disassemble_string(x)
  45     else:
  46         raise TypeError, \
  47               "don't know how to disassemble %s objects" % \
  48               type(x).__name__
  49
  50 def distb(tb=None):
  51     """Disassemble a traceback (default: last traceback)."""
  52     if tb is None:
  53         try:
  54             tb = sys.last_traceback
  55         except AttributeError:
  56             raise RuntimeError, "no last traceback to disassemble"
  57         while tb.tb_next: tb = tb.tb_next
  58     disassemble(tb.tb_frame.f_code, tb.tb_lasti)
  59
  60 def disassemble(co, lasti=-1):
  61     """Disassemble a code object."""
  62     code = co.co_code
  63
  64     byte_increments = [ord(c) for c in co.co_lnotab[0::2]]
  65     line_increments = [ord(c) for c in co.co_lnotab[1::2]]
  66     table_length = len(byte_increments) # == len(line_increments)
  67
  68     lineno = co.co_firstlineno
  69     table_index = 0
  70     while (table_index < table_length
  71            and byte_increments[table_index] == 0):
  72         lineno += line_increments[table_index]
  73         table_index += 1
  74     addr = 0
  75     line_incr = 0
  76
  77     labels = findlabels(code)
  78     n = len(code)
  79     i = 0
  80     extended_arg = 0
  81     free = None
  82     while i < n:
  83         c = code[i]
  84         op = ord(c)
  85
  86         if i >= addr:
  87             lineno += line_incr
  88             while table_index < table_length:
  89                 addr += byte_increments[table_index]
  90                 line_incr = line_increments[table_index]
  91                 table_index += 1
  92                 if line_incr:
  93                     break
  94             else:
  95                 addr = sys.maxint
  96             if i > 0:
  97                 print
  98             print "%3d"%lineno,
  99         else:
 100             print '   ',
 101
 102         if i == lasti: print '-->',
 103         else: print '   ',
 104         if i in labels: print '>>',
 105         else: print '  ',
 106         print `i`.rjust(4),
 107         print opname[op].ljust(20),
 108         i = i+1
 109         if op >= HAVE_ARGUMENT:
 110             oparg = ord(code[i]) + ord(code[i+1])*256 + extended_arg
 111             extended_arg = 0
 112             i = i+2
 113             if op == EXTENDED_ARG:
 114                 extended_arg = oparg*65536L
 115             print `oparg`.rjust(5),
 116             if op in hasconst:
 117                 print '(' + `co.co_consts[oparg]` + ')',
 118             elif op in hasname:
 119                 print '(' + co.co_names[oparg] + ')',
 120             elif op in hasjrel:
 121                 print '(to ' + `i + oparg` + ')',
 122             elif op in haslocal:
 123                 print '(' + co.co_varnames[oparg] + ')',
 124             elif op in hascompare:
 125                 print '(' + cmp_op[oparg] + ')',
 126             elif op in hasfree:
 127                 if free is None:
 128                     free = co.co_cellvars + co.co_freevars
 129                 print '(' + free[oparg] + ')',
 130         print
 131
 132 def disassemble_string(code, lasti=-1, varnames=None, names=None,
 133                        constants=None):
 134     labels = findlabels(code)
 135     n = len(code)
 136     i = 0
 137     while i < n:
 138         c = code[i]
 139         op = ord(c)
 140         if op == opmap['SET_LINENO'] and i > 0:
 141             print # Extra blank line
 142         if i == lasti: print '-->',
 143         else: print '   ',
 144         if i in labels: print '>>',
 145         else: print '  ',
 146         print `i`.rjust(4),
 147         print opname[op].ljust(15),
 148         i = i+1
 149         if op >= HAVE_ARGUMENT:
 150             oparg = ord(code[i]) + ord(code[i+1])*256
 151             i = i+2
 152             print `oparg`.rjust(5),
 153             if op in hasconst:
 154                 if constants:
 155                     print '(' + `constants[oparg]` + ')',
 156                 else:
 157                     print '(%d)'%oparg,
 158             elif op in hasname:
 159                 if names is not None:
 160                     print '(' + names[oparg] + ')',
 161                 else:
 162                     print '(%d)'%oparg,
 163             elif op in hasjrel:
 164                 print '(to ' + `i + oparg` + ')',
 165             elif op in haslocal:
 166                 if varnames:
 167                     print '(' + varnames[oparg] + ')',
 168                 else:
 169                     print '(%d)' % oparg,
 170             elif op in hascompare:
 171                 print '(' + cmp_op[oparg] + ')',
 172         print
 173
 174 disco = disassemble                     # XXX For backwards compatibility
 175
 176 def findlabels(code):
 177     """Detect all offsets in a byte code which are jump targets.
 178
 179     Return the list of offsets.
 180
 181     """
 182     labels = []
 183     n = len(code)
 184     i = 0
 185     while i < n:
 186         c = code[i]
 187         op = ord(c)
 188         i = i+1
 189         if op >= HAVE_ARGUMENT:
 190             oparg = ord(code[i]) + ord(code[i+1])*256
 191             i = i+2
 192             label = -1
 193             if op in hasjrel:
 194                 label = i+oparg
 195             elif op in hasjabs:
 196                 label = oparg
 197             if label >= 0:
 198                 if label not in labels:
 199                     labels.append(label)
 200     return labels
 201
 202
 203 def _test():
 204     """Simple test program to disassemble a file."""
 205     if sys.argv[1:]:
 206         if sys.argv[2:]:
 207             sys.stderr.write("usage: python dis.py [-|file]\n")
 208             sys.exit(2)
 209         fn = sys.argv[1]
 210         if not fn or fn == "-":
 211             fn = None
 212     else:
 213         fn = None
 214     if fn is None:
 215         f = sys.stdin
 216     else:
 217         f = open(fn)
 218     source = f.read()
 219     if fn is not None:
 220         f.close()
 221     else:
 222         fn = "<stdin>"
 223     code = compile(source, fn, "exec")
 224     dis(code)
 225
 226 if __name__ == "__main__":
 227     _test()