contrib/llvm/tools/lldb/source/API/SBCommandInterpreter.cpp

   1 //===-- SBCommandInterpreter.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-types.h"
  11
  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/SBCommandReturnObject.h"
  21 #include "lldb/API/SBEvent.h"
  22 #include "lldb/API/SBExecutionContext.h"
  23 #include "lldb/API/SBListener.h"
  24 #include "lldb/API/SBProcess.h"
  25 #include "lldb/API/SBStream.h"
  26 #include "lldb/API/SBStringList.h"
  27 #include "lldb/API/SBTarget.h"
  28
  29 using namespace lldb;
  30 using namespace lldb_private;
  31
  32 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
  33   m_opaque_up.reset(new CommandInterpreterRunOptions());
  34 }
  35
  36 SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
  37
  38 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
  39   return m_opaque_up->GetStopOnContinue();
  40 }
  41
  42 void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
  43   m_opaque_up->SetStopOnContinue(stop_on_continue);
  44 }
  45
  46 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
  47   return m_opaque_up->GetStopOnError();
  48 }
  49
  50 void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
  51   m_opaque_up->SetStopOnError(stop_on_error);
  52 }
  53
  54 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
  55   return m_opaque_up->GetStopOnCrash();
  56 }
  57
  58 void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
  59   m_opaque_up->SetStopOnCrash(stop_on_crash);
  60 }
  61
  62 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
  63   return m_opaque_up->GetEchoCommands();
  64 }
  65
  66 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
  67   m_opaque_up->SetEchoCommands(echo_commands);
  68 }
  69
  70 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
  71   return m_opaque_up->GetEchoCommentCommands();
  72 }
  73
  74 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
  75   m_opaque_up->SetEchoCommentCommands(echo);
  76 }
  77
  78 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
  79   return m_opaque_up->GetPrintResults();
  80 }
  81
  82 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
  83   m_opaque_up->SetPrintResults(print_results);
  84 }
  85
  86 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
  87   return m_opaque_up->GetAddToHistory();
  88 }
  89
  90 void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
  91   m_opaque_up->SetAddToHistory(add_to_history);
  92 }
  93
  94 lldb_private::CommandInterpreterRunOptions *
  95 SBCommandInterpreterRunOptions::get() const {
  96   return m_opaque_up.get();
  97 }
  98
  99 lldb_private::CommandInterpreterRunOptions &
 100 SBCommandInterpreterRunOptions::ref() const {
 101   return *m_opaque_up;
 102 }
 103
 104 class CommandPluginInterfaceImplementation : public CommandObjectParsed {
 105 public:
 106   CommandPluginInterfaceImplementation(CommandInterpreter &interpreter,
 107                                        const char *name,
 108                                        lldb::SBCommandPluginInterface *backend,
 109                                        const char *help = nullptr,
 110                                        const char *syntax = nullptr,
 111                                        uint32_t flags = 0)
 112       : CommandObjectParsed(interpreter, name, help, syntax, flags),
 113         m_backend(backend) {}
 114
 115   bool IsRemovable() const override { return true; }
 116
 117 protected:
 118   bool DoExecute(Args &command, CommandReturnObject &result) override {
 119     SBCommandReturnObject sb_return(&result);
 120     SBCommandInterpreter sb_interpreter(&m_interpreter);
 121     SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
 122     bool ret = m_backend->DoExecute(
 123         debugger_sb, (char **)command.GetArgumentVector(), sb_return);
 124     sb_return.Release();
 125     return ret;
 126   }
 127   std::shared_ptr<lldb::SBCommandPluginInterface> m_backend;
 128 };
 129
 130 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
 131     : m_opaque_ptr(interpreter) {
 132   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 133
 134   if (log)
 135     log->Printf("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
 136                 " => SBCommandInterpreter(%p)",
 137                 static_cast<void *>(interpreter),
 138                 static_cast<void *>(m_opaque_ptr));
 139 }
 140
 141 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
 142     : m_opaque_ptr(rhs.m_opaque_ptr) {}
 143
 144 SBCommandInterpreter::~SBCommandInterpreter() = default;
 145
 146 const SBCommandInterpreter &SBCommandInterpreter::
 147 operator=(const SBCommandInterpreter &rhs) {
 148   m_opaque_ptr = rhs.m_opaque_ptr;
 149   return *this;
 150 }
 151
 152 bool SBCommandInterpreter::IsValid() const { return m_opaque_ptr != nullptr; }
 153
 154 bool SBCommandInterpreter::CommandExists(const char *cmd) {
 155   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
 156                                           : false);
 157 }
 158
 159 bool SBCommandInterpreter::AliasExists(const char *cmd) {
 160   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
 161                                           : false);
 162 }
 163
 164 bool SBCommandInterpreter::IsActive() {
 165   return (IsValid() ? m_opaque_ptr->IsActive() : false);
 166 }
 167
 168 bool SBCommandInterpreter::WasInterrupted() const {
 169   return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
 170 }
 171
 172 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
 173   return (IsValid()
 174               ? m_opaque_ptr->GetDebugger()
 175                     .GetTopIOHandlerControlSequence(ch)
 176                     .GetCString()
 177               : nullptr);
 178 }
 179
 180 lldb::ReturnStatus
 181 SBCommandInterpreter::HandleCommand(const char *command_line,
 182                                     SBCommandReturnObject &result,
 183                                     bool add_to_history) {
 184   SBExecutionContext sb_exe_ctx;
 185   return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
 186 }
 187
 188 lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
 189     const char *command_line, SBExecutionContext &override_context,
 190     SBCommandReturnObject &result, bool add_to_history) {
 191   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 192
 193   if (log)
 194     log->Printf("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", "
 195                 "SBCommandReturnObject(%p), add_to_history=%i)",
 196                 static_cast<void *>(m_opaque_ptr), command_line,
 197                 static_cast<void *>(result.get()), add_to_history);
 198
 199   ExecutionContext ctx, *ctx_ptr;
 200   if (override_context.get()) {
 201     ctx = override_context.get()->Lock(true);
 202     ctx_ptr = &ctx;
 203   } else
 204     ctx_ptr = nullptr;
 205
 206   result.Clear();
 207   if (command_line && IsValid()) {
 208     result.ref().SetInteractive(false);
 209     m_opaque_ptr->HandleCommand(command_line,
 210                                 add_to_history ? eLazyBoolYes : eLazyBoolNo,
 211                                 result.ref(), ctx_ptr);
 212   } else {
 213     result->AppendError(
 214         "SBCommandInterpreter or the command line is not valid");
 215     result->SetStatus(eReturnStatusFailed);
 216   }
 217
 218   // We need to get the value again, in case the command disabled the log!
 219   log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API);
 220   if (log) {
 221     SBStream sstr;
 222     result.GetDescription(sstr);
 223     log->Printf("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", "
 224                 "SBCommandReturnObject(%p): %s, add_to_history=%i) => %i",
 225                 static_cast<void *>(m_opaque_ptr), command_line,
 226                 static_cast<void *>(result.get()), sstr.GetData(),
 227                 add_to_history, result.GetStatus());
 228   }
 229
 230   return result.GetStatus();
 231 }
 232
 233 void SBCommandInterpreter::HandleCommandsFromFile(
 234     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
 235     lldb::SBCommandInterpreterRunOptions &options,
 236     lldb::SBCommandReturnObject result) {
 237   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 238
 239   if (log) {
 240     SBStream s;
 241     file.GetDescription(s);
 242     log->Printf("SBCommandInterpreter(%p)::HandleCommandsFromFile "
 243                 "(file=\"%s\", SBCommandReturnObject(%p))",
 244                 static_cast<void *>(m_opaque_ptr), s.GetData(),
 245                 static_cast<void *>(result.get()));
 246   }
 247
 248   if (!IsValid()) {
 249     result->AppendError("SBCommandInterpreter is not valid.");
 250     result->SetStatus(eReturnStatusFailed);
 251     return;
 252   }
 253
 254   if (!file.IsValid()) {
 255     SBStream s;
 256     file.GetDescription(s);
 257     result->AppendErrorWithFormat("File is not valid: %s.", s.GetData());
 258     result->SetStatus(eReturnStatusFailed);
 259   }
 260
 261   FileSpec tmp_spec = file.ref();
 262   ExecutionContext ctx, *ctx_ptr;
 263   if (override_context.get()) {
 264     ctx = override_context.get()->Lock(true);
 265     ctx_ptr = &ctx;
 266   } else
 267     ctx_ptr = nullptr;
 268
 269   m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(),
 270                                        result.ref());
 271 }
 272
 273 int SBCommandInterpreter::HandleCompletion(
 274     const char *current_line, const char *cursor, const char *last_char,
 275     int match_start_point, int max_return_elements, SBStringList &matches) {
 276   SBStringList dummy_descriptions;
 277   return HandleCompletionWithDescriptions(
 278       current_line, cursor, last_char, match_start_point, max_return_elements,
 279       matches, dummy_descriptions);
 280 }
 281
 282 int SBCommandInterpreter::HandleCompletionWithDescriptions(
 283     const char *current_line, const char *cursor, const char *last_char,
 284     int match_start_point, int max_return_elements, SBStringList &matches,
 285     SBStringList &descriptions) {
 286   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 287   int num_completions = 0;
 288
 289   // Sanity check the arguments that are passed in: cursor & last_char have to
 290   // be within the current_line.
 291   if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
 292     return 0;
 293
 294   if (cursor < current_line || last_char < current_line)
 295     return 0;
 296
 297   size_t current_line_size = strlen(current_line);
 298   if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
 299       last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
 300     return 0;
 301
 302   if (log)
 303     log->Printf("SBCommandInterpreter(%p)::HandleCompletion "
 304                 "(current_line=\"%s\", cursor at: %" PRId64
 305                 ", last char at: %" PRId64
 306                 ", match_start_point: %d, max_return_elements: %d)",
 307                 static_cast<void *>(m_opaque_ptr), current_line,
 308                 static_cast<uint64_t>(cursor - current_line),
 309                 static_cast<uint64_t>(last_char - current_line),
 310                 match_start_point, max_return_elements);
 311
 312   if (IsValid()) {
 313     lldb_private::StringList lldb_matches, lldb_descriptions;
 314     num_completions = m_opaque_ptr->HandleCompletion(
 315         current_line, cursor, last_char, match_start_point, max_return_elements,
 316         lldb_matches, lldb_descriptions);
 317
 318     SBStringList temp_matches_list(&lldb_matches);
 319     matches.AppendList(temp_matches_list);
 320     SBStringList temp_descriptions_list(&lldb_descriptions);
 321     descriptions.AppendList(temp_descriptions_list);
 322   }
 323   if (log)
 324     log->Printf(
 325         "SBCommandInterpreter(%p)::HandleCompletion - Found %d completions.",
 326         static_cast<void *>(m_opaque_ptr), num_completions);
 327
 328   return num_completions;
 329 }
 330
 331 int SBCommandInterpreter::HandleCompletionWithDescriptions(
 332     const char *current_line, uint32_t cursor_pos, int match_start_point,
 333     int max_return_elements, SBStringList &matches,
 334     SBStringList &descriptions) {
 335   const char *cursor = current_line + cursor_pos;
 336   const char *last_char = current_line + strlen(current_line);
 337   return HandleCompletionWithDescriptions(
 338       current_line, cursor, last_char, match_start_point, max_return_elements,
 339       matches, descriptions);
 340 }
 341
 342 int SBCommandInterpreter::HandleCompletion(const char *current_line,
 343                                            uint32_t cursor_pos,
 344                                            int match_start_point,
 345                                            int max_return_elements,
 346                                            lldb::SBStringList &matches) {
 347   const char *cursor = current_line + cursor_pos;
 348   const char *last_char = current_line + strlen(current_line);
 349   return HandleCompletion(current_line, cursor, last_char, match_start_point,
 350                           max_return_elements, matches);
 351 }
 352
 353 bool SBCommandInterpreter::HasCommands() {
 354   return (IsValid() ? m_opaque_ptr->HasCommands() : false);
 355 }
 356
 357 bool SBCommandInterpreter::HasAliases() {
 358   return (IsValid() ? m_opaque_ptr->HasAliases() : false);
 359 }
 360
 361 bool SBCommandInterpreter::HasAliasOptions() {
 362   return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
 363 }
 364
 365 SBProcess SBCommandInterpreter::GetProcess() {
 366   SBProcess sb_process;
 367   ProcessSP process_sp;
 368   if (IsValid()) {
 369     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
 370     if (target_sp) {
 371       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 372       process_sp = target_sp->GetProcessSP();
 373       sb_process.SetSP(process_sp);
 374     }
 375   }
 376   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 377
 378   if (log)
 379     log->Printf("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
 380                 static_cast<void *>(m_opaque_ptr),
 381                 static_cast<void *>(process_sp.get()));
 382
 383   return sb_process;
 384 }
 385
 386 SBDebugger SBCommandInterpreter::GetDebugger() {
 387   SBDebugger sb_debugger;
 388   if (IsValid())
 389     sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
 390   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 391
 392   if (log)
 393     log->Printf("SBCommandInterpreter(%p)::GetDebugger () => SBDebugger(%p)",
 394                 static_cast<void *>(m_opaque_ptr),
 395                 static_cast<void *>(sb_debugger.get()));
 396
 397   return sb_debugger;
 398 }
 399
 400 bool SBCommandInterpreter::GetPromptOnQuit() {
 401   return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
 402 }
 403
 404 void SBCommandInterpreter::SetPromptOnQuit(bool b) {
 405   if (IsValid())
 406     m_opaque_ptr->SetPromptOnQuit(b);
 407 }
 408
 409 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
 410   if (m_opaque_ptr)
 411     m_opaque_ptr->AllowExitCodeOnQuit(allow);
 412 }
 413
 414 bool SBCommandInterpreter::HasCustomQuitExitCode() {
 415   bool exited = false;
 416   if (m_opaque_ptr)
 417     m_opaque_ptr->GetQuitExitCode(exited);
 418   return exited;
 419 }
 420
 421 int SBCommandInterpreter::GetQuitStatus() {
 422   bool exited = false;
 423   return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
 424 }
 425
 426 void SBCommandInterpreter::ResolveCommand(const char *command_line,
 427                                           SBCommandReturnObject &result) {
 428   result.Clear();
 429   if (command_line && IsValid()) {
 430     m_opaque_ptr->ResolveCommand(command_line, result.ref());
 431   } else {
 432     result->AppendError(
 433         "SBCommandInterpreter or the command line is not valid");
 434     result->SetStatus(eReturnStatusFailed);
 435   }
 436 }
 437
 438 CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; }
 439
 440 CommandInterpreter &SBCommandInterpreter::ref() {
 441   assert(m_opaque_ptr);
 442   return *m_opaque_ptr;
 443 }
 444
 445 void SBCommandInterpreter::reset(
 446     lldb_private::CommandInterpreter *interpreter) {
 447   m_opaque_ptr = interpreter;
 448 }
 449
 450 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
 451     SBCommandReturnObject &result) {
 452   result.Clear();
 453   if (IsValid()) {
 454     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
 455     std::unique_lock<std::recursive_mutex> lock;
 456     if (target_sp)
 457       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 458     m_opaque_ptr->SourceInitFile(false, result.ref());
 459   } else {
 460     result->AppendError("SBCommandInterpreter is not valid");
 461     result->SetStatus(eReturnStatusFailed);
 462   }
 463   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 464
 465   if (log)
 466     log->Printf("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory "
 467                 "(&SBCommandReturnObject(%p))",
 468                 static_cast<void *>(m_opaque_ptr),
 469                 static_cast<void *>(result.get()));
 470 }
 471
 472 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
 473     SBCommandReturnObject &result) {
 474   result.Clear();
 475   if (IsValid()) {
 476     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
 477     std::unique_lock<std::recursive_mutex> lock;
 478     if (target_sp)
 479       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 480     m_opaque_ptr->SourceInitFile(true, result.ref());
 481   } else {
 482     result->AppendError("SBCommandInterpreter is not valid");
 483     result->SetStatus(eReturnStatusFailed);
 484   }
 485   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 486
 487   if (log)
 488     log->Printf(
 489         "SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory "
 490         "(&SBCommandReturnObject(%p))",
 491         static_cast<void *>(m_opaque_ptr), static_cast<void *>(result.get()));
 492 }
 493
 494 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
 495   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 496
 497   SBBroadcaster broadcaster(m_opaque_ptr, false);
 498
 499   if (log)
 500     log->Printf(
 501         "SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
 502         static_cast<void *>(m_opaque_ptr),
 503         static_cast<void *>(broadcaster.get()));
 504
 505   return broadcaster;
 506 }
 507
 508 const char *SBCommandInterpreter::GetBroadcasterClass() {
 509   return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
 510 }
 511
 512 const char *SBCommandInterpreter::GetArgumentTypeAsCString(
 513     const lldb::CommandArgumentType arg_type) {
 514   return CommandObject::GetArgumentTypeAsCString(arg_type);
 515 }
 516
 517 const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
 518     const lldb::CommandArgumentType arg_type) {
 519   return CommandObject::GetArgumentDescriptionAsCString(arg_type);
 520 }
 521
 522 bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
 523     const lldb::SBEvent &event) {
 524   return event.GetBroadcasterClass() ==
 525          SBCommandInterpreter::GetBroadcasterClass();
 526 }
 527
 528 bool SBCommandInterpreter::SetCommandOverrideCallback(
 529     const char *command_name, lldb::CommandOverrideCallback callback,
 530     void *baton) {
 531   if (command_name && command_name[0] && IsValid()) {
 532     llvm::StringRef command_name_str = command_name;
 533     CommandObject *cmd_obj =
 534         m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
 535     if (cmd_obj) {
 536       assert(command_name_str.empty());
 537       cmd_obj->SetOverrideCallback(callback, baton);
 538       return true;
 539     }
 540   }
 541   return false;
 542 }
 543
 544 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
 545                                                           const char *help) {
 546   CommandObjectMultiword *new_command =
 547       new CommandObjectMultiword(*m_opaque_ptr, name, help);
 548   new_command->SetRemovable(true);
 549   lldb::CommandObjectSP new_command_sp(new_command);
 550   if (new_command_sp &&
 551       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
 552     return lldb::SBCommand(new_command_sp);
 553   return lldb::SBCommand();
 554 }
 555
 556 lldb::SBCommand SBCommandInterpreter::AddCommand(
 557     const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
 558   lldb::CommandObjectSP new_command_sp;
 559   new_command_sp.reset(new CommandPluginInterfaceImplementation(
 560       *m_opaque_ptr, name, impl, help));
 561
 562   if (new_command_sp &&
 563       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
 564     return lldb::SBCommand(new_command_sp);
 565   return lldb::SBCommand();
 566 }
 567
 568 lldb::SBCommand
 569 SBCommandInterpreter::AddCommand(const char *name,
 570                                  lldb::SBCommandPluginInterface *impl,
 571                                  const char *help, const char *syntax) {
 572   lldb::CommandObjectSP new_command_sp;
 573   new_command_sp.reset(new CommandPluginInterfaceImplementation(
 574       *m_opaque_ptr, name, impl, help, syntax));
 575
 576   if (new_command_sp &&
 577       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
 578     return lldb::SBCommand(new_command_sp);
 579   return lldb::SBCommand();
 580 }
 581
 582 SBCommand::SBCommand() = default;
 583
 584 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
 585
 586 bool SBCommand::IsValid() { return m_opaque_sp.get() != nullptr; }
 587
 588 const char *SBCommand::GetName() {
 589   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
 590 }
 591
 592 const char *SBCommand::GetHelp() {
 593   return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
 594                     : nullptr);
 595 }
 596
 597 const char *SBCommand::GetHelpLong() {
 598   return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
 599                     : nullptr);
 600 }
 601
 602 void SBCommand::SetHelp(const char *help) {
 603   if (IsValid())
 604     m_opaque_sp->SetHelp(help);
 605 }
 606
 607 void SBCommand::SetHelpLong(const char *help) {
 608   if (IsValid())
 609     m_opaque_sp->SetHelpLong(help);
 610 }
 611
 612 lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
 613                                                const char *help) {
 614   if (!IsValid())
 615     return lldb::SBCommand();
 616   if (!m_opaque_sp->IsMultiwordObject())
 617     return lldb::SBCommand();
 618   CommandObjectMultiword *new_command = new CommandObjectMultiword(
 619       m_opaque_sp->GetCommandInterpreter(), name, help);
 620   new_command->SetRemovable(true);
 621   lldb::CommandObjectSP new_command_sp(new_command);
 622   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
 623     return lldb::SBCommand(new_command_sp);
 624   return lldb::SBCommand();
 625 }
 626
 627 lldb::SBCommand SBCommand::AddCommand(const char *name,
 628                                       lldb::SBCommandPluginInterface *impl,
 629                                       const char *help) {
 630   if (!IsValid())
 631     return lldb::SBCommand();
 632   if (!m_opaque_sp->IsMultiwordObject())
 633     return lldb::SBCommand();
 634   lldb::CommandObjectSP new_command_sp;
 635   new_command_sp.reset(new CommandPluginInterfaceImplementation(
 636       m_opaque_sp->GetCommandInterpreter(), name, impl, help));
 637   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
 638     return lldb::SBCommand(new_command_sp);
 639   return lldb::SBCommand();
 640 }
 641
 642 lldb::SBCommand SBCommand::AddCommand(const char *name,
 643                                       lldb::SBCommandPluginInterface *impl,
 644                                       const char *help, const char *syntax) {
 645   if (!IsValid())
 646     return lldb::SBCommand();
 647   if (!m_opaque_sp->IsMultiwordObject())
 648     return lldb::SBCommand();
 649   lldb::CommandObjectSP new_command_sp;
 650   new_command_sp.reset(new CommandPluginInterfaceImplementation(
 651       m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax));
 652   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
 653     return lldb::SBCommand(new_command_sp);
 654   return lldb::SBCommand();
 655 }
 656
 657 uint32_t SBCommand::GetFlags() {
 658   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
 659 }
 660
 661 void SBCommand::SetFlags(uint32_t flags) {
 662   if (IsValid())
 663     m_opaque_sp->GetFlags().Set(flags);
 664 }