04b443e778
If your arguments or option values are of a type that naturally uses one of our common completion mechanisms, you will get completion for free. But if you have your own custom values or if you want to do fancy things like have `break set -s foo.dylib -n ba<TAB>` only complete on symbols in foo.dylib, you can use this new mechanism to achieve that.
256 lines
7.4 KiB
Python
256 lines
7.4 KiB
Python
"""
|
|
Test defining commands using the lldb command definitions
|
|
"""
|
|
import inspect
|
|
import sys
|
|
import lldb
|
|
from lldb.plugins.parsed_cmd import ParsedCommand
|
|
|
|
|
|
class ReportingCmd(ParsedCommand):
|
|
def __init__(self, debugger, unused):
|
|
super().__init__(debugger, unused)
|
|
|
|
def __call__(self, debugger, args_array, exe_ctx, result):
|
|
opt_def = self.get_options_definition()
|
|
if len(opt_def):
|
|
result.AppendMessage("Options:\n")
|
|
for long_option, elem in opt_def.items():
|
|
dest = elem["dest"]
|
|
result.AppendMessage(
|
|
f"{long_option} (set: {elem['_value_set']}): {object.__getattribute__(self.get_parser(), dest)}\n"
|
|
)
|
|
else:
|
|
result.AppendMessage("No options\n")
|
|
|
|
num_args = args_array.GetSize()
|
|
if num_args > 0:
|
|
result.AppendMessage(f"{num_args} arguments:")
|
|
for idx in range(0, num_args):
|
|
result.AppendMessage(
|
|
f"{idx}: {args_array.GetItemAtIndex(idx).GetStringValue(10000)}\n"
|
|
)
|
|
|
|
# Use these to make sure that get_repeat_command sends the right
|
|
# command.
|
|
no_args_repeat = None
|
|
one_arg_repeat = None
|
|
two_arg_repeat = None
|
|
|
|
class NoArgsCommand(ReportingCmd):
|
|
program = "no-args"
|
|
|
|
def __init__(self, debugger, unused):
|
|
super().__init__(debugger, unused)
|
|
|
|
@classmethod
|
|
def register_lldb_command(cls, debugger, module_name):
|
|
ParsedCommand.do_register_cmd(cls, debugger, module_name)
|
|
|
|
def setup_command_definition(self):
|
|
ov_parser = self.get_parser()
|
|
ov_parser.add_option(
|
|
"b",
|
|
"bool-arg",
|
|
"a boolean arg, defaults to True",
|
|
value_type=lldb.eArgTypeBoolean,
|
|
groups=[1, 2],
|
|
dest="bool_arg",
|
|
default=True,
|
|
)
|
|
|
|
ov_parser.add_option(
|
|
"s",
|
|
"shlib-name",
|
|
"A shared library name.",
|
|
value_type=lldb.eArgTypeShlibName,
|
|
groups=[1, [3, 4]],
|
|
dest="shlib_name",
|
|
default=None,
|
|
)
|
|
|
|
ov_parser.add_option(
|
|
"d",
|
|
"disk-file-name",
|
|
"An on disk filename",
|
|
value_type=lldb.eArgTypeFilename,
|
|
dest="disk_file_name",
|
|
default=None,
|
|
)
|
|
|
|
ov_parser.add_option(
|
|
"l",
|
|
"line-num",
|
|
"A line number",
|
|
value_type=lldb.eArgTypeLineNum,
|
|
groups=3,
|
|
dest="line_num",
|
|
default=0,
|
|
)
|
|
|
|
ov_parser.add_option(
|
|
"e",
|
|
"enum-option",
|
|
"An enum, doesn't actually do anything",
|
|
enum_values=[
|
|
["foo", "does foo things"],
|
|
["bar", "does bar things"],
|
|
["baz", "does baz things"],
|
|
],
|
|
groups=4,
|
|
dest="enum_option",
|
|
default="foo",
|
|
)
|
|
|
|
def get_repeat_command(self, command):
|
|
# No auto-repeat
|
|
global no_args_repeat
|
|
no_args_repeat = command
|
|
return ""
|
|
|
|
def get_short_help(self):
|
|
return "Example command for use in debugging"
|
|
|
|
def get_long_help(self):
|
|
return self.help_string
|
|
|
|
|
|
class OneArgCommandNoOptions(ReportingCmd):
|
|
program = "one-arg-no-opt"
|
|
|
|
def __init__(self, debugger, unused):
|
|
super().__init__(debugger, unused)
|
|
|
|
@classmethod
|
|
def register_lldb_command(cls, debugger, module_name):
|
|
ParsedCommand.do_register_cmd(cls, debugger, module_name)
|
|
|
|
def setup_command_definition(self):
|
|
ov_parser = self.get_parser()
|
|
ov_parser.add_argument_set(
|
|
[ov_parser.make_argument_element(lldb.eArgTypeSourceFile, "plain")]
|
|
)
|
|
|
|
def get_repeat_command(self, command):
|
|
# Repeat the current command
|
|
global one_arg_repeat
|
|
one_arg_repeat = command
|
|
return None
|
|
|
|
def get_short_help(self):
|
|
return "Example command for use in debugging"
|
|
|
|
def get_long_help(self):
|
|
return self.help_string
|
|
|
|
|
|
class TwoArgGroupsCommand(ReportingCmd):
|
|
program = "two-args"
|
|
|
|
def __init__(self, debugger, unused):
|
|
super().__init__(debugger, unused)
|
|
|
|
@classmethod
|
|
def register_lldb_command(cls, debugger, module_name):
|
|
ParsedCommand.do_register_cmd(cls, debugger, module_name)
|
|
|
|
def setup_command_definition(self):
|
|
ov_parser = self.get_parser()
|
|
ov_parser.add_option(
|
|
"l",
|
|
"language",
|
|
"language defaults to None",
|
|
value_type=lldb.eArgTypeLanguage,
|
|
groups=[1, 2],
|
|
dest="language",
|
|
default=None,
|
|
)
|
|
|
|
ov_parser.add_option(
|
|
"c",
|
|
"log-channel",
|
|
"log channel - defaults to lldb",
|
|
value_type=lldb.eArgTypeLogChannel,
|
|
groups=[1, 3],
|
|
dest="log_channel",
|
|
default="lldb",
|
|
)
|
|
|
|
ov_parser.add_option(
|
|
"p",
|
|
"process-name",
|
|
"A process name, defaults to None",
|
|
value_type=lldb.eArgTypeProcessName,
|
|
dest="proc_name",
|
|
default=None,
|
|
)
|
|
|
|
ov_parser.add_argument_set(
|
|
[
|
|
ov_parser.make_argument_element(
|
|
lldb.eArgTypeClassName, "plain", [1, 2]
|
|
),
|
|
ov_parser.make_argument_element(
|
|
lldb.eArgTypeOffset, "optional", [1, 2]
|
|
),
|
|
]
|
|
)
|
|
|
|
ov_parser.add_argument_set(
|
|
[
|
|
ov_parser.make_argument_element(
|
|
lldb.eArgTypePythonClass, "plain", [3, 4]
|
|
),
|
|
ov_parser.make_argument_element(lldb.eArgTypePid, "optional", [3, 4]),
|
|
]
|
|
)
|
|
|
|
def get_repeat_command(self, command):
|
|
global two_arg_repeat
|
|
two_arg_repeat = command
|
|
return command + " THIRD_ARG"
|
|
|
|
def handle_option_argument_completion(self, long_option, cursor_pos):
|
|
ov_parser = self.get_parser()
|
|
value = ov_parser.dest_for_option(long_option)[0 : cursor_pos + 1]
|
|
proc_value = ov_parser.proc_name
|
|
if proc_value != None:
|
|
new_str = value + proc_value
|
|
ret_arr = {"completion": new_str, "mode": "partial"}
|
|
return ret_arr
|
|
|
|
ret_arr = {"values": [value + "nice", value + "not_nice", value + "mediocre"]}
|
|
return ret_arr
|
|
|
|
def handle_argument_completion(self, args, arg_pos, cursor_pos):
|
|
ov_parser = self.get_parser()
|
|
orig_arg = args[arg_pos][0:cursor_pos]
|
|
if orig_arg == "correct_":
|
|
ret_arr = {"completion": "correct_answer"}
|
|
return ret_arr
|
|
|
|
if ov_parser.was_set("process-name"):
|
|
# No completions if proc_name was set.
|
|
return True
|
|
|
|
ret_arr = {
|
|
"values": [orig_arg + "cool", orig_arg + "yuck"],
|
|
"descriptions": ["good idea", "bad idea"],
|
|
}
|
|
return ret_arr
|
|
|
|
def get_short_help(self):
|
|
return "This is my short help string"
|
|
|
|
def get_long_help(self):
|
|
return self.help_string
|
|
|
|
|
|
def __lldb_init_module(debugger, dict):
|
|
# Register all classes that have a register_lldb_command method
|
|
for _name, cls in inspect.getmembers(sys.modules[__name__]):
|
|
if inspect.isclass(cls) and callable(
|
|
getattr(cls, "register_lldb_command", None)
|
|
):
|
|
cls.register_lldb_command(debugger, __name__)
|