source/Interpreter/Options.cpp

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