From 76ae1592d00b0dabe1f08606e85efea1d6197a3c Mon Sep 17 00:00:00 2001 From: rocky Date: Thu, 17 Nov 2016 03:43:39 -0500 Subject: [PATCH] verify scanner2 vs scanner3 small changes... verify.py: allow LOAD_CONST None to make LOAD_NAME 'None' scanner{2,3}.py: make them look more alike --- uncompyle6/scanners/scanner2.py | 32 ++++++++++++++++++-------------- uncompyle6/scanners/scanner3.py | 7 ++++--- uncompyle6/verify.py | 9 ++++++--- 3 files changed, 28 insertions(+), 20 deletions(-) diff --git a/uncompyle6/scanners/scanner2.py b/uncompyle6/scanners/scanner2.py index 84f74e6c..5c5d5311 100644 --- a/uncompyle6/scanners/scanner2.py +++ b/uncompyle6/scanners/scanner2.py @@ -25,6 +25,7 @@ from __future__ import print_function from collections import namedtuple from array import array +from uncompyle6.scanner import op_has_argument from xdis.code import iscode import uncompyle6.scanner as scan @@ -175,7 +176,7 @@ class Scanner2(scan.Scanner): opname = self.opc.opname[op] oparg = None; pattr = None - has_arg = (op >= self.opc.HAVE_ARGUMENT) + has_arg = op_has_argument(op, self.opc) if has_arg: oparg = self.get_argument(offset) + extended_arg extended_arg = 0 @@ -814,20 +815,23 @@ class Scanner2(scan.Scanner): self.fixed_jumps[pos] = self.restrict_to_parent(target, parent) def find_jump_targets(self): - ''' + """ Detect all offsets in a byte code which are jump targets where we might insert a COME_FROM instruction. Return the list of offsets. An instruction can be jumped to in from multiple instructions. - ''' - - n = len(self.code) + """ + code = self.code + n = len(code) self.structs = [{'type': 'root', 'start': 0, 'end': n-1}] - self.loops = [] # All loop entry points - self.fixed_jumps = {} # Map fixed jumps to their real destination + # All loop entry points + self.loops = [] + + # Map fixed jumps to their real destination + self.fixed_jumps = {} self.ignore_if = set() self.build_stmt_indices() @@ -837,13 +841,13 @@ class Scanner2(scan.Scanner): targets = {} for offset in self.op_range(0, n): - op = self.code[offset] + op = code[offset] # Determine structures and fix jumps in Python versions # since 2.3 self.detect_structure(offset, op) - if op >= self.opc.HAVE_ARGUMENT: + if op_has_argument(op, self.opc): label = self.fixed_jumps.get(offset) oparg = self.get_argument(offset) @@ -867,16 +871,16 @@ class Scanner2(scan.Scanner): # does now start a new statement # Otherwise, we have want to add a "COME_FROM" if not (self.version < 2.7 and - self.code[label] == self.opc.POP_TOP and - self.code[self.prev[label]] == self.opc.RETURN_VALUE): + code[label] == self.opc.POP_TOP and + code[self.prev[label]] == self.opc.RETURN_VALUE): # In Python < 2.7, don't add a COME_FROM, for: # JUMP_FORWARD, END_FINALLY # or: # JUMP_FORWARD, POP_TOP, END_FINALLY if not (self.version < 2.7 and op == self.opc.JUMP_FORWARD - and ((self.code[offset+3] == self.opc.END_FINALLY) - or (self.code[offset+3] == self.opc.POP_TOP - and self.code[offset+4] == self.opc.END_FINALLY))): + and ((code[offset+3] == self.opc.END_FINALLY) + or (code[offset+3] == self.opc.POP_TOP + and code[offset+4] == self.opc.END_FINALLY))): # FIXME: rocky: I think we need something like this... if offset not in set(self.ignore_if) or self.version == 2.7: diff --git a/uncompyle6/scanners/scanner3.py b/uncompyle6/scanners/scanner3.py index bd294d55..2a2b50b5 100644 --- a/uncompyle6/scanners/scanner3.py +++ b/uncompyle6/scanners/scanner3.py @@ -403,12 +403,13 @@ class Scanner3(Scanner): def find_jump_targets(self): """ - Detect all offsets in a byte code which are jump targets. + Detect all offsets in a byte code which are jump targets + where we might insert a COME_FROM instruction. Return the list of offsets. - This procedure is modelled after dis.findlabels(), but here - for each target the number of jumps is counted. + Return the list of offsets. An instruction can be jumped + to in from multiple instructions. """ code = self.code n = len(code) diff --git a/uncompyle6/verify.py b/uncompyle6/verify.py index f021e79a..0063be7b 100755 --- a/uncompyle6/verify.py +++ b/uncompyle6/verify.py @@ -316,9 +316,12 @@ def cmp_code_objects(version, is_pypy, code_obj1, code_obj2, i1 += 2 i2 += 2 continue - - raise CmpErrorCode(name, tokens1[i1].offset, tokens1[i1], - tokens2[i2], tokens1, tokens2) + elif tokens1[i1].type == 'LOAD_NAME' and tokens2[i2].type == 'LOAD_CONST' \ + and tokens1[i1].pattr == 'None' and tokens2[i2].pattr == None: + pass + else: + raise CmpErrorCode(name, tokens1[i1].offset, tokens1[i1], + tokens2[i2], tokens1, tokens2) elif tokens1[i1].type in JUMP_OPs and tokens1[i1].pattr != tokens2[i2].pattr: dest1 = int(tokens1[i1].pattr) dest2 = int(tokens2[i2].pattr)