LLDB  mainline
Options.cpp
Go to the documentation of this file.
1 //===-- Options.cpp ---------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 
11 #include <algorithm>
12 #include <bitset>
13 #include <map>
14 #include <set>
15 
16 #include "lldb/Host/OptionParser.h"
21 #include "lldb/Target/Target.h"
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
27 // Options
28 Options::Options() : m_getopt_table() { BuildValidOptionSets(); }
29 
31 
33  m_seen_options.clear();
34  // Let the subclass reset its option values
35  OptionParsingStarting(execution_context);
36 }
37 
38 Status
40  return OptionParsingFinished(execution_context);
41 }
42 
43 void Options::OptionSeen(int option_idx) { m_seen_options.insert(option_idx); }
44 
45 // Returns true is set_a is a subset of set_b; Otherwise returns false.
46 
47 bool Options::IsASubset(const OptionSet &set_a, const OptionSet &set_b) {
48  bool is_a_subset = true;
49  OptionSet::const_iterator pos_a;
50  OptionSet::const_iterator pos_b;
51 
52  // set_a is a subset of set_b if every member of set_a is also a member of
53  // set_b
54 
55  for (pos_a = set_a.begin(); pos_a != set_a.end() && is_a_subset; ++pos_a) {
56  pos_b = set_b.find(*pos_a);
57  if (pos_b == set_b.end())
58  is_a_subset = false;
59  }
60 
61  return is_a_subset;
62 }
63 
64 // Returns the set difference set_a - set_b, i.e. { x | ElementOf (x, set_a) &&
65 // !ElementOf (x, set_b) }
66 
67 size_t Options::OptionsSetDiff(const OptionSet &set_a, const OptionSet &set_b,
68  OptionSet &diffs) {
69  size_t num_diffs = 0;
70  OptionSet::const_iterator pos_a;
71  OptionSet::const_iterator pos_b;
72 
73  for (pos_a = set_a.begin(); pos_a != set_a.end(); ++pos_a) {
74  pos_b = set_b.find(*pos_a);
75  if (pos_b == set_b.end()) {
76  ++num_diffs;
77  diffs.insert(*pos_a);
78  }
79  }
80 
81  return num_diffs;
82 }
83 
84 // Returns the union of set_a and set_b. Does not put duplicate members into
85 // the union.
86 
87 void Options::OptionsSetUnion(const OptionSet &set_a, const OptionSet &set_b,
88  OptionSet &union_set) {
89  OptionSet::const_iterator pos;
90  OptionSet::iterator pos_union;
91 
92  // Put all the elements of set_a into the union.
93 
94  for (pos = set_a.begin(); pos != set_a.end(); ++pos)
95  union_set.insert(*pos);
96 
97  // Put all the elements of set_b that are not already there into the union.
98  for (pos = set_b.begin(); pos != set_b.end(); ++pos) {
99  pos_union = union_set.find(*pos);
100  if (pos_union == union_set.end())
101  union_set.insert(*pos);
102  }
103 }
104 
106  bool options_are_valid = false;
107 
108  int num_levels = GetRequiredOptions().size();
109  if (num_levels) {
110  for (int i = 0; i < num_levels && !options_are_valid; ++i) {
111  // This is the correct set of options if: 1). m_seen_options contains
112  // all of m_required_options[i] (i.e. all the required options at this
113  // level are a subset of m_seen_options); AND 2). { m_seen_options -
114  // m_required_options[i] is a subset of m_options_options[i] (i.e. all
115  // the rest of m_seen_options are in the set of optional options at this
116  // level.
117 
118  // Check to see if all of m_required_options[i] are a subset of
119  // m_seen_options
121  // Construct the set difference: remaining_options = {m_seen_options} -
122  // {m_required_options[i]}
123  OptionSet remaining_options;
125  remaining_options);
126  // Check to see if remaining_options is a subset of
127  // m_optional_options[i]
128  if (IsASubset(remaining_options, GetOptionalOptions()[i]))
129  options_are_valid = true;
130  }
131  }
132  } else {
133  options_are_valid = true;
134  }
135 
136  if (options_are_valid) {
138  } else {
139  result.AppendError("invalid combination of options for the given command");
141  }
142 
143  return options_are_valid;
144 }
145 
146 // This is called in the Options constructor, though we could call it lazily if
147 // that ends up being a performance problem.
148 
150  // Check to see if we already did this.
151  if (m_required_options.size() != 0)
152  return;
153 
154  // Check to see if there are any options.
155  int num_options = NumCommandOptions();
156  if (num_options == 0)
157  return;
158 
159  auto opt_defs = GetDefinitions();
160  m_required_options.resize(1);
161  m_optional_options.resize(1);
162 
163  // First count the number of option sets we've got. Ignore
164  // LLDB_ALL_OPTION_SETS...
165 
166  uint32_t num_option_sets = 0;
167 
168  for (const auto &def : opt_defs) {
169  uint32_t this_usage_mask = def.usage_mask;
170  if (this_usage_mask == LLDB_OPT_SET_ALL) {
171  if (num_option_sets == 0)
172  num_option_sets = 1;
173  } else {
174  for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++) {
175  if (this_usage_mask & (1 << j)) {
176  if (num_option_sets <= j)
177  num_option_sets = j + 1;
178  }
179  }
180  }
181  }
182 
183  if (num_option_sets > 0) {
184  m_required_options.resize(num_option_sets);
185  m_optional_options.resize(num_option_sets);
186 
187  for (const auto &def : opt_defs) {
188  for (uint32_t j = 0; j < num_option_sets; j++) {
189  if (def.usage_mask & 1 << j) {
190  if (def.required)
191  m_required_options[j].insert(def.short_option);
192  else
193  m_optional_options[j].insert(def.short_option);
194  }
195  }
196  }
197  }
198 }
199 
201 
203  // Check to see if this has already been done.
204  if (m_getopt_table.empty()) {
205  auto defs = GetDefinitions();
206  if (defs.empty())
207  return nullptr;
208 
209  std::map<int, uint32_t> option_seen;
210 
211  m_getopt_table.resize(defs.size() + 1);
212  for (size_t i = 0; i < defs.size(); ++i) {
213  const int short_opt = defs[i].short_option;
214 
215  m_getopt_table[i].definition = &defs[i];
216  m_getopt_table[i].flag = nullptr;
217  m_getopt_table[i].val = short_opt;
218 
219  if (option_seen.find(short_opt) == option_seen.end()) {
220  option_seen[short_opt] = i;
221  } else if (short_opt) {
222  m_getopt_table[i].val = 0;
223  std::map<int, uint32_t>::const_iterator pos =
224  option_seen.find(short_opt);
225  StreamString strm;
226  if (isprint8(short_opt))
228  "option[%u] --%s has a short option -%c that "
229  "conflicts with option[%u] --%s, short option won't "
230  "be used for --%s\n",
231  (int)i, defs[i].long_option, short_opt, pos->second,
232  m_getopt_table[pos->second].definition->long_option,
233  defs[i].long_option);
234  else
236  "option[%u] --%s has a short option 0x%x that "
237  "conflicts with option[%u] --%s, short option won't "
238  "be used for --%s\n",
239  (int)i, defs[i].long_option, short_opt, pos->second,
240  m_getopt_table[pos->second].definition->long_option,
241  defs[i].long_option);
242  }
243  }
244 
245  // getopt_long_only requires a NULL final entry in the table:
246 
247  m_getopt_table.back().definition = nullptr;
248  m_getopt_table.back().flag = nullptr;
249  m_getopt_table.back().val = 0;
250  }
251 
252  if (m_getopt_table.empty())
253  return nullptr;
254 
255  return &m_getopt_table.front();
256 }
257 
258 // This function takes INDENT, which tells how many spaces to output at the
259 // front of each line; SPACES, which is a string containing 80 spaces; and
260 // TEXT, which is the text that is to be output. It outputs the text, on
261 // multiple lines if necessary, to RESULT, with INDENT spaces at the front of
262 // each line. It breaks lines on spaces, tabs or newlines, shortening the line
263 // if necessary to not break in the middle of a word. It assumes that each
264 // output line should contain a maximum of OUTPUT_MAX_COLUMNS characters.
265 
267  const OptionDefinition &option_def,
268  uint32_t output_max_columns) {
269  std::string actual_text;
270  if (option_def.validator) {
271  const char *condition = option_def.validator->ShortConditionString();
272  if (condition) {
273  actual_text = "[";
274  actual_text.append(condition);
275  actual_text.append("] ");
276  }
277  }
278  actual_text.append(option_def.usage_text);
279 
280  // Will it all fit on one line?
281 
282  if (static_cast<uint32_t>(actual_text.length() + strm.GetIndentLevel()) <
283  output_max_columns) {
284  // Output it as a single line.
285  strm.Indent(actual_text.c_str());
286  strm.EOL();
287  } else {
288  // We need to break it up into multiple lines.
289 
290  int text_width = output_max_columns - strm.GetIndentLevel() - 1;
291  int start = 0;
292  int end = start;
293  int final_end = actual_text.length();
294  int sub_len;
295 
296  while (end < final_end) {
297  // Don't start the 'text' on a space, since we're already outputting the
298  // indentation.
299  while ((start < final_end) && (actual_text[start] == ' '))
300  start++;
301 
302  end = start + text_width;
303  if (end > final_end)
304  end = final_end;
305  else {
306  // If we're not at the end of the text, make sure we break the line on
307  // white space.
308  while (end > start && actual_text[end] != ' ' &&
309  actual_text[end] != '\t' && actual_text[end] != '\n')
310  end--;
311  }
312 
313  sub_len = end - start;
314  if (start != 0)
315  strm.EOL();
316  strm.Indent();
317  assert(start < final_end);
318  assert(start + sub_len <= final_end);
319  strm.Write(actual_text.c_str() + start, sub_len);
320  start = end + 1;
321  }
322  strm.EOL();
323  }
324 }
325 
326 bool Options::SupportsLongOption(const char *long_option) {
327  if (!long_option || !long_option[0])
328  return false;
329 
330  auto opt_defs = GetDefinitions();
331  if (opt_defs.empty())
332  return false;
333 
334  const char *long_option_name = long_option;
335  if (long_option[0] == '-' && long_option[1] == '-')
336  long_option_name += 2;
337 
338  for (auto &def : opt_defs) {
339  if (!def.long_option)
340  continue;
341 
342  if (strcmp(def.long_option, long_option_name) == 0)
343  return true;
344  }
345 
346  return false;
347 }
348 
353 };
354 
355 static bool PrintOption(const OptionDefinition &opt_def,
356  OptionDisplayType display_type, const char *header,
357  const char *footer, bool show_optional, Stream &strm) {
358  const bool has_short_option = isprint8(opt_def.short_option) != 0;
359 
360  if (display_type == eDisplayShortOption && !has_short_option)
361  return false;
362 
363  if (header && header[0])
364  strm.PutCString(header);
365 
366  if (show_optional && !opt_def.required)
367  strm.PutChar('[');
368  const bool show_short_option =
369  has_short_option && display_type != eDisplayLongOption;
370  if (show_short_option)
371  strm.Printf("-%c", opt_def.short_option);
372  else
373  strm.Printf("--%s", opt_def.long_option);
374  switch (opt_def.option_has_arg) {
376  break;
378  strm.Printf(" <%s>", CommandObject::GetArgumentName(opt_def.argument_type));
379  break;
380 
382  strm.Printf("%s[<%s>]", show_short_option ? "" : "=",
383  CommandObject::GetArgumentName(opt_def.argument_type));
384  break;
385  }
386  if (show_optional && !opt_def.required)
387  strm.PutChar(']');
388  if (footer && footer[0])
389  strm.PutCString(footer);
390  return true;
391 }
392 
394  uint32_t screen_width) {
395  const bool only_print_args = cmd->IsDashDashCommand();
396 
397  auto opt_defs = GetDefinitions();
398  const uint32_t save_indent_level = strm.GetIndentLevel();
399  llvm::StringRef name;
400 
401  StreamString arguments_str;
402 
403  if (cmd) {
404  name = cmd->GetCommandName();
405  cmd->GetFormattedCommandArguments(arguments_str);
406  } else
407  name = "";
408 
409  strm.PutCString("\nCommand Options Usage:\n");
410 
411  strm.IndentMore(2);
412 
413  // First, show each usage level set of options, e.g. <cmd> [options-for-
414  // level-0]
415  // <cmd>
416  // [options-for-level-1]
417  // etc.
418 
419  const uint32_t num_options = NumCommandOptions();
420  if (num_options == 0)
421  return;
422 
423  uint32_t num_option_sets = GetRequiredOptions().size();
424 
425  uint32_t i;
426 
427  if (!only_print_args) {
428  for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
429  uint32_t opt_set_mask;
430 
431  opt_set_mask = 1 << opt_set;
432  if (opt_set > 0)
433  strm.Printf("\n");
434  strm.Indent(name);
435 
436  // Different option sets may require different args.
437  StreamString args_str;
438  if (cmd)
439  cmd->GetFormattedCommandArguments(args_str, opt_set_mask);
440 
441  // First go through and print all options that take no arguments as a
442  // single string. If a command has "-a" "-b" and "-c", this will show up
443  // as [-abc]
444 
445  std::set<int> options;
446  std::set<int>::const_iterator options_pos, options_end;
447  for (auto &def : opt_defs) {
448  if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
449  // Add current option to the end of out_stream.
450 
451  if (def.required && def.option_has_arg == OptionParser::eNoArgument) {
452  options.insert(def.short_option);
453  }
454  }
455  }
456 
457  if (!options.empty()) {
458  // We have some required options with no arguments
459  strm.PutCString(" -");
460  for (i = 0; i < 2; ++i)
461  for (options_pos = options.begin(), options_end = options.end();
462  options_pos != options_end; ++options_pos) {
463  if (i == 0 && ::islower(*options_pos))
464  continue;
465  if (i == 1 && ::isupper(*options_pos))
466  continue;
467  strm << (char)*options_pos;
468  }
469  }
470 
471  options.clear();
472  for (auto &def : opt_defs) {
473  if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
474  // Add current option to the end of out_stream.
475 
476  if (!def.required &&
477  def.option_has_arg == OptionParser::eNoArgument) {
478  options.insert(def.short_option);
479  }
480  }
481  }
482 
483  if (!options.empty()) {
484  // We have some required options with no arguments
485  strm.PutCString(" [-");
486  for (i = 0; i < 2; ++i)
487  for (options_pos = options.begin(), options_end = options.end();
488  options_pos != options_end; ++options_pos) {
489  if (i == 0 && ::islower(*options_pos))
490  continue;
491  if (i == 1 && ::isupper(*options_pos))
492  continue;
493  strm << (char)*options_pos;
494  }
495  strm.PutChar(']');
496  }
497 
498  // First go through and print the required options (list them up front).
499 
500  for (auto &def : opt_defs) {
501  if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
502  if (def.required && def.option_has_arg != OptionParser::eNoArgument)
503  PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
504  }
505  }
506 
507  // Now go through again, and this time only print the optional options.
508 
509  for (auto &def : opt_defs) {
510  if (def.usage_mask & opt_set_mask) {
511  // Add current option to the end of out_stream.
512 
513  if (!def.required && def.option_has_arg != OptionParser::eNoArgument)
514  PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
515  }
516  }
517 
518  if (args_str.GetSize() > 0) {
519  if (cmd->WantsRawCommandString() && !only_print_args)
520  strm.Printf(" --");
521 
522  strm << " " << args_str.GetString();
523  if (only_print_args)
524  break;
525  }
526  }
527  }
528 
529  if (cmd && (only_print_args || cmd->WantsRawCommandString()) &&
530  arguments_str.GetSize() > 0) {
531  if (!only_print_args)
532  strm.PutChar('\n');
533  strm.Indent(name);
534  strm << " " << arguments_str.GetString();
535  }
536 
537  strm.Printf("\n\n");
538 
539  if (!only_print_args) {
540  // Now print out all the detailed information about the various options:
541  // long form, short form and help text:
542  // -short <argument> ( --long_name <argument> )
543  // help text
544 
545  // This variable is used to keep track of which options' info we've printed
546  // out, because some options can be in more than one usage level, but we
547  // only want to print the long form of its information once.
548 
549  std::multimap<int, uint32_t> options_seen;
550  strm.IndentMore(5);
551 
552  // Put the unique command options in a vector & sort it, so we can output
553  // them alphabetically (by short_option) when writing out detailed help for
554  // each option.
555 
556  i = 0;
557  for (auto &def : opt_defs)
558  options_seen.insert(std::make_pair(def.short_option, i++));
559 
560  // Go through the unique'd and alphabetically sorted vector of options,
561  // find the table entry for each option and write out the detailed help
562  // information for that option.
563 
564  bool first_option_printed = false;
565 
566  for (auto pos : options_seen) {
567  i = pos.second;
568  // Print out the help information for this option.
569 
570  // Put a newline separation between arguments
571  if (first_option_printed)
572  strm.EOL();
573  else
574  first_option_printed = true;
575 
576  CommandArgumentType arg_type = opt_defs[i].argument_type;
577 
578  StreamString arg_name_str;
579  arg_name_str.Printf("<%s>", CommandObject::GetArgumentName(arg_type));
580 
581  strm.Indent();
582  if (opt_defs[i].short_option && isprint8(opt_defs[i].short_option)) {
583  PrintOption(opt_defs[i], eDisplayShortOption, nullptr, nullptr, false,
584  strm);
585  PrintOption(opt_defs[i], eDisplayLongOption, " ( ", " )", false, strm);
586  } else {
587  // Short option is not printable, just print long option
588  PrintOption(opt_defs[i], eDisplayLongOption, nullptr, nullptr, false,
589  strm);
590  }
591  strm.EOL();
592 
593  strm.IndentMore(5);
594 
595  if (opt_defs[i].usage_text)
596  OutputFormattedUsageText(strm, opt_defs[i], screen_width);
597  if (!opt_defs[i].enum_values.empty()) {
598  strm.Indent();
599  strm.Printf("Values: ");
600  bool is_first = true;
601  for (const auto &enum_value : opt_defs[i].enum_values) {
602  if (is_first) {
603  strm.Printf("%s", enum_value.string_value);
604  is_first = false;
605  }
606  else
607  strm.Printf(" | %s", enum_value.string_value);
608  }
609  strm.EOL();
610  }
611  strm.IndentLess(5);
612  }
613  }
614 
615  // Restore the indent level
616  strm.SetIndentLevel(save_indent_level);
617 }
618 
619 // This function is called when we have been given a potentially incomplete set
620 // of options, such as when an alias has been defined (more options might be
621 // added at at the time the alias is invoked). We need to verify that the
622 // options in the set m_seen_options are all part of a set that may be used
623 // together, but m_seen_options may be missing some of the "required" options.
624 
626  bool options_are_valid = false;
627 
628  int num_levels = GetRequiredOptions().size();
629  if (num_levels) {
630  for (int i = 0; i < num_levels && !options_are_valid; ++i) {
631  // In this case we are treating all options as optional rather than
632  // required. Therefore a set of options is correct if m_seen_options is a
633  // subset of the union of m_required_options and m_optional_options.
634  OptionSet union_set;
636  union_set);
637  if (IsASubset(m_seen_options, union_set))
638  options_are_valid = true;
639  }
640  }
641 
642  return options_are_valid;
643 }
644 
646  OptionElementVector &opt_element_vector,
647  CommandInterpreter &interpreter) {
648  request.SetWordComplete(true);
649 
650  // For now we just scan the completions to see if the cursor position is in
651  // an option or its argument. Otherwise we'll call HandleArgumentCompletion.
652  // In the future we can use completion to validate options as well if we
653  // want.
654 
655  auto opt_defs = GetDefinitions();
656 
657  std::string cur_opt_std_str = request.GetCursorArgumentPrefix().str();
658  const char *cur_opt_str = cur_opt_std_str.c_str();
659 
660  for (size_t i = 0; i < opt_element_vector.size(); i++) {
661  int opt_pos = opt_element_vector[i].opt_pos;
662  int opt_arg_pos = opt_element_vector[i].opt_arg_pos;
663  int opt_defs_index = opt_element_vector[i].opt_defs_index;
664  if (opt_pos == request.GetCursorIndex()) {
665  // We're completing the option itself.
666 
667  if (opt_defs_index == OptionArgElement::eBareDash) {
668  // We're completing a bare dash. That means all options are open.
669  // FIXME: We should scan the other options provided and only complete
670  // options
671  // within the option group they belong to.
672  char opt_str[3] = {'-', 'a', '\0'};
673 
674  for (auto &def : opt_defs) {
675  if (!def.short_option)
676  continue;
677  opt_str[1] = def.short_option;
678  request.AddCompletion(opt_str);
679  }
680 
681  return true;
682  } else if (opt_defs_index == OptionArgElement::eBareDoubleDash) {
683  std::string full_name("--");
684  for (auto &def : opt_defs) {
685  if (!def.short_option)
686  continue;
687 
688  full_name.erase(full_name.begin() + 2, full_name.end());
689  full_name.append(def.long_option);
690  request.AddCompletion(full_name.c_str());
691  }
692  return true;
693  } else if (opt_defs_index != OptionArgElement::eUnrecognizedArg) {
694  // We recognized it, if it an incomplete long option, complete it
695  // anyway (getopt_long_only is happy with shortest unique string, but
696  // it's still a nice thing to do.) Otherwise return The string so the
697  // upper level code will know this is a full match and add the " ".
698  if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
699  cur_opt_str[1] == '-' &&
700  strcmp(opt_defs[opt_defs_index].long_option, cur_opt_str) != 0) {
701  std::string full_name("--");
702  full_name.append(opt_defs[opt_defs_index].long_option);
703  request.AddCompletion(full_name.c_str());
704  return true;
705  } else {
706  request.AddCompletion(request.GetCursorArgument());
707  return true;
708  }
709  } else {
710  // FIXME - not handling wrong options yet:
711  // Check to see if they are writing a long option & complete it.
712  // I think we will only get in here if the long option table has two
713  // elements
714  // that are not unique up to this point. getopt_long_only does
715  // shortest unique match for long options already.
716 
717  if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
718  cur_opt_str[1] == '-') {
719  for (auto &def : opt_defs) {
720  if (!def.long_option)
721  continue;
722 
723  if (strstr(def.long_option, cur_opt_str + 2) == def.long_option) {
724  std::string full_name("--");
725  full_name.append(def.long_option);
726  request.AddCompletion(full_name.c_str());
727  }
728  }
729  }
730  return true;
731  }
732 
733  } else if (opt_arg_pos == request.GetCursorIndex()) {
734  // Okay the cursor is on the completion of an argument. See if it has a
735  // completion, otherwise return no matches.
736 
737  CompletionRequest subrequest = request;
738  subrequest.SetCursorCharPosition(subrequest.GetCursorArgument().size());
739  if (opt_defs_index != -1) {
740  HandleOptionArgumentCompletion(subrequest, opt_element_vector, i,
741  interpreter);
742  request.SetWordComplete(subrequest.GetWordComplete());
743  return true;
744  } else {
745  // No completion callback means no completions...
746  return true;
747  }
748 
749  } else {
750  // Not the last element, keep going.
751  continue;
752  }
753  }
754  return false;
755 }
756 
758  CompletionRequest &request, OptionElementVector &opt_element_vector,
759  int opt_element_index, CommandInterpreter &interpreter) {
760  auto opt_defs = GetDefinitions();
761  std::unique_ptr<SearchFilter> filter_up;
762 
763  int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
764  int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
765 
766  // See if this is an enumeration type option, and if so complete it here:
767 
768  const auto &enum_values = opt_defs[opt_defs_index].enum_values;
769  if (!enum_values.empty()) {
770  bool return_value = false;
771  std::string match_string(
772  request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos),
773  request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos) +
774  request.GetCursorCharPosition());
775 
776  for (const auto &enum_value : enum_values) {
777  if (strstr(enum_value.string_value, match_string.c_str()) ==
778  enum_value.string_value) {
779  request.AddCompletion(enum_value.string_value);
780  return_value = true;
781  }
782  }
783  return return_value;
784  }
785 
786  // If this is a source file or symbol type completion, and there is a -shlib
787  // option somewhere in the supplied arguments, then make a search filter for
788  // that shared library.
789  // FIXME: Do we want to also have an "OptionType" so we don't have to match
790  // string names?
791 
792  uint32_t completion_mask = opt_defs[opt_defs_index].completion_type;
793 
794  if (completion_mask == 0) {
795  lldb::CommandArgumentType option_arg_type =
796  opt_defs[opt_defs_index].argument_type;
797  if (option_arg_type != eArgTypeNone) {
798  const CommandObject::ArgumentTableEntry *arg_entry =
800  opt_defs[opt_defs_index].argument_type);
801  if (arg_entry)
802  completion_mask = arg_entry->completion_type;
803  }
804  }
805 
806  if (completion_mask & CommandCompletions::eSourceFileCompletion ||
807  completion_mask & CommandCompletions::eSymbolCompletion) {
808  for (size_t i = 0; i < opt_element_vector.size(); i++) {
809  int cur_defs_index = opt_element_vector[i].opt_defs_index;
810 
811  // trying to use <0 indices will definitely cause problems
812  if (cur_defs_index == OptionArgElement::eUnrecognizedArg ||
813  cur_defs_index == OptionArgElement::eBareDash ||
814  cur_defs_index == OptionArgElement::eBareDoubleDash)
815  continue;
816 
817  int cur_arg_pos = opt_element_vector[i].opt_arg_pos;
818  const char *cur_opt_name = opt_defs[cur_defs_index].long_option;
819 
820  // If this is the "shlib" option and there was an argument provided,
821  // restrict it to that shared library.
822  if (cur_opt_name && strcmp(cur_opt_name, "shlib") == 0 &&
823  cur_arg_pos != -1) {
824  const char *module_name =
825  request.GetParsedLine().GetArgumentAtIndex(cur_arg_pos);
826  if (module_name) {
827  FileSpec module_spec(module_name);
828  lldb::TargetSP target_sp =
829  interpreter.GetDebugger().GetSelectedTarget();
830  // Search filters require a target...
831  if (target_sp)
832  filter_up.reset(new SearchFilterByModule(target_sp, module_spec));
833  }
834  break;
835  }
836  }
837  }
838 
840  interpreter, completion_mask, request, filter_up.get());
841 }
842 
844  auto group_option_defs = group->GetDefinitions();
845  for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
846  m_option_infos.push_back(OptionInfo(group, i));
847  m_option_defs.push_back(group_option_defs[i]);
848  }
849 }
850 
852  for (uint32_t i = 0; i < m_option_defs.size(); i++) {
853  OptionDefinition opt_def = m_option_defs[i];
854  if (opt_def.short_option == short_opt)
855  return m_option_infos[i].option_group;
856  }
857  return nullptr;
858 }
859 
861  uint32_t dst_mask) {
862  auto group_option_defs = group->GetDefinitions();
863  for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
864  if (group_option_defs[i].usage_mask & src_mask) {
865  m_option_infos.push_back(OptionInfo(group, i));
866  m_option_defs.push_back(group_option_defs[i]);
867  m_option_defs.back().usage_mask = dst_mask;
868  }
869  }
870 }
871 
873  m_did_finalize = true;
874 }
875 
877  llvm::StringRef option_value,
878  ExecutionContext *execution_context) {
879  // After calling OptionGroupOptions::Append(...), you must finalize the
880  // groups by calling OptionGroupOptions::Finlize()
881  assert(m_did_finalize);
882  Status error;
883  if (option_idx < m_option_infos.size()) {
884  error = m_option_infos[option_idx].option_group->SetOptionValue(
885  m_option_infos[option_idx].option_index, option_value,
886  execution_context);
887 
888  } else {
889  error.SetErrorString("invalid option index"); // Shouldn't happen...
890  }
891  return error;
892 }
893 
895  ExecutionContext *execution_context) {
896  std::set<OptionGroup *> group_set;
897  OptionInfos::iterator pos, end = m_option_infos.end();
898  for (pos = m_option_infos.begin(); pos != end; ++pos) {
899  OptionGroup *group = pos->option_group;
900  if (group_set.find(group) == group_set.end()) {
901  group->OptionParsingStarting(execution_context);
902  group_set.insert(group);
903  }
904  }
905 }
906 Status
908  std::set<OptionGroup *> group_set;
909  Status error;
910  OptionInfos::iterator pos, end = m_option_infos.end();
911  for (pos = m_option_infos.begin(); pos != end; ++pos) {
912  OptionGroup *group = pos->option_group;
913  if (group_set.find(group) == group_set.end()) {
914  error = group->OptionParsingFinished(execution_context);
915  group_set.insert(group);
916  if (error.Fail())
917  return error;
918  }
919  }
920  return error;
921 }
922 
923 // OptionParser permutes the arguments while processing them, so we create a
924 // temporary array holding to avoid modification of the input arguments. The
925 // options themselves are never modified, but the API expects a char * anyway,
926 // hence the const_cast.
927 static std::vector<char *> GetArgvForParsing(const Args &args) {
928  std::vector<char *> result;
929  // OptionParser always skips the first argument as it is based on getopt().
930  result.push_back(const_cast<char *>("<FAKE-ARG0>"));
931  for (const Args::ArgEntry &entry : args)
932  result.push_back(const_cast<char *>(entry.c_str()));
933  return result;
934 }
935 
936 // Given a permuted argument, find it's position in the original Args vector.
937 static Args::const_iterator FindOriginalIter(const char *arg,
938  const Args &original) {
939  return llvm::find_if(
940  original, [arg](const Args::ArgEntry &D) { return D.c_str() == arg; });
941 }
942 
943 // Given a permuted argument, find it's index in the original Args vector.
944 static size_t FindOriginalIndex(const char *arg, const Args &original) {
945  return std::distance(original.begin(), FindOriginalIter(arg, original));
946 }
947 
948 // Construct a new Args object, consisting of the entries from the original
949 // arguments, but in the permuted order.
950 static Args ReconstituteArgsAfterParsing(llvm::ArrayRef<char *> parsed,
951  const Args &original) {
952  Args result;
953  for (const char *arg : parsed) {
954  auto pos = FindOriginalIter(arg, original);
955  assert(pos != original.end());
956  result.AppendArgument(pos->ref, pos->quote);
957  }
958  return result;
959 }
960 
961 static size_t FindArgumentIndexForOption(const Args &args,
962  const Option &long_option) {
963  std::string short_opt = llvm::formatv("-{0}", char(long_option.val)).str();
964  std::string long_opt =
965  llvm::formatv("--{0}", long_option.definition->long_option);
966  for (const auto &entry : llvm::enumerate(args)) {
967  if (entry.value().ref.startswith(short_opt) ||
968  entry.value().ref.startswith(long_opt))
969  return entry.index();
970  }
971 
972  return size_t(-1);
973 }
974 
975 llvm::Expected<Args> Options::ParseAlias(const Args &args,
976  OptionArgVector *option_arg_vector,
977  std::string &input_line) {
978  StreamString sstr;
979  int i;
980  Option *long_options = GetLongOptions();
981 
982  if (long_options == nullptr) {
983  return llvm::make_error<llvm::StringError>("Invalid long options",
984  llvm::inconvertibleErrorCode());
985  }
986 
987  for (i = 0; long_options[i].definition != nullptr; ++i) {
988  if (long_options[i].flag == nullptr) {
989  sstr << (char)long_options[i].val;
990  switch (long_options[i].definition->option_has_arg) {
991  default:
993  break;
995  sstr << ":";
996  break;
998  sstr << "::";
999  break;
1000  }
1001  }
1002  }
1003 
1004  Args args_copy = args;
1005  std::vector<char *> argv = GetArgvForParsing(args);
1006 
1007  std::unique_lock<std::mutex> lock;
1008  OptionParser::Prepare(lock);
1009  int val;
1010  while (1) {
1011  int long_options_index = -1;
1012  val = OptionParser::Parse(argv.size(), &*argv.begin(), sstr.GetString(),
1013  long_options, &long_options_index);
1014 
1015  if (val == -1)
1016  break;
1017 
1018  if (val == '?') {
1019  return llvm::make_error<llvm::StringError>(
1020  "Unknown or ambiguous option", llvm::inconvertibleErrorCode());
1021  }
1022 
1023  if (val == 0)
1024  continue;
1025 
1026  OptionSeen(val);
1027 
1028  // Look up the long option index
1029  if (long_options_index == -1) {
1030  for (int j = 0; long_options[j].definition || long_options[j].flag ||
1031  long_options[j].val;
1032  ++j) {
1033  if (long_options[j].val == val) {
1034  long_options_index = j;
1035  break;
1036  }
1037  }
1038  }
1039 
1040  // See if the option takes an argument, and see if one was supplied.
1041  if (long_options_index == -1) {
1042  return llvm::make_error<llvm::StringError>(
1043  llvm::formatv("Invalid option with value '{0}'.", char(val)).str(),
1044  llvm::inconvertibleErrorCode());
1045  }
1046 
1047  StreamString option_str;
1048  option_str.Printf("-%c", val);
1049  const OptionDefinition *def = long_options[long_options_index].definition;
1050  int has_arg =
1051  (def == nullptr) ? OptionParser::eNoArgument : def->option_has_arg;
1052 
1053  const char *option_arg = nullptr;
1054  switch (has_arg) {
1056  if (OptionParser::GetOptionArgument() == nullptr) {
1057  return llvm::make_error<llvm::StringError>(
1058  llvm::formatv("Option '{0}' is missing argument specifier.",
1059  option_str.GetString())
1060  .str(),
1061  llvm::inconvertibleErrorCode());
1062  }
1063  LLVM_FALLTHROUGH;
1065  option_arg = OptionParser::GetOptionArgument();
1066  LLVM_FALLTHROUGH;
1068  break;
1069  default:
1070  return llvm::make_error<llvm::StringError>(
1071  llvm::formatv("error with options table; invalid value in has_arg "
1072  "field for option '{0}'.",
1073  char(val))
1074  .str(),
1075  llvm::inconvertibleErrorCode());
1076  }
1077  if (!option_arg)
1078  option_arg = "<no-argument>";
1079  option_arg_vector->emplace_back(option_str.GetString(), has_arg,
1080  option_arg);
1081 
1082  // Find option in the argument list; also see if it was supposed to take an
1083  // argument and if one was supplied. Remove option (and argument, if
1084  // given) from the argument list. Also remove them from the
1085  // raw_input_string, if one was passed in.
1086  size_t idx =
1087  FindArgumentIndexForOption(args_copy, long_options[long_options_index]);
1088  if (idx == size_t(-1))
1089  continue;
1090 
1091  if (!input_line.empty()) {
1092  auto tmp_arg = args_copy[idx].ref;
1093  size_t pos = input_line.find(tmp_arg);
1094  if (pos != std::string::npos)
1095  input_line.erase(pos, tmp_arg.size());
1096  }
1097  args_copy.DeleteArgumentAtIndex(idx);
1098  if ((long_options[long_options_index].definition->option_has_arg !=
1100  (OptionParser::GetOptionArgument() != nullptr) &&
1101  (idx < args_copy.GetArgumentCount()) &&
1102  (args_copy[idx].ref == OptionParser::GetOptionArgument())) {
1103  if (input_line.size() > 0) {
1104  auto tmp_arg = args_copy[idx].ref;
1105  size_t pos = input_line.find(tmp_arg);
1106  if (pos != std::string::npos)
1107  input_line.erase(pos, tmp_arg.size());
1108  }
1109  args_copy.DeleteArgumentAtIndex(idx);
1110  }
1111  }
1112 
1113  return std::move(args_copy);
1114 }
1115 
1117  uint32_t cursor_index) {
1118  OptionElementVector option_element_vector;
1119  StreamString sstr;
1120  Option *long_options = GetLongOptions();
1121  option_element_vector.clear();
1122 
1123  if (long_options == nullptr)
1124  return option_element_vector;
1125 
1126  // Leading : tells getopt to return a : for a missing option argument AND to
1127  // suppress error messages.
1128 
1129  sstr << ":";
1130  for (int i = 0; long_options[i].definition != nullptr; ++i) {
1131  if (long_options[i].flag == nullptr) {
1132  sstr << (char)long_options[i].val;
1133  switch (long_options[i].definition->option_has_arg) {
1134  default:
1136  break;
1138  sstr << ":";
1139  break;
1141  sstr << "::";
1142  break;
1143  }
1144  }
1145  }
1146 
1147  std::unique_lock<std::mutex> lock;
1148  OptionParser::Prepare(lock);
1150 
1151  int val;
1152  auto opt_defs = GetDefinitions();
1153 
1154  std::vector<char *> dummy_vec = GetArgvForParsing(args);
1155 
1156  // I stick an element on the end of the input, because if the last element
1157  // is option that requires an argument, getopt_long_only will freak out.
1158  dummy_vec.push_back(const_cast<char *>("<FAKE-VALUE>"));
1159 
1160  bool failed_once = false;
1161  uint32_t dash_dash_pos = -1;
1162 
1163  while (1) {
1164  bool missing_argument = false;
1165  int long_options_index = -1;
1166 
1167  val = OptionParser::Parse(dummy_vec.size(), &dummy_vec[0], sstr.GetString(),
1168  long_options, &long_options_index);
1169 
1170  if (val == -1) {
1171  // When we're completing a "--" which is the last option on line,
1172  if (failed_once)
1173  break;
1174 
1175  failed_once = true;
1176 
1177  // If this is a bare "--" we mark it as such so we can complete it
1178  // successfully later. Handling the "--" is a little tricky, since that
1179  // may mean end of options or arguments, or the user might want to
1180  // complete options by long name. I make this work by checking whether
1181  // the cursor is in the "--" argument, and if so I assume we're
1182  // completing the long option, otherwise I let it pass to
1183  // OptionParser::Parse which will terminate the option parsing. Note, in
1184  // either case we continue parsing the line so we can figure out what
1185  // other options were passed. This will be useful when we come to
1186  // restricting completions based on what other options we've seen on the
1187  // line.
1188 
1189  if (static_cast<size_t>(OptionParser::GetOptionIndex()) <
1190  dummy_vec.size() &&
1191  (strcmp(dummy_vec[OptionParser::GetOptionIndex() - 1], "--") == 0)) {
1192  dash_dash_pos = FindOriginalIndex(
1193  dummy_vec[OptionParser::GetOptionIndex() - 1], args);
1194  if (dash_dash_pos == cursor_index) {
1195  option_element_vector.push_back(
1198  continue;
1199  } else
1200  break;
1201  } else
1202  break;
1203  } else if (val == '?') {
1204  option_element_vector.push_back(OptionArgElement(
1207  args),
1209  continue;
1210  } else if (val == 0) {
1211  continue;
1212  } else if (val == ':') {
1213  // This is a missing argument.
1215  missing_argument = true;
1216  }
1217 
1218  OptionSeen(val);
1219 
1220  // Look up the long option index
1221  if (long_options_index == -1) {
1222  for (int j = 0; long_options[j].definition || long_options[j].flag ||
1223  long_options[j].val;
1224  ++j) {
1225  if (long_options[j].val == val) {
1226  long_options_index = j;
1227  break;
1228  }
1229  }
1230  }
1231 
1232  // See if the option takes an argument, and see if one was supplied.
1233  if (long_options_index >= 0) {
1234  int opt_defs_index = -1;
1235  for (size_t i = 0; i < opt_defs.size(); i++) {
1236  if (opt_defs[i].short_option != val)
1237  continue;
1238  opt_defs_index = i;
1239  break;
1240  }
1241 
1242  const OptionDefinition *def = long_options[long_options_index].definition;
1243  int has_arg =
1244  (def == nullptr) ? OptionParser::eNoArgument : def->option_has_arg;
1245  switch (has_arg) {
1247  option_element_vector.push_back(OptionArgElement(
1248  opt_defs_index,
1250  args),
1251  0));
1252  break;
1254  if (OptionParser::GetOptionArgument() != nullptr) {
1255  int arg_index;
1256  if (missing_argument)
1257  arg_index = -1;
1258  else
1259  arg_index = OptionParser::GetOptionIndex() - 2;
1260 
1261  option_element_vector.push_back(OptionArgElement(
1262  opt_defs_index,
1264  args),
1265  arg_index));
1266  } else {
1267  option_element_vector.push_back(OptionArgElement(
1268  opt_defs_index,
1270  args),
1271  -1));
1272  }
1273  break;
1275  if (OptionParser::GetOptionArgument() != nullptr) {
1276  option_element_vector.push_back(OptionArgElement(
1277  opt_defs_index,
1279  args),
1281  args)));
1282  } else {
1283  option_element_vector.push_back(OptionArgElement(
1284  opt_defs_index,
1286  args),
1288  args)));
1289  }
1290  break;
1291  default:
1292  // The options table is messed up. Here we'll just continue
1293  option_element_vector.push_back(OptionArgElement(
1296  args),
1298  break;
1299  }
1300  } else {
1301  option_element_vector.push_back(OptionArgElement(
1304  args),
1306  }
1307  }
1308 
1309  // Finally we have to handle the case where the cursor index points at a
1310  // single "-". We want to mark that in the option_element_vector, but only
1311  // if it is not after the "--". But it turns out that OptionParser::Parse
1312  // just ignores an isolated "-". So we have to look it up by hand here. We
1313  // only care if it is AT the cursor position. Note, a single quoted dash is
1314  // not the same as a single dash...
1315 
1316  const Args::ArgEntry &cursor = args[cursor_index];
1317  if ((static_cast<int32_t>(dash_dash_pos) == -1 ||
1318  cursor_index < dash_dash_pos) &&
1319  !cursor.IsQuoted() && cursor.ref == "-") {
1320  option_element_vector.push_back(
1323  }
1324  return option_element_vector;
1325 }
1326 
1327 llvm::Expected<Args> Options::Parse(const Args &args,
1328  ExecutionContext *execution_context,
1329  lldb::PlatformSP platform_sp,
1330  bool require_validation) {
1331  StreamString sstr;
1332  Status error;
1333  Option *long_options = GetLongOptions();
1334  if (long_options == nullptr) {
1335  return llvm::make_error<llvm::StringError>("Invalid long options.",
1336  llvm::inconvertibleErrorCode());
1337  }
1338 
1339  for (int i = 0; long_options[i].definition != nullptr; ++i) {
1340  if (long_options[i].flag == nullptr) {
1341  if (isprint8(long_options[i].val)) {
1342  sstr << (char)long_options[i].val;
1343  switch (long_options[i].definition->option_has_arg) {
1344  default:
1346  break;
1348  sstr << ':';
1349  break;
1351  sstr << "::";
1352  break;
1353  }
1354  }
1355  }
1356  }
1357  std::vector<char *> argv = GetArgvForParsing(args);
1358  std::unique_lock<std::mutex> lock;
1359  OptionParser::Prepare(lock);
1360  int val;
1361  while (1) {
1362  int long_options_index = -1;
1363  val = OptionParser::Parse(argv.size(), &*argv.begin(), sstr.GetString(),
1364  long_options, &long_options_index);
1365  if (val == -1)
1366  break;
1367 
1368  // Did we get an error?
1369  if (val == '?') {
1370  error.SetErrorStringWithFormat("unknown or ambiguous option");
1371  break;
1372  }
1373  // The option auto-set itself
1374  if (val == 0)
1375  continue;
1376 
1377  OptionSeen(val);
1378 
1379  // Lookup the long option index
1380  if (long_options_index == -1) {
1381  for (int i = 0; long_options[i].definition || long_options[i].flag ||
1382  long_options[i].val;
1383  ++i) {
1384  if (long_options[i].val == val) {
1385  long_options_index = i;
1386  break;
1387  }
1388  }
1389  }
1390  // Call the callback with the option
1391  if (long_options_index >= 0 &&
1392  long_options[long_options_index].definition) {
1393  const OptionDefinition *def = long_options[long_options_index].definition;
1394 
1395  if (!platform_sp) {
1396  // User did not pass in an explicit platform. Try to grab from the
1397  // execution context.
1398  TargetSP target_sp =
1399  execution_context ? execution_context->GetTargetSP() : TargetSP();
1400  platform_sp = target_sp ? target_sp->GetPlatform() : PlatformSP();
1401  }
1402  OptionValidator *validator = def->validator;
1403 
1404  if (!platform_sp && require_validation) {
1405  // Caller requires validation but we cannot validate as we don't have
1406  // the mandatory platform against which to validate.
1407  return llvm::make_error<llvm::StringError>(
1408  "cannot validate options: no platform available",
1409  llvm::inconvertibleErrorCode());
1410  }
1411 
1412  bool validation_failed = false;
1413  if (platform_sp) {
1414  // Ensure we have an execution context, empty or not.
1415  ExecutionContext dummy_context;
1416  ExecutionContext *exe_ctx_p =
1417  execution_context ? execution_context : &dummy_context;
1418  if (validator && !validator->IsValid(*platform_sp, *exe_ctx_p)) {
1419  validation_failed = true;
1420  error.SetErrorStringWithFormat("Option \"%s\" invalid. %s",
1421  def->long_option,
1422  def->validator->LongConditionString());
1423  }
1424  }
1425 
1426  // As long as validation didn't fail, we set the option value.
1427  if (!validation_failed)
1428  error =
1429  SetOptionValue(long_options_index,
1430  (def->option_has_arg == OptionParser::eNoArgument)
1431  ? nullptr
1433  execution_context);
1434  } else {
1435  error.SetErrorStringWithFormat("invalid option with value '%i'", val);
1436  }
1437  }
1438 
1439  if (error.Fail())
1440  return error.ToError();
1441 
1442  argv.erase(argv.begin(), argv.begin() + OptionParser::GetOptionIndex());
1443  return ReconstituteArgsAfterParsing(argv, args);
1444 }
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
OptionSetVector & GetRequiredOptions()
Definition: Options.h:214
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
virtual bool IsDashDashCommand()
A command line argument class.
Definition: Args.h:32
llvm::Error ToError() const
Definition: Status.cpp:88
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
void DeleteArgumentAtIndex(size_t idx)
Deletes the argument value at index if idx is a valid argument index.
Definition: Args.cpp:355
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...
Definition: Options.cpp:645
OptionSet m_seen_options
Definition: Options.h:210
This is a SearchFilter that restricts the search to a given module.
Definition: SearchFilter.h:326
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
const_iterator end() const
Definition: Args.h:129
static int GetOptionErrorCause()
void OptionParsingStarting(ExecutionContext *execution_context) override
Definition: Options.cpp:894
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.cpp:254
static size_t FindArgumentIndexForOption(const Args &args, const Option &long_option)
Definition: Options.cpp:961
void BuildValidOptionSets()
Definition: Options.cpp:149
A file utility class.
Definition: FileSpec.h:55
llvm::Expected< Args > ParseAlias(const Args &args, OptionArgVector *option_arg_vector, std::string &input_line)
Definition: Options.cpp:975
OptionSetVector & GetOptionalOptions()
Definition: Options.h:219
static void SystemLog(SystemLogType type, const char *format,...) __attribute__((format(printf
void OutputFormattedUsageText(Stream &strm, const OptionDefinition &option_def, uint32_t output_max_columns)
Definition: Options.cpp:266
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
llvm::StringRef ref
Definition: Args.h:45
void SetIndentLevel(int level)
Set the current indentation level.
Definition: Stream.cpp:215
OptionSetVector m_required_options
Definition: Options.h:211
void AddCompletion(llvm::StringRef completion, llvm::StringRef description="")
Adds a possible completion string.
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
Definition: Stream.h:100
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx. ...
Definition: Args.cpp:256
static std::vector< char * > GetArgvForParsing(const Args &args)
Definition: Options.cpp:927
std::vector< Option > m_getopt_table
Definition: Options.h:209
uint32_t NumCommandOptions()
Definition: Options.cpp:200
static void EnableError(bool error)
"lldb/Utility/ArgCompletionRequest.h"
llvm::StringRef GetCursorArgument() const
std::vector< OptionArgElement > OptionElementVector
Definition: Options.h:41
size_t OptionsSetDiff(const OptionSet &set_a, const OptionSet &set_b, OptionSet &diffs)
Definition: Options.cpp:67
bool IsQuoted() const
Returns true if this argument was quoted in any way.
Definition: Args.h:50
llvm::StringRef GetCursorArgumentPrefix() const
virtual llvm::ArrayRef< OptionDefinition > GetDefinitions()
Definition: Options.h:102
int GetIndentLevel() const
Get the current indentation level.
Definition: Stream.cpp:212
std::vector< std::tuple< std::string, int, std::string > > OptionArgVector
Definition: Options.h:25
#define LLDB_MAX_NUM_OPTION_SETS
Option Set definitions.
Definition: lldb-defines.h:109
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:127
virtual bool 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...
Definition: Options.cpp:757
virtual Status OptionParsingFinished(ExecutionContext *execution_context)
Definition: Options.h:237
static const ArgumentTableEntry * FindArgumentDataByType(lldb::CommandArgumentType arg_type)
virtual bool WantsRawCommandString()=0
virtual Status OptionParsingFinished(ExecutionContext *execution_context)
Definition: Options.h:259
std::set< int > OptionSet
Definition: Options.h:206
Option * GetLongOptions()
Get the option definitions to use when parsing Args options.
Definition: Options.cpp:202
OptionDisplayType
Definition: Options.cpp:349
llvm::StringRef GetString() const
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
Status NotifyOptionParsingFinished(ExecutionContext *execution_context)
Definition: Options.cpp:39
const_iterator begin() const
Definition: Args.h:128
void IndentLess(int amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:221
virtual void OptionParsingStarting(ExecutionContext *execution_context)=0
const OptionGroup * GetGroupWithOption(char short_opt)
Definition: Options.cpp:851
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
void GetFormattedCommandArguments(Stream &str, uint32_t opt_set_mask=LLDB_OPT_SET_ALL)
void OptionsSetUnion(const OptionSet &set_a, const OptionSet &set_b, OptionSet &union_set)
Definition: Options.cpp:87
static void Prepare(std::unique_lock< std::mutex > &lock)
static char * GetOptionArgument()
llvm::Expected< Args > Parse(const Args &args, ExecutionContext *execution_context, lldb::PlatformSP platform_sp, bool require_validation)
Parse the provided arguments.
Definition: Options.cpp:1327
virtual Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context)=0
Set the value of an option.
size_t PutChar(char ch)
Definition: Stream.cpp:103
void void AppendError(llvm::StringRef in_string)
OptionSetVector m_optional_options
Definition: Options.h:212
const OptionDefinition * definition
Definition: OptionParser.h:25
static size_t FindOriginalIndex(const char *arg, const Args &original)
Definition: Options.cpp:944
bool VerifyPartialOptions(CommandReturnObject &result)
Definition: Options.cpp:625
const char * c_str() const
Definition: Args.h:47
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
Definition: SBAddress.h:15
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
Definition: Args.cpp:321
size_t Indent(const char *s=nullptr)
Indent the current line in the stream.
Definition: Stream.cpp:131
std::vector< ArgEntry >::const_iterator const_iterator
Definition: Args.h:126
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:110
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
Definition: Options.cpp:876
static bool isprint8(int ch)
Definition: Options.h:43
const Args & GetParsedLine() const
static Args ReconstituteArgsAfterParsing(llvm::ArrayRef< char *> parsed, const Args &original)
Definition: Options.cpp:950
static Args::const_iterator FindOriginalIter(const char *arg, const Args &original)
Definition: Options.cpp:937
virtual llvm::ArrayRef< OptionDefinition > GetDefinitions()=0
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
void IndentMore(int amount=2)
Increment the current indentation level.
Definition: Stream.cpp:218
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Definition: Options.cpp:843
bool IsASubset(const OptionSet &set_a, const OptionSet &set_b)
Definition: Options.cpp:47
virtual ~Options()
Definition: Options.cpp:30
static int Parse(int argc, char *const argv[], llvm::StringRef optstring, const Option *longopts, int *longindex)
bool SupportsLongOption(const char *long_option)
Definition: Options.cpp:326
lldb::TargetSP GetSelectedTarget()
Definition: Debugger.h:167
void OptionSeen(int short_option)
Definition: Options.cpp:43
Status OptionParsingFinished(ExecutionContext *execution_context) override
Definition: Options.cpp:907
OptionElementVector ParseForCompletion(const Args &args, uint32_t cursor_index)
Definition: Options.cpp:1116
llvm::StringRef GetCommandName() const
void SetStatus(lldb::ReturnStatus status)
bool VerifyOptions(CommandReturnObject &result)
Definition: Options.cpp:105
virtual void OptionParsingStarting(ExecutionContext *execution_context)=0
static bool PrintOption(const OptionDefinition &opt_def, OptionDisplayType display_type, const char *header, const char *footer, bool show_optional, Stream &strm)
Definition: Options.cpp:355
void GenerateOptionUsage(Stream &strm, CommandObject *cmd, uint32_t screen_width)
Definition: Options.cpp:393
void NotifyOptionParsingStarting(ExecutionContext *execution_context)
Definition: Options.cpp:32
CommandCompletions::CommonCompletionTypes completion_type
Definition: CommandObject.h:84
An error handling class.
Definition: Status.h:44
static const char * GetArgumentName(lldb::CommandArgumentType arg_type)