Make a pass over extended formatting...

There is plenty more to do, but this is a start.

Author: rocky

xdis/disasm.py

@@ -385,15 +385,20 @@ def disassemble_file(
 def _test():
     """Simple test program to disassemble a file."""
     argc = len(sys.argv)
-    if argc != 2:
-        if argc == 1 and xdis.PYTHON3:
+    if argc == 1:
+        if xdis.PYTHON3:
             fn = __file__
         else:
-            sys.stderr.write("usage: %s [-|CPython compiled file]\n" % __file__)
+            sys.stderr.write(
+                "usage: %s [-|CPython compiled file [format]]\n" % __file__
+            )
             sys.exit(2)
+    elif argc == 3:
+        fn, asm_format = sys.argv[1:3]
+        disassemble_file(fn, asm_format=asm_format)
     else:
         fn = sys.argv[1]
-    disassemble_file(fn)
+        disassemble_file(fn)
 
 
 if __name__ == "__main__":

xdis/opcodes/format/extended.py

@@ -235,13 +235,13 @@ def extended_format_unary_op(
     return "", None
 
 
-def extended_format_ATTR(opc, instructions: list) -> Optional[Tuple[str, int]]:
+def extended_format_ATTR(opc, instructions: list) -> Tuple[str, Optional[int]]:
     if instructions[1].opcode in opc.NAME_OPS | opc.CONST_OPS | opc.LOCAL_OPS:
         return (
             f"{instructions[0].argrepr}.{instructions[1].argrepr}",
             instructions[1].offset,
         )
-    return None
+    return "", None
 
 
 def extended_format_BINARY_ADD(opc, instructions: list) -> Tuple[str, Optional[int]]:
@@ -365,7 +365,7 @@ def extended_format_COMPARE_OP(opc, instructions: list) -> Tuple[str, Optional[i
     )
 
 
-def extended_format_CALL_FUNCTION(opc, instructions):
+def extended_format_CALL_FUNCTION(opc, instructions) -> Tuple[str, Optional[int]]:
     """call_function_inst should be a "CALL_FUNCTION" instruction. Look in
     `instructions` to see if we can find a method name.  If not we'll
     return None.
@@ -575,7 +575,6 @@ def get_arglist(
 
     """
     arglist = []
-    i = 0
     inst = None
     n = len(instructions) - 1
     while arg_count > 0 and i < n:

xdis/opcodes/opcode_311.py

@@ -1,11 +1,27 @@
+# (C) Copyright 2024
+# by Rocky Bernstein
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 """
 CPython 3.11 bytecode opcodes
 
 This is like Python 3.11's opcode.py  with some classification
 of stack usage and information for formatting instructions.
 """
 
-from typing import Optional
+from typing import Optional, Tuple
 
 import xdis.opcodes.opcode_310 as opcode_310
 from xdis.opcodes.base import (
@@ -209,7 +225,7 @@
 # fmt: on
 
 
-def extended_format_BINARY_OP(opc, instructions) -> Optional[str]:
+def extended_format_BINARY_OP(opc, instructions) -> Tuple[str, Optional[int]]:
     opname = _nb_ops[instructions[0].argval][1]
     if opname == "%":
         opname = "%%"
@@ -254,7 +270,7 @@ def format_BINARY_OP(arg) -> str:
 del opcode_extended_fmt311["BINARY_XOR"]
 del opcode_extended_fmt311["CALL_FUNCTION"]
 del opcode_extended_fmt311["CALL_FUNCTION_KW"]
-del opcode_extended_fmt311["CALL_METHOD"]
+# del opcode_extended_fmt311["CALL_METHOD"]
 del opcode_extended_fmt311["INPLACE_ADD"]
 del opcode_extended_fmt311["INPLACE_AND"]
 del opcode_extended_fmt311["INPLACE_FLOOR_DIVIDE"]

xdis/opcodes/opcode_36.py

@@ -1,4 +1,5 @@
-# (C) Copyright 2016-2017, 2019-2021, 2023 by Rocky Bernstein
+# (C) Copyright 2016-2017, 2019-2021, 2023-2024
+# by Rocky Bernstein
 #
 #  This program is free software; you can redistribute it and/or
 #  modify it under the terms of the GNU General Public License
@@ -20,7 +21,7 @@
 of stack usage.
 """
 
-from typing import Tuple
+from typing import Optional, Tuple
 
 import xdis.opcodes.opcode_35 as opcode_35
 from xdis.opcodes.base import (
@@ -231,34 +232,7 @@ def format_BUILD_MAP_UNPACK_WITH_CALL(count):
 # since they make use of the information there.
 
 
-def extended_format_CALL_METHOD(opc, instructions) -> str:
-    """Inst should be a "LOAD_METHOD" instruction. Looks in `instructions`
-    to see if we can find a method name.  If not we'll return "".
-
-    """
-    # From opcode description: Loads a method named co_names[namei] from the TOS object.
-    # Sometimes the method name is in the stack arg positions back.
-    call_method_inst = instructions[0]
-    assert call_method_inst.opname == "CALL_METHOD"
-    method_pos = call_method_inst.arg + 1
-    assert len(instructions) >= method_pos
-    s = ""
-    for inst in instructions[1:method_pos]:
-        # Make sure we are in the same basic block
-        # and ... ?
-        if inst.opname in ("CALL_METHOD",) or inst.is_jump_target:
-            break
-        pass
-    else:
-        if instructions[method_pos].opname == "LOAD_METHOD":
-            s += "%s: " % instructions[method_pos].argrepr
-            pass
-        pass
-    s += format_CALL_FUNCTION(call_method_inst.arg)
-    return s
-
-
-def extended_format_CALL_FUNCTION36(opc, instructions):
+def extended_format_CALL_FUNCTION36(opc, instructions) -> Tuple[str, Optional[int]]:
     """call_function_inst should be a "CALL_FUNCTION" instruction. Look in
     `instructions` to see if we can find a method name.  If not we'll
     return None.
@@ -289,7 +263,7 @@ def extended_format_CALL_FUNCTION36(opc, instructions):
     return "", None
 
 
-def extended_format_CALL_FUNCTION_KW(opc, instructions):
+def extended_format_CALL_FUNCTION_KW(opc, instructions) -> Tuple[str, Optional[int]]:
     """call_function_inst should be a "CALL_FUNCTION_KW" instruction. Look in
     `instructions` to see if we can find a method name.  If not we'll
     return None.
@@ -298,41 +272,44 @@ def extended_format_CALL_FUNCTION_KW(opc, instructions):
     # From opcode description: argc indicates the total number of
     # positional and keyword arguments.  Sometimes the function name
     # is in the stack arg positions back.
-    call_function_inst = instructions[0]
-    assert call_function_inst.opname == "CALL_FUNCTION_KW"
-    function_pos = call_function_inst.arg
-    assert len(instructions) >= function_pos + 1
-    load_const = instructions[1]
-    if load_const.opname == "LOAD_CONST" and isinstance(load_const.argval, tuple):
-        function_pos += len(load_const.argval) + 1
-        s = ""
-        i = -1
-        for i, inst in enumerate(instructions[2:]):
-            if i == function_pos:
-                break
-            if inst.is_jump_target:
-                i += 1
-                break
-            # Make sure we are in the same basic block
-            # and ... ?
-            opcode = inst.opcode
-            if inst.optype in ("nargs", "vargs"):
-                break
-            if inst.optype != "name":
-                function_pos += (oppop[opcode] - oppush[opcode]) + 1
-            if inst.opname in ("CALL_FUNCTION", "CALL_FUNCTION_KW"):
-                break
-            pass
+    # From opcode description: arg_count indicates the total number of
+    # positional and keyword arguments.
 
-        if i == function_pos:
-            if instructions[function_pos].opname in opc.NAME_OPS | opc.CONST_OPS:
-                if instructions[function_pos].opname == "LOAD_ATTR":
-                    s += "."
-                s += "%s() " % instructions[function_pos].argrepr
-                pass
-            pass
-        s += format_CALL_FUNCTION(call_function_inst.arg)
-        return s
+    call_inst = instructions[0]
+    arg_count = call_inst.argval
+    keywords = instructions[1].argval
+    s = ""
+
+    arglist, arg_count, i = get_arglist(instructions, 1, arg_count)
+
+    if arg_count != 0:
+        return "", None
+
+    assert i is not None
+    if i >= len(instructions) - 1:
+        return "", None
+
+    fn_inst = instructions[i + 1]
+    start_offset = instructions[i].start_offset
+    if fn_inst.opcode in opc.operator_set:
+        if instructions[1].opname == "MAKE_FUNCTION" and opc.version_tuple >= (3, 3):
+            arglist[0] = instructions[2].argval
+
+        fn_name = fn_inst.tos_str if fn_inst.tos_str else fn_inst.argrepr
+        # Note, 3.5 and 3.4 and before work slightly different with respect
+        # to placement of keyword values, and order of arguments.
+        arglist.reverse()
+        for i in range(len(keywords)):
+            j = -(i + 1)
+            param_name = keywords[j]
+            arglist[j] = f"{param_name}={arglist[j]}"
+
+        str_arglist = ", ".join(arglist)
+        if len(str_arglist) > 30:
+            str_arglist = str_arglist[:27] + "..."
+        s = f"{fn_name}({str_arglist})"
+        return s, start_offset
+    return "", None
 
 
 opcode_arg_fmt = opcode_arg_fmt36 = {
@@ -355,7 +332,6 @@ def extended_format_CALL_FUNCTION_KW(opc, instructions):
     **{
         "CALL_FUNCTION_KW": extended_format_CALL_FUNCTION_KW,
         # "CALL_FUNCTION_VAR": extended_format_CALL_FUNCTION,
-        "CALL_METHOD": extended_format_CALL_METHOD,
         "MAKE_FUNCTION": extended_format_MAKE_FUNCTION_36,
         "RAISE_VARARGS": extended_format_RAISE_VARARGS_older,
         "STORE_ATTR": extended_format_ATTR,