Sync python2 and python3 scanner/injest code more

uncompyle6/scanners/scanner2.py

@@ -26,7 +26,7 @@ from collections import namedtuple
 from array import array
 
 from xdis.code import iscode
-from xdis.bytecode import Bytecode, op_has_argument, op_size, instruction_size
+from xdis.bytecode import Bytecode, op_has_argument, instruction_size
 from xdis.util import code2num
 
 from uncompyle6.scanner import Scanner
@@ -72,13 +72,14 @@ class Scanner2(Scanner):
     def ingest(self, co, classname=None, code_objects={}, show_asm=None):
         """
         Pick out tokens from an uncompyle6 code object, and transform them,
-        returning a list of uncompyle6 'Token's.
+        returning a list of uncompyle6 Token's.
 
         The transformations are made to assist the deparsing grammar.
         Specificially:
            -  various types of LOAD_CONST's are categorized in terms of what they load
            -  COME_FROM instructions are added to assist parsing control structures
            -  MAKE_FUNCTION and FUNCTION_CALLS append the number of positional arguments
+           -  some EXTENDED_ARGS instructions are removed
 
         Also, when we encounter certain tokens, we add them to a set which will cause custom
         grammar rules. Specifically, variable arg tokens like MAKE_FUNCTION or BUILD_LIST
@@ -112,6 +113,7 @@ class Scanner2(Scanner):
 
         self.insts = list(bytecode)
         self.offset2inst_index = {}
+        n = len(self.insts)
         for i, inst in enumerate(self.insts):
             self.offset2inst_index[inst.offset] = i
 
@@ -141,8 +143,10 @@ class Scanner2(Scanner):
                 if names[self.get_argument(i+3)] == 'AssertionError':
                     self.load_asserts.add(i+3)
 
+        # Get jump targets
+        # Format: {target offset: [jump offsets]}
         jump_targets = self.find_jump_targets(show_asm)
-        # contains (code, [addrRefToCode])
+        # print("XXX2", jump_targets)
 
         last_stmt = self.next_stmt[0]
         i = self.next_stmt[last_stmt]
@@ -383,7 +387,7 @@ class Scanner2(Scanner):
                     if elem != code[i]:
                         match = False
                         break
-                    i += op_size(code[i], self.opc)
+                    i += instruction_size(code[i], self.opc)
 
                 if match:
                     i = self.prev[i]
@@ -629,7 +633,7 @@ class Scanner2(Scanner):
                                        'start': jump_back_offset+3,
                                        'end':   loop_end_offset})
         elif op == self.opc.SETUP_EXCEPT:
-            start  = offset + op_size(op, self.opc)
+            start  = offset + instruction_size(op, self.opc)
             target = self.get_target(offset, op)
             end_offset = self.restrict_to_parent(target, parent)
             if target != end_offset:
@@ -653,7 +657,7 @@ class Scanner2(Scanner):
                         setup_except_nest -= 1
                 elif self.code[end_finally_offset] == self.opc.SETUP_EXCEPT:
                     setup_except_nest += 1
-                end_finally_offset += op_size(code[end_finally_offset], self.opc)
+                end_finally_offset += instruction_size(code[end_finally_offset], self.opc)
                 pass
 
             # Add the except blocks
@@ -866,7 +870,7 @@ class Scanner2(Scanner):
                     else:
                         # We still have the case in 2.7 that the next instruction
                         # is a jump to a SETUP_LOOP target.
-                        next_offset = target + op_size(self.code[target], self.opc)
+                        next_offset = target + instruction_size(self.code[target], self.opc)
                         next_op = self.code[next_offset]
                         if self.op_name(next_op) == 'JUMP_FORWARD':
                             jump_target = self.get_target(next_offset, next_op)