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-python.h"
  11
  12 #include "lldb/lldb-types.h"
  13 #include "lldb/Core/SourceManager.h"
  14 #include "lldb/Core/Listener.h"
  15 #include "lldb/Interpreter/CommandInterpreter.h"
  16 #include "lldb/Interpreter/CommandObjectMultiword.h"
  17 #include "lldb/Interpreter/CommandReturnObject.h"
  18 #include "lldb/Target/Target.h"
  19
  20 #include "lldb/API/SBBroadcaster.h"
  21 #include "lldb/API/SBCommandReturnObject.h"
  22 #include "lldb/API/SBCommandInterpreter.h"
  23 #include "lldb/API/SBProcess.h"
  24 #include "lldb/API/SBTarget.h"
  25 #include "lldb/API/SBListener.h"
  26 #include "lldb/API/SBStream.h"
  27 #include "lldb/API/SBStringList.h"
  28
  29 using namespace lldb;
  30 using namespace lldb_private;
  31
  32 class CommandPluginInterfaceImplementation : public CommandObjectParsed
  33 {
  34 public:
  35     CommandPluginInterfaceImplementation (CommandInterpreter &interpreter,
  36                                           const char *name,
  37                                           lldb::SBCommandPluginInterface* backend,
  38                                           const char *help = NULL,
  39                                           const char *syntax = NULL,
  40                                           uint32_t flags = 0) :
  41     CommandObjectParsed (interpreter, name, help, syntax, flags),
  42     m_backend(backend) {}
  43
  44     virtual bool
  45     IsRemovable() const { return true; }
  46
  47 protected:
  48     virtual bool
  49     DoExecute (Args& command, CommandReturnObject &result)
  50     {
  51         SBCommandReturnObject sb_return(&result);
  52         SBCommandInterpreter sb_interpreter(&m_interpreter);
  53         SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
  54         bool ret = m_backend->DoExecute (debugger_sb,(char**)command.GetArgumentVector(), sb_return);
  55         sb_return.Release();
  56         return ret;
  57     }
  58     lldb::SBCommandPluginInterface* m_backend;
  59 };
  60
  61 SBCommandInterpreter::SBCommandInterpreter (CommandInterpreter *interpreter) :
  62     m_opaque_ptr (interpreter)
  63 {
  64     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  65
  66     if (log)
  67         log->Printf ("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
  68                      " => SBCommandInterpreter(%p)", interpreter, m_opaque_ptr);
  69 }
  70
  71 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) :
  72     m_opaque_ptr (rhs.m_opaque_ptr)
  73 {
  74 }
  75
  76 const SBCommandInterpreter &
  77 SBCommandInterpreter::operator = (const SBCommandInterpreter &rhs)
  78 {
  79     m_opaque_ptr = rhs.m_opaque_ptr;
  80     return *this;
  81 }
  82
  83 SBCommandInterpreter::~SBCommandInterpreter ()
  84 {
  85 }
  86
  87 bool
  88 SBCommandInterpreter::IsValid() const
  89 {
  90     return m_opaque_ptr != NULL;
  91 }
  92
  93
  94 bool
  95 SBCommandInterpreter::CommandExists (const char *cmd)
  96 {
  97     if (cmd && m_opaque_ptr)
  98         return m_opaque_ptr->CommandExists (cmd);
  99     return false;
 100 }
 101
 102 bool
 103 SBCommandInterpreter::AliasExists (const char *cmd)
 104 {
 105     if (cmd && m_opaque_ptr)
 106         return m_opaque_ptr->AliasExists (cmd);
 107     return false;
 108 }
 109
 110 bool
 111 SBCommandInterpreter::IsActive ()
 112 {
 113     if (m_opaque_ptr)
 114         return m_opaque_ptr->IsActive ();
 115     return false;
 116 }
 117
 118 const char *
 119 SBCommandInterpreter::GetIOHandlerControlSequence(char ch)
 120 {
 121     if (m_opaque_ptr)
 122         return m_opaque_ptr->GetDebugger().GetTopIOHandlerControlSequence (ch).GetCString();
 123     return NULL;
 124 }
 125
 126 lldb::ReturnStatus
 127 SBCommandInterpreter::HandleCommand (const char *command_line, SBCommandReturnObject &result, bool add_to_history)
 128 {
 129     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 130
 131     if (log)
 132         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p), add_to_history=%i)",
 133                      m_opaque_ptr, command_line, result.get(), add_to_history);
 134
 135     result.Clear();
 136     if (command_line && m_opaque_ptr)
 137     {
 138         m_opaque_ptr->HandleCommand (command_line, add_to_history ? eLazyBoolYes : eLazyBoolNo, result.ref());
 139     }
 140     else
 141     {
 142         result->AppendError ("SBCommandInterpreter or the command line is not valid");
 143         result->SetStatus (eReturnStatusFailed);
 144     }
 145
 146     // We need to get the value again, in case the command disabled the log!
 147     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
 148     if (log)
 149     {
 150         SBStream sstr;
 151         result.GetDescription (sstr);
 152         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p): %s, add_to_history=%i) => %i",
 153                      m_opaque_ptr, command_line, result.get(), sstr.GetData(), add_to_history, result.GetStatus());
 154     }
 155
 156     return result.GetStatus();
 157 }
 158
 159 int
 160 SBCommandInterpreter::HandleCompletion (const char *current_line,
 161                                         const char *cursor,
 162                                         const char *last_char,
 163                                         int match_start_point,
 164                                         int max_return_elements,
 165                                         SBStringList &matches)
 166 {
 167     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 168     int num_completions = 0;
 169
 170     // Sanity check the arguments that are passed in:
 171     // cursor & last_char have to be within the current_line.
 172     if (current_line == NULL || cursor == NULL || last_char == NULL)
 173         return 0;
 174
 175     if (cursor < current_line || last_char < current_line)
 176         return 0;
 177
 178     size_t current_line_size = strlen (current_line);
 179     if (cursor - current_line > current_line_size || last_char - current_line > current_line_size)
 180         return 0;
 181
 182     if (log)
 183         log->Printf ("SBCommandInterpreter(%p)::HandleCompletion (current_line=\"%s\", cursor at: %" PRId64 ", last char at: %" PRId64 ", match_start_point: %d, max_return_elements: %d)",
 184                      m_opaque_ptr, current_line, (uint64_t) (cursor - current_line), (uint64_t) (last_char - current_line), match_start_point, max_return_elements);
 185
 186     if (m_opaque_ptr)
 187     {
 188         lldb_private::StringList lldb_matches;
 189         num_completions =  m_opaque_ptr->HandleCompletion (current_line, cursor, last_char, match_start_point,
 190                                                            max_return_elements, lldb_matches);
 191
 192         SBStringList temp_list (&lldb_matches);
 193         matches.AppendList (temp_list);
 194     }
 195     if (log)
 196         log->Printf ("SBCommandInterpreter(%p)::HandleCompletion - Found %d completions.", m_opaque_ptr, num_completions);
 197
 198     return num_completions;
 199 }
 200
 201 int
 202 SBCommandInterpreter::HandleCompletion (const char *current_line,
 203                   uint32_t cursor_pos,
 204                   int match_start_point,
 205                   int max_return_elements,
 206                   lldb::SBStringList &matches)
 207 {
 208     const char *cursor = current_line + cursor_pos;
 209     const char *last_char = current_line + strlen (current_line);
 210     return HandleCompletion (current_line, cursor, last_char, match_start_point, max_return_elements, matches);
 211 }
 212
 213 bool
 214 SBCommandInterpreter::HasCommands ()
 215 {
 216     if (m_opaque_ptr)
 217         return m_opaque_ptr->HasCommands();
 218     return false;
 219 }
 220
 221 bool
 222 SBCommandInterpreter::HasAliases ()
 223 {
 224     if (m_opaque_ptr)
 225         return m_opaque_ptr->HasAliases();
 226     return false;
 227 }
 228
 229 bool
 230 SBCommandInterpreter::HasAliasOptions ()
 231 {
 232     if (m_opaque_ptr)
 233         return m_opaque_ptr->HasAliasOptions ();
 234     return false;
 235 }
 236
 237 SBProcess
 238 SBCommandInterpreter::GetProcess ()
 239 {
 240     SBProcess sb_process;
 241     ProcessSP process_sp;
 242     if (m_opaque_ptr)
 243     {
 244         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
 245         if (target_sp)
 246         {
 247             Mutex::Locker api_locker(target_sp->GetAPIMutex());
 248             process_sp = target_sp->GetProcessSP();
 249             sb_process.SetSP(process_sp);
 250         }
 251     }
 252     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 253
 254     if (log)
 255         log->Printf ("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
 256                      m_opaque_ptr, process_sp.get());
 257
 258
 259     return sb_process;
 260 }
 261
 262 SBDebugger
 263 SBCommandInterpreter::GetDebugger ()
 264 {
 265     SBDebugger sb_debugger;
 266     if (m_opaque_ptr)
 267         sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
 268     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 269
 270     if (log)
 271         log->Printf ("SBCommandInterpreter(%p)::GetDebugger () => SBDebugger(%p)",
 272                      m_opaque_ptr, sb_debugger.get());
 273
 274
 275     return sb_debugger;
 276 }
 277
 278 CommandInterpreter *
 279 SBCommandInterpreter::get ()
 280 {
 281     return m_opaque_ptr;
 282 }
 283
 284 CommandInterpreter &
 285 SBCommandInterpreter::ref ()
 286 {
 287     assert (m_opaque_ptr);
 288     return *m_opaque_ptr;
 289 }
 290
 291 void
 292 SBCommandInterpreter::reset (lldb_private::CommandInterpreter *interpreter)
 293 {
 294     m_opaque_ptr = interpreter;
 295 }
 296
 297 void
 298 SBCommandInterpreter::SourceInitFileInHomeDirectory (SBCommandReturnObject &result)
 299 {
 300     result.Clear();
 301     if (m_opaque_ptr)
 302     {
 303         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
 304         Mutex::Locker api_locker;
 305         if (target_sp)
 306             api_locker.Lock(target_sp->GetAPIMutex());
 307         m_opaque_ptr->SourceInitFile (false, result.ref());
 308     }
 309     else
 310     {
 311         result->AppendError ("SBCommandInterpreter is not valid");
 312         result->SetStatus (eReturnStatusFailed);
 313     }
 314     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 315
 316     if (log)
 317         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory (&SBCommandReturnObject(%p))",
 318                      m_opaque_ptr, result.get());
 319
 320 }
 321
 322 void
 323 SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory (SBCommandReturnObject &result)
 324 {
 325     result.Clear();
 326     if (m_opaque_ptr)
 327     {
 328         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
 329         Mutex::Locker api_locker;
 330         if (target_sp)
 331             api_locker.Lock(target_sp->GetAPIMutex());
 332         m_opaque_ptr->SourceInitFile (true, result.ref());
 333     }
 334     else
 335     {
 336         result->AppendError ("SBCommandInterpreter is not valid");
 337         result->SetStatus (eReturnStatusFailed);
 338     }
 339     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 340
 341     if (log)
 342         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory (&SBCommandReturnObject(%p))",
 343                      m_opaque_ptr, result.get());
 344 }
 345
 346 SBBroadcaster
 347 SBCommandInterpreter::GetBroadcaster ()
 348 {
 349     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 350
 351     SBBroadcaster broadcaster (m_opaque_ptr, false);
 352
 353     if (log)
 354         log->Printf ("SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
 355                      m_opaque_ptr, broadcaster.get());
 356
 357     return broadcaster;
 358 }
 359
 360 const char *
 361 SBCommandInterpreter::GetBroadcasterClass ()
 362 {
 363     return Communication::GetStaticBroadcasterClass().AsCString();
 364 }
 365
 366 const char *
 367 SBCommandInterpreter::GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type)
 368 {
 369     return CommandObject::GetArgumentTypeAsCString (arg_type);
 370 }
 371
 372 const char *
 373 SBCommandInterpreter::GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type)
 374 {
 375     return CommandObject::GetArgumentDescriptionAsCString (arg_type);
 376 }
 377
 378 bool
 379 SBCommandInterpreter::SetCommandOverrideCallback (const char *command_name,
 380                                                   lldb::CommandOverrideCallback callback,
 381                                                   void *baton)
 382 {
 383     if (command_name && command_name[0] && m_opaque_ptr)
 384     {
 385         std::string command_name_str (command_name);
 386         CommandObject *cmd_obj = m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
 387         if (cmd_obj)
 388         {
 389             assert(command_name_str.empty());
 390             cmd_obj->SetOverrideCallback (callback, baton);
 391             return true;
 392         }
 393     }
 394     return false;
 395 }
 396
 397 #ifndef LLDB_DISABLE_PYTHON
 398
 399 // Defined in the SWIG source file
 400 extern "C" void
 401 init_lldb(void);
 402
 403 // these are the Pythonic implementations of the required callbacks
 404 // these are scripting-language specific, which is why they belong here
 405 // we still need to use function pointers to them instead of relying
 406 // on linkage-time resolution because the SWIG stuff and this file
 407 // get built at different times
 408 extern "C" bool
 409 LLDBSwigPythonBreakpointCallbackFunction (const char *python_function_name,
 410                                           const char *session_dictionary_name,
 411                                           const lldb::StackFrameSP& sb_frame,
 412                                           const lldb::BreakpointLocationSP& sb_bp_loc);
 413
 414 extern "C" bool
 415 LLDBSwigPythonWatchpointCallbackFunction (const char *python_function_name,
 416                                           const char *session_dictionary_name,
 417                                           const lldb::StackFrameSP& sb_frame,
 418                                           const lldb::WatchpointSP& sb_wp);
 419
 420 extern "C" bool
 421 LLDBSwigPythonCallTypeScript (const char *python_function_name,
 422                               void *session_dictionary,
 423                               const lldb::ValueObjectSP& valobj_sp,
 424                               void** pyfunct_wrapper,
 425                               std::string& retval);
 426
 427 extern "C" void*
 428 LLDBSwigPythonCreateSyntheticProvider (const char *python_class_name,
 429                                        const char *session_dictionary_name,
 430                                        const lldb::ValueObjectSP& valobj_sp);
 431
 432
 433 extern "C" uint32_t
 434 LLDBSwigPython_CalculateNumChildren (void *implementor);
 435
 436 extern "C" void *
 437 LLDBSwigPython_GetChildAtIndex (void *implementor, uint32_t idx);
 438
 439 extern "C" int
 440 LLDBSwigPython_GetIndexOfChildWithName (void *implementor, const char* child_name);
 441
 442 extern "C" void *
 443 LLDBSWIGPython_CastPyObjectToSBValue (void* data);
 444
 445 extern lldb::ValueObjectSP
 446 LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data);
 447
 448 extern "C" bool
 449 LLDBSwigPython_UpdateSynthProviderInstance (void* implementor);
 450
 451 extern "C" bool
 452 LLDBSwigPython_MightHaveChildrenSynthProviderInstance (void* implementor);
 453
 454 extern "C" bool
 455 LLDBSwigPythonCallCommand (const char *python_function_name,
 456                            const char *session_dictionary_name,
 457                            lldb::DebuggerSP& debugger,
 458                            const char* args,
 459                            lldb_private::CommandReturnObject &cmd_retobj);
 460
 461 extern "C" bool
 462 LLDBSwigPythonCallModuleInit (const char *python_module_name,
 463                               const char *session_dictionary_name,
 464                               lldb::DebuggerSP& debugger);
 465
 466 extern "C" void*
 467 LLDBSWIGPythonCreateOSPlugin (const char *python_class_name,
 468                               const char *session_dictionary_name,
 469                               const lldb::ProcessSP& process_sp);
 470
 471 extern "C" bool
 472 LLDBSWIGPythonRunScriptKeywordProcess (const char* python_function_name,
 473                                        const char* session_dictionary_name,
 474                                        lldb::ProcessSP& process,
 475                                        std::string& output);
 476
 477 extern "C" bool
 478 LLDBSWIGPythonRunScriptKeywordThread (const char* python_function_name,
 479                                       const char* session_dictionary_name,
 480                                       lldb::ThreadSP& thread,
 481                                       std::string& output);
 482
 483 extern "C" bool
 484 LLDBSWIGPythonRunScriptKeywordTarget (const char* python_function_name,
 485                                       const char* session_dictionary_name,
 486                                       lldb::TargetSP& target,
 487                                       std::string& output);
 488
 489 extern "C" bool
 490 LLDBSWIGPythonRunScriptKeywordFrame (const char* python_function_name,
 491                                      const char* session_dictionary_name,
 492                                      lldb::StackFrameSP& frame,
 493                                      std::string& output);
 494
 495 extern "C" void*
 496 LLDBSWIGPython_GetDynamicSetting (void* module,
 497                                   const char* setting,
 498                                   const lldb::TargetSP& target_sp);
 499
 500
 501 #endif
 502
 503 void
 504 SBCommandInterpreter::InitializeSWIG ()
 505 {
 506     static bool g_initialized = false;
 507     if (!g_initialized)
 508     {
 509         g_initialized = true;
 510 #ifndef LLDB_DISABLE_PYTHON
 511         ScriptInterpreter::InitializeInterpreter (init_lldb,
 512                                                   LLDBSwigPythonBreakpointCallbackFunction,
 513                                                   LLDBSwigPythonWatchpointCallbackFunction,
 514                                                   LLDBSwigPythonCallTypeScript,
 515                                                   LLDBSwigPythonCreateSyntheticProvider,
 516                                                   LLDBSwigPython_CalculateNumChildren,
 517                                                   LLDBSwigPython_GetChildAtIndex,
 518                                                   LLDBSwigPython_GetIndexOfChildWithName,
 519                                                   LLDBSWIGPython_CastPyObjectToSBValue,
 520                                                   LLDBSWIGPython_GetValueObjectSPFromSBValue,
 521                                                   LLDBSwigPython_UpdateSynthProviderInstance,
 522                                                   LLDBSwigPython_MightHaveChildrenSynthProviderInstance,
 523                                                   LLDBSwigPythonCallCommand,
 524                                                   LLDBSwigPythonCallModuleInit,
 525                                                   LLDBSWIGPythonCreateOSPlugin,
 526                                                   LLDBSWIGPythonRunScriptKeywordProcess,
 527                                                   LLDBSWIGPythonRunScriptKeywordThread,
 528                                                   LLDBSWIGPythonRunScriptKeywordTarget,
 529                                                   LLDBSWIGPythonRunScriptKeywordFrame,
 530                                                   LLDBSWIGPython_GetDynamicSetting);
 531 #endif
 532     }
 533 }
 534
 535 lldb::SBCommand
 536 SBCommandInterpreter::AddMultiwordCommand (const char* name, const char* help)
 537 {
 538     CommandObjectMultiword *new_command = new CommandObjectMultiword(*m_opaque_ptr,name,help);
 539     new_command->SetRemovable (true);
 540     lldb::CommandObjectSP new_command_sp(new_command);
 541     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
 542         return lldb::SBCommand(new_command_sp);
 543     return lldb::SBCommand();
 544 }
 545
 546 lldb::SBCommand
 547 SBCommandInterpreter::AddCommand (const char* name, lldb::SBCommandPluginInterface* impl, const char* help)
 548 {
 549     lldb::CommandObjectSP new_command_sp;
 550     new_command_sp.reset(new CommandPluginInterfaceImplementation(*m_opaque_ptr,name,impl,help));
 551
 552     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
 553         return lldb::SBCommand(new_command_sp);
 554     return lldb::SBCommand();
 555 }
 556
 557 SBCommand::SBCommand ()
 558 {}
 559
 560 SBCommand::SBCommand (lldb::CommandObjectSP cmd_sp) : m_opaque_sp (cmd_sp)
 561 {}
 562
 563 bool
 564 SBCommand::IsValid ()
 565 {
 566     return (bool)m_opaque_sp;
 567 }
 568
 569 const char*
 570 SBCommand::GetName ()
 571 {
 572     if (IsValid ())
 573         return m_opaque_sp->GetCommandName ();
 574     return NULL;
 575 }
 576
 577 const char*
 578 SBCommand::GetHelp ()
 579 {
 580     if (IsValid ())
 581         return m_opaque_sp->GetHelp ();
 582     return NULL;
 583 }
 584
 585 lldb::SBCommand
 586 SBCommand::AddMultiwordCommand (const char* name, const char* help)
 587 {
 588     if (!IsValid ())
 589         return lldb::SBCommand();
 590     if (m_opaque_sp->IsMultiwordObject() == false)
 591         return lldb::SBCommand();
 592     CommandObjectMultiword *new_command = new CommandObjectMultiword(m_opaque_sp->GetCommandInterpreter(),name,help);
 593     new_command->SetRemovable (true);
 594     lldb::CommandObjectSP new_command_sp(new_command);
 595     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
 596         return lldb::SBCommand(new_command_sp);
 597     return lldb::SBCommand();
 598 }
 599
 600 lldb::SBCommand
 601 SBCommand::AddCommand (const char* name, lldb::SBCommandPluginInterface *impl, const char* help)
 602 {
 603     if (!IsValid ())
 604         return lldb::SBCommand();
 605     if (m_opaque_sp->IsMultiwordObject() == false)
 606         return lldb::SBCommand();
 607     lldb::CommandObjectSP new_command_sp;
 608     new_command_sp.reset(new CommandPluginInterfaceImplementation(m_opaque_sp->GetCommandInterpreter(),name,impl,help));
 609     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
 610         return lldb::SBCommand(new_command_sp);
 611     return lldb::SBCommand();
 612 }
 613