Breakpoints

def get_breakpoints(self, bp_type: BreakpointType) -> list[Breakpoint]:
    """
    Retrieves all breakpoints of the specified type

    Args:
        bp_type: The type of breakpoint to get

    Returns:
        A list of Breakpoint objects
    """
    resp = self._send_request(XAutoCommand.XAUTO_REQ_GET_BREAKPOINTS, bp_type)
    return [Breakpoint(
        type=BreakpointType(bp[0]),
        addr=bp[1],
        enabled=bp[2],
        singleshoot=bp[3],
        active=bp[4],
        name=bp[5],
        mod=bp[6],
        slot=bp[7],
        typeEx=bp[8],
        hwSize=bp[9],
        hitCount=bp[10],
        fastResume=bp[11],
        silent=bp[12],
        breakCondition=bp[13],
        logText=bp[14],
        logCondition=bp[15],
        commandText=bp[16],
        commandCondition=bp[17]
    ) for bp in resp]

def set_breakpoint(self, address_or_symbol: int | str, name: str | None = None, bp_type: StandardBreakpointType = StandardBreakpointType.Short, singleshoot: bool = False) -> bool:
    """
    Sets a software breakpoint at the specified address or symbol.

    Args:
        address_or_symbol: Address or symbol to set the breakpoint at
        name: Optional name for the breakpoint
        bp_type: Type of software breakpoint to set
        singleshoot: Set a single-shot breakpoint

    Returns:
        Success
    """
    bp_type_str = str(bp_type).lower()
    if singleshoot and bp_type_str != "ss":
        bp_type_str = f'ss{bp_type_str}'
    if isinstance(address_or_symbol, int):
        name = name or f"bpx_{address_or_symbol:x}"
        return self.cmd_sync(f'bpx 0x{address_or_symbol:x}, "{name}", {bp_type_str}')
    else:
        name = name or f"bpx_{address_or_symbol.replace(' ', '_')}"
        if '"' in name:
            raise ValueError("Name cannot contain double quotes")
        return self.cmd_sync(f'bpx {address_or_symbol}, "{name}", {bp_type_str}')

def set_hardware_breakpoint(self, address_or_symbol: int | str, bp_type: HardwareBreakpointType = HardwareBreakpointType.x, size: int = 1) -> bool:
    """
    Sets a hardware breakpoint at the specified address or symbol.

    Args:
        address_or_symbol: Address or symbol to set the breakpoint at
        bp_type: Type of software breakpoint to set
        size: breakpoint size, one of [1, 2, 4, 8]

    Returns:
        Success
    """
    if size not in [1, 2, 4, 8]:
        raise ValueError("Invalid size")
    if isinstance(address_or_symbol, int):
        return self.cmd_sync(f'bph 0x{address_or_symbol:x}, {bp_type}, {size}')
    else:
        return self.cmd_sync(f'bph {address_or_symbol}, {bp_type}, {size}')

def set_memory_breakpoint(self, address_or_symbol: int | str, bp_type: MemoryBreakpointType = MemoryBreakpointType.a, singleshoot: bool = False) -> bool:
    """
    Sets a memory breakpoint at the specified address or symbol.

    Args:
        address_or_symbol: Address or symbol to set the breakpoint at
        bp_type: Type of software breakpoint to set
        singleshoot: Set a single-shot breakpoint

    Returns:
        Success
    """
    if isinstance(address_or_symbol, int):
        return self.cmd_sync(f'bpm 0x{address_or_symbol:x}, {int(not singleshoot)}, {bp_type}')
    else:
        return self.cmd_sync(f'bpm {address_or_symbol}, {int(not singleshoot)}, {bp_type}')

