1 //===-- SBCommandInterpreter.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/lldb-types.h" 10 11 #include "SBReproducerPrivate.h" 12 #include "lldb/Interpreter/CommandInterpreter.h" 13 #include "lldb/Interpreter/CommandObjectMultiword.h" 14 #include "lldb/Interpreter/CommandReturnObject.h" 15 #include "lldb/Target/Target.h" 16 #include "lldb/Utility/Listener.h" 17 18 #include "lldb/API/SBBroadcaster.h" 19 #include "lldb/API/SBCommandInterpreter.h" 20 #include "lldb/API/SBCommandInterpreterRunOptions.h" 21 #include "lldb/API/SBCommandReturnObject.h" 22 #include "lldb/API/SBEvent.h" 23 #include "lldb/API/SBExecutionContext.h" 24 #include "lldb/API/SBListener.h" 25 #include "lldb/API/SBProcess.h" 26 #include "lldb/API/SBStream.h" 27 #include "lldb/API/SBStringList.h" 28 #include "lldb/API/SBTarget.h" 29 30 #include <memory> 31 32 using namespace lldb; 33 using namespace lldb_private; 34 35 class CommandPluginInterfaceImplementation : public CommandObjectParsed { 36 public: 37 CommandPluginInterfaceImplementation(CommandInterpreter &interpreter, 38 const char *name, 39 lldb::SBCommandPluginInterface *backend, 40 const char *help = nullptr, 41 const char *syntax = nullptr, 42 uint32_t flags = 0, 43 const char *auto_repeat_command = "") 44 : CommandObjectParsed(interpreter, name, help, syntax, flags), 45 m_backend(backend) { 46 m_auto_repeat_command = 47 auto_repeat_command == nullptr 48 ? llvm::None 49 : llvm::Optional<std::string>(auto_repeat_command); 50 } 51 52 bool IsRemovable() const override { return true; } 53 54 /// More documentation is available in lldb::CommandObject::GetRepeatCommand, 55 /// but in short, if nullptr is returned, the previous command will be 56 /// repeated, and if an empty string is returned, no commands will be 57 /// executed. 58 const char *GetRepeatCommand(Args ¤t_command_args, 59 uint32_t index) override { 60 if (!m_auto_repeat_command) 61 return nullptr; 62 else 63 return m_auto_repeat_command->c_str(); 64 } 65 66 protected: 67 bool DoExecute(Args &command, CommandReturnObject &result) override { 68 SBCommandReturnObject sb_return(result); 69 SBCommandInterpreter sb_interpreter(&m_interpreter); 70 SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this()); 71 bool ret = m_backend->DoExecute( 72 debugger_sb, command.GetArgumentVector(), sb_return); 73 return ret; 74 } 75 std::shared_ptr<lldb::SBCommandPluginInterface> m_backend; 76 llvm::Optional<std::string> m_auto_repeat_command; 77 }; 78 79 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter) 80 : m_opaque_ptr(interpreter) { 81 LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, 82 (lldb_private::CommandInterpreter *), interpreter); 83 84 } 85 86 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) 87 : m_opaque_ptr(rhs.m_opaque_ptr) { 88 LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, 89 (const lldb::SBCommandInterpreter &), rhs); 90 } 91 92 SBCommandInterpreter::~SBCommandInterpreter() = default; 93 94 const SBCommandInterpreter &SBCommandInterpreter:: 95 operator=(const SBCommandInterpreter &rhs) { 96 LLDB_RECORD_METHOD( 97 const lldb::SBCommandInterpreter &, 98 SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &), 99 rhs); 100 101 m_opaque_ptr = rhs.m_opaque_ptr; 102 return LLDB_RECORD_RESULT(*this); 103 } 104 105 bool SBCommandInterpreter::IsValid() const { 106 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid); 107 return this->operator bool(); 108 } 109 SBCommandInterpreter::operator bool() const { 110 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool); 111 112 return m_opaque_ptr != nullptr; 113 } 114 115 bool SBCommandInterpreter::CommandExists(const char *cmd) { 116 LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *), 117 cmd); 118 119 return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd) 120 : false); 121 } 122 123 bool SBCommandInterpreter::AliasExists(const char *cmd) { 124 LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *), 125 cmd); 126 127 return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd) 128 : false); 129 } 130 131 bool SBCommandInterpreter::IsActive() { 132 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive); 133 134 return (IsValid() ? m_opaque_ptr->IsActive() : false); 135 } 136 137 bool SBCommandInterpreter::WasInterrupted() const { 138 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted); 139 140 return (IsValid() ? m_opaque_ptr->WasInterrupted() : false); 141 } 142 143 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) { 144 LLDB_RECORD_METHOD(const char *, SBCommandInterpreter, 145 GetIOHandlerControlSequence, (char), ch); 146 147 return (IsValid() 148 ? m_opaque_ptr->GetDebugger() 149 .GetTopIOHandlerControlSequence(ch) 150 .GetCString() 151 : nullptr); 152 } 153 154 lldb::ReturnStatus 155 SBCommandInterpreter::HandleCommand(const char *command_line, 156 SBCommandReturnObject &result, 157 bool add_to_history) { 158 LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, 159 (const char *, lldb::SBCommandReturnObject &, bool), 160 command_line, result, add_to_history); 161 162 SBExecutionContext sb_exe_ctx; 163 return HandleCommand(command_line, sb_exe_ctx, result, add_to_history); 164 } 165 166 lldb::ReturnStatus SBCommandInterpreter::HandleCommand( 167 const char *command_line, SBExecutionContext &override_context, 168 SBCommandReturnObject &result, bool add_to_history) { 169 LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, 170 (const char *, lldb::SBExecutionContext &, 171 lldb::SBCommandReturnObject &, bool), 172 command_line, override_context, result, add_to_history); 173 174 175 ExecutionContext ctx, *ctx_ptr; 176 if (override_context.get()) { 177 ctx = override_context.get()->Lock(true); 178 ctx_ptr = &ctx; 179 } else 180 ctx_ptr = nullptr; 181 182 result.Clear(); 183 if (command_line && IsValid()) { 184 result.ref().SetInteractive(false); 185 m_opaque_ptr->HandleCommand(command_line, 186 add_to_history ? eLazyBoolYes : eLazyBoolNo, 187 result.ref(), ctx_ptr); 188 } else { 189 result->AppendError( 190 "SBCommandInterpreter or the command line is not valid"); 191 result->SetStatus(eReturnStatusFailed); 192 } 193 194 195 return result.GetStatus(); 196 } 197 198 void SBCommandInterpreter::HandleCommandsFromFile( 199 lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context, 200 lldb::SBCommandInterpreterRunOptions &options, 201 lldb::SBCommandReturnObject result) { 202 LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, 203 (lldb::SBFileSpec &, lldb::SBExecutionContext &, 204 lldb::SBCommandInterpreterRunOptions &, 205 lldb::SBCommandReturnObject), 206 file, override_context, options, result); 207 208 if (!IsValid()) { 209 result->AppendError("SBCommandInterpreter is not valid."); 210 result->SetStatus(eReturnStatusFailed); 211 return; 212 } 213 214 if (!file.IsValid()) { 215 SBStream s; 216 file.GetDescription(s); 217 result->AppendErrorWithFormat("File is not valid: %s.", s.GetData()); 218 result->SetStatus(eReturnStatusFailed); 219 } 220 221 FileSpec tmp_spec = file.ref(); 222 ExecutionContext ctx, *ctx_ptr; 223 if (override_context.get()) { 224 ctx = override_context.get()->Lock(true); 225 ctx_ptr = &ctx; 226 } else 227 ctx_ptr = nullptr; 228 229 m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(), 230 result.ref()); 231 } 232 233 int SBCommandInterpreter::HandleCompletion( 234 const char *current_line, const char *cursor, const char *last_char, 235 int match_start_point, int max_return_elements, SBStringList &matches) { 236 LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, 237 (const char *, const char *, const char *, int, int, 238 lldb::SBStringList &), 239 current_line, cursor, last_char, match_start_point, 240 max_return_elements, matches); 241 242 SBStringList dummy_descriptions; 243 return HandleCompletionWithDescriptions( 244 current_line, cursor, last_char, match_start_point, max_return_elements, 245 matches, dummy_descriptions); 246 } 247 248 int SBCommandInterpreter::HandleCompletionWithDescriptions( 249 const char *current_line, const char *cursor, const char *last_char, 250 int match_start_point, int max_return_elements, SBStringList &matches, 251 SBStringList &descriptions) { 252 LLDB_RECORD_METHOD(int, SBCommandInterpreter, 253 HandleCompletionWithDescriptions, 254 (const char *, const char *, const char *, int, int, 255 lldb::SBStringList &, lldb::SBStringList &), 256 current_line, cursor, last_char, match_start_point, 257 max_return_elements, matches, descriptions); 258 259 // Sanity check the arguments that are passed in: cursor & last_char have to 260 // be within the current_line. 261 if (current_line == nullptr || cursor == nullptr || last_char == nullptr) 262 return 0; 263 264 if (cursor < current_line || last_char < current_line) 265 return 0; 266 267 size_t current_line_size = strlen(current_line); 268 if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) || 269 last_char - current_line > static_cast<ptrdiff_t>(current_line_size)) 270 return 0; 271 272 if (!IsValid()) 273 return 0; 274 275 lldb_private::StringList lldb_matches, lldb_descriptions; 276 CompletionResult result; 277 CompletionRequest request(current_line, cursor - current_line, result); 278 m_opaque_ptr->HandleCompletion(request); 279 result.GetMatches(lldb_matches); 280 result.GetDescriptions(lldb_descriptions); 281 282 // Make the result array indexed from 1 again by adding the 'common prefix' 283 // of all completions as element 0. This is done to emulate the old API. 284 if (request.GetParsedLine().GetArgumentCount() == 0) { 285 // If we got an empty string, insert nothing. 286 lldb_matches.InsertStringAtIndex(0, ""); 287 lldb_descriptions.InsertStringAtIndex(0, ""); 288 } else { 289 // Now figure out if there is a common substring, and if so put that in 290 // element 0, otherwise put an empty string in element 0. 291 std::string command_partial_str = request.GetCursorArgumentPrefix().str(); 292 293 std::string common_prefix = lldb_matches.LongestCommonPrefix(); 294 const size_t partial_name_len = command_partial_str.size(); 295 common_prefix.erase(0, partial_name_len); 296 297 // If we matched a unique single command, add a space... Only do this if 298 // the completer told us this was a complete word, however... 299 if (lldb_matches.GetSize() == 1) { 300 char quote_char = request.GetParsedArg().GetQuoteChar(); 301 common_prefix = 302 Args::EscapeLLDBCommandArgument(common_prefix, quote_char); 303 if (request.GetParsedArg().IsQuoted()) 304 common_prefix.push_back(quote_char); 305 common_prefix.push_back(' '); 306 } 307 lldb_matches.InsertStringAtIndex(0, common_prefix.c_str()); 308 lldb_descriptions.InsertStringAtIndex(0, ""); 309 } 310 311 SBStringList temp_matches_list(&lldb_matches); 312 matches.AppendList(temp_matches_list); 313 SBStringList temp_descriptions_list(&lldb_descriptions); 314 descriptions.AppendList(temp_descriptions_list); 315 return result.GetNumberOfResults(); 316 } 317 318 int SBCommandInterpreter::HandleCompletionWithDescriptions( 319 const char *current_line, uint32_t cursor_pos, int match_start_point, 320 int max_return_elements, SBStringList &matches, 321 SBStringList &descriptions) { 322 LLDB_RECORD_METHOD(int, SBCommandInterpreter, 323 HandleCompletionWithDescriptions, 324 (const char *, uint32_t, int, int, lldb::SBStringList &, 325 lldb::SBStringList &), 326 current_line, cursor_pos, match_start_point, 327 max_return_elements, matches, descriptions); 328 329 const char *cursor = current_line + cursor_pos; 330 const char *last_char = current_line + strlen(current_line); 331 return HandleCompletionWithDescriptions( 332 current_line, cursor, last_char, match_start_point, max_return_elements, 333 matches, descriptions); 334 } 335 336 int SBCommandInterpreter::HandleCompletion(const char *current_line, 337 uint32_t cursor_pos, 338 int match_start_point, 339 int max_return_elements, 340 lldb::SBStringList &matches) { 341 LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, 342 (const char *, uint32_t, int, int, lldb::SBStringList &), 343 current_line, cursor_pos, match_start_point, 344 max_return_elements, matches); 345 346 const char *cursor = current_line + cursor_pos; 347 const char *last_char = current_line + strlen(current_line); 348 return HandleCompletion(current_line, cursor, last_char, match_start_point, 349 max_return_elements, matches); 350 } 351 352 bool SBCommandInterpreter::HasCommands() { 353 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands); 354 355 return (IsValid() ? m_opaque_ptr->HasCommands() : false); 356 } 357 358 bool SBCommandInterpreter::HasAliases() { 359 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases); 360 361 return (IsValid() ? m_opaque_ptr->HasAliases() : false); 362 } 363 364 bool SBCommandInterpreter::HasAliasOptions() { 365 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions); 366 367 return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false); 368 } 369 370 SBProcess SBCommandInterpreter::GetProcess() { 371 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess); 372 373 SBProcess sb_process; 374 ProcessSP process_sp; 375 if (IsValid()) { 376 TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); 377 if (target_sp) { 378 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 379 process_sp = target_sp->GetProcessSP(); 380 sb_process.SetSP(process_sp); 381 } 382 } 383 384 return LLDB_RECORD_RESULT(sb_process); 385 } 386 387 SBDebugger SBCommandInterpreter::GetDebugger() { 388 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter, 389 GetDebugger); 390 391 SBDebugger sb_debugger; 392 if (IsValid()) 393 sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this()); 394 395 return LLDB_RECORD_RESULT(sb_debugger); 396 } 397 398 bool SBCommandInterpreter::GetPromptOnQuit() { 399 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit); 400 401 return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false); 402 } 403 404 void SBCommandInterpreter::SetPromptOnQuit(bool b) { 405 LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b); 406 407 if (IsValid()) 408 m_opaque_ptr->SetPromptOnQuit(b); 409 } 410 411 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) { 412 LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool), 413 allow); 414 415 if (m_opaque_ptr) 416 m_opaque_ptr->AllowExitCodeOnQuit(allow); 417 } 418 419 bool SBCommandInterpreter::HasCustomQuitExitCode() { 420 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode); 421 422 bool exited = false; 423 if (m_opaque_ptr) 424 m_opaque_ptr->GetQuitExitCode(exited); 425 return exited; 426 } 427 428 int SBCommandInterpreter::GetQuitStatus() { 429 LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus); 430 431 bool exited = false; 432 return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0); 433 } 434 435 void SBCommandInterpreter::ResolveCommand(const char *command_line, 436 SBCommandReturnObject &result) { 437 LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand, 438 (const char *, lldb::SBCommandReturnObject &), 439 command_line, result); 440 441 result.Clear(); 442 if (command_line && IsValid()) { 443 m_opaque_ptr->ResolveCommand(command_line, result.ref()); 444 } else { 445 result->AppendError( 446 "SBCommandInterpreter or the command line is not valid"); 447 result->SetStatus(eReturnStatusFailed); 448 } 449 } 450 451 CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; } 452 453 CommandInterpreter &SBCommandInterpreter::ref() { 454 assert(m_opaque_ptr); 455 return *m_opaque_ptr; 456 } 457 458 void SBCommandInterpreter::reset( 459 lldb_private::CommandInterpreter *interpreter) { 460 m_opaque_ptr = interpreter; 461 } 462 463 void SBCommandInterpreter::SourceInitFileInHomeDirectory( 464 SBCommandReturnObject &result) { 465 LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, 466 (lldb::SBCommandReturnObject &), result); 467 468 result.Clear(); 469 if (IsValid()) { 470 TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); 471 std::unique_lock<std::recursive_mutex> lock; 472 if (target_sp) 473 lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); 474 m_opaque_ptr->SourceInitFileHome(result.ref()); 475 } else { 476 result->AppendError("SBCommandInterpreter is not valid"); 477 result->SetStatus(eReturnStatusFailed); 478 } 479 } 480 481 void SBCommandInterpreter::SourceInitFileInHomeDirectory( 482 SBCommandReturnObject &result, bool is_repl) { 483 LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, 484 (lldb::SBCommandReturnObject &, bool), result, is_repl); 485 486 result.Clear(); 487 if (IsValid()) { 488 TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); 489 std::unique_lock<std::recursive_mutex> lock; 490 if (target_sp) 491 lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); 492 m_opaque_ptr->SourceInitFileHome(result.ref(), is_repl); 493 } else { 494 result->AppendError("SBCommandInterpreter is not valid"); 495 result->SetStatus(eReturnStatusFailed); 496 } 497 } 498 499 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory( 500 SBCommandReturnObject &result) { 501 LLDB_RECORD_METHOD(void, SBCommandInterpreter, 502 SourceInitFileInCurrentWorkingDirectory, 503 (lldb::SBCommandReturnObject &), result); 504 505 result.Clear(); 506 if (IsValid()) { 507 TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); 508 std::unique_lock<std::recursive_mutex> lock; 509 if (target_sp) 510 lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); 511 m_opaque_ptr->SourceInitFileCwd(result.ref()); 512 } else { 513 result->AppendError("SBCommandInterpreter is not valid"); 514 result->SetStatus(eReturnStatusFailed); 515 } 516 } 517 518 SBBroadcaster SBCommandInterpreter::GetBroadcaster() { 519 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter, 520 GetBroadcaster); 521 522 523 SBBroadcaster broadcaster(m_opaque_ptr, false); 524 525 526 return LLDB_RECORD_RESULT(broadcaster); 527 } 528 529 const char *SBCommandInterpreter::GetBroadcasterClass() { 530 LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter, 531 GetBroadcasterClass); 532 533 return CommandInterpreter::GetStaticBroadcasterClass().AsCString(); 534 } 535 536 const char *SBCommandInterpreter::GetArgumentTypeAsCString( 537 const lldb::CommandArgumentType arg_type) { 538 LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, 539 GetArgumentTypeAsCString, 540 (const lldb::CommandArgumentType), arg_type); 541 542 return CommandObject::GetArgumentTypeAsCString(arg_type); 543 } 544 545 const char *SBCommandInterpreter::GetArgumentDescriptionAsCString( 546 const lldb::CommandArgumentType arg_type) { 547 LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, 548 GetArgumentDescriptionAsCString, 549 (const lldb::CommandArgumentType), arg_type); 550 551 return CommandObject::GetArgumentDescriptionAsCString(arg_type); 552 } 553 554 bool SBCommandInterpreter::EventIsCommandInterpreterEvent( 555 const lldb::SBEvent &event) { 556 LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter, 557 EventIsCommandInterpreterEvent, 558 (const lldb::SBEvent &), event); 559 560 return event.GetBroadcasterClass() == 561 SBCommandInterpreter::GetBroadcasterClass(); 562 } 563 564 bool SBCommandInterpreter::SetCommandOverrideCallback( 565 const char *command_name, lldb::CommandOverrideCallback callback, 566 void *baton) { 567 LLDB_RECORD_DUMMY(bool, SBCommandInterpreter, SetCommandOverrideCallback, 568 (const char *, lldb::CommandOverrideCallback, void *), 569 command_name, callback, baton); 570 571 if (command_name && command_name[0] && IsValid()) { 572 llvm::StringRef command_name_str = command_name; 573 CommandObject *cmd_obj = 574 m_opaque_ptr->GetCommandObjectForCommand(command_name_str); 575 if (cmd_obj) { 576 assert(command_name_str.empty()); 577 cmd_obj->SetOverrideCallback(callback, baton); 578 return true; 579 } 580 } 581 return false; 582 } 583 584 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name, 585 const char *help) { 586 LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand, 587 (const char *, const char *), name, help); 588 589 CommandObjectMultiword *new_command = 590 new CommandObjectMultiword(*m_opaque_ptr, name, help); 591 new_command->SetRemovable(true); 592 lldb::CommandObjectSP new_command_sp(new_command); 593 if (new_command_sp && 594 m_opaque_ptr->AddUserCommand(name, new_command_sp, true)) 595 return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); 596 return LLDB_RECORD_RESULT(lldb::SBCommand()); 597 } 598 599 lldb::SBCommand SBCommandInterpreter::AddCommand( 600 const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { 601 LLDB_RECORD_METHOD( 602 lldb::SBCommand, SBCommandInterpreter, AddCommand, 603 (const char *, lldb::SBCommandPluginInterface *, const char *), name, 604 impl, help); 605 606 return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr, 607 /*auto_repeat_command=*/"")) 608 } 609 610 lldb::SBCommand 611 SBCommandInterpreter::AddCommand(const char *name, 612 lldb::SBCommandPluginInterface *impl, 613 const char *help, const char *syntax) { 614 LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, 615 (const char *, lldb::SBCommandPluginInterface *, 616 const char *, const char *), 617 name, impl, help, syntax); 618 return LLDB_RECORD_RESULT( 619 AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"")) 620 } 621 622 lldb::SBCommand SBCommandInterpreter::AddCommand( 623 const char *name, lldb::SBCommandPluginInterface *impl, const char *help, 624 const char *syntax, const char *auto_repeat_command) { 625 LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, 626 (const char *, lldb::SBCommandPluginInterface *, 627 const char *, const char *, const char *), 628 name, impl, help, syntax, auto_repeat_command); 629 630 lldb::CommandObjectSP new_command_sp; 631 new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( 632 *m_opaque_ptr, name, impl, help, syntax, /*flags=*/0, 633 auto_repeat_command); 634 635 if (new_command_sp && 636 m_opaque_ptr->AddUserCommand(name, new_command_sp, true)) 637 return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); 638 return LLDB_RECORD_RESULT(lldb::SBCommand()); 639 } 640 641 SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); } 642 643 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {} 644 645 bool SBCommand::IsValid() { 646 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid); 647 return this->operator bool(); 648 } 649 SBCommand::operator bool() const { 650 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool); 651 652 return m_opaque_sp.get() != nullptr; 653 } 654 655 const char *SBCommand::GetName() { 656 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName); 657 658 return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr); 659 } 660 661 const char *SBCommand::GetHelp() { 662 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp); 663 664 return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString() 665 : nullptr); 666 } 667 668 const char *SBCommand::GetHelpLong() { 669 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong); 670 671 return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString() 672 : nullptr); 673 } 674 675 void SBCommand::SetHelp(const char *help) { 676 LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help); 677 678 if (IsValid()) 679 m_opaque_sp->SetHelp(help); 680 } 681 682 void SBCommand::SetHelpLong(const char *help) { 683 LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help); 684 685 if (IsValid()) 686 m_opaque_sp->SetHelpLong(help); 687 } 688 689 lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name, 690 const char *help) { 691 LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, 692 (const char *, const char *), name, help); 693 694 if (!IsValid()) 695 return LLDB_RECORD_RESULT(lldb::SBCommand()); 696 if (!m_opaque_sp->IsMultiwordObject()) 697 return LLDB_RECORD_RESULT(lldb::SBCommand()); 698 CommandObjectMultiword *new_command = new CommandObjectMultiword( 699 m_opaque_sp->GetCommandInterpreter(), name, help); 700 new_command->SetRemovable(true); 701 lldb::CommandObjectSP new_command_sp(new_command); 702 if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) 703 return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); 704 return LLDB_RECORD_RESULT(lldb::SBCommand()); 705 } 706 707 lldb::SBCommand SBCommand::AddCommand(const char *name, 708 lldb::SBCommandPluginInterface *impl, 709 const char *help) { 710 LLDB_RECORD_METHOD( 711 lldb::SBCommand, SBCommand, AddCommand, 712 (const char *, lldb::SBCommandPluginInterface *, const char *), name, 713 impl, help); 714 return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr, 715 /*auto_repeat_command=*/"")) 716 } 717 718 lldb::SBCommand SBCommand::AddCommand(const char *name, 719 lldb::SBCommandPluginInterface *impl, 720 const char *help, const char *syntax) { 721 LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, 722 (const char *, lldb::SBCommandPluginInterface *, 723 const char *, const char *), 724 name, impl, help, syntax); 725 return LLDB_RECORD_RESULT( 726 AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"")) 727 } 728 729 lldb::SBCommand SBCommand::AddCommand(const char *name, 730 lldb::SBCommandPluginInterface *impl, 731 const char *help, const char *syntax, 732 const char *auto_repeat_command) { 733 LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, 734 (const char *, lldb::SBCommandPluginInterface *, 735 const char *, const char *, const char *), 736 name, impl, help, syntax, auto_repeat_command); 737 738 if (!IsValid()) 739 return LLDB_RECORD_RESULT(lldb::SBCommand()); 740 if (!m_opaque_sp->IsMultiwordObject()) 741 return LLDB_RECORD_RESULT(lldb::SBCommand()); 742 lldb::CommandObjectSP new_command_sp; 743 new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( 744 m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax, 745 /*flags=*/0, auto_repeat_command); 746 if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) 747 return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); 748 return LLDB_RECORD_RESULT(lldb::SBCommand()); 749 } 750 751 uint32_t SBCommand::GetFlags() { 752 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags); 753 754 return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0); 755 } 756 757 void SBCommand::SetFlags(uint32_t flags) { 758 LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags); 759 760 if (IsValid()) 761 m_opaque_sp->GetFlags().Set(flags); 762 } 763 764 namespace lldb_private { 765 namespace repro { 766 767 template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) { 768 LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, 769 (lldb_private::CommandInterpreter *)); 770 LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, 771 (const lldb::SBCommandInterpreter &)); 772 LLDB_REGISTER_METHOD( 773 const lldb::SBCommandInterpreter &, 774 SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &)); 775 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ()); 776 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ()); 777 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists, 778 (const char *)); 779 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists, 780 (const char *)); 781 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ()); 782 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ()); 783 LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter, 784 GetIOHandlerControlSequence, (char)); 785 LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, 786 HandleCommand, 787 (const char *, lldb::SBCommandReturnObject &, bool)); 788 LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, 789 HandleCommand, 790 (const char *, lldb::SBExecutionContext &, 791 lldb::SBCommandReturnObject &, bool)); 792 LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, 793 (lldb::SBFileSpec &, lldb::SBExecutionContext &, 794 lldb::SBCommandInterpreterRunOptions &, 795 lldb::SBCommandReturnObject)); 796 LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion, 797 (const char *, const char *, const char *, int, int, 798 lldb::SBStringList &)); 799 LLDB_REGISTER_METHOD(int, SBCommandInterpreter, 800 HandleCompletionWithDescriptions, 801 (const char *, const char *, const char *, int, int, 802 lldb::SBStringList &, lldb::SBStringList &)); 803 LLDB_REGISTER_METHOD(int, SBCommandInterpreter, 804 HandleCompletionWithDescriptions, 805 (const char *, uint32_t, int, int, 806 lldb::SBStringList &, lldb::SBStringList &)); 807 LLDB_REGISTER_METHOD( 808 int, SBCommandInterpreter, HandleCompletion, 809 (const char *, uint32_t, int, int, lldb::SBStringList &)); 810 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ()); 811 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ()); 812 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ()); 813 LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ()); 814 LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger, 815 ()); 816 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ()); 817 LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool)); 818 LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, 819 (bool)); 820 LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ()); 821 LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ()); 822 LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand, 823 (const char *, lldb::SBCommandReturnObject &)); 824 LLDB_REGISTER_METHOD(void, SBCommandInterpreter, 825 SourceInitFileInHomeDirectory, 826 (lldb::SBCommandReturnObject &)); 827 LLDB_REGISTER_METHOD(void, SBCommandInterpreter, 828 SourceInitFileInHomeDirectory, 829 (lldb::SBCommandReturnObject &, bool)); 830 LLDB_REGISTER_METHOD(void, SBCommandInterpreter, 831 SourceInitFileInCurrentWorkingDirectory, 832 (lldb::SBCommandReturnObject &)); 833 LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter, 834 GetBroadcaster, ()); 835 LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, 836 GetBroadcasterClass, ()); 837 LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, 838 GetArgumentTypeAsCString, 839 (const lldb::CommandArgumentType)); 840 LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, 841 GetArgumentDescriptionAsCString, 842 (const lldb::CommandArgumentType)); 843 LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter, 844 EventIsCommandInterpreterEvent, 845 (const lldb::SBEvent &)); 846 LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, 847 AddMultiwordCommand, (const char *, const char *)); 848 LLDB_REGISTER_METHOD( 849 lldb::SBCommand, SBCommandInterpreter, AddCommand, 850 (const char *, lldb::SBCommandPluginInterface *, const char *)); 851 LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, 852 (const char *, lldb::SBCommandPluginInterface *, 853 const char *, const char *)); 854 LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, 855 (const char *, lldb::SBCommandPluginInterface *, 856 const char *, const char *, const char *)); 857 LLDB_REGISTER_CONSTRUCTOR(SBCommand, ()); 858 LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ()); 859 LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ()); 860 LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ()); 861 LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ()); 862 LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ()); 863 LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *)); 864 LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *)); 865 LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, 866 (const char *, const char *)); 867 LLDB_REGISTER_METHOD( 868 lldb::SBCommand, SBCommand, AddCommand, 869 (const char *, lldb::SBCommandPluginInterface *, const char *)); 870 LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand, 871 (const char *, lldb::SBCommandPluginInterface *, 872 const char *, const char *)); 873 LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand, 874 (const char *, lldb::SBCommandPluginInterface *, 875 const char *, const char *, const char *)); 876 LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ()); 877 LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t)); 878 } 879 } 880 } 881