Copy the stdlib 'dis' module, and move our copy of the 'opcode' module.

oilshell · Apr 15, 2018 · a0a0b142b95a47c64bf0238e0a25b3d9b8b07c43 · a0a0b14
1 parent bf89a33
commit a0a0b142b95a47c64bf0238e0a25b3d9b8b07c43
Unified Split

Showing with 230 additions and 56 deletions.

+1 −1 opy/callgraph.py

+0 −55 opy/callgraph_demo.py

+4 −0 opy/count.sh

+225 −0 opy/lib/dis.py

0 opy/{compiler2 → lib}/opcode.py
diff --git a/opy/callgraph.py b/opy/callgraph.py
@@ -5,13 +5,13 @@
 """

 import collections
-import dis
 import os
 import sys

 import __builtin__  # For looking up names
 import types

+from .lib import dis
 from .lib import inspect

 from core import util
diff --git a/opy/callgraph_demo.py b/opy/callgraph_demo.py
diff --git a/opy/count.sh b/opy/count.sh
@@ -27,6 +27,10 @@ all() {
  ls compiler2/*.py | grep -v ast.py | _count
  echo

+  echo STDLIB
+  echo lib/*.py | _count
+  echo
+
  echo GENERATED CODE
  wc -l compiler2/ast.py
  echo
diff --git a/opy/lib/dis.py b/opy/lib/dis.py
@@ -0,0 +1,225 @@
+from __future__ import print_function  # for OPy compiler
+"""Disassembler of Python byte code into mnemonics."""
+
+import sys
+import types
+
+from opy.lib.opcode import *
+from opy.lib.opcode import __all__ as _opcodes_all
+
+__all__ = ["dis", "disassemble", "distb", "disco",
+           "findlinestarts", "findlabels"] + _opcodes_all
+del _opcodes_all
+
+_have_code = (types.MethodType, types.FunctionType, types.CodeType,
+              types.ClassType, type)
+
+def dis(x=None):
+    """Disassemble classes, methods, functions, or code.
+
+    With no argument, disassemble the last traceback.
+
+    """
+    if x is None:
+        distb()
+        return
+    if isinstance(x, types.InstanceType):
+        x = x.__class__
+    if hasattr(x, 'im_func'):
+        x = x.im_func
+    if hasattr(x, 'func_code'):
+        x = x.func_code
+    if hasattr(x, '__dict__'):
+        items = x.__dict__.items()
+        items.sort()
+        for name, x1 in items:
+            if isinstance(x1, _have_code):
+                print("Disassembly of %s:" % name)
+                try:
+                    dis(x1)
+                except TypeError, msg:
+                    print("Sorry:", msg)
+                print()
+    elif hasattr(x, 'co_code'):
+        disassemble(x)
+    elif isinstance(x, str):
+        disassemble_string(x)
+    else:
+        raise TypeError, \
+              "don't know how to disassemble %s objects" % \
+              type(x).__name__
+
+def distb(tb=None):
+    """Disassemble a traceback (default: last traceback)."""
+    if tb is None:
+        try:
+            tb = sys.last_traceback
+        except AttributeError:
+            raise RuntimeError, "no last traceback to disassemble"
+        while tb.tb_next: tb = tb.tb_next
+    disassemble(tb.tb_frame.f_code, tb.tb_lasti)
+
+def disassemble(co, lasti=-1):
+    """Disassemble a code object."""
+    code = co.co_code
+    labels = findlabels(code)
+    linestarts = dict(findlinestarts(co))
+    n = len(code)
+    i = 0
+    extended_arg = 0
+    free = None
+    while i < n:
+        c = code[i]
+        op = ord(c)
+        if i in linestarts:
+            if i > 0:
+                print()
+            print("%3d" % linestarts[i], end=' ')
+        else:
+            print('   ', end=' ')
+
+        if i == lasti: print('-->', end=' ')
+        else: print('   ', end=' ')
+        if i in labels: print('>>', end=' ')
+        else: print('  ', end=' ')
+        print(repr(i).rjust(4), end=' ')
+        print(opname[op].ljust(20), end=' ')
+        i = i+1
+        if op >= HAVE_ARGUMENT:
+            oparg = ord(code[i]) + ord(code[i+1])*256 + extended_arg
+            extended_arg = 0
+            i = i+2
+            if op == EXTENDED_ARG:
+                extended_arg = oparg*65536L
+            print(repr(oparg).rjust(5), end=' ')
+            if op in hasconst:
+                print('(' + repr(co.co_consts[oparg]) + ')', end=' ')
+            elif op in hasname:
+                print('(' + co.co_names[oparg] + ')', end=' ')
+            elif op in hasjrel:
+                print('(to ' + repr(i + oparg) + ')', end=' ')
+            elif op in haslocal:
+                print('(' + co.co_varnames[oparg] + ')', end=' ')
+            elif op in hascompare:
+                print('(' + cmp_op[oparg] + ')', end=' ')
+            elif op in hasfree:
+                if free is None:
+                    free = co.co_cellvars + co.co_freevars
+                print('(' + free[oparg] + ')', end=' ')
+        print()
+
+def disassemble_string(code, lasti=-1, varnames=None, names=None,
+                       constants=None):
+    labels = findlabels(code)
+    n = len(code)
+    i = 0
+    while i < n:
+        c = code[i]
+        op = ord(c)
+        if i == lasti: print('-->', end=' ')
+        else: print('   ', end=' ')
+        if i in labels: print('>>', end=' ')
+        else: print('  ', end=' ')
+        print(repr(i).rjust(4), end=' ')
+        print(opname[op].ljust(15), end=' ')
+        i = i+1
+        if op >= HAVE_ARGUMENT:
+            oparg = ord(code[i]) + ord(code[i+1])*256
+            i = i+2
+            print(repr(oparg).rjust(5), end=' ')
+            if op in hasconst:
+                if constants:
+                    print('(' + repr(constants[oparg]) + ')', end=' ')
+                else:
+                    print('(%d)'%oparg, end=' ')
+            elif op in hasname:
+                if names is not None:
+                    print('(' + names[oparg] + ')', end=' ')
+                else:
+                    print('(%d)'%oparg, end=' ')
+            elif op in hasjrel:
+                print('(to ' + repr(i + oparg) + ')', end=' ')
+            elif op in haslocal:
+                if varnames:
+                    print('(' + varnames[oparg] + ')', end=' ')
+                else:
+                    print('(%d)' % oparg, end=' ')
+            elif op in hascompare:
+                print('(' + cmp_op[oparg] + ')', end=' ')
+        print()
+
+disco = disassemble                     # XXX For backwards compatibility
+
+def findlabels(code):
+    """Detect all offsets in a byte code which are jump targets.
+
+    Return the list of offsets.
+
+    """
+    labels = []
+    n = len(code)
+    i = 0
+    while i < n:
+        c = code[i]
+        op = ord(c)
+        i = i+1
+        if op >= HAVE_ARGUMENT:
+            oparg = ord(code[i]) + ord(code[i+1])*256
+            i = i+2
+            label = -1
+            if op in hasjrel:
+                label = i+oparg
+            elif op in hasjabs:
+                label = oparg
+            if label >= 0:
+                if label not in labels:
+                    labels.append(label)
+    return labels
+
+def findlinestarts(code):
+    """Find the offsets in a byte code which are start of lines in the source.
+
+    Generate pairs (offset, lineno) as described in Python/compile.c.
+
+    """
+    byte_increments = [ord(c) for c in code.co_lnotab[0::2]]
+    line_increments = [ord(c) for c in code.co_lnotab[1::2]]
+
+    lastlineno = None
+    lineno = code.co_firstlineno
+    addr = 0
+    for byte_incr, line_incr in zip(byte_increments, line_increments):
+        if byte_incr:
+            if lineno != lastlineno:
+                yield (addr, lineno)
+                lastlineno = lineno
+            addr += byte_incr
+        lineno += line_incr
+    if lineno != lastlineno:
+        yield (addr, lineno)
+
+def _test():
+    """Simple test program to disassemble a file."""
+    if sys.argv[1:]:
+        if sys.argv[2:]:
+            sys.stderr.write("usage: python dis.py [-|file]\n")
+            sys.exit(2)
+        fn = sys.argv[1]
+        if not fn or fn == "-":
+            fn = None
+    else:
+        fn = None
+    if fn is None:
+        f = sys.stdin
+    else:
+        f = open(fn)
+    source = f.read()
+    if fn is not None:
+        f.close()
+    else:
+        fn = "<stdin>"
+    code = compile(source, fn, "exec")
+    dis(code)
+
+if __name__ == "__main__":
+    _test()
diff --git a/opy/compiler2/opcode.py → opy/lib/opcode.py b/opy/compiler2/opcode.py → opy/lib/opcode.py