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