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 bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word, 309 bool search_short_help, 310 bool search_long_help, 311 bool search_syntax, 312 bool search_options) { 313 std::string options_usage_help; 314 315 bool found_word = false; 316 317 llvm::StringRef short_help = GetHelp(); 318 llvm::StringRef long_help = GetHelpLong(); 319 llvm::StringRef syntax_help = GetSyntax(); 320 321 if (search_short_help && short_help.contains_insensitive(search_word)) 322 found_word = true; 323 else if (search_long_help && long_help.contains_insensitive(search_word)) 324 found_word = true; 325 else if (search_syntax && syntax_help.contains_insensitive(search_word)) 326 found_word = true; 327 328 if (!found_word && search_options && GetOptions() != nullptr) { 329 StreamString usage_help; 330 GetOptions()->GenerateOptionUsage( 331 usage_help, *this, 332 GetCommandInterpreter().GetDebugger().GetTerminalWidth()); 333 if (!usage_help.Empty()) { 334 llvm::StringRef usage_text = usage_help.GetString(); 335 if (usage_text.contains_insensitive(search_word)) 336 found_word = true; 337 } 338 } 339 340 return found_word; 341 } 342 343 bool CommandObject::ParseOptionsAndNotify(Args &args, 344 CommandReturnObject &result, 345 OptionGroupOptions &group_options, 346 ExecutionContext &exe_ctx) { 347 if (!ParseOptions(args, result)) 348 return false; 349 350 Status error(group_options.NotifyOptionParsingFinished(&exe_ctx)); 351 if (error.Fail()) { 352 result.AppendError(error.AsCString()); 353 return false; 354 } 355 return true; 356 } 357 358 int CommandObject::GetNumArgumentEntries() { return m_arguments.size(); } 359 360 CommandObject::CommandArgumentEntry * 361 CommandObject::GetArgumentEntryAtIndex(int idx) { 362 if (static_cast<size_t>(idx) < m_arguments.size()) 363 return &(m_arguments[idx]); 364 365 return nullptr; 366 } 367 368 const CommandObject::ArgumentTableEntry * 369 CommandObject::FindArgumentDataByType(CommandArgumentType arg_type) { 370 for (int i = 0; i < eArgTypeLastArg; ++i) 371 if (g_argument_table[i].arg_type == arg_type) 372 return &(g_argument_table[i]); 373 374 return nullptr; 375 } 376 377 void CommandObject::GetArgumentHelp(Stream &str, CommandArgumentType arg_type, 378 CommandInterpreter &interpreter) { 379 const ArgumentTableEntry *entry = &(g_argument_table[arg_type]); 380 381 // The table is *supposed* to be kept in arg_type order, but someone *could* 382 // have messed it up... 383 384 if (entry->arg_type != arg_type) 385 entry = CommandObject::FindArgumentDataByType(arg_type); 386 387 if (!entry) 388 return; 389 390 StreamString name_str; 391 name_str.Printf("<%s>", entry->arg_name); 392 393 if (entry->help_function) { 394 llvm::StringRef help_text = entry->help_function(); 395 if (!entry->help_function.self_formatting) { 396 interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--", 397 help_text, name_str.GetSize()); 398 } else { 399 interpreter.OutputHelpText(str, name_str.GetString(), "--", help_text, 400 name_str.GetSize()); 401 } 402 } else { 403 interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--", 404 entry->help_text, name_str.GetSize()); 405 406 // Print enum values and their description if any. 407 OptionEnumValues enum_values = g_argument_table[arg_type].enum_values; 408 if (!enum_values.empty()) { 409 str.EOL(); 410 size_t longest = 0; 411 for (const OptionEnumValueElement &element : enum_values) 412 longest = 413 std::max(longest, llvm::StringRef(element.string_value).size()); 414 str.IndentMore(5); 415 for (const OptionEnumValueElement &element : enum_values) { 416 str.Indent(); 417 interpreter.OutputHelpText(str, element.string_value, ":", 418 element.usage, longest); 419 } 420 str.IndentLess(5); 421 str.EOL(); 422 } 423 } 424 } 425 426 const char *CommandObject::GetArgumentName(CommandArgumentType arg_type) { 427 const ArgumentTableEntry *entry = &(g_argument_table[arg_type]); 428 429 // The table is *supposed* to be kept in arg_type order, but someone *could* 430 // have messed it up... 431 432 if (entry->arg_type != arg_type) 433 entry = CommandObject::FindArgumentDataByType(arg_type); 434 435 if (entry) 436 return entry->arg_name; 437 438 return nullptr; 439 } 440 441 bool CommandObject::IsPairType(ArgumentRepetitionType arg_repeat_type) { 442 return (arg_repeat_type == eArgRepeatPairPlain) || 443 (arg_repeat_type == eArgRepeatPairOptional) || 444 (arg_repeat_type == eArgRepeatPairPlus) || 445 (arg_repeat_type == eArgRepeatPairStar) || 446 (arg_repeat_type == eArgRepeatPairRange) || 447 (arg_repeat_type == eArgRepeatPairRangeOptional); 448 } 449 450 static CommandObject::CommandArgumentEntry 451 OptSetFiltered(uint32_t opt_set_mask, 452 CommandObject::CommandArgumentEntry &cmd_arg_entry) { 453 CommandObject::CommandArgumentEntry ret_val; 454 for (unsigned i = 0; i < cmd_arg_entry.size(); ++i) 455 if (opt_set_mask & cmd_arg_entry[i].arg_opt_set_association) 456 ret_val.push_back(cmd_arg_entry[i]); 457 return ret_val; 458 } 459 460 // Default parameter value of opt_set_mask is LLDB_OPT_SET_ALL, which means 461 // take all the argument data into account. On rare cases where some argument 462 // sticks with certain option sets, this function returns the option set 463 // filtered args. 464 void CommandObject::GetFormattedCommandArguments(Stream &str, 465 uint32_t opt_set_mask) { 466 int num_args = m_arguments.size(); 467 for (int i = 0; i < num_args; ++i) { 468 if (i > 0) 469 str.Printf(" "); 470 CommandArgumentEntry arg_entry = 471 opt_set_mask == LLDB_OPT_SET_ALL 472 ? m_arguments[i] 473 : OptSetFiltered(opt_set_mask, m_arguments[i]); 474 // This argument is not associated with the current option set, so skip it. 475 if (arg_entry.empty()) 476 continue; 477 int num_alternatives = arg_entry.size(); 478 479 if ((num_alternatives == 2) && IsPairType(arg_entry[0].arg_repetition)) { 480 const char *first_name = GetArgumentName(arg_entry[0].arg_type); 481 const char *second_name = GetArgumentName(arg_entry[1].arg_type); 482 switch (arg_entry[0].arg_repetition) { 483 case eArgRepeatPairPlain: 484 str.Printf("<%s> <%s>", first_name, second_name); 485 break; 486 case eArgRepeatPairOptional: 487 str.Printf("[<%s> <%s>]", first_name, second_name); 488 break; 489 case eArgRepeatPairPlus: 490 str.Printf("<%s> <%s> [<%s> <%s> [...]]", first_name, second_name, 491 first_name, second_name); 492 break; 493 case eArgRepeatPairStar: 494 str.Printf("[<%s> <%s> [<%s> <%s> [...]]]", first_name, second_name, 495 first_name, second_name); 496 break; 497 case eArgRepeatPairRange: 498 str.Printf("<%s_1> <%s_1> ... <%s_n> <%s_n>", first_name, second_name, 499 first_name, second_name); 500 break; 501 case eArgRepeatPairRangeOptional: 502 str.Printf("[<%s_1> <%s_1> ... <%s_n> <%s_n>]", first_name, second_name, 503 first_name, second_name); 504 break; 505 // Explicitly test for all the rest of the cases, so if new types get 506 // added we will notice the missing case statement(s). 507 case eArgRepeatPlain: 508 case eArgRepeatOptional: 509 case eArgRepeatPlus: 510 case eArgRepeatStar: 511 case eArgRepeatRange: 512 // These should not be reached, as they should fail the IsPairType test 513 // above. 514 break; 515 } 516 } else { 517 StreamString names; 518 for (int j = 0; j < num_alternatives; ++j) { 519 if (j > 0) 520 names.Printf(" | "); 521 names.Printf("%s", GetArgumentName(arg_entry[j].arg_type)); 522 } 523 524 std::string name_str = std::string(names.GetString()); 525 switch (arg_entry[0].arg_repetition) { 526 case eArgRepeatPlain: 527 str.Printf("<%s>", name_str.c_str()); 528 break; 529 case eArgRepeatPlus: 530 str.Printf("<%s> [<%s> [...]]", name_str.c_str(), name_str.c_str()); 531 break; 532 case eArgRepeatStar: 533 str.Printf("[<%s> [<%s> [...]]]", name_str.c_str(), name_str.c_str()); 534 break; 535 case eArgRepeatOptional: 536 str.Printf("[<%s>]", name_str.c_str()); 537 break; 538 case eArgRepeatRange: 539 str.Printf("<%s_1> .. <%s_n>", name_str.c_str(), name_str.c_str()); 540 break; 541 // Explicitly test for all the rest of the cases, so if new types get 542 // added we will notice the missing case statement(s). 543 case eArgRepeatPairPlain: 544 case eArgRepeatPairOptional: 545 case eArgRepeatPairPlus: 546 case eArgRepeatPairStar: 547 case eArgRepeatPairRange: 548 case eArgRepeatPairRangeOptional: 549 // These should not be hit, as they should pass the IsPairType test 550 // above, and control should have gone into the other branch of the if 551 // statement. 552 break; 553 } 554 } 555 } 556 } 557 558 CommandArgumentType 559 CommandObject::LookupArgumentName(llvm::StringRef arg_name) { 560 CommandArgumentType return_type = eArgTypeLastArg; 561 562 arg_name = arg_name.ltrim('<').rtrim('>'); 563 564 for (int i = 0; i < eArgTypeLastArg; ++i) 565 if (arg_name == g_argument_table[i].arg_name) 566 return_type = g_argument_table[i].arg_type; 567 568 return return_type; 569 } 570 571 void CommandObject::FormatLongHelpText(Stream &output_strm, 572 llvm::StringRef long_help) { 573 CommandInterpreter &interpreter = GetCommandInterpreter(); 574 std::stringstream lineStream{std::string(long_help)}; 575 std::string line; 576 while (std::getline(lineStream, line)) { 577 if (line.empty()) { 578 output_strm << "\n"; 579 continue; 580 } 581 size_t result = line.find_first_not_of(" \t"); 582 if (result == std::string::npos) { 583 result = 0; 584 } 585 std::string whitespace_prefix = line.substr(0, result); 586 std::string remainder = line.substr(result); 587 interpreter.OutputFormattedHelpText(output_strm, whitespace_prefix, 588 remainder); 589 } 590 } 591 592 void CommandObject::GenerateHelpText(CommandReturnObject &result) { 593 GenerateHelpText(result.GetOutputStream()); 594 595 result.SetStatus(eReturnStatusSuccessFinishNoResult); 596 } 597 598 void CommandObject::GenerateHelpText(Stream &output_strm) { 599 CommandInterpreter &interpreter = GetCommandInterpreter(); 600 std::string help_text(GetHelp()); 601 if (WantsRawCommandString()) { 602 help_text.append(" Expects 'raw' input (see 'help raw-input'.)"); 603 } 604 interpreter.OutputFormattedHelpText(output_strm, "", help_text); 605 output_strm << "\nSyntax: " << GetSyntax() << "\n"; 606 Options *options = GetOptions(); 607 if (options != nullptr) { 608 options->GenerateOptionUsage( 609 output_strm, *this, 610 GetCommandInterpreter().GetDebugger().GetTerminalWidth()); 611 } 612 llvm::StringRef long_help = GetHelpLong(); 613 if (!long_help.empty()) { 614 FormatLongHelpText(output_strm, long_help); 615 } 616 if (!IsDashDashCommand() && options && options->NumCommandOptions() > 0) { 617 if (WantsRawCommandString() && !WantsCompletion()) { 618 // Emit the message about using ' -- ' between the end of the command 619 // options and the raw input conditionally, i.e., only if the command 620 // object does not want completion. 621 interpreter.OutputFormattedHelpText( 622 output_strm, "", "", 623 "\nImportant Note: Because this command takes 'raw' input, if you " 624 "use any command options" 625 " you must use ' -- ' between the end of the command options and the " 626 "beginning of the raw input.", 627 1); 628 } else if (GetNumArgumentEntries() > 0) { 629 // Also emit a warning about using "--" in case you are using a command 630 // that takes options and arguments. 631 interpreter.OutputFormattedHelpText( 632 output_strm, "", "", 633 "\nThis command takes options and free-form arguments. If your " 634 "arguments resemble" 635 " option specifiers (i.e., they start with a - or --), you must use " 636 "' -- ' between" 637 " the end of the command options and the beginning of the arguments.", 638 1); 639 } 640 } 641 } 642 643 void CommandObject::AddIDsArgumentData(CommandArgumentEntry &arg, 644 CommandArgumentType ID, 645 CommandArgumentType IDRange) { 646 CommandArgumentData id_arg; 647 CommandArgumentData id_range_arg; 648 649 // Create the first variant for the first (and only) argument for this 650 // command. 651 id_arg.arg_type = ID; 652 id_arg.arg_repetition = eArgRepeatOptional; 653 654 // Create the second variant for the first (and only) argument for this 655 // command. 656 id_range_arg.arg_type = IDRange; 657 id_range_arg.arg_repetition = eArgRepeatOptional; 658 659 // The first (and only) argument for this command could be either an id or an 660 // id_range. Push both variants into the entry for the first argument for 661 // this command. 662 arg.push_back(id_arg); 663 arg.push_back(id_range_arg); 664 } 665 666 const char *CommandObject::GetArgumentTypeAsCString( 667 const lldb::CommandArgumentType arg_type) { 668 assert(arg_type < eArgTypeLastArg && 669 "Invalid argument type passed to GetArgumentTypeAsCString"); 670 return g_argument_table[arg_type].arg_name; 671 } 672 673 const char *CommandObject::GetArgumentDescriptionAsCString( 674 const lldb::CommandArgumentType arg_type) { 675 assert(arg_type < eArgTypeLastArg && 676 "Invalid argument type passed to GetArgumentDescriptionAsCString"); 677 return g_argument_table[arg_type].help_text; 678 } 679 680 Target &CommandObject::GetDummyTarget() { 681 return m_interpreter.GetDebugger().GetDummyTarget(); 682 } 683 684 Target &CommandObject::GetSelectedOrDummyTarget(bool prefer_dummy) { 685 return m_interpreter.GetDebugger().GetSelectedOrDummyTarget(prefer_dummy); 686 } 687 688 Target &CommandObject::GetSelectedTarget() { 689 assert(m_flags.AnySet(eCommandRequiresTarget | eCommandProcessMustBePaused | 690 eCommandProcessMustBeLaunched | eCommandRequiresFrame | 691 eCommandRequiresThread | eCommandRequiresProcess | 692 eCommandRequiresRegContext) && 693 "GetSelectedTarget called from object that may have no target"); 694 return *m_interpreter.GetDebugger().GetSelectedTarget(); 695 } 696 697 Thread *CommandObject::GetDefaultThread() { 698 Thread *thread_to_use = m_exe_ctx.GetThreadPtr(); 699 if (thread_to_use) 700 return thread_to_use; 701 702 Process *process = m_exe_ctx.GetProcessPtr(); 703 if (!process) { 704 Target *target = m_exe_ctx.GetTargetPtr(); 705 if (!target) { 706 target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 707 } 708 if (target) 709 process = target->GetProcessSP().get(); 710 } 711 712 if (process) 713 return process->GetThreadList().GetSelectedThread().get(); 714 else 715 return nullptr; 716 } 717 718 void CommandObjectParsed::Execute(const char *args_string, 719 CommandReturnObject &result) { 720 bool handled = false; 721 Args cmd_args(args_string); 722 if (HasOverrideCallback()) { 723 Args full_args(GetCommandName()); 724 full_args.AppendArguments(cmd_args); 725 handled = 726 InvokeOverrideCallback(full_args.GetConstArgumentVector(), result); 727 } 728 if (!handled) { 729 for (auto entry : llvm::enumerate(cmd_args.entries())) { 730 const Args::ArgEntry &value = entry.value(); 731 if (!value.ref().empty() && value.GetQuoteChar() == '`') { 732 // We have to put the backtick back in place for PreprocessCommand. 733 std::string opt_string = value.c_str(); 734 Status error; 735 error = m_interpreter.PreprocessToken(opt_string); 736 if (error.Success()) 737 cmd_args.ReplaceArgumentAtIndex(entry.index(), opt_string); 738 } 739 } 740 741 if (CheckRequirements(result)) { 742 if (ParseOptions(cmd_args, result)) { 743 // Call the command-specific version of 'Execute', passing it the 744 // already processed arguments. 745 if (cmd_args.GetArgumentCount() != 0 && m_arguments.empty()) { 746 result.AppendErrorWithFormatv("'{0}' doesn't take any arguments.", 747 GetCommandName()); 748 Cleanup(); 749 return; 750 } 751 DoExecute(cmd_args, result); 752 } 753 } 754 755 Cleanup(); 756 } 757 } 758 759 void CommandObjectRaw::Execute(const char *args_string, 760 CommandReturnObject &result) { 761 bool handled = false; 762 if (HasOverrideCallback()) { 763 std::string full_command(GetCommandName()); 764 full_command += ' '; 765 full_command += args_string; 766 const char *argv[2] = {nullptr, nullptr}; 767 argv[0] = full_command.c_str(); 768 handled = InvokeOverrideCallback(argv, result); 769 } 770 if (!handled) { 771 if (CheckRequirements(result)) 772 DoExecute(args_string, result); 773 774 Cleanup(); 775 } 776 } 777