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     labels = findlabels(code)
  64     linestarts = dict(findlinestarts(co))
  65     n = len(code)
  66     i = 0
  67     extended_arg = 0
  68     free = None
  69     while i < n:
  70         c = code[i]
  71         op = ord(c)
  72         if i in linestarts:
  73             if i > 0:
  74                 print
  75             print "%3d" % linestarts[i],
  76         else:
  77             print '   ',
  78
  79         if i == lasti: print '-->',
  80         else: print '   ',
  81         if i in labels: print '>>',
  82         else: print '  ',
  83         print repr(i).rjust(4),
  84         print opname[op].ljust(20),
  85         i = i+1
  86         if op >= HAVE_ARGUMENT:
  87             oparg = ord(code[i]) + ord(code[i+1])*256 + extended_arg
  88             extended_arg = 0
  89             i = i+2
  90             if op == EXTENDED_ARG:
  91                 extended_arg = oparg*65536L
  92             print repr(oparg).rjust(5),
  93             if op in hasconst:
  94                 print '(' + repr(co.co_consts[oparg]) + ')',
  95             elif op in hasname:
  96                 print '(' + co.co_names[oparg] + ')',
  97             elif op in hasjrel:
  98                 print '(to ' + repr(i + oparg) + ')',
  99             elif op in haslocal:
 100                 print '(' + co.co_varnames[oparg] + ')',
 101             elif op in hascompare:
 102                 print '(' + cmp_op[oparg] + ')',
 103             elif op in hasfree:
 104                 if free is None:
 105                     free = co.co_cellvars + co.co_freevars
 106                 print '(' + free[oparg] + ')',
 107         print
 108
 109 def disassemble_string(code, lasti=-1, varnames=None, names=None,
 110                        constants=None):
 111     labels = findlabels(code)
 112     n = len(code)
 113     i = 0
 114     while i < n:
 115         c = code[i]
 116         op = ord(c)
 117         if i == lasti: print '-->',
 118         else: print '   ',
 119         if i in labels: print '>>',
 120         else: print '  ',
 121         print repr(i).rjust(4),
 122         print opname[op].ljust(15),
 123         i = i+1
 124         if op >= HAVE_ARGUMENT:
 125             oparg = ord(code[i]) + ord(code[i+1])*256
 126             i = i+2
 127             print repr(oparg).rjust(5),
 128             if op in hasconst:
 129                 if constants:
 130                     print '(' + repr(constants[oparg]) + ')',
 131                 else:
 132                     print '(%d)'%oparg,
 133             elif op in hasname:
 134                 if names is not None:
 135                     print '(' + names[oparg] + ')',
 136                 else:
 137                     print '(%d)'%oparg,
 138             elif op in hasjrel:
 139                 print '(to ' + repr(i + oparg) + ')',
 140             elif op in haslocal:
 141                 if varnames:
 142                     print '(' + varnames[oparg] + ')',
 143                 else:
 144                     print '(%d)' % oparg,
 145             elif op in hascompare:
 146                 print '(' + cmp_op[oparg] + ')',
 147         print
 148
 149 disco = disassemble                     # XXX For backwards compatibility
 150
 151 def findlabels(code):
 152     """Detect all offsets in a byte code which are jump targets.
 153
 154     Return the list of offsets.
 155
 156     """
 157     labels = []
 158     n = len(code)
 159     i = 0
 160     while i < n:
 161         c = code[i]
 162         op = ord(c)
 163         i = i+1
 164         if op >= HAVE_ARGUMENT:
 165             oparg = ord(code[i]) + ord(code[i+1])*256
 166             i = i+2
 167             label = -1
 168             if op in hasjrel:
 169                 label = i+oparg
 170             elif op in hasjabs:
 171                 label = oparg
 172             if label >= 0:
 173                 if label not in labels:
 174                     labels.append(label)
 175     return labels
 176
 177 def findlinestarts(code):
 178     """Find the offsets in a byte code which are start of lines in the source.
 179
 180     Generate pairs (offset, lineno) as described in Python/compile.c.
 181
 182     """
 183     byte_increments = [ord(c) for c in code.co_lnotab[0::2]]
 184     line_increments = [ord(c) for c in code.co_lnotab[1::2]]
 185
 186     lastlineno = None
 187     lineno = code.co_firstlineno
 188     addr = 0
 189     for byte_incr, line_incr in zip(byte_increments, line_increments):
 190         if byte_incr:
 191             if lineno != lastlineno:
 192                 yield (addr, lineno)
 193                 lastlineno = lineno
 194             addr += byte_incr
 195         lineno += line_incr
 196     if lineno != lastlineno:
 197         yield (addr, lineno)
 198
 199 def _test():
 200     """Simple test program to disassemble a file."""
 201     if sys.argv[1:]:
 202         if sys.argv[2:]:
 203             sys.stderr.write("usage: python dis.py [-|file]\n")
 204             sys.exit(2)
 205         fn = sys.argv[1]
 206         if not fn or fn == "-":
 207             fn = None
 208     else:
 209         fn = None
 210     if fn is None:
 211         f = sys.stdin
 212     else:
 213         f = open(fn)
 214     source = f.read()
 215     if fn is not None:
 216         f.close()
 217     else:
 218         fn = "<stdin>"
 219     code = compile(source, fn, "exec")
 220     dis(code)
 221
 222 if __name__ == "__main__":
 223     _test()