DRY scanner34 and scanner35

handle 3.0..3.4 build maps as key/value pairs

uncompyle6/scanners/scanner3.py

@@ -21,6 +21,8 @@ Finally we save token information.
 from __future__ import print_function
 
 import dis
+import uncompyle6.scanners.dis3 as dis3
+
 from collections import namedtuple
 from array import array
 
@@ -42,6 +44,142 @@ class Scanner3(scan.Scanner):
         self.version = version
         scan.Scanner.__init__(self, version)
 
+    def disassemble3(self, co, opnames, classname=None, code_objects={}):
+
+        # import dis; dis.disassemble(co) # DEBUG
+
+        # Container for tokens
+        tokens = []
+
+        customize = {}
+        self.code = array('B', co.co_code)
+        self.build_lines_data(co)
+        self.build_prev_op()
+
+        bytecode = dis3.Bytecode(co, opnames)
+
+        # self.lines contains (block,addrLastInstr)
+        if classname:
+            classname = '_' + classname.lstrip('_') + '__'
+
+            def unmangle(name):
+                if name.startswith(classname) and name[-2:] != '__':
+                    return name[len(classname) - 2:]
+                return name
+        else:
+            pass
+
+        # Scan for assertions. Later we will
+        # turn 'LOAD_GLOBAL' to 'LOAD_ASSERT' for those
+        # assertions
+        self.load_asserts = set()
+        bs = list(bytecode)
+        n = len(bs)
+        for i in range(n):
+            inst = bs[i]
+
+            if inst.opname == 'POP_JUMP_IF_TRUE' and i+1 < n:
+                next_inst = bs[i+1]
+                if (next_inst.opname == 'LOAD_GLOBAL' and
+                    next_inst.argval == 'AssertionError'):
+                    self.load_asserts.add(next_inst.offset)
+
+        # Get jump targets
+        # Format: {target offset: [jump offsets]}
+        jump_targets = self.find_jump_targets()
+
+        for inst in bytecode:
+            if inst.offset in jump_targets:
+                jump_idx = 0
+                for jump_offset in jump_targets[inst.offset]:
+                    tokens.append(Token('COME_FROM', None, repr(jump_offset),
+                                        offset='%s_%s' % (inst.offset, jump_idx)))
+                    jump_idx += 1
+                    pass
+                pass
+
+            pattr =  inst.argrepr
+            opname = inst.opname
+
+            if opname in ['LOAD_CONST']:
+                const = inst.argval
+                if iscode(const):
+                    if const.co_name == '<lambda>':
+                        opname = 'LOAD_LAMBDA'
+                    elif const.co_name == '<genexpr>':
+                        opname = 'LOAD_GENEXPR'
+                    elif const.co_name == '<dictcomp>':
+                        opname = 'LOAD_DICTCOMP'
+                    elif const.co_name == '<setcomp>':
+                        opname = 'LOAD_SETCOMP'
+                    elif const.co_name == '<listcomp>':
+                        opname = 'LOAD_LISTCOMP'
+                    # verify() uses 'pattr' for comparison, since 'attr'
+                    # now holds Code(const) and thus can not be used
+                    # for comparison (todo: think about changing this)
+                    # pattr = 'code_object @ 0x%x %s->%s' %\
+                    # (id(const), const.co_filename, const.co_name)
+                    pattr = '<code_object ' + const.co_name + '>'
+                else:
+                    pattr = const
+                    pass
+            elif opname == 'MAKE_FUNCTION':
+                argc = inst.argval
+                attr = ((argc & 0xFF), (argc >> 8) & 0xFF, (argc >> 16) & 0x7FFF)
+                pos_args, name_pair_args, annotate_args = attr
+                if name_pair_args > 0:
+                    opname = 'MAKE_FUNCTION_N%d' % name_pair_args
+                    pass
+                if annotate_args > 0:
+                    opname = '%s_A_%d' % [op_name, annotate_args]
+                    pass
+                opname = '%s_%d' % (opname, pos_args)
+                pattr = ("%d positional, %d keyword pair, %d annotated" %
+                             (pos_args, name_pair_args, annotate_args))
+                tokens.append(
+                    Token(
+                        type_ = opname,
+                        attr = (pos_args, name_pair_args, annotate_args),
+                        pattr = pattr,
+                        offset = inst.offset,
+                        linestart = inst.starts_line)
+                    )
+                continue
+            elif opname in ('BUILD_LIST', 'BUILD_TUPLE', 'BUILD_SET', 'BUILD_SLICE',
+                            'BUILD_MAP', 'UNPACK_SEQUENCE', 'MAKE_CLOSURE',
+                            'RAISE_VARARGS'
+                            ):
+                pos_args = inst.argval
+                if inst.opname != 'BUILD_SLICE':
+                    customize[opname] = pos_args
+                    pass
+                opname = '%s_%d' % (opname, pos_args)
+            elif opname == 'JUMP_ABSOLUTE':
+                pattr = inst.argval
+                target = self.get_target(inst.offset)
+                if target < inst.offset:
+                    if (inst.offset in self.stmts and
+                        self.code[inst.offset+3] not in (END_FINALLY, POP_BLOCK)
+                        and inst.offset not in self.not_continue):
+                        opname = 'CONTINUE'
+                    else:
+                        opname = 'JUMP_BACK'
+
+            elif inst.offset in self.load_asserts:
+                opname = 'LOAD_ASSERT'
+
+            tokens.append(
+                Token(
+                    type_ = opname,
+                    attr = inst.argval,
+                    pattr = pattr,
+                    offset = inst.offset,
+                    linestart = inst.starts_line,
+                    )
+                )
+            pass
+        return tokens, {}
+
     def disassemble_generic(self, co, classname=None, code_objects={}):
         """
         Convert code object <co> into a sequence of tokens.