contrib/llvm-project/lldb/source/Interpreter/Options.cpp

   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
   9 #include "lldb/Interpreter/Options.h"
  10
  11 #include <algorithm>
  12 #include <bitset>
  13 #include <map>
  14 #include <set>
  15
  16 #include "lldb/Host/OptionParser.h"
  17 #include "lldb/Interpreter/CommandCompletions.h"
  18 #include "lldb/Interpreter/CommandInterpreter.h"
  19 #include "lldb/Interpreter/CommandObject.h"
  20 #include "lldb/Interpreter/CommandReturnObject.h"
  21 #include "lldb/Target/Target.h"
  22 #include "lldb/Utility/StreamString.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 // Options
  28 Options::Options() : m_getopt_table() { BuildValidOptionSets(); }
  29
  30 Options::~Options() {}
  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) {
 137     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 138   } else {
 139     result.AppendError("invalid combination of options for the given command");
 140     result.SetStatus(eReturnStatusFailed);
 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
 149 void Options::BuildValidOptionSets() {
 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
 200 uint32_t Options::NumCommandOptions() { return GetDefinitions().size(); }
 201
 202 Option *Options::GetLongOptions() {
 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))
 227           Host::SystemLog(Host::eSystemLogError,
 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
 235           Host::SystemLog(Host::eSystemLogError,
 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
 266 void Options::OutputFormattedUsageText(Stream &strm,
 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
 349 enum OptionDisplayType {
 350   eDisplayBestOption,
 351   eDisplayShortOption,
 352   eDisplayLongOption
 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) {
 375   case OptionParser::eNoArgument:
 376     break;
 377   case OptionParser::eRequiredArgument:
 378     strm.Printf(" <%s>", CommandObject::GetArgumentName(opt_def.argument_type));
 379     break;
 380
 381   case OptionParser::eOptionalArgument:
 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
 393 void Options::GenerateOptionUsage(Stream &strm, CommandObject *cmd,
 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
 625 bool Options::VerifyPartialOptions(CommandReturnObject &result) {
 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;
 635       OptionsSetUnion(GetRequiredOptions()[i], GetOptionalOptions()[i],
 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
 645 bool Options::HandleOptionCompletion(CompletionRequest &request,
 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
 757 bool Options::HandleOptionArgumentCompletion(
 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 =
 799           CommandObject::FindArgumentDataByType(
 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
 839   return CommandCompletions::InvokeCommonCompletionCallbacks(
 840       interpreter, completion_mask, request, filter_up.get());
 841 }
 842
 843 void OptionGroupOptions::Append(OptionGroup *group) {
 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
 851 const OptionGroup *OptionGroupOptions::GetGroupWithOption(char short_opt) {
 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
 860 void OptionGroupOptions::Append(OptionGroup *group, uint32_t src_mask,
 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
 872 void OptionGroupOptions::Finalize() {
 873   m_did_finalize = true;
 874 }
 875
 876 Status OptionGroupOptions::SetOptionValue(uint32_t option_idx,
 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
 894 void OptionGroupOptions::OptionParsingStarting(
 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
 907 OptionGroupOptions::OptionParsingFinished(ExecutionContext *execution_context) {
 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   result.push_back(nullptr);
 934   return result;
 935 }
 936
 937 // Given a permuted argument, find it's position in the original Args vector.
 938 static Args::const_iterator FindOriginalIter(const char *arg,
 939                                              const Args &original) {
 940   return llvm::find_if(
 941       original, [arg](const Args::ArgEntry &D) { return D.c_str() == arg; });
 942 }
 943
 944 // Given a permuted argument, find it's index in the original Args vector.
 945 static size_t FindOriginalIndex(const char *arg, const Args &original) {
 946   return std::distance(original.begin(), FindOriginalIter(arg, original));
 947 }
 948
 949 // Construct a new Args object, consisting of the entries from the original
 950 // arguments, but in the permuted order.
 951 static Args ReconstituteArgsAfterParsing(llvm::ArrayRef<char *> parsed,
 952                                          const Args &original) {
 953   Args result;
 954   for (const char *arg : parsed) {
 955     auto pos = FindOriginalIter(arg, original);
 956     assert(pos != original.end());
 957     result.AppendArgument(pos->ref, pos->quote);
 958   }
 959   return result;
 960 }
 961
 962 static size_t FindArgumentIndexForOption(const Args &args,
 963                                          const Option &long_option) {
 964   std::string short_opt = llvm::formatv("-{0}", char(long_option.val)).str();
 965   std::string long_opt =
 966       llvm::formatv("--{0}", long_option.definition->long_option);
 967   for (const auto &entry : llvm::enumerate(args)) {
 968     if (entry.value().ref.startswith(short_opt) ||
 969         entry.value().ref.startswith(long_opt))
 970       return entry.index();
 971   }
 972
 973   return size_t(-1);
 974 }
 975
 976 static std::string BuildShortOptions(const Option *long_options) {
 977   std::string storage;
 978   llvm::raw_string_ostream sstr(storage);
 979
 980   // Leading : tells getopt to return a : for a missing option argument AND to
 981   // suppress error messages.
 982   sstr << ":";
 983
 984   for (size_t i = 0; long_options[i].definition != nullptr; ++i) {
 985     if (long_options[i].flag == nullptr) {
 986       sstr << (char)long_options[i].val;
 987       switch (long_options[i].definition->option_has_arg) {
 988       default:
 989       case OptionParser::eNoArgument:
 990         break;
 991       case OptionParser::eRequiredArgument:
 992         sstr << ":";
 993         break;
 994       case OptionParser::eOptionalArgument:
 995         sstr << "::";
 996         break;
 997       }
 998     }
 999   }
1000   return std::move(sstr.str());
1001 }
1002
1003 llvm::Expected<Args> Options::ParseAlias(const Args &args,
1004                                          OptionArgVector *option_arg_vector,
1005                                          std::string &input_line) {
1006   Option *long_options = GetLongOptions();
1007
1008   if (long_options == nullptr) {
1009     return llvm::make_error<llvm::StringError>("Invalid long options",
1010                                                llvm::inconvertibleErrorCode());
1011   }
1012
1013   std::string short_options = BuildShortOptions(long_options);
1014
1015   Args args_copy = args;
1016   std::vector<char *> argv = GetArgvForParsing(args);
1017
1018   std::unique_lock<std::mutex> lock;
1019   OptionParser::Prepare(lock);
1020   int val;
1021   while (true) {
1022     int long_options_index = -1;
1023     val = OptionParser::Parse(argv, short_options, long_options,
1024                               &long_options_index);
1025
1026     if (val == ':') {
1027       return llvm::createStringError(llvm::inconvertibleErrorCode(),
1028                                      "last option requires an argument");
1029     }
1030
1031     if (val == -1)
1032       break;
1033
1034     if (val == '?') {
1035       return llvm::make_error<llvm::StringError>(
1036           "Unknown or ambiguous option", llvm::inconvertibleErrorCode());
1037     }
1038
1039     if (val == 0)
1040       continue;
1041
1042     OptionSeen(val);
1043
1044     // Look up the long option index
1045     if (long_options_index == -1) {
1046       for (int j = 0; long_options[j].definition || long_options[j].flag ||
1047                       long_options[j].val;
1048            ++j) {
1049         if (long_options[j].val == val) {
1050           long_options_index = j;
1051           break;
1052         }
1053       }
1054     }
1055
1056     // See if the option takes an argument, and see if one was supplied.
1057     if (long_options_index == -1) {
1058       return llvm::make_error<llvm::StringError>(
1059           llvm::formatv("Invalid option with value '{0}'.", char(val)).str(),
1060           llvm::inconvertibleErrorCode());
1061     }
1062
1063     StreamString option_str;
1064     option_str.Printf("-%c", val);
1065     const OptionDefinition *def = long_options[long_options_index].definition;
1066     int has_arg =
1067         (def == nullptr) ? OptionParser::eNoArgument : def->option_has_arg;
1068
1069     const char *option_arg = nullptr;
1070     switch (has_arg) {
1071     case OptionParser::eRequiredArgument:
1072       if (OptionParser::GetOptionArgument() == nullptr) {
1073         return llvm::make_error<llvm::StringError>(
1074             llvm::formatv("Option '{0}' is missing argument specifier.",
1075                           option_str.GetString())
1076                 .str(),
1077             llvm::inconvertibleErrorCode());
1078       }
1079       LLVM_FALLTHROUGH;
1080     case OptionParser::eOptionalArgument:
1081       option_arg = OptionParser::GetOptionArgument();
1082       LLVM_FALLTHROUGH;
1083     case OptionParser::eNoArgument:
1084       break;
1085     default:
1086       return llvm::make_error<llvm::StringError>(
1087           llvm::formatv("error with options table; invalid value in has_arg "
1088                         "field for option '{0}'.",
1089                         char(val))
1090               .str(),
1091           llvm::inconvertibleErrorCode());
1092     }
1093     if (!option_arg)
1094       option_arg = "<no-argument>";
1095     option_arg_vector->emplace_back(option_str.GetString(), has_arg,
1096                                     option_arg);
1097
1098     // Find option in the argument list; also see if it was supposed to take an
1099     // argument and if one was supplied.  Remove option (and argument, if
1100     // given) from the argument list.  Also remove them from the
1101     // raw_input_string, if one was passed in.
1102     size_t idx =
1103         FindArgumentIndexForOption(args_copy, long_options[long_options_index]);
1104     if (idx == size_t(-1))
1105       continue;
1106
1107     if (!input_line.empty()) {
1108       auto tmp_arg = args_copy[idx].ref;
1109       size_t pos = input_line.find(tmp_arg);
1110       if (pos != std::string::npos)
1111         input_line.erase(pos, tmp_arg.size());
1112     }
1113     args_copy.DeleteArgumentAtIndex(idx);
1114     if ((long_options[long_options_index].definition->option_has_arg !=
1115          OptionParser::eNoArgument) &&
1116         (OptionParser::GetOptionArgument() != nullptr) &&
1117         (idx < args_copy.GetArgumentCount()) &&
1118         (args_copy[idx].ref == OptionParser::GetOptionArgument())) {
1119       if (input_line.size() > 0) {
1120         auto tmp_arg = args_copy[idx].ref;
1121         size_t pos = input_line.find(tmp_arg);
1122         if (pos != std::string::npos)
1123           input_line.erase(pos, tmp_arg.size());
1124       }
1125       args_copy.DeleteArgumentAtIndex(idx);
1126     }
1127   }
1128
1129   return std::move(args_copy);
1130 }
1131
1132 OptionElementVector Options::ParseForCompletion(const Args &args,
1133                                                 uint32_t cursor_index) {
1134   OptionElementVector option_element_vector;
1135   Option *long_options = GetLongOptions();
1136   option_element_vector.clear();
1137
1138   if (long_options == nullptr)
1139     return option_element_vector;
1140
1141   std::string short_options = BuildShortOptions(long_options);
1142
1143   std::unique_lock<std::mutex> lock;
1144   OptionParser::Prepare(lock);
1145   OptionParser::EnableError(false);
1146
1147   int val;
1148   auto opt_defs = GetDefinitions();
1149
1150   std::vector<char *> dummy_vec = GetArgvForParsing(args);
1151
1152   bool failed_once = false;
1153   uint32_t dash_dash_pos = -1;
1154
1155   while (true) {
1156     bool missing_argument = false;
1157     int long_options_index = -1;
1158
1159     val = OptionParser::Parse(dummy_vec, short_options, long_options,
1160                               &long_options_index);
1161
1162     if (val == -1) {
1163       // When we're completing a "--" which is the last option on line,
1164       if (failed_once)
1165         break;
1166
1167       failed_once = true;
1168
1169       // If this is a bare  "--" we mark it as such so we can complete it
1170       // successfully later.  Handling the "--" is a little tricky, since that
1171       // may mean end of options or arguments, or the user might want to
1172       // complete options by long name.  I make this work by checking whether
1173       // the cursor is in the "--" argument, and if so I assume we're
1174       // completing the long option, otherwise I let it pass to
1175       // OptionParser::Parse which will terminate the option parsing.  Note, in
1176       // either case we continue parsing the line so we can figure out what
1177       // other options were passed.  This will be useful when we come to
1178       // restricting completions based on what other options we've seen on the
1179       // line.
1180
1181       if (static_cast<size_t>(OptionParser::GetOptionIndex()) <
1182               dummy_vec.size() &&
1183           (strcmp(dummy_vec[OptionParser::GetOptionIndex() - 1], "--") == 0)) {
1184         dash_dash_pos = FindOriginalIndex(
1185             dummy_vec[OptionParser::GetOptionIndex() - 1], args);
1186         if (dash_dash_pos == cursor_index) {
1187           option_element_vector.push_back(
1188               OptionArgElement(OptionArgElement::eBareDoubleDash, dash_dash_pos,
1189                                OptionArgElement::eBareDoubleDash));
1190           continue;
1191         } else
1192           break;
1193       } else
1194         break;
1195     } else if (val == '?') {
1196       option_element_vector.push_back(OptionArgElement(
1197           OptionArgElement::eUnrecognizedArg,
1198           FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1199                             args),
1200           OptionArgElement::eUnrecognizedArg));
1201       continue;
1202     } else if (val == 0) {
1203       continue;
1204     } else if (val == ':') {
1205       // This is a missing argument.
1206       val = OptionParser::GetOptionErrorCause();
1207       missing_argument = true;
1208     }
1209
1210     OptionSeen(val);
1211
1212     // Look up the long option index
1213     if (long_options_index == -1) {
1214       for (int j = 0; long_options[j].definition || long_options[j].flag ||
1215                       long_options[j].val;
1216            ++j) {
1217         if (long_options[j].val == val) {
1218           long_options_index = j;
1219           break;
1220         }
1221       }
1222     }
1223
1224     // See if the option takes an argument, and see if one was supplied.
1225     if (long_options_index >= 0) {
1226       int opt_defs_index = -1;
1227       for (size_t i = 0; i < opt_defs.size(); i++) {
1228         if (opt_defs[i].short_option != val)
1229           continue;
1230         opt_defs_index = i;
1231         break;
1232       }
1233
1234       const OptionDefinition *def = long_options[long_options_index].definition;
1235       int has_arg =
1236           (def == nullptr) ? OptionParser::eNoArgument : def->option_has_arg;
1237       switch (has_arg) {
1238       case OptionParser::eNoArgument:
1239         option_element_vector.push_back(OptionArgElement(
1240             opt_defs_index,
1241             FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1242                               args),
1243             0));
1244         break;
1245       case OptionParser::eRequiredArgument:
1246         if (OptionParser::GetOptionArgument() != nullptr) {
1247           int arg_index;
1248           if (missing_argument)
1249             arg_index = -1;
1250           else
1251             arg_index = OptionParser::GetOptionIndex() - 2;
1252
1253           option_element_vector.push_back(OptionArgElement(
1254               opt_defs_index,
1255               FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 2],
1256                                 args),
1257               arg_index));
1258         } else {
1259           option_element_vector.push_back(OptionArgElement(
1260               opt_defs_index,
1261               FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1262                                 args),
1263               -1));
1264         }
1265         break;
1266       case OptionParser::eOptionalArgument:
1267         if (OptionParser::GetOptionArgument() != nullptr) {
1268           option_element_vector.push_back(OptionArgElement(
1269               opt_defs_index,
1270               FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 2],
1271                                 args),
1272               FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1273                                 args)));
1274         } else {
1275           option_element_vector.push_back(OptionArgElement(
1276               opt_defs_index,
1277               FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 2],
1278                                 args),
1279               FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1280                                 args)));
1281         }
1282         break;
1283       default:
1284         // The options table is messed up.  Here we'll just continue
1285         option_element_vector.push_back(OptionArgElement(
1286             OptionArgElement::eUnrecognizedArg,
1287             FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1288                               args),
1289             OptionArgElement::eUnrecognizedArg));
1290         break;
1291       }
1292     } else {
1293       option_element_vector.push_back(OptionArgElement(
1294           OptionArgElement::eUnrecognizedArg,
1295           FindOriginalIndex(dummy_vec[OptionParser::GetOptionIndex() - 1],
1296                             args),
1297           OptionArgElement::eUnrecognizedArg));
1298     }
1299   }
1300
1301   // Finally we have to handle the case where the cursor index points at a
1302   // single "-".  We want to mark that in the option_element_vector, but only
1303   // if it is not after the "--".  But it turns out that OptionParser::Parse
1304   // just ignores an isolated "-".  So we have to look it up by hand here.  We
1305   // only care if it is AT the cursor position. Note, a single quoted dash is
1306   // not the same as a single dash...
1307
1308   const Args::ArgEntry &cursor = args[cursor_index];
1309   if ((static_cast<int32_t>(dash_dash_pos) == -1 ||
1310        cursor_index < dash_dash_pos) &&
1311       !cursor.IsQuoted() && cursor.ref == "-") {
1312     option_element_vector.push_back(
1313         OptionArgElement(OptionArgElement::eBareDash, cursor_index,
1314                          OptionArgElement::eBareDash));
1315   }
1316   return option_element_vector;
1317 }
1318
1319 llvm::Expected<Args> Options::Parse(const Args &args,
1320                                     ExecutionContext *execution_context,
1321                                     lldb::PlatformSP platform_sp,
1322                                     bool require_validation) {
1323   Status error;
1324   Option *long_options = GetLongOptions();
1325   if (long_options == nullptr) {
1326     return llvm::make_error<llvm::StringError>("Invalid long options.",
1327                                                llvm::inconvertibleErrorCode());
1328   }
1329
1330   std::string short_options = BuildShortOptions(long_options);
1331   std::vector<char *> argv = GetArgvForParsing(args);
1332   std::unique_lock<std::mutex> lock;
1333   OptionParser::Prepare(lock);
1334   int val;
1335   while (true) {
1336     int long_options_index = -1;
1337     val = OptionParser::Parse(argv, short_options, long_options,
1338                               &long_options_index);
1339
1340     if (val == ':') {
1341       error.SetErrorStringWithFormat("last option requires an argument");
1342       break;
1343     }
1344
1345     if (val == -1)
1346       break;
1347
1348     // Did we get an error?
1349     if (val == '?') {
1350       error.SetErrorStringWithFormat("unknown or ambiguous option");
1351       break;
1352     }
1353     // The option auto-set itself
1354     if (val == 0)
1355       continue;
1356
1357     OptionSeen(val);
1358
1359     // Lookup the long option index
1360     if (long_options_index == -1) {
1361       for (int i = 0; long_options[i].definition || long_options[i].flag ||
1362                       long_options[i].val;
1363            ++i) {
1364         if (long_options[i].val == val) {
1365           long_options_index = i;
1366           break;
1367         }
1368       }
1369     }
1370     // Call the callback with the option
1371     if (long_options_index >= 0 &&
1372         long_options[long_options_index].definition) {
1373       const OptionDefinition *def = long_options[long_options_index].definition;
1374
1375       if (!platform_sp) {
1376         // User did not pass in an explicit platform.  Try to grab from the
1377         // execution context.
1378         TargetSP target_sp =
1379             execution_context ? execution_context->GetTargetSP() : TargetSP();
1380         platform_sp = target_sp ? target_sp->GetPlatform() : PlatformSP();
1381       }
1382       OptionValidator *validator = def->validator;
1383
1384       if (!platform_sp && require_validation) {
1385         // Caller requires validation but we cannot validate as we don't have
1386         // the mandatory platform against which to validate.
1387         return llvm::make_error<llvm::StringError>(
1388             "cannot validate options: no platform available",
1389             llvm::inconvertibleErrorCode());
1390       }
1391
1392       bool validation_failed = false;
1393       if (platform_sp) {
1394         // Ensure we have an execution context, empty or not.
1395         ExecutionContext dummy_context;
1396         ExecutionContext *exe_ctx_p =
1397             execution_context ? execution_context : &dummy_context;
1398         if (validator && !validator->IsValid(*platform_sp, *exe_ctx_p)) {
1399           validation_failed = true;
1400           error.SetErrorStringWithFormat("Option \"%s\" invalid.  %s",
1401                                          def->long_option,
1402                                          def->validator->LongConditionString());
1403         }
1404       }
1405
1406       // As long as validation didn't fail, we set the option value.
1407       if (!validation_failed)
1408         error =
1409             SetOptionValue(long_options_index,
1410                            (def->option_has_arg == OptionParser::eNoArgument)
1411                                ? nullptr
1412                                : OptionParser::GetOptionArgument(),
1413                            execution_context);
1414     } else {
1415       error.SetErrorStringWithFormat("invalid option with value '%i'", val);
1416     }
1417   }
1418
1419   if (error.Fail())
1420     return error.ToError();
1421
1422   argv.pop_back();
1423   argv.erase(argv.begin(), argv.begin() + OptionParser::GetOptionIndex());
1424   return ReconstituteArgsAfterParsing(argv, args);
1425 }