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/lldb-python.h" 11 12 #include "lldb/Interpreter/Options.h" 13 14 // C Includes 15 // C++ Includes 16 #include <algorithm> 17 #include <bitset> 18 #include <map> 19 20 // Other libraries and framework includes 21 // Project includes 22 #include "lldb/Interpreter/CommandObject.h" 23 #include "lldb/Interpreter/CommandReturnObject.h" 24 #include "lldb/Interpreter/CommandCompletions.h" 25 #include "lldb/Interpreter/CommandInterpreter.h" 26 #include "lldb/Core/StreamString.h" 27 #include "lldb/Target/Target.h" 28 29 using namespace lldb; 30 using namespace lldb_private; 31 32 //------------------------------------------------------------------------- 33 // Options 34 //------------------------------------------------------------------------- 35 Options::Options (CommandInterpreter &interpreter) : 36 m_interpreter (interpreter), 37 m_getopt_table () 38 { 39 BuildValidOptionSets(); 40 } 41 42 Options::~Options () 43 { 44 } 45 46 void 47 Options::NotifyOptionParsingStarting () 48 { 49 m_seen_options.clear(); 50 // Let the subclass reset its option values 51 OptionParsingStarting (); 52 } 53 54 Error 55 Options::NotifyOptionParsingFinished () 56 { 57 return OptionParsingFinished (); 58 } 59 60 void 61 Options::OptionSeen (int option_idx) 62 { 63 m_seen_options.insert (option_idx); 64 } 65 66 // Returns true is set_a is a subset of set_b; Otherwise returns false. 67 68 bool 69 Options::IsASubset (const OptionSet& set_a, const OptionSet& set_b) 70 { 71 bool is_a_subset = true; 72 OptionSet::const_iterator pos_a; 73 OptionSet::const_iterator pos_b; 74 75 // set_a is a subset of set_b if every member of set_a is also a member of set_b 76 77 for (pos_a = set_a.begin(); pos_a != set_a.end() && is_a_subset; ++pos_a) 78 { 79 pos_b = set_b.find(*pos_a); 80 if (pos_b == set_b.end()) 81 is_a_subset = false; 82 } 83 84 return is_a_subset; 85 } 86 87 // Returns the set difference set_a - set_b, i.e. { x | ElementOf (x, set_a) && !ElementOf (x, set_b) } 88 89 size_t 90 Options::OptionsSetDiff (const OptionSet& set_a, const OptionSet& set_b, OptionSet& diffs) 91 { 92 size_t num_diffs = 0; 93 OptionSet::const_iterator pos_a; 94 OptionSet::const_iterator pos_b; 95 96 for (pos_a = set_a.begin(); pos_a != set_a.end(); ++pos_a) 97 { 98 pos_b = set_b.find(*pos_a); 99 if (pos_b == set_b.end()) 100 { 101 ++num_diffs; 102 diffs.insert(*pos_a); 103 } 104 } 105 106 return num_diffs; 107 } 108 109 // Returns the union of set_a and set_b. Does not put duplicate members into the union. 110 111 void 112 Options::OptionsSetUnion (const OptionSet &set_a, const OptionSet &set_b, OptionSet &union_set) 113 { 114 OptionSet::const_iterator pos; 115 OptionSet::iterator pos_union; 116 117 // Put all the elements of set_a into the union. 118 119 for (pos = set_a.begin(); pos != set_a.end(); ++pos) 120 union_set.insert(*pos); 121 122 // Put all the elements of set_b that are not already there into the union. 123 for (pos = set_b.begin(); pos != set_b.end(); ++pos) 124 { 125 pos_union = union_set.find(*pos); 126 if (pos_union == union_set.end()) 127 union_set.insert(*pos); 128 } 129 } 130 131 bool 132 Options::VerifyOptions (CommandReturnObject &result) 133 { 134 bool options_are_valid = false; 135 136 int num_levels = GetRequiredOptions().size(); 137 if (num_levels) 138 { 139 for (int i = 0; i < num_levels && !options_are_valid; ++i) 140 { 141 // This is the correct set of options if: 1). m_seen_options contains all of m_required_options[i] 142 // (i.e. all the required options at this level are a subset of m_seen_options); AND 143 // 2). { m_seen_options - m_required_options[i] is a subset of m_options_options[i] (i.e. all the rest of 144 // m_seen_options are in the set of optional options at this level. 145 146 // Check to see if all of m_required_options[i] are a subset of m_seen_options 147 if (IsASubset (GetRequiredOptions()[i], m_seen_options)) 148 { 149 // Construct the set difference: remaining_options = {m_seen_options} - {m_required_options[i]} 150 OptionSet remaining_options; 151 OptionsSetDiff (m_seen_options, GetRequiredOptions()[i], remaining_options); 152 // Check to see if remaining_options is a subset of m_optional_options[i] 153 if (IsASubset (remaining_options, GetOptionalOptions()[i])) 154 options_are_valid = true; 155 } 156 } 157 } 158 else 159 { 160 options_are_valid = true; 161 } 162 163 if (options_are_valid) 164 { 165 result.SetStatus (eReturnStatusSuccessFinishNoResult); 166 } 167 else 168 { 169 result.AppendError ("invalid combination of options for the given command"); 170 result.SetStatus (eReturnStatusFailed); 171 } 172 173 return options_are_valid; 174 } 175 176 // This is called in the Options constructor, though we could call it lazily if that ends up being 177 // a performance problem. 178 179 void 180 Options::BuildValidOptionSets () 181 { 182 // Check to see if we already did this. 183 if (m_required_options.size() != 0) 184 return; 185 186 // Check to see if there are any options. 187 int num_options = NumCommandOptions (); 188 if (num_options == 0) 189 return; 190 191 const OptionDefinition *opt_defs = GetDefinitions(); 192 m_required_options.resize(1); 193 m_optional_options.resize(1); 194 195 // First count the number of option sets we've got. Ignore LLDB_ALL_OPTION_SETS... 196 197 uint32_t num_option_sets = 0; 198 199 for (int i = 0; i < num_options; i++) 200 { 201 uint32_t this_usage_mask = opt_defs[i].usage_mask; 202 if (this_usage_mask == LLDB_OPT_SET_ALL) 203 { 204 if (num_option_sets == 0) 205 num_option_sets = 1; 206 } 207 else 208 { 209 for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++) 210 { 211 if (this_usage_mask & (1 << j)) 212 { 213 if (num_option_sets <= j) 214 num_option_sets = j + 1; 215 } 216 } 217 } 218 } 219 220 if (num_option_sets > 0) 221 { 222 m_required_options.resize(num_option_sets); 223 m_optional_options.resize(num_option_sets); 224 225 for (int i = 0; i < num_options; ++i) 226 { 227 for (uint32_t j = 0; j < num_option_sets; j++) 228 { 229 if (opt_defs[i].usage_mask & 1 << j) 230 { 231 if (opt_defs[i].required) 232 m_required_options[j].insert(opt_defs[i].short_option); 233 else 234 m_optional_options[j].insert(opt_defs[i].short_option); 235 } 236 } 237 } 238 } 239 } 240 241 uint32_t 242 Options::NumCommandOptions () 243 { 244 const OptionDefinition *opt_defs = GetDefinitions (); 245 if (opt_defs == NULL) 246 return 0; 247 248 int i = 0; 249 250 if (opt_defs != NULL) 251 { 252 while (opt_defs[i].long_option != NULL) 253 ++i; 254 } 255 256 return i; 257 } 258 259 struct option * 260 Options::GetLongOptions () 261 { 262 // Check to see if this has already been done. 263 if (m_getopt_table.empty()) 264 { 265 // Check to see if there are any options. 266 const uint32_t num_options = NumCommandOptions(); 267 if (num_options == 0) 268 return NULL; 269 270 uint32_t i; 271 const OptionDefinition *opt_defs = GetDefinitions(); 272 273 std::map<int, uint32_t> option_seen; 274 275 m_getopt_table.resize(num_options + 1); 276 for (i = 0; i < num_options; ++i) 277 { 278 const int short_opt = opt_defs[i].short_option; 279 280 m_getopt_table[i].name = opt_defs[i].long_option; 281 m_getopt_table[i].has_arg = opt_defs[i].option_has_arg; 282 m_getopt_table[i].flag = NULL; 283 m_getopt_table[i].val = short_opt; 284 285 if (option_seen.find(short_opt) == option_seen.end()) 286 { 287 option_seen[short_opt] = i; 288 } 289 else if (short_opt) 290 { 291 m_getopt_table[i].val = 0; 292 std::map<int, uint32_t>::const_iterator pos = option_seen.find(short_opt); 293 StreamString strm; 294 if (isprint8(short_opt)) 295 Host::SystemLog (Host::eSystemLogError, "option[%u] --%s has a short option -%c that conflicts with option[%u] --%s, short option won't be used for --%s\n", 296 i, 297 opt_defs[i].long_option, 298 short_opt, 299 pos->second, 300 m_getopt_table[pos->second].name, 301 opt_defs[i].long_option); 302 else 303 Host::SystemLog (Host::eSystemLogError, "option[%u] --%s has a short option 0x%x that conflicts with option[%u] --%s, short option won't be used for --%s\n", 304 i, 305 opt_defs[i].long_option, 306 short_opt, 307 pos->second, 308 m_getopt_table[pos->second].name, 309 opt_defs[i].long_option); 310 } 311 } 312 313 //getopt_long_only requires a NULL final entry in the table: 314 315 m_getopt_table[i].name = NULL; 316 m_getopt_table[i].has_arg = 0; 317 m_getopt_table[i].flag = NULL; 318 m_getopt_table[i].val = 0; 319 } 320 321 if (m_getopt_table.empty()) 322 return NULL; 323 324 return &m_getopt_table.front(); 325 } 326 327 328 // This function takes INDENT, which tells how many spaces to output at the front of each line; SPACES, which is 329 // a string containing 80 spaces; and TEXT, which is the text that is to be output. It outputs the text, on 330 // multiple lines if necessary, to RESULT, with INDENT spaces at the front of each line. It breaks lines on spaces, 331 // tabs or newlines, shortening the line if necessary to not break in the middle of a word. It assumes that each 332 // output line should contain a maximum of OUTPUT_MAX_COLUMNS characters. 333 334 335 void 336 Options::OutputFormattedUsageText 337 ( 338 Stream &strm, 339 const char *text, 340 uint32_t output_max_columns 341 ) 342 { 343 int len = strlen (text); 344 345 // Will it all fit on one line? 346 347 if ((len + strm.GetIndentLevel()) < output_max_columns) 348 { 349 // Output it as a single line. 350 strm.Indent (text); 351 strm.EOL(); 352 } 353 else 354 { 355 // We need to break it up into multiple lines. 356 357 int text_width = output_max_columns - strm.GetIndentLevel() - 1; 358 int start = 0; 359 int end = start; 360 int final_end = strlen (text); 361 int sub_len; 362 363 while (end < final_end) 364 { 365 // Don't start the 'text' on a space, since we're already outputting the indentation. 366 while ((start < final_end) && (text[start] == ' ')) 367 start++; 368 369 end = start + text_width; 370 if (end > final_end) 371 end = final_end; 372 else 373 { 374 // If we're not at the end of the text, make sure we break the line on white space. 375 while (end > start 376 && text[end] != ' ' && text[end] != '\t' && text[end] != '\n') 377 end--; 378 } 379 380 sub_len = end - start; 381 if (start != 0) 382 strm.EOL(); 383 strm.Indent(); 384 assert (start < final_end); 385 assert (start + sub_len <= final_end); 386 strm.Write(text + start, sub_len); 387 start = end + 1; 388 } 389 strm.EOL(); 390 } 391 } 392 393 bool 394 Options::SupportsLongOption (const char *long_option) 395 { 396 if (long_option && long_option[0]) 397 { 398 const OptionDefinition *opt_defs = GetDefinitions (); 399 if (opt_defs) 400 { 401 const char *long_option_name = long_option; 402 if (long_option[0] == '-' && long_option[1] == '-') 403 long_option_name += 2; 404 405 for (uint32_t i = 0; opt_defs[i].long_option; ++i) 406 { 407 if (strcmp(opt_defs[i].long_option, long_option_name) == 0) 408 return true; 409 } 410 } 411 } 412 return false; 413 } 414 415 enum OptionDisplayType 416 { 417 eDisplayBestOption, 418 eDisplayShortOption, 419 eDisplayLongOption 420 }; 421 422 static bool 423 PrintOption (const OptionDefinition &opt_def, 424 OptionDisplayType display_type, 425 const char *header, 426 const char *footer, 427 bool show_optional, 428 Stream &strm) 429 { 430 const bool has_short_option = isprint8(opt_def.short_option) != 0; 431 432 if (display_type == eDisplayShortOption && !has_short_option) 433 return false; 434 435 if (header && header[0]) 436 strm.PutCString(header); 437 438 if (show_optional && !opt_def.required) 439 strm.PutChar('['); 440 const bool show_short_option = has_short_option && display_type != eDisplayLongOption; 441 if (show_short_option) 442 strm.Printf ("-%c", opt_def.short_option); 443 else 444 strm.Printf ("--%s", opt_def.long_option); 445 switch (opt_def.option_has_arg) 446 { 447 case no_argument: 448 break; 449 case required_argument: 450 strm.Printf (" <%s>", CommandObject::GetArgumentName (opt_def.argument_type)); 451 break; 452 453 case optional_argument: 454 strm.Printf ("%s[<%s>]", 455 show_short_option ? "" : "=", 456 CommandObject::GetArgumentName (opt_def.argument_type)); 457 break; 458 } 459 if (show_optional && !opt_def.required) 460 strm.PutChar(']'); 461 if (footer && footer[0]) 462 strm.PutCString(footer); 463 return true; 464 } 465 466 void 467 Options::GenerateOptionUsage 468 ( 469 Stream &strm, 470 CommandObject *cmd 471 ) 472 { 473 const uint32_t screen_width = m_interpreter.GetDebugger().GetTerminalWidth(); 474 475 const OptionDefinition *opt_defs = GetDefinitions(); 476 const uint32_t save_indent_level = strm.GetIndentLevel(); 477 const char *name; 478 479 StreamString arguments_str; 480 481 if (cmd) 482 { 483 name = cmd->GetCommandName(); 484 cmd->GetFormattedCommandArguments (arguments_str); 485 } 486 else 487 name = ""; 488 489 strm.PutCString ("\nCommand Options Usage:\n"); 490 491 strm.IndentMore(2); 492 493 // First, show each usage level set of options, e.g. <cmd> [options-for-level-0] 494 // <cmd> [options-for-level-1] 495 // etc. 496 497 const uint32_t num_options = NumCommandOptions(); 498 if (num_options == 0) 499 return; 500 501 uint32_t num_option_sets = GetRequiredOptions().size(); 502 503 uint32_t i; 504 505 for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) 506 { 507 uint32_t opt_set_mask; 508 509 opt_set_mask = 1 << opt_set; 510 if (opt_set > 0) 511 strm.Printf ("\n"); 512 strm.Indent (name); 513 514 // Different option sets may require different args. 515 StreamString args_str; 516 if (cmd) 517 cmd->GetFormattedCommandArguments(args_str, opt_set_mask); 518 519 // First go through and print all options that take no arguments as 520 // a single string. If a command has "-a" "-b" and "-c", this will show 521 // up as [-abc] 522 523 std::set<int> options; 524 std::set<int>::const_iterator options_pos, options_end; 525 for (i = 0; i < num_options; ++i) 526 { 527 if (opt_defs[i].usage_mask & opt_set_mask && isprint8(opt_defs[i].short_option)) 528 { 529 // Add current option to the end of out_stream. 530 531 if (opt_defs[i].required == true && 532 opt_defs[i].option_has_arg == no_argument) 533 { 534 options.insert (opt_defs[i].short_option); 535 } 536 } 537 } 538 539 if (options.empty() == false) 540 { 541 // We have some required options with no arguments 542 strm.PutCString(" -"); 543 for (i=0; i<2; ++i) 544 for (options_pos = options.begin(), options_end = options.end(); 545 options_pos != options_end; 546 ++options_pos) 547 { 548 if (i==0 && ::islower (*options_pos)) 549 continue; 550 if (i==1 && ::isupper (*options_pos)) 551 continue; 552 strm << (char)*options_pos; 553 } 554 } 555 556 for (i = 0, options.clear(); i < num_options; ++i) 557 { 558 if (opt_defs[i].usage_mask & opt_set_mask && isprint8(opt_defs[i].short_option)) 559 { 560 // Add current option to the end of out_stream. 561 562 if (opt_defs[i].required == false && 563 opt_defs[i].option_has_arg == no_argument) 564 { 565 options.insert (opt_defs[i].short_option); 566 } 567 } 568 } 569 570 if (options.empty() == false) 571 { 572 // We have some required options with no arguments 573 strm.PutCString(" [-"); 574 for (i=0; i<2; ++i) 575 for (options_pos = options.begin(), options_end = options.end(); 576 options_pos != options_end; 577 ++options_pos) 578 { 579 if (i==0 && ::islower (*options_pos)) 580 continue; 581 if (i==1 && ::isupper (*options_pos)) 582 continue; 583 strm << (char)*options_pos; 584 } 585 strm.PutChar(']'); 586 } 587 588 // First go through and print the required options (list them up front). 589 590 for (i = 0; i < num_options; ++i) 591 { 592 if (opt_defs[i].usage_mask & opt_set_mask && isprint8(opt_defs[i].short_option)) 593 { 594 if (opt_defs[i].required && opt_defs[i].option_has_arg != no_argument) 595 PrintOption (opt_defs[i], eDisplayBestOption, " ", NULL, true, strm); 596 } 597 } 598 599 // Now go through again, and this time only print the optional options. 600 601 for (i = 0; i < num_options; ++i) 602 { 603 if (opt_defs[i].usage_mask & opt_set_mask) 604 { 605 // Add current option to the end of out_stream. 606 607 if (!opt_defs[i].required && opt_defs[i].option_has_arg != no_argument) 608 PrintOption (opt_defs[i], eDisplayBestOption, " ", NULL, true, strm); 609 } 610 } 611 612 if (args_str.GetSize() > 0) 613 { 614 if (cmd->WantsRawCommandString()) 615 strm.Printf(" --"); 616 617 strm.Printf (" %s", args_str.GetData()); 618 } 619 } 620 621 if (cmd && 622 cmd->WantsRawCommandString() && 623 arguments_str.GetSize() > 0) 624 { 625 strm.PutChar('\n'); 626 strm.Indent(name); 627 strm.Printf(" %s", arguments_str.GetData()); 628 } 629 630 strm.Printf ("\n\n"); 631 632 // Now print out all the detailed information about the various options: long form, short form and help text: 633 // --long_name <argument> ( -short <argument> ) 634 // help text 635 636 // This variable is used to keep track of which options' info we've printed out, because some options can be in 637 // more than one usage level, but we only want to print the long form of its information once. 638 639 std::multimap<int, uint32_t> options_seen; 640 strm.IndentMore (5); 641 642 // Put the unique command options in a vector & sort it, so we can output them alphabetically (by short_option) 643 // when writing out detailed help for each option. 644 645 for (i = 0; i < num_options; ++i) 646 options_seen.insert(std::make_pair(opt_defs[i].short_option, i)); 647 648 // Go through the unique'd and alphabetically sorted vector of options, find the table entry for each option 649 // and write out the detailed help information for that option. 650 651 bool first_option_printed = false;; 652 653 for (auto pos : options_seen) 654 { 655 i = pos.second; 656 //Print out the help information for this option. 657 658 // Put a newline separation between arguments 659 if (first_option_printed) 660 strm.EOL(); 661 else 662 first_option_printed = true; 663 664 CommandArgumentType arg_type = opt_defs[i].argument_type; 665 666 StreamString arg_name_str; 667 arg_name_str.Printf ("<%s>", CommandObject::GetArgumentName (arg_type)); 668 669 strm.Indent (); 670 if (opt_defs[i].short_option && isprint8(opt_defs[i].short_option)) 671 { 672 PrintOption (opt_defs[i], eDisplayShortOption, NULL, NULL, false, strm); 673 PrintOption (opt_defs[i], eDisplayLongOption, " ( ", " )", false, strm); 674 } 675 else 676 { 677 // Short option is not printable, just print long option 678 PrintOption (opt_defs[i], eDisplayLongOption, NULL, NULL, false, strm); 679 } 680 strm.EOL(); 681 682 strm.IndentMore (5); 683 684 if (opt_defs[i].usage_text) 685 OutputFormattedUsageText (strm, 686 opt_defs[i].usage_text, 687 screen_width); 688 if (opt_defs[i].enum_values != NULL) 689 { 690 strm.Indent (); 691 strm.Printf("Values: "); 692 for (int k = 0; opt_defs[i].enum_values[k].string_value != NULL; k++) 693 { 694 if (k == 0) 695 strm.Printf("%s", opt_defs[i].enum_values[k].string_value); 696 else 697 strm.Printf(" | %s", opt_defs[i].enum_values[k].string_value); 698 } 699 strm.EOL(); 700 } 701 strm.IndentLess (5); 702 } 703 704 // Restore the indent level 705 strm.SetIndentLevel (save_indent_level); 706 } 707 708 // This function is called when we have been given a potentially incomplete set of 709 // options, such as when an alias has been defined (more options might be added at 710 // at the time the alias is invoked). We need to verify that the options in the set 711 // m_seen_options are all part of a set that may be used together, but m_seen_options 712 // may be missing some of the "required" options. 713 714 bool 715 Options::VerifyPartialOptions (CommandReturnObject &result) 716 { 717 bool options_are_valid = false; 718 719 int num_levels = GetRequiredOptions().size(); 720 if (num_levels) 721 { 722 for (int i = 0; i < num_levels && !options_are_valid; ++i) 723 { 724 // In this case we are treating all options as optional rather than required. 725 // Therefore a set of options is correct if m_seen_options is a subset of the 726 // union of m_required_options and m_optional_options. 727 OptionSet union_set; 728 OptionsSetUnion (GetRequiredOptions()[i], GetOptionalOptions()[i], union_set); 729 if (IsASubset (m_seen_options, union_set)) 730 options_are_valid = true; 731 } 732 } 733 734 return options_are_valid; 735 } 736 737 bool 738 Options::HandleOptionCompletion 739 ( 740 Args &input, 741 OptionElementVector &opt_element_vector, 742 int cursor_index, 743 int char_pos, 744 int match_start_point, 745 int max_return_elements, 746 bool &word_complete, 747 lldb_private::StringList &matches 748 ) 749 { 750 word_complete = true; 751 752 // For now we just scan the completions to see if the cursor position is in 753 // an option or its argument. Otherwise we'll call HandleArgumentCompletion. 754 // In the future we can use completion to validate options as well if we want. 755 756 const OptionDefinition *opt_defs = GetDefinitions(); 757 758 std::string cur_opt_std_str (input.GetArgumentAtIndex(cursor_index)); 759 cur_opt_std_str.erase(char_pos); 760 const char *cur_opt_str = cur_opt_std_str.c_str(); 761 762 for (size_t i = 0; i < opt_element_vector.size(); i++) 763 { 764 int opt_pos = opt_element_vector[i].opt_pos; 765 int opt_arg_pos = opt_element_vector[i].opt_arg_pos; 766 int opt_defs_index = opt_element_vector[i].opt_defs_index; 767 if (opt_pos == cursor_index) 768 { 769 // We're completing the option itself. 770 771 if (opt_defs_index == OptionArgElement::eBareDash) 772 { 773 // We're completing a bare dash. That means all options are open. 774 // FIXME: We should scan the other options provided and only complete options 775 // within the option group they belong to. 776 char opt_str[3] = {'-', 'a', '\0'}; 777 778 for (int j = 0 ; opt_defs[j].short_option != 0 ; j++) 779 { 780 opt_str[1] = opt_defs[j].short_option; 781 matches.AppendString (opt_str); 782 } 783 return true; 784 } 785 else if (opt_defs_index == OptionArgElement::eBareDoubleDash) 786 { 787 std::string full_name ("--"); 788 for (int j = 0 ; opt_defs[j].short_option != 0 ; j++) 789 { 790 full_name.erase(full_name.begin() + 2, full_name.end()); 791 full_name.append (opt_defs[j].long_option); 792 matches.AppendString (full_name.c_str()); 793 } 794 return true; 795 } 796 else if (opt_defs_index != OptionArgElement::eUnrecognizedArg) 797 { 798 // We recognized it, if it an incomplete long option, complete it anyway (getopt_long_only is 799 // happy with shortest unique string, but it's still a nice thing to do.) Otherwise return 800 // The string so the upper level code will know this is a full match and add the " ". 801 if (cur_opt_str && strlen (cur_opt_str) > 2 802 && cur_opt_str[0] == '-' && cur_opt_str[1] == '-' 803 && strcmp (opt_defs[opt_defs_index].long_option, cur_opt_str) != 0) 804 { 805 std::string full_name ("--"); 806 full_name.append (opt_defs[opt_defs_index].long_option); 807 matches.AppendString(full_name.c_str()); 808 return true; 809 } 810 else 811 { 812 matches.AppendString(input.GetArgumentAtIndex(cursor_index)); 813 return true; 814 } 815 } 816 else 817 { 818 // FIXME - not handling wrong options yet: 819 // Check to see if they are writing a long option & complete it. 820 // I think we will only get in here if the long option table has two elements 821 // that are not unique up to this point. getopt_long_only does shortest unique match 822 // for long options already. 823 824 if (cur_opt_str && strlen (cur_opt_str) > 2 825 && cur_opt_str[0] == '-' && cur_opt_str[1] == '-') 826 { 827 for (int j = 0 ; opt_defs[j].short_option != 0 ; j++) 828 { 829 if (strstr(opt_defs[j].long_option, cur_opt_str + 2) == opt_defs[j].long_option) 830 { 831 std::string full_name ("--"); 832 full_name.append (opt_defs[j].long_option); 833 // The options definitions table has duplicates because of the 834 // way the grouping information is stored, so only add once. 835 bool duplicate = false; 836 for (size_t k = 0; k < matches.GetSize(); k++) 837 { 838 if (matches.GetStringAtIndex(k) == full_name) 839 { 840 duplicate = true; 841 break; 842 } 843 } 844 if (!duplicate) 845 matches.AppendString(full_name.c_str()); 846 } 847 } 848 } 849 return true; 850 } 851 852 853 } 854 else if (opt_arg_pos == cursor_index) 855 { 856 // Okay the cursor is on the completion of an argument. 857 // See if it has a completion, otherwise return no matches. 858 859 if (opt_defs_index != -1) 860 { 861 HandleOptionArgumentCompletion (input, 862 cursor_index, 863 strlen (input.GetArgumentAtIndex(cursor_index)), 864 opt_element_vector, 865 i, 866 match_start_point, 867 max_return_elements, 868 word_complete, 869 matches); 870 return true; 871 } 872 else 873 { 874 // No completion callback means no completions... 875 return true; 876 } 877 878 } 879 else 880 { 881 // Not the last element, keep going. 882 continue; 883 } 884 } 885 return false; 886 } 887 888 bool 889 Options::HandleOptionArgumentCompletion 890 ( 891 Args &input, 892 int cursor_index, 893 int char_pos, 894 OptionElementVector &opt_element_vector, 895 int opt_element_index, 896 int match_start_point, 897 int max_return_elements, 898 bool &word_complete, 899 lldb_private::StringList &matches 900 ) 901 { 902 const OptionDefinition *opt_defs = GetDefinitions(); 903 std::unique_ptr<SearchFilter> filter_ap; 904 905 int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos; 906 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index; 907 908 // See if this is an enumeration type option, and if so complete it here: 909 910 OptionEnumValueElement *enum_values = opt_defs[opt_defs_index].enum_values; 911 if (enum_values != NULL) 912 { 913 bool return_value = false; 914 std::string match_string(input.GetArgumentAtIndex (opt_arg_pos), input.GetArgumentAtIndex (opt_arg_pos) + char_pos); 915 for (int i = 0; enum_values[i].string_value != NULL; i++) 916 { 917 if (strstr(enum_values[i].string_value, match_string.c_str()) == enum_values[i].string_value) 918 { 919 matches.AppendString (enum_values[i].string_value); 920 return_value = true; 921 } 922 } 923 return return_value; 924 } 925 926 // If this is a source file or symbol type completion, and there is a 927 // -shlib option somewhere in the supplied arguments, then make a search filter 928 // for that shared library. 929 // FIXME: Do we want to also have an "OptionType" so we don't have to match string names? 930 931 uint32_t completion_mask = opt_defs[opt_defs_index].completion_type; 932 933 if (completion_mask == 0) 934 { 935 lldb::CommandArgumentType option_arg_type = opt_defs[opt_defs_index].argument_type; 936 if (option_arg_type != eArgTypeNone) 937 { 938 CommandObject::ArgumentTableEntry *arg_entry = CommandObject::FindArgumentDataByType (opt_defs[opt_defs_index].argument_type); 939 if (arg_entry) 940 completion_mask = arg_entry->completion_type; 941 } 942 } 943 944 if (completion_mask & CommandCompletions::eSourceFileCompletion 945 || completion_mask & CommandCompletions::eSymbolCompletion) 946 { 947 for (size_t i = 0; i < opt_element_vector.size(); i++) 948 { 949 int cur_defs_index = opt_element_vector[i].opt_defs_index; 950 int cur_arg_pos = opt_element_vector[i].opt_arg_pos; 951 const char *cur_opt_name = opt_defs[cur_defs_index].long_option; 952 953 // If this is the "shlib" option and there was an argument provided, 954 // restrict it to that shared library. 955 if (strcmp(cur_opt_name, "shlib") == 0 && cur_arg_pos != -1) 956 { 957 const char *module_name = input.GetArgumentAtIndex(cur_arg_pos); 958 if (module_name) 959 { 960 FileSpec module_spec(module_name, false); 961 lldb::TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget(); 962 // Search filters require a target... 963 if (target_sp) 964 filter_ap.reset (new SearchFilterByModule (target_sp, module_spec)); 965 } 966 break; 967 } 968 } 969 } 970 971 return CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 972 completion_mask, 973 input.GetArgumentAtIndex (opt_arg_pos), 974 match_start_point, 975 max_return_elements, 976 filter_ap.get(), 977 word_complete, 978 matches); 979 980 } 981 982 983 void 984 OptionGroupOptions::Append (OptionGroup* group) 985 { 986 const OptionDefinition* group_option_defs = group->GetDefinitions (); 987 const uint32_t group_option_count = group->GetNumDefinitions(); 988 for (uint32_t i=0; i<group_option_count; ++i) 989 { 990 m_option_infos.push_back (OptionInfo (group, i)); 991 m_option_defs.push_back (group_option_defs[i]); 992 } 993 } 994 995 void 996 OptionGroupOptions::Append (OptionGroup* group, 997 uint32_t src_mask, 998 uint32_t dst_mask) 999 { 1000 const OptionDefinition* group_option_defs = group->GetDefinitions (); 1001 const uint32_t group_option_count = group->GetNumDefinitions(); 1002 for (uint32_t i=0; i<group_option_count; ++i) 1003 { 1004 if (group_option_defs[i].usage_mask & src_mask) 1005 { 1006 m_option_infos.push_back (OptionInfo (group, i)); 1007 m_option_defs.push_back (group_option_defs[i]); 1008 m_option_defs.back().usage_mask = dst_mask; 1009 } 1010 } 1011 } 1012 1013 void 1014 OptionGroupOptions::Finalize () 1015 { 1016 m_did_finalize = true; 1017 OptionDefinition empty_option_def = { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }; 1018 m_option_defs.push_back (empty_option_def); 1019 } 1020 1021 Error 1022 OptionGroupOptions::SetOptionValue (uint32_t option_idx, 1023 const char *option_value) 1024 { 1025 // After calling OptionGroupOptions::Append(...), you must finalize the groups 1026 // by calling OptionGroupOptions::Finlize() 1027 assert (m_did_finalize); 1028 assert (m_option_infos.size() + 1 == m_option_defs.size()); 1029 Error error; 1030 if (option_idx < m_option_infos.size()) 1031 { 1032 error = m_option_infos[option_idx].option_group->SetOptionValue (m_interpreter, 1033 m_option_infos[option_idx].option_index, 1034 option_value); 1035 1036 } 1037 else 1038 { 1039 error.SetErrorString ("invalid option index"); // Shouldn't happen... 1040 } 1041 return error; 1042 } 1043 1044 void 1045 OptionGroupOptions::OptionParsingStarting () 1046 { 1047 std::set<OptionGroup*> group_set; 1048 OptionInfos::iterator pos, end = m_option_infos.end(); 1049 for (pos = m_option_infos.begin(); pos != end; ++pos) 1050 { 1051 OptionGroup* group = pos->option_group; 1052 if (group_set.find(group) == group_set.end()) 1053 { 1054 group->OptionParsingStarting (m_interpreter); 1055 group_set.insert(group); 1056 } 1057 } 1058 } 1059 Error 1060 OptionGroupOptions::OptionParsingFinished () 1061 { 1062 std::set<OptionGroup*> group_set; 1063 Error error; 1064 OptionInfos::iterator pos, end = m_option_infos.end(); 1065 for (pos = m_option_infos.begin(); pos != end; ++pos) 1066 { 1067 OptionGroup* group = pos->option_group; 1068 if (group_set.find(group) == group_set.end()) 1069 { 1070 error = group->OptionParsingFinished (m_interpreter); 1071 group_set.insert(group); 1072 if (error.Fail()) 1073 return error; 1074 } 1075 } 1076 return error; 1077 } 1078
