24#include "llvm/ADT/STLExtras.h"
33 :
public llvm::ErrorInfo<OptionParseError, DiagnosticError> {
39 : ErrorInfo(std::error_code(EINVAL, std::generic_category())),
42 : ErrorInfo(std::error_code(EINVAL, std::generic_category())) {
44 if (
auto pos = arg.
GetPos()) {
46 sloc = {
FileSpec{}, 1, *pos, len,
false,
true};
50 std::unique_ptr<CloneableError>
Clone()
const override {
51 return std::make_unique<OptionParseError>(
m_details[0]);
53 llvm::ArrayRef<DiagnosticDetail>
GetDetails()
const override {
84 bool is_a_subset =
true;
85 OptionSet::const_iterator pos_a;
86 OptionSet::const_iterator pos_b;
91 for (pos_a = set_a.begin(); pos_a != set_a.end() && is_a_subset; ++pos_a) {
92 pos_b = set_b.find(*pos_a);
93 if (pos_b == set_b.end())
105 size_t num_diffs = 0;
106 OptionSet::const_iterator pos_a;
107 OptionSet::const_iterator pos_b;
109 for (pos_a = set_a.begin(); pos_a != set_a.end(); ++pos_a) {
110 pos_b = set_b.find(*pos_a);
111 if (pos_b == set_b.end()) {
113 diffs.insert(*pos_a);
125 OptionSet::const_iterator pos;
126 OptionSet::iterator pos_union;
130 for (pos = set_a.begin(); pos != set_a.end(); ++pos)
131 union_set.insert(*pos);
134 for (pos = set_b.begin(); pos != set_b.end(); ++pos) {
135 pos_union = union_set.find(*pos);
136 if (pos_union == union_set.end())
137 union_set.insert(*pos);
142 bool options_are_valid =
false;
146 for (
int i = 0; i < num_levels && !options_are_valid; ++i) {
165 options_are_valid =
true;
169 options_are_valid =
true;
172 if (options_are_valid) {
175 result.
AppendError(
"invalid combination of options for the given command");
178 return options_are_valid;
191 if (num_options == 0)
201 uint32_t num_option_sets = 0;
203 for (
const auto &def : opt_defs) {
204 uint32_t this_usage_mask = def.usage_mask;
206 if (num_option_sets == 0)
210 if (this_usage_mask & (1 << j)) {
211 if (num_option_sets <= j)
212 num_option_sets = j + 1;
218 if (num_option_sets > 0) {
222 for (
const auto &def : opt_defs) {
223 for (uint32_t j = 0; j < num_option_sets; j++) {
224 if (def.usage_mask & 1 << j) {
244 std::map<int, uint32_t> option_seen;
247 for (
size_t i = 0; i < defs.size(); ++i) {
248 const int short_opt = defs[i].short_option;
254 auto [pos, inserted] = option_seen.try_emplace(short_opt, i);
255 if (!inserted && short_opt) {
258 if (defs[i].HasShortOption())
261 "option[{0}] --{1} has a short option -{2} that "
262 "conflicts with option[{3}] --{4}, short option won't "
264 i, defs[i].long_option, short_opt, pos->second,
271 "option[{0}] --{1} has a short option {2:x} that "
272 "conflicts with option[{3}] --{4}, short option won't "
274 (
int)i, defs[i].long_option, short_opt, pos->second,
304 uint32_t output_max_columns) {
305 std::string actual_text;
310 actual_text.append(condition);
311 actual_text.append(
"] ");
318 if (
static_cast<uint32_t
>(actual_text.length() + strm.
GetIndentLevel()) <
319 output_max_columns) {
329 int final_end = actual_text.length();
332 while (end < final_end) {
335 while ((start < final_end) && (actual_text[start] ==
' '))
338 end = start + text_width;
344 while (end > start && actual_text[end] !=
' ' &&
345 actual_text[end] !=
'\t' && actual_text[end] !=
'\n')
349 sub_len = end - start;
353 assert(start < final_end);
354 assert(start + sub_len <= final_end);
355 strm.
Write(actual_text.c_str() + start, sub_len);
363 if (!long_option || !long_option[0])
367 if (opt_defs.empty())
370 const char *long_option_name = long_option;
371 if (long_option[0] ==
'-' && long_option[1] ==
'-')
372 long_option_name += 2;
374 for (
auto &def : opt_defs) {
375 if (!def.long_option)
378 if (strcmp(def.long_option, long_option_name) == 0)
393 const char *footer,
bool show_optional,
Stream &strm) {
397 if (header && header[0])
400 if (show_optional && !opt_def.
required)
402 const bool show_short_option =
404 if (show_short_option)
416 strm.
Printf(
"%s[<%s>]", show_short_option ?
"" :
"=",
420 if (show_optional && !opt_def.
required)
422 if (footer && footer[0])
428 uint32_t screen_width) {
436 if (num_options == 0)
440 if (!only_print_args)
441 strm.
PutCString(
"\nCommand Options Usage:\n");
451 if (!only_print_args) {
453 for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
460 uint32_t opt_set_mask = 1 << opt_set;
468 std::set<int> required_options;
469 std::set<int> optional_options;
471 for (
auto &def : opt_defs) {
472 if (def.usage_mask & opt_set_mask && def.HasShortOption() &&
475 required_options.insert(def.short_option);
477 optional_options.insert(def.short_option);
482 if (!required_options.empty()) {
484 for (
int short_option : required_options)
488 if (!optional_options.empty()) {
490 for (
int short_option : optional_options)
496 for (
auto &def : opt_defs) {
497 if (def.usage_mask & opt_set_mask && def.HasShortOption() &&
503 for (
auto &def : opt_defs) {
504 if (def.usage_mask & opt_set_mask && !def.required &&
519 if (!only_print_args)
522 strm <<
" " << arguments_str.
GetString();
525 if (!only_print_args) {
537 std::multimap<int, uint32_t> options_ordered;
538 for (
auto def : llvm::enumerate(opt_defs))
539 options_ordered.insert(
540 std::make_pair(def.value().short_option, def.index()));
545 bool first_option_printed =
false;
547 for (
auto pos : options_ordered) {
549 if (first_option_printed)
552 first_option_printed =
true;
574 bool is_first =
true;
575 for (
const auto &enum_value : opt_def.
enum_values) {
577 strm.
Printf(
"%s", enum_value.string_value);
581 strm.
Printf(
" | %s", enum_value.string_value);
600 bool options_are_valid =
false;
604 for (
int i = 0; i < num_levels && !options_are_valid; ++i) {
612 options_are_valid =
true;
616 return options_are_valid;
631 for (
size_t i = 0; i < opt_element_vector.size(); i++) {
632 size_t opt_pos =
static_cast<size_t>(opt_element_vector[i].opt_pos);
633 size_t opt_arg_pos =
static_cast<size_t>(opt_element_vector[i].opt_arg_pos);
634 int opt_defs_index = opt_element_vector[i].opt_defs_index;
643 std::string opt_str =
"-a";
645 for (
auto &def : opt_defs) {
646 if (!def.short_option)
648 opt_str[1] = def.short_option;
654 std::string full_name(
"--");
655 for (
auto &def : opt_defs) {
656 if (!def.short_option)
659 full_name.erase(full_name.begin() + 2, full_name.end());
660 full_name.append(def.long_option);
671 if (cur_opt_str.starts_with(
"--") && cur_opt_str != long_option) {
684 if (cur_opt_str.consume_front(
"--")) {
685 for (
auto &def : opt_defs) {
686 llvm::StringRef long_option(def.long_option);
687 if (long_option.starts_with(cur_opt_str))
688 request.
AddCompletion(
"--" + long_option.str(), def.usage_text);
699 if (opt_defs_index != -1) {
720 std::unique_ptr<SearchFilter> filter_up;
722 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
725 const auto &enum_values = opt_defs[opt_defs_index].enum_values;
726 if (!enum_values.empty())
727 for (
const auto &enum_value : enum_values)
736 uint32_t completion_mask = opt_defs[opt_defs_index].completion_type;
738 if (completion_mask == 0) {
740 opt_defs[opt_defs_index].argument_type;
744 opt_defs[opt_defs_index].argument_type);
752 for (
size_t i = 0; i < opt_element_vector.size(); i++) {
753 int cur_defs_index = opt_element_vector[i].opt_defs_index;
761 int cur_arg_pos = opt_element_vector[i].opt_arg_pos;
762 const char *cur_opt_name = opt_defs[cur_defs_index].long_option;
766 if (cur_opt_name && strcmp(cur_opt_name,
"shlib") == 0 &&
768 const char *module_name =
777 std::make_unique<SearchFilterByModule>(target_sp, module_spec);
785 interpreter, completion_mask, request, filter_up.get());
790 for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
808 for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
809 if (group_option_defs[i].usage_mask & src_mask) {
818 OptionGroup *group, llvm::ArrayRef<llvm::StringRef> exclude_long_options) {
820 for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
821 const auto &definition = group_option_defs[i];
822 if (llvm::is_contained(exclude_long_options, definition.long_option))
835 llvm::StringRef option_value,
855 std::set<OptionGroup *> group_set;
859 if (group_set.find(group) == group_set.end()) {
861 group_set.insert(group);
867 std::set<OptionGroup *> group_set;
872 if (group_set.find(group) == group_set.end()) {
874 group_set.insert(group);
887 std::vector<char *> result;
889 result.push_back(
const_cast<char *
>(
"<FAKE-ARG0>"));
891 result.push_back(
const_cast<char *
>(entry.c_str()));
892 result.push_back(
nullptr);
898 const Args &original) {
899 return llvm::find_if(
911 const Args &original) {
913 for (
const char *arg : parsed) {
915 assert(pos != original.
end());
922 const Option &long_option) {
923 std::string short_opt = llvm::formatv(
"-{0}",
char(long_option.
val)).str();
924 std::string long_opt =
926 for (
const auto &entry : llvm::enumerate(args)) {
927 if (entry.value().ref().starts_with(short_opt) ||
928 entry.value().ref().starts_with(long_opt))
929 return entry.index();
937 llvm::raw_string_ostream sstr(storage);
943 for (
size_t i = 0; long_options[i].
definition !=
nullptr; ++i) {
944 if (long_options[i].flag ==
nullptr) {
945 sstr << (char)long_options[i].val;
946 switch (long_options[i].definition->option_has_arg) {
964 std::string &input_line) {
967 if (long_options ==
nullptr) {
968 return llvm::createStringError(
"Invalid long options");
973 Args args_copy = args;
976 std::unique_lock<std::mutex> lock;
980 int long_options_index = -1;
982 &long_options_index);
985 return llvm::createStringError(llvm::inconvertibleErrorCode(),
986 "last option requires an argument");
993 return llvm::createStringError(
"Unknown or ambiguous option");
1002 if (long_options_index == -1) {
1003 for (
int j = 0; long_options[j].
definition || long_options[j].
flag ||
1004 long_options[j].
val;
1006 if (long_options[j].val == val) {
1007 long_options_index = j;
1014 if (long_options_index == -1) {
1015 return llvm::createStringError(
1016 llvm::formatv(
"Invalid option with value '{0}'.",
char(val)).str());
1020 option_str.
Printf(
"-%c", val);
1025 const char *option_arg =
nullptr;
1029 return llvm::createStringError(
1030 llvm::formatv(
"Option '{0}' is missing argument specifier.",
1041 return llvm::createStringError(
1042 llvm::formatv(
"error with options table; invalid value in has_arg "
1043 "field for option '{0}'.",
1056 std::string option_to_insert;
1058 if (idx !=
size_t(-1) && has_arg) {
1059 bool arg_has_backtick = args_copy[idx + 1].GetQuoteChar() ==
'`';
1060 if (arg_has_backtick)
1061 option_to_insert =
"`";
1062 option_to_insert += option_arg;
1063 if (arg_has_backtick)
1064 option_to_insert +=
"`";
1066 option_to_insert = option_arg;
1070 option_arg_vector->emplace_back(std::string(option_str.
GetString()),
1071 has_arg, option_to_insert);
1073 if (idx ==
size_t(-1))
1076 if (!input_line.empty()) {
1077 llvm::StringRef tmp_arg = args_copy[idx].ref();
1078 size_t pos = input_line.find(std::string(tmp_arg));
1079 if (pos != std::string::npos)
1080 input_line.erase(pos, tmp_arg.size());
1087 if (input_line.size() > 0) {
1088 size_t pos = input_line.find(option_to_insert);
1089 if (pos != std::string::npos)
1090 input_line.erase(pos, option_to_insert.size());
1096 return std::move(args_copy);
1100 uint32_t cursor_index) {
1103 option_element_vector.clear();
1105 if (long_options ==
nullptr)
1106 return option_element_vector;
1110 std::unique_lock<std::mutex> lock;
1119 bool failed_once =
false;
1120 uint32_t dash_dash_pos = -1;
1123 bool missing_argument =
false;
1124 int long_options_index = -1;
1127 &long_options_index);
1153 if (dash_dash_pos == cursor_index) {
1154 option_element_vector.push_back(
1162 }
else if (val ==
'?') {
1169 }
else if (val == 0) {
1171 }
else if (val ==
':') {
1174 missing_argument =
true;
1180 if (long_options_index == -1) {
1181 for (
int j = 0; long_options[j].
definition || long_options[j].
flag ||
1182 long_options[j].
val;
1184 if (long_options[j].val == val) {
1185 long_options_index = j;
1192 if (long_options_index >= 0) {
1193 int opt_defs_index = -1;
1194 for (
size_t i = 0; i < opt_defs.size(); i++) {
1195 if (opt_defs[i].short_option != val)
1215 if (missing_argument)
1267 if ((
static_cast<int32_t
>(dash_dash_pos) == -1 ||
1268 cursor_index < dash_dash_pos) &&
1270 option_element_vector.push_back(
1274 return option_element_vector;
1280 bool require_validation) {
1283 if (long_options ==
nullptr) {
1284 return llvm::createStringError(
"Invalid long options.");
1290 std::unique_lock<std::mutex> lock;
1293 int long_options_index = -1;
1295 &long_options_index);
1311 args[idx],
"unknown or ambiguous option"));
1324 if (long_options_index == -1) {
1325 for (
int i = 0; long_options[i].
definition || long_options[i].
flag ||
1326 long_options[i].
val;
1328 if (long_options[i].val == val) {
1329 long_options_index = i;
1335 if (long_options_index >= 0 &&
1336 long_options[long_options_index].definition) {
1344 platform_sp = target_sp ? target_sp->GetPlatform() :
PlatformSP();
1348 if (!platform_sp && require_validation) {
1351 return llvm::createStringError(
1352 "cannot validate options: no platform available");
1355 bool validation_failed =
false;
1360 execution_context ? execution_context : &dummy_context;
1362 validation_failed =
true;
1370 if (!validation_failed)
1383 "invalid option with value '%i'", val);
1388 return error.ToError();
1396 llvm::StringRef option_arg,
const char short_option,
1397 llvm::StringRef long_option, llvm::StringRef additional_context) {
1399 llvm::raw_string_ostream stream(buffer);
1400 stream <<
"Invalid value ('" << option_arg <<
"') for -" << short_option;
1401 if (!long_option.empty())
1402 stream <<
" (" << long_option <<
")";
1403 if (!additional_context.empty())
1404 stream <<
": " << additional_context;
1405 return llvm::createStringError(llvm::inconvertibleErrorCode(), buffer);
static llvm::raw_ostream & error(Stream &strm)
static Args ReconstituteArgsAfterParsing(llvm::ArrayRef< char * > parsed, const Args &original)
static std::string BuildShortOptions(const Option *long_options)
static std::vector< char * > GetArgvForParsing(const Args &args)
static bool PrintOption(const OptionDefinition &opt_def, OptionDisplayType display_type, const char *header, const char *footer, bool show_optional, Stream &strm)
static Args::const_iterator FindOriginalIter(const char *arg, const Args &original)
static size_t FindArgumentIndexForOption(const Args &args, const Option &long_option)
static size_t FindOriginalIndex(const char *arg, const Args &original)
A command line argument class.
std::vector< ArgEntry >::const_iterator const_iterator
void DeleteArgumentAtIndex(size_t idx)
Deletes the argument value at index if idx is a valid argument index.
const_iterator begin() const
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
const_iterator end() const
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
static const char * g_no_argument
virtual bool WantsRawCommandString()=0
static const ArgumentTableEntry * FindArgumentDataByType(lldb::CommandArgumentType arg_type)
llvm::StringRef GetCommandName() const
void GetFormattedCommandArguments(Stream &str, uint32_t opt_set_mask=LLDB_OPT_SET_ALL)
virtual bool IsDashDashCommand()
static const char * GetArgumentName(lldb::CommandArgumentType arg_type)
void void AppendError(llvm::StringRef in_string)
void SetStatus(lldb::ReturnStatus status)
"lldb/Utility/ArgCompletionRequest.h"
void AddCompletion(llvm::StringRef completion, llvm::StringRef description="", CompletionMode mode=CompletionMode::Normal)
Adds a possible completion string.
const Args & GetParsedLine() const
llvm::StringRef GetCursorArgumentPrefix() const
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
lldb::TargetSP GetSelectedTarget()
static void ReportError(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report error events.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
void OptionParsingStarting(ExecutionContext *execution_context) override
std::vector< OptionDefinition > m_option_defs
const OptionGroup * GetGroupWithOption(char short_opt)
OptionInfos m_option_infos
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
Status OptionParsingFinished(ExecutionContext *execution_context) override
void Append(OptionGroup *group)
Append options from a OptionGroup class.
virtual Status OptionParsingFinished(ExecutionContext *execution_context)
virtual llvm::ArrayRef< OptionDefinition > GetDefinitions()=0
virtual void OptionParsingStarting(ExecutionContext *execution_context)=0
An llvm::Error that represents an option parsing diagnostic.
OptionParseError(DiagnosticDetail detail)
std::vector< DiagnosticDetail > m_details
llvm::ArrayRef< DiagnosticDetail > GetDetails() const override
OptionParseError(const Args::ArgEntry &arg, std::string msg)
std::unique_ptr< CloneableError > Clone() const override
static void Prepare(std::unique_lock< std::mutex > &lock)
static int Parse(llvm::MutableArrayRef< char * > argv, llvm::StringRef optstring, const Option *longopts, int *longindex)
Argv must be an argument vector "as passed to main", i.e.
static int GetOptionIndex()
static char * GetOptionArgument()
static void EnableError(bool error)
static int GetOptionErrorCause()
bool VerifyOptions(CommandReturnObject &result)
void OptionsSetUnion(const OptionSet &set_a, const OptionSet &set_b, OptionSet &union_set)
virtual void HandleOptionArgumentCompletion(lldb_private::CompletionRequest &request, OptionElementVector &opt_element_vector, int opt_element_index, CommandInterpreter &interpreter)
Handles the generic bits of figuring out whether we are in an option, and if so completing it.
virtual Status OptionParsingFinished(ExecutionContext *execution_context)
void GenerateOptionUsage(Stream &strm, CommandObject &cmd, uint32_t screen_width)
virtual Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context)=0
Set the value of an option.
void OutputFormattedUsageText(Stream &strm, const OptionDefinition &option_def, uint32_t output_max_columns)
uint32_t NumCommandOptions()
virtual void OptionParsingStarting(ExecutionContext *execution_context)=0
void OptionSeen(int short_option)
virtual llvm::ArrayRef< OptionDefinition > GetDefinitions()
Status NotifyOptionParsingFinished(ExecutionContext *execution_context)
bool VerifyPartialOptions(CommandReturnObject &result)
Option * GetLongOptions()
Get the option definitions to use when parsing Args options.
OptionSetVector m_optional_options
void NotifyOptionParsingStarting(ExecutionContext *execution_context)
llvm::Expected< Args > ParseAlias(const Args &args, OptionArgVector *option_arg_vector, std::string &input_line)
std::set< int > OptionSet
OptionSetVector m_required_options
OptionSetVector & GetOptionalOptions()
size_t OptionsSetDiff(const OptionSet &set_a, const OptionSet &set_b, OptionSet &diffs)
void BuildValidOptionSets()
bool HandleOptionCompletion(lldb_private::CompletionRequest &request, OptionElementVector &option_map, CommandInterpreter &interpreter)
Handles the generic bits of figuring out whether we are in an option, and if so completing it.
bool IsASubset(const OptionSet &set_a, const OptionSet &set_b)
bool SupportsLongOption(const char *long_option)
std::vector< Option > m_getopt_table
llvm::Expected< Args > Parse(const Args &args, ExecutionContext *execution_context, lldb::PlatformSP platform_sp, bool require_validation)
Parse the provided arguments.
OptionSetVector & GetRequiredOptions()
OptionElementVector ParseForCompletion(const Args &args, uint32_t cursor_index)
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
static Status FromErrorString(const char *str)
static Status FromError(llvm::Error error)
Avoid using this in new code. Migrate APIs to llvm::Expected instead.
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
void SetIndentLevel(unsigned level)
Set the current indentation level.
size_t EOL()
Output and End of Line character to the stream.
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
void IndentMore(unsigned amount=2)
Increment the current indentation level.
unsigned GetIndentLevel() const
Get the current indentation level.
#define LLDB_MAX_NUM_OPTION_SETS
Option Set definitions.
A class that represents a running process on the host machine.
std::vector< OptionArgElement > OptionElementVector
TableValidator< 0 > validator
llvm::Error CreateOptionParsingError(llvm::StringRef option_arg, const char short_option, llvm::StringRef long_option={}, llvm::StringRef additional_context={})
Creates an error that represents the failure to parse an command line option argument.
std::vector< std::tuple< std::string, int, std::string > > OptionArgVector
std::shared_ptr< lldb_private::Platform > PlatformSP
@ eReturnStatusSuccessFinishNoResult
std::shared_ptr< lldb_private::Target > TargetSP
const char * c_str() const
llvm::StringRef ref() const
bool IsQuoted() const
Returns true if this argument was quoted in any way.
std::optional< uint16_t > GetPos() const
Entries in the main argument information table.
lldb::CompletionType completion_type
A source location consisting of a file name and position.
A compiler-independent representation of an lldb_private::Diagnostic.
bool HasShortOption() const
Whether this has a short option character.
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).
int option_has_arg
no_argument, required_argument or optional_argument
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.
virtual const char * LongConditionString() const =0
virtual const char * ShortConditionString() const =0
const OptionDefinition * definition