1 //===-- Options.cpp ---------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Interpreter/Options.h"
19 // Other libraries and framework includes
21 #include "lldb/Host/OptionParser.h"
22 #include "lldb/Interpreter/CommandCompletions.h"
23 #include "lldb/Interpreter/CommandInterpreter.h"
24 #include "lldb/Interpreter/CommandObject.h"
25 #include "lldb/Interpreter/CommandReturnObject.h"
26 #include "lldb/Target/Target.h"
27 #include "lldb/Utility/StreamString.h"
30 using namespace lldb_private;
32 //-------------------------------------------------------------------------
34 //-------------------------------------------------------------------------
35 Options::Options() : m_getopt_table() { BuildValidOptionSets(); }
37 Options::~Options() {}
39 void Options::NotifyOptionParsingStarting(ExecutionContext *execution_context) {
40 m_seen_options.clear();
41 // Let the subclass reset its option values
42 OptionParsingStarting(execution_context);
46 Options::NotifyOptionParsingFinished(ExecutionContext *execution_context) {
47 return OptionParsingFinished(execution_context);
50 void Options::OptionSeen(int option_idx) { m_seen_options.insert(option_idx); }
52 // Returns true is set_a is a subset of set_b; Otherwise returns false.
54 bool Options::IsASubset(const OptionSet &set_a, const OptionSet &set_b) {
55 bool is_a_subset = true;
56 OptionSet::const_iterator pos_a;
57 OptionSet::const_iterator pos_b;
59 // set_a is a subset of set_b if every member of set_a is also a member of
62 for (pos_a = set_a.begin(); pos_a != set_a.end() && is_a_subset; ++pos_a) {
63 pos_b = set_b.find(*pos_a);
64 if (pos_b == set_b.end())
71 // Returns the set difference set_a - set_b, i.e. { x | ElementOf (x, set_a) &&
72 // !ElementOf (x, set_b) }
74 size_t Options::OptionsSetDiff(const OptionSet &set_a, const OptionSet &set_b,
77 OptionSet::const_iterator pos_a;
78 OptionSet::const_iterator pos_b;
80 for (pos_a = set_a.begin(); pos_a != set_a.end(); ++pos_a) {
81 pos_b = set_b.find(*pos_a);
82 if (pos_b == set_b.end()) {
91 // Returns the union of set_a and set_b. Does not put duplicate members into
94 void Options::OptionsSetUnion(const OptionSet &set_a, const OptionSet &set_b,
95 OptionSet &union_set) {
96 OptionSet::const_iterator pos;
97 OptionSet::iterator pos_union;
99 // Put all the elements of set_a into the union.
101 for (pos = set_a.begin(); pos != set_a.end(); ++pos)
102 union_set.insert(*pos);
104 // Put all the elements of set_b that are not already there into the union.
105 for (pos = set_b.begin(); pos != set_b.end(); ++pos) {
106 pos_union = union_set.find(*pos);
107 if (pos_union == union_set.end())
108 union_set.insert(*pos);
112 bool Options::VerifyOptions(CommandReturnObject &result) {
113 bool options_are_valid = false;
115 int num_levels = GetRequiredOptions().size();
117 for (int i = 0; i < num_levels && !options_are_valid; ++i) {
118 // This is the correct set of options if: 1). m_seen_options contains
119 // all of m_required_options[i] (i.e. all the required options at this
120 // level are a subset of m_seen_options); AND 2). { m_seen_options -
121 // m_required_options[i] is a subset of m_options_options[i] (i.e. all
122 // the rest of m_seen_options are in the set of optional options at this
125 // Check to see if all of m_required_options[i] are a subset of
127 if (IsASubset(GetRequiredOptions()[i], m_seen_options)) {
128 // Construct the set difference: remaining_options = {m_seen_options} -
129 // {m_required_options[i]}
130 OptionSet remaining_options;
131 OptionsSetDiff(m_seen_options, GetRequiredOptions()[i],
133 // Check to see if remaining_options is a subset of
134 // m_optional_options[i]
135 if (IsASubset(remaining_options, GetOptionalOptions()[i]))
136 options_are_valid = true;
140 options_are_valid = true;
143 if (options_are_valid) {
144 result.SetStatus(eReturnStatusSuccessFinishNoResult);
146 result.AppendError("invalid combination of options for the given command");
147 result.SetStatus(eReturnStatusFailed);
150 return options_are_valid;
153 // This is called in the Options constructor, though we could call it lazily if
154 // that ends up being a performance problem.
156 void Options::BuildValidOptionSets() {
157 // Check to see if we already did this.
158 if (m_required_options.size() != 0)
161 // Check to see if there are any options.
162 int num_options = NumCommandOptions();
163 if (num_options == 0)
166 auto opt_defs = GetDefinitions();
167 m_required_options.resize(1);
168 m_optional_options.resize(1);
170 // First count the number of option sets we've got. Ignore
171 // LLDB_ALL_OPTION_SETS...
173 uint32_t num_option_sets = 0;
175 for (const auto &def : opt_defs) {
176 uint32_t this_usage_mask = def.usage_mask;
177 if (this_usage_mask == LLDB_OPT_SET_ALL) {
178 if (num_option_sets == 0)
181 for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++) {
182 if (this_usage_mask & (1 << j)) {
183 if (num_option_sets <= j)
184 num_option_sets = j + 1;
190 if (num_option_sets > 0) {
191 m_required_options.resize(num_option_sets);
192 m_optional_options.resize(num_option_sets);
194 for (const auto &def : opt_defs) {
195 for (uint32_t j = 0; j < num_option_sets; j++) {
196 if (def.usage_mask & 1 << j) {
198 m_required_options[j].insert(def.short_option);
200 m_optional_options[j].insert(def.short_option);
207 uint32_t Options::NumCommandOptions() { return GetDefinitions().size(); }
209 Option *Options::GetLongOptions() {
210 // Check to see if this has already been done.
211 if (m_getopt_table.empty()) {
212 auto defs = GetDefinitions();
216 std::map<int, uint32_t> option_seen;
218 m_getopt_table.resize(defs.size() + 1);
219 for (size_t i = 0; i < defs.size(); ++i) {
220 const int short_opt = defs[i].short_option;
222 m_getopt_table[i].definition = &defs[i];
223 m_getopt_table[i].flag = nullptr;
224 m_getopt_table[i].val = short_opt;
226 if (option_seen.find(short_opt) == option_seen.end()) {
227 option_seen[short_opt] = i;
228 } else if (short_opt) {
229 m_getopt_table[i].val = 0;
230 std::map<int, uint32_t>::const_iterator pos =
231 option_seen.find(short_opt);
233 if (isprint8(short_opt))
234 Host::SystemLog(Host::eSystemLogError,
235 "option[%u] --%s has a short option -%c that "
236 "conflicts with option[%u] --%s, short option won't "
237 "be used for --%s\n",
238 (int)i, defs[i].long_option, short_opt, pos->second,
239 m_getopt_table[pos->second].definition->long_option,
240 defs[i].long_option);
242 Host::SystemLog(Host::eSystemLogError,
243 "option[%u] --%s has a short option 0x%x that "
244 "conflicts with option[%u] --%s, short option won't "
245 "be used for --%s\n",
246 (int)i, defs[i].long_option, short_opt, pos->second,
247 m_getopt_table[pos->second].definition->long_option,
248 defs[i].long_option);
252 // getopt_long_only requires a NULL final entry in the table:
254 m_getopt_table.back().definition = nullptr;
255 m_getopt_table.back().flag = nullptr;
256 m_getopt_table.back().val = 0;
259 if (m_getopt_table.empty())
262 return &m_getopt_table.front();
265 // This function takes INDENT, which tells how many spaces to output at the
266 // front of each line; SPACES, which is a string containing 80 spaces; and
267 // TEXT, which is the text that is to be output. It outputs the text, on
268 // multiple lines if necessary, to RESULT, with INDENT spaces at the front of
269 // each line. It breaks lines on spaces, tabs or newlines, shortening the line
270 // if necessary to not break in the middle of a word. It assumes that each
271 // output line should contain a maximum of OUTPUT_MAX_COLUMNS characters.
273 void Options::OutputFormattedUsageText(Stream &strm,
274 const OptionDefinition &option_def,
275 uint32_t output_max_columns) {
276 std::string actual_text;
277 if (option_def.validator) {
278 const char *condition = option_def.validator->ShortConditionString();
281 actual_text.append(condition);
282 actual_text.append("] ");
285 actual_text.append(option_def.usage_text);
287 // Will it all fit on one line?
289 if (static_cast<uint32_t>(actual_text.length() + strm.GetIndentLevel()) <
290 output_max_columns) {
291 // Output it as a single line.
292 strm.Indent(actual_text.c_str());
295 // We need to break it up into multiple lines.
297 int text_width = output_max_columns - strm.GetIndentLevel() - 1;
300 int final_end = actual_text.length();
303 while (end < final_end) {
304 // Don't start the 'text' on a space, since we're already outputting the
306 while ((start < final_end) && (actual_text[start] == ' '))
309 end = start + text_width;
313 // If we're not at the end of the text, make sure we break the line on
315 while (end > start && actual_text[end] != ' ' &&
316 actual_text[end] != '\t' && actual_text[end] != '\n')
320 sub_len = end - start;
324 assert(start < final_end);
325 assert(start + sub_len <= final_end);
326 strm.Write(actual_text.c_str() + start, sub_len);
333 bool Options::SupportsLongOption(const char *long_option) {
334 if (!long_option || !long_option[0])
337 auto opt_defs = GetDefinitions();
338 if (opt_defs.empty())
341 const char *long_option_name = long_option;
342 if (long_option[0] == '-' && long_option[1] == '-')
343 long_option_name += 2;
345 for (auto &def : opt_defs) {
346 if (!def.long_option)
349 if (strcmp(def.long_option, long_option_name) == 0)
356 enum OptionDisplayType {
362 static bool PrintOption(const OptionDefinition &opt_def,
363 OptionDisplayType display_type, const char *header,
364 const char *footer, bool show_optional, Stream &strm) {
365 const bool has_short_option = isprint8(opt_def.short_option) != 0;
367 if (display_type == eDisplayShortOption && !has_short_option)
370 if (header && header[0])
371 strm.PutCString(header);
373 if (show_optional && !opt_def.required)
375 const bool show_short_option =
376 has_short_option && display_type != eDisplayLongOption;
377 if (show_short_option)
378 strm.Printf("-%c", opt_def.short_option);
380 strm.Printf("--%s", opt_def.long_option);
381 switch (opt_def.option_has_arg) {
382 case OptionParser::eNoArgument:
384 case OptionParser::eRequiredArgument:
385 strm.Printf(" <%s>", CommandObject::GetArgumentName(opt_def.argument_type));
388 case OptionParser::eOptionalArgument:
389 strm.Printf("%s[<%s>]", show_short_option ? "" : "=",
390 CommandObject::GetArgumentName(opt_def.argument_type));
393 if (show_optional && !opt_def.required)
395 if (footer && footer[0])
396 strm.PutCString(footer);
400 void Options::GenerateOptionUsage(Stream &strm, CommandObject *cmd,
401 uint32_t screen_width) {
402 const bool only_print_args = cmd->IsDashDashCommand();
404 auto opt_defs = GetDefinitions();
405 const uint32_t save_indent_level = strm.GetIndentLevel();
406 llvm::StringRef name;
408 StreamString arguments_str;
411 name = cmd->GetCommandName();
412 cmd->GetFormattedCommandArguments(arguments_str);
416 strm.PutCString("\nCommand Options Usage:\n");
420 // First, show each usage level set of options, e.g. <cmd> [options-for-
423 // [options-for-level-1]
426 const uint32_t num_options = NumCommandOptions();
427 if (num_options == 0)
430 uint32_t num_option_sets = GetRequiredOptions().size();
434 if (!only_print_args) {
435 for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
436 uint32_t opt_set_mask;
438 opt_set_mask = 1 << opt_set;
443 // Different option sets may require different args.
444 StreamString args_str;
446 cmd->GetFormattedCommandArguments(args_str, opt_set_mask);
448 // First go through and print all options that take no arguments as a
449 // single string. If a command has "-a" "-b" and "-c", this will show up
452 std::set<int> options;
453 std::set<int>::const_iterator options_pos, options_end;
454 for (auto &def : opt_defs) {
455 if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
456 // Add current option to the end of out_stream.
458 if (def.required && def.option_has_arg == OptionParser::eNoArgument) {
459 options.insert(def.short_option);
464 if (options.empty() == false) {
465 // We have some required options with no arguments
466 strm.PutCString(" -");
467 for (i = 0; i < 2; ++i)
468 for (options_pos = options.begin(), options_end = options.end();
469 options_pos != options_end; ++options_pos) {
470 if (i == 0 && ::islower(*options_pos))
472 if (i == 1 && ::isupper(*options_pos))
474 strm << (char)*options_pos;
479 for (auto &def : opt_defs) {
480 if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
481 // Add current option to the end of out_stream.
483 if (def.required == false &&
484 def.option_has_arg == OptionParser::eNoArgument) {
485 options.insert(def.short_option);
490 if (options.empty() == false) {
491 // We have some required options with no arguments
492 strm.PutCString(" [-");
493 for (i = 0; i < 2; ++i)
494 for (options_pos = options.begin(), options_end = options.end();
495 options_pos != options_end; ++options_pos) {
496 if (i == 0 && ::islower(*options_pos))
498 if (i == 1 && ::isupper(*options_pos))
500 strm << (char)*options_pos;
505 // First go through and print the required options (list them up front).
507 for (auto &def : opt_defs) {
508 if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
509 if (def.required && def.option_has_arg != OptionParser::eNoArgument)
510 PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
514 // Now go through again, and this time only print the optional options.
516 for (auto &def : opt_defs) {
517 if (def.usage_mask & opt_set_mask) {
518 // Add current option to the end of out_stream.
520 if (!def.required && def.option_has_arg != OptionParser::eNoArgument)
521 PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
525 if (args_str.GetSize() > 0) {
526 if (cmd->WantsRawCommandString() && !only_print_args)
529 strm << " " << args_str.GetString();
536 if (cmd && (only_print_args || cmd->WantsRawCommandString()) &&
537 arguments_str.GetSize() > 0) {
538 if (!only_print_args)
541 strm << " " << arguments_str.GetString();
546 if (!only_print_args) {
547 // Now print out all the detailed information about the various options:
548 // long form, short form and help text:
549 // -short <argument> ( --long_name <argument> )
552 // This variable is used to keep track of which options' info we've printed
553 // out, because some options can be in more than one usage level, but we
554 // only want to print the long form of its information once.
556 std::multimap<int, uint32_t> options_seen;
559 // Put the unique command options in a vector & sort it, so we can output
560 // them alphabetically (by short_option) when writing out detailed help for
564 for (auto &def : opt_defs)
565 options_seen.insert(std::make_pair(def.short_option, i++));
567 // Go through the unique'd and alphabetically sorted vector of options,
568 // find the table entry for each option and write out the detailed help
569 // information for that option.
571 bool first_option_printed = false;
573 for (auto pos : options_seen) {
575 // Print out the help information for this option.
577 // Put a newline separation between arguments
578 if (first_option_printed)
581 first_option_printed = true;
583 CommandArgumentType arg_type = opt_defs[i].argument_type;
585 StreamString arg_name_str;
586 arg_name_str.Printf("<%s>", CommandObject::GetArgumentName(arg_type));
589 if (opt_defs[i].short_option && isprint8(opt_defs[i].short_option)) {
590 PrintOption(opt_defs[i], eDisplayShortOption, nullptr, nullptr, false,
592 PrintOption(opt_defs[i], eDisplayLongOption, " ( ", " )", false, strm);
594 // Short option is not printable, just print long option
595 PrintOption(opt_defs[i], eDisplayLongOption, nullptr, nullptr, false,
602 if (opt_defs[i].usage_text)
603 OutputFormattedUsageText(strm, opt_defs[i], screen_width);
604 if (opt_defs[i].enum_values != nullptr) {
606 strm.Printf("Values: ");
607 for (int k = 0; opt_defs[i].enum_values[k].string_value != nullptr;
610 strm.Printf("%s", opt_defs[i].enum_values[k].string_value);
612 strm.Printf(" | %s", opt_defs[i].enum_values[k].string_value);
620 // Restore the indent level
621 strm.SetIndentLevel(save_indent_level);
624 // This function is called when we have been given a potentially incomplete set
625 // of options, such as when an alias has been defined (more options might be
626 // added at at the time the alias is invoked). We need to verify that the
627 // options in the set m_seen_options are all part of a set that may be used
628 // together, but m_seen_options may be missing some of the "required" options.
630 bool Options::VerifyPartialOptions(CommandReturnObject &result) {
631 bool options_are_valid = false;
633 int num_levels = GetRequiredOptions().size();
635 for (int i = 0; i < num_levels && !options_are_valid; ++i) {
636 // In this case we are treating all options as optional rather than
637 // required. Therefore a set of options is correct if m_seen_options is a
638 // subset of the union of m_required_options and m_optional_options.
640 OptionsSetUnion(GetRequiredOptions()[i], GetOptionalOptions()[i],
642 if (IsASubset(m_seen_options, union_set))
643 options_are_valid = true;
647 return options_are_valid;
650 bool Options::HandleOptionCompletion(CompletionRequest &request,
651 OptionElementVector &opt_element_vector,
652 CommandInterpreter &interpreter) {
653 request.SetWordComplete(true);
655 // For now we just scan the completions to see if the cursor position is in
656 // an option or its argument. Otherwise we'll call HandleArgumentCompletion.
657 // In the future we can use completion to validate options as well if we
660 auto opt_defs = GetDefinitions();
662 std::string cur_opt_std_str = request.GetCursorArgumentPrefix().str();
663 const char *cur_opt_str = cur_opt_std_str.c_str();
665 for (size_t i = 0; i < opt_element_vector.size(); i++) {
666 int opt_pos = opt_element_vector[i].opt_pos;
667 int opt_arg_pos = opt_element_vector[i].opt_arg_pos;
668 int opt_defs_index = opt_element_vector[i].opt_defs_index;
669 if (opt_pos == request.GetCursorIndex()) {
670 // We're completing the option itself.
672 if (opt_defs_index == OptionArgElement::eBareDash) {
673 // We're completing a bare dash. That means all options are open.
674 // FIXME: We should scan the other options provided and only complete
676 // within the option group they belong to.
677 char opt_str[3] = {'-', 'a', '\0'};
679 for (auto &def : opt_defs) {
680 if (!def.short_option)
682 opt_str[1] = def.short_option;
683 request.GetMatches().AppendString(opt_str);
687 } else if (opt_defs_index == OptionArgElement::eBareDoubleDash) {
688 std::string full_name("--");
689 for (auto &def : opt_defs) {
690 if (!def.short_option)
693 full_name.erase(full_name.begin() + 2, full_name.end());
694 full_name.append(def.long_option);
695 request.GetMatches().AppendString(full_name.c_str());
698 } else if (opt_defs_index != OptionArgElement::eUnrecognizedArg) {
699 // We recognized it, if it an incomplete long option, complete it
700 // anyway (getopt_long_only is happy with shortest unique string, but
701 // it's still a nice thing to do.) Otherwise return The string so the
702 // upper level code will know this is a full match and add the " ".
703 if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
704 cur_opt_str[1] == '-' &&
705 strcmp(opt_defs[opt_defs_index].long_option, cur_opt_str) != 0) {
706 std::string full_name("--");
707 full_name.append(opt_defs[opt_defs_index].long_option);
708 request.GetMatches().AppendString(full_name.c_str());
711 request.GetMatches().AppendString(request.GetCursorArgument());
715 // FIXME - not handling wrong options yet:
716 // Check to see if they are writing a long option & complete it.
717 // I think we will only get in here if the long option table has two
719 // that are not unique up to this point. getopt_long_only does
720 // shortest unique match for long options already.
722 if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
723 cur_opt_str[1] == '-') {
724 for (auto &def : opt_defs) {
725 if (!def.long_option)
728 if (strstr(def.long_option, cur_opt_str + 2) == def.long_option) {
729 std::string full_name("--");
730 full_name.append(def.long_option);
731 // The options definitions table has duplicates because of the
732 // way the grouping information is stored, so only add once.
733 bool duplicate = false;
734 for (size_t k = 0; k < request.GetMatches().GetSize(); k++) {
735 if (request.GetMatches().GetStringAtIndex(k) == full_name) {
741 request.GetMatches().AppendString(full_name.c_str());
748 } else if (opt_arg_pos == request.GetCursorIndex()) {
749 // Okay the cursor is on the completion of an argument. See if it has a
750 // completion, otherwise return no matches.
752 CompletionRequest subrequest = request;
753 subrequest.SetCursorCharPosition(subrequest.GetCursorArgument().size());
754 if (opt_defs_index != -1) {
755 HandleOptionArgumentCompletion(subrequest, opt_element_vector, i,
757 request.SetWordComplete(subrequest.GetWordComplete());
760 // No completion callback means no completions...
765 // Not the last element, keep going.
772 bool Options::HandleOptionArgumentCompletion(
773 CompletionRequest &request, OptionElementVector &opt_element_vector,
774 int opt_element_index, CommandInterpreter &interpreter) {
775 auto opt_defs = GetDefinitions();
776 std::unique_ptr<SearchFilter> filter_ap;
778 int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
779 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
781 // See if this is an enumeration type option, and if so complete it here:
783 OptionEnumValueElement *enum_values = opt_defs[opt_defs_index].enum_values;
784 if (enum_values != nullptr) {
785 bool return_value = false;
786 std::string match_string(
787 request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos),
788 request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos) +
789 request.GetCursorCharPosition());
790 for (int i = 0; enum_values[i].string_value != nullptr; i++) {
791 if (strstr(enum_values[i].string_value, match_string.c_str()) ==
792 enum_values[i].string_value) {
793 request.GetMatches().AppendString(enum_values[i].string_value);
800 // If this is a source file or symbol type completion, and there is a -shlib
801 // option somewhere in the supplied arguments, then make a search filter for
802 // that shared library.
803 // FIXME: Do we want to also have an "OptionType" so we don't have to match
806 uint32_t completion_mask = opt_defs[opt_defs_index].completion_type;
808 if (completion_mask == 0) {
809 lldb::CommandArgumentType option_arg_type =
810 opt_defs[opt_defs_index].argument_type;
811 if (option_arg_type != eArgTypeNone) {
812 const CommandObject::ArgumentTableEntry *arg_entry =
813 CommandObject::FindArgumentDataByType(
814 opt_defs[opt_defs_index].argument_type);
816 completion_mask = arg_entry->completion_type;
820 if (completion_mask & CommandCompletions::eSourceFileCompletion ||
821 completion_mask & CommandCompletions::eSymbolCompletion) {
822 for (size_t i = 0; i < opt_element_vector.size(); i++) {
823 int cur_defs_index = opt_element_vector[i].opt_defs_index;
825 // trying to use <0 indices will definitely cause problems
826 if (cur_defs_index == OptionArgElement::eUnrecognizedArg ||
827 cur_defs_index == OptionArgElement::eBareDash ||
828 cur_defs_index == OptionArgElement::eBareDoubleDash)
831 int cur_arg_pos = opt_element_vector[i].opt_arg_pos;
832 const char *cur_opt_name = opt_defs[cur_defs_index].long_option;
834 // If this is the "shlib" option and there was an argument provided,
835 // restrict it to that shared library.
836 if (cur_opt_name && strcmp(cur_opt_name, "shlib") == 0 &&
838 const char *module_name =
839 request.GetParsedLine().GetArgumentAtIndex(cur_arg_pos);
841 FileSpec module_spec(module_name, false);
842 lldb::TargetSP target_sp =
843 interpreter.GetDebugger().GetSelectedTarget();
844 // Search filters require a target...
846 filter_ap.reset(new SearchFilterByModule(target_sp, module_spec));
853 return CommandCompletions::InvokeCommonCompletionCallbacks(
854 interpreter, completion_mask, request, filter_ap.get());
857 void OptionGroupOptions::Append(OptionGroup *group) {
858 auto group_option_defs = group->GetDefinitions();
859 for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
860 m_option_infos.push_back(OptionInfo(group, i));
861 m_option_defs.push_back(group_option_defs[i]);
865 const OptionGroup *OptionGroupOptions::GetGroupWithOption(char short_opt) {
866 for (uint32_t i = 0; i < m_option_defs.size(); i++) {
867 OptionDefinition opt_def = m_option_defs[i];
868 if (opt_def.short_option == short_opt)
869 return m_option_infos[i].option_group;
874 void OptionGroupOptions::Append(OptionGroup *group, uint32_t src_mask,
876 auto group_option_defs = group->GetDefinitions();
877 for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
878 if (group_option_defs[i].usage_mask & src_mask) {
879 m_option_infos.push_back(OptionInfo(group, i));
880 m_option_defs.push_back(group_option_defs[i]);
881 m_option_defs.back().usage_mask = dst_mask;
886 void OptionGroupOptions::Finalize() {
887 m_did_finalize = true;
890 Status OptionGroupOptions::SetOptionValue(uint32_t option_idx,
891 llvm::StringRef option_value,
892 ExecutionContext *execution_context) {
893 // After calling OptionGroupOptions::Append(...), you must finalize the
894 // groups by calling OptionGroupOptions::Finlize()
895 assert(m_did_finalize);
897 if (option_idx < m_option_infos.size()) {
898 error = m_option_infos[option_idx].option_group->SetOptionValue(
899 m_option_infos[option_idx].option_index, option_value,
903 error.SetErrorString("invalid option index"); // Shouldn't happen...
908 void OptionGroupOptions::OptionParsingStarting(
909 ExecutionContext *execution_context) {
910 std::set<OptionGroup *> group_set;
911 OptionInfos::iterator pos, end = m_option_infos.end();
912 for (pos = m_option_infos.begin(); pos != end; ++pos) {
913 OptionGroup *group = pos->option_group;
914 if (group_set.find(group) == group_set.end()) {
915 group->OptionParsingStarting(execution_context);
916 group_set.insert(group);
921 OptionGroupOptions::OptionParsingFinished(ExecutionContext *execution_context) {
922 std::set<OptionGroup *> group_set;
924 OptionInfos::iterator pos, end = m_option_infos.end();
925 for (pos = m_option_infos.begin(); pos != end; ++pos) {
926 OptionGroup *group = pos->option_group;
927 if (group_set.find(group) == group_set.end()) {
928 error = group->OptionParsingFinished(execution_context);
929 group_set.insert(group);
937 // OptionParser permutes the arguments while processing them, so we create a
938 // temporary array holding to avoid modification of the input arguments. The
939 // options themselves are never modified, but the API expects a char * anyway,
940 // hence the const_cast.
941 static std::vector<char *> GetArgvForParsing(const Args &args) {
942 std::vector<char *> result;
943 // OptionParser always skips the first argument as it is based on getopt().
944 result.push_back(const_cast<char *>("<FAKE-ARG0>"));
945 for (const Args::ArgEntry &entry : args)
946 result.push_back(const_cast<char *>(entry.c_str()));
950 // Given a permuted argument, find it's position in the original Args vector.
951 static Args::const_iterator FindOriginalIter(const char *arg,
952 const Args &original) {
953 return llvm::find_if(
954 original, [arg](const Args::ArgEntry &D) { return D.c_str() == arg; });
957 // Given a permuted argument, find it's index in the original Args vector.
958 static size_t FindOriginalIndex(const char *arg, const Args &original) {
959 return std::distance(original.begin(), FindOriginalIter(arg, original));
962 // Construct a new Args object, consisting of the entries from the original
963 // arguments, but in the permuted order.
964 static Args ReconstituteArgsAfterParsing(llvm::ArrayRef<char *> parsed,
965 const Args &original) {
967 for (const char *arg : parsed) {
968 auto pos = FindOriginalIter(arg, original);
969 assert(pos != original.end());
970 result.AppendArgument(pos->ref, pos->quote);
975 static size_t FindArgumentIndexForOption(const Args &args,
976 const Option &long_option) {
977 std::string short_opt = llvm::formatv("-{0}", char(long_option.val)).str();
978 std::string long_opt =
979 llvm::formatv("--{0}", long_option.definition->long_option);
980 for (const auto &entry : llvm::enumerate(args)) {
981 if (entry.value().ref.startswith(short_opt) ||
982 entry.value().ref.startswith(long_opt))
983 return entry.index();
989 llvm::Expected<Args> Options::ParseAlias(const Args &args,
990 OptionArgVector *option_arg_vector,
991 std::string &input_line) {
994 Option *long_options = GetLongOptions();
996 if (long_options == nullptr) {
997 return llvm::make_error<llvm::StringError>("Invalid long options",
998 llvm::inconvertibleErrorCode());
1001 for (i = 0; long_options[i].definition != nullptr; ++i) {
1002 if (long_options[i].flag == nullptr) {
1003 sstr << (char)long_options[i].val;
1004 switch (long_options[i].definition->option_has_arg) {
1006 case OptionParser::eNoArgument:
1008 case OptionParser::eRequiredArgument:
1011 case OptionParser::eOptionalArgument:
1018 Args args_copy = args;
1019 std::vector<char *> argv = GetArgvForParsing(args);
1021 std::unique_lock<std::mutex> lock;
1022 OptionParser::Prepare(lock);
1025 int long_options_index = -1;
1026 val = OptionParser::Parse(argv.size(), &*argv.begin(), sstr.GetString(),
1027 long_options, &long_options_index);
1033 return llvm::make_error<llvm::StringError>(
1034 "Unknown or ambiguous option", llvm::inconvertibleErrorCode());
1042 // Look up the long option index
1043 if (long_options_index == -1) {
1044 for (int j = 0; long_options[j].definition || long_options[j].flag ||
1045 long_options[j].val;
1047 if (long_options[j].val == val) {
1048 long_options_index = j;
1054 // See if the option takes an argument, and see if one was supplied.
1055 if (long_options_index == -1) {
1056 return llvm::make_error<llvm::StringError>(
1057 llvm::formatv("Invalid option with value '{0}'.", char(val)).str(),
1058 llvm::inconvertibleErrorCode());
1061 StreamString option_str;
1062 option_str.Printf("-%c", val);
1063 const OptionDefinition *def = long_options[long_options_index].definition;
1065 (def == nullptr) ? OptionParser::eNoArgument : def->option_has_arg;
1067 const char *option_arg = nullptr;
1069 case OptionParser::eRequiredArgument:
1070 if (OptionParser::GetOptionArgument() == nullptr) {
1071 return llvm::make_error<llvm::StringError>(
1072 llvm::formatv("Option '{0}' is missing argument specifier.",
1073 option_str.GetString())
1075 llvm::inconvertibleErrorCode());
1078 case OptionParser::eOptionalArgument:
1079 option_arg = OptionParser::GetOptionArgument();
1081 case OptionParser::eNoArgument:
1084 return llvm::make_error<llvm::StringError>(
1085 llvm::formatv("error with options table; invalid value in has_arg "
1086 "field for option '{0}'.",
1089 llvm::inconvertibleErrorCode());
1092 option_arg = "<no-argument>";
1093 option_arg_vector->emplace_back(option_str.GetString(), has_arg,
1096 // Find option in the argument list; also see if it was supposed to take an
1097 // argument and if one was supplied. Remove option (and argument, if
1098 // given) from the argument list. Also remove them from the
1099 // raw_input_string, if one was passed in.
1101 FindArgumentIndexForOption(args_copy, long_options[long_options_index]);
1102 if (idx == size_t(-1))
1105 if (!input_line.empty()) {
1106 auto tmp_arg = args_copy[idx].ref;
1107 size_t pos = input_line.find(tmp_arg);
1108 if (pos != std::string::npos)
1109 input_line.erase(pos, tmp_arg.size());
1111 args_copy.DeleteArgumentAtIndex(idx);
1112 if ((long_options[long_options_index].definition->option_has_arg !=
1113 OptionParser::eNoArgument) &&
1114 (OptionParser::GetOptionArgument() != nullptr) &&
1115 (idx < args_copy.GetArgumentCount()) &&
1116 (args_copy[idx].ref == OptionParser::GetOptionArgument())) {
1117 if (input_line.size() > 0) {
1118 auto tmp_arg = args_copy[idx].ref;
1119 size_t pos = input_line.find(tmp_arg);
1120 if (pos != std::string::npos)
1121 input_line.erase(pos, tmp_arg.size());
1123 args_copy.DeleteArgumentAtIndex(idx);
1127 return std::move(args_copy);
1130 OptionElementVector Options::ParseForCompletion(const Args &args,
1131 uint32_t cursor_index) {
1132 OptionElementVector option_element_vector;
1134 Option *long_options = GetLongOptions();
1135 option_element_vector.clear();
1137 if (long_options == nullptr)
1138 return option_element_vector;
1140 // Leading : tells getopt to return a : for a missing option argument AND to
1141 // suppress error messages.
1144 for (int i = 0; long_options[i].definition != nullptr; ++i) {
1145 if (long_options[i].flag == nullptr) {
1146 sstr << (char)long_options[i].val;
1147 switch (long_options[i].definition->option_has_arg) {
1149 case OptionParser::eNoArgument:
1151 case OptionParser::eRequiredArgument:
1154 case OptionParser::eOptionalArgument:
1161 std::unique_lock<std::mutex> lock;
1162 OptionParser::Prepare(lock);
1163 OptionParser::EnableError(false);
1166 auto opt_defs = GetDefinitions();
1168 std::vector<char *> dummy_vec = GetArgvForParsing(args);
1170 // I stick an element on the end of the input, because if the last element
1171 // is option that requires an argument, getopt_long_only will freak out.
1172 dummy_vec.push_back(const_cast<char *>("<FAKE-VALUE>"));
1174 bool failed_once = false;
1175 uint32_t dash_dash_pos = -1;
1178 bool missing_argument = false;
1179 int long_options_index = -1;
1181 val = OptionParser::Parse(dummy_vec.size(), &dummy_vec[0], sstr.GetString(),
1182 long_options, &long_options_index);
1185 // When we're completing a "--" which is the last option on line,
1191 // If this is a bare "--" we mark it as such so we can complete it
1192 // successfully later. Handling the "--" is a little tricky, since that
1193 // may mean end of options or arguments, or the user might want to
1194 // complete options by long name. I make this work by checking whether
1195 // the cursor is in the "--" argument, and if so I assume we're
1196 // completing the long option, otherwise I let it pass to
1197 // OptionParser::Parse which will terminate the option parsing. Note, in
1198 // either case we continue parsing the line so we can figure out what
1199 // other options were passed. This will be useful when we come to
1200 // restricting completions based on what other options we've seen on the
1203 if (static_cast<size_t>(OptionParser::GetOptionIndex()) <
1205 (strcmp(dummy_vec[OptionParser::GetOptionIndex() - 1], "--") == 0)) {
1206 dash_dash_pos = FindOriginalIndex(
1207 dummy_vec[OptionParser::GetOptionIndex() - 1], args);
1208 if (dash_dash_pos == cursor_index) {
1209 option_element_vector.push_back(
1210 OptionArgElement(OptionArgElement::eBareDoubleDash, dash_dash_pos,
1211 OptionArgElement::eBareDoubleDash));
1217 } else if (val == '?') {
1218 option_element_vector.push_back(OptionArgElement(
1219 OptionArgElement::eUnrecognizedArg,
1220 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1222 OptionArgElement::eUnrecognizedArg));
1224 } else if (val == 0) {
1226 } else if (val == ':') {
1227 // This is a missing argument.
1228 val = OptionParser::GetOptionErrorCause();
1229 missing_argument = true;
1234 // Look up the long option index
1235 if (long_options_index == -1) {
1236 for (int j = 0; long_options[j].definition || long_options[j].flag ||
1237 long_options[j].val;
1239 if (long_options[j].val == val) {
1240 long_options_index = j;
1246 // See if the option takes an argument, and see if one was supplied.
1247 if (long_options_index >= 0) {
1248 int opt_defs_index = -1;
1249 for (size_t i = 0; i < opt_defs.size(); i++) {
1250 if (opt_defs[i].short_option != val)
1256 const OptionDefinition *def = long_options[long_options_index].definition;
1258 (def == nullptr) ? OptionParser::eNoArgument : def->option_has_arg;
1260 case OptionParser::eNoArgument:
1261 option_element_vector.push_back(OptionArgElement(
1263 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1267 case OptionParser::eRequiredArgument:
1268 if (OptionParser::GetOptionArgument() != nullptr) {
1270 if (missing_argument)
1273 arg_index = OptionParser::GetOptionIndex() - 2;
1275 option_element_vector.push_back(OptionArgElement(
1277 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 2],
1281 option_element_vector.push_back(OptionArgElement(
1283 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1288 case OptionParser::eOptionalArgument:
1289 if (OptionParser::GetOptionArgument() != nullptr) {
1290 option_element_vector.push_back(OptionArgElement(
1292 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 2],
1294 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1297 option_element_vector.push_back(OptionArgElement(
1299 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 2],
1301 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1306 // The options table is messed up. Here we'll just continue
1307 option_element_vector.push_back(OptionArgElement(
1308 OptionArgElement::eUnrecognizedArg,
1309 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1311 OptionArgElement::eUnrecognizedArg));
1315 option_element_vector.push_back(OptionArgElement(
1316 OptionArgElement::eUnrecognizedArg,
1317 FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1319 OptionArgElement::eUnrecognizedArg));
1323 // Finally we have to handle the case where the cursor index points at a
1324 // single "-". We want to mark that in the option_element_vector, but only
1325 // if it is not after the "--". But it turns out that OptionParser::Parse
1326 // just ignores an isolated "-". So we have to look it up by hand here. We
1327 // only care if it is AT the cursor position. Note, a single quoted dash is
1328 // not the same as a single dash...
1330 const Args::ArgEntry &cursor = args[cursor_index];
1331 if ((static_cast<int32_t>(dash_dash_pos) == -1 ||
1332 cursor_index < dash_dash_pos) &&
1333 !cursor.IsQuoted() && cursor.ref == "-") {
1334 option_element_vector.push_back(
1335 OptionArgElement(OptionArgElement::eBareDash, cursor_index,
1336 OptionArgElement::eBareDash));
1338 return option_element_vector;
1341 llvm::Expected<Args> Options::Parse(const Args &args,
1342 ExecutionContext *execution_context,
1343 lldb::PlatformSP platform_sp,
1344 bool require_validation) {
1347 Option *long_options = GetLongOptions();
1348 if (long_options == nullptr) {
1349 return llvm::make_error<llvm::StringError>("Invalid long options.",
1350 llvm::inconvertibleErrorCode());
1353 for (int i = 0; long_options[i].definition != nullptr; ++i) {
1354 if (long_options[i].flag == nullptr) {
1355 if (isprint8(long_options[i].val)) {
1356 sstr << (char)long_options[i].val;
1357 switch (long_options[i].definition->option_has_arg) {
1359 case OptionParser::eNoArgument:
1361 case OptionParser::eRequiredArgument:
1364 case OptionParser::eOptionalArgument:
1371 std::vector<char *> argv = GetArgvForParsing(args);
1372 std::unique_lock<std::mutex> lock;
1373 OptionParser::Prepare(lock);
1376 int long_options_index = -1;
1377 val = OptionParser::Parse(argv.size(), &*argv.begin(), sstr.GetString(),
1378 long_options, &long_options_index);
1382 // Did we get an error?
1384 error.SetErrorStringWithFormat("unknown or ambiguous option");
1387 // The option auto-set itself
1393 // Lookup the long option index
1394 if (long_options_index == -1) {
1395 for (int i = 0; long_options[i].definition || long_options[i].flag ||
1396 long_options[i].val;
1398 if (long_options[i].val == val) {
1399 long_options_index = i;
1404 // Call the callback with the option
1405 if (long_options_index >= 0 &&
1406 long_options[long_options_index].definition) {
1407 const OptionDefinition *def = long_options[long_options_index].definition;
1410 // User did not pass in an explicit platform. Try to grab from the
1411 // execution context.
1412 TargetSP target_sp =
1413 execution_context ? execution_context->GetTargetSP() : TargetSP();
1414 platform_sp = target_sp ? target_sp->GetPlatform() : PlatformSP();
1416 OptionValidator *validator = def->validator;
1418 if (!platform_sp && require_validation) {
1419 // Caller requires validation but we cannot validate as we don't have
1420 // the mandatory platform against which to validate.
1421 return llvm::make_error<llvm::StringError>(
1422 "cannot validate options: no platform available",
1423 llvm::inconvertibleErrorCode());
1426 bool validation_failed = false;
1428 // Ensure we have an execution context, empty or not.
1429 ExecutionContext dummy_context;
1430 ExecutionContext *exe_ctx_p =
1431 execution_context ? execution_context : &dummy_context;
1432 if (validator && !validator->IsValid(*platform_sp, *exe_ctx_p)) {
1433 validation_failed = true;
1434 error.SetErrorStringWithFormat("Option \"%s\" invalid. %s",
1436 def->validator->LongConditionString());
1440 // As long as validation didn't fail, we set the option value.
1441 if (!validation_failed)
1443 SetOptionValue(long_options_index,
1444 (def->option_has_arg == OptionParser::eNoArgument)
1446 : OptionParser::GetOptionArgument(),
1449 error.SetErrorStringWithFormat("invalid option with value '%i'", val);
1452 return error.ToError();
1455 argv.erase(argv.begin(), argv.begin() + OptionParser::GetOptionIndex());
1456 return ReconstituteArgsAfterParsing(argv, args);