Run ruff and ruff format

config/macos/.config/lldb/block.py

@@ -1,36 +1,50 @@
 #!/usr/bin/python
 
-'''
+"""
 Add this to ~/.lldbinit
 command script import ~/.lldb/block.py
-'''
+"""
 
 import lldb
 import shlex
 import optparse
 
+
 def __lldb_init_module(debugger, dict):
-    debugger.HandleCommand('command script add -f block.block_disass_command block_disass')
+    debugger.HandleCommand(
+        "command script add -f block.block_disass_command block_disass"
+    )
     print('The "block_disass" command has been installed')
 
+
 def create_command_arguments(command):
     return shlex.split(command)
 
+
 def create_block_disass_parser():
-    usage = "usage: %prog arg1 [--disass -d] [--number-instructions -n] [--signature -s]"
-    parser = optparse.OptionParser(prog='block_disass', usage=usage)
-    parser.add_option('-d', '--disass', action='store_true', dest='disass', default=False)
-    parser.add_option('-n', '--number-instructions', dest='numberinstructions', default=20)
-    parser.add_option('-s', '--signature', action='store_true', dest='signature', default=False)
+    usage = (
+        "usage: %prog arg1 [--disass -d] [--number-instructions -n] [--signature -s]"
+    )
+    parser = optparse.OptionParser(prog="block_disass", usage=usage)
+    parser.add_option(
+        "-d", "--disass", action="store_true", dest="disass", default=False
+    )
+    parser.add_option(
+        "-n", "--number-instructions", dest="numberinstructions", default=20
+    )
+    parser.add_option(
+        "-s", "--signature", action="store_true", dest="signature", default=False
+    )
     return parser
 
+
 def block_disass_command(debugger, command, result, dict):
     cmd_args = create_command_arguments(command)
     parser = create_block_disass_parser()
 
     try:
         (options, args) = parser.parse_args(cmd_args)
-    except:
+    except Exception:
         return
 
     if len(args) == 0:
@@ -53,14 +67,17 @@ def block_disass_command(debugger, command, result, dict):
     else:
         try:
             address = int(variable_arg, 0)
-        except:
+        except Exception:
             print("The argument is not a valid address or variable in the frame")
             return
 
     if should_signature:
         print_block_signature(debugger, target, process, address)
     if should_disass:
-        disass_block_invoke_function(debugger, target, process, address, number_instructions)
+        disass_block_invoke_function(
+            debugger, target, process, address, number_instructions
+        )
+
 
 """
 struct Block_literal_1 {
@@ -78,10 +95,13 @@ def block_disass_command(debugger, command, result, dict):
 };
 """
 
+
 def print_block_signature(debugger, target, process, block_address):
     pointer_size = 8 if arch_for_target_is_64bit(target) else 4
 
-    flags_address = block_address + pointer_size    # The `flags` integer is after a pointer in the struct
+    flags_address = (
+        block_address + pointer_size
+    )  # The `flags` integer is after a pointer in the struct
 
     flags_error = lldb.SBError()
     flags = process.ReadUnsignedFromMemory(flags_address, 4, flags_error)
@@ -90,9 +110,9 @@ def print_block_signature(debugger, target, process, block_address):
         return
 
     # BLOCK_HAS_SIGNATURE = (1 << 30)
-    block_has_signature = ((flags & (1 << 30)) != 0)
+    block_has_signature = (flags & (1 << 30)) != 0
     # BLOCK_HAS_COPY_DISPOSE = (1 << 25)
-    block_has_copy_dispose_helpers = ((flags & (1 << 25)) != 0)
+    block_has_copy_dispose_helpers = (flags & (1 << 25)) != 0
 
     if not block_has_signature:
         print("The block does not have a signature")
@@ -102,7 +122,9 @@ def print_block_signature(debugger, target, process, block_address):
     block_descriptor_address = block_address + 2 * 4 + 2 * pointer_size
 
     block_descriptor_error = lldb.SBError()
-    block_descriptor = process.ReadPointerFromMemory(block_descriptor_address, block_descriptor_error)
+    block_descriptor = process.ReadPointerFromMemory(
+        block_descriptor_address, block_descriptor_error
+    )
     if not block_descriptor_error.Success():
         print("Could not read the block descriptor struct")
         return
@@ -114,7 +136,9 @@ def print_block_signature(debugger, target, process, block_address):
         signature_address += 2 * pointer_size
 
     signature_pointer_error = lldb.SBError()
-    signature_pointer = process.ReadPointerFromMemory(signature_address, signature_pointer_error)
+    signature_pointer = process.ReadPointerFromMemory(
+        signature_address, signature_pointer_error
+    )
 
     signature_error = lldb.SBError()
     signature = process.ReadCStringFromMemory(signature_pointer, 256, signature_error)
@@ -124,27 +148,41 @@ def print_block_signature(debugger, target, process, block_address):
 
     escaped_signature = signature.replace('"', '\\"')
 
-    method_signature_cmd = 'po [NSMethodSignature signatureWithObjCTypes:"' + escaped_signature + '"]'
+    method_signature_cmd = (
+        'po [NSMethodSignature signatureWithObjCTypes:"' + escaped_signature + '"]'
+    )
     debugger.HandleCommand(method_signature_cmd)
 
-def disass_block_invoke_function(debugger, target, process, block_address, instruction_count):
+
+def disass_block_invoke_function(
+    debugger, target, process, block_address, instruction_count
+):
     pointer_size = 8 if arch_for_target_is_64bit(target) else 4
 
     # The `invoke` function is after one pointer and 2 int in the struct
     invoke_function_address = block_address + pointer_size + 2 * 4
 
     invoke_function_error = lldb.SBError()
-    invoke_function_pointer = process.ReadPointerFromMemory(invoke_function_address, invoke_function_error)
+    invoke_function_pointer = process.ReadPointerFromMemory(
+        invoke_function_address, invoke_function_error
+    )
     if not invoke_function_error.Success():
         print("Could not retrieve the block invoke function pointer")
         return
 
-    disass_cmd = "disassemble --start-address " + str(invoke_function_pointer) + " -c " + str(instruction_count)
+    disass_cmd = (
+        "disassemble --start-address "
+        + str(invoke_function_pointer)
+        + " -c "
+        + str(instruction_count)
+    )
     debugger.HandleCommand(disass_cmd)
 
-arch_64 = ['armv64', 'x86_64']
-arch_32 = ['i386', 'armv7', 'armv7s']
+
+arch_64 = ["armv64", "x86_64"]
+arch_32 = ["i386", "armv7", "armv7s"]
+
 
 def arch_for_target_is_64bit(target):
-    arch = target.GetTriple().split('-')[0]
+    arch = target.GetTriple().split("-")[0]
     return arch in arch_64