1 //===-- CommandObject.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/CommandObject.h" 13 14 #include <string> 15 #include <map> 16 17 #include <getopt.h> 18 #include <stdlib.h> 19 #include <ctype.h> 20 21 #include "lldb/Core/Address.h" 22 #include "lldb/Core/ArchSpec.h" 23 #include "lldb/Interpreter/Options.h" 24 25 // These are for the Sourcename completers. 26 // FIXME: Make a separate file for the completers. 27 #include "lldb/Host/FileSpec.h" 28 #include "lldb/Core/FileSpecList.h" 29 #include "lldb/Target/Process.h" 30 #include "lldb/Target/Target.h" 31 32 #include "lldb/Interpreter/CommandInterpreter.h" 33 #include "lldb/Interpreter/CommandReturnObject.h" 34 #include "lldb/Interpreter/ScriptInterpreter.h" 35 #include "lldb/Interpreter/ScriptInterpreterPython.h" 36 37 using namespace lldb; 38 using namespace lldb_private; 39 40 //------------------------------------------------------------------------- 41 // CommandObject 42 //------------------------------------------------------------------------- 43 44 CommandObject::CommandObject 45 ( 46 CommandInterpreter &interpreter, 47 const char *name, 48 const char *help, 49 const char *syntax, 50 uint32_t flags 51 ) : 52 m_interpreter (interpreter), 53 m_cmd_name (name), 54 m_cmd_help_short (), 55 m_cmd_help_long (), 56 m_cmd_syntax (), 57 m_is_alias (false), 58 m_flags (flags), 59 m_arguments(), 60 m_command_override_callback (NULL), 61 m_command_override_baton (NULL) 62 { 63 if (help && help[0]) 64 m_cmd_help_short = help; 65 if (syntax && syntax[0]) 66 m_cmd_syntax = syntax; 67 } 68 69 CommandObject::~CommandObject () 70 { 71 } 72 73 const char * 74 CommandObject::GetHelp () 75 { 76 return m_cmd_help_short.c_str(); 77 } 78 79 const char * 80 CommandObject::GetHelpLong () 81 { 82 return m_cmd_help_long.c_str(); 83 } 84 85 const char * 86 CommandObject::GetSyntax () 87 { 88 if (m_cmd_syntax.length() == 0) 89 { 90 StreamString syntax_str; 91 syntax_str.Printf ("%s", GetCommandName()); 92 if (GetOptions() != NULL) 93 syntax_str.Printf (" <cmd-options>"); 94 if (m_arguments.size() > 0) 95 { 96 syntax_str.Printf (" "); 97 if (WantsRawCommandString() && GetOptions() && GetOptions()->NumCommandOptions()) 98 syntax_str.Printf("-- "); 99 GetFormattedCommandArguments (syntax_str); 100 } 101 m_cmd_syntax = syntax_str.GetData (); 102 } 103 104 return m_cmd_syntax.c_str(); 105 } 106 107 const char * 108 CommandObject::GetCommandName () 109 { 110 return m_cmd_name.c_str(); 111 } 112 113 void 114 CommandObject::SetCommandName (const char *name) 115 { 116 m_cmd_name = name; 117 } 118 119 void 120 CommandObject::SetHelp (const char *cstr) 121 { 122 m_cmd_help_short = cstr; 123 } 124 125 void 126 CommandObject::SetHelpLong (const char *cstr) 127 { 128 m_cmd_help_long = cstr; 129 } 130 131 void 132 CommandObject::SetHelpLong (std::string str) 133 { 134 m_cmd_help_long = str; 135 } 136 137 void 138 CommandObject::SetSyntax (const char *cstr) 139 { 140 m_cmd_syntax = cstr; 141 } 142 143 Options * 144 CommandObject::GetOptions () 145 { 146 // By default commands don't have options unless this virtual function 147 // is overridden by base classes. 148 return NULL; 149 } 150 151 bool 152 CommandObject::ParseOptions 153 ( 154 Args& args, 155 CommandReturnObject &result 156 ) 157 { 158 // See if the subclass has options? 159 Options *options = GetOptions(); 160 if (options != NULL) 161 { 162 Error error; 163 options->NotifyOptionParsingStarting(); 164 165 // ParseOptions calls getopt_long_only, which always skips the zero'th item in the array and starts at position 1, 166 // so we need to push a dummy value into position zero. 167 args.Unshift("dummy_string"); 168 error = args.ParseOptions (*options); 169 170 // The "dummy_string" will have already been removed by ParseOptions, 171 // so no need to remove it. 172 173 if (error.Success()) 174 error = options->NotifyOptionParsingFinished(); 175 176 if (error.Success()) 177 { 178 if (options->VerifyOptions (result)) 179 return true; 180 } 181 else 182 { 183 const char *error_cstr = error.AsCString(); 184 if (error_cstr) 185 { 186 // We got an error string, lets use that 187 result.AppendError(error_cstr); 188 } 189 else 190 { 191 // No error string, output the usage information into result 192 options->GenerateOptionUsage (result.GetErrorStream(), this); 193 } 194 } 195 result.SetStatus (eReturnStatusFailed); 196 return false; 197 } 198 return true; 199 } 200 201 202 203 bool 204 CommandObject::CheckRequirements (CommandReturnObject &result) 205 { 206 #ifdef LLDB_CONFIGURATION_DEBUG 207 // Nothing should be stored in m_exe_ctx between running commands as m_exe_ctx 208 // has shared pointers to the target, process, thread and frame and we don't 209 // want any CommandObject instances to keep any of these objects around 210 // longer than for a single command. Every command should call 211 // CommandObject::Cleanup() after it has completed 212 assert (m_exe_ctx.GetTargetPtr() == NULL); 213 assert (m_exe_ctx.GetProcessPtr() == NULL); 214 assert (m_exe_ctx.GetThreadPtr() == NULL); 215 assert (m_exe_ctx.GetFramePtr() == NULL); 216 #endif 217 218 // Lock down the interpreter's execution context prior to running the 219 // command so we guarantee the selected target, process, thread and frame 220 // can't go away during the execution 221 m_exe_ctx = m_interpreter.GetExecutionContext(); 222 223 const uint32_t flags = GetFlags().Get(); 224 if (flags & (eFlagRequiresTarget | 225 eFlagRequiresProcess | 226 eFlagRequiresThread | 227 eFlagRequiresFrame | 228 eFlagTryTargetAPILock )) 229 { 230 231 if ((flags & eFlagRequiresTarget) && !m_exe_ctx.HasTargetScope()) 232 { 233 result.AppendError (GetInvalidTargetDescription()); 234 return false; 235 } 236 237 if ((flags & eFlagRequiresProcess) && !m_exe_ctx.HasProcessScope()) 238 { 239 result.AppendError (GetInvalidProcessDescription()); 240 return false; 241 } 242 243 if ((flags & eFlagRequiresThread) && !m_exe_ctx.HasThreadScope()) 244 { 245 result.AppendError (GetInvalidThreadDescription()); 246 return false; 247 } 248 249 if ((flags & eFlagRequiresFrame) && !m_exe_ctx.HasFrameScope()) 250 { 251 result.AppendError (GetInvalidFrameDescription()); 252 return false; 253 } 254 255 if ((flags & eFlagRequiresRegContext) && (m_exe_ctx.GetRegisterContext() == NULL)) 256 { 257 result.AppendError (GetInvalidRegContextDescription()); 258 return false; 259 } 260 261 if (flags & eFlagTryTargetAPILock) 262 { 263 Target *target = m_exe_ctx.GetTargetPtr(); 264 if (target) 265 { 266 if (m_api_locker.TryLock (target->GetAPIMutex(), NULL) == false) 267 { 268 result.AppendError ("failed to get API lock"); 269 return false; 270 } 271 } 272 } 273 } 274 275 if (GetFlags().AnySet (CommandObject::eFlagProcessMustBeLaunched | CommandObject::eFlagProcessMustBePaused)) 276 { 277 Process *process = m_interpreter.GetExecutionContext().GetProcessPtr(); 278 if (process == NULL) 279 { 280 // A process that is not running is considered paused. 281 if (GetFlags().Test(CommandObject::eFlagProcessMustBeLaunched)) 282 { 283 result.AppendError ("Process must exist."); 284 result.SetStatus (eReturnStatusFailed); 285 return false; 286 } 287 } 288 else 289 { 290 StateType state = process->GetState(); 291 switch (state) 292 { 293 case eStateInvalid: 294 case eStateSuspended: 295 case eStateCrashed: 296 case eStateStopped: 297 break; 298 299 case eStateConnected: 300 case eStateAttaching: 301 case eStateLaunching: 302 case eStateDetached: 303 case eStateExited: 304 case eStateUnloaded: 305 if (GetFlags().Test(CommandObject::eFlagProcessMustBeLaunched)) 306 { 307 result.AppendError ("Process must be launched."); 308 result.SetStatus (eReturnStatusFailed); 309 return false; 310 } 311 break; 312 313 case eStateRunning: 314 case eStateStepping: 315 if (GetFlags().Test(CommandObject::eFlagProcessMustBePaused)) 316 { 317 result.AppendError ("Process is running. Use 'process interrupt' to pause execution."); 318 result.SetStatus (eReturnStatusFailed); 319 return false; 320 } 321 } 322 } 323 } 324 return true; 325 } 326 327 void 328 CommandObject::Cleanup () 329 { 330 m_exe_ctx.Clear(); 331 m_api_locker.Unlock(); 332 } 333 334 335 class CommandDictCommandPartialMatch 336 { 337 public: 338 CommandDictCommandPartialMatch (const char *match_str) 339 { 340 m_match_str = match_str; 341 } 342 bool operator() (const std::pair<std::string, lldb::CommandObjectSP> map_element) const 343 { 344 // A NULL or empty string matches everything. 345 if (m_match_str == NULL || *m_match_str == '\0') 346 return true; 347 348 return map_element.first.find (m_match_str, 0) == 0; 349 } 350 351 private: 352 const char *m_match_str; 353 }; 354 355 int 356 CommandObject::AddNamesMatchingPartialString (CommandObject::CommandMap &in_map, const char *cmd_str, 357 StringList &matches) 358 { 359 int number_added = 0; 360 CommandDictCommandPartialMatch matcher(cmd_str); 361 362 CommandObject::CommandMap::iterator matching_cmds = std::find_if (in_map.begin(), in_map.end(), matcher); 363 364 while (matching_cmds != in_map.end()) 365 { 366 ++number_added; 367 matches.AppendString((*matching_cmds).first.c_str()); 368 matching_cmds = std::find_if (++matching_cmds, in_map.end(), matcher);; 369 } 370 return number_added; 371 } 372 373 int 374 CommandObject::HandleCompletion 375 ( 376 Args &input, 377 int &cursor_index, 378 int &cursor_char_position, 379 int match_start_point, 380 int max_return_elements, 381 bool &word_complete, 382 StringList &matches 383 ) 384 { 385 // Default implmentation of WantsCompletion() is !WantsRawCommandString(). 386 // Subclasses who want raw command string but desire, for example, 387 // argument completion should override WantsCompletion() to return true, 388 // instead. 389 if (WantsRawCommandString() && !WantsCompletion()) 390 { 391 // FIXME: Abstract telling the completion to insert the completion character. 392 matches.Clear(); 393 return -1; 394 } 395 else 396 { 397 // Can we do anything generic with the options? 398 Options *cur_options = GetOptions(); 399 CommandReturnObject result; 400 OptionElementVector opt_element_vector; 401 402 if (cur_options != NULL) 403 { 404 // Re-insert the dummy command name string which will have been 405 // stripped off: 406 input.Unshift ("dummy-string"); 407 cursor_index++; 408 409 410 // I stick an element on the end of the input, because if the last element is 411 // option that requires an argument, getopt_long_only will freak out. 412 413 input.AppendArgument ("<FAKE-VALUE>"); 414 415 input.ParseArgsForCompletion (*cur_options, opt_element_vector, cursor_index); 416 417 input.DeleteArgumentAtIndex(input.GetArgumentCount() - 1); 418 419 bool handled_by_options; 420 handled_by_options = cur_options->HandleOptionCompletion (input, 421 opt_element_vector, 422 cursor_index, 423 cursor_char_position, 424 match_start_point, 425 max_return_elements, 426 word_complete, 427 matches); 428 if (handled_by_options) 429 return matches.GetSize(); 430 } 431 432 // If we got here, the last word is not an option or an option argument. 433 return HandleArgumentCompletion (input, 434 cursor_index, 435 cursor_char_position, 436 opt_element_vector, 437 match_start_point, 438 max_return_elements, 439 word_complete, 440 matches); 441 } 442 } 443 444 bool 445 CommandObject::HelpTextContainsWord (const char *search_word) 446 { 447 std::string options_usage_help; 448 449 bool found_word = false; 450 451 const char *short_help = GetHelp(); 452 const char *long_help = GetHelpLong(); 453 const char *syntax_help = GetSyntax(); 454 455 if (short_help && strcasestr (short_help, search_word)) 456 found_word = true; 457 else if (long_help && strcasestr (long_help, search_word)) 458 found_word = true; 459 else if (syntax_help && strcasestr (syntax_help, search_word)) 460 found_word = true; 461 462 if (!found_word 463 && GetOptions() != NULL) 464 { 465 StreamString usage_help; 466 GetOptions()->GenerateOptionUsage (usage_help, this); 467 if (usage_help.GetSize() > 0) 468 { 469 const char *usage_text = usage_help.GetData(); 470 if (strcasestr (usage_text, search_word)) 471 found_word = true; 472 } 473 } 474 475 return found_word; 476 } 477 478 int 479 CommandObject::GetNumArgumentEntries () 480 { 481 return m_arguments.size(); 482 } 483 484 CommandObject::CommandArgumentEntry * 485 CommandObject::GetArgumentEntryAtIndex (int idx) 486 { 487 if (idx < m_arguments.size()) 488 return &(m_arguments[idx]); 489 490 return NULL; 491 } 492 493 CommandObject::ArgumentTableEntry * 494 CommandObject::FindArgumentDataByType (CommandArgumentType arg_type) 495 { 496 const ArgumentTableEntry *table = CommandObject::GetArgumentTable(); 497 498 for (int i = 0; i < eArgTypeLastArg; ++i) 499 if (table[i].arg_type == arg_type) 500 return (ArgumentTableEntry *) &(table[i]); 501 502 return NULL; 503 } 504 505 void 506 CommandObject::GetArgumentHelp (Stream &str, CommandArgumentType arg_type, CommandInterpreter &interpreter) 507 { 508 const ArgumentTableEntry* table = CommandObject::GetArgumentTable(); 509 ArgumentTableEntry *entry = (ArgumentTableEntry *) &(table[arg_type]); 510 511 // The table is *supposed* to be kept in arg_type order, but someone *could* have messed it up... 512 513 if (entry->arg_type != arg_type) 514 entry = CommandObject::FindArgumentDataByType (arg_type); 515 516 if (!entry) 517 return; 518 519 StreamString name_str; 520 name_str.Printf ("<%s>", entry->arg_name); 521 522 if (entry->help_function) 523 { 524 const char* help_text = entry->help_function(); 525 if (!entry->help_function.self_formatting) 526 { 527 interpreter.OutputFormattedHelpText (str, name_str.GetData(), "--", help_text, 528 name_str.GetSize()); 529 } 530 else 531 { 532 interpreter.OutputHelpText(str, name_str.GetData(), "--", help_text, 533 name_str.GetSize()); 534 } 535 } 536 else 537 interpreter.OutputFormattedHelpText (str, name_str.GetData(), "--", entry->help_text, name_str.GetSize()); 538 } 539 540 const char * 541 CommandObject::GetArgumentName (CommandArgumentType arg_type) 542 { 543 ArgumentTableEntry *entry = (ArgumentTableEntry *) &(CommandObject::GetArgumentTable()[arg_type]); 544 545 // The table is *supposed* to be kept in arg_type order, but someone *could* have messed it up... 546 547 if (entry->arg_type != arg_type) 548 entry = CommandObject::FindArgumentDataByType (arg_type); 549 550 if (entry) 551 return entry->arg_name; 552 553 StreamString str; 554 str << "Arg name for type (" << arg_type << ") not in arg table!"; 555 return str.GetData(); 556 } 557 558 bool 559 CommandObject::IsPairType (ArgumentRepetitionType arg_repeat_type) 560 { 561 if ((arg_repeat_type == eArgRepeatPairPlain) 562 || (arg_repeat_type == eArgRepeatPairOptional) 563 || (arg_repeat_type == eArgRepeatPairPlus) 564 || (arg_repeat_type == eArgRepeatPairStar) 565 || (arg_repeat_type == eArgRepeatPairRange) 566 || (arg_repeat_type == eArgRepeatPairRangeOptional)) 567 return true; 568 569 return false; 570 } 571 572 static CommandObject::CommandArgumentEntry 573 OptSetFiltered(uint32_t opt_set_mask, CommandObject::CommandArgumentEntry &cmd_arg_entry) 574 { 575 CommandObject::CommandArgumentEntry ret_val; 576 for (unsigned i = 0; i < cmd_arg_entry.size(); ++i) 577 if (opt_set_mask & cmd_arg_entry[i].arg_opt_set_association) 578 ret_val.push_back(cmd_arg_entry[i]); 579 return ret_val; 580 } 581 582 // Default parameter value of opt_set_mask is LLDB_OPT_SET_ALL, which means take 583 // all the argument data into account. On rare cases where some argument sticks 584 // with certain option sets, this function returns the option set filtered args. 585 void 586 CommandObject::GetFormattedCommandArguments (Stream &str, uint32_t opt_set_mask) 587 { 588 int num_args = m_arguments.size(); 589 for (int i = 0; i < num_args; ++i) 590 { 591 if (i > 0) 592 str.Printf (" "); 593 CommandArgumentEntry arg_entry = 594 opt_set_mask == LLDB_OPT_SET_ALL ? m_arguments[i] 595 : OptSetFiltered(opt_set_mask, m_arguments[i]); 596 int num_alternatives = arg_entry.size(); 597 598 if ((num_alternatives == 2) 599 && IsPairType (arg_entry[0].arg_repetition)) 600 { 601 const char *first_name = GetArgumentName (arg_entry[0].arg_type); 602 const char *second_name = GetArgumentName (arg_entry[1].arg_type); 603 switch (arg_entry[0].arg_repetition) 604 { 605 case eArgRepeatPairPlain: 606 str.Printf ("<%s> <%s>", first_name, second_name); 607 break; 608 case eArgRepeatPairOptional: 609 str.Printf ("[<%s> <%s>]", first_name, second_name); 610 break; 611 case eArgRepeatPairPlus: 612 str.Printf ("<%s> <%s> [<%s> <%s> [...]]", first_name, second_name, first_name, second_name); 613 break; 614 case eArgRepeatPairStar: 615 str.Printf ("[<%s> <%s> [<%s> <%s> [...]]]", first_name, second_name, first_name, second_name); 616 break; 617 case eArgRepeatPairRange: 618 str.Printf ("<%s_1> <%s_1> ... <%s_n> <%s_n>", first_name, second_name, first_name, second_name); 619 break; 620 case eArgRepeatPairRangeOptional: 621 str.Printf ("[<%s_1> <%s_1> ... <%s_n> <%s_n>]", first_name, second_name, first_name, second_name); 622 break; 623 // Explicitly test for all the rest of the cases, so if new types get added we will notice the 624 // missing case statement(s). 625 case eArgRepeatPlain: 626 case eArgRepeatOptional: 627 case eArgRepeatPlus: 628 case eArgRepeatStar: 629 case eArgRepeatRange: 630 // These should not be reached, as they should fail the IsPairType test above. 631 break; 632 } 633 } 634 else 635 { 636 StreamString names; 637 for (int j = 0; j < num_alternatives; ++j) 638 { 639 if (j > 0) 640 names.Printf (" | "); 641 names.Printf ("%s", GetArgumentName (arg_entry[j].arg_type)); 642 } 643 switch (arg_entry[0].arg_repetition) 644 { 645 case eArgRepeatPlain: 646 str.Printf ("<%s>", names.GetData()); 647 break; 648 case eArgRepeatPlus: 649 str.Printf ("<%s> [<%s> [...]]", names.GetData(), names.GetData()); 650 break; 651 case eArgRepeatStar: 652 str.Printf ("[<%s> [<%s> [...]]]", names.GetData(), names.GetData()); 653 break; 654 case eArgRepeatOptional: 655 str.Printf ("[<%s>]", names.GetData()); 656 break; 657 case eArgRepeatRange: 658 str.Printf ("<%s_1> .. <%s_n>", names.GetData(), names.GetData()); 659 break; 660 // Explicitly test for all the rest of the cases, so if new types get added we will notice the 661 // missing case statement(s). 662 case eArgRepeatPairPlain: 663 case eArgRepeatPairOptional: 664 case eArgRepeatPairPlus: 665 case eArgRepeatPairStar: 666 case eArgRepeatPairRange: 667 case eArgRepeatPairRangeOptional: 668 // These should not be hit, as they should pass the IsPairType test above, and control should 669 // have gone into the other branch of the if statement. 670 break; 671 } 672 } 673 } 674 } 675 676 CommandArgumentType 677 CommandObject::LookupArgumentName (const char *arg_name) 678 { 679 CommandArgumentType return_type = eArgTypeLastArg; 680 681 std::string arg_name_str (arg_name); 682 size_t len = arg_name_str.length(); 683 if (arg_name[0] == '<' 684 && arg_name[len-1] == '>') 685 arg_name_str = arg_name_str.substr (1, len-2); 686 687 const ArgumentTableEntry *table = GetArgumentTable(); 688 for (int i = 0; i < eArgTypeLastArg; ++i) 689 if (arg_name_str.compare (table[i].arg_name) == 0) 690 return_type = g_arguments_data[i].arg_type; 691 692 return return_type; 693 } 694 695 static const char * 696 RegisterNameHelpTextCallback () 697 { 698 return "Register names can be specified using the architecture specific names. " 699 "They can also be specified using generic names. Not all generic entities have " 700 "registers backing them on all architectures. When they don't the generic name " 701 "will return an error.\n" 702 "The generic names defined in lldb are:\n" 703 "\n" 704 "pc - program counter register\n" 705 "ra - return address register\n" 706 "fp - frame pointer register\n" 707 "sp - stack pointer register\n" 708 "flags - the flags register\n" 709 "arg{1-6} - integer argument passing registers.\n"; 710 } 711 712 static const char * 713 BreakpointIDHelpTextCallback () 714 { 715 return "Breakpoint ID's consist major and minor numbers; the major number " 716 "corresponds to the single entity that was created with a 'breakpoint set' " 717 "command; the minor numbers correspond to all the locations that were actually " 718 "found/set based on the major breakpoint. A full breakpoint ID might look like " 719 "3.14, meaning the 14th location set for the 3rd breakpoint. You can specify " 720 "all the locations of a breakpoint by just indicating the major breakpoint " 721 "number. A valid breakpoint id consists either of just the major id number, " 722 "or the major number, a dot, and the location number (e.g. 3 or 3.2 could " 723 "both be valid breakpoint ids)."; 724 } 725 726 static const char * 727 BreakpointIDRangeHelpTextCallback () 728 { 729 return "A 'breakpoint id list' is a manner of specifying multiple breakpoints. " 730 "This can be done through several mechanisms. The easiest way is to just " 731 "enter a space-separated list of breakpoint ids. To specify all the " 732 "breakpoint locations under a major breakpoint, you can use the major " 733 "breakpoint number followed by '.*', eg. '5.*' means all the locations under " 734 "breakpoint 5. You can also indicate a range of breakpoints by using " 735 "<start-bp-id> - <end-bp-id>. The start-bp-id and end-bp-id for a range can " 736 "be any valid breakpoint ids. It is not legal, however, to specify a range " 737 "using specific locations that cross major breakpoint numbers. I.e. 3.2 - 3.7" 738 " is legal; 2 - 5 is legal; but 3.2 - 4.4 is not legal."; 739 } 740 741 static const char * 742 GDBFormatHelpTextCallback () 743 { 744 return "A GDB format consists of a repeat count, a format letter and a size letter. " 745 "The repeat count is optional and defaults to 1. The format letter is optional " 746 "and defaults to the previous format that was used. The size letter is optional " 747 "and defaults to the previous size that was used.\n" 748 "\n" 749 "Format letters include:\n" 750 "o - octal\n" 751 "x - hexadecimal\n" 752 "d - decimal\n" 753 "u - unsigned decimal\n" 754 "t - binary\n" 755 "f - float\n" 756 "a - address\n" 757 "i - instruction\n" 758 "c - char\n" 759 "s - string\n" 760 "T - OSType\n" 761 "A - float as hex\n" 762 "\n" 763 "Size letters include:\n" 764 "b - 1 byte (byte)\n" 765 "h - 2 bytes (halfword)\n" 766 "w - 4 bytes (word)\n" 767 "g - 8 bytes (giant)\n" 768 "\n" 769 "Example formats:\n" 770 "32xb - show 32 1 byte hexadecimal integer values\n" 771 "16xh - show 16 2 byte hexadecimal integer values\n" 772 "64 - show 64 2 byte hexadecimal integer values (format and size from the last format)\n" 773 "dw - show 1 4 byte decimal integer value\n" 774 ; 775 } 776 777 static const char * 778 FormatHelpTextCallback () 779 { 780 781 static char* help_text_ptr = NULL; 782 783 if (help_text_ptr) 784 return help_text_ptr; 785 786 StreamString sstr; 787 sstr << "One of the format names (or one-character names) that can be used to show a variable's value:\n"; 788 for (Format f = eFormatDefault; f < kNumFormats; f = Format(f+1)) 789 { 790 if (f != eFormatDefault) 791 sstr.PutChar('\n'); 792 793 char format_char = FormatManager::GetFormatAsFormatChar(f); 794 if (format_char) 795 sstr.Printf("'%c' or ", format_char); 796 797 sstr.Printf ("\"%s\"", FormatManager::GetFormatAsCString(f)); 798 } 799 800 sstr.Flush(); 801 802 std::string data = sstr.GetString(); 803 804 help_text_ptr = new char[data.length()+1]; 805 806 data.copy(help_text_ptr, data.length()); 807 808 return help_text_ptr; 809 } 810 811 static const char * 812 LanguageTypeHelpTextCallback () 813 { 814 static char* help_text_ptr = NULL; 815 816 if (help_text_ptr) 817 return help_text_ptr; 818 819 StreamString sstr; 820 sstr << "One of the following languages:\n"; 821 822 for (unsigned int l = eLanguageTypeUnknown; l < eNumLanguageTypes; ++l) 823 { 824 sstr << " " << LanguageRuntime::GetNameForLanguageType(static_cast<LanguageType>(l)) << "\n"; 825 } 826 827 sstr.Flush(); 828 829 std::string data = sstr.GetString(); 830 831 help_text_ptr = new char[data.length()+1]; 832 833 data.copy(help_text_ptr, data.length()); 834 835 return help_text_ptr; 836 } 837 838 static const char * 839 SummaryStringHelpTextCallback() 840 { 841 return 842 "A summary string is a way to extract information from variables in order to present them using a summary.\n" 843 "Summary strings contain static text, variables, scopes and control sequences:\n" 844 " - Static text can be any sequence of non-special characters, i.e. anything but '{', '}', '$', or '\\'.\n" 845 " - Variables are sequences of characters beginning with ${, ending with } and that contain symbols in the format described below.\n" 846 " - Scopes are any sequence of text between { and }. Anything included in a scope will only appear in the output summary if there were no errors.\n" 847 " - Control sequences are the usual C/C++ '\\a', '\\n', ..., plus '\\$', '\\{' and '\\}'.\n" 848 "A summary string works by copying static text verbatim, turning control sequences into their character counterpart, expanding variables and trying to expand scopes.\n" 849 "A variable is expanded by giving it a value other than its textual representation, and the way this is done depends on what comes after the ${ marker.\n" 850 "The most common sequence if ${var followed by an expression path, which is the text one would type to access a member of an aggregate types, given a variable of that type" 851 " (e.g. if type T has a member named x, which has a member named y, and if t is of type T, the expression path would be .x.y and the way to fit that into a summary string would be" 852 " ${var.x.y}). You can also use ${*var followed by an expression path and in that case the object referred by the path will be dereferenced before being displayed." 853 " If the object is not a pointer, doing so will cause an error. For additional details on expression paths, you can type 'help expr-path'. \n" 854 "By default, summary strings attempt to display the summary for any variable they reference, and if that fails the value. If neither can be shown, nothing is displayed." 855 "In a summary string, you can also use an array index [n], or a slice-like range [n-m]. This can have two different meanings depending on what kind of object the expression" 856 " path refers to:\n" 857 " - if it is a scalar type (any basic type like int, float, ...) the expression is a bitfield, i.e. the bits indicated by the indexing operator are extracted out of the number" 858 " and displayed as an individual variable\n" 859 " - if it is an array or pointer the array items indicated by the indexing operator are shown as the result of the variable. if the expression is an array, real array items are" 860 " printed; if it is a pointer, the pointer-as-array syntax is used to obtain the values (this means, the latter case can have no range checking)\n" 861 "If you are trying to display an array for which the size is known, you can also use [] instead of giving an exact range. This has the effect of showing items 0 thru size - 1.\n" 862 "Additionally, a variable can contain an (optional) format code, as in ${var.x.y%code}, where code can be any of the valid formats described in 'help format', or one of the" 863 " special symbols only allowed as part of a variable:\n" 864 " %V: show the value of the object by default\n" 865 " %S: show the summary of the object by default\n" 866 " %@: show the runtime-provided object description (for Objective-C, it calls NSPrintForDebugger; for C/C++ it does nothing)\n" 867 " %L: show the location of the object (memory address or a register name)\n" 868 " %#: show the number of children of the object\n" 869 " %T: show the type of the object\n" 870 "Another variable that you can use in summary strings is ${svar . This sequence works exactly like ${var, including the fact that ${*svar is an allowed sequence, but uses" 871 " the object's synthetic children provider instead of the actual objects. For instance, if you are using STL synthetic children providers, the following summary string would" 872 " count the number of actual elements stored in an std::list:\n" 873 "type summary add -s \"${svar%#}\" -x \"std::list<\""; 874 } 875 876 static const char * 877 ExprPathHelpTextCallback() 878 { 879 return 880 "An expression path is the sequence of symbols that is used in C/C++ to access a member variable of an aggregate object (class).\n" 881 "For instance, given a class:\n" 882 " class foo {\n" 883 " int a;\n" 884 " int b; .\n" 885 " foo* next;\n" 886 " };\n" 887 "the expression to read item b in the item pointed to by next for foo aFoo would be aFoo.next->b.\n" 888 "Given that aFoo could just be any object of type foo, the string '.next->b' is the expression path, because it can be attached to any foo instance to achieve the effect.\n" 889 "Expression paths in LLDB include dot (.) and arrow (->) operators, and most commands using expression paths have ways to also accept the star (*) operator.\n" 890 "The meaning of these operators is the same as the usual one given to them by the C/C++ standards.\n" 891 "LLDB also has support for indexing ([ ]) in expression paths, and extends the traditional meaning of the square brackets operator to allow bitfield extraction:\n" 892 "for objects of native types (int, float, char, ...) saying '[n-m]' as an expression path (where n and m are any positive integers, e.g. [3-5]) causes LLDB to extract" 893 " bits n thru m from the value of the variable. If n == m, [n] is also allowed as a shortcut syntax. For arrays and pointers, expression paths can only contain one index" 894 " and the meaning of the operation is the same as the one defined by C/C++ (item extraction). Some commands extend bitfield-like syntax for arrays and pointers with the" 895 " meaning of array slicing (taking elements n thru m inside the array or pointed-to memory)."; 896 } 897 898 void 899 CommandObject::GenerateHelpText (CommandReturnObject &result) 900 { 901 GenerateHelpText(result.GetOutputStream()); 902 903 result.SetStatus (eReturnStatusSuccessFinishNoResult); 904 } 905 906 void 907 CommandObject::GenerateHelpText (Stream &output_strm) 908 { 909 CommandInterpreter& interpreter = GetCommandInterpreter(); 910 if (GetOptions() != NULL) 911 { 912 if (WantsRawCommandString()) 913 { 914 std::string help_text (GetHelp()); 915 help_text.append (" This command takes 'raw' input (no need to quote stuff)."); 916 interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1); 917 } 918 else 919 interpreter.OutputFormattedHelpText (output_strm, "", "", GetHelp(), 1); 920 output_strm.Printf ("\nSyntax: %s\n", GetSyntax()); 921 GetOptions()->GenerateOptionUsage (output_strm, this); 922 const char *long_help = GetHelpLong(); 923 if ((long_help != NULL) 924 && (strlen (long_help) > 0)) 925 output_strm.Printf ("\n%s", long_help); 926 if (WantsRawCommandString() && !WantsCompletion()) 927 { 928 // Emit the message about using ' -- ' between the end of the command options and the raw input 929 // conditionally, i.e., only if the command object does not want completion. 930 interpreter.OutputFormattedHelpText (output_strm, "", "", 931 "\nIMPORTANT NOTE: Because this command takes 'raw' input, if you use any command options" 932 " you must use ' -- ' between the end of the command options and the beginning of the raw input.", 1); 933 } 934 else if (GetNumArgumentEntries() > 0 935 && GetOptions() 936 && GetOptions()->NumCommandOptions() > 0) 937 { 938 // Also emit a warning about using "--" in case you are using a command that takes options and arguments. 939 interpreter.OutputFormattedHelpText (output_strm, "", "", 940 "\nThis command takes options and free-form arguments. If your arguments resemble" 941 " option specifiers (i.e., they start with a - or --), you must use ' -- ' between" 942 " the end of the command options and the beginning of the arguments.", 1); 943 } 944 } 945 else if (IsMultiwordObject()) 946 { 947 if (WantsRawCommandString()) 948 { 949 std::string help_text (GetHelp()); 950 help_text.append (" This command takes 'raw' input (no need to quote stuff)."); 951 interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1); 952 } 953 else 954 interpreter.OutputFormattedHelpText (output_strm, "", "", GetHelp(), 1); 955 GenerateHelpText (output_strm); 956 } 957 else 958 { 959 const char *long_help = GetHelpLong(); 960 if ((long_help != NULL) 961 && (strlen (long_help) > 0)) 962 output_strm.Printf ("%s", long_help); 963 else if (WantsRawCommandString()) 964 { 965 std::string help_text (GetHelp()); 966 help_text.append (" This command takes 'raw' input (no need to quote stuff)."); 967 interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1); 968 } 969 else 970 interpreter.OutputFormattedHelpText (output_strm, "", "", GetHelp(), 1); 971 output_strm.Printf ("\nSyntax: %s\n", GetSyntax()); 972 } 973 } 974 975 void 976 CommandObject::AddIDsArgumentData(CommandArgumentEntry &arg, CommandArgumentType ID, CommandArgumentType IDRange) 977 { 978 CommandArgumentData id_arg; 979 CommandArgumentData id_range_arg; 980 981 // Create the first variant for the first (and only) argument for this command. 982 id_arg.arg_type = ID; 983 id_arg.arg_repetition = eArgRepeatOptional; 984 985 // Create the second variant for the first (and only) argument for this command. 986 id_range_arg.arg_type = IDRange; 987 id_range_arg.arg_repetition = eArgRepeatOptional; 988 989 // The first (and only) argument for this command could be either an id or an id_range. 990 // Push both variants into the entry for the first argument for this command. 991 arg.push_back(id_arg); 992 arg.push_back(id_range_arg); 993 } 994 995 const char * 996 CommandObject::GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type) 997 { 998 if (arg_type >=0 && arg_type < eArgTypeLastArg) 999 return g_arguments_data[arg_type].arg_name; 1000 return NULL; 1001 1002 } 1003 1004 const char * 1005 CommandObject::GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type) 1006 { 1007 if (arg_type >=0 && arg_type < eArgTypeLastArg) 1008 return g_arguments_data[arg_type].help_text; 1009 return NULL; 1010 } 1011 1012 bool 1013 CommandObjectParsed::Execute (const char *args_string, CommandReturnObject &result) 1014 { 1015 CommandOverrideCallback command_callback = GetOverrideCallback(); 1016 bool handled = false; 1017 Args cmd_args (args_string); 1018 if (command_callback) 1019 { 1020 Args full_args (GetCommandName ()); 1021 full_args.AppendArguments(cmd_args); 1022 handled = command_callback (GetOverrideCallbackBaton(), full_args.GetConstArgumentVector()); 1023 } 1024 if (!handled) 1025 { 1026 for (size_t i = 0; i < cmd_args.GetArgumentCount(); ++i) 1027 { 1028 const char *tmp_str = cmd_args.GetArgumentAtIndex (i); 1029 if (tmp_str[0] == '`') // back-quote 1030 cmd_args.ReplaceArgumentAtIndex (i, m_interpreter.ProcessEmbeddedScriptCommands (tmp_str)); 1031 } 1032 1033 if (CheckRequirements(result)) 1034 { 1035 if (ParseOptions (cmd_args, result)) 1036 { 1037 // Call the command-specific version of 'Execute', passing it the already processed arguments. 1038 handled = DoExecute (cmd_args, result); 1039 } 1040 } 1041 1042 Cleanup(); 1043 } 1044 return handled; 1045 } 1046 1047 bool 1048 CommandObjectRaw::Execute (const char *args_string, CommandReturnObject &result) 1049 { 1050 CommandOverrideCallback command_callback = GetOverrideCallback(); 1051 bool handled = false; 1052 if (command_callback) 1053 { 1054 std::string full_command (GetCommandName ()); 1055 full_command += ' '; 1056 full_command += args_string; 1057 const char *argv[2] = { NULL, NULL }; 1058 argv[0] = full_command.c_str(); 1059 handled = command_callback (GetOverrideCallbackBaton(), argv); 1060 } 1061 if (!handled) 1062 { 1063 if (CheckRequirements(result)) 1064 handled = DoExecute (args_string, result); 1065 1066 Cleanup(); 1067 } 1068 return handled; 1069 } 1070 1071 static 1072 const char *arch_helper() 1073 { 1074 static StreamString g_archs_help; 1075 if (g_archs_help.Empty()) 1076 { 1077 StringList archs; 1078 ArchSpec::AutoComplete(NULL, archs); 1079 g_archs_help.Printf("These are the supported architecture names:\n"); 1080 archs.Join("\n", g_archs_help); 1081 } 1082 return g_archs_help.GetData(); 1083 } 1084 1085 CommandObject::ArgumentTableEntry 1086 CommandObject::g_arguments_data[] = 1087 { 1088 { eArgTypeAddress, "address", CommandCompletions::eNoCompletion, { NULL, false }, "A valid address in the target program's execution space." }, 1089 { eArgTypeAddressOrExpression, "address-expression", CommandCompletions::eNoCompletion, { NULL, false }, "An expression that resolves to an address." }, 1090 { eArgTypeAliasName, "alias-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of an abbreviation (alias) for a debugger command." }, 1091 { eArgTypeAliasOptions, "options-for-aliased-command", CommandCompletions::eNoCompletion, { NULL, false }, "Command options to be used as part of an alias (abbreviation) definition. (See 'help commands alias' for more information.)" }, 1092 { eArgTypeArchitecture, "arch", CommandCompletions::eArchitectureCompletion, { arch_helper, true }, "The architecture name, e.g. i386 or x86_64." }, 1093 { eArgTypeBoolean, "boolean", CommandCompletions::eNoCompletion, { NULL, false }, "A Boolean value: 'true' or 'false'" }, 1094 { eArgTypeBreakpointID, "breakpt-id", CommandCompletions::eNoCompletion, { BreakpointIDHelpTextCallback, false }, NULL }, 1095 { eArgTypeBreakpointIDRange, "breakpt-id-list", CommandCompletions::eNoCompletion, { BreakpointIDRangeHelpTextCallback, false }, NULL }, 1096 { eArgTypeByteSize, "byte-size", CommandCompletions::eNoCompletion, { NULL, false }, "Number of bytes to use." }, 1097 { eArgTypeClassName, "class-name", CommandCompletions::eNoCompletion, { NULL, false }, "Then name of a class from the debug information in the program." }, 1098 { eArgTypeCommandName, "cmd-name", CommandCompletions::eNoCompletion, { NULL, false }, "A debugger command (may be multiple words), without any options or arguments." }, 1099 { eArgTypeCount, "count", CommandCompletions::eNoCompletion, { NULL, false }, "An unsigned integer." }, 1100 { eArgTypeDirectoryName, "directory", CommandCompletions::eDiskDirectoryCompletion, { NULL, false }, "A directory name." }, 1101 { eArgTypeDisassemblyFlavor, "disassembly-flavor", CommandCompletions::eNoCompletion, { NULL, false }, "A disassembly flavor recognized by your disassembly plugin. Currently the only valid options are \"att\" and \"intel\" for Intel targets" }, 1102 { eArgTypeEndAddress, "end-address", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1103 { eArgTypeExpression, "expr", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1104 { eArgTypeExpressionPath, "expr-path", CommandCompletions::eNoCompletion, { ExprPathHelpTextCallback, true }, NULL }, 1105 { eArgTypeExprFormat, "expression-format", CommandCompletions::eNoCompletion, { NULL, false }, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]" }, 1106 { eArgTypeFilename, "filename", CommandCompletions::eDiskFileCompletion, { NULL, false }, "The name of a file (can include path)." }, 1107 { eArgTypeFormat, "format", CommandCompletions::eNoCompletion, { FormatHelpTextCallback, true }, NULL }, 1108 { eArgTypeFrameIndex, "frame-index", CommandCompletions::eNoCompletion, { NULL, false }, "Index into a thread's list of frames." }, 1109 { eArgTypeFullName, "fullname", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1110 { eArgTypeFunctionName, "function-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a function." }, 1111 { eArgTypeFunctionOrSymbol, "function-or-symbol", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a function or symbol." }, 1112 { eArgTypeGDBFormat, "gdb-format", CommandCompletions::eNoCompletion, { GDBFormatHelpTextCallback, true }, NULL }, 1113 { eArgTypeIndex, "index", CommandCompletions::eNoCompletion, { NULL, false }, "An index into a list." }, 1114 { eArgTypeLanguage, "language", CommandCompletions::eNoCompletion, { LanguageTypeHelpTextCallback, true }, NULL }, 1115 { eArgTypeLineNum, "linenum", CommandCompletions::eNoCompletion, { NULL, false }, "Line number in a source file." }, 1116 { eArgTypeLogCategory, "log-category", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a category within a log channel, e.g. all (try \"log list\" to see a list of all channels and their categories." }, 1117 { eArgTypeLogChannel, "log-channel", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a log channel, e.g. process.gdb-remote (try \"log list\" to see a list of all channels and their categories)." }, 1118 { eArgTypeMethod, "method", CommandCompletions::eNoCompletion, { NULL, false }, "A C++ method name." }, 1119 { eArgTypeName, "name", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1120 { eArgTypeNewPathPrefix, "new-path-prefix", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1121 { eArgTypeNumLines, "num-lines", CommandCompletions::eNoCompletion, { NULL, false }, "The number of lines to use." }, 1122 { eArgTypeNumberPerLine, "number-per-line", CommandCompletions::eNoCompletion, { NULL, false }, "The number of items per line to display." }, 1123 { eArgTypeOffset, "offset", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1124 { eArgTypeOldPathPrefix, "old-path-prefix", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1125 { eArgTypeOneLiner, "one-line-command", CommandCompletions::eNoCompletion, { NULL, false }, "A command that is entered as a single line of text." }, 1126 { eArgTypePid, "pid", CommandCompletions::eNoCompletion, { NULL, false }, "The process ID number." }, 1127 { eArgTypePlugin, "plugin", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1128 { eArgTypeProcessName, "process-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of the process." }, 1129 { eArgTypePythonClass, "python-class", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a Python class." }, 1130 { eArgTypePythonFunction, "python-function", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a Python function." }, 1131 { eArgTypePythonScript, "python-script", CommandCompletions::eNoCompletion, { NULL, false }, "Source code written in Python." }, 1132 { eArgTypeQueueName, "queue-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of the thread queue." }, 1133 { eArgTypeRegisterName, "register-name", CommandCompletions::eNoCompletion, { RegisterNameHelpTextCallback, true }, NULL }, 1134 { eArgTypeRegularExpression, "regular-expression", CommandCompletions::eNoCompletion, { NULL, false }, "A regular expression." }, 1135 { eArgTypeRunArgs, "run-args", CommandCompletions::eNoCompletion, { NULL, false }, "Arguments to be passed to the target program when it starts executing." }, 1136 { eArgTypeRunMode, "run-mode", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1137 { eArgTypeScriptedCommandSynchronicity, "script-cmd-synchronicity", CommandCompletions::eNoCompletion, { NULL, false }, "The synchronicity to use to run scripted commands with regard to LLDB event system." }, 1138 { eArgTypeScriptLang, "script-language", CommandCompletions::eNoCompletion, { NULL, false }, "The scripting language to be used for script-based commands. Currently only Python is valid." }, 1139 { eArgTypeSearchWord, "search-word", CommandCompletions::eNoCompletion, { NULL, false }, "The word for which you wish to search for information about." }, 1140 { eArgTypeSelector, "selector", CommandCompletions::eNoCompletion, { NULL, false }, "An Objective-C selector name." }, 1141 { eArgTypeSettingIndex, "setting-index", CommandCompletions::eNoCompletion, { NULL, false }, "An index into a settings variable that is an array (try 'settings list' to see all the possible settings variables and their types)." }, 1142 { eArgTypeSettingKey, "setting-key", CommandCompletions::eNoCompletion, { NULL, false }, "A key into a settings variables that is a dictionary (try 'settings list' to see all the possible settings variables and their types)." }, 1143 { eArgTypeSettingPrefix, "setting-prefix", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a settable internal debugger variable up to a dot ('.'), e.g. 'target.process.'" }, 1144 { eArgTypeSettingVariableName, "setting-variable-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a settable internal debugger variable. Type 'settings list' to see a complete list of such variables." }, 1145 { eArgTypeShlibName, "shlib-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a shared library." }, 1146 { eArgTypeSourceFile, "source-file", CommandCompletions::eSourceFileCompletion, { NULL, false }, "The name of a source file.." }, 1147 { eArgTypeSortOrder, "sort-order", CommandCompletions::eNoCompletion, { NULL, false }, "Specify a sort order when dumping lists." }, 1148 { eArgTypeStartAddress, "start-address", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1149 { eArgTypeSummaryString, "summary-string", CommandCompletions::eNoCompletion, { SummaryStringHelpTextCallback, true }, NULL }, 1150 { eArgTypeSymbol, "symbol", CommandCompletions::eSymbolCompletion, { NULL, false }, "Any symbol name (function name, variable, argument, etc.)" }, 1151 { eArgTypeThreadID, "thread-id", CommandCompletions::eNoCompletion, { NULL, false }, "Thread ID number." }, 1152 { eArgTypeThreadIndex, "thread-index", CommandCompletions::eNoCompletion, { NULL, false }, "Index into the process' list of threads." }, 1153 { eArgTypeThreadName, "thread-name", CommandCompletions::eNoCompletion, { NULL, false }, "The thread's name." }, 1154 { eArgTypeUnsignedInteger, "unsigned-integer", CommandCompletions::eNoCompletion, { NULL, false }, "An unsigned integer." }, 1155 { eArgTypeUnixSignal, "unix-signal", CommandCompletions::eNoCompletion, { NULL, false }, "A valid Unix signal name or number (e.g. SIGKILL, KILL or 9)." }, 1156 { eArgTypeVarName, "variable-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a variable in your program." }, 1157 { eArgTypeValue, "value", CommandCompletions::eNoCompletion, { NULL, false }, "A value could be anything, depending on where and how it is used." }, 1158 { eArgTypeWidth, "width", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." }, 1159 { eArgTypeNone, "none", CommandCompletions::eNoCompletion, { NULL, false }, "No help available for this." }, 1160 { eArgTypePlatform, "platform-name", CommandCompletions::ePlatformPluginCompletion, { NULL, false }, "The name of an installed platform plug-in . Type 'platform list' to see a complete list of installed platforms." }, 1161 { eArgTypeWatchpointID, "watchpt-id", CommandCompletions::eNoCompletion, { NULL, false }, "Watchpoint IDs are positive integers." }, 1162 { eArgTypeWatchpointIDRange, "watchpt-id-list", CommandCompletions::eNoCompletion, { NULL, false }, "For example, '1-3' or '1 to 3'." }, 1163 { eArgTypeWatchType, "watch-type", CommandCompletions::eNoCompletion, { NULL, false }, "Specify the type for a watchpoint." } 1164 }; 1165 1166 const CommandObject::ArgumentTableEntry* 1167 CommandObject::GetArgumentTable () 1168 { 1169 // If this assertion fires, then the table above is out of date with the CommandArgumentType enumeration 1170 assert ((sizeof (CommandObject::g_arguments_data) / sizeof (CommandObject::ArgumentTableEntry)) == eArgTypeLastArg); 1171 return CommandObject::g_arguments_data; 1172 } 1173 1174 1175
