From f5eeed675959bc6665db99b23b58b3cb69e89e90 Mon Sep 17 00:00:00 2001
From: rocky <rb@dustyfeet.com>
Date: Thu, 1 Sep 2016 20:44:17 -0400
Subject: [PATCH] 2.6- bug: while..and: stmt - on one line

If 2.6 or before POP_BLOCK after a JUMP_IF_FALSE does not
constitute a new statement. The POP_BLOCK is really part
of the JUMP_IF_FALSE. In Python 2.7+ it's a single op.
---
 .../04_while_and_stmt_one_line.pyc            | Bin 0 -> 230 bytes
 .../bug26/04_while_and_stmt_one_line.py       |   9 +++++++
 uncompyle6/scanners/scanner2.py               |  25 ++++++++++++------
 uncompyle6/scanners/scanner26.py              |  21 +++++++++------
 4 files changed, 39 insertions(+), 16 deletions(-)
 create mode 100644 test/bytecode_2.7/04_while_and_stmt_one_line.pyc
 create mode 100644 test/simple_source/bug26/04_while_and_stmt_one_line.py

diff --git a/test/bytecode_2.7/04_while_and_stmt_one_line.pyc b/test/bytecode_2.7/04_while_and_stmt_one_line.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b65d9e169ed7a7a0301284c3e9c899b8e23ea09
GIT binary patch
literal 230
zcmZSn%*$1J>O^=l0~9a;X$K%KHUbi<3=CO}3@Ho@&5R6DObit=45>^EMY<p|g^@v$
z2hOxD6k-TZVPXi@U<T=B1QJ}C|AD{{EKtG$6o`*c%gjlQk1t^bDJjUwECI7}GV@Z4
zHGo142%^{!q$D%90I0q=zqBYhRX?dT-N;Pez$Csr17u2KUP^p%Np4AeeqL%k$OyfH
ZO0X?9x%nxjIjMFa8;e<h1V5t)0|1{^GW7re

literal 0
HcmV?d00001

diff --git a/test/simple_source/bug26/04_while_and_stmt_one_line.py b/test/simple_source/bug26/04_while_and_stmt_one_line.py
new file mode 100644
index 00000000..bb3b4b1b
--- /dev/null
+++ b/test/simple_source/bug26/04_while_and_stmt_one_line.py
@@ -0,0 +1,9 @@
+# From Python 2.6/MimeWriter.py
+#
+# Bug is detecting that "del" starts a statement
+# and is not: del not lines[-1] and lines[-1]
+#
+# A complicating factor is that the "while"
+# and statement are on the same line.
+lines = __file__.split("\n")
+while lines and not lines[-1]: del lines[-1]
diff --git a/uncompyle6/scanners/scanner2.py b/uncompyle6/scanners/scanner2.py
index 230ab217..d92fc5bd 100644
--- a/uncompyle6/scanners/scanner2.py
+++ b/uncompyle6/scanners/scanner2.py
@@ -56,13 +56,18 @@ class Scanner2(scan.Scanner):
         """
 
         show_asm = self.show_asm if not show_asm else show_asm
-        # show_asm = 'before'
+        # show_asm = 'both'
         if show_asm in ('both', 'before'):
             from xdis.bytecode import Bytecode
             bytecode = Bytecode(co, self.opc)
             for instr in bytecode.get_instructions(co):
                 print(instr._disassemble())
 
+        # from xdis.bytecode import Bytecode
+        # bytecode = Bytecode(co, self.opc)
+        # for instr in bytecode.get_instructions(co):
+        #     print(instr._disassemble())
+
         # Container for tokens
         tokens = []
 
@@ -77,7 +82,7 @@ class Scanner2(scan.Scanner):
         self.build_lines_data(co, n)
         self.build_prev_op(n)
 
-        # self.lines contains (block,addrLastInstr)
+        # class and names
         if classname:
             classname = '_' + classname.lstrip('_') + '__'
 
@@ -120,6 +125,7 @@ class Scanner2(scan.Scanner):
 
         cf = self.find_jump_targets()
         # contains (code, [addrRefToCode])
+
         last_stmt = self.next_stmt[0]
         i = self.next_stmt[last_stmt]
         replace = {}
@@ -316,7 +322,7 @@ class Scanner2(scan.Scanner):
         self.lines = []
         linetuple = namedtuple('linetuple', ['l_no', 'next'])
 
-        # linestarts is a tuple of (offset, line number).
+        # self.linestarts is a tuple of (offset, line number).
         # Turn that in a has that we can index
         self.linestarts = list(self.opc.findlinestarts(co))
         self.linestartoffsets = {}
@@ -382,12 +388,15 @@ class Scanner2(scan.Scanner):
                 while code[j] == self.opc.JUMP_ABSOLUTE:
                     j = self.prev[j]
                 if (self.version >= 2.3 and
-                    code[j] == self.opc.LIST_APPEND): # list comprehension
+                    self.opc.opname[code[j]] == 'LIST_APPEND'): # list comprehension
+                    stmts.remove(s)
+                    continue
+            elif code[s] == self.opc.POP_TOP:
+                prev = code[self.prev[s]]
+                if (prev == self.opc.ROT_TWO or
+                    self.version <= 2.6 and prev == self.opc.JUMP_IF_FALSE):
                     stmts.remove(s)
                     continue
-            elif code[s] == self.opc.POP_TOP and code[self.prev[s]] == self.opc.ROT_TWO:
-                stmts.remove(s)
-                continue
             elif code[s] in self.designator_ops:
                 j = self.prev[s]
                 while code[j] in self.designator_ops:
@@ -654,7 +663,7 @@ class Scanner2(scan.Scanner):
                                        'end':   pre[target]})
                 return
 
-            # Is it an "and" inside an "if" block
+            # Is it an "and" inside an "if" or "while" block
             if op == self.opc.PJIF:
                 # Search for other POP_JUMP_IF_FALSE targetting the same op,
                 # in current statement, starting from current offset, and filter
diff --git a/uncompyle6/scanners/scanner26.py b/uncompyle6/scanners/scanner26.py
index 5284d45c..12f3c0c2 100755
--- a/uncompyle6/scanners/scanner26.py
+++ b/uncompyle6/scanners/scanner26.py
@@ -71,12 +71,20 @@ class Scanner26(scan.Scanner2):
         return
 
     def disassemble(self, co, classname=None, code_objects={}, show_asm=None):
-        '''
-        Disassemble a code object, returning a list of 'Token'.
+        """
+        Pick out tokens from an uncompyle6 code object, and transform them,
+        returning a list of uncompyle6 'Token's.
 
-        The main part of this procedure is modelled after
-        dis.disassemble().
-        '''
+        The tranformations 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
+
+        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
+        cause specific rules for the specific number of arguments they take.
+        """
 
         show_asm = self.show_asm if not show_asm else show_asm
         # show_asm = 'both'
@@ -102,9 +110,6 @@ class Scanner26(scan.Scanner2):
         self.build_lines_data(co, n)
         self.build_prev_op(n)
 
-        # linestarts contains block code adresses (addr,block)
-        self.linestarts = list(self.opc.findlinestarts(co))
-
         # class and names
         if classname:
             classname = '_' + classname.lstrip('_') + '__'