1 //===-- CommandObject.cpp -------------------------------------------------===// 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/CommandObject.h" 10 11 #include <map> 12 #include <sstream> 13 #include <string> 14 15 #include <cctype> 16 #include <cstdlib> 17 18 #include "lldb/Core/Address.h" 19 #include "lldb/Interpreter/CommandOptionArgumentTable.h" 20 #include "lldb/Interpreter/Options.h" 21 #include "lldb/Utility/ArchSpec.h" 22 #include "llvm/ADT/ScopeExit.h" 23 24 // These are for the Sourcename completers. 25 // FIXME: Make a separate file for the completers. 26 #include "lldb/DataFormatters/FormatManager.h" 27 #include "lldb/Target/Process.h" 28 #include "lldb/Target/Target.h" 29 #include "lldb/Utility/FileSpec.h" 30 #include "lldb/Utility/FileSpecList.h" 31 32 #include "lldb/Target/Language.h" 33 34 #include "lldb/Interpreter/CommandInterpreter.h" 35 #include "lldb/Interpreter/CommandOptionArgumentTable.h" 36 #include "lldb/Interpreter/CommandReturnObject.h" 37 38 using namespace lldb; 39 using namespace lldb_private; 40 41 // CommandObject 42 43 CommandObject::CommandObject(CommandInterpreter &interpreter, 44 llvm::StringRef name, llvm::StringRef help, 45 llvm::StringRef syntax, uint32_t flags) 46 : m_interpreter(interpreter), m_cmd_name(std::string(name)), 47 m_flags(flags), m_deprecated_command_override_callback(nullptr), 48 m_command_override_callback(nullptr), m_command_override_baton(nullptr) { 49 m_cmd_help_short = std::string(help); 50 m_cmd_syntax = std::string(syntax); 51 } 52 53 Debugger &CommandObject::GetDebugger() { return m_interpreter.GetDebugger(); } 54 55 llvm::StringRef CommandObject::GetHelp() { return m_cmd_help_short; } 56 57 llvm::StringRef CommandObject::GetHelpLong() { return m_cmd_help_long; } 58 59 llvm::StringRef CommandObject::GetSyntax() { 60 if (!m_cmd_syntax.empty()) 61 return m_cmd_syntax; 62 63 StreamString syntax_str; 64 syntax_str.PutCString(GetCommandName()); 65 66 if (!IsDashDashCommand() && GetOptions() != nullptr) 67 syntax_str.PutCString(" <cmd-options>"); 68 69 if (!m_arguments.empty()) { 70 syntax_str.PutCString(" "); 71 72 if (!IsDashDashCommand() && WantsRawCommandString() && GetOptions() && 73 GetOptions()->NumCommandOptions()) 74 syntax_str.PutCString("-- "); 75 GetFormattedCommandArguments(syntax_str); 76 } 77 m_cmd_syntax = std::string(syntax_str.GetString()); 78 79 return m_cmd_syntax; 80 } 81 82 llvm::StringRef CommandObject::GetCommandName() const { return m_cmd_name; } 83 84 void CommandObject::SetCommandName(llvm::StringRef name) { 85 m_cmd_name = std::string(name); 86 } 87 88 void CommandObject::SetHelp(llvm::StringRef str) { 89 m_cmd_help_short = std::string(str); 90 } 91 92 void CommandObject::SetHelpLong(llvm::StringRef str) { 93 m_cmd_help_long = std::string(str); 94 } 95 96 void CommandObject::SetSyntax(llvm::StringRef str) { 97 m_cmd_syntax = std::string(str); 98 } 99 100 Options *CommandObject::GetOptions() { 101 // By default commands don't have options unless this virtual function is 102 // overridden by base classes. 103 return nullptr; 104 } 105 106 bool CommandObject::ParseOptions(Args &args, CommandReturnObject &result) { 107 // See if the subclass has options? 108 Options *options = GetOptions(); 109 if (options != nullptr) { 110 Status error; 111 112 auto exe_ctx = GetCommandInterpreter().GetExecutionContext(); 113 options->NotifyOptionParsingStarting(&exe_ctx); 114 115 const bool require_validation = true; 116 llvm::Expected<Args> args_or = options->Parse( 117 args, &exe_ctx, GetCommandInterpreter().GetPlatform(true), 118 require_validation); 119 120 if (args_or) { 121 args = std::move(*args_or); 122 error = options->NotifyOptionParsingFinished(&exe_ctx); 123 } else 124 error = args_or.takeError(); 125 126 if (error.Success()) { 127 if (options->VerifyOptions(result)) 128 return true; 129 } else { 130 const char *error_cstr = error.AsCString(); 131 if (error_cstr) { 132 // We got an error string, lets use that 133 result.AppendError(error_cstr); 134 } else { 135 // No error string, output the usage information into result 136 options->GenerateOptionUsage( 137 result.GetErrorStream(), *this, 138 GetCommandInterpreter().GetDebugger().GetTerminalWidth()); 139 } 140 } 141 result.SetStatus(eReturnStatusFailed); 142 return false; 143 } 144 return true; 145 } 146 147 bool CommandObject::CheckRequirements(CommandReturnObject &result) { 148 // Nothing should be stored in m_exe_ctx between running commands as 149 // m_exe_ctx has shared pointers to the target, process, thread and frame and 150 // we don't want any CommandObject instances to keep any of these objects 151 // around longer than for a single command. Every command should call 152 // CommandObject::Cleanup() after it has completed. 153 assert(!m_exe_ctx.GetTargetPtr()); 154 assert(!m_exe_ctx.GetProcessPtr()); 155 assert(!m_exe_ctx.GetThreadPtr()); 156 assert(!m_exe_ctx.GetFramePtr()); 157 158 // Lock down the interpreter's execution context prior to running the command 159 // so we guarantee the selected target, process, thread and frame can't go 160 // away during the execution 161 m_exe_ctx = m_interpreter.GetExecutionContext(); 162 163 const uint32_t flags = GetFlags().Get(); 164 if (flags & (eCommandRequiresTarget | eCommandRequiresProcess | 165 eCommandRequiresThread | eCommandRequiresFrame | 166 eCommandTryTargetAPILock)) { 167 168 if ((flags & eCommandRequiresTarget) && !m_exe_ctx.HasTargetScope()) { 169 result.AppendError(GetInvalidTargetDescription()); 170 return false; 171 } 172 173 if ((flags & eCommandRequiresProcess) && !m_exe_ctx.HasProcessScope()) { 174 if (!m_exe_ctx.HasTargetScope()) 175 result.AppendError(GetInvalidTargetDescription()); 176 else 177 result.AppendError(GetInvalidProcessDescription()); 178 return false; 179 } 180 181 if ((flags & eCommandRequiresThread) && !m_exe_ctx.HasThreadScope()) { 182 if (!m_exe_ctx.HasTargetScope()) 183 result.AppendError(GetInvalidTargetDescription()); 184 else if (!m_exe_ctx.HasProcessScope()) 185 result.AppendError(GetInvalidProcessDescription()); 186 else 187 result.AppendError(GetInvalidThreadDescription()); 188 return false; 189 } 190 191 if ((flags & eCommandRequiresFrame) && !m_exe_ctx.HasFrameScope()) { 192 if (!m_exe_ctx.HasTargetScope()) 193 result.AppendError(GetInvalidTargetDescription()); 194 else if (!m_exe_ctx.HasProcessScope()) 195 result.AppendError(GetInvalidProcessDescription()); 196 else if (!m_exe_ctx.HasThreadScope()) 197 result.AppendError(GetInvalidThreadDescription()); 198 else 199 result.AppendError(GetInvalidFrameDescription()); 200 return false; 201 } 202 203 if ((flags & eCommandRequiresRegContext) && 204 (m_exe_ctx.GetRegisterContext() == nullptr)) { 205 result.AppendError(GetInvalidRegContextDescription()); 206 return false; 207 } 208 209 if (flags & eCommandTryTargetAPILock) { 210 Target *target = m_exe_ctx.GetTargetPtr(); 211 if (target) 212 m_api_locker = 213 std::unique_lock<std::recursive_mutex>(target->GetAPIMutex()); 214 } 215 } 216 217 if (GetFlags().AnySet(eCommandProcessMustBeLaunched | 218 eCommandProcessMustBePaused)) { 219 Process *process = m_interpreter.GetExecutionContext().GetProcessPtr(); 220 if (process == nullptr) { 221 // A process that is not running is considered paused. 222 if (GetFlags().Test(eCommandProcessMustBeLaunched)) { 223 result.AppendError("Process must exist."); 224 return false; 225 } 226 } else { 227 StateType state = process->GetState(); 228 switch (state) { 229 case eStateInvalid: 230 case eStateSuspended: 231 case eStateCrashed: 232 case eStateStopped: 233 break; 234 235 case eStateConnected: 236 case eStateAttaching: 237 case eStateLaunching: 238 case eStateDetached: 239 case eStateExited: 240 case eStateUnloaded: 241 if (GetFlags().Test(eCommandProcessMustBeLaunched)) { 242 result.AppendError("Process must be launched."); 243 return false; 244 } 245 break; 246 247 case eStateRunning: 248 case eStateStepping: 249 if (GetFlags().Test(eCommandProcessMustBePaused)) { 250 result.AppendError("Process is running. Use 'process interrupt' to " 251 "pause execution."); 252 return false; 253 } 254 } 255 } 256 } 257 258 if (GetFlags().Test(eCommandProcessMustBeTraced)) { 259 Target *target = m_exe_ctx.GetTargetPtr(); 260 if (target && !target->GetTrace()) { 261 result.AppendError("Process is not being traced."); 262 return false; 263 } 264 } 265 266 return true; 267 } 268 269 void CommandObject::Cleanup() { 270 m_exe_ctx.Clear(); 271 if (m_api_locker.owns_lock()) 272 m_api_locker.unlock(); 273 } 274 275 void CommandObject::HandleCompletion(CompletionRequest &request) { 276 277 m_exe_ctx = m_interpreter.GetExecutionContext(); 278 auto reset_ctx = llvm::make_scope_exit([this]() { Cleanup(); }); 279 280 // Default implementation of WantsCompletion() is !WantsRawCommandString(). 281 // Subclasses who want raw command string but desire, for example, argument 282 // completion should override WantsCompletion() to return true, instead. 283 if (WantsRawCommandString() && !WantsCompletion()) { 284 // FIXME: Abstract telling the completion to insert the completion 285 // character. 286 return; 287 } else { 288 // Can we do anything generic with the options? 289 Options *cur_options = GetOptions(); 290 CommandReturnObject result(m_interpreter.GetDebugger().GetUseColor()); 291 OptionElementVector opt_element_vector; 292 293 if (cur_options != nullptr) { 294 opt_element_vector = cur_options->ParseForCompletion( 295 request.GetParsedLine(), request.GetCursorIndex()); 296 297 bool handled_by_options = cur_options->HandleOptionCompletion( 298 request, opt_element_vector, GetCommandInterpreter()); 299 if (handled_by_options) 300 return; 301 } 302 303 // If we got here, the last word is not an option or an option argument. 304 HandleArgumentCompletion(request, opt_element_vector); 305 } 306 } 307 308 void CommandObject::HandleArgumentCompletion( 309 CompletionRequest &request, OptionElementVector &opt_element_vector) { 310 size_t num_arg_entries = GetNumArgumentEntries(); 311 if (num_arg_entries != 1) 312 return; 313 314 CommandArgumentEntry *entry_ptr = GetArgumentEntryAtIndex(0); 315 if (!entry_ptr) { 316 assert(entry_ptr && "We said there was one entry, but there wasn't."); 317 return; // Not worth crashing if asserts are off... 318 } 319 320 CommandArgumentEntry &entry = *entry_ptr; 321 // For now, we only handle the simple case of one homogenous argument type. 322 if (entry.size() != 1) 323 return; 324 325 // Look up the completion type, and if it has one, invoke it: 326 const CommandObject::ArgumentTableEntry *arg_entry = 327 FindArgumentDataByType(entry[0].arg_type); 328 const ArgumentRepetitionType repeat = entry[0].arg_repetition; 329 330 if (arg_entry == nullptr || arg_entry->completion_type == lldb::eNoCompletion) 331 return; 332 333 // FIXME: This should be handled higher in the Command Parser. 334 // Check the case where this command only takes one argument, and don't do 335 // the completion if we aren't on the first entry: 336 if (repeat == eArgRepeatPlain && request.GetCursorIndex() != 0) 337 return; 338 339 lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks( 340 GetCommandInterpreter(), arg_entry->completion_type, request, nullptr); 341 342 } 343 344 345 bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word, 346 bool search_short_help, 347 bool search_long_help, 348 bool search_syntax, 349 bool search_options) { 350 std::string options_usage_help; 351 352 bool found_word = false; 353 354 llvm::StringRef short_help = GetHelp(); 355 llvm::StringRef long_help = GetHelpLong(); 356 llvm::StringRef syntax_help = GetSyntax(); 357 358 if (search_short_help && short_help.contains_insensitive(search_word)) 359 found_word = true; 360 else if (search_long_help && long_help.contains_insensitive(search_word)) 361 found_word = true; 362 else if (search_syntax && syntax_help.contains_insensitive(search_word)) 363 found_word = true; 364 365 if (!found_word && search_options && GetOptions() != nullptr) { 366 StreamString usage_help; 367 GetOptions()->GenerateOptionUsage( 368 usage_help, *this, 369 GetCommandInterpreter().GetDebugger().GetTerminalWidth()); 370 if (!usage_help.Empty()) { 371 llvm::StringRef usage_text = usage_help.GetString(); 372 if (usage_text.contains_insensitive(search_word)) 373 found_word = true; 374 } 375 } 376 377 return found_word; 378 } 379 380 bool CommandObject::ParseOptionsAndNotify(Args &args, 381 CommandReturnObject &result, 382 OptionGroupOptions &group_options, 383 ExecutionContext &exe_ctx) { 384 if (!ParseOptions(args, result)) 385 return false; 386 387 Status error(group_options.NotifyOptionParsingFinished(&exe_ctx)); 388 if (error.Fail()) { 389 result.AppendError(error.AsCString()); 390 return false; 391 } 392 return true; 393 } 394 395 void CommandObject::AddSimpleArgumentList( 396 CommandArgumentType arg_type, ArgumentRepetitionType repetition_type) { 397 398 CommandArgumentEntry arg_entry; 399 CommandArgumentData simple_arg; 400 401 // Define the first (and only) variant of this arg. 402 simple_arg.arg_type = arg_type; 403 simple_arg.arg_repetition = repetition_type; 404 405 // There is only one variant this argument could be; put it into the argument 406 // entry. 407 arg_entry.push_back(simple_arg); 408 409 // Push the data for the first argument into the m_arguments vector. 410 m_arguments.push_back(arg_entry); 411 } 412 413 int CommandObject::GetNumArgumentEntries() { return m_arguments.size(); } 414 415 CommandObject::CommandArgumentEntry * 416 CommandObject::GetArgumentEntryAtIndex(int idx) { 417 if (static_cast<size_t>(idx) < m_arguments.size()) 418 return &(m_arguments[idx]); 419 420 return nullptr; 421 } 422 423 const CommandObject::ArgumentTableEntry * 424 CommandObject::FindArgumentDataByType(CommandArgumentType arg_type) { 425 for (int i = 0; i < eArgTypeLastArg; ++i) 426 if (g_argument_table[i].arg_type == arg_type) 427 return &(g_argument_table[i]); 428 429 return nullptr; 430 } 431 432 void CommandObject::GetArgumentHelp(Stream &str, CommandArgumentType arg_type, 433 CommandInterpreter &interpreter) { 434 const ArgumentTableEntry *entry = &(g_argument_table[arg_type]); 435 436 // The table is *supposed* to be kept in arg_type order, but someone *could* 437 // have messed it up... 438 439 if (entry->arg_type != arg_type) 440 entry = CommandObject::FindArgumentDataByType(arg_type); 441 442 if (!entry) 443 return; 444 445 StreamString name_str; 446 name_str.Printf("<%s>", entry->arg_name); 447 448 if (entry->help_function) { 449 llvm::StringRef help_text = entry->help_function(); 450 if (!entry->help_function.self_formatting) { 451 interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--", 452 help_text, name_str.GetSize()); 453 } else { 454 interpreter.OutputHelpText(str, name_str.GetString(), "--", help_text, 455 name_str.GetSize()); 456 } 457 } else { 458 interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--", 459 entry->help_text, name_str.GetSize()); 460 461 // Print enum values and their description if any. 462 OptionEnumValues enum_values = g_argument_table[arg_type].enum_values; 463 if (!enum_values.empty()) { 464 str.EOL(); 465 size_t longest = 0; 466 for (const OptionEnumValueElement &element : enum_values) 467 longest = 468 std::max(longest, llvm::StringRef(element.string_value).size()); 469 str.IndentMore(5); 470 for (const OptionEnumValueElement &element : enum_values) { 471 str.Indent(); 472 interpreter.OutputHelpText(str, element.string_value, ":", 473 element.usage, longest); 474 } 475 str.IndentLess(5); 476 str.EOL(); 477 } 478 } 479 } 480 481 const char *CommandObject::GetArgumentName(CommandArgumentType arg_type) { 482 const ArgumentTableEntry *entry = &(g_argument_table[arg_type]); 483 484 // The table is *supposed* to be kept in arg_type order, but someone *could* 485 // have messed it up... 486 487 if (entry->arg_type != arg_type) 488 entry = CommandObject::FindArgumentDataByType(arg_type); 489 490 if (entry) 491 return entry->arg_name; 492 493 return nullptr; 494 } 495 496 bool CommandObject::IsPairType(ArgumentRepetitionType arg_repeat_type) { 497 return (arg_repeat_type == eArgRepeatPairPlain) || 498 (arg_repeat_type == eArgRepeatPairOptional) || 499 (arg_repeat_type == eArgRepeatPairPlus) || 500 (arg_repeat_type == eArgRepeatPairStar) || 501 (arg_repeat_type == eArgRepeatPairRange) || 502 (arg_repeat_type == eArgRepeatPairRangeOptional); 503 } 504 505 std::optional<ArgumentRepetitionType> 506 CommandObject::ArgRepetitionFromString(llvm::StringRef string) { 507 return llvm::StringSwitch<ArgumentRepetitionType>(string) 508 .Case("plain", eArgRepeatPlain) 509 .Case("optional", eArgRepeatOptional) 510 .Case("plus", eArgRepeatPlus) 511 .Case("star", eArgRepeatStar) 512 .Case("range", eArgRepeatRange) 513 .Case("pair-plain", eArgRepeatPairPlain) 514 .Case("pair-optional", eArgRepeatPairOptional) 515 .Case("pair-plus", eArgRepeatPairPlus) 516 .Case("pair-star", eArgRepeatPairStar) 517 .Case("pair-range", eArgRepeatPairRange) 518 .Case("pair-range-optional", eArgRepeatPairRangeOptional) 519 .Default({}); 520 } 521 522 static CommandObject::CommandArgumentEntry 523 OptSetFiltered(uint32_t opt_set_mask, 524 CommandObject::CommandArgumentEntry &cmd_arg_entry) { 525 CommandObject::CommandArgumentEntry ret_val; 526 for (unsigned i = 0; i < cmd_arg_entry.size(); ++i) 527 if (opt_set_mask & cmd_arg_entry[i].arg_opt_set_association) 528 ret_val.push_back(cmd_arg_entry[i]); 529 return ret_val; 530 } 531 532 // Default parameter value of opt_set_mask is LLDB_OPT_SET_ALL, which means 533 // take all the argument data into account. On rare cases where some argument 534 // sticks with certain option sets, this function returns the option set 535 // filtered args. 536 void CommandObject::GetFormattedCommandArguments(Stream &str, 537 uint32_t opt_set_mask) { 538 int num_args = m_arguments.size(); 539 for (int i = 0; i < num_args; ++i) { 540 if (i > 0) 541 str.Printf(" "); 542 CommandArgumentEntry arg_entry = 543 opt_set_mask == LLDB_OPT_SET_ALL 544 ? m_arguments[i] 545 : OptSetFiltered(opt_set_mask, m_arguments[i]); 546 // This argument is not associated with the current option set, so skip it. 547 if (arg_entry.empty()) 548 continue; 549 int num_alternatives = arg_entry.size(); 550 551 if ((num_alternatives == 2) && IsPairType(arg_entry[0].arg_repetition)) { 552 const char *first_name = GetArgumentName(arg_entry[0].arg_type); 553 const char *second_name = GetArgumentName(arg_entry[1].arg_type); 554 switch (arg_entry[0].arg_repetition) { 555 case eArgRepeatPairPlain: 556 str.Printf("<%s> <%s>", first_name, second_name); 557 break; 558 case eArgRepeatPairOptional: 559 str.Printf("[<%s> <%s>]", first_name, second_name); 560 break; 561 case eArgRepeatPairPlus: 562 str.Printf("<%s> <%s> [<%s> <%s> [...]]", first_name, second_name, 563 first_name, second_name); 564 break; 565 case eArgRepeatPairStar: 566 str.Printf("[<%s> <%s> [<%s> <%s> [...]]]", first_name, second_name, 567 first_name, second_name); 568 break; 569 case eArgRepeatPairRange: 570 str.Printf("<%s_1> <%s_1> ... <%s_n> <%s_n>", first_name, second_name, 571 first_name, second_name); 572 break; 573 case eArgRepeatPairRangeOptional: 574 str.Printf("[<%s_1> <%s_1> ... <%s_n> <%s_n>]", first_name, second_name, 575 first_name, second_name); 576 break; 577 // Explicitly test for all the rest of the cases, so if new types get 578 // added we will notice the missing case statement(s). 579 case eArgRepeatPlain: 580 case eArgRepeatOptional: 581 case eArgRepeatPlus: 582 case eArgRepeatStar: 583 case eArgRepeatRange: 584 // These should not be reached, as they should fail the IsPairType test 585 // above. 586 break; 587 } 588 } else { 589 StreamString names; 590 for (int j = 0; j < num_alternatives; ++j) { 591 if (j > 0) 592 names.Printf(" | "); 593 names.Printf("%s", GetArgumentName(arg_entry[j].arg_type)); 594 } 595 596 std::string name_str = std::string(names.GetString()); 597 switch (arg_entry[0].arg_repetition) { 598 case eArgRepeatPlain: 599 str.Printf("<%s>", name_str.c_str()); 600 break; 601 case eArgRepeatPlus: 602 str.Printf("<%s> [<%s> [...]]", name_str.c_str(), name_str.c_str()); 603 break; 604 case eArgRepeatStar: 605 str.Printf("[<%s> [<%s> [...]]]", name_str.c_str(), name_str.c_str()); 606 break; 607 case eArgRepeatOptional: 608 str.Printf("[<%s>]", name_str.c_str()); 609 break; 610 case eArgRepeatRange: 611 str.Printf("<%s_1> .. <%s_n>", name_str.c_str(), name_str.c_str()); 612 break; 613 // Explicitly test for all the rest of the cases, so if new types get 614 // added we will notice the missing case statement(s). 615 case eArgRepeatPairPlain: 616 case eArgRepeatPairOptional: 617 case eArgRepeatPairPlus: 618 case eArgRepeatPairStar: 619 case eArgRepeatPairRange: 620 case eArgRepeatPairRangeOptional: 621 // These should not be hit, as they should pass the IsPairType test 622 // above, and control should have gone into the other branch of the if 623 // statement. 624 break; 625 } 626 } 627 } 628 } 629 630 CommandArgumentType 631 CommandObject::LookupArgumentName(llvm::StringRef arg_name) { 632 CommandArgumentType return_type = eArgTypeLastArg; 633 634 arg_name = arg_name.ltrim('<').rtrim('>'); 635 636 for (int i = 0; i < eArgTypeLastArg; ++i) 637 if (arg_name == g_argument_table[i].arg_name) 638 return_type = g_argument_table[i].arg_type; 639 640 return return_type; 641 } 642 643 void CommandObject::FormatLongHelpText(Stream &output_strm, 644 llvm::StringRef long_help) { 645 CommandInterpreter &interpreter = GetCommandInterpreter(); 646 std::stringstream lineStream{std::string(long_help)}; 647 std::string line; 648 while (std::getline(lineStream, line)) { 649 if (line.empty()) { 650 output_strm << "\n"; 651 continue; 652 } 653 size_t result = line.find_first_not_of(" \t"); 654 if (result == std::string::npos) { 655 result = 0; 656 } 657 std::string whitespace_prefix = line.substr(0, result); 658 std::string remainder = line.substr(result); 659 interpreter.OutputFormattedHelpText(output_strm, whitespace_prefix, 660 remainder); 661 } 662 } 663 664 void CommandObject::GenerateHelpText(CommandReturnObject &result) { 665 GenerateHelpText(result.GetOutputStream()); 666 667 result.SetStatus(eReturnStatusSuccessFinishNoResult); 668 } 669 670 void CommandObject::GenerateHelpText(Stream &output_strm) { 671 CommandInterpreter &interpreter = GetCommandInterpreter(); 672 std::string help_text(GetHelp()); 673 if (WantsRawCommandString()) { 674 help_text.append(" Expects 'raw' input (see 'help raw-input'.)"); 675 } 676 interpreter.OutputFormattedHelpText(output_strm, "", help_text); 677 output_strm << "\nSyntax: " << GetSyntax() << "\n"; 678 Options *options = GetOptions(); 679 if (options != nullptr) { 680 options->GenerateOptionUsage( 681 output_strm, *this, 682 GetCommandInterpreter().GetDebugger().GetTerminalWidth()); 683 } 684 llvm::StringRef long_help = GetHelpLong(); 685 if (!long_help.empty()) { 686 FormatLongHelpText(output_strm, long_help); 687 } 688 if (!IsDashDashCommand() && options && options->NumCommandOptions() > 0) { 689 if (WantsRawCommandString() && !WantsCompletion()) { 690 // Emit the message about using ' -- ' between the end of the command 691 // options and the raw input conditionally, i.e., only if the command 692 // object does not want completion. 693 interpreter.OutputFormattedHelpText( 694 output_strm, "", "", 695 "\nImportant Note: Because this command takes 'raw' input, if you " 696 "use any command options" 697 " you must use ' -- ' between the end of the command options and the " 698 "beginning of the raw input.", 699 1); 700 } else if (GetNumArgumentEntries() > 0) { 701 // Also emit a warning about using "--" in case you are using a command 702 // that takes options and arguments. 703 interpreter.OutputFormattedHelpText( 704 output_strm, "", "", 705 "\nThis command takes options and free-form arguments. If your " 706 "arguments resemble" 707 " option specifiers (i.e., they start with a - or --), you must use " 708 "' -- ' between" 709 " the end of the command options and the beginning of the arguments.", 710 1); 711 } 712 } 713 } 714 715 void CommandObject::AddIDsArgumentData(CommandObject::IDType type) { 716 CommandArgumentEntry arg; 717 CommandArgumentData id_arg; 718 CommandArgumentData id_range_arg; 719 720 // Create the first variant for the first (and only) argument for this 721 // command. 722 switch (type) { 723 case eBreakpointArgs: 724 id_arg.arg_type = eArgTypeBreakpointID; 725 id_range_arg.arg_type = eArgTypeBreakpointIDRange; 726 break; 727 case eWatchpointArgs: 728 id_arg.arg_type = eArgTypeWatchpointID; 729 id_range_arg.arg_type = eArgTypeWatchpointIDRange; 730 break; 731 } 732 id_arg.arg_repetition = eArgRepeatOptional; 733 id_range_arg.arg_repetition = eArgRepeatOptional; 734 735 // The first (and only) argument for this command could be either an id or an 736 // id_range. Push both variants into the entry for the first argument for 737 // this command. 738 arg.push_back(id_arg); 739 arg.push_back(id_range_arg); 740 m_arguments.push_back(arg); 741 } 742 743 const char *CommandObject::GetArgumentTypeAsCString( 744 const lldb::CommandArgumentType arg_type) { 745 assert(arg_type < eArgTypeLastArg && 746 "Invalid argument type passed to GetArgumentTypeAsCString"); 747 return g_argument_table[arg_type].arg_name; 748 } 749 750 const char *CommandObject::GetArgumentDescriptionAsCString( 751 const lldb::CommandArgumentType arg_type) { 752 assert(arg_type < eArgTypeLastArg && 753 "Invalid argument type passed to GetArgumentDescriptionAsCString"); 754 return g_argument_table[arg_type].help_text; 755 } 756 757 Target &CommandObject::GetDummyTarget() { 758 return m_interpreter.GetDebugger().GetDummyTarget(); 759 } 760 761 Target &CommandObject::GetSelectedOrDummyTarget(bool prefer_dummy) { 762 return m_interpreter.GetDebugger().GetSelectedOrDummyTarget(prefer_dummy); 763 } 764 765 Target &CommandObject::GetSelectedTarget() { 766 assert(m_flags.AnySet(eCommandRequiresTarget | eCommandProcessMustBePaused | 767 eCommandProcessMustBeLaunched | eCommandRequiresFrame | 768 eCommandRequiresThread | eCommandRequiresProcess | 769 eCommandRequiresRegContext) && 770 "GetSelectedTarget called from object that may have no target"); 771 return *m_interpreter.GetDebugger().GetSelectedTarget(); 772 } 773 774 Thread *CommandObject::GetDefaultThread() { 775 Thread *thread_to_use = m_exe_ctx.GetThreadPtr(); 776 if (thread_to_use) 777 return thread_to_use; 778 779 Process *process = m_exe_ctx.GetProcessPtr(); 780 if (!process) { 781 Target *target = m_exe_ctx.GetTargetPtr(); 782 if (!target) { 783 target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 784 } 785 if (target) 786 process = target->GetProcessSP().get(); 787 } 788 789 if (process) 790 return process->GetThreadList().GetSelectedThread().get(); 791 else 792 return nullptr; 793 } 794 795 void CommandObjectParsed::Execute(const char *args_string, 796 CommandReturnObject &result) { 797 bool handled = false; 798 Args cmd_args(args_string); 799 if (HasOverrideCallback()) { 800 Args full_args(GetCommandName()); 801 full_args.AppendArguments(cmd_args); 802 handled = 803 InvokeOverrideCallback(full_args.GetConstArgumentVector(), result); 804 } 805 if (!handled) { 806 for (auto entry : llvm::enumerate(cmd_args.entries())) { 807 const Args::ArgEntry &value = entry.value(); 808 if (!value.ref().empty() && value.GetQuoteChar() == '`') { 809 // We have to put the backtick back in place for PreprocessCommand. 810 std::string opt_string = value.c_str(); 811 Status error; 812 error = m_interpreter.PreprocessToken(opt_string); 813 if (error.Success()) 814 cmd_args.ReplaceArgumentAtIndex(entry.index(), opt_string); 815 } 816 } 817 818 if (CheckRequirements(result)) { 819 if (ParseOptions(cmd_args, result)) { 820 // Call the command-specific version of 'Execute', passing it the 821 // already processed arguments. 822 if (cmd_args.GetArgumentCount() != 0 && m_arguments.empty()) { 823 result.AppendErrorWithFormatv("'{0}' doesn't take any arguments.", 824 GetCommandName()); 825 Cleanup(); 826 return; 827 } 828 m_interpreter.IncreaseCommandUsage(*this); 829 DoExecute(cmd_args, result); 830 } 831 } 832 833 Cleanup(); 834 } 835 } 836 837 void CommandObjectRaw::Execute(const char *args_string, 838 CommandReturnObject &result) { 839 bool handled = false; 840 if (HasOverrideCallback()) { 841 std::string full_command(GetCommandName()); 842 full_command += ' '; 843 full_command += args_string; 844 const char *argv[2] = {nullptr, nullptr}; 845 argv[0] = full_command.c_str(); 846 handled = InvokeOverrideCallback(argv, result); 847 } 848 if (!handled) { 849 if (CheckRequirements(result)) 850 DoExecute(args_string, result); 851 852 Cleanup(); 853 } 854 } 855