26#include "llvm/ADT/StringRef.h"
34#define LLDB_OPTIONS_source
35#include "CommandOptions.inc"
41 interpreter,
"command source",
42 "Read and execute LLDB commands from the file <filename>.",
50 uint32_t index)
override {
51 return std::string(
"");
70 switch (short_option) {
88 llvm_unreachable(
"Unimplemented option");
102 return llvm::ArrayRef(g_source_options);
116 "'%s' takes exactly one executable filename argument.\n",
125 result.
AppendError(
"command source -C can only be specified "
126 "from a command file");
132 FileSpec cmd_file(command[0].ref());
136 result.
AppendError(
"command source -C can only be used "
137 "with a relative path.");
175#pragma mark CommandObjectCommandsAlias
178#define LLDB_OPTIONS_alias
179#include "CommandOptions.inc"
182 "Enter your Python command(s). Type 'DONE' to end.\n"
183 "You must define a Python function with this signature:\n"
184 "def my_command_impl(debugger, args, exe_ctx, result, internal_dict):\n";
195 return llvm::ArrayRef(g_alias_options);
202 const int short_option =
GetDefinitions()[option_idx].short_option;
203 std::string option_str(option_value);
205 switch (short_option) {
217 llvm_unreachable(
"Unimplemented option");
240 interpreter,
"command alias",
241 "Define a custom command in terms of an existing command.") {
246 "'alias' allows the user to create a short-cut or abbreviation for long \
247commands, multi-word commands, and commands that take particular options. \
248Below are some simple examples of how one might use the 'alias' command:"
251(lldb) command alias sc script
253 Creates the abbreviation 'sc' for the 'script' command.
255(lldb) command alias bp breakpoint
258 " Creates the abbreviation 'bp' for the 'breakpoint' command. Since \
259breakpoint commands are two-word commands, the user would still need to \
260enter the second word after 'bp', e.g. 'bp enable' or 'bp delete'."
263(lldb) command alias bpl breakpoint list
265 Creates the abbreviation 'bpl' for the two-word command 'breakpoint list'.
268 "An alias can include some options for the command, with the values either \
269filled in at the time the alias is created, or specified as positional \
270arguments, to be filled in when the alias is invoked. The following example \
271shows how to create aliases with options:"
274(lldb) command alias bfl breakpoint set -f %1 -l %2
277 " Creates the abbreviation 'bfl' (for break-file-line), with the -f and -l \
278options already part of the alias. So if the user wants to set a breakpoint \
279by file and line without explicitly having to use the -f and -l options, the \
280user can now use 'bfl' instead. The '%1' and '%2' are positional placeholders \
281for the actual arguments that will be passed when the alias command is used. \
282The number in the placeholder refers to the position/order the actual value \
283occupies when the alias is used. All the occurrences of '%1' in the alias \
284will be replaced with the first argument, all the occurrences of '%2' in the \
285alias will be replaced with the second argument, and so on. This also allows \
286actual arguments to be used multiple times within an alias (see 'process \
287launch' example below)."
291 "Note: the positional arguments must substitute as whole words in the resultant \
292command, so you can't at present do something like this to append the file extension \
296(lldb) command alias bcppfl breakpoint set -f %1.cpp -l %2
299 "For more complex aliasing, use the \"command regex\" command instead. In the \
300'bfl' case above, the actual file value will be filled in with the first argument \
301following 'bfl' and the actual line number value will be filled in with the second \
302argument. The user would use this alias as follows:"
305(lldb) command alias bfl breakpoint set -f %1 -l %2
306(lldb) bfl my-file.c 137
308This would be the same as if the user had entered 'breakpoint set -f my-file.c -l 137'.
312(lldb) command alias pltty process launch -s -o %1 -e %1
313(lldb) pltty /dev/tty0
315 Interpreted as 'process launch -s -o /dev/tty0 -e /dev/tty0'
318 "If the user always wanted to pass the same value to a particular option, the \
319alias could be defined with that value directly in the alias as a constant, \
320rather than using a positional placeholder:"
323(lldb) command alias bl3 breakpoint set -f %1 -l 3
325 Always sets a breakpoint on line 3 of whatever file is indicated.)");
340 arg1.push_back(alias_arg);
348 arg2.push_back(cmd_arg);
356 arg3.push_back(options_arg);
367 void DoExecute(llvm::StringRef raw_command_line,
369 if (raw_command_line.empty()) {
370 result.
AppendError(
"'command alias' requires at least two arguments");
379 if (args_with_suffix.HasArgs())
384 llvm::StringRef raw_command_string = args_with_suffix.GetRawPart();
385 Args args(raw_command_string);
387 if (args.GetArgumentCount() < 2) {
388 result.
AppendError(
"'command alias' requires at least two arguments");
394 auto alias_command = args[0].ref();
395 if (alias_command.starts_with(
"-")) {
396 result.
AppendError(
"aliases starting with a dash are not supported");
397 if (alias_command ==
"--help" || alias_command ==
"--long-help") {
398 result.
AppendWarning(
"if trying to pass options to 'command alias' add "
399 "a -- at the end of the options");
406 size_t pos = raw_command_string.find(alias_command);
408 raw_command_string = raw_command_string.substr(alias_command.size());
409 pos = raw_command_string.find_first_not_of(
' ');
410 if ((pos != std::string::npos) && (pos > 0))
411 raw_command_string = raw_command_string.substr(pos);
413 result.
AppendError(
"Error parsing command string. No alias created.");
420 "'%s' is a permanent debugger command and cannot be redefined.\n",
427 "'%s' is a user container command and cannot be overwritten.\n"
428 "Delete it first with 'command container delete'\n",
436 llvm::StringRef original_raw_command_string = raw_command_string;
442 "'%s' does not begin with a valid command."
443 " No alias created.",
444 original_raw_command_string.str().c_str());
457 llvm::StringRef raw_command_string,
465 const bool include_aliases =
true;
473 cmd_obj_sp = cmd_obj.shared_from_this();
478 "Overwriting existing definition for '%s'.\n",
479 alias_command.str().c_str());
482 alias_command, cmd_obj_sp, raw_command_string)) {
489 result.
AppendError(
"Unable to create requested alias.\n");
498 result.
AppendError(
"'command alias' requires at least two arguments");
503 const std::string alias_command(std::string(args[0].ref()));
504 const std::string actual_command(std::string(args[1].ref()));
514 "'%s' is a permanent debugger command and cannot be redefined.\n",
515 alias_command.c_str());
521 "'%s' is user container command and cannot be overwritten.\n"
522 "Delete it first with 'command container delete'",
523 alias_command.c_str());
530 bool use_subcommand =
false;
531 if (!command_obj_sp) {
533 actual_command.c_str());
542 auto sub_command = args[0].ref();
543 assert(!sub_command.empty());
545 if (!subcommand_obj_sp) {
547 "'%s' is not a valid sub-command of '%s'. "
548 "Unable to create alias.\n",
549 args[0].c_str(), actual_command.c_str());
553 sub_cmd_obj = subcommand_obj_sp.get();
554 use_subcommand =
true;
556 cmd_obj = sub_cmd_obj;
561 std::string args_string;
575 "Overwriting existing definition for '%s'.\n", alias_command.c_str());
579 alias_command, use_subcommand ? subcommand_obj_sp : command_obj_sp,
587 result.
AppendError(
"Unable to create requested alias.\n");
595#pragma mark CommandObjectCommandsUnalias
602 interpreter,
"command unalias",
603 "Delete one or more custom commands defined by 'command alias'.",
623 CommandObject::CommandMap::iterator pos;
627 result.
AppendError(
"must call 'unalias' with a valid alias");
631 auto command_name = args[0].ref();
635 "'%s' is not a known command.\nTry 'help' to see a "
636 "current list of commands.\n",
644 "'%s' is not an alias, it is a debugger command which can be "
645 "removed using the 'command delete' command.\n",
649 "'%s' is a permanent debugger command and cannot be removed.\n",
658 "Error occurred while attempting to unalias '%s'.\n",
670#pragma mark CommandObjectCommandsDelete
677 interpreter,
"command delete",
678 "Delete one or more custom commands defined by 'command regex'.",
692 if (ent.second->IsRemovable())
699 CommandObject::CommandMap::iterator pos;
703 "defined regular expression command names",
708 auto command_name = args[0].ref();
711 const bool generate_upropos =
true;
712 const bool generate_type_lookup =
false;
714 &error_msg_stream, command_name, llvm::StringRef(), llvm::StringRef(),
715 generate_upropos, generate_type_lookup);
722 "'%s' is a permanent debugger command and cannot be removed.\n",
733#define LLDB_OPTIONS_regex
734#include "CommandOptions.inc"
736#pragma mark CommandObjectCommandsAddRegex
743 interpreter,
"command regex",
744 "Define a custom command in terms of "
745 "existing commands by matching "
746 "regular expressions.",
747 "command regex <cmd-name> [s/<regex>/<subst>/ ...]"),
753 "This command allows the user to create powerful regular expression commands \
754with substitutions. The regular expressions and substitutions are specified \
755using the regular expression substitution format of:"
761 "<regex> is a regular expression that can use parenthesis to capture regular \
762expression input and substitute the captured matches in the output using %1 \
763for the first match, %2 for the second, and so on."
767 "The regular expressions can all be specified on the command line if more than \
768one argument is provided. If just the command name is provided on the command \
769line, then the regular expressions and substitutions can be entered on separate \
770lines, followed by an empty line to terminate the command definition."
776 "The following example will define a regular expression command named 'f' that \
777will call 'finish' if there are no arguments, or 'frame select <frame-idx>' if \
778a number follows 'f':"
781 (lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/')");
790 if (output_sp && interactive) {
791 output_sp->PutCString(
"Enter one or more sed substitution commands in "
792 "the form: 's/<regex>/<subst>/'.\nTerminate the "
793 "substitution list with an empty line.\n");
799 std::string &data)
override {
804 bool check_only =
false;
805 for (
const std::string &line : lines) {
810 out_stream->Printf(
"error: %s\n",
error.AsCString());
825 result.
AppendError(
"usage: 'command regex <command-name> "
826 "[s/<regex1>/<subst1>/ s/<regex2>/<subst2>/ ...]'\n");
831 auto name = command[0].ref();
839 const bool multiple_lines =
true;
841 debugger, IOHandler::Type::Other,
843 llvm::StringRef(
"> "),
845 multiple_lines, color_prompt,
854 for (
auto &entry : command.
entries().drop_front()) {
855 bool check_only =
false;
861 if (
error.Success()) {
875 error.SetErrorStringWithFormat(
876 "invalid regular expression command object for: '%.*s'",
877 (
int)regex_sed.size(), regex_sed.data());
881 size_t regex_sed_size = regex_sed.size();
883 if (regex_sed_size <= 1) {
884 error.SetErrorStringWithFormat(
885 "regular expression substitution string is too short: '%.*s'",
886 (
int)regex_sed.size(), regex_sed.data());
890 if (regex_sed[0] !=
's') {
891 error.SetErrorStringWithFormat(
"regular expression substitution string "
892 "doesn't start with 's': '%.*s'",
893 (
int)regex_sed.size(), regex_sed.data());
896 const size_t first_separator_char_pos = 1;
899 const char separator_char = regex_sed[first_separator_char_pos];
900 const size_t second_separator_char_pos =
901 regex_sed.find(separator_char, first_separator_char_pos + 1);
903 if (second_separator_char_pos == std::string::npos) {
904 error.SetErrorStringWithFormat(
905 "missing second '%c' separator char after '%.*s' in '%.*s'",
907 (
int)(regex_sed.size() - first_separator_char_pos - 1),
908 regex_sed.data() + (first_separator_char_pos + 1),
909 (
int)regex_sed.size(), regex_sed.data());
913 const size_t third_separator_char_pos =
914 regex_sed.find(separator_char, second_separator_char_pos + 1);
916 if (third_separator_char_pos == std::string::npos) {
917 error.SetErrorStringWithFormat(
918 "missing third '%c' separator char after '%.*s' in '%.*s'",
920 (
int)(regex_sed.size() - second_separator_char_pos - 1),
921 regex_sed.data() + (second_separator_char_pos + 1),
922 (
int)regex_sed.size(), regex_sed.data());
926 if (third_separator_char_pos != regex_sed_size - 1) {
928 if (regex_sed.find_first_not_of(
"\t\n\v\f\r ",
929 third_separator_char_pos + 1) !=
931 error.SetErrorStringWithFormat(
932 "extra data found after the '%.*s' regular expression substitution "
934 (
int)third_separator_char_pos + 1, regex_sed.data(),
935 (
int)(regex_sed.size() - third_separator_char_pos - 1),
936 regex_sed.data() + (third_separator_char_pos + 1));
939 }
else if (first_separator_char_pos + 1 == second_separator_char_pos) {
940 error.SetErrorStringWithFormat(
941 "<regex> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'",
942 separator_char, separator_char, separator_char, (
int)regex_sed.size(),
945 }
else if (second_separator_char_pos + 1 == third_separator_char_pos) {
946 error.SetErrorStringWithFormat(
947 "<subst> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'",
948 separator_char, separator_char, separator_char, (
int)regex_sed.size(),
954 std::string regex(std::string(regex_sed.substr(
955 first_separator_char_pos + 1,
956 second_separator_char_pos - first_separator_char_pos - 1)));
957 std::string subst(std::string(regex_sed.substr(
958 second_separator_char_pos + 1,
959 third_separator_char_pos - second_separator_char_pos - 1)));
977 class CommandOptions :
public Options {
988 switch (short_option) {
990 m_help.assign(std::string(option_arg));
993 m_syntax.assign(std::string(option_arg));
996 llvm_unreachable(
"Unimplemented option");
1008 return llvm::ArrayRef(g_regex_options);
1030 std::string funct, std::string help,
1039 stream.
Printf(
"For more information run 'help %s'", name.c_str());
1054 return CommandObjectRaw::GetHelpLong();
1058 return CommandObjectRaw::GetHelpLong();
1060 std::string docstring;
1063 if (!docstring.empty())
1065 return CommandObjectRaw::GetHelpLong();
1124 stream.
Printf(
"For more information run 'help %s'", name.c_str());
1127 GetFlags().
Set(scripter->GetFlagsForCommandObject(cmd_obj_sp));
1147 return CommandObjectRaw::GetHelp();
1150 return CommandObjectRaw::GetHelp();
1151 std::string docstring;
1154 if (!docstring.empty())
1157 return CommandObjectRaw::GetHelp();
1162 return CommandObjectRaw::GetHelpLong();
1166 return CommandObjectRaw::GetHelpLong();
1168 std::string docstring;
1171 if (!docstring.empty())
1173 return CommandObjectRaw::GetHelpLong();
1237 error.SetErrorString(
"No script interpreter for SetOptionValue.");
1241 error.SetErrorString(
"SetOptionValue called with empty cmd_obj.");
1245 error.SetErrorString(
"SetOptionValue called before options definitions "
1252 const char * long_option =
1255 execution_context, long_option, option_arg);
1257 error.SetErrorStringWithFormatv(
"Error setting option: {0} to {1}",
1258 long_option, option_arg);
1278 size_t counter, uint32_t &usage_mask) {
1297 uint32_t value = uint_val->
GetValue();
1299 error.SetErrorStringWithFormatv(
1300 "0 is not a valid group for option {0}", counter);
1303 usage_mask = (1 << (value - 1));
1309 error.SetErrorStringWithFormatv(
1310 "required field is not a array for option {0}", counter);
1315 auto groups_accumulator
1316 = [counter, &usage_mask, &
error]
1320 uint32_t value = int_val->
GetValue();
1322 error.SetErrorStringWithFormatv(
1323 "0 is not a valid group for element {0}", counter);
1326 usage_mask |= (1 << (value - 1));
1331 error.SetErrorStringWithFormatv(
1332 "Group element not an int or array of integers for element {0}",
1336 size_t num_range_elem = arr_val->
GetSize();
1337 if (num_range_elem != 2) {
1338 error.SetErrorStringWithFormatv(
1339 "Subranges of a group not a start and a stop for element {0}",
1345 error.SetErrorStringWithFormatv(
"Start element of a subrange of a "
1346 "group not unsigned int for element {0}", counter);
1349 uint32_t start = int_val->
GetValue();
1352 error.SetErrorStringWithFormatv(
"End element of a subrange of a group"
1353 " not unsigned int for element {0}", counter);
1356 uint32_t end = int_val->
GetValue();
1357 if (start == 0 || end == 0 || start > end) {
1358 error.SetErrorStringWithFormatv(
"Invalid subrange of a group: {0} - "
1359 "{1} for element {2}", start, end, counter);
1362 for (uint32_t i = start; i <= end; i++) {
1363 usage_mask |= (1 << (i - 1));
1367 array_val->
ForEach(groups_accumulator);
1383 size_t short_opt_counter = 0;
1385 auto add_element = [
this, &
error, &counter, &short_opt_counter]
1389 error.SetErrorString(
"Value in options dictionary is not a dictionary");
1420 error.SetErrorStringWithFormatv(
"'required' field is not a boolean "
1421 "for option {0}", counter);
1432 llvm::StringRef short_str = obj_sp->GetStringValue();
1433 if (short_str.empty()) {
1434 error.SetErrorStringWithFormatv(
"short_option field empty for "
1435 "option {0}", counter);
1437 }
else if (short_str.size() != 1) {
1438 error.SetErrorStringWithFormatv(
"short_option field has extra "
1439 "characters for option {0}", counter);
1442 short_option = (int) short_str[0];
1446 short_option = short_opt_counter++;
1451 if (long_option.empty()) {
1452 error.SetErrorStringWithFormatv(
"empty long_option for option {0}",
1457 option_def.
long_option = ((*(inserted.first)).data());
1465 error.SetErrorStringWithFormatv(
"Value type must be an unsigned "
1469 uint64_t val_type = uint_val->
GetValue();
1471 error.SetErrorStringWithFormatv(
"Value type {0} beyond the "
1472 "CommandArgumentType bounds", val_type);
1487 error.SetErrorStringWithFormatv(
"Completion type must be an "
1488 "unsigned integer for option {0}", counter);
1491 uint64_t completion_type = uint_val->
GetValue();
1493 error.SetErrorStringWithFormatv(
"Completion type for option {0} "
1494 "beyond the CompletionType bounds", completion_type);
1502 std::string usage_text;
1505 error.SetErrorStringWithFormatv(
"required usage missing from option "
1509 llvm::StringRef usage_stref;
1510 usage_stref = obj_sp->GetStringValue();
1511 if (usage_stref.empty()) {
1512 error.SetErrorStringWithFormatv(
"empty usage text for option {0}",
1525 error.SetErrorStringWithFormatv(
"enum values must be an array for "
1526 "option {0}", counter);
1529 size_t num_elem = array->
GetSize();
1530 size_t enum_ctr = 0;
1531 m_enum_storage[counter] = std::vector<EnumValueStorage>(num_elem);
1532 std::vector<EnumValueStorage> &curr_elem =
m_enum_storage[counter];
1538 auto add_enum = [&enum_ctr, &curr_elem, counter, &
error]
1542 error.SetErrorStringWithFormatv(
"Enum values for option {0} not "
1543 "an array", counter);
1546 size_t num_enum_elements = enum_arr->
GetSize();
1547 if (num_enum_elements != 2) {
1548 error.SetErrorStringWithFormatv(
"Wrong number of elements: {0} "
1549 "for enum {1} in option {2}",
1550 num_enum_elements, enum_ctr, counter);
1555 llvm::StringRef val_stref = obj_sp->GetStringValue();
1556 std::string value_cstr_str = val_stref.str().c_str();
1561 error.SetErrorStringWithFormatv(
"No usage for enum {0} in option "
1562 "{1}", enum_ctr, counter);
1565 llvm::StringRef usage_stref = obj_sp->GetStringValue();
1566 std::string usage_cstr_str = usage_stref.str().c_str();
1568 usage_cstr_str, enum_ctr);
1575 if (!
error.Success())
1579 for (
auto &elem : curr_elem)
1601 size_t in_value) :
value(std::move(in_str_val)),
usage(std::move(in_usage)) {
1654 interpreter, name, cmd_obj_sp, synch));
1662 if (opt_error.
Fail())
1665 if (arg_error.
Fail())
1667 opt_error.
Fail() ?
", also " :
"",
1698 if (options_object_sp) {
1719 if (args_object_sp) {
1733 size_t elem_counter = 0;
1734 auto args_adder = [
this, counter, &elem_counter, &this_entry]
1740 uint32_t arg_opt_set_association;
1742 auto report_error = [
this, elem_counter, counter]
1743 (
const char *err_txt) ->
bool {
1745 "list element {1}: %s.", elem_counter, counter, err_txt);
1751 report_error(
"is not a dictionary.");
1761 report_error(
"value type must be an unsigned integer");
1764 uint64_t arg_type_int = uint_val->
GetValue();
1766 report_error(
"value type beyond ArgumentRepetitionType bounds");
1773 std::optional<ArgumentRepetitionType> repeat;
1775 llvm::StringRef repeat_str = obj_sp->GetStringValue();
1776 if (repeat_str.empty()) {
1777 report_error(
"repeat value is empty");
1782 report_error(
"invalid repeat value");
1785 arg_repetition = *repeat;
1791 counter, arg_opt_set_association);
1792 this_entry.emplace_back(arg_type, arg_repetition,
1793 arg_opt_set_association);
1800 "{0} is not an array", counter);
1803 args_array->
ForEach(args_adder);
1806 if (this_entry.empty()) {
1808 "{0} is empty", counter);
1816 args_array->
ForEach(arg_array_adder);
1832 return CommandObjectParsed::GetHelp();
1835 return CommandObjectParsed::GetHelp();
1836 std::string docstring;
1839 if (!docstring.empty())
1842 return CommandObjectParsed::GetHelp();
1847 return CommandObjectParsed::GetHelpLong();
1851 return CommandObjectParsed::GetHelpLong();
1853 std::string docstring;
1856 if (!docstring.empty())
1858 return CommandObjectParsed::GetHelpLong();
1898std::unordered_set<std::string>
1902#define LLDB_OPTIONS_script_import
1903#include "CommandOptions.inc"
1909 "Import a scripting module in LLDB.", nullptr) {
1929 switch (short_option) {
1940 llvm_unreachable(
"Unimplemented option");
1951 return llvm::ArrayRef(g_script_import_options);
1958 if (command.
empty()) {
1959 result.
AppendError(
"command script import needs one or more arguments");
1967 result.
AppendError(
"command script import -c can only be specified "
1968 "from a command file");
1973 for (
auto &entry : command.
entries()) {
1989 if (
GetDebugger().GetScriptInterpreter()->LoadScriptingModule(
1990 entry.c_str(), options,
error,
nullptr,
2003#define LLDB_OPTIONS_script_add
2004#include "CommandOptions.inc"
2011 "Add a scripted function as an LLDB command.",
2012 "Add a scripted function as an lldb command. "
2013 "If you provide a single argument, the command "
2014 "will be added at the root level of the command "
2015 "hierarchy. If there are more arguments they "
2016 "must be a path to a user-added container "
2017 "command, and the last element will be the new "
2031 opt_element_vector);
2046 switch (short_option) {
2048 if (!option_arg.empty())
2052 if (!option_arg.empty())
2056 if (!option_arg.empty())
2069 if (!
error.Success())
2070 error.SetErrorStringWithFormat(
2071 "unrecognized value for synchronicity '%s'",
2072 option_arg.str().c_str());
2080 if (!
error.Success())
2081 error.SetErrorStringWithFormat(
2082 "unrecognized value for command completion type '%s'",
2083 option_arg.str().c_str());
2087 llvm_unreachable(
"Unimplemented option");
2104 return llvm::ArrayRef(g_script_add_options);
2121 if (output_sp && interactive) {
2128 std::string &data)
override {
2136 std::string funct_name_str;
2138 if (funct_name_str.empty()) {
2139 error_sp->Printf(
"error: unable to obtain a function name, didn't "
2140 "add python command.\n");
2152 error_sp->Printf(
"error: unable to add selected command: '%s'",
2160 error_sp->Printf(
"error: unable to add selected command: '%s'",
2161 llvm::toString(std::move(llvm_error)).c_str());
2168 "error: unable to create function, didn't add python command\n");
2172 error_sp->Printf(
"error: empty function, didn't add python command\n");
2177 "error: script interpreter missing, didn't add python command\n");
2186 result.
AppendError(
"only scripting language supported for scripted "
2187 "commands is currently Python");
2192 result.
AppendError(
"'command script add' requires at least one argument");
2210 command,
true, path_error);
2212 if (path_error.
Fail()) {
2223 m_cmd_name = std::string(command[num_args - 1].ref());
2245 result.
AppendError(
"cannot find ScriptInterpreter");
2273 if (add_error.
Fail())
2277 llvm::Error llvm_error =
2281 "cannot add command: %s",
2282 llvm::toString(std::move(llvm_error)).c_str());
2302 "List defined top-level scripted commands.",
2320 "Delete all scripted commands.", nullptr) {}
2338 interpreter,
"command script delete",
2339 "Delete a scripted command by specifying the path to the command.",
2356 llvm::StringRef root_cmd = command[0].ref();
2359 if (root_cmd.empty()) {
2366 "but no user defined commands found");
2373 command[0].c_str());
2376 if (!cmd_sp->IsUserCommand()) {
2378 command[0].c_str());
2381 if (cmd_sp->GetAsMultiwordCommand() && num_args == 1) {
2383 "Delete with \"command container delete\"",
2384 command[0].c_str());
2408 command[0].c_str());
2411 const char *leaf_cmd = command[num_args - 1].c_str();
2412 llvm::Error llvm_error =
2417 "could not delete command '%s': %s", leaf_cmd,
2418 llvm::toString(std::move(llvm_error)).c_str());
2424 out_stream <<
"Deleted command:";
2425 for (
size_t idx = 0; idx < num_args; idx++) {
2427 out_stream << command[idx].c_str();
2434#pragma mark CommandObjectMultiwordCommandsScript
2442 interpreter,
"command script",
2443 "Commands for managing custom "
2444 "commands implemented by "
2445 "interpreter scripts.",
2446 "command script <subcommand> [<subcommand-options>]") {
2465#pragma mark CommandObjectCommandContainer
2466#define LLDB_OPTIONS_container_add
2467#include "CommandOptions.inc"
2473 interpreter,
"command container add",
2474 "Add a container command to lldb. Adding to built-"
2475 "in container commands is not allowed.",
2476 "command container add [[path1]...] container-name") {
2503 switch (short_option) {
2505 if (!option_arg.empty())
2512 if (!option_arg.empty())
2516 llvm_unreachable(
"Unimplemented option");
2529 return llvm::ArrayRef(g_container_add_options);
2541 if (num_args == 0) {
2546 if (num_args == 1) {
2552 cmd_sp->GetAsMultiwordCommand()->SetRemovable(
true);
2555 if (add_error.
Fail()) {
2580 llvm::Error llvm_error =
2584 llvm::toString(std::move(llvm_error)).c_str());
2595#define LLDB_OPTIONS_multiword_delete
2596#include "CommandOptions.inc"
2601 interpreter,
"command container delete",
2602 "Delete a container command previously added to "
2604 "command container delete [[path1] ...] container-cmd") {
2621 if (num_args == 0) {
2626 if (num_args == 1) {
2638 if (!cmd_sp->IsUserCommand()) {
2640 "container command %s is not a user command", cmd_name);
2643 if (!cmd_sp->GetAsMultiwordCommand()) {
2671 llvm::Error llvm_error =
2675 llvm::toString(std::move(llvm_error)).c_str());
2686 interpreter,
"command container",
2687 "Commands for adding container commands to lldb. "
2688 "Container commands are containers for other commands. You can "
2689 "add nested container commands by specifying a command path, "
2690 "but you can't add commands into the built-in command hierarchy.",
2691 "command container <subcommand> [<subcommand-options>]") {
2702#pragma mark CommandObjectMultiwordCommands
2709 "Commands for managing custom LLDB commands.",
2710 "command <subcommand> [<subcommand-options>]") {
static const char * g_python_command_instructions
static llvm::raw_ostream & error(Stream &strm)
CommandObjectCommandContainer(CommandInterpreter &interpreter)
~CommandObjectCommandContainer() override=default
llvm::StringRef GetSyntax()
~CommandOptions() override=default
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
llvm::StringRef GetHelp()
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
std::unique_ptr< CommandObjectRegexCommand > m_regex_cmd_up
void IOHandlerInputComplete(IOHandler &io_handler, std::string &data) override
Called when a line or lines have been retrieved.
~CommandObjectCommandsAddRegex() override=default
CommandObjectCommandsAddRegex(CommandInterpreter &interpreter)
Options * GetOptions() override
Status AppendRegexSubstitution(const llvm::StringRef ®ex_sed, bool check_only)
void DoExecute(Args &command, CommandReturnObject &result) override
void IOHandlerActivated(IOHandler &io_handler, bool interactive) override
void AddRegexCommandToInterpreter()
~CommandOptions() override=default
OptionValueString m_long_help
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
bool HandleAliasingNormalCommand(Args &args, CommandReturnObject &result)
OptionGroupOptions m_option_group
CommandOptions m_command_options
void DoExecute(llvm::StringRef raw_command_line, CommandReturnObject &result) override
~CommandObjectCommandsAlias() override=default
Options * GetOptions() override
bool HandleAliasingRawCommand(llvm::StringRef alias_command, llvm::StringRef raw_command_string, CommandObject &cmd_obj, CommandReturnObject &result)
CommandObjectCommandsAlias(CommandInterpreter &interpreter)
~CommandOptions() override=default
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
~CommandObjectCommandsContainerAdd() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
Options * GetOptions() override
CommandObjectCommandsContainerAdd(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectCommandsContainerDelete(CommandInterpreter &interpreter)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectCommandsContainerDelete() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectCommandsDelete(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectCommandsDelete() override=default
LazyBool m_overwrite_lazy
~CommandOptions() override=default
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
CompletionType m_completion_type
ScriptedCommandSynchronicity m_synchronicity
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void IOHandlerActivated(IOHandler &io_handler, bool interactive) override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectCommandsScriptAdd() override=default
void IOHandlerInputComplete(IOHandler &io_handler, std::string &data) override
Called when a line or lines have been retrieved.
CompletionType m_completion_type
ScriptedCommandSynchronicity m_synchronicity
Options * GetOptions() override
CommandObjectMultiword * m_container
CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter)
CommandObjectCommandsScriptClear(CommandInterpreter &interpreter)
~CommandObjectCommandsScriptClear() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectCommandsScriptDelete() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectCommandsScriptDelete(CommandInterpreter &interpreter)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
void OptionParsingStarting(ExecutionContext *execution_context) override
bool relative_to_command_file
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
~CommandOptions() override=default
CommandObjectCommandsScriptImport(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
~CommandObjectCommandsScriptImport() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectCommandsScriptList() override=default
CommandObjectCommandsScriptList(CommandInterpreter &interpreter)
OptionValueBoolean m_cmd_relative_to_command_file
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
OptionValueBoolean m_stop_on_error
~CommandOptions() override=default
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
OptionValueBoolean m_stop_on_continue
OptionValueBoolean m_silent_run
std::optional< std::string > GetRepeatCommand(Args ¤t_command_args, uint32_t index) override
Get the command that appropriate for a "repeat" of the current command.
CommandObjectCommandsSource(CommandInterpreter &interpreter)
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectCommandsSource() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectCommandsUnalias(CommandInterpreter &interpreter)
~CommandObjectCommandsUnalias() override=default
~CommandObjectMultiwordCommandsScript() override=default
CommandObjectMultiwordCommandsScript(CommandInterpreter &interpreter)
std::string m_function_name
void DoExecute(llvm::StringRef raw_command_line, CommandReturnObject &result) override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
bool IsRemovable() const override
ScriptedCommandSynchronicity GetSynchronicity()
bool WantsCompletion() override
CommandObjectPythonFunction(CommandInterpreter &interpreter, std::string name, std::string funct, std::string help, ScriptedCommandSynchronicity synch, CompletionType completion_type)
ScriptedCommandSynchronicity m_synchro
llvm::StringRef GetHelpLong() override
const std::string & GetFunctionName()
CompletionType m_completion_type
~CommandObjectPythonFunction() override=default
StructuredData::GenericSP m_cmd_obj_sp
static Status ParseUsageMaskFromArray(StructuredData::ObjectSP obj_sp, size_t counter, uint32_t &usage_mask)
std::vector< std::string > m_usage_container
CommandInterpreter & m_interpreter
std::unique_ptr< OptionDefinition > m_options_definition_up
void OptionParsingStarting(ExecutionContext *execution_context) override
~CommandOptions() override=default
static std::unordered_set< std::string > g_string_storer
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
CommandOptions(CommandInterpreter &interpreter, StructuredData::GenericSP cmd_obj_sp)
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
std::vector< std::vector< OptionEnumValueElement > > m_enum_vector
std::vector< std::vector< EnumValueStorage > > m_enum_storage
Status SetOptionsFromArray(StructuredData::Dictionary &options)
This command implements a lldb parsed scripted command.
llvm::StringRef GetHelpLong() override
bool IsRemovable() const override
CommandObjectScriptingObjectParsed(CommandInterpreter &interpreter, std::string name, StructuredData::GenericSP cmd_obj_sp, ScriptedCommandSynchronicity synch)
void DoExecute(Args &args, CommandReturnObject &result) override
Options * GetOptions() override
llvm::StringRef GetHelp() override
~CommandObjectScriptingObjectParsed() override=default
bool m_fetched_help_short
bool WantsCompletion() override
ScriptedCommandSynchronicity m_synchro
StructuredData::GenericSP m_cmd_obj_sp
ScriptedCommandSynchronicity GetSynchronicity()
static CommandObjectSP Create(CommandInterpreter &interpreter, std::string name, StructuredData::GenericSP cmd_obj_sp, ScriptedCommandSynchronicity synch, CommandReturnObject &result)
This class implements a "raw" scripted command.
CompletionType m_completion_type
bool WantsCompletion() override
llvm::StringRef GetHelp() override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
StructuredData::GenericSP m_cmd_obj_sp
llvm::StringRef GetHelpLong() override
ScriptedCommandSynchronicity m_synchro
~CommandObjectScriptingObjectRaw() override=default
bool m_fetched_help_short
bool IsRemovable() const override
CommandObjectScriptingObjectRaw(CommandInterpreter &interpreter, std::string name, StructuredData::GenericSP cmd_obj_sp, ScriptedCommandSynchronicity synch, CompletionType completion_type)
ScriptedCommandSynchronicity GetSynchronicity()
void DoExecute(llvm::StringRef raw_command_line, CommandReturnObject &result) override
A command line argument class.
void Shift()
Shifts the first argument C string value of the array off the argument array.
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
llvm::ArrayRef< ArgEntry > entries() const
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
bool GetCommandString(std::string &command) const
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
static void CompleteModifiableCmdPathArgs(CommandInterpreter &interpreter, CompletionRequest &request, OptionElementVector &opt_element_vector)
This completer works for commands whose only arguments are a command path.
void SetStopOnContinue(bool stop_on_continue)
void SetSilent(bool silent)
void SetPrintErrors(bool print_errors)
void SetEchoCommands(bool echo_commands)
void SetStopOnError(bool stop_on_error)
void SetPrintResults(bool print_results)
void SetEchoCommentCommands(bool echo_comments)
bool UserMultiwordCommandExists(llvm::StringRef cmd) const
Determine whether a root-level user multiword command with this name exists.
void IncreaseCommandUsage(const CommandObject &cmd_obj)
bool RemoveAlias(llvm::StringRef alias_name)
CommandAlias * AddAlias(llvm::StringRef alias_name, lldb::CommandObjectSP &command_obj_sp, llvm::StringRef args_string=llvm::StringRef())
CommandObject * GetCommandObject(llvm::StringRef cmd, StringList *matches=nullptr, StringList *descriptions=nullptr) const
ExecutionContext GetExecutionContext() const
CommandObjectMultiword * VerifyUserMultiwordCmdPath(Args &path, bool leaf_is_command, Status &result)
Look up the command pointed to by path encoded in the arguments of the incoming command object.
bool GetEchoCommentCommands() const
Status AddUserCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
bool AddCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
bool AliasExists(llvm::StringRef cmd) const
Determine whether an alias command with this name exists.
bool HasUserMultiwordCommands() const
void GetHelp(CommandReturnObject &result, uint32_t types=eCommandTypesAllThem)
bool CommandExists(llvm::StringRef cmd) const
Determine whether a root level, built-in command with this name exists.
bool GetRequireCommandOverwrite() const
void GetPythonCommandsFromIOHandler(const char *prompt, IOHandlerDelegate &delegate, void *baton=nullptr)
lldb::CommandObjectSP GetCommandSPExact(llvm::StringRef cmd, bool include_aliases=false) const
bool RemoveUser(llvm::StringRef alias_name)
CommandObject * GetCommandObjectForCommand(llvm::StringRef &command_line)
bool RemoveUserMultiword(llvm::StringRef multiword_name)
bool UserCommandExists(llvm::StringRef cmd) const
Determine whether a root-level user command with this name exists.
bool HasUserCommands() const
const CommandObject::CommandMap & GetCommands() const
void HandleCommandsFromFile(FileSpec &file, const ExecutionContext &context, const CommandInterpreterRunOptions &options, CommandReturnObject &result)
Execute a list of commands from a file.
FileSpec GetCurrentSourceDir()
bool RemoveCommand(llvm::StringRef cmd, bool force=false)
Remove a command if it is removable (python or regex command).
const CommandObject::CommandMap & GetAliases() const
bool GetEchoCommands() const
static void GenerateAdditionalHelpAvenuesMessage(Stream *s, llvm::StringRef command, llvm::StringRef prefix, llvm::StringRef subcommand, bool include_upropos=true, bool include_type_lookup=true)
~CommandObjectMultiwordCommands() override
CommandObjectMultiwordCommands(CommandInterpreter &interpreter)
llvm::Error LoadUserSubcommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj, bool can_replace) override
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
llvm::Error RemoveUserSubcommand(llvm::StringRef cmd_name, bool multiword_okay)
std::vector< CommandArgumentData > CommandArgumentEntry
virtual void SetHelpLong(llvm::StringRef str)
virtual bool WantsRawCommandString()=0
void AddSimpleArgumentList(lldb::CommandArgumentType arg_type, ArgumentRepetitionType repetition_type=eArgRepeatPlain)
bool ParseOptionsAndNotify(Args &args, CommandReturnObject &result, OptionGroupOptions &group_options, ExecutionContext &exe_ctx)
llvm::StringRef GetCommandName() const
static std::optional< ArgumentRepetitionType > ArgRepetitionFromString(llvm::StringRef string)
virtual bool IsMultiwordObject()
ExecutionContext m_exe_ctx
std::vector< CommandArgumentEntry > m_arguments
CommandInterpreter & GetCommandInterpreter()
CommandInterpreter & m_interpreter
Flags & GetFlags()
The flags accessor.
virtual bool IsRemovable() const
virtual void SetHelp(llvm::StringRef str)
virtual lldb::CommandObjectSP GetSubcommandSP(llvm::StringRef sub_cmd, StringList *matches=nullptr)
void AppendErrorWithFormatv(const char *format, Args &&... args)
void void AppendError(llvm::StringRef in_string)
void AppendWarningWithFormat(const char *format,...) __attribute__((format(printf
llvm::StringRef GetOutputData()
void SetStatus(lldb::ReturnStatus status)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
lldb::ReturnStatus GetStatus() const
void void AppendWarning(llvm::StringRef in_string)
Stream & GetOutputStream()
"lldb/Utility/ArgCompletionRequest.h"
void TryCompleteCurrentArg(llvm::StringRef completion, llvm::StringRef description="")
Adds a possible completion string if the completion would complete the current argument.
size_t GetCursorIndex() const
A class to manage flag bits.
lldb::StreamSP GetAsyncOutputStream()
CommandInterpreter & GetCommandInterpreter()
void RunIOHandlerAsync(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler=true)
Run the given IO handler and return immediately.
ScriptInterpreter * GetScriptInterpreter(bool can_create=true, std::optional< lldb::ScriptLanguage > language={})
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
void Clear()
Clear the object's state.
bool IsRelative() const
Returns true if the filespec represents a relative path.
void MakeAbsolute(const FileSpec &dir)
Make the FileSpec absolute by treating it relative to dir.
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
static FileSystem & Instance()
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
A delegate class for use with IOHandler subclasses.
lldb::StreamFileSP GetErrorStreamFileSP()
lldb::StreamFileSP GetOutputStreamFileSP()
LoadScriptOptions & SetInitSession(bool b)
LoadScriptOptions & SetSilent(bool b)
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
bool GetCurrentValue() const
const char * GetCurrentValue() const
Status SetCurrentValue(llvm::StringRef value)
bool OptionWasSet() const
A pair of an option list with a 'raw' string as a suffix.
A command line option parsing protocol class.
void NotifyOptionParsingStarting(ExecutionContext *execution_context)
std::vector< Option > m_getopt_table
virtual bool SetOptionValueForCommandObject(StructuredData::GenericSP cmd_obj_sp, ExecutionContext *exe_ctx, llvm::StringRef long_option, llvm::StringRef value)
virtual StructuredData::GenericSP CreateScriptCommandObject(const char *class_name)
virtual bool RunScriptBasedCommand(const char *impl_function, llvm::StringRef args, ScriptedCommandSynchronicity synchronicity, lldb_private::CommandReturnObject &cmd_retobj, Status &error, const lldb_private::ExecutionContext &exe_ctx)
virtual bool GenerateScriptAliasFunction(StringList &input, std::string &output)
virtual bool GetDocumentationForItem(const char *item, std::string &dest)
virtual bool RunScriptBasedParsedCommand(StructuredData::GenericSP impl_obj_sp, Args &args, ScriptedCommandSynchronicity synchronicity, lldb_private::CommandReturnObject &cmd_retobj, Status &error, const lldb_private::ExecutionContext &exe_ctx)
virtual StructuredData::ObjectSP GetOptionsForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual StructuredData::ObjectSP GetArgumentsForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual void OptionParsingStartedForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual bool GetLongHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string &dest)
virtual uint32_t GetFlagsForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual bool GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string &dest)
void SetErrorStringWithFormatv(const char *format, Args &&... args)
bool Fail() const
Test for error condition.
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t SplitIntoLines(const std::string &lines)
ObjectSP GetItemAtIndex(size_t idx) const
bool ForEach(std::function< bool(Object *object)> const &foreach_callback) const
ObjectSP GetValueForKey(llvm::StringRef key) const
void ForEach(std::function< bool(llvm::StringRef key, Object *object)> const &callback) const
Dictionary * GetAsDictionary()
UnsignedInteger * GetAsUnsignedInteger()
std::shared_ptr< Generic > GenericSP
std::shared_ptr< Object > ObjectSP
A class that represents a running process on the host machine.
std::vector< OptionArgElement > OptionElementVector
std::shared_ptr< OptionArgVector > OptionArgVectorSP
ScriptedCommandSynchronicity
@ eScriptedCommandSynchronicitySynchronous
std::vector< std::tuple< std::string, int, std::string > > OptionArgVector
std::shared_ptr< lldb_private::IOHandler > IOHandlerSP
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
std::shared_ptr< lldb_private::Stream > StreamSP
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
std::shared_ptr< lldb_private::StreamFile > StreamFileSP
OptionEnumValueElement element
EnumValueStorage(const EnumValueStorage &in)
EnumValueStorage & operator=(const EnumValueStorage &in)
void SetElement(size_t in_value)
EnumValueStorage(std::string in_str_val, std::string in_usage, size_t in_value)
Used to build individual command argument lists.
ArgumentRepetitionType arg_repetition
lldb::CommandArgumentType arg_type
static int64_t ToOptionEnum(llvm::StringRef s, const OptionEnumValues &enum_values, int32_t fail_value, Status &error)
OptionValidator * validator
If non-NULL, option is valid iff |validator->IsValid()|, otherwise always valid.
const char * long_option
Full name for this option.
const char * usage_text
Full text explaining what this options does and what (if any) argument to pass it.
bool required
This option is required (in the current usage level).
uint32_t completion_type
The kind of completion for this option.
int option_has_arg
no_argument, required_argument or optional_argument
uint32_t usage_mask
Used to mark options that can be used together.
lldb::CommandArgumentType argument_type
Type of argument this option takes.
OptionEnumValues enum_values
If not empty, an array of enum values.
int short_option
Single character for this option.
const char * string_value