def clear_breakpoint(self, address_name_symbol_or_none: int | str | None = None) -> bool:
    """
    Clears software breakpoint at the specified address, name, or symbol.

    Args:
        address_name_symbol_or_none: Address or symbol to remove the breakpoint at (None removes all breakpoints of this type)

    Returns:
        Success
    """
    if address_name_symbol_or_none is None:
        return self.cmd_sync('bpc')
    if isinstance(address_name_symbol_or_none, int):
        return self.cmd_sync(f'bpc 0x{address_name_symbol_or_none:x}')
    return self.cmd_sync(f'bpc "{address_name_symbol_or_none}"')

def clear_hardware_breakpoint(self, address_symbol_or_none: int | str | None = None) -> bool:
    """
    Clears hardware breakpoint at the specified address or symbol.

    Args:
        address_symbol_or_none: Address or symbol to remove the breakpoint at (None removes all breakpoints of this type)

    Returns:
        Success
    """
    if address_symbol_or_none is None:
        return self.cmd_sync('bphc')
    if isinstance(address_symbol_or_none, int):
        return self.cmd_sync(f'bphc 0x{address_symbol_or_none:x}')
    return self.cmd_sync(f'bphc {address_symbol_or_none}')

def clear_memory_breakpoint(self, address_symbol_or_none: int | str | None = None) -> bool:
    """
    Clears memory breakpoint at the specified address or symbol.

    Args:
        address_symbol_or_none: Address or symbol to remove the breakpoint at (None removes all breakpoints of this type)

    Returns:
        Success
    """
    if address_symbol_or_none is None:
        return self.cmd_sync('bpmc')
    if isinstance(address_symbol_or_none, int):
        return self.cmd_sync(f'bpmc 0x{address_symbol_or_none:x}')
    return self.cmd_sync(f'bpmc {address_symbol_or_none}')

def toggle_breakpoint(self, address_name_symbol_or_none: int | str | None = None, on: bool = True) -> bool:
    """
    Toggles software breakpoint at the specified address or symbol.

    Args:
        address_name_symbol_or_none: Address, name, or symbol to toggle the breakpoint at
        on: Enable or disable the breakpoint

    Returns:
        Success
    """
    toggle_cmd = 'bpe' if on else 'bpd'
    if isinstance(address_name_symbol_or_none, int):
        return self.cmd_sync(f'{toggle_cmd} 0x{address_name_symbol_or_none:x}')
    elif address_name_symbol_or_none is None:
        return self.cmd_sync(f'{toggle_cmd}')
    else:
        return self.cmd_sync(f'{toggle_cmd} {address_name_symbol_or_none}')

def toggle_hardware_breakpoint(self, address_symbol_or_none: int | str | None = None, on: bool = True) -> bool:
    """
    Toggles hardware breakpoint at the specified address or symbol.

    Args:
        address_symbol_or_none: Address or symbol to toggle the breakpoint at
        on: Enable or disable the breakpoint

    Returns:
        Success
    """
    toggle_cmd = 'bphe' if on else 'bphd'
    if isinstance(address_symbol_or_none, int):
        return self.cmd_sync(f'{toggle_cmd} 0x{address_symbol_or_none:x}')
    elif address_symbol_or_none is None:
        return self.cmd_sync(f'{toggle_cmd}')
    else:
        return self.cmd_sync(f'{toggle_cmd} {address_symbol_or_none}')

def toggle_memory_breakpoint(self, address_symbol_or_none: int | str | None = None, on: bool = True) -> bool:
    """
    Toggles memory breakpoint at the specified address or symbol.

    Args:
        address_symbol_or_none: Address or symbol to toggle the breakpoint at
        on: Enable or disable the breakpoint

    Returns:
        Success
    """
    toggle_cmd = 'bpme' if on else 'bpmd'
    if isinstance(address_symbol_or_none, int):
        return self.cmd_sync(f'{toggle_cmd} 0x{address_symbol_or_none:x}')
    elif address_symbol_or_none is None:
        return self.cmd_sync(f'{toggle_cmd}')
    else:
        return self.cmd_sync(f'{toggle_cmd} {address_symbol_or_none}')