Python 3.6-inspired instruction size cleanup

Revise and generalize for Python 3.6+ instructions vs < 3.6 instuctions.
Used more of the generalized methods in xdis and remove some (but not
all) of the magic numbers.

This is a lot of changes, but not all of the refactoring needed. Much
crap still remains. Also, there are still bugs in handling 3.6 bytecodes.

uncompyle6/scanners/scanner2.py

@@ -25,9 +25,9 @@ from __future__ import print_function
 from collections import namedtuple
 from array import array
 
-from uncompyle6.scanner import L65536
 from xdis.code import iscode
-from xdis.bytecode import op_has_argument, op_size
+from xdis.bytecode import op_has_argument, op_size, instruction_size
+from xdis.util import code2num
 
 from uncompyle6.scanner import Scanner
 
@@ -193,7 +193,7 @@ class Scanner2(Scanner):
                 oparg = self.get_argument(offset) + extended_arg
                 extended_arg = 0
                 if op == self.opc.EXTENDED_ARG:
-                    extended_arg = oparg * L65536
+                    extended_arg += self.extended_arg_val(oparg)
                     continue
                 if op in self.opc.CONST_OPS:
                     const = co.co_consts[oparg]
@@ -485,7 +485,7 @@ class Scanner2(Scanner):
             elif op in self.setup_ops:
                 count_SETUP_ += 1
 
-    def detect_control_flow(self, offset, op):
+    def detect_control_flow(self, offset, op, extended_arg):
         """
         Detect type of block structures and their boundaries to fix optimized jumps
         in python2.3+
@@ -509,14 +509,13 @@ class Scanner2(Scanner):
                 parent = struct
 
         if op == self.opc.SETUP_LOOP:
-
             # We categorize loop types: 'for', 'while', 'while 1' with
             # possibly suffixes '-loop' and '-else'
             # Try to find the jump_back instruction of the loop.
             # It could be a return instruction.
 
-            start = offset+3
-            target = self.get_target(offset, op)
+            start += instruction_size(op, self.opc)
+            target = self.get_target(offset) + extended_arg
             end    = self.restrict_to_parent(target, parent)
             self.setup_loop_targets[offset] = target
             self.setup_loops[target] = offset
@@ -988,12 +987,18 @@ class Scanner2(Scanner):
         self.thens = {} # JUMP_IF's that separate the 'then' part of an 'if'
 
         targets = {}
+        extended_arg = 0
         for offset in self.op_range(0, n):
             op = code[offset]
 
+            if op == self.opc.EXTENDED_ARG:
+                arg = code2num(code, offset+1) | extended_arg
+                extended_arg += self.extended_arg_val(arg)
+                continue
+
             # Determine structures and fix jumps in Python versions
             # since 2.3
-            self.detect_control_flow(offset, op)
+            self.detect_control_flow(offset, op, extended_arg)
 
             if op_has_argument(op, self.opc):
                 label = self.fixed_jumps.get(offset)
@@ -1043,7 +1048,9 @@ class Scanner2(Scanner):
                 label = self.fixed_jumps[offset]
                 targets[label] = targets.get(label, []) + [offset]
                 pass
-            pass
+
+            extended_arg = 0
+            pass # for loop
 
         # DEBUG:
         if debug in ('both', 'after'):