contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

   1 //===-- ScriptInterpreterPython.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 #ifdef LLDB_DISABLE_PYTHON
  11
  12 // Python is disabled in this build
  13
  14 #else
  15
  16 #include "lldb-python.h"
  17 #include "ScriptInterpreterPython.h"
  18 #include "PythonDataObjects.h"
  19 #include "PythonExceptionState.h"
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23
  24 #include <mutex>
  25 #include <string>
  26
  27 #include "lldb/API/SBValue.h"
  28 #include "lldb/Breakpoint/BreakpointLocation.h"
  29 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  30 #include "lldb/Breakpoint/WatchpointOptions.h"
  31 #include "lldb/Core/Communication.h"
  32 #include "lldb/Core/Debugger.h"
  33 #include "lldb/Core/PluginManager.h"
  34 #include "lldb/Core/Timer.h"
  35 #include "lldb/Core/ValueObject.h"
  36 #include "lldb/DataFormatters/TypeSummary.h"
  37 #include "lldb/Host/ConnectionFileDescriptor.h"
  38 #include "lldb/Host/FileSystem.h"
  39 #include "lldb/Host/HostInfo.h"
  40 #include "lldb/Host/Pipe.h"
  41 #include "lldb/Interpreter/CommandInterpreter.h"
  42 #include "lldb/Interpreter/CommandReturnObject.h"
  43 #include "lldb/Target/Thread.h"
  44 #include "lldb/Target/ThreadPlan.h"
  45
  46 #if defined(_WIN32)
  47 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
  48 #endif
  49
  50 #include "llvm/ADT/StringRef.h"
  51 #include "llvm/ADT/STLExtras.h"
  52
  53 using namespace lldb;
  54 using namespace lldb_private;
  55
  56 static ScriptInterpreterPython::SWIGInitCallback g_swig_init_callback = nullptr;
  57 static ScriptInterpreterPython::SWIGBreakpointCallbackFunction g_swig_breakpoint_callback = nullptr;
  58 static ScriptInterpreterPython::SWIGWatchpointCallbackFunction g_swig_watchpoint_callback = nullptr;
  59 static ScriptInterpreterPython::SWIGPythonTypeScriptCallbackFunction g_swig_typescript_callback = nullptr;
  60 static ScriptInterpreterPython::SWIGPythonCreateSyntheticProvider g_swig_synthetic_script = nullptr;
  61 static ScriptInterpreterPython::SWIGPythonCreateCommandObject g_swig_create_cmd = nullptr;
  62 static ScriptInterpreterPython::SWIGPythonCalculateNumChildren g_swig_calc_children = nullptr;
  63 static ScriptInterpreterPython::SWIGPythonGetChildAtIndex g_swig_get_child_index = nullptr;
  64 static ScriptInterpreterPython::SWIGPythonGetIndexOfChildWithName g_swig_get_index_child = nullptr;
  65 static ScriptInterpreterPython::SWIGPythonCastPyObjectToSBValue g_swig_cast_to_sbvalue  = nullptr;
  66 static ScriptInterpreterPython::SWIGPythonGetValueObjectSPFromSBValue g_swig_get_valobj_sp_from_sbvalue = nullptr;
  67 static ScriptInterpreterPython::SWIGPythonUpdateSynthProviderInstance g_swig_update_provider = nullptr;
  68 static ScriptInterpreterPython::SWIGPythonMightHaveChildrenSynthProviderInstance g_swig_mighthavechildren_provider = nullptr;
  69 static ScriptInterpreterPython::SWIGPythonGetValueSynthProviderInstance g_swig_getvalue_provider = nullptr;
  70 static ScriptInterpreterPython::SWIGPythonCallCommand g_swig_call_command = nullptr;
  71 static ScriptInterpreterPython::SWIGPythonCallCommandObject g_swig_call_command_object = nullptr;
  72 static ScriptInterpreterPython::SWIGPythonCallModuleInit g_swig_call_module_init = nullptr;
  73 static ScriptInterpreterPython::SWIGPythonCreateOSPlugin g_swig_create_os_plugin = nullptr;
  74 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Process g_swig_run_script_keyword_process = nullptr;
  75 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Thread g_swig_run_script_keyword_thread = nullptr;
  76 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Target g_swig_run_script_keyword_target = nullptr;
  77 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Frame g_swig_run_script_keyword_frame = nullptr;
  78 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Value g_swig_run_script_keyword_value = nullptr;
  79 static ScriptInterpreterPython::SWIGPython_GetDynamicSetting g_swig_plugin_get = nullptr;
  80 static ScriptInterpreterPython::SWIGPythonCreateScriptedThreadPlan g_swig_thread_plan_script = nullptr;
  81 static ScriptInterpreterPython::SWIGPythonCallThreadPlan g_swig_call_thread_plan = nullptr;
  82
  83 static bool g_initialized = false;
  84
  85 namespace
  86 {
  87
  88 // Initializing Python is not a straightforward process.  We cannot control what
  89 // external code may have done before getting to this point in LLDB, including
  90 // potentially having already initialized Python, so we need to do a lot of work
  91 // to ensure that the existing state of the system is maintained across our
  92 // initialization.  We do this by using an RAII pattern where we save off initial
  93 // state at the beginning, and restore it at the end
  94 struct InitializePythonRAII
  95 {
  96 public:
  97     InitializePythonRAII() :
  98         m_gil_state(PyGILState_UNLOCKED),
  99         m_was_already_initialized(false)
 100     {
 101         // Python will muck with STDIN terminal state, so save off any current TTY
 102         // settings so we can restore them.
 103         m_stdin_tty_state.Save(STDIN_FILENO, false);
 104
 105         InitializePythonHome();
 106
 107         // Python < 3.2 and Python >= 3.2 reversed the ordering requirements for
 108         // calling `Py_Initialize` and `PyEval_InitThreads`.  < 3.2 requires that you
 109         // call `PyEval_InitThreads` first, and >= 3.2 requires that you call it last.
 110 #if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 2) || (PY_MAJOR_VERSION > 3)
 111         Py_InitializeEx(0);
 112         InitializeThreadsPrivate();
 113 #else
 114         InitializeThreadsPrivate();
 115         Py_InitializeEx(0);
 116 #endif
 117     }
 118
 119     ~InitializePythonRAII()
 120     {
 121         if (m_was_already_initialized)
 122         {
 123             Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
 124
 125             if (log)
 126             {
 127                 log->Printf("Releasing PyGILState. Returning to state = %slocked\n",
 128                     m_was_already_initialized == PyGILState_UNLOCKED ? "un" : "");
 129             }
 130             PyGILState_Release(m_gil_state);
 131         }
 132         else
 133         {
 134             // We initialized the threads in this function, just unlock the GIL.
 135             PyEval_SaveThread();
 136         }
 137
 138         m_stdin_tty_state.Restore();
 139     }
 140
 141 private:
 142     void InitializePythonHome()
 143     {
 144 #if defined(LLDB_PYTHON_HOME)
 145 #if PY_MAJOR_VERSION >= 3
 146         size_t size = 0;
 147         static wchar_t *g_python_home = Py_DecodeLocale(LLDB_PYTHON_HOME, &size);
 148 #else
 149         static char *g_python_home = LLDB_PYTHON_HOME;
 150 #endif
 151         Py_SetPythonHome(g_python_home);
 152 #endif
 153     }
 154
 155     void InitializeThreadsPrivate()
 156     {
 157         if (PyEval_ThreadsInitialized())
 158         {
 159             Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
 160
 161             m_was_already_initialized = true;
 162             m_gil_state = PyGILState_Ensure();
 163             if (log)
 164             {
 165                 log->Printf("Ensured PyGILState. Previous state = %slocked\n",
 166                     m_gil_state == PyGILState_UNLOCKED ? "un" : "");
 167             }
 168             return;
 169         }
 170
 171         // InitThreads acquires the GIL if it hasn't been called before.
 172         PyEval_InitThreads();
 173     }
 174
 175     TerminalState m_stdin_tty_state;
 176     PyGILState_STATE m_gil_state;
 177     bool m_was_already_initialized;
 178 };
 179
 180 }
 181
 182 ScriptInterpreterPython::Locker::Locker (ScriptInterpreterPython *py_interpreter,
 183                                          uint16_t on_entry,
 184                                          uint16_t on_leave,
 185                                          FILE *in,
 186                                          FILE *out,
 187                                          FILE *err) :
 188     ScriptInterpreterLocker (),
 189     m_teardown_session( (on_leave & TearDownSession) == TearDownSession ),
 190     m_python_interpreter(py_interpreter)
 191 {
 192     DoAcquireLock();
 193     if ((on_entry & InitSession) == InitSession)
 194     {
 195         if (DoInitSession(on_entry, in, out, err) == false)
 196         {
 197             // Don't teardown the session if we didn't init it.
 198             m_teardown_session = false;
 199         }
 200     }
 201 }
 202
 203 bool
 204 ScriptInterpreterPython::Locker::DoAcquireLock()
 205 {
 206     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
 207     m_GILState = PyGILState_Ensure();
 208     if (log)
 209         log->Printf("Ensured PyGILState. Previous state = %slocked\n", m_GILState == PyGILState_UNLOCKED ? "un" : "");
 210
 211     // we need to save the thread state when we first start the command
 212     // because we might decide to interrupt it while some action is taking
 213     // place outside of Python (e.g. printing to screen, waiting for the network, ...)
 214     // in that case, _PyThreadState_Current will be NULL - and we would be unable
 215     // to set the asynchronous exception - not a desirable situation
 216     m_python_interpreter->SetThreadState(PyThreadState_Get());
 217     m_python_interpreter->IncrementLockCount();
 218     return true;
 219 }
 220
 221 bool
 222 ScriptInterpreterPython::Locker::DoInitSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err)
 223 {
 224     if (!m_python_interpreter)
 225         return false;
 226     return m_python_interpreter->EnterSession (on_entry_flags, in, out, err);
 227 }
 228
 229 bool
 230 ScriptInterpreterPython::Locker::DoFreeLock()
 231 {
 232     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
 233     if (log)
 234         log->Printf("Releasing PyGILState. Returning to state = %slocked\n", m_GILState == PyGILState_UNLOCKED ? "un" : "");
 235     PyGILState_Release(m_GILState);
 236     m_python_interpreter->DecrementLockCount();
 237     return true;
 238 }
 239
 240 bool
 241 ScriptInterpreterPython::Locker::DoTearDownSession()
 242 {
 243     if (!m_python_interpreter)
 244         return false;
 245     m_python_interpreter->LeaveSession ();
 246     return true;
 247 }
 248
 249 ScriptInterpreterPython::Locker::~Locker()
 250 {
 251     if (m_teardown_session)
 252         DoTearDownSession();
 253     DoFreeLock();
 254 }
 255
 256 ScriptInterpreterPython::ScriptInterpreterPython(CommandInterpreter &interpreter) :
 257     ScriptInterpreter(interpreter, eScriptLanguagePython),
 258     IOHandlerDelegateMultiline("DONE"),
 259     m_saved_stdin(),
 260     m_saved_stdout(),
 261     m_saved_stderr(),
 262     m_main_module(),
 263     m_lldb_module(),
 264     m_session_dict(PyInitialValue::Invalid),
 265     m_sys_module_dict(PyInitialValue::Invalid),
 266     m_run_one_line_function(),
 267     m_run_one_line_str_global(),
 268     m_dictionary_name(interpreter.GetDebugger().GetInstanceName().AsCString()),
 269     m_terminal_state(),
 270     m_active_io_handler(eIOHandlerNone),
 271     m_session_is_active(false),
 272     m_pty_slave_is_open(false),
 273     m_valid_session(true),
 274     m_lock_count(0),
 275     m_command_thread_state(nullptr)
 276 {
 277     assert(g_initialized && "ScriptInterpreterPython created but InitializePrivate has not been called!");
 278
 279     m_dictionary_name.append("_dict");
 280     StreamString run_string;
 281     run_string.Printf ("%s = dict()", m_dictionary_name.c_str());
 282
 283     Locker locker(this,
 284                   ScriptInterpreterPython::Locker::AcquireLock,
 285                   ScriptInterpreterPython::Locker::FreeAcquiredLock);
 286     PyRun_SimpleString (run_string.GetData());
 287
 288     run_string.Clear();
 289     run_string.Printf ("run_one_line (%s, 'import copy, keyword, os, re, sys, uuid, lldb')", m_dictionary_name.c_str());
 290     PyRun_SimpleString (run_string.GetData());
 291
 292     // Reloading modules requires a different syntax in Python 2 and Python 3.  This provides
 293     // a consistent syntax no matter what version of Python.
 294     run_string.Clear();
 295     run_string.Printf("run_one_line (%s, 'from six.moves import reload_module')", m_dictionary_name.c_str());
 296     PyRun_SimpleString(run_string.GetData());
 297
 298     // WARNING: temporary code that loads Cocoa formatters - this should be done on a per-platform basis rather than loading the whole set
 299     // and letting the individual formatter classes exploit APIs to check whether they can/cannot do their task
 300     run_string.Clear();
 301     run_string.Printf ("run_one_line (%s, 'import lldb.formatters, lldb.formatters.cpp, pydoc')", m_dictionary_name.c_str());
 302     PyRun_SimpleString (run_string.GetData());
 303     run_string.Clear();
 304
 305     run_string.Printf ("run_one_line (%s, 'import lldb.embedded_interpreter; from lldb.embedded_interpreter import run_python_interpreter; from lldb.embedded_interpreter import run_one_line')", m_dictionary_name.c_str());
 306     PyRun_SimpleString (run_string.GetData());
 307     run_string.Clear();
 308
 309     run_string.Printf ("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64 "; pydoc.pager = pydoc.plainpager')", m_dictionary_name.c_str(),
 310                        interpreter.GetDebugger().GetID());
 311     PyRun_SimpleString (run_string.GetData());
 312 }
 313
 314 ScriptInterpreterPython::~ScriptInterpreterPython ()
 315 {
 316     // the session dictionary may hold objects with complex state
 317     // which means that they may need to be torn down with some level of smarts
 318     // and that, in turn, requires a valid thread state
 319     // force Python to procure itself such a thread state, nuke the session dictionary
 320     // and then release it for others to use and proceed with the rest of the shutdown
 321     auto gil_state = PyGILState_Ensure();
 322     m_session_dict.Reset();
 323     PyGILState_Release(gil_state);
 324 }
 325
 326 void
 327 ScriptInterpreterPython::Initialize()
 328 {
 329     static std::once_flag g_once_flag;
 330
 331     std::call_once(g_once_flag, []()
 332     {
 333         InitializePrivate();
 334
 335         PluginManager::RegisterPlugin(GetPluginNameStatic(),
 336                                       GetPluginDescriptionStatic(),
 337                                       lldb::eScriptLanguagePython,
 338                                       CreateInstance);
 339     });
 340 }
 341
 342 void
 343 ScriptInterpreterPython::Terminate()
 344 {
 345
 346 }
 347
 348 lldb::ScriptInterpreterSP
 349 ScriptInterpreterPython::CreateInstance(CommandInterpreter &interpreter)
 350 {
 351     return std::make_shared<ScriptInterpreterPython>(interpreter);
 352 }
 353
 354 lldb_private::ConstString
 355 ScriptInterpreterPython::GetPluginNameStatic()
 356 {
 357     static ConstString g_name("script-python");
 358     return g_name;
 359 }
 360
 361 const char *
 362 ScriptInterpreterPython::GetPluginDescriptionStatic()
 363 {
 364     return "Embedded Python interpreter";
 365 }
 366
 367 lldb_private::ConstString
 368 ScriptInterpreterPython::GetPluginName()
 369 {
 370     return GetPluginNameStatic();
 371 }
 372
 373 uint32_t
 374 ScriptInterpreterPython::GetPluginVersion()
 375 {
 376     return 1;
 377 }
 378
 379 void
 380 ScriptInterpreterPython::IOHandlerActivated (IOHandler &io_handler)
 381 {
 382     const char *instructions = nullptr;
 383
 384     switch (m_active_io_handler)
 385     {
 386     case eIOHandlerNone:
 387             break;
 388     case eIOHandlerBreakpoint:
 389             instructions = R"(Enter your Python command(s). Type 'DONE' to end.
 390 def function (frame, bp_loc, internal_dict):
 391     """frame: the lldb.SBFrame for the location at which you stopped
 392        bp_loc: an lldb.SBBreakpointLocation for the breakpoint location information
 393        internal_dict: an LLDB support object not to be used"""
 394 )";
 395             break;
 396     case eIOHandlerWatchpoint:
 397             instructions = "Enter your Python command(s). Type 'DONE' to end.\n";
 398             break;
 399     }
 400
 401     if (instructions)
 402     {
 403         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
 404         if (output_sp)
 405         {
 406             output_sp->PutCString(instructions);
 407             output_sp->Flush();
 408         }
 409     }
 410 }
 411
 412 void
 413 ScriptInterpreterPython::IOHandlerInputComplete (IOHandler &io_handler, std::string &data)
 414 {
 415     io_handler.SetIsDone(true);
 416     bool batch_mode = m_interpreter.GetBatchCommandMode();
 417
 418     switch (m_active_io_handler)
 419     {
 420     case eIOHandlerNone:
 421         break;
 422     case eIOHandlerBreakpoint:
 423         {
 424             std::vector<BreakpointOptions *> *bp_options_vec = (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
 425             for (auto bp_options : *bp_options_vec)
 426             {
 427                 if (!bp_options)
 428                     continue;
 429
 430                 std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
 431                 if (data_ap.get())
 432                 {
 433                     data_ap->user_source.SplitIntoLines(data);
 434
 435                     if (GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source).Success())
 436                     {
 437                         BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
 438                         bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp);
 439                     }
 440                     else if (!batch_mode)
 441                     {
 442                         StreamFileSP error_sp = io_handler.GetErrorStreamFile();
 443                         if (error_sp)
 444                         {
 445                             error_sp->Printf ("Warning: No command attached to breakpoint.\n");
 446                             error_sp->Flush();
 447                         }
 448                     }
 449                 }
 450             }
 451             m_active_io_handler = eIOHandlerNone;
 452         }
 453         break;
 454     case eIOHandlerWatchpoint:
 455         {
 456             WatchpointOptions *wp_options = (WatchpointOptions *)io_handler.GetUserData();
 457             std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
 458             if (data_ap.get())
 459             {
 460                 data_ap->user_source.SplitIntoLines(data);
 461
 462                 if (GenerateWatchpointCommandCallbackData (data_ap->user_source, data_ap->script_source))
 463                 {
 464                     BatonSP baton_sp (new WatchpointOptions::CommandBaton (data_ap.release()));
 465                     wp_options->SetCallback (ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp);
 466                 }
 467                 else if (!batch_mode)
 468                 {
 469                     StreamFileSP error_sp = io_handler.GetErrorStreamFile();
 470                     if (error_sp)
 471                     {
 472                         error_sp->Printf ("Warning: No command attached to breakpoint.\n");
 473                         error_sp->Flush();
 474                     }
 475                 }
 476             }
 477             m_active_io_handler = eIOHandlerNone;
 478         }
 479         break;
 480     }
 481 }
 482
 483
 484 void
 485 ScriptInterpreterPython::ResetOutputFileHandle (FILE *fh)
 486 {
 487 }
 488
 489 void
 490 ScriptInterpreterPython::SaveTerminalState (int fd)
 491 {
 492     // Python mucks with the terminal state of STDIN. If we can possibly avoid
 493     // this by setting the file handles up correctly prior to entering the
 494     // interpreter we should. For now we save and restore the terminal state
 495     // on the input file handle.
 496     m_terminal_state.Save (fd, false);
 497 }
 498
 499 void
 500 ScriptInterpreterPython::RestoreTerminalState ()
 501 {
 502     // Python mucks with the terminal state of STDIN. If we can possibly avoid
 503     // this by setting the file handles up correctly prior to entering the
 504     // interpreter we should. For now we save and restore the terminal state
 505     // on the input file handle.
 506     m_terminal_state.Restore();
 507 }
 508
 509 void
 510 ScriptInterpreterPython::LeaveSession ()
 511 {
 512     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT));
 513     if (log)
 514         log->PutCString("ScriptInterpreterPython::LeaveSession()");
 515
 516     // checking that we have a valid thread state - since we use our own threading and locking
 517     // in some (rare) cases during cleanup Python may end up believing we have no thread state
 518     // and PyImport_AddModule will crash if that is the case - since that seems to only happen
 519     // when destroying the SBDebugger, we can make do without clearing up stdout and stderr
 520
 521     // rdar://problem/11292882
 522     // When the current thread state is NULL, PyThreadState_Get() issues a fatal error.
 523     if (PyThreadState_GetDict())
 524     {
 525         PythonDictionary &sys_module_dict = GetSysModuleDictionary ();
 526         if (sys_module_dict.IsValid())
 527         {
 528             if (m_saved_stdin.IsValid())
 529             {
 530                 sys_module_dict.SetItemForKey(PythonString("stdin"), m_saved_stdin);
 531                 m_saved_stdin.Reset ();
 532             }
 533             if (m_saved_stdout.IsValid())
 534             {
 535                 sys_module_dict.SetItemForKey(PythonString("stdout"), m_saved_stdout);
 536                 m_saved_stdout.Reset ();
 537             }
 538             if (m_saved_stderr.IsValid())
 539             {
 540                 sys_module_dict.SetItemForKey(PythonString("stderr"), m_saved_stderr);
 541                 m_saved_stderr.Reset ();
 542             }
 543         }
 544     }
 545
 546     m_session_is_active = false;
 547 }
 548
 549 bool
 550 ScriptInterpreterPython::EnterSession (uint16_t on_entry_flags,
 551                                        FILE *in,
 552                                        FILE *out,
 553                                        FILE *err)
 554 {
 555     // If we have already entered the session, without having officially 'left' it, then there is no need to
 556     // 'enter' it again.
 557     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT));
 558     if (m_session_is_active)
 559     {
 560         if (log)
 561             log->Printf("ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16 ") session is already active, returning without doing anything", on_entry_flags);
 562         return false;
 563     }
 564
 565     if (log)
 566         log->Printf("ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16 ")", on_entry_flags);
 567
 568
 569     m_session_is_active = true;
 570
 571     StreamString run_string;
 572
 573     if (on_entry_flags & Locker::InitGlobals)
 574     {
 575         run_string.Printf (    "run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64, m_dictionary_name.c_str(), GetCommandInterpreter().GetDebugger().GetID());
 576         run_string.Printf (    "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")", GetCommandInterpreter().GetDebugger().GetID());
 577         run_string.PutCString ("; lldb.target = lldb.debugger.GetSelectedTarget()");
 578         run_string.PutCString ("; lldb.process = lldb.target.GetProcess()");
 579         run_string.PutCString ("; lldb.thread = lldb.process.GetSelectedThread ()");
 580         run_string.PutCString ("; lldb.frame = lldb.thread.GetSelectedFrame ()");
 581         run_string.PutCString ("')");
 582     }
 583     else
 584     {
 585         // If we aren't initing the globals, we should still always set the debugger (since that is always unique.)
 586         run_string.Printf (    "run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64, m_dictionary_name.c_str(), GetCommandInterpreter().GetDebugger().GetID());
 587         run_string.Printf (    "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")", GetCommandInterpreter().GetDebugger().GetID());
 588         run_string.PutCString ("')");
 589     }
 590
 591     PyRun_SimpleString (run_string.GetData());
 592     run_string.Clear();
 593
 594     PythonDictionary &sys_module_dict = GetSysModuleDictionary ();
 595     if (sys_module_dict.IsValid())
 596     {
 597         File in_file(in, false);
 598         File out_file(out, false);
 599         File err_file(err, false);
 600
 601         lldb::StreamFileSP in_sp;
 602         lldb::StreamFileSP out_sp;
 603         lldb::StreamFileSP err_sp;
 604         if (!in_file.IsValid() || !out_file.IsValid() || !err_file.IsValid())
 605             m_interpreter.GetDebugger().AdoptTopIOHandlerFilesIfInvalid (in_sp, out_sp, err_sp);
 606
 607         m_saved_stdin.Reset();
 608
 609         if ((on_entry_flags & Locker::NoSTDIN) == 0)
 610         {
 611             // STDIN is enabled
 612             if (!in_file.IsValid() && in_sp)
 613                 in_file = in_sp->GetFile();
 614             if (in_file.IsValid())
 615             {
 616                 // Flush the file before giving it to python to avoid interleaved output.
 617                 in_file.Flush();
 618
 619                 m_saved_stdin = sys_module_dict.GetItemForKey(PythonString("stdin")).AsType<PythonFile>();
 620                 // This call can deadlock your process if the file is locked
 621                 PythonFile new_file(in_file, "r");
 622                 sys_module_dict.SetItemForKey (PythonString("stdin"), new_file);
 623             }
 624         }
 625
 626         if (!out_file.IsValid() && out_sp)
 627             out_file = out_sp->GetFile();
 628         if (out_file.IsValid())
 629         {
 630             // Flush the file before giving it to python to avoid interleaved output.
 631             out_file.Flush();
 632
 633             m_saved_stdout = sys_module_dict.GetItemForKey(PythonString("stdout")).AsType<PythonFile>();
 634
 635             PythonFile new_file(out_file, "w");
 636             sys_module_dict.SetItemForKey (PythonString("stdout"), new_file);
 637         }
 638         else
 639             m_saved_stdout.Reset();
 640
 641         if (!err_file.IsValid() && err_sp)
 642             err_file = err_sp->GetFile();
 643         if (err_file.IsValid())
 644         {
 645             // Flush the file before giving it to python to avoid interleaved output.
 646             err_file.Flush();
 647
 648             m_saved_stderr = sys_module_dict.GetItemForKey(PythonString("stderr")).AsType<PythonFile>();
 649
 650             PythonFile new_file(err_file, "w");
 651             sys_module_dict.SetItemForKey (PythonString("stderr"), new_file);
 652         }
 653         else
 654             m_saved_stderr.Reset();
 655     }
 656
 657     if (PyErr_Occurred())
 658         PyErr_Clear ();
 659
 660     return true;
 661 }
 662
 663 PythonObject &
 664 ScriptInterpreterPython::GetMainModule()
 665 {
 666     if (!m_main_module.IsValid())
 667         m_main_module.Reset(PyRefType::Borrowed, PyImport_AddModule("__main__"));
 668     return m_main_module;
 669 }
 670
 671 PythonDictionary &
 672 ScriptInterpreterPython::GetSessionDictionary ()
 673 {
 674     if (m_session_dict.IsValid())
 675         return m_session_dict;
 676
 677     PythonObject &main_module = GetMainModule();
 678     if (!main_module.IsValid())
 679         return m_session_dict;
 680
 681     PythonDictionary main_dict(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
 682     if (!main_dict.IsValid())
 683         return m_session_dict;
 684
 685     PythonObject item = main_dict.GetItemForKey(PythonString(m_dictionary_name));
 686     m_session_dict.Reset(PyRefType::Borrowed, item.get());
 687     return m_session_dict;
 688 }
 689
 690 PythonDictionary &
 691 ScriptInterpreterPython::GetSysModuleDictionary ()
 692 {
 693     if (m_sys_module_dict.IsValid())
 694         return m_sys_module_dict;
 695
 696     PythonObject sys_module(PyRefType::Borrowed, PyImport_AddModule("sys"));
 697     if (sys_module.IsValid())
 698         m_sys_module_dict.Reset(PyRefType::Borrowed, PyModule_GetDict(sys_module.get()));
 699     return m_sys_module_dict;
 700 }
 701
 702 static std::string
 703 GenerateUniqueName (const char* base_name_wanted,
 704                     uint32_t& functions_counter,
 705                     const void* name_token = nullptr)
 706 {
 707     StreamString sstr;
 708
 709     if (!base_name_wanted)
 710         return std::string();
 711
 712     if (!name_token)
 713         sstr.Printf ("%s_%d", base_name_wanted, functions_counter++);
 714     else
 715         sstr.Printf ("%s_%p", base_name_wanted, name_token);
 716
 717     return sstr.GetString();
 718 }
 719
 720 bool
 721 ScriptInterpreterPython::GetEmbeddedInterpreterModuleObjects ()
 722 {
 723     if (m_run_one_line_function.IsValid())
 724         return true;
 725
 726     PythonObject module(PyRefType::Borrowed, PyImport_AddModule ("lldb.embedded_interpreter"));
 727     if (!module.IsValid())
 728         return false;
 729
 730     PythonDictionary module_dict(PyRefType::Borrowed, PyModule_GetDict(module.get()));
 731     if (!module_dict.IsValid())
 732         return false;
 733
 734     m_run_one_line_function = module_dict.GetItemForKey(PythonString("run_one_line"));
 735     m_run_one_line_str_global = module_dict.GetItemForKey(PythonString("g_run_one_line_str"));
 736     return m_run_one_line_function.IsValid();
 737 }
 738
 739 static void
 740 ReadThreadBytesReceived(void *baton, const void *src, size_t src_len)
 741 {
 742     if (src && src_len)
 743     {
 744         Stream *strm = (Stream *)baton;
 745         strm->Write(src, src_len);
 746         strm->Flush();
 747     }
 748 }
 749
 750 bool
 751 ScriptInterpreterPython::ExecuteOneLine (const char *command, CommandReturnObject *result, const ExecuteScriptOptions &options)
 752 {
 753     if (!m_valid_session)
 754         return false;
 755
 756     if (command && command[0])
 757     {
 758         // We want to call run_one_line, passing in the dictionary and the command string.  We cannot do this through
 759         // PyRun_SimpleString here because the command string may contain escaped characters, and putting it inside
 760         // another string to pass to PyRun_SimpleString messes up the escaping.  So we use the following more complicated
 761         // method to pass the command string directly down to Python.
 762         Debugger &debugger = m_interpreter.GetDebugger();
 763
 764         StreamFileSP input_file_sp;
 765         StreamFileSP output_file_sp;
 766         StreamFileSP error_file_sp;
 767         Communication output_comm ("lldb.ScriptInterpreterPython.ExecuteOneLine.comm");
 768         bool join_read_thread = false;
 769         if (options.GetEnableIO())
 770         {
 771             if (result)
 772             {
 773                 input_file_sp = debugger.GetInputFile();
 774                 // Set output to a temporary file so we can forward the results on to the result object
 775
 776                 Pipe pipe;
 777                 Error pipe_result = pipe.CreateNew(false);
 778                 if (pipe_result.Success())
 779                 {
 780 #if defined(_WIN32)
 781                     lldb::file_t read_file = pipe.GetReadNativeHandle();
 782                     pipe.ReleaseReadFileDescriptor();
 783                     std::unique_ptr<ConnectionGenericFile> conn_ap(new ConnectionGenericFile(read_file, true));
 784 #else
 785                     std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor(pipe.ReleaseReadFileDescriptor(), true));
 786 #endif
 787                     if (conn_ap->IsConnected())
 788                     {
 789                         output_comm.SetConnection(conn_ap.release());
 790                         output_comm.SetReadThreadBytesReceivedCallback(ReadThreadBytesReceived, &result->GetOutputStream());
 791                         output_comm.StartReadThread();
 792                         join_read_thread = true;
 793                         FILE *outfile_handle = fdopen (pipe.ReleaseWriteFileDescriptor(), "w");
 794                         output_file_sp.reset(new StreamFile(outfile_handle, true));
 795                         error_file_sp = output_file_sp;
 796                         if (outfile_handle)
 797                             ::setbuf (outfile_handle, nullptr);
 798
 799                         result->SetImmediateOutputFile(debugger.GetOutputFile()->GetFile().GetStream());
 800                         result->SetImmediateErrorFile(debugger.GetErrorFile()->GetFile().GetStream());
 801                     }
 802                 }
 803             }
 804             if (!input_file_sp || !output_file_sp || !error_file_sp)
 805                 debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp, error_file_sp);
 806         }
 807         else
 808         {
 809             input_file_sp.reset (new StreamFile ());
 810             input_file_sp->GetFile().Open(FileSystem::DEV_NULL, File::eOpenOptionRead);
 811             output_file_sp.reset (new StreamFile ());
 812             output_file_sp->GetFile().Open(FileSystem::DEV_NULL, File::eOpenOptionWrite);
 813             error_file_sp = output_file_sp;
 814         }
 815
 816         FILE *in_file = input_file_sp->GetFile().GetStream();
 817         FILE *out_file = output_file_sp->GetFile().GetStream();
 818         FILE *err_file = error_file_sp->GetFile().GetStream();
 819         bool success = false;
 820         {
 821             // WARNING!  It's imperative that this RAII scope be as tight as possible.  In particular, the
 822             // scope must end *before* we try to join the read thread.  The reason for this is that a
 823             // pre-requisite for joining the read thread is that we close the write handle (to break the
 824             // pipe and cause it to wake up and exit).  But acquiring the GIL as below will redirect Python's
 825             // stdio to use this same handle.  If we close the handle while Python is still using it, bad
 826             // things will happen.
 827             Locker locker(this,
 828                           ScriptInterpreterPython::Locker::AcquireLock |
 829                           ScriptInterpreterPython::Locker::InitSession |
 830                           (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) |
 831                           ((result && result->GetInteractive()) ? 0: Locker::NoSTDIN),
 832                           ScriptInterpreterPython::Locker::FreeAcquiredLock |
 833                           ScriptInterpreterPython::Locker::TearDownSession,
 834                           in_file,
 835                           out_file,
 836                           err_file);
 837
 838             // Find the correct script interpreter dictionary in the main module.
 839             PythonDictionary &session_dict = GetSessionDictionary ();
 840             if (session_dict.IsValid())
 841             {
 842                 if (GetEmbeddedInterpreterModuleObjects ())
 843                 {
 844                     if (PyCallable_Check(m_run_one_line_function.get()))
 845                     {
 846                         PythonObject pargs(PyRefType::Owned, Py_BuildValue("(Os)", session_dict.get(), command));
 847                         if (pargs.IsValid())
 848                         {
 849                             PythonObject return_value(PyRefType::Owned,
 850                                 PyObject_CallObject(m_run_one_line_function.get(), pargs.get()));
 851                             if (return_value.IsValid())
 852                                 success = true;
 853                             else if (options.GetMaskoutErrors() && PyErr_Occurred ())
 854                             {
 855                                 PyErr_Print();
 856                                 PyErr_Clear();
 857                             }
 858                         }
 859                     }
 860                 }
 861             }
 862
 863             // Flush our output and error file handles
 864             ::fflush (out_file);
 865             if (out_file != err_file)
 866                 ::fflush (err_file);
 867         }
 868
 869         if (join_read_thread)
 870         {
 871             // Close the write end of the pipe since we are done with our
 872             // one line script. This should cause the read thread that
 873             // output_comm is using to exit
 874             output_file_sp->GetFile().Close();
 875             // The close above should cause this thread to exit when it gets
 876             // to the end of file, so let it get all its data
 877             output_comm.JoinReadThread();
 878             // Now we can close the read end of the pipe
 879             output_comm.Disconnect();
 880         }
 881
 882
 883         if (success)
 884             return true;
 885
 886         // The one-liner failed.  Append the error message.
 887         if (result)
 888             result->AppendErrorWithFormat ("python failed attempting to evaluate '%s'\n", command);
 889         return false;
 890     }
 891
 892     if (result)
 893         result->AppendError ("empty command passed to python\n");
 894     return false;
 895 }
 896
 897
 898 class IOHandlerPythonInterpreter :
 899     public IOHandler
 900 {
 901 public:
 902
 903     IOHandlerPythonInterpreter (Debugger &debugger,
 904                                 ScriptInterpreterPython *python) :
 905         IOHandler (debugger, IOHandler::Type::PythonInterpreter),
 906         m_python(python)
 907     {
 908
 909     }
 910
 911     ~IOHandlerPythonInterpreter() override
 912     {
 913
 914     }
 915
 916     ConstString
 917     GetControlSequence (char ch) override
 918     {
 919         if (ch == 'd')
 920             return ConstString("quit()\n");
 921         return ConstString();
 922     }
 923
 924     void
 925     Run () override
 926     {
 927         if (m_python)
 928         {
 929             int stdin_fd = GetInputFD();
 930             if (stdin_fd >= 0)
 931             {
 932                 Terminal terminal(stdin_fd);
 933                 TerminalState terminal_state;
 934                 const bool is_a_tty = terminal.IsATerminal();
 935
 936                 if (is_a_tty)
 937                 {
 938                     terminal_state.Save (stdin_fd, false);
 939                     terminal.SetCanonical(false);
 940                     terminal.SetEcho(true);
 941                 }
 942
 943                 ScriptInterpreterPython::Locker locker (m_python,
 944                                                         ScriptInterpreterPython::Locker::AcquireLock |
 945                                                         ScriptInterpreterPython::Locker::InitSession |
 946                                                         ScriptInterpreterPython::Locker::InitGlobals,
 947                                                         ScriptInterpreterPython::Locker::FreeAcquiredLock |
 948                                                         ScriptInterpreterPython::Locker::TearDownSession);
 949
 950                 // The following call drops into the embedded interpreter loop and stays there until the
 951                 // user chooses to exit from the Python interpreter.
 952                 // This embedded interpreter will, as any Python code that performs I/O, unlock the GIL before
 953                 // a system call that can hang, and lock it when the syscall has returned.
 954
 955                 // We need to surround the call to the embedded interpreter with calls to PyGILState_Ensure and
 956                 // PyGILState_Release (using the Locker above). This is because Python has a global lock which must be held whenever we want
 957                 // to touch any Python objects. Otherwise, if the user calls Python code, the interpreter state will be off,
 958                 // and things could hang (it's happened before).
 959
 960                 StreamString run_string;
 961                 run_string.Printf ("run_python_interpreter (%s)", m_python->GetDictionaryName ());
 962                 PyRun_SimpleString (run_string.GetData());
 963
 964                 if (is_a_tty)
 965                     terminal_state.Restore();
 966             }
 967         }
 968         SetIsDone(true);
 969     }
 970
 971     void
 972     Cancel () override
 973     {
 974
 975     }
 976
 977     bool
 978     Interrupt () override
 979     {
 980         return m_python->Interrupt();
 981     }
 982
 983     void
 984     GotEOF() override
 985     {
 986
 987     }
 988 protected:
 989     ScriptInterpreterPython *m_python;
 990 };
 991
 992
 993 void
 994 ScriptInterpreterPython::ExecuteInterpreterLoop ()
 995 {
 996     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
 997
 998     Debugger &debugger = GetCommandInterpreter().GetDebugger();
 999
1000     // At the moment, the only time the debugger does not have an input file handle is when this is called
1001     // directly from Python, in which case it is both dangerous and unnecessary (not to mention confusing) to
1002     // try to embed a running interpreter loop inside the already running Python interpreter loop, so we won't
1003     // do it.
1004
1005     if (!debugger.GetInputFile()->GetFile().IsValid())
1006         return;
1007
1008     IOHandlerSP io_handler_sp (new IOHandlerPythonInterpreter (debugger, this));
1009     if (io_handler_sp)
1010     {
1011         debugger.PushIOHandler(io_handler_sp);
1012     }
1013 }
1014
1015 bool
1016 ScriptInterpreterPython::Interrupt()
1017 {
1018     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT));
1019
1020     if (IsExecutingPython())
1021     {
1022         PyThreadState *state = PyThreadState_Get();
1023         if (!state)
1024             state = GetThreadState();
1025         if (state)
1026         {
1027             long tid = state->thread_id;
1028             PyThreadState_Swap(state);
1029             int num_threads = PyThreadState_SetAsyncExc(tid, PyExc_KeyboardInterrupt);
1030             if (log)
1031                 log->Printf("ScriptInterpreterPython::Interrupt() sending PyExc_KeyboardInterrupt (tid = %li, num_threads = %i)...", tid, num_threads);
1032             return true;
1033         }
1034     }
1035     if (log)
1036         log->Printf("ScriptInterpreterPython::Interrupt() python code not running, can't interrupt");
1037     return false;
1038
1039 }
1040 bool
1041 ScriptInterpreterPython::ExecuteOneLineWithReturn (const char *in_string,
1042                                                    ScriptInterpreter::ScriptReturnType return_type,
1043                                                    void *ret_value,
1044                                                    const ExecuteScriptOptions &options)
1045 {
1046
1047     Locker locker(this,
1048                   ScriptInterpreterPython::Locker::AcquireLock | ScriptInterpreterPython::Locker::InitSession | (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) | Locker::NoSTDIN,
1049                   ScriptInterpreterPython::Locker::FreeAcquiredLock | ScriptInterpreterPython::Locker::TearDownSession);
1050
1051     PythonObject py_return;
1052     PythonObject &main_module = GetMainModule();
1053     PythonDictionary globals(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
1054     PythonObject py_error;
1055     bool ret_success = false;
1056     int success;
1057
1058     PythonDictionary locals = GetSessionDictionary ();
1059
1060     if (!locals.IsValid())
1061     {
1062         locals.Reset(PyRefType::Owned, PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
1063     }
1064
1065     if (!locals.IsValid())
1066         locals = globals;
1067
1068     py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1069     if (py_error.IsValid())
1070         PyErr_Clear();
1071
1072     if (in_string != nullptr)
1073     {
1074         { // scope for PythonInputReaderManager
1075             //PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
1076             py_return.Reset(PyRefType::Owned, PyRun_String(in_string, Py_eval_input, globals.get(), locals.get()));
1077             if (!py_return.IsValid())
1078             {
1079                 py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1080                 if (py_error.IsValid())
1081                     PyErr_Clear();
1082
1083                 py_return.Reset(PyRefType::Owned, PyRun_String(in_string, Py_single_input, globals.get(), locals.get()));
1084             }
1085         }
1086
1087         if (py_return.IsValid())
1088         {
1089             switch (return_type)
1090             {
1091                 case eScriptReturnTypeCharPtr: // "char *"
1092                 {
1093                     const char format[3] = "s#";
1094                     success = PyArg_Parse (py_return.get(), format, (char **) ret_value);
1095                     break;
1096                 }
1097                 case eScriptReturnTypeCharStrOrNone: // char* or NULL if py_return == Py_None
1098                 {
1099                     const char format[3] = "z";
1100                     success = PyArg_Parse (py_return.get(), format, (char **) ret_value);
1101                     break;
1102                 }
1103                 case eScriptReturnTypeBool:
1104                 {
1105                     const char format[2] = "b";
1106                     success = PyArg_Parse (py_return.get(), format, (bool *) ret_value);
1107                     break;
1108                 }
1109                 case eScriptReturnTypeShortInt:
1110                 {
1111                     const char format[2] = "h";
1112                     success = PyArg_Parse (py_return.get(), format, (short *) ret_value);
1113                     break;
1114                 }
1115                 case eScriptReturnTypeShortIntUnsigned:
1116                 {
1117                     const char format[2] = "H";
1118                     success = PyArg_Parse (py_return.get(), format, (unsigned short *) ret_value);
1119                     break;
1120                 }
1121                 case eScriptReturnTypeInt:
1122                 {
1123                     const char format[2] = "i";
1124                     success = PyArg_Parse (py_return.get(), format, (int *) ret_value);
1125                     break;
1126                 }
1127                 case eScriptReturnTypeIntUnsigned:
1128                 {
1129                     const char format[2] = "I";
1130                     success = PyArg_Parse (py_return.get(), format, (unsigned int *) ret_value);
1131                     break;
1132                 }
1133                 case eScriptReturnTypeLongInt:
1134                 {
1135                     const char format[2] = "l";
1136                     success = PyArg_Parse (py_return.get(), format, (long *) ret_value);
1137                     break;
1138                 }
1139                 case eScriptReturnTypeLongIntUnsigned:
1140                 {
1141                     const char format[2] = "k";
1142                     success = PyArg_Parse (py_return.get(), format, (unsigned long *) ret_value);
1143                     break;
1144                 }
1145                 case eScriptReturnTypeLongLong:
1146                 {
1147                     const char format[2] = "L";
1148                     success = PyArg_Parse (py_return.get(), format, (long long *) ret_value);
1149                     break;
1150                 }
1151                 case eScriptReturnTypeLongLongUnsigned:
1152                 {
1153                     const char format[2] = "K";
1154                     success = PyArg_Parse (py_return.get(), format, (unsigned long long *) ret_value);
1155                     break;
1156                 }
1157                 case eScriptReturnTypeFloat:
1158                 {
1159                     const char format[2] = "f";
1160                     success = PyArg_Parse (py_return.get(), format, (float *) ret_value);
1161                     break;
1162                 }
1163                 case eScriptReturnTypeDouble:
1164                 {
1165                     const char format[2] = "d";
1166                     success = PyArg_Parse (py_return.get(), format, (double *) ret_value);
1167                     break;
1168                 }
1169                 case eScriptReturnTypeChar:
1170                 {
1171                     const char format[2] = "c";
1172                     success = PyArg_Parse (py_return.get(), format, (char *) ret_value);
1173                     break;
1174                 }
1175                 case eScriptReturnTypeOpaqueObject:
1176                 {
1177                     success = true;
1178                     PyObject *saved_value = py_return.get();
1179                     Py_XINCREF(saved_value);
1180                     *((PyObject **)ret_value) = saved_value;
1181                     break;
1182                 }
1183             }
1184
1185             if (success)
1186                 ret_success = true;
1187             else
1188                 ret_success = false;
1189         }
1190     }
1191
1192     py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1193     if (py_error.IsValid())
1194     {
1195         ret_success = false;
1196         if (options.GetMaskoutErrors())
1197         {
1198             if (PyErr_GivenExceptionMatches (py_error.get(), PyExc_SyntaxError))
1199                 PyErr_Print ();
1200             PyErr_Clear();
1201         }
1202     }
1203
1204     return ret_success;
1205 }
1206
1207 Error
1208 ScriptInterpreterPython::ExecuteMultipleLines (const char *in_string, const ExecuteScriptOptions &options)
1209 {
1210     Error error;
1211
1212     Locker locker(this,
1213                   ScriptInterpreterPython::Locker::AcquireLock      | ScriptInterpreterPython::Locker::InitSession | (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) | Locker::NoSTDIN,
1214                   ScriptInterpreterPython::Locker::FreeAcquiredLock | ScriptInterpreterPython::Locker::TearDownSession);
1215
1216     PythonObject return_value;
1217     PythonObject &main_module = GetMainModule();
1218     PythonDictionary globals(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
1219     PythonObject py_error;
1220
1221     PythonDictionary locals = GetSessionDictionary();
1222
1223     if (!locals.IsValid())
1224         locals.Reset(PyRefType::Owned, PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
1225
1226     if (!locals.IsValid())
1227         locals = globals;
1228
1229     py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1230     if (py_error.IsValid())
1231         PyErr_Clear();
1232
1233     if (in_string != nullptr)
1234     {
1235         PythonObject code_object;
1236         code_object.Reset(PyRefType::Owned, Py_CompileString(in_string, "temp.py", Py_file_input));
1237
1238         if (code_object.IsValid())
1239         {
1240             // In Python 2.x, PyEval_EvalCode takes a PyCodeObject, but in Python 3.x, it takes
1241             // a PyObject.  They are convertible (hence the function PyCode_Check(PyObject*), so
1242             // we have to do the cast for Python 2.x
1243 #if PY_MAJOR_VERSION >= 3
1244             PyObject *py_code_obj = code_object.get();
1245 #else
1246             PyCodeObject *py_code_obj = reinterpret_cast<PyCodeObject *>(code_object.get());
1247 #endif
1248             return_value.Reset(PyRefType::Owned, PyEval_EvalCode(py_code_obj, globals.get(), locals.get()));
1249         }
1250     }
1251
1252     PythonExceptionState exception_state(!options.GetMaskoutErrors());
1253     if (exception_state.IsError())
1254         error.SetErrorString(exception_state.Format().c_str());
1255
1256     return error;
1257 }
1258
1259
1260 void
1261 ScriptInterpreterPython::CollectDataForBreakpointCommandCallback (std::vector<BreakpointOptions *> &bp_options_vec,
1262                                                                   CommandReturnObject &result)
1263 {
1264     m_active_io_handler = eIOHandlerBreakpoint;
1265     m_interpreter.GetPythonCommandsFromIOHandler ("    ", *this, true, &bp_options_vec);
1266 }
1267
1268 void
1269 ScriptInterpreterPython::CollectDataForWatchpointCommandCallback (WatchpointOptions *wp_options,
1270                                                                   CommandReturnObject &result)
1271 {
1272     m_active_io_handler = eIOHandlerWatchpoint;
1273     m_interpreter.GetPythonCommandsFromIOHandler ("    ", *this, true, wp_options);
1274 }
1275
1276 void
1277 ScriptInterpreterPython::SetBreakpointCommandCallbackFunction (BreakpointOptions *bp_options,
1278                                                                const char *function_name)
1279 {
1280     // For now just cons up a oneliner that calls the provided function.
1281     std::string oneliner("return ");
1282     oneliner += function_name;
1283     oneliner += "(frame, bp_loc, internal_dict)";
1284     m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
1285                                                                         oneliner.c_str());
1286 }
1287
1288 // Set a Python one-liner as the callback for the breakpoint.
1289 Error
1290 ScriptInterpreterPython::SetBreakpointCommandCallback (BreakpointOptions *bp_options,
1291                                                        const char *command_body_text)
1292 {
1293     std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
1294
1295     // Split the command_body_text into lines, and pass that to GenerateBreakpointCommandCallbackData.  That will
1296     // wrap the body in an auto-generated function, and return the function name in script_source.  That is what
1297     // the callback will actually invoke.
1298
1299     data_ap->user_source.SplitIntoLines(command_body_text);
1300     Error error = GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source);
1301     if (error.Success())
1302     {
1303         BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
1304         bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp);
1305         return error;
1306     }
1307     else
1308         return error;
1309 }
1310
1311 // Set a Python one-liner as the callback for the watchpoint.
1312 void
1313 ScriptInterpreterPython::SetWatchpointCommandCallback (WatchpointOptions *wp_options,
1314                                                        const char *oneliner)
1315 {
1316     std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
1317
1318     // It's necessary to set both user_source and script_source to the oneliner.
1319     // The former is used to generate callback description (as in watchpoint command list)
1320     // while the latter is used for Python to interpret during the actual callback.
1321
1322     data_ap->user_source.AppendString (oneliner);
1323     data_ap->script_source.assign (oneliner);
1324
1325     if (GenerateWatchpointCommandCallbackData (data_ap->user_source, data_ap->script_source))
1326     {
1327         BatonSP baton_sp (new WatchpointOptions::CommandBaton (data_ap.release()));
1328         wp_options->SetCallback (ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp);
1329     }
1330
1331     return;
1332 }
1333
1334 Error
1335 ScriptInterpreterPython::ExportFunctionDefinitionToInterpreter (StringList &function_def)
1336 {
1337     // Convert StringList to one long, newline delimited, const char *.
1338     std::string function_def_string(function_def.CopyList());
1339
1340     Error error = ExecuteMultipleLines (function_def_string.c_str(), ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false));
1341     return error;
1342 }
1343
1344 Error
1345 ScriptInterpreterPython::GenerateFunction(const char *signature, const StringList &input)
1346 {
1347     Error error;
1348     int num_lines = input.GetSize ();
1349     if (num_lines == 0)
1350     {
1351         error.SetErrorString ("No input data.");
1352         return error;
1353     }
1354
1355     if (!signature || *signature == 0)
1356     {
1357         error.SetErrorString("No output function name.");
1358         return error;
1359     }
1360
1361     StreamString sstr;
1362     StringList auto_generated_function;
1363     auto_generated_function.AppendString (signature);
1364     auto_generated_function.AppendString ("     global_dict = globals()");   // Grab the global dictionary
1365     auto_generated_function.AppendString ("     new_keys = internal_dict.keys()");    // Make a list of keys in the session dict
1366     auto_generated_function.AppendString ("     old_keys = global_dict.keys()"); // Save list of keys in global dict
1367     auto_generated_function.AppendString ("     global_dict.update (internal_dict)"); // Add the session dictionary to the
1368     // global dictionary.
1369
1370     // Wrap everything up inside the function, increasing the indentation.
1371
1372     auto_generated_function.AppendString("     if True:");
1373     for (int i = 0; i < num_lines; ++i)
1374     {
1375         sstr.Clear ();
1376         sstr.Printf ("       %s", input.GetStringAtIndex (i));
1377         auto_generated_function.AppendString (sstr.GetData());
1378     }
1379     auto_generated_function.AppendString ("     for key in new_keys:");  // Iterate over all the keys from session dict
1380     auto_generated_function.AppendString ("         internal_dict[key] = global_dict[key]");  // Update session dict values
1381     auto_generated_function.AppendString ("         if key not in old_keys:");       // If key was not originally in global dict
1382     auto_generated_function.AppendString ("             del global_dict[key]");      //  ...then remove key/value from global dict
1383
1384     // Verify that the results are valid Python.
1385
1386     error = ExportFunctionDefinitionToInterpreter (auto_generated_function);
1387
1388     return error;
1389 }
1390
1391 bool
1392 ScriptInterpreterPython::GenerateTypeScriptFunction (StringList &user_input, std::string& output, const void* name_token)
1393 {
1394     static uint32_t num_created_functions = 0;
1395     user_input.RemoveBlankLines ();
1396     StreamString sstr;
1397
1398     // Check to see if we have any data; if not, just return.
1399     if (user_input.GetSize() == 0)
1400         return false;
1401
1402     // Take what the user wrote, wrap it all up inside one big auto-generated Python function, passing in the
1403     // ValueObject as parameter to the function.
1404
1405     std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_type_print_func", num_created_functions, name_token));
1406     sstr.Printf ("def %s (valobj, internal_dict):", auto_generated_function_name.c_str());
1407
1408     if (!GenerateFunction(sstr.GetData(), user_input).Success())
1409         return false;
1410
1411     // Store the name of the auto-generated function to be called.
1412     output.assign(auto_generated_function_name);
1413     return true;
1414 }
1415
1416 bool
1417 ScriptInterpreterPython::GenerateScriptAliasFunction (StringList &user_input, std::string &output)
1418 {
1419     static uint32_t num_created_functions = 0;
1420     user_input.RemoveBlankLines ();
1421     StreamString sstr;
1422
1423     // Check to see if we have any data; if not, just return.
1424     if (user_input.GetSize() == 0)
1425         return false;
1426
1427     std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_cmd_alias_func", num_created_functions));
1428
1429     sstr.Printf ("def %s (debugger, args, result, internal_dict):", auto_generated_function_name.c_str());
1430
1431     if (!GenerateFunction(sstr.GetData(),user_input).Success())
1432         return false;
1433
1434     // Store the name of the auto-generated function to be called.
1435     output.assign(auto_generated_function_name);
1436     return true;
1437 }
1438
1439
1440 bool
1441 ScriptInterpreterPython::GenerateTypeSynthClass (StringList &user_input, std::string &output, const void* name_token)
1442 {
1443     static uint32_t num_created_classes = 0;
1444     user_input.RemoveBlankLines ();
1445     int num_lines = user_input.GetSize ();
1446     StreamString sstr;
1447
1448     // Check to see if we have any data; if not, just return.
1449     if (user_input.GetSize() == 0)
1450         return false;
1451
1452     // Wrap all user input into a Python class
1453
1454     std::string auto_generated_class_name(GenerateUniqueName("lldb_autogen_python_type_synth_class",num_created_classes,name_token));
1455
1456     StringList auto_generated_class;
1457
1458     // Create the function name & definition string.
1459
1460     sstr.Printf ("class %s:", auto_generated_class_name.c_str());
1461     auto_generated_class.AppendString (sstr.GetData());
1462
1463     // Wrap everything up inside the class, increasing the indentation.
1464     // we don't need to play any fancy indentation tricks here because there is no
1465     // surrounding code whose indentation we need to honor
1466     for (int i = 0; i < num_lines; ++i)
1467     {
1468         sstr.Clear ();
1469         sstr.Printf ("     %s", user_input.GetStringAtIndex (i));
1470         auto_generated_class.AppendString (sstr.GetData());
1471     }
1472
1473
1474     // Verify that the results are valid Python.
1475     // (even though the method is ExportFunctionDefinitionToInterpreter, a class will actually be exported)
1476     // (TODO: rename that method to ExportDefinitionToInterpreter)
1477     if (!ExportFunctionDefinitionToInterpreter (auto_generated_class).Success())
1478         return false;
1479
1480     // Store the name of the auto-generated class
1481
1482     output.assign(auto_generated_class_name);
1483     return true;
1484 }
1485
1486 StructuredData::GenericSP
1487 ScriptInterpreterPython::OSPlugin_CreatePluginObject(const char *class_name, lldb::ProcessSP process_sp)
1488 {
1489     if (class_name == nullptr || class_name[0] == '\0')
1490         return StructuredData::GenericSP();
1491
1492     if (!process_sp)
1493         return StructuredData::GenericSP();
1494
1495     void* ret_val;
1496
1497     {
1498         Locker py_lock  (this,
1499                          Locker::AcquireLock | Locker::NoSTDIN,
1500                          Locker::FreeLock);
1501         ret_val = g_swig_create_os_plugin    (class_name,
1502                                               m_dictionary_name.c_str(),
1503                                               process_sp);
1504     }
1505
1506     return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
1507 }
1508
1509 StructuredData::DictionarySP
1510 ScriptInterpreterPython::OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp)
1511 {
1512     Locker py_lock(this,
1513                    Locker::AcquireLock | Locker::NoSTDIN,
1514                    Locker::FreeLock);
1515
1516     static char callee_name[] = "get_register_info";
1517
1518     if (!os_plugin_object_sp)
1519         return StructuredData::DictionarySP();
1520
1521     StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1522     if (!generic)
1523         return nullptr;
1524
1525     PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
1526
1527     if (!implementor.IsAllocated())
1528         return StructuredData::DictionarySP();
1529
1530     PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
1531
1532     if (PyErr_Occurred())
1533         PyErr_Clear();
1534
1535     if (!pmeth.IsAllocated())
1536         return StructuredData::DictionarySP();
1537
1538     if (PyCallable_Check(pmeth.get()) == 0)
1539     {
1540         if (PyErr_Occurred())
1541             PyErr_Clear();
1542
1543         return StructuredData::DictionarySP();
1544     }
1545
1546     if (PyErr_Occurred())
1547         PyErr_Clear();
1548
1549     // right now we know this function exists and is callable..
1550     PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
1551
1552     // if it fails, print the error but otherwise go on
1553     if (PyErr_Occurred())
1554     {
1555         PyErr_Print();
1556         PyErr_Clear();
1557     }
1558     assert(PythonDictionary::Check(py_return.get()) && "get_register_info returned unknown object type!");
1559
1560     PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
1561     return result_dict.CreateStructuredDictionary();
1562 }
1563
1564 StructuredData::ArraySP
1565 ScriptInterpreterPython::OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp)
1566 {
1567     Locker py_lock (this,
1568                     Locker::AcquireLock | Locker::NoSTDIN,
1569                     Locker::FreeLock);
1570
1571     static char callee_name[] = "get_thread_info";
1572
1573     if (!os_plugin_object_sp)
1574         return StructuredData::ArraySP();
1575
1576     StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1577     if (!generic)
1578         return nullptr;
1579
1580     PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
1581
1582     if (!implementor.IsAllocated())
1583         return StructuredData::ArraySP();
1584
1585     PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
1586
1587     if (PyErr_Occurred())
1588         PyErr_Clear();
1589
1590     if (!pmeth.IsAllocated())
1591         return StructuredData::ArraySP();
1592
1593     if (PyCallable_Check(pmeth.get()) == 0)
1594     {
1595         if (PyErr_Occurred())
1596             PyErr_Clear();
1597
1598         return StructuredData::ArraySP();
1599     }
1600
1601     if (PyErr_Occurred())
1602         PyErr_Clear();
1603
1604     // right now we know this function exists and is callable..
1605     PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
1606
1607     // if it fails, print the error but otherwise go on
1608     if (PyErr_Occurred())
1609     {
1610         PyErr_Print();
1611         PyErr_Clear();
1612     }
1613
1614     assert(PythonList::Check(py_return.get()) && "get_thread_info returned unknown object type!");
1615
1616     PythonList result_list(PyRefType::Borrowed, py_return.get());
1617     return result_list.CreateStructuredArray();
1618 }
1619
1620 // GetPythonValueFormatString provides a system independent type safe way to
1621 // convert a variable's type into a python value format. Python value formats
1622 // are defined in terms of builtin C types and could change from system to
1623 // as the underlying typedef for uint* types, size_t, off_t and other values
1624 // change.
1625
1626 template <typename T>
1627 const char *GetPythonValueFormatString(T t)
1628 {
1629     assert(!"Unhandled type passed to GetPythonValueFormatString(T), make a specialization of GetPythonValueFormatString() to support this type.");
1630     return nullptr;
1631 }
1632 template <> const char *GetPythonValueFormatString (char *)             { return "s"; }
1633 template <> const char *GetPythonValueFormatString (char)               { return "b"; }
1634 template <> const char *GetPythonValueFormatString (unsigned char)      { return "B"; }
1635 template <> const char *GetPythonValueFormatString (short)              { return "h"; }
1636 template <> const char *GetPythonValueFormatString (unsigned short)     { return "H"; }
1637 template <> const char *GetPythonValueFormatString (int)                { return "i"; }
1638 template <> const char *GetPythonValueFormatString (unsigned int)       { return "I"; }
1639 template <> const char *GetPythonValueFormatString (long)               { return "l"; }
1640 template <> const char *GetPythonValueFormatString (unsigned long)      { return "k"; }
1641 template <> const char *GetPythonValueFormatString (long long)          { return "L"; }
1642 template <> const char *GetPythonValueFormatString (unsigned long long) { return "K"; }
1643 template <> const char *GetPythonValueFormatString (float t)            { return "f"; }
1644 template <> const char *GetPythonValueFormatString (double t)           { return "d"; }
1645
1646 StructuredData::StringSP
1647 ScriptInterpreterPython::OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid)
1648 {
1649     Locker py_lock (this,
1650                     Locker::AcquireLock | Locker::NoSTDIN,
1651                     Locker::FreeLock);
1652
1653     static char callee_name[] = "get_register_data";
1654     static char *param_format = const_cast<char *>(GetPythonValueFormatString(tid));
1655
1656     if (!os_plugin_object_sp)
1657         return StructuredData::StringSP();
1658
1659     StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1660     if (!generic)
1661         return nullptr;
1662     PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
1663
1664     if (!implementor.IsAllocated())
1665         return StructuredData::StringSP();
1666
1667     PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
1668
1669     if (PyErr_Occurred())
1670         PyErr_Clear();
1671
1672     if (!pmeth.IsAllocated())
1673         return StructuredData::StringSP();
1674
1675     if (PyCallable_Check(pmeth.get()) == 0)
1676     {
1677         if (PyErr_Occurred())
1678             PyErr_Clear();
1679         return StructuredData::StringSP();
1680     }
1681
1682     if (PyErr_Occurred())
1683         PyErr_Clear();
1684
1685     // right now we know this function exists and is callable..
1686     PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, param_format, tid));
1687
1688     // if it fails, print the error but otherwise go on
1689     if (PyErr_Occurred())
1690     {
1691         PyErr_Print();
1692         PyErr_Clear();
1693     }
1694
1695     assert(PythonBytes::Check(py_return.get()) && "get_register_data returned unknown object type!");
1696
1697     PythonBytes result(PyRefType::Borrowed, py_return.get());
1698     return result.CreateStructuredString();
1699 }
1700
1701 StructuredData::DictionarySP
1702 ScriptInterpreterPython::OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid, lldb::addr_t context)
1703 {
1704     Locker py_lock(this,
1705                    Locker::AcquireLock | Locker::NoSTDIN,
1706                    Locker::FreeLock);
1707
1708     static char callee_name[] = "create_thread";
1709     std::string param_format;
1710     param_format += GetPythonValueFormatString(tid);
1711     param_format += GetPythonValueFormatString(context);
1712
1713     if (!os_plugin_object_sp)
1714         return StructuredData::DictionarySP();
1715
1716     StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1717     if (!generic)
1718         return nullptr;
1719
1720     PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
1721
1722     if (!implementor.IsAllocated())
1723         return StructuredData::DictionarySP();
1724
1725     PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
1726
1727     if (PyErr_Occurred())
1728         PyErr_Clear();
1729
1730     if (!pmeth.IsAllocated())
1731         return StructuredData::DictionarySP();
1732
1733     if (PyCallable_Check(pmeth.get()) == 0)
1734     {
1735         if (PyErr_Occurred())
1736             PyErr_Clear();
1737         return StructuredData::DictionarySP();
1738     }
1739
1740     if (PyErr_Occurred())
1741         PyErr_Clear();
1742
1743     // right now we know this function exists and is callable..
1744     PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, &param_format[0], tid, context));
1745
1746     // if it fails, print the error but otherwise go on
1747     if (PyErr_Occurred())
1748     {
1749         PyErr_Print();
1750         PyErr_Clear();
1751     }
1752
1753     assert(PythonDictionary::Check(py_return.get()) && "create_thread returned unknown object type!");
1754
1755     PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
1756     return result_dict.CreateStructuredDictionary();
1757 }
1758
1759 StructuredData::ObjectSP
1760 ScriptInterpreterPython::CreateScriptedThreadPlan(const char *class_name, lldb::ThreadPlanSP thread_plan_sp)
1761 {
1762     if (class_name == nullptr || class_name[0] == '\0')
1763         return StructuredData::ObjectSP();
1764
1765     if (!thread_plan_sp.get())
1766         return StructuredData::ObjectSP();
1767
1768     Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
1769     ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
1770     ScriptInterpreterPython *python_interpreter = static_cast<ScriptInterpreterPython *>(script_interpreter);
1771
1772     if (!script_interpreter)
1773         return StructuredData::ObjectSP();
1774
1775     void* ret_val;
1776
1777     {
1778         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1779
1780         ret_val = g_swig_thread_plan_script (class_name,
1781                                              python_interpreter->m_dictionary_name.c_str(),
1782                                              thread_plan_sp);
1783     }
1784
1785     return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
1786 }
1787
1788 bool
1789 ScriptInterpreterPython::ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
1790 {
1791     bool explains_stop = true;
1792     StructuredData::Generic *generic = nullptr;
1793     if (implementor_sp)
1794         generic = implementor_sp->GetAsGeneric();
1795     if (generic)
1796     {
1797         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1798         explains_stop = g_swig_call_thread_plan(generic->GetValue(), "explains_stop", event, script_error);
1799         if (script_error)
1800             return true;
1801     }
1802     return explains_stop;
1803 }
1804
1805 bool
1806 ScriptInterpreterPython::ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
1807 {
1808     bool should_stop = true;
1809     StructuredData::Generic *generic = nullptr;
1810     if (implementor_sp)
1811         generic = implementor_sp->GetAsGeneric();
1812     if (generic)
1813     {
1814         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1815         should_stop = g_swig_call_thread_plan(generic->GetValue(), "should_stop", event, script_error);
1816         if (script_error)
1817             return true;
1818     }
1819     return should_stop;
1820 }
1821
1822 lldb::StateType
1823 ScriptInterpreterPython::ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp, bool &script_error)
1824 {
1825     bool should_step = false;
1826     StructuredData::Generic *generic = nullptr;
1827     if (implementor_sp)
1828         generic = implementor_sp->GetAsGeneric();
1829     if (generic)
1830     {
1831         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1832         should_step = g_swig_call_thread_plan(generic->GetValue(), "should_step", NULL, script_error);
1833         if (script_error)
1834             should_step = true;
1835     }
1836     if (should_step)
1837         return lldb::eStateStepping;
1838     else
1839         return lldb::eStateRunning;
1840 }
1841
1842 StructuredData::ObjectSP
1843 ScriptInterpreterPython::LoadPluginModule(const FileSpec &file_spec, lldb_private::Error &error)
1844 {
1845     if (!file_spec.Exists())
1846     {
1847         error.SetErrorString("no such file");
1848         return StructuredData::ObjectSP();
1849     }
1850
1851     StructuredData::ObjectSP module_sp;
1852
1853     if (LoadScriptingModule(file_spec.GetPath().c_str(),true,true,error,&module_sp))
1854         return module_sp;
1855
1856     return StructuredData::ObjectSP();
1857 }
1858
1859 StructuredData::DictionarySP
1860 ScriptInterpreterPython::GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target, const char *setting_name,
1861                                             lldb_private::Error &error)
1862 {
1863     if (!plugin_module_sp || !target || !setting_name || !setting_name[0] || !g_swig_plugin_get)
1864         return StructuredData::DictionarySP();
1865     StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
1866     if (!generic)
1867         return StructuredData::DictionarySP();
1868
1869     PythonObject reply_pyobj;
1870     {
1871         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1872         TargetSP target_sp(target->shared_from_this());
1873         reply_pyobj.Reset(PyRefType::Owned,
1874                           (PyObject *)g_swig_plugin_get(generic->GetValue(), setting_name, target_sp));
1875     }
1876
1877     PythonDictionary py_dict(PyRefType::Borrowed, reply_pyobj.get());
1878     return py_dict.CreateStructuredDictionary();
1879 }
1880
1881 StructuredData::ObjectSP
1882 ScriptInterpreterPython::CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj)
1883 {
1884     if (class_name == nullptr || class_name[0] == '\0')
1885         return StructuredData::ObjectSP();
1886
1887     if (!valobj.get())
1888         return StructuredData::ObjectSP();
1889
1890     ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
1891     Target *target = exe_ctx.GetTargetPtr();
1892
1893     if (!target)
1894         return StructuredData::ObjectSP();
1895
1896     Debugger &debugger = target->GetDebugger();
1897     ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
1898     ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter;
1899
1900     if (!script_interpreter)
1901         return StructuredData::ObjectSP();
1902
1903     void *ret_val = nullptr;
1904
1905     {
1906         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1907         ret_val = g_swig_synthetic_script (class_name,
1908                                            python_interpreter->m_dictionary_name.c_str(),
1909                                            valobj);
1910     }
1911
1912     return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
1913 }
1914
1915 StructuredData::GenericSP
1916 ScriptInterpreterPython::CreateScriptCommandObject (const char *class_name)
1917 {
1918     DebuggerSP debugger_sp(GetCommandInterpreter().GetDebugger().shared_from_this());
1919
1920     if (class_name == nullptr || class_name[0] == '\0')
1921         return StructuredData::GenericSP();
1922
1923     if (!debugger_sp.get())
1924         return StructuredData::GenericSP();
1925
1926     void* ret_val;
1927
1928     {
1929         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1930         ret_val = g_swig_create_cmd (class_name,
1931                                      m_dictionary_name.c_str(),
1932                                      debugger_sp);
1933     }
1934
1935     return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
1936 }
1937
1938 bool
1939 ScriptInterpreterPython::GenerateTypeScriptFunction (const char* oneliner, std::string& output, const void* name_token)
1940 {
1941     StringList input;
1942     input.SplitIntoLines(oneliner, strlen(oneliner));
1943     return GenerateTypeScriptFunction(input, output, name_token);
1944 }
1945
1946 bool
1947 ScriptInterpreterPython::GenerateTypeSynthClass (const char* oneliner, std::string& output, const void* name_token)
1948 {
1949     StringList input;
1950     input.SplitIntoLines(oneliner, strlen(oneliner));
1951     return GenerateTypeSynthClass(input, output, name_token);
1952 }
1953
1954
1955 Error
1956 ScriptInterpreterPython::GenerateBreakpointCommandCallbackData (StringList &user_input, std::string& output)
1957 {
1958     static uint32_t num_created_functions = 0;
1959     user_input.RemoveBlankLines ();
1960     StreamString sstr;
1961     Error error;
1962     if (user_input.GetSize() == 0)
1963     {
1964         error.SetErrorString("No input data.");
1965         return error;
1966     }
1967
1968     std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_bp_callback_func_",num_created_functions));
1969     sstr.Printf ("def %s (frame, bp_loc, internal_dict):", auto_generated_function_name.c_str());
1970
1971     error = GenerateFunction(sstr.GetData(), user_input);
1972     if (!error.Success())
1973         return error;
1974
1975     // Store the name of the auto-generated function to be called.
1976     output.assign(auto_generated_function_name);
1977     return error;
1978 }
1979
1980 bool
1981 ScriptInterpreterPython::GenerateWatchpointCommandCallbackData (StringList &user_input, std::string& output)
1982 {
1983     static uint32_t num_created_functions = 0;
1984     user_input.RemoveBlankLines ();
1985     StreamString sstr;
1986
1987     if (user_input.GetSize() == 0)
1988         return false;
1989
1990     std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_wp_callback_func_",num_created_functions));
1991     sstr.Printf ("def %s (frame, wp, internal_dict):", auto_generated_function_name.c_str());
1992
1993     if (!GenerateFunction(sstr.GetData(), user_input).Success())
1994         return false;
1995
1996     // Store the name of the auto-generated function to be called.
1997     output.assign(auto_generated_function_name);
1998     return true;
1999 }
2000
2001 bool
2002 ScriptInterpreterPython::GetScriptedSummary(const char *python_function_name, lldb::ValueObjectSP valobj,
2003                                             StructuredData::ObjectSP &callee_wrapper_sp, const TypeSummaryOptions &options,
2004                                             std::string &retval)
2005 {
2006
2007     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
2008
2009     if (!valobj.get())
2010     {
2011         retval.assign("<no object>");
2012         return false;
2013     }
2014
2015     void *old_callee = nullptr;
2016     StructuredData::Generic *generic = nullptr;
2017     if (callee_wrapper_sp)
2018     {
2019         generic = callee_wrapper_sp->GetAsGeneric();
2020         if (generic)
2021             old_callee = generic->GetValue();
2022     }
2023     void* new_callee = old_callee;
2024
2025     bool ret_val;
2026     if (python_function_name && *python_function_name)
2027     {
2028         {
2029             Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2030             {
2031                 TypeSummaryOptionsSP options_sp(new TypeSummaryOptions(options));
2032
2033                 Timer scoped_timer ("g_swig_typescript_callback","g_swig_typescript_callback");
2034                 ret_val = g_swig_typescript_callback (python_function_name,
2035                                                       GetSessionDictionary().get(),
2036                                                       valobj,
2037                                                       &new_callee,
2038                                                       options_sp,
2039                                                       retval);
2040             }
2041         }
2042     }
2043     else
2044     {
2045         retval.assign("<no function name>");
2046         return false;
2047     }
2048
2049     if (new_callee && old_callee != new_callee)
2050         callee_wrapper_sp.reset(new StructuredPythonObject(new_callee));
2051
2052     return ret_val;
2053 }
2054
2055 void
2056 ScriptInterpreterPython::Clear ()
2057 {
2058     // Release any global variables that might have strong references to
2059     // LLDB objects when clearing the python script interpreter.
2060     Locker locker(this,
2061                   ScriptInterpreterPython::Locker::AcquireLock,
2062                   ScriptInterpreterPython::Locker::FreeAcquiredLock);
2063
2064     // This may be called as part of Py_Finalize.  In that case the modules are destroyed in random
2065     // order and we can't guarantee that we can access these.
2066     if (Py_IsInitialized())
2067         PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process = None; lldb.thread = None; lldb.frame = None");
2068 }
2069
2070 bool
2071 ScriptInterpreterPython::BreakpointCallbackFunction
2072 (
2073     void *baton,
2074     StoppointCallbackContext *context,
2075     user_id_t break_id,
2076     user_id_t break_loc_id
2077 )
2078 {
2079     BreakpointOptions::CommandData *bp_option_data = (BreakpointOptions::CommandData *) baton;
2080     const char *python_function_name = bp_option_data->script_source.c_str();
2081
2082     if (!context)
2083         return true;
2084
2085     ExecutionContext exe_ctx (context->exe_ctx_ref);
2086     Target *target = exe_ctx.GetTargetPtr();
2087
2088     if (!target)
2089         return true;
2090
2091     Debugger &debugger = target->GetDebugger();
2092     ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
2093     ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter;
2094
2095     if (!script_interpreter)
2096         return true;
2097
2098     if (python_function_name && python_function_name[0])
2099     {
2100         const StackFrameSP stop_frame_sp (exe_ctx.GetFrameSP());
2101         BreakpointSP breakpoint_sp = target->GetBreakpointByID (break_id);
2102         if (breakpoint_sp)
2103         {
2104             const BreakpointLocationSP bp_loc_sp (breakpoint_sp->FindLocationByID (break_loc_id));
2105
2106             if (stop_frame_sp && bp_loc_sp)
2107             {
2108                 bool ret_val = true;
2109                 {
2110                     Locker py_lock(python_interpreter, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2111                     ret_val = g_swig_breakpoint_callback (python_function_name,
2112                                                           python_interpreter->m_dictionary_name.c_str(),
2113                                                           stop_frame_sp,
2114                                                           bp_loc_sp);
2115                 }
2116                 return ret_val;
2117             }
2118         }
2119     }
2120     // We currently always true so we stop in case anything goes wrong when
2121     // trying to call the script function
2122     return true;
2123 }
2124
2125 bool
2126 ScriptInterpreterPython::WatchpointCallbackFunction
2127 (
2128     void *baton,
2129     StoppointCallbackContext *context,
2130     user_id_t watch_id
2131 )
2132 {
2133     WatchpointOptions::CommandData *wp_option_data = (WatchpointOptions::CommandData *) baton;
2134     const char *python_function_name = wp_option_data->script_source.c_str();
2135
2136     if (!context)
2137         return true;
2138
2139     ExecutionContext exe_ctx (context->exe_ctx_ref);
2140     Target *target = exe_ctx.GetTargetPtr();
2141
2142     if (!target)
2143         return true;
2144
2145     Debugger &debugger = target->GetDebugger();
2146     ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
2147     ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter;
2148
2149     if (!script_interpreter)
2150         return true;
2151
2152     if (python_function_name && python_function_name[0])
2153     {
2154         const StackFrameSP stop_frame_sp (exe_ctx.GetFrameSP());
2155         WatchpointSP wp_sp = target->GetWatchpointList().FindByID (watch_id);
2156         if (wp_sp)
2157         {
2158             if (stop_frame_sp && wp_sp)
2159             {
2160                 bool ret_val = true;
2161                 {
2162                     Locker py_lock(python_interpreter, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2163                     ret_val = g_swig_watchpoint_callback (python_function_name,
2164                                                           python_interpreter->m_dictionary_name.c_str(),
2165                                                           stop_frame_sp,
2166                                                           wp_sp);
2167                 }
2168                 return ret_val;
2169             }
2170         }
2171     }
2172     // We currently always true so we stop in case anything goes wrong when
2173     // trying to call the script function
2174     return true;
2175 }
2176
2177 size_t
2178 ScriptInterpreterPython::CalculateNumChildren(const StructuredData::ObjectSP &implementor_sp, uint32_t max)
2179 {
2180     if (!implementor_sp)
2181         return 0;
2182     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2183     if (!generic)
2184         return 0;
2185     void *implementor = generic->GetValue();
2186     if (!implementor)
2187         return 0;
2188
2189     if (!g_swig_calc_children)
2190         return 0;
2191
2192     size_t ret_val = 0;
2193
2194     {
2195         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2196         ret_val = g_swig_calc_children (implementor, max);
2197     }
2198
2199     return ret_val;
2200 }
2201
2202 lldb::ValueObjectSP
2203 ScriptInterpreterPython::GetChildAtIndex(const StructuredData::ObjectSP &implementor_sp, uint32_t idx)
2204 {
2205     if (!implementor_sp)
2206         return lldb::ValueObjectSP();
2207
2208     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2209     if (!generic)
2210         return lldb::ValueObjectSP();
2211     void *implementor = generic->GetValue();
2212     if (!implementor)
2213         return lldb::ValueObjectSP();
2214
2215     if (!g_swig_get_child_index || !g_swig_cast_to_sbvalue)
2216         return lldb::ValueObjectSP();
2217
2218     lldb::ValueObjectSP ret_val;
2219
2220     {
2221         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2222         void* child_ptr = g_swig_get_child_index (implementor,idx);
2223         if (child_ptr != nullptr && child_ptr != Py_None)
2224         {
2225             lldb::SBValue* sb_value_ptr = (lldb::SBValue*)g_swig_cast_to_sbvalue(child_ptr);
2226             if (sb_value_ptr == nullptr)
2227                 Py_XDECREF(child_ptr);
2228             else
2229                 ret_val = g_swig_get_valobj_sp_from_sbvalue (sb_value_ptr);
2230         }
2231         else
2232         {
2233             Py_XDECREF(child_ptr);
2234         }
2235     }
2236
2237     return ret_val;
2238 }
2239
2240 int
2241 ScriptInterpreterPython::GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor_sp, const char *child_name)
2242 {
2243     if (!implementor_sp)
2244         return UINT32_MAX;
2245
2246     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2247     if (!generic)
2248         return UINT32_MAX;
2249     void *implementor = generic->GetValue();
2250     if (!implementor)
2251         return UINT32_MAX;
2252
2253     if (!g_swig_get_index_child)
2254         return UINT32_MAX;
2255
2256     int ret_val = UINT32_MAX;
2257
2258     {
2259         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2260         ret_val = g_swig_get_index_child (implementor, child_name);
2261     }
2262
2263     return ret_val;
2264 }
2265
2266 bool
2267 ScriptInterpreterPython::UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor_sp)
2268 {
2269     bool ret_val = false;
2270
2271     if (!implementor_sp)
2272         return ret_val;
2273
2274     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2275     if (!generic)
2276         return ret_val;
2277     void *implementor = generic->GetValue();
2278     if (!implementor)
2279         return ret_val;
2280
2281     if (!g_swig_update_provider)
2282         return ret_val;
2283
2284     {
2285         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2286         ret_val = g_swig_update_provider (implementor);
2287     }
2288
2289     return ret_val;
2290 }
2291
2292 bool
2293 ScriptInterpreterPython::MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor_sp)
2294 {
2295     bool ret_val = false;
2296
2297     if (!implementor_sp)
2298         return ret_val;
2299
2300     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2301     if (!generic)
2302         return ret_val;
2303     void *implementor = generic->GetValue();
2304     if (!implementor)
2305         return ret_val;
2306
2307     if (!g_swig_mighthavechildren_provider)
2308         return ret_val;
2309
2310     {
2311         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2312         ret_val = g_swig_mighthavechildren_provider (implementor);
2313     }
2314
2315     return ret_val;
2316 }
2317
2318 lldb::ValueObjectSP
2319 ScriptInterpreterPython::GetSyntheticValue(const StructuredData::ObjectSP &implementor_sp)
2320 {
2321     lldb::ValueObjectSP ret_val(nullptr);
2322
2323     if (!implementor_sp)
2324         return ret_val;
2325
2326     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2327     if (!generic)
2328         return ret_val;
2329     void *implementor = generic->GetValue();
2330     if (!implementor)
2331         return ret_val;
2332
2333     if (!g_swig_getvalue_provider || !g_swig_cast_to_sbvalue || !g_swig_get_valobj_sp_from_sbvalue)
2334         return ret_val;
2335
2336     {
2337         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2338         void* child_ptr = g_swig_getvalue_provider (implementor);
2339         if (child_ptr != nullptr && child_ptr != Py_None)
2340         {
2341             lldb::SBValue* sb_value_ptr = (lldb::SBValue*)g_swig_cast_to_sbvalue(child_ptr);
2342             if (sb_value_ptr == nullptr)
2343                 Py_XDECREF(child_ptr);
2344             else
2345                 ret_val = g_swig_get_valobj_sp_from_sbvalue (sb_value_ptr);
2346         }
2347         else
2348         {
2349             Py_XDECREF(child_ptr);
2350         }
2351     }
2352
2353     return ret_val;
2354 }
2355
2356 bool
2357 ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
2358                                                  Process* process,
2359                                                  std::string& output,
2360                                                  Error& error)
2361 {
2362     bool ret_val;
2363     if (!process)
2364     {
2365         error.SetErrorString("no process");
2366         return false;
2367     }
2368     if (!impl_function || !impl_function[0])
2369     {
2370         error.SetErrorString("no function to execute");
2371         return false;
2372     }
2373     if (!g_swig_run_script_keyword_process)
2374     {
2375         error.SetErrorString("internal helper function missing");
2376         return false;
2377     }
2378     {
2379         ProcessSP process_sp(process->shared_from_this());
2380         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2381         ret_val = g_swig_run_script_keyword_process (impl_function, m_dictionary_name.c_str(), process_sp, output);
2382         if (!ret_val)
2383             error.SetErrorString("python script evaluation failed");
2384     }
2385     return ret_val;
2386 }
2387
2388 bool
2389 ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
2390                                                  Thread* thread,
2391                                                  std::string& output,
2392                                                  Error& error)
2393 {
2394     bool ret_val;
2395     if (!thread)
2396     {
2397         error.SetErrorString("no thread");
2398         return false;
2399     }
2400     if (!impl_function || !impl_function[0])
2401     {
2402         error.SetErrorString("no function to execute");
2403         return false;
2404     }
2405     if (!g_swig_run_script_keyword_thread)
2406     {
2407         error.SetErrorString("internal helper function missing");
2408         return false;
2409     }
2410     {
2411         ThreadSP thread_sp(thread->shared_from_this());
2412         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2413         ret_val = g_swig_run_script_keyword_thread (impl_function, m_dictionary_name.c_str(), thread_sp, output);
2414         if (!ret_val)
2415             error.SetErrorString("python script evaluation failed");
2416     }
2417     return ret_val;
2418 }
2419
2420 bool
2421 ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
2422                                                  Target* target,
2423                                                  std::string& output,
2424                                                  Error& error)
2425 {
2426     bool ret_val;
2427     if (!target)
2428     {
2429         error.SetErrorString("no thread");
2430         return false;
2431     }
2432     if (!impl_function || !impl_function[0])
2433     {
2434         error.SetErrorString("no function to execute");
2435         return false;
2436     }
2437     if (!g_swig_run_script_keyword_target)
2438     {
2439         error.SetErrorString("internal helper function missing");
2440         return false;
2441     }
2442     {
2443         TargetSP target_sp(target->shared_from_this());
2444         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2445         ret_val = g_swig_run_script_keyword_target (impl_function, m_dictionary_name.c_str(), target_sp, output);
2446         if (!ret_val)
2447             error.SetErrorString("python script evaluation failed");
2448     }
2449     return ret_val;
2450 }
2451
2452 bool
2453 ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
2454                                                  StackFrame* frame,
2455                                                  std::string& output,
2456                                                  Error& error)
2457 {
2458     bool ret_val;
2459     if (!frame)
2460     {
2461         error.SetErrorString("no frame");
2462         return false;
2463     }
2464     if (!impl_function || !impl_function[0])
2465     {
2466         error.SetErrorString("no function to execute");
2467         return false;
2468     }
2469     if (!g_swig_run_script_keyword_frame)
2470     {
2471         error.SetErrorString("internal helper function missing");
2472         return false;
2473     }
2474     {
2475         StackFrameSP frame_sp(frame->shared_from_this());
2476         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2477         ret_val = g_swig_run_script_keyword_frame (impl_function, m_dictionary_name.c_str(), frame_sp, output);
2478         if (!ret_val)
2479             error.SetErrorString("python script evaluation failed");
2480     }
2481     return ret_val;
2482 }
2483
2484 bool
2485 ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
2486                                                  ValueObject *value,
2487                                                  std::string& output,
2488                                                  Error& error)
2489 {
2490     bool ret_val;
2491     if (!value)
2492     {
2493         error.SetErrorString("no value");
2494         return false;
2495     }
2496     if (!impl_function || !impl_function[0])
2497     {
2498         error.SetErrorString("no function to execute");
2499         return false;
2500     }
2501     if (!g_swig_run_script_keyword_value)
2502     {
2503         error.SetErrorString("internal helper function missing");
2504         return false;
2505     }
2506     {
2507         ValueObjectSP value_sp(value->GetSP());
2508         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2509         ret_val = g_swig_run_script_keyword_value (impl_function, m_dictionary_name.c_str(), value_sp, output);
2510         if (!ret_val)
2511             error.SetErrorString("python script evaluation failed");
2512     }
2513     return ret_val;
2514 }
2515
2516 uint64_t replace_all(std::string& str, const std::string& oldStr, const std::string& newStr)
2517 {
2518     size_t pos = 0;
2519     uint64_t matches = 0;
2520     while((pos = str.find(oldStr, pos)) != std::string::npos)
2521     {
2522         matches++;
2523         str.replace(pos, oldStr.length(), newStr);
2524         pos += newStr.length();
2525     }
2526     return matches;
2527 }
2528
2529 bool
2530 ScriptInterpreterPython::LoadScriptingModule(const char *pathname, bool can_reload, bool init_session, lldb_private::Error &error,
2531                                              StructuredData::ObjectSP *module_sp)
2532 {
2533     if (!pathname || !pathname[0])
2534     {
2535         error.SetErrorString("invalid pathname");
2536         return false;
2537     }
2538
2539     if (!g_swig_call_module_init)
2540     {
2541         error.SetErrorString("internal helper function missing");
2542         return false;
2543     }
2544
2545     lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
2546
2547     {
2548         FileSpec target_file(pathname, true);
2549         std::string basename(target_file.GetFilename().GetCString());
2550
2551         StreamString command_stream;
2552
2553         // Before executing Pyton code, lock the GIL.
2554         Locker py_lock (this,
2555                         Locker::AcquireLock      | (init_session ? Locker::InitSession     : 0) | Locker::NoSTDIN,
2556                         Locker::FreeAcquiredLock | (init_session ? Locker::TearDownSession : 0));
2557
2558         if (target_file.GetFileType() == FileSpec::eFileTypeInvalid ||
2559             target_file.GetFileType() == FileSpec::eFileTypeUnknown)
2560         {
2561             // if not a valid file of any sort, check if it might be a filename still
2562             // dot can't be used but / and \ can, and if either is found, reject
2563             if (strchr(pathname,'\\') || strchr(pathname,'/'))
2564             {
2565                 error.SetErrorString("invalid pathname");
2566                 return false;
2567             }
2568             basename = pathname; // not a filename, probably a package of some sort, let it go through
2569         }
2570         else if (target_file.GetFileType() == FileSpec::eFileTypeDirectory ||
2571                  target_file.GetFileType() == FileSpec::eFileTypeRegular ||
2572                  target_file.GetFileType() == FileSpec::eFileTypeSymbolicLink)
2573         {
2574             std::string directory(target_file.GetDirectory().GetCString());
2575             replace_all(directory,"'","\\'");
2576
2577             // now make sure that Python has "directory" in the search path
2578             StreamString command_stream;
2579             command_stream.Printf("if not (sys.path.__contains__('%s')):\n    sys.path.insert(1,'%s');\n\n",
2580                                   directory.c_str(),
2581                                   directory.c_str());
2582             bool syspath_retval = ExecuteMultipleLines(command_stream.GetData(), ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false).SetSetLLDBGlobals(false)).Success();
2583             if (!syspath_retval)
2584             {
2585                 error.SetErrorString("Python sys.path handling failed");
2586                 return false;
2587             }
2588
2589             // strip .py or .pyc extension
2590             ConstString extension = target_file.GetFileNameExtension();
2591             if (extension)
2592             {
2593                 if (::strcmp(extension.GetCString(), "py") == 0)
2594                     basename.resize(basename.length()-3);
2595                 else if(::strcmp(extension.GetCString(), "pyc") == 0)
2596                     basename.resize(basename.length()-4);
2597             }
2598         }
2599         else
2600         {
2601             error.SetErrorString("no known way to import this module specification");
2602             return false;
2603         }
2604
2605         // check if the module is already import-ed
2606         command_stream.Clear();
2607         command_stream.Printf("sys.modules.__contains__('%s')",basename.c_str());
2608         bool does_contain = false;
2609         // this call will succeed if the module was ever imported in any Debugger in the lifetime of the process
2610         // in which this LLDB framework is living
2611         bool was_imported_globally = (ExecuteOneLineWithReturn(command_stream.GetData(),
2612                                                                ScriptInterpreterPython::eScriptReturnTypeBool,
2613                                                                &does_contain,
2614                                                                ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false).SetSetLLDBGlobals(false)) && does_contain);
2615         // this call will fail if the module was not imported in this Debugger before
2616         command_stream.Clear();
2617         command_stream.Printf("sys.getrefcount(%s)",basename.c_str());
2618         bool was_imported_locally = GetSessionDictionary().GetItemForKey(PythonString(basename)).IsAllocated();
2619
2620         bool was_imported = (was_imported_globally || was_imported_locally);
2621
2622         if (was_imported == true && can_reload == false)
2623         {
2624             error.SetErrorString("module already imported");
2625             return false;
2626         }
2627
2628         // now actually do the import
2629         command_stream.Clear();
2630
2631         if (was_imported)
2632         {
2633             if (!was_imported_locally)
2634                 command_stream.Printf("import %s ; reload_module(%s)",basename.c_str(),basename.c_str());
2635             else
2636                 command_stream.Printf("reload_module(%s)",basename.c_str());
2637         }
2638         else
2639             command_stream.Printf("import %s",basename.c_str());
2640
2641         error = ExecuteMultipleLines(command_stream.GetData(), ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false).SetSetLLDBGlobals(false));
2642         if (error.Fail())
2643             return false;
2644
2645         // if we are here, everything worked
2646         // call __lldb_init_module(debugger,dict)
2647         if (!g_swig_call_module_init (basename.c_str(),
2648                                       m_dictionary_name.c_str(),
2649                                       debugger_sp))
2650         {
2651             error.SetErrorString("calling __lldb_init_module failed");
2652             return false;
2653         }
2654
2655         if (module_sp)
2656         {
2657             // everything went just great, now set the module object
2658             command_stream.Clear();
2659             command_stream.Printf("%s",basename.c_str());
2660             void* module_pyobj = nullptr;
2661             if (ExecuteOneLineWithReturn(command_stream.GetData(),ScriptInterpreter::eScriptReturnTypeOpaqueObject,&module_pyobj) && module_pyobj)
2662                 module_sp->reset(new StructuredPythonObject(module_pyobj));
2663         }
2664
2665         return true;
2666     }
2667 }
2668
2669 bool
2670 ScriptInterpreterPython::IsReservedWord (const char* word)
2671 {
2672     if (!word || !word[0])
2673         return false;
2674
2675     llvm::StringRef word_sr(word);
2676
2677     // filter out a few characters that would just confuse us
2678     // and that are clearly not keyword material anyway
2679     if (word_sr.find_first_of("'\"") != llvm::StringRef::npos)
2680         return false;
2681
2682     StreamString command_stream;
2683     command_stream.Printf("keyword.iskeyword('%s')", word);
2684     bool result;
2685     ExecuteScriptOptions options;
2686     options.SetEnableIO(false);
2687     options.SetMaskoutErrors(true);
2688     options.SetSetLLDBGlobals(false);
2689     if (ExecuteOneLineWithReturn(command_stream.GetData(), ScriptInterpreter::eScriptReturnTypeBool, &result, options))
2690         return result;
2691     return false;
2692 }
2693
2694 ScriptInterpreterPython::SynchronicityHandler::SynchronicityHandler (lldb::DebuggerSP debugger_sp,
2695                                                                      ScriptedCommandSynchronicity synchro) :
2696     m_debugger_sp(debugger_sp),
2697     m_synch_wanted(synchro),
2698     m_old_asynch(debugger_sp->GetAsyncExecution())
2699 {
2700     if (m_synch_wanted == eScriptedCommandSynchronicitySynchronous)
2701         m_debugger_sp->SetAsyncExecution(false);
2702     else if (m_synch_wanted == eScriptedCommandSynchronicityAsynchronous)
2703         m_debugger_sp->SetAsyncExecution(true);
2704 }
2705
2706 ScriptInterpreterPython::SynchronicityHandler::~SynchronicityHandler()
2707 {
2708     if (m_synch_wanted != eScriptedCommandSynchronicityCurrentValue)
2709         m_debugger_sp->SetAsyncExecution(m_old_asynch);
2710 }
2711
2712 bool
2713 ScriptInterpreterPython::RunScriptBasedCommand(const char* impl_function,
2714                                                const char* args,
2715                                                ScriptedCommandSynchronicity synchronicity,
2716                                                lldb_private::CommandReturnObject& cmd_retobj,
2717                                                Error& error,
2718                                                const lldb_private::ExecutionContext& exe_ctx)
2719 {
2720     if (!impl_function)
2721     {
2722         error.SetErrorString("no function to execute");
2723         return false;
2724     }
2725
2726     if (!g_swig_call_command)
2727     {
2728         error.SetErrorString("no helper function to run scripted commands");
2729         return false;
2730     }
2731
2732     lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
2733     lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
2734
2735     if (!debugger_sp.get())
2736     {
2737         error.SetErrorString("invalid Debugger pointer");
2738         return false;
2739    }
2740
2741     bool ret_val = false;
2742
2743     std::string err_msg;
2744
2745     {
2746         Locker py_lock(this,
2747                        Locker::AcquireLock | Locker::InitSession | (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
2748                        Locker::FreeLock    | Locker::TearDownSession);
2749
2750         SynchronicityHandler synch_handler(debugger_sp,
2751                                            synchronicity);
2752
2753         ret_val = g_swig_call_command       (impl_function,
2754                                              m_dictionary_name.c_str(),
2755                                              debugger_sp,
2756                                              args,
2757                                              cmd_retobj,
2758                                              exe_ctx_ref_sp);
2759     }
2760
2761     if (!ret_val)
2762         error.SetErrorString("unable to execute script function");
2763     else
2764         error.Clear();
2765
2766     return ret_val;
2767 }
2768
2769 bool
2770 ScriptInterpreterPython::RunScriptBasedCommand (StructuredData::GenericSP impl_obj_sp,
2771                                                 const char* args,
2772                                                 ScriptedCommandSynchronicity synchronicity,
2773                                                 lldb_private::CommandReturnObject& cmd_retobj,
2774                                                 Error& error,
2775                                                 const lldb_private::ExecutionContext& exe_ctx)
2776 {
2777     if (!impl_obj_sp || !impl_obj_sp->IsValid())
2778     {
2779         error.SetErrorString("no function to execute");
2780         return false;
2781     }
2782
2783     if (!g_swig_call_command_object)
2784     {
2785         error.SetErrorString("no helper function to run scripted commands");
2786         return false;
2787     }
2788
2789     lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
2790     lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
2791
2792     if (!debugger_sp.get())
2793     {
2794         error.SetErrorString("invalid Debugger pointer");
2795         return false;
2796     }
2797
2798     bool ret_val = false;
2799
2800     std::string err_msg;
2801
2802     {
2803         Locker py_lock(this,
2804                        Locker::AcquireLock | Locker::InitSession | (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
2805                        Locker::FreeLock    | Locker::TearDownSession);
2806
2807         SynchronicityHandler synch_handler(debugger_sp,
2808                                            synchronicity);
2809
2810         ret_val = g_swig_call_command_object      (impl_obj_sp->GetValue(),
2811                                                    debugger_sp,
2812                                                    args,
2813                                                    cmd_retobj,
2814                                                    exe_ctx_ref_sp);
2815     }
2816
2817     if (!ret_val)
2818         error.SetErrorString("unable to execute script function");
2819     else
2820         error.Clear();
2821
2822     return ret_val;
2823 }
2824
2825 // in Python, a special attribute __doc__ contains the docstring
2826 // for an object (function, method, class, ...) if any is defined
2827 // Otherwise, the attribute's value is None
2828 bool
2829 ScriptInterpreterPython::GetDocumentationForItem(const char* item, std::string& dest)
2830 {
2831         dest.clear();
2832         if (!item || !*item)
2833                 return false;
2834     std::string command(item);
2835     command += ".__doc__";
2836
2837     char* result_ptr = nullptr; // Python is going to point this to valid data if ExecuteOneLineWithReturn returns successfully
2838
2839     if (ExecuteOneLineWithReturn (command.c_str(),
2840                                   ScriptInterpreter::eScriptReturnTypeCharStrOrNone,
2841                                   &result_ptr,
2842                                   ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false)))
2843     {
2844         if (result_ptr)
2845             dest.assign(result_ptr);
2846         return true;
2847     }
2848     else
2849     {
2850         StreamString str_stream;
2851         str_stream.Printf("Function %s was not found. Containing module might be missing.",item);
2852         dest.assign(str_stream.GetData());
2853         return false;
2854     }
2855 }
2856
2857 bool
2858 ScriptInterpreterPython::GetShortHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
2859                                                        std::string& dest)
2860 {
2861     bool got_string = false;
2862     dest.clear();
2863
2864     Locker py_lock (this,
2865                     Locker::AcquireLock | Locker::NoSTDIN,
2866                     Locker::FreeLock);
2867
2868     static char callee_name[] = "get_short_help";
2869
2870     if (!cmd_obj_sp)
2871         return false;
2872
2873     PythonObject implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
2874
2875     if (!implementor.IsAllocated())
2876         return false;
2877
2878     PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
2879
2880     if (PyErr_Occurred())
2881         PyErr_Clear();
2882
2883     if (!pmeth.IsAllocated())
2884         return false;
2885
2886     if (PyCallable_Check(pmeth.get()) == 0)
2887     {
2888         if (PyErr_Occurred())
2889             PyErr_Clear();
2890         return false;
2891     }
2892
2893     if (PyErr_Occurred())
2894         PyErr_Clear();
2895
2896     // right now we know this function exists and is callable..
2897     PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
2898
2899     // if it fails, print the error but otherwise go on
2900     if (PyErr_Occurred())
2901     {
2902         PyErr_Print();
2903         PyErr_Clear();
2904     }
2905
2906     if (py_return.IsAllocated() && PythonString::Check(py_return.get()))
2907     {
2908         PythonString py_string(PyRefType::Borrowed, py_return.get());
2909         llvm::StringRef return_data(py_string.GetString());
2910         dest.assign(return_data.data(), return_data.size());
2911         got_string = true;
2912     }
2913     return got_string;
2914 }
2915
2916 uint32_t
2917 ScriptInterpreterPython::GetFlagsForCommandObject (StructuredData::GenericSP cmd_obj_sp)
2918 {
2919     uint32_t result = 0;
2920
2921     Locker py_lock (this,
2922                     Locker::AcquireLock | Locker::NoSTDIN,
2923                     Locker::FreeLock);
2924
2925     static char callee_name[] = "get_flags";
2926
2927     if (!cmd_obj_sp)
2928         return result;
2929
2930     PythonObject implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
2931
2932     if (!implementor.IsAllocated())
2933         return result;
2934
2935     PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
2936
2937     if (PyErr_Occurred())
2938         PyErr_Clear();
2939
2940     if (!pmeth.IsAllocated())
2941         return result;
2942
2943     if (PyCallable_Check(pmeth.get()) == 0)
2944     {
2945         if (PyErr_Occurred())
2946             PyErr_Clear();
2947         return result;
2948     }
2949
2950     if (PyErr_Occurred())
2951         PyErr_Clear();
2952
2953     // right now we know this function exists and is callable..
2954     PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
2955
2956     // if it fails, print the error but otherwise go on
2957     if (PyErr_Occurred())
2958     {
2959         PyErr_Print();
2960         PyErr_Clear();
2961     }
2962
2963     if (py_return.IsAllocated() && PythonInteger::Check(py_return.get()))
2964     {
2965         PythonInteger int_value(PyRefType::Borrowed, py_return.get());
2966         result = int_value.GetInteger();
2967     }
2968
2969     return result;
2970 }
2971
2972 bool
2973 ScriptInterpreterPython::GetLongHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
2974                                                       std::string& dest)
2975 {
2976     bool got_string = false;
2977     dest.clear();
2978
2979     Locker py_lock (this,
2980                     Locker::AcquireLock | Locker::NoSTDIN,
2981                     Locker::FreeLock);
2982
2983     static char callee_name[] = "get_long_help";
2984
2985     if (!cmd_obj_sp)
2986         return false;
2987
2988     PythonObject implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
2989
2990     if (!implementor.IsAllocated())
2991         return false;
2992
2993     PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
2994
2995     if (PyErr_Occurred())
2996         PyErr_Clear();
2997
2998     if (!pmeth.IsAllocated())
2999         return false;
3000
3001     if (PyCallable_Check(pmeth.get()) == 0)
3002     {
3003         if (PyErr_Occurred())
3004             PyErr_Clear();
3005
3006         return false;
3007     }
3008
3009     if (PyErr_Occurred())
3010         PyErr_Clear();
3011
3012     // right now we know this function exists and is callable..
3013     PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
3014
3015     // if it fails, print the error but otherwise go on
3016     if (PyErr_Occurred())
3017     {
3018         PyErr_Print();
3019         PyErr_Clear();
3020     }
3021
3022     if (py_return.IsAllocated() && PythonString::Check(py_return.get()))
3023     {
3024         PythonString str(PyRefType::Borrowed, py_return.get());
3025         llvm::StringRef str_data(str.GetString());
3026         dest.assign(str_data.data(), str_data.size());
3027         got_string = true;
3028     }
3029
3030     return got_string;
3031 }
3032
3033 std::unique_ptr<ScriptInterpreterLocker>
3034 ScriptInterpreterPython::AcquireInterpreterLock ()
3035 {
3036     std::unique_ptr<ScriptInterpreterLocker> py_lock(new Locker(this,
3037                                                                 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN,
3038                                                                 Locker::FreeLock | Locker::TearDownSession));
3039     return py_lock;
3040 }
3041
3042 void
3043 ScriptInterpreterPython::InitializeInterpreter (SWIGInitCallback swig_init_callback,
3044                                                 SWIGBreakpointCallbackFunction swig_breakpoint_callback,
3045                                                 SWIGWatchpointCallbackFunction swig_watchpoint_callback,
3046                                                 SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
3047                                                 SWIGPythonCreateSyntheticProvider swig_synthetic_script,
3048                                                 SWIGPythonCreateCommandObject swig_create_cmd,
3049                                                 SWIGPythonCalculateNumChildren swig_calc_children,
3050                                                 SWIGPythonGetChildAtIndex swig_get_child_index,
3051                                                 SWIGPythonGetIndexOfChildWithName swig_get_index_child,
3052                                                 SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue ,
3053                                                 SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
3054                                                 SWIGPythonUpdateSynthProviderInstance swig_update_provider,
3055                                                 SWIGPythonMightHaveChildrenSynthProviderInstance swig_mighthavechildren_provider,
3056                                                 SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
3057                                                 SWIGPythonCallCommand swig_call_command,
3058                                                 SWIGPythonCallCommandObject swig_call_command_object,
3059                                                 SWIGPythonCallModuleInit swig_call_module_init,
3060                                                 SWIGPythonCreateOSPlugin swig_create_os_plugin,
3061                                                 SWIGPythonScriptKeyword_Process swig_run_script_keyword_process,
3062                                                 SWIGPythonScriptKeyword_Thread swig_run_script_keyword_thread,
3063                                                 SWIGPythonScriptKeyword_Target swig_run_script_keyword_target,
3064                                                 SWIGPythonScriptKeyword_Frame swig_run_script_keyword_frame,
3065                                                 SWIGPythonScriptKeyword_Value swig_run_script_keyword_value,
3066                                                 SWIGPython_GetDynamicSetting swig_plugin_get,
3067                                                 SWIGPythonCreateScriptedThreadPlan swig_thread_plan_script,
3068                                                 SWIGPythonCallThreadPlan swig_call_thread_plan)
3069 {
3070     g_swig_init_callback = swig_init_callback;
3071     g_swig_breakpoint_callback = swig_breakpoint_callback;
3072     g_swig_watchpoint_callback = swig_watchpoint_callback;
3073     g_swig_typescript_callback = swig_typescript_callback;
3074     g_swig_synthetic_script = swig_synthetic_script;
3075     g_swig_create_cmd = swig_create_cmd;
3076     g_swig_calc_children = swig_calc_children;
3077     g_swig_get_child_index = swig_get_child_index;
3078     g_swig_get_index_child = swig_get_index_child;
3079     g_swig_cast_to_sbvalue = swig_cast_to_sbvalue;
3080     g_swig_get_valobj_sp_from_sbvalue = swig_get_valobj_sp_from_sbvalue;
3081     g_swig_update_provider = swig_update_provider;
3082     g_swig_mighthavechildren_provider = swig_mighthavechildren_provider;
3083     g_swig_getvalue_provider = swig_getvalue_provider;
3084     g_swig_call_command = swig_call_command;
3085     g_swig_call_command_object = swig_call_command_object;
3086     g_swig_call_module_init = swig_call_module_init;
3087     g_swig_create_os_plugin = swig_create_os_plugin;
3088     g_swig_run_script_keyword_process = swig_run_script_keyword_process;
3089     g_swig_run_script_keyword_thread = swig_run_script_keyword_thread;
3090     g_swig_run_script_keyword_target = swig_run_script_keyword_target;
3091     g_swig_run_script_keyword_frame = swig_run_script_keyword_frame;
3092     g_swig_run_script_keyword_value = swig_run_script_keyword_value;
3093     g_swig_plugin_get = swig_plugin_get;
3094     g_swig_thread_plan_script = swig_thread_plan_script;
3095     g_swig_call_thread_plan = swig_call_thread_plan;
3096 }
3097
3098 void
3099 ScriptInterpreterPython::InitializePrivate ()
3100 {
3101     assert(!g_initialized && "ScriptInterpreterPython::InitializePrivate() called more than once!");
3102     g_initialized = true;
3103
3104     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
3105
3106     // RAII-based initialization which correctly handles multiple-initialization, version-
3107     // specific differences among Python 2 and Python 3, and saving and restoring various
3108     // other pieces of state that can get mucked with during initialization.
3109     InitializePythonRAII initialize_guard;
3110
3111     if (g_swig_init_callback)
3112         g_swig_init_callback ();
3113
3114     // Update the path python uses to search for modules to include the current directory.
3115
3116     PyRun_SimpleString ("import sys");
3117     AddToSysPath(AddLocation::End, ".");
3118
3119     FileSpec file_spec;
3120     // Don't denormalize paths when calling file_spec.GetPath().  On platforms that use
3121     // a backslash as the path separator, this will result in executing python code containing
3122     // paths with unescaped backslashes.  But Python also accepts forward slashes, so to make
3123     // life easier we just use that.
3124     if (HostInfo::GetLLDBPath(ePathTypePythonDir, file_spec))
3125         AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
3126     if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, file_spec))
3127         AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
3128
3129     PyRun_SimpleString ("sys.dont_write_bytecode = 1; import lldb.embedded_interpreter; from lldb.embedded_interpreter import run_python_interpreter; from lldb.embedded_interpreter import run_one_line");
3130 }
3131
3132 void
3133 ScriptInterpreterPython::AddToSysPath(AddLocation location, std::string path)
3134 {
3135     std::string path_copy;
3136
3137     std::string statement;
3138     if (location == AddLocation::Beginning)
3139     {
3140         statement.assign("sys.path.insert(0,\"");
3141         statement.append (path);
3142         statement.append ("\")");
3143     }
3144     else
3145     {
3146         statement.assign("sys.path.append(\"");
3147         statement.append(path);
3148         statement.append("\")");
3149     }
3150     PyRun_SimpleString (statement.c_str());
3151 }
3152
3153
3154 //void
3155 //ScriptInterpreterPython::Terminate ()
3156 //{
3157 //    // We are intentionally NOT calling Py_Finalize here (this would be the logical place to call it).  Calling
3158 //    // Py_Finalize here causes test suite runs to seg fault:  The test suite runs in Python.  It registers
3159 //    // SBDebugger::Terminate to be called 'at_exit'.  When the test suite Python harness finishes up, it calls
3160 //    // Py_Finalize, which calls all the 'at_exit' registered functions.  SBDebugger::Terminate calls Debugger::Terminate,
3161 //    // which calls lldb::Terminate, which calls ScriptInterpreter::Terminate, which calls
3162 //    // ScriptInterpreterPython::Terminate.  So if we call Py_Finalize here, we end up with Py_Finalize being called from
3163 //    // within Py_Finalize, which results in a seg fault.
3164 //    //
3165 //    // Since this function only gets called when lldb is shutting down and going away anyway, the fact that we don't
3166 //    // actually call Py_Finalize should not cause any problems (everything should shut down/go away anyway when the
3167 //    // process exits).
3168 //    //
3169 ////    Py_Finalize ();
3170 //}
3171
3172 #endif // #ifdef LLDB_DISABLE_PYTHON