Options.cpp revision 353358
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 24using namespace lldb; 25using namespace lldb_private; 26 27// Options 28Options::Options() : m_getopt_table() { BuildValidOptionSets(); } 29 30Options::~Options() {} 31 32void Options::NotifyOptionParsingStarting(ExecutionContext *execution_context) { 33 m_seen_options.clear(); 34 // Let the subclass reset its option values 35 OptionParsingStarting(execution_context); 36} 37 38Status 39Options::NotifyOptionParsingFinished(ExecutionContext *execution_context) { 40 return OptionParsingFinished(execution_context); 41} 42 43void 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 47bool 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 67size_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 87void 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 105bool 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 149void 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 200uint32_t Options::NumCommandOptions() { return GetDefinitions().size(); } 201 202Option *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 266void 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 326bool 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 349enum OptionDisplayType { 350 eDisplayBestOption, 351 eDisplayShortOption, 352 eDisplayLongOption 353}; 354 355static 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 393void 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 625bool 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 645bool 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 757bool 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 843void 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 851const 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 860void 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 872void OptionGroupOptions::Finalize() { 873 m_did_finalize = true; 874} 875 876Status 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 894void 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} 906Status 907OptionGroupOptions::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. 927static 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. 938static 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. 945static 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. 951static 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 962static 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 976static 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 1003llvm::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 1132OptionElementVector 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 1319llvm::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} 1426