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