[Python] Remove Python include from ScriptInterpreterPython.h

[JDevlieghere]

Summary

This patch limits the scope of the python header to the python script interpreter plugin by removing the include from ScriptInterpreterPython.h. To make that possible I had to forward declare the PythonDataObjects and move the PythonScriptInterpreterLocker into ScriptInterpreterPython.cpp.

[labath]

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

327 ↗

(On Diff #192763)

You could still keep this class inside ScriptInterpreterPython, and just forward-declare it in the header.
The cpp file can define it as class ScriptInterpreterPython::Locker.

394–410 ↗

(On Diff #192763)

Instead of pimpl-ing each individual field, what if we just have one struct which contains all of these fields, and pimpl that?

This should make things more efficient (less heap traffic), and allow you to cut down on the number of forward declarations (particularly the ones from python headers worry me).

lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h

35 ↗

(On Diff #192763)

Python headers are fun. :)

[labath]

Btw, I really like this cleanup.

[labath]

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

394–410 ↗

(On Diff #192763)

In fact, since ScriptInterpreterPython is already polymorphic, we might not need to pimpl anything at all. Since the only place where we create an instance if this class is the static Create function, we could just have that function create a subclass of ScriptInterpreterPython (and make ScriptInterpreterPython by moving all non-interface stuff into the subclass). WDYT?

[JDevlieghere]

Make ScriptInterpreterPython abstract.

[labath]

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

1229–1230 ↗

(On Diff #192892)

The ScriptInterpreterPythonImpl qualification on the Locker class is probably overkill. (I know it was present before this patch, but it's overkill there too :P ).

[JDevlieghere]

Thanks for the review, Pavel!

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

1229–1230 ↗

(On Diff #192892)

Makes sense, I'll remove it before landing.

lldb/trunk/source/API/SBHostOS.cpp

 //===-- SBHostOS.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLDB_DISABLE_PYTHON
-#include "Plugins/ScriptInterpreter/Python/lldb-python.h"
-#endif
-
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"

lldb/trunk/source/API/SystemInitializerFull.cpp

 //===-- SystemInitializerFull.cpp -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#if !defined(LLDB_DISABLE_PYTHON)
-#include "Plugins/ScriptInterpreter/Python/lldb-python.h"
-#endif
-
 #include "SystemInitializerFull.h"
 
 #include "lldb/API/SBCommandInterpreter.h"
 
 #if !defined(LLDB_DISABLE_PYTHON)
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

 #define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H
 
 #ifdef LLDB_DISABLE_PYTHON
 
 // Python is disabled in this build
 
 #else
 
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "PythonDataObjects.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/IOHandler.h"
-#include "lldb/Host/Terminal.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/lldb-private.h"
 
-class IOHandlerPythonInterpreter;
+#include <memory>
+#include <string>
+#include <vector>
 
 namespace lldb_private {
-
+/// Abstract interface for the Python script interpreter.
 class ScriptInterpreterPython : public ScriptInterpreter,
                                 public IOHandlerDelegateMultiline {
 public:
   class CommandDataPython : public BreakpointOptions::CommandData {
   public:
     CommandDataPython() : BreakpointOptions::CommandData() {
       interpreter = lldb::eScriptLanguagePython;
     }
   };
 
-  friend class ::IOHandlerPythonInterpreter;
-
-  ScriptInterpreterPython(CommandInterpreter &interpreter);
-
-  ~ScriptInterpreterPython() override;
-
-  bool Interrupt() override;
-
-  bool ExecuteOneLine(
-      llvm::StringRef command, CommandReturnObject *result,
-      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
-
-  void ExecuteInterpreterLoop() override;
-
-  bool ExecuteOneLineWithReturn(
-      llvm::StringRef in_string,
-      ScriptInterpreter::ScriptReturnType return_type, void *ret_value,
-      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
-
-  lldb_private::Status ExecuteMultipleLines(
-      const char *in_string,
-      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
-
-  Status
-  ExportFunctionDefinitionToInterpreter(StringList &function_def) override;
-
-  bool GenerateTypeScriptFunction(StringList &input, std::string &output,
-                                  const void *name_token = nullptr) override;
-
-  bool GenerateTypeSynthClass(StringList &input, std::string &output,
-                              const void *name_token = nullptr) override;
-
-  bool GenerateTypeSynthClass(const char *oneliner, std::string &output,
-                              const void *name_token = nullptr) override;
-
-  // use this if the function code is just a one-liner script
-  bool GenerateTypeScriptFunction(const char *oneliner, std::string &output,
-                                  const void *name_token = nullptr) override;
-
-  bool GenerateScriptAliasFunction(StringList &input,
-                                   std::string &output) override;
-
-  StructuredData::ObjectSP
-  CreateSyntheticScriptedProvider(const char *class_name,
-                                  lldb::ValueObjectSP valobj) override;
-
-  StructuredData::GenericSP
-  CreateScriptCommandObject(const char *class_name) override;
-
-  StructuredData::ObjectSP
-  CreateScriptedThreadPlan(const char *class_name,
-                           lldb::ThreadPlanSP thread_plan) override;
-
-  bool ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp,
-                                      Event *event,
-                                      bool &script_error) override;
-
-  bool ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp,
-                                    Event *event, bool &script_error) override;
-
-  bool ScriptedThreadPlanIsStale(StructuredData::ObjectSP implementor_sp,
-                                 bool &script_error) override;
-
-  lldb::StateType
-  ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp,
-                                bool &script_error) override;
-
-  StructuredData::GenericSP
-  CreateScriptedBreakpointResolver(const char *class_name,
-                                   StructuredDataImpl *args_data,
-                                   lldb::BreakpointSP &bkpt_sp) override;
-  bool
-  ScriptedBreakpointResolverSearchCallback(StructuredData::GenericSP
-                                               implementor_sp,
-                                           SymbolContext *sym_ctx) override;
-
-  lldb::SearchDepth
-  ScriptedBreakpointResolverSearchDepth(StructuredData::GenericSP
-                                            implementor_sp) override;
-
-  StructuredData::GenericSP
-  CreateFrameRecognizer(const char *class_name) override;
-
-  lldb::ValueObjectListSP
-  GetRecognizedArguments(const StructuredData::ObjectSP &implementor,
-                         lldb::StackFrameSP frame_sp) override;
-
-  StructuredData::GenericSP
-  OSPlugin_CreatePluginObject(const char *class_name,
-                              lldb::ProcessSP process_sp) override;
-
-  StructuredData::DictionarySP
-  OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp) override;
-
-  StructuredData::ArraySP
-  OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp) override;
-
-  StructuredData::StringSP
-  OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp,
-                               lldb::tid_t thread_id) override;
-
-  StructuredData::DictionarySP
-  OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp,
-                        lldb::tid_t tid, lldb::addr_t context) override;
-
-  StructuredData::ObjectSP
-  LoadPluginModule(const FileSpec &file_spec,
-                   lldb_private::Status &error) override;
-
-  StructuredData::DictionarySP
-  GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target,
-                     const char *setting_name,
-                     lldb_private::Status &error) override;
-
-  size_t CalculateNumChildren(const StructuredData::ObjectSP &implementor,
-                              uint32_t max) override;
-
-  lldb::ValueObjectSP
-  GetChildAtIndex(const StructuredData::ObjectSP &implementor,
-                  uint32_t idx) override;
-
-  int GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor,
-                              const char *child_name) override;
-
-  bool UpdateSynthProviderInstance(
-      const StructuredData::ObjectSP &implementor) override;
-
-  bool MightHaveChildrenSynthProviderInstance(
-      const StructuredData::ObjectSP &implementor) override;
-
-  lldb::ValueObjectSP
-  GetSyntheticValue(const StructuredData::ObjectSP &implementor) override;
-
-  ConstString
-  GetSyntheticTypeName(const StructuredData::ObjectSP &implementor) override;
-
-  bool
-  RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
-                        ScriptedCommandSynchronicity synchronicity,
-                        lldb_private::CommandReturnObject &cmd_retobj,
-                        Status &error,
-                        const lldb_private::ExecutionContext &exe_ctx) override;
-
-  bool RunScriptBasedCommand(
-      StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
-      ScriptedCommandSynchronicity synchronicity,
-      lldb_private::CommandReturnObject &cmd_retobj, Status &error,
-      const lldb_private::ExecutionContext &exe_ctx) override;
-
-  Status GenerateFunction(const char *signature,
-                          const StringList &input) override;
-
-  Status GenerateBreakpointCommandCallbackData(StringList &input,
-                                               std::string &output) override;
-
-  bool GenerateWatchpointCommandCallbackData(StringList &input,
-                                             std::string &output) override;
-
-  static bool BreakpointCallbackFunction(void *baton,
-                                         StoppointCallbackContext *context,
-                                         lldb::user_id_t break_id,
-                                         lldb::user_id_t break_loc_id);
-
-  static bool WatchpointCallbackFunction(void *baton,
-                                         StoppointCallbackContext *context,
-                                         lldb::user_id_t watch_id);
-
-  bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj,
-                          StructuredData::ObjectSP &callee_wrapper_sp,
-                          const TypeSummaryOptions &options,
-                          std::string &retval) override;
-
-  void Clear() override;
-
-  bool GetDocumentationForItem(const char *item, std::string &dest) override;
-
-  bool GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp,
-                                    std::string &dest) override;
-
-  uint32_t
-  GetFlagsForCommandObject(StructuredData::GenericSP cmd_obj_sp) override;
-
-  bool GetLongHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp,
-                                   std::string &dest) override;
-
-  bool CheckObjectExists(const char *name) override {
-    if (!name || !name[0])
-      return false;
-    std::string temp;
-    return GetDocumentationForItem(name, temp);
-  }
-
-  bool RunScriptFormatKeyword(const char *impl_function, Process *process,
-                              std::string &output, Status &error) override;
-
-  bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
-                              std::string &output, Status &error) override;
-
-  bool RunScriptFormatKeyword(const char *impl_function, Target *target,
-                              std::string &output, Status &error) override;
+  ScriptInterpreterPython(CommandInterpreter &interpreter)
+      : ScriptInterpreter(interpreter, lldb::eScriptLanguagePython),
+        IOHandlerDelegateMultiline("DONE") {}
 
-  bool RunScriptFormatKeyword(const char *impl_function, StackFrame *frame,
-                              std::string &output, Status &error) override;
-
-  bool RunScriptFormatKeyword(const char *impl_function, ValueObject *value,
-                              std::string &output, Status &error) override;
-
-  bool
-  LoadScriptingModule(const char *filename, bool can_reload, bool init_session,
-                      lldb_private::Status &error,
-                      StructuredData::ObjectSP *module_sp = nullptr) override;
-
-  bool IsReservedWord(const char *word) override;
-
-  std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock() override;
-
-  void CollectDataForBreakpointCommandCallback(
-      std::vector<BreakpointOptions *> &bp_options_vec,
-      CommandReturnObject &result) override;
-
-  void
-  CollectDataForWatchpointCommandCallback(WatchpointOptions *wp_options,
-                                          CommandReturnObject &result) override;
-
-  /// Set the callback body text into the callback for the breakpoint.
-  Status SetBreakpointCommandCallback(BreakpointOptions *bp_options,
-                                      const char *callback_body) override;
-
-  void SetBreakpointCommandCallbackFunction(BreakpointOptions *bp_options,
-                                            const char *function_name) override;
-
-  /// This one is for deserialization:
-  Status SetBreakpointCommandCallback(
-      BreakpointOptions *bp_options,
-      std::unique_ptr<BreakpointOptions::CommandData> &data_up) override;
-
-  /// Set a one-liner as the callback for the watchpoint.
-  void SetWatchpointCommandCallback(WatchpointOptions *wp_options,
-                                    const char *oneliner) override;
-
-  StringList ReadCommandInputFromUser(FILE *in_file);
-
-  void ResetOutputFileHandle(FILE *new_fh) override;
-
-  const char *GetDictionaryName() { return m_dictionary_name.c_str(); }
-
-  PyThreadState *GetThreadState() { return m_command_thread_state; }
-
-  void SetThreadState(PyThreadState *s) {
-    if (s)
-      m_command_thread_state = s;
-  }
-
-  //----------------------------------------------------------------------
-  // IOHandlerDelegate
-  //----------------------------------------------------------------------
-  void IOHandlerActivated(IOHandler &io_handler, bool interactive) override;
-
-  void IOHandlerInputComplete(IOHandler &io_handler,
-                              std::string &data) override;
-
-  //------------------------------------------------------------------
-  // Static Functions
-  //------------------------------------------------------------------
   static void Initialize();
-
   static void Terminate();
-
-  static lldb::ScriptInterpreterSP
-  CreateInstance(CommandInterpreter &interpreter);
-
   static lldb_private::ConstString GetPluginNameStatic();
-
   static const char *GetPluginDescriptionStatic();
-
   static FileSpec GetPythonDir();
 
-  //------------------------------------------------------------------
-  // PluginInterface protocol
-  //------------------------------------------------------------------
-  lldb_private::ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
-
-  class Locker : public ScriptInterpreterLocker {
-  public:
-    enum OnEntry {
-      AcquireLock = 0x0001,
-      InitSession = 0x0002,
-      InitGlobals = 0x0004,
-      NoSTDIN = 0x0008
-    };
-
-    enum OnLeave {
-      FreeLock = 0x0001,
-      FreeAcquiredLock = 0x0002, // do not free the lock if we already held it
-                                 // when calling constructor
-      TearDownSession = 0x0004
-    };
-
-    Locker(ScriptInterpreterPython *py_interpreter = nullptr,
-           uint16_t on_entry = AcquireLock | InitSession,
-           uint16_t on_leave = FreeLock | TearDownSession, FILE *in = nullptr,
-           FILE *out = nullptr, FILE *err = nullptr);
-
-    ~Locker() override;
-
-  private:
-    bool DoAcquireLock();
-
-    bool DoInitSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
-
-    bool DoFreeLock();
-
-    bool DoTearDownSession();
-
-    static void ReleasePythonLock();
-
-    bool m_teardown_session;
-    ScriptInterpreterPython *m_python_interpreter;
-    //      FILE*                    m_tmp_fh;
-    PyGILState_STATE m_GILState;
-  };
-
 protected:
-  static void InitializePrivate();
-
-  class SynchronicityHandler {
-  private:
-    lldb::DebuggerSP m_debugger_sp;
-    ScriptedCommandSynchronicity m_synch_wanted;
-    bool m_old_asynch;
-
-  public:
-    SynchronicityHandler(lldb::DebuggerSP, ScriptedCommandSynchronicity);
-
-    ~SynchronicityHandler();
-  };
-
-  enum class AddLocation { Beginning, End };
-
-  static void AddToSysPath(AddLocation location, std::string path);
-
   static void ComputePythonDirForApple(llvm::SmallVectorImpl<char> &path);
   static void ComputePythonDirForPosix(llvm::SmallVectorImpl<char> &path);
   static void ComputePythonDirForWindows(llvm::SmallVectorImpl<char> &path);
-
-  bool EnterSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
-
-  void LeaveSession();
-
-  void SaveTerminalState(int fd);
-
-  void RestoreTerminalState();
-
-  uint32_t IsExecutingPython() const { return m_lock_count > 0; }
-
-  uint32_t IncrementLockCount() { return ++m_lock_count; }
-
-  uint32_t DecrementLockCount() {
-    if (m_lock_count > 0)
-      --m_lock_count;
-    return m_lock_count;
-  }
-
-  enum ActiveIOHandler {
-    eIOHandlerNone,
-    eIOHandlerBreakpoint,
-    eIOHandlerWatchpoint
-  };
-
-  PythonObject &GetMainModule();
-
-  PythonDictionary &GetSessionDictionary();
-
-  PythonDictionary &GetSysModuleDictionary();
-
-  bool GetEmbeddedInterpreterModuleObjects();
-
-  bool SetStdHandle(File &file, const char *py_name, PythonFile &save_file,
-                    const char *mode);
-
-  PythonFile m_saved_stdin;
-  PythonFile m_saved_stdout;
-  PythonFile m_saved_stderr;
-  PythonObject m_main_module;
-  PythonDictionary m_session_dict;
-  PythonDictionary m_sys_module_dict;
-  PythonObject m_run_one_line_function;
-  PythonObject m_run_one_line_str_global;
-  std::string m_dictionary_name;
-  TerminalState m_terminal_state;
-  ActiveIOHandler m_active_io_handler;
-  bool m_session_is_active;
-  bool m_pty_slave_is_open;
-  bool m_valid_session;
-  uint32_t m_lock_count;
-  PyThreadState *m_command_thread_state;
-};
-
 } // namespace lldb_private
 
 #endif // LLDB_DISABLE_PYTHON
-
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 
 #else
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "PythonExceptionState.h"
-#include "ScriptInterpreterPython.h"
+#include "ScriptInterpreterPythonImpl.h"
 
-#include "lldb/API/SBValue.h"
 #include "lldb/API/SBFrame.h"
+#include "lldb/API/SBValue.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/WatchpointOptions.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"

 #include <mutex>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 
-#ifndef LLDB_DISABLE_PYTHON
-
 // Defined in the SWIG source file
 #if PY_MAJOR_VERSION >= 3
 extern "C" PyObject *PyInit__lldb(void);
 
 #define LLDBSwigPyInit PyInit__lldb
 
 #else
 extern "C" void init_lldb(void);

 extern "C" bool LLDBSWIGPythonRunScriptKeywordValue(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::ValueObjectSP &value, std::string &output);
 
 extern "C" void *
 LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
                                  const lldb::TargetSP &target_sp);
 
-#endif
-
 static bool g_initialized = false;
 
 namespace {
 
 // Initializing Python is not a straightforward process.  We cannot control
 // what external code may have done before getting to this point in LLDB,
 // including potentially having already initialized Python, so we need to do a
 // lot of work to ensure that the existing state of the system is maintained
#if PY_MAJOR_VERSION >= 3
     size_t size = 0;
     static wchar_t *g_python_home = Py_DecodeLocale(LLDB_PYTHON_HOME, &size);
 #else
     static char g_python_home[] = LLDB_PYTHON_HOME;
 #endif
     Py_SetPythonHome(g_python_home);
 #else
 #if defined(__APPLE__) && PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION == 7
-    // For Darwin, the only Python version supported is the one shipped in the OS
-    // OS and linked with lldb. Other installation of Python may have higher
+    // For Darwin, the only Python version supported is the one shipped in the
+    // OS OS and linked with lldb. Other installation of Python may have higher
     // priorities in the path, overriding PYTHONHOME and causing
     // problems/incompatibilities. In order to avoid confusion, always hardcode
     // the PythonHome to be right, as it's not going to change.
-    static char path[] = "/System/Library/Frameworks/Python.framework/Versions/2.7";
+    static char path[] =
+        "/System/Library/Frameworks/Python.framework/Versions/2.7";
     Py_SetPythonHome(path);
 #endif
 #endif
   }
 
   void InitializeThreadsPrivate() {
 // Since Python 3.7 `Py_Initialize` calls `PyEval_InitThreads` inside itself,
 // so there is no way to determine whether the embedded interpreter
 // was already initialized by some external code. `PyEval_ThreadsInitialized`
 // would always return `true` and `PyGILState_Ensure/Release` flow would be
 // executed instead of unlocking GIL with `PyEval_SaveThread`. When
 // an another thread calls `PyGILState_Ensure` it would get stuck in deadlock.
 #if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 7) || (PY_MAJOR_VERSION > 3)
     // The only case we should go further and acquire the GIL: it is unlocked.
     if (PyGILState_Check())
       return;
 #endif
 
     if (PyEval_ThreadsInitialized()) {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
 
       m_was_already_initialized = true;
       m_gil_state = PyGILState_Ensure();
       LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked\n",
                 m_gil_state == PyGILState_UNLOCKED ? "un" : "");
       return;
     }
 
     // InitThreads acquires the GIL if it hasn't been called before.
     PyEval_InitThreads();
   }
 
   TerminalState m_stdin_tty_state;
   PyGILState_STATE m_gil_state;
   bool m_was_already_initialized;
 };
+} // namespace
+
+void ScriptInterpreterPython::ComputePythonDirForApple(
+    llvm::SmallVectorImpl<char> &path) {
+  auto style = llvm::sys::path::Style::posix;
+
+  llvm::StringRef path_ref(path.begin(), path.size());
+  auto rbegin = llvm::sys::path::rbegin(path_ref, style);
+  auto rend = llvm::sys::path::rend(path_ref);
+  auto framework = std::find(rbegin, rend, "LLDB.framework");
+  if (framework == rend) {
+    ComputePythonDirForPosix(path);
+    return;
+  }
+  path.resize(framework - rend);
+  llvm::sys::path::append(path, style, "LLDB.framework", "Resources", "Python");
+}
+
+void ScriptInterpreterPython::ComputePythonDirForPosix(
+    llvm::SmallVectorImpl<char> &path) {
+  auto style = llvm::sys::path::Style::posix;
+#if defined(LLDB_PYTHON_RELATIVE_LIBDIR)
+  // Build the path by backing out of the lib dir, then building with whatever
+  // the real python interpreter uses.  (e.g. lib for most, lib64 on RHEL
+  // x86_64).
+  llvm::sys::path::remove_filename(path, style);
+  llvm::sys::path::append(path, style, LLDB_PYTHON_RELATIVE_LIBDIR);
+#else
+  llvm::sys::path::append(path, style,
+                          "python" + llvm::Twine(PY_MAJOR_VERSION) + "." +
+                              llvm::Twine(PY_MINOR_VERSION),
+                          "site-packages");
+#endif
 }
 
-ScriptInterpreterPython::Locker::Locker(ScriptInterpreterPython *py_interpreter,
-                                        uint16_t on_entry, uint16_t on_leave,
-                                        FILE *in, FILE *out, FILE *err)
+void ScriptInterpreterPython::ComputePythonDirForWindows(
+    llvm::SmallVectorImpl<char> &path) {
+  auto style = llvm::sys::path::Style::windows;
+  llvm::sys::path::remove_filename(path, style);
+  llvm::sys::path::append(path, style, "lib", "site-packages");
+
+  // This will be injected directly through FileSpec.GetDirectory().SetString(),
+  // so we need to normalize manually.
+  std::replace(path.begin(), path.end(), '\\', '/');
+}
+
+FileSpec ScriptInterpreterPython::GetPythonDir() {
+  static FileSpec g_spec = []() {
+    FileSpec spec = HostInfo::GetShlibDir();
+    if (!spec)
+      return FileSpec();
+    llvm::SmallString<64> path;
+    spec.GetPath(path);
+
+#if defined(__APPLE__)
+    ComputePythonDirForApple(path);
+#elif defined(_WIN32)
+    ComputePythonDirForWindows(path);
+#else
+    ComputePythonDirForPosix(path);
+#endif
+    spec.GetDirectory().SetString(path);
+    return spec;
+  }();
+  return g_spec;
+}
+
+lldb_private::ConstString ScriptInterpreterPython::GetPluginNameStatic() {
+  static ConstString g_name("script-python");
+  return g_name;
+}
+
+const char *ScriptInterpreterPython::GetPluginDescriptionStatic() {
+  return "Embedded Python interpreter";
+}
+
+void ScriptInterpreterPython::Initialize() {
+  static llvm::once_flag g_once_flag;
+
+  llvm::call_once(g_once_flag, []() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(),
+                                  lldb::eScriptLanguagePython,
+                                  ScriptInterpreterPythonImpl::CreateInstance);
+  });
+}
+
+void ScriptInterpreterPython::Terminate() {}
+
+ScriptInterpreterPythonImpl::Locker::Locker(
+    ScriptInterpreterPythonImpl *py_interpreter, uint16_t on_entry,
+    uint16_t on_leave, FILE *in, FILE *out, FILE *err)
     : ScriptInterpreterLocker(),
       m_teardown_session((on_leave & TearDownSession) == TearDownSession),
       m_python_interpreter(py_interpreter) {
   DoAcquireLock();
   if ((on_entry & InitSession) == InitSession) {
     if (!DoInitSession(on_entry, in, out, err)) {
       // Don't teardown the session if we didn't init it.
       m_teardown_session = false;
     }
   }
 }
 
-bool ScriptInterpreterPython::Locker::DoAcquireLock() {
+bool ScriptInterpreterPythonImpl::Locker::DoAcquireLock() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
   m_GILState = PyGILState_Ensure();
   LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked",
             m_GILState == PyGILState_UNLOCKED ? "un" : "");
 
   // we need to save the thread state when we first start the command because
   // we might decide to interrupt it while some action is taking place outside
   // of Python (e.g. printing to screen, waiting for the network, ...) in that
   // case, _PyThreadState_Current will be NULL - and we would be unable to set
   // the asynchronous exception - not a desirable situation
   m_python_interpreter->SetThreadState(PyThreadState_Get());
   m_python_interpreter->IncrementLockCount();
   return true;
 }
 
-bool ScriptInterpreterPython::Locker::DoInitSession(uint16_t on_entry_flags,
+bool ScriptInterpreterPythonImpl::Locker::DoInitSession(uint16_t on_entry_flags,
                                                         FILE *in, FILE *out,
                                                         FILE *err) {
   if (!m_python_interpreter)
     return false;
   return m_python_interpreter->EnterSession(on_entry_flags, in, out, err);
 }
 
-bool ScriptInterpreterPython::Locker::DoFreeLock() {
+bool ScriptInterpreterPythonImpl::Locker::DoFreeLock() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
   LLDB_LOGV(log, "Releasing PyGILState. Returning to state = {0}locked",
             m_GILState == PyGILState_UNLOCKED ? "un" : "");
   PyGILState_Release(m_GILState);
   m_python_interpreter->DecrementLockCount();
   return true;
 }
 
-bool ScriptInterpreterPython::Locker::DoTearDownSession() {
+bool ScriptInterpreterPythonImpl::Locker::DoTearDownSession() {
   if (!m_python_interpreter)
     return false;
   m_python_interpreter->LeaveSession();
   return true;
 }
 
-ScriptInterpreterPython::Locker::~Locker() {
+ScriptInterpreterPythonImpl::Locker::~Locker() {
   if (m_teardown_session)
     DoTearDownSession();
   DoFreeLock();
 }
 
-ScriptInterpreterPython::ScriptInterpreterPython(
+ScriptInterpreterPythonImpl::ScriptInterpreterPythonImpl(
     CommandInterpreter &interpreter)
-    : ScriptInterpreter(interpreter, eScriptLanguagePython),
-      IOHandlerDelegateMultiline("DONE"), m_saved_stdin(), m_saved_stdout(),
+    : ScriptInterpreterPython(interpreter), m_saved_stdin(), m_saved_stdout(),
       m_saved_stderr(), m_main_module(),
       m_session_dict(PyInitialValue::Invalid),
       m_sys_module_dict(PyInitialValue::Invalid), m_run_one_line_function(),
       m_run_one_line_str_global(),
       m_dictionary_name(
           interpreter.GetDebugger().GetInstanceName().AsCString()),
       m_terminal_state(), m_active_io_handler(eIOHandlerNone),
       m_session_is_active(false), m_pty_slave_is_open(false),
       m_valid_session(true), m_lock_count(0), m_command_thread_state(nullptr) {
   InitializePrivate();
 
   m_dictionary_name.append("_dict");
   StreamString run_string;
   run_string.Printf("%s = dict()", m_dictionary_name.c_str());
 
-  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
-                ScriptInterpreterPython::Locker::FreeAcquiredLock);
+  Locker locker(this, Locker::AcquireLock, Locker::FreeAcquiredLock);
   PyRun_SimpleString(run_string.GetData());
 
   run_string.Clear();
   run_string.Printf(
       "run_one_line (%s, 'import copy, keyword, os, re, sys, uuid, lldb')",
       m_dictionary_name.c_str());
   PyRun_SimpleString(run_string.GetData());
 
ScriptInterpreterPythonImpl::ScriptInterpreterPythonImpl(
 
   run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64
                     "; pydoc.pager = pydoc.plainpager')",
                     m_dictionary_name.c_str(),
                     interpreter.GetDebugger().GetID());
   PyRun_SimpleString(run_string.GetData());
 }
 
-ScriptInterpreterPython::~ScriptInterpreterPython() {
+ScriptInterpreterPythonImpl::~ScriptInterpreterPythonImpl() {
   // the session dictionary may hold objects with complex state which means
   // that they may need to be torn down with some level of smarts and that, in
   // turn, requires a valid thread state force Python to procure itself such a
   // thread state, nuke the session dictionary and then release it for others
   // to use and proceed with the rest of the shutdown
   auto gil_state = PyGILState_Ensure();
   m_session_dict.Reset();
   PyGILState_Release(gil_state);
 }
 
-void ScriptInterpreterPython::Initialize() {
-  static llvm::once_flag g_once_flag;
-
-  llvm::call_once(g_once_flag, []() {
-    PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                  GetPluginDescriptionStatic(),
-                                  lldb::eScriptLanguagePython, CreateInstance);
-  });
-}
-
-void ScriptInterpreterPython::Terminate() {}
-
-lldb::ScriptInterpreterSP
-ScriptInterpreterPython::CreateInstance(CommandInterpreter &interpreter) {
-  return std::make_shared<ScriptInterpreterPython>(interpreter);
-}
-
-lldb_private::ConstString ScriptInterpreterPython::GetPluginNameStatic() {
-  static ConstString g_name("script-python");
-  return g_name;
-}
-
-const char *ScriptInterpreterPython::GetPluginDescriptionStatic() {
-  return "Embedded Python interpreter";
-}
-
-void ScriptInterpreterPython::ComputePythonDirForApple(
-    llvm::SmallVectorImpl<char> &path) {
-  auto style = llvm::sys::path::Style::posix;
-
-  llvm::StringRef path_ref(path.begin(), path.size());
-  auto rbegin = llvm::sys::path::rbegin(path_ref, style);
-  auto rend = llvm::sys::path::rend(path_ref);
-  auto framework = std::find(rbegin, rend, "LLDB.framework");
-  if (framework == rend) {
-    ComputePythonDirForPosix(path);
-    return;
-  }
-  path.resize(framework - rend);
-  llvm::sys::path::append(path, style, "LLDB.framework", "Resources", "Python");
-}
-
-void ScriptInterpreterPython::ComputePythonDirForPosix(
-    llvm::SmallVectorImpl<char> &path) {
-  auto style = llvm::sys::path::Style::posix;
-#if defined(LLDB_PYTHON_RELATIVE_LIBDIR)
-  // Build the path by backing out of the lib dir, then building with whatever
-  // the real python interpreter uses.  (e.g. lib for most, lib64 on RHEL
-  // x86_64).
-  llvm::sys::path::remove_filename(path, style);
-  llvm::sys::path::append(path, style, LLDB_PYTHON_RELATIVE_LIBDIR);
-#else
-  llvm::sys::path::append(path, style,
-                          "python" + llvm::Twine(PY_MAJOR_VERSION) + "." +
-                              llvm::Twine(PY_MINOR_VERSION),
-                          "site-packages");
-#endif
-}
-
-void ScriptInterpreterPython::ComputePythonDirForWindows(
-    llvm::SmallVectorImpl<char> &path) {
-  auto style = llvm::sys::path::Style::windows;
-  llvm::sys::path::remove_filename(path, style);
-  llvm::sys::path::append(path, style, "lib", "site-packages");
-
-  // This will be injected directly through FileSpec.GetDirectory().SetString(),
-  // so we need to normalize manually.
-  std::replace(path.begin(), path.end(), '\\', '/');
-}
-
-FileSpec ScriptInterpreterPython::GetPythonDir() {
-  static FileSpec g_spec = []() {
-    FileSpec spec = HostInfo::GetShlibDir();
-    if (!spec)
-      return FileSpec();
-    llvm::SmallString<64> path;
-    spec.GetPath(path);
-
-#if defined(__APPLE__)
-    ComputePythonDirForApple(path);
-#elif defined(_WIN32)
-    ComputePythonDirForWindows(path);
-#else
-    ComputePythonDirForPosix(path);
-#endif
-    spec.GetDirectory().SetString(path);
-    return spec;
-  }();
-  return g_spec;
-}
-
-lldb_private::ConstString ScriptInterpreterPython::GetPluginName() {
+lldb_private::ConstString ScriptInterpreterPythonImpl::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ScriptInterpreterPython::GetPluginVersion() { return 1; }
+uint32_t ScriptInterpreterPythonImpl::GetPluginVersion() { return 1; }
 
-void ScriptInterpreterPython::IOHandlerActivated(IOHandler &io_handler, bool interactive) {
+void ScriptInterpreterPythonImpl::IOHandlerActivated(IOHandler &io_handler,
+                                                     bool interactive) {
   const char *instructions = nullptr;
 
   switch (m_active_io_handler) {
   case eIOHandlerNone:
     break;
   case eIOHandlerBreakpoint:
     instructions = R"(Enter your Python command(s). Type 'DONE' to end.
 def function (frame, bp_loc, internal_dict):
if (instructions) {
     StreamFileSP output_sp(io_handler.GetOutputStreamFile());
     if (output_sp && interactive) {
       output_sp->PutCString(instructions);
       output_sp->Flush();
     }
   }
 }
 
-void ScriptInterpreterPython::IOHandlerInputComplete(IOHandler &io_handler,
+void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
                                                          std::string &data) {
   io_handler.SetIsDone(true);
   bool batch_mode = m_interpreter.GetBatchCommandMode();
 
   switch (m_active_io_handler) {
   case eIOHandlerNone:
     break;
   case eIOHandlerBreakpoint: {
     std::vector<BreakpointOptions *> *bp_options_vec =
         (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
     for (auto bp_options : *bp_options_vec) {
       if (!bp_options)
         continue;
 
       auto data_up = llvm::make_unique<CommandDataPython>();
       if (!data_up)
         break;
       data_up->user_source.SplitIntoLines(data);
 
       if (GenerateBreakpointCommandCallbackData(data_up->user_source,
                                                 data_up->script_source)
               .Success()) {
         auto baton_sp = std::make_shared<BreakpointOptions::CommandBaton>(
             std::move(data_up));
         bp_options->SetCallback(
-            ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp);
+            ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
       } else if (!batch_mode) {
         StreamFileSP error_sp = io_handler.GetErrorStreamFile();
         if (error_sp) {
           error_sp->Printf("Warning: No command attached to breakpoint.\n");
           error_sp->Flush();
         }
       }
     }
     m_active_io_handler = eIOHandlerNone;
   } break;
   case eIOHandlerWatchpoint: {
     WatchpointOptions *wp_options =
         (WatchpointOptions *)io_handler.GetUserData();
     auto data_up = llvm::make_unique<WatchpointOptions::CommandData>();
     data_up->user_source.SplitIntoLines(data);
 
     if (GenerateWatchpointCommandCallbackData(data_up->user_source,
                                               data_up->script_source)) {
       auto baton_sp =
           std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
       wp_options->SetCallback(
-          ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp);
+          ScriptInterpreterPythonImpl::WatchpointCallbackFunction, baton_sp);
     } else if (!batch_mode) {
       StreamFileSP error_sp = io_handler.GetErrorStreamFile();
       if (error_sp) {
         error_sp->Printf("Warning: No command attached to breakpoint.\n");
         error_sp->Flush();
       }
     }
     m_active_io_handler = eIOHandlerNone;
   } break;
   }
 }
 
-void ScriptInterpreterPython::ResetOutputFileHandle(FILE *fh) {}
+lldb::ScriptInterpreterSP
+ScriptInterpreterPythonImpl::CreateInstance(CommandInterpreter &interpreter) {
+  return std::make_shared<ScriptInterpreterPythonImpl>(interpreter);
+}
 
-void ScriptInterpreterPython::SaveTerminalState(int fd) {
+void ScriptInterpreterPythonImpl::ResetOutputFileHandle(FILE *fh) {}
+
+void ScriptInterpreterPythonImpl::SaveTerminalState(int fd) {
   // Python mucks with the terminal state of STDIN. If we can possibly avoid
   // this by setting the file handles up correctly prior to entering the
   // interpreter we should. For now we save and restore the terminal state on
   // the input file handle.
   m_terminal_state.Save(fd, false);
 }
 
-void ScriptInterpreterPython::RestoreTerminalState() {
+void ScriptInterpreterPythonImpl::RestoreTerminalState() {
   // Python mucks with the terminal state of STDIN. If we can possibly avoid
   // this by setting the file handles up correctly prior to entering the
   // interpreter we should. For now we save and restore the terminal state on
   // the input file handle.
   m_terminal_state.Restore();
 }
 
-void ScriptInterpreterPython::LeaveSession() {
+void ScriptInterpreterPythonImpl::LeaveSession() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
   if (log)
-    log->PutCString("ScriptInterpreterPython::LeaveSession()");
+    log->PutCString("ScriptInterpreterPythonImpl::LeaveSession()");
 
   // checking that we have a valid thread state - since we use our own
   // threading and locking in some (rare) cases during cleanup Python may end
   // up believing we have no thread state and PyImport_AddModule will crash if
   // that is the case - since that seems to only happen when destroying the
   // SBDebugger, we can make do without clearing up stdout and stderr
 
   // rdar://problem/11292882
if (sys_module_dict.IsValid()) {
         m_saved_stderr.Reset();
       }
     }
   }
 
   m_session_is_active = false;
 }
 
-bool ScriptInterpreterPython::SetStdHandle(File &file, const char *py_name,
+bool ScriptInterpreterPythonImpl::SetStdHandle(File &file, const char *py_name,
                                                PythonFile &save_file,
                                                const char *mode) {
   if (file.IsValid()) {
     // Flush the file before giving it to python to avoid interleaved output.
     file.Flush();
 
     PythonDictionary &sys_module_dict = GetSysModuleDictionary();
 
     save_file = sys_module_dict.GetItemForKey(PythonString(py_name))
                     .AsType<PythonFile>();
 
     PythonFile new_file(file, mode);
     sys_module_dict.SetItemForKey(PythonString(py_name), new_file);
     return true;
   } else
     save_file.Reset();
   return false;
 }
 
-bool ScriptInterpreterPython::EnterSession(uint16_t on_entry_flags, FILE *in,
-                                           FILE *out, FILE *err) {
+bool ScriptInterpreterPythonImpl::EnterSession(uint16_t on_entry_flags,
+                                               FILE *in, FILE *out, FILE *err) {
   // If we have already entered the session, without having officially 'left'
   // it, then there is no need to 'enter' it again.
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
   if (m_session_is_active) {
     if (log)
       log->Printf(
-          "ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16
+          "ScriptInterpreterPythonImpl::EnterSession(on_entry_flags=0x%" PRIx16
           ") session is already active, returning without doing anything",
           on_entry_flags);
     return false;
   }
 
   if (log)
     log->Printf(
-        "ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16 ")",
+        "ScriptInterpreterPythonImpl::EnterSession(on_entry_flags=0x%" PRIx16
+        ")",
         on_entry_flags);
 
   m_session_is_active = true;
 
   StreamString run_string;
 
   if (on_entry_flags & Locker::InitGlobals) {
     run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
bool ScriptInterpreterPythonImpl::EnterSession(uint16_t on_entry_flags,
   }
 
   if (PyErr_Occurred())
     PyErr_Clear();
 
   return true;
 }
 
-PythonObject &ScriptInterpreterPython::GetMainModule() {
+PythonObject &ScriptInterpreterPythonImpl::GetMainModule() {
   if (!m_main_module.IsValid())
     m_main_module.Reset(PyRefType::Borrowed, PyImport_AddModule("__main__"));
   return m_main_module;
 }
 
-PythonDictionary &ScriptInterpreterPython::GetSessionDictionary() {
+PythonDictionary &ScriptInterpreterPythonImpl::GetSessionDictionary() {
   if (m_session_dict.IsValid())
     return m_session_dict;
 
   PythonObject &main_module = GetMainModule();
   if (!main_module.IsValid())
     return m_session_dict;
 
   PythonDictionary main_dict(PyRefType::Borrowed,
                              PyModule_GetDict(main_module.get()));
   if (!main_dict.IsValid())
     return m_session_dict;
 
   PythonObject item = main_dict.GetItemForKey(PythonString(m_dictionary_name));
   m_session_dict.Reset(PyRefType::Borrowed, item.get());
   return m_session_dict;
 }
 
-PythonDictionary &ScriptInterpreterPython::GetSysModuleDictionary() {
+PythonDictionary &ScriptInterpreterPythonImpl::GetSysModuleDictionary() {
   if (m_sys_module_dict.IsValid())
     return m_sys_module_dict;
 
   PythonObject sys_module(PyRefType::Borrowed, PyImport_AddModule("sys"));
   if (sys_module.IsValid())
     m_sys_module_dict.Reset(PyRefType::Borrowed,
                             PyModule_GetDict(sys_module.get()));
   return m_sys_module_dict;
static std::string GenerateUniqueName(const char *base_name_wanted,
   if (!name_token)
     sstr.Printf("%s_%d", base_name_wanted, functions_counter++);
   else
     sstr.Printf("%s_%p", base_name_wanted, name_token);
 
   return sstr.GetString();
 }
 
-bool ScriptInterpreterPython::GetEmbeddedInterpreterModuleObjects() {
+bool ScriptInterpreterPythonImpl::GetEmbeddedInterpreterModuleObjects() {
   if (m_run_one_line_function.IsValid())
     return true;
 
   PythonObject module(PyRefType::Borrowed,
                       PyImport_AddModule("lldb.embedded_interpreter"));
   if (!module.IsValid())
     return false;
 
static void ReadThreadBytesReceived(void *baton, const void *src,
                                     size_t src_len) {
   if (src && src_len) {
     Stream *strm = (Stream *)baton;
     strm->Write(src, src_len);
     strm->Flush();
   }
 }
 
-bool ScriptInterpreterPython::ExecuteOneLine(
+bool ScriptInterpreterPythonImpl::ExecuteOneLine(
     llvm::StringRef command, CommandReturnObject *result,
     const ExecuteScriptOptions &options) {
   std::string command_str = command.str();
 
   if (!m_valid_session)
     return false;
 
   if (!command.empty()) {
     // We want to call run_one_line, passing in the dictionary and the command
     // string.  We cannot do this through PyRun_SimpleString here because the
     // command string may contain escaped characters, and putting it inside
     // another string to pass to PyRun_SimpleString messes up the escaping.  So
     // we use the following more complicated method to pass the command string
     // directly down to Python.
     Debugger &debugger = m_interpreter.GetDebugger();
 
     StreamFileSP input_file_sp;
     StreamFileSP output_file_sp;
     StreamFileSP error_file_sp;
     Communication output_comm(
-        "lldb.ScriptInterpreterPython.ExecuteOneLine.comm");
+        "lldb.ScriptInterpreterPythonImpl.ExecuteOneLine.comm");
     bool join_read_thread = false;
     if (options.GetEnableIO()) {
       if (result) {
         input_file_sp = debugger.GetInputFile();
         // Set output to a temporary file so we can forward the results on to
         // the result object
 
         Pipe pipe;
bool success = false;
       // the read thread.  The reason for this is that a pre-requisite for
       // joining the read thread is that we close the write handle (to break
       // the pipe and cause it to wake up and exit).  But acquiring the GIL as
       // below will redirect Python's stdio to use this same handle.  If we
       // close the handle while Python is still using it, bad things will
       // happen.
       Locker locker(
           this,
-          ScriptInterpreterPython::Locker::AcquireLock |
-              ScriptInterpreterPython::Locker::InitSession |
-              (options.GetSetLLDBGlobals()
-                   ? ScriptInterpreterPython::Locker::InitGlobals
-                   : 0) |
+          Locker::AcquireLock | Locker::InitSession |
+              (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
               ((result && result->GetInteractive()) ? 0 : Locker::NoSTDIN),
-          ScriptInterpreterPython::Locker::FreeAcquiredLock |
-              ScriptInterpreterPython::Locker::TearDownSession,
-          in_file, out_file, err_file);
+          Locker::FreeAcquiredLock | Locker::TearDownSession, in_file, out_file,
+          err_file);
 
       // Find the correct script interpreter dictionary in the main module.
       PythonDictionary &session_dict = GetSessionDictionary();
       if (session_dict.IsValid()) {
         if (GetEmbeddedInterpreterModuleObjects()) {
           if (PyCallable_Check(m_run_one_line_function.get())) {
             PythonObject pargs(
                 PyRefType::Owned,
#endif
     return false;
   }
 
   if (result)
     result->AppendError("empty command passed to python\n");
   return false;
 }
 
-class IOHandlerPythonInterpreter : public IOHandler {
-public:
-  IOHandlerPythonInterpreter(Debugger &debugger,
-                             ScriptInterpreterPython *python)
-      : IOHandler(debugger, IOHandler::Type::PythonInterpreter),
-        m_python(python) {}
-
-  ~IOHandlerPythonInterpreter() override {}
-
-  ConstString GetControlSequence(char ch) override {
-    if (ch == 'd')
-      return ConstString("quit()\n");
-    return ConstString();
-  }
-
-  void Run() override {
-    if (m_python) {
-      int stdin_fd = GetInputFD();
-      if (stdin_fd >= 0) {
-        Terminal terminal(stdin_fd);
-        TerminalState terminal_state;
-        const bool is_a_tty = terminal.IsATerminal();
-
-        if (is_a_tty) {
-          terminal_state.Save(stdin_fd, false);
-          terminal.SetCanonical(false);
-          terminal.SetEcho(true);
-        }
-
-        ScriptInterpreterPython::Locker locker(
-            m_python, ScriptInterpreterPython::Locker::AcquireLock |
-                          ScriptInterpreterPython::Locker::InitSession |
-                          ScriptInterpreterPython::Locker::InitGlobals,
-            ScriptInterpreterPython::Locker::FreeAcquiredLock |
-                ScriptInterpreterPython::Locker::TearDownSession);
-
-        // The following call drops into the embedded interpreter loop and
-        // stays there until the user chooses to exit from the Python
-        // interpreter. This embedded interpreter will, as any Python code that
-        // performs I/O, unlock the GIL before a system call that can hang, and
-        // lock it when the syscall has returned.
-
-        // We need to surround the call to the embedded interpreter with calls
-        // to PyGILState_Ensure and PyGILState_Release (using the Locker
-        // above). This is because Python has a global lock which must be held
-        // whenever we want to touch any Python objects. Otherwise, if the user
-        // calls Python code, the interpreter state will be off, and things
-        // could hang (it's happened before).
-
-        StreamString run_string;
-        run_string.Printf("run_python_interpreter (%s)",
-                          m_python->GetDictionaryName());
-        PyRun_SimpleString(run_string.GetData());
-
-        if (is_a_tty)
-          terminal_state.Restore();
-      }
-    }
-    SetIsDone(true);
-  }
-
-  void Cancel() override {}
-
-  bool Interrupt() override { return m_python->Interrupt(); }
-
-  void GotEOF() override {}
-
-protected:
-  ScriptInterpreterPython *m_python;
-};
-
-void ScriptInterpreterPython::ExecuteInterpreterLoop() {
+void ScriptInterpreterPythonImpl::ExecuteInterpreterLoop() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   Debugger &debugger = GetCommandInterpreter().GetDebugger();
 
   // At the moment, the only time the debugger does not have an input file
   // handle is when this is called directly from Python, in which case it is
   // both dangerous and unnecessary (not to mention confusing) to try to embed
   // a running interpreter loop inside the already running Python interpreter
   // loop, so we won't do it.
 
   if (!debugger.GetInputFile()->GetFile().IsValid())
     return;
 
   IOHandlerSP io_handler_sp(new IOHandlerPythonInterpreter(debugger, this));
   if (io_handler_sp) {
     debugger.PushIOHandler(io_handler_sp);
   }
 }
 
-bool ScriptInterpreterPython::Interrupt() {
+bool ScriptInterpreterPythonImpl::Interrupt() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
 
   if (IsExecutingPython()) {
     PyThreadState *state = PyThreadState_GET();
     if (!state)
       state = GetThreadState();
     if (state) {
       long tid = state->thread_id;
       PyThreadState_Swap(state);
       int num_threads = PyThreadState_SetAsyncExc(tid, PyExc_KeyboardInterrupt);
       if (log)
-        log->Printf("ScriptInterpreterPython::Interrupt() sending "
+        log->Printf("ScriptInterpreterPythonImpl::Interrupt() sending "
                     "PyExc_KeyboardInterrupt (tid = %li, num_threads = %i)...",
                     tid, num_threads);
       return true;
     }
   }
   if (log)
-    log->Printf("ScriptInterpreterPython::Interrupt() python code not running, "
-                "can't interrupt");
+    log->Printf(
+        "ScriptInterpreterPythonImpl::Interrupt() python code not running, "
   return false;
 }
-bool ScriptInterpreterPython::ExecuteOneLineWithReturn(
+bool ScriptInterpreterPythonImpl::ExecuteOneLineWithReturn(
     llvm::StringRef in_string, ScriptInterpreter::ScriptReturnType return_type,
     void *ret_value, const ExecuteScriptOptions &options) {
 
-  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock |
-                          ScriptInterpreterPython::Locker::InitSession |
-                          (options.GetSetLLDBGlobals()
-                               ? ScriptInterpreterPython::Locker::InitGlobals
-                               : 0) |
-                          Locker::NoSTDIN,
-                ScriptInterpreterPython::Locker::FreeAcquiredLock |
-                    ScriptInterpreterPython::Locker::TearDownSession);
+  Locker locker(this,
+                Locker::AcquireLock | Locker::InitSession |
+                    (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
+                Locker::FreeAcquiredLock | Locker::TearDownSession);
 
   PythonObject py_return;
   PythonObject &main_module = GetMainModule();
   PythonDictionary globals(PyRefType::Borrowed,
                            PyModule_GetDict(main_module.get()));
   PythonObject py_error;
   bool ret_success = false;
   int success;
if (options.GetMaskoutErrors()) {
         PyErr_Print();
       PyErr_Clear();
     }
   }
 
   return ret_success;
 }
 
-Status ScriptInterpreterPython::ExecuteMultipleLines(
+Status ScriptInterpreterPythonImpl::ExecuteMultipleLines(
     const char *in_string, const ExecuteScriptOptions &options) {
   Status error;
 
-  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock |
-                          ScriptInterpreterPython::Locker::InitSession |
-                          (options.GetSetLLDBGlobals()
-                               ? ScriptInterpreterPython::Locker::InitGlobals
-                               : 0) |
-                          Locker::NoSTDIN,
-                ScriptInterpreterPython::Locker::FreeAcquiredLock |
-                    ScriptInterpreterPython::Locker::TearDownSession);
+  Locker locker(this,
+                Locker::AcquireLock | Locker::InitSession |
+                    (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
+                Locker::FreeAcquiredLock | Locker::TearDownSession);
 
   PythonObject return_value;
   PythonObject &main_module = GetMainModule();
   PythonDictionary globals(PyRefType::Borrowed,
                            PyModule_GetDict(main_module.get()));
   PythonObject py_error;
 
   PythonDictionary locals = GetSessionDictionary();
#endif
 
   PythonExceptionState exception_state(!options.GetMaskoutErrors());
   if (exception_state.IsError())
     error.SetErrorString(exception_state.Format().c_str());
 
   return error;
 }
 
-void ScriptInterpreterPython::CollectDataForBreakpointCommandCallback(
+void ScriptInterpreterPythonImpl::CollectDataForBreakpointCommandCallback(
     std::vector<BreakpointOptions *> &bp_options_vec,
     CommandReturnObject &result) {
   m_active_io_handler = eIOHandlerBreakpoint;
   m_interpreter.GetPythonCommandsFromIOHandler("    ", *this, true,
                                                &bp_options_vec);
 }
 
-void ScriptInterpreterPython::CollectDataForWatchpointCommandCallback(
+void ScriptInterpreterPythonImpl::CollectDataForWatchpointCommandCallback(
     WatchpointOptions *wp_options, CommandReturnObject &result) {
   m_active_io_handler = eIOHandlerWatchpoint;
   m_interpreter.GetPythonCommandsFromIOHandler("    ", *this, true, wp_options);
 }
 
-void ScriptInterpreterPython::SetBreakpointCommandCallbackFunction(
+void ScriptInterpreterPythonImpl::SetBreakpointCommandCallbackFunction(
     BreakpointOptions *bp_options, const char *function_name) {
   // For now just cons up a oneliner that calls the provided function.
   std::string oneliner("return ");
   oneliner += function_name;
   oneliner += "(frame, bp_loc, internal_dict)";
   m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback(
       bp_options, oneliner.c_str());
 }
 
-Status ScriptInterpreterPython::SetBreakpointCommandCallback(
+Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
     BreakpointOptions *bp_options,
     std::unique_ptr<BreakpointOptions::CommandData> &cmd_data_up) {
   Status error;
   error = GenerateBreakpointCommandCallbackData(cmd_data_up->user_source,
                                                 cmd_data_up->script_source);
   if (error.Fail()) {
     return error;
   }
   auto baton_sp =
       std::make_shared<BreakpointOptions::CommandBaton>(std::move(cmd_data_up));
-  bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction,
-                          baton_sp);
+  bp_options->SetCallback(
+      ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
   return error;
 }
 
 // Set a Python one-liner as the callback for the breakpoint.
-Status ScriptInterpreterPython::SetBreakpointCommandCallback(
+Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
     BreakpointOptions *bp_options, const char *command_body_text) {
   auto data_up = llvm::make_unique<CommandDataPython>();
 
   // Split the command_body_text into lines, and pass that to
   // GenerateBreakpointCommandCallbackData.  That will wrap the body in an
   // auto-generated function, and return the function name in script_source.
   // That is what the callback will actually invoke.
 
   data_up->user_source.SplitIntoLines(command_body_text);
   Status error = GenerateBreakpointCommandCallbackData(data_up->user_source,
                                                        data_up->script_source);
   if (error.Success()) {
     auto baton_sp =
         std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up));
-    bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction,
-                            baton_sp);
+    bp_options->SetCallback(
+        ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
     return error;
   } else
     return error;
 }
 
 // Set a Python one-liner as the callback for the watchpoint.
-void ScriptInterpreterPython::SetWatchpointCommandCallback(
+void ScriptInterpreterPythonImpl::SetWatchpointCommandCallback(
     WatchpointOptions *wp_options, const char *oneliner) {
   auto data_up = llvm::make_unique<WatchpointOptions::CommandData>();
 
   // It's necessary to set both user_source and script_source to the oneliner.
   // The former is used to generate callback description (as in watchpoint
   // command list) while the latter is used for Python to interpret during the
   // actual callback.
 
   data_up->user_source.AppendString(oneliner);
   data_up->script_source.assign(oneliner);
 
   if (GenerateWatchpointCommandCallbackData(data_up->user_source,
                                             data_up->script_source)) {
     auto baton_sp =
         std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
-    wp_options->SetCallback(ScriptInterpreterPython::WatchpointCallbackFunction,
-                            baton_sp);
+    wp_options->SetCallback(
+        ScriptInterpreterPythonImpl::WatchpointCallbackFunction, baton_sp);
   }
 
   return;
 }
 
-Status ScriptInterpreterPython::ExportFunctionDefinitionToInterpreter(
+Status ScriptInterpreterPythonImpl::ExportFunctionDefinitionToInterpreter(
     StringList &function_def) {
   // Convert StringList to one long, newline delimited, const char *.
   std::string function_def_string(function_def.CopyList());
 
   Status error = ExecuteMultipleLines(
       function_def_string.c_str(),
       ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false));
   return error;
 }
 
-Status ScriptInterpreterPython::GenerateFunction(const char *signature,
+Status ScriptInterpreterPythonImpl::GenerateFunction(const char *signature,
                                                      const StringList &input) {
   Status error;
   int num_lines = input.GetSize();
   if (num_lines == 0) {
     error.SetErrorString("No input data.");
     return error;
   }
 
   if (!signature || *signature == 0) {
Status ScriptInterpreterPythonImpl::GenerateFunction(const char *signature,
 
   // Verify that the results are valid Python.
 
   error = ExportFunctionDefinitionToInterpreter(auto_generated_function);
 
   return error;
 }
 
-bool ScriptInterpreterPython::GenerateTypeScriptFunction(
+bool ScriptInterpreterPythonImpl::GenerateTypeScriptFunction(
     StringList &user_input, std::string &output, const void *name_token) {
   static uint32_t num_created_functions = 0;
   user_input.RemoveBlankLines();
   StreamString sstr;
 
   // Check to see if we have any data; if not, just return.
   if (user_input.GetSize() == 0)
     return false;
bool ScriptInterpreterPythonImpl::GenerateTypeScriptFunction(
   if (!GenerateFunction(sstr.GetData(), user_input).Success())
     return false;
 
   // Store the name of the auto-generated function to be called.
   output.assign(auto_generated_function_name);
   return true;
 }
 
-bool ScriptInterpreterPython::GenerateScriptAliasFunction(
+bool ScriptInterpreterPythonImpl::GenerateScriptAliasFunction(
     StringList &user_input, std::string &output) {
   static uint32_t num_created_functions = 0;
   user_input.RemoveBlankLines();
   StreamString sstr;
 
   // Check to see if we have any data; if not, just return.
   if (user_input.GetSize() == 0)
     return false;
 
   std::string auto_generated_function_name(GenerateUniqueName(
       "lldb_autogen_python_cmd_alias_func", num_created_functions));
 
   sstr.Printf("def %s (debugger, args, result, internal_dict):",
               auto_generated_function_name.c_str());
 
   if (!GenerateFunction(sstr.GetData(), user_input).Success())
     return false;
 
   // Store the name of the auto-generated function to be called.
   output.assign(auto_generated_function_name);
   return true;
 }
 
-bool ScriptInterpreterPython::GenerateTypeSynthClass(StringList &user_input,
-                                                     std::string &output,
-                                                     const void *name_token) {
+bool ScriptInterpreterPythonImpl::GenerateTypeSynthClass(
+    StringList &user_input, std::string &output, const void *name_token) {
   static uint32_t num_created_classes = 0;
   user_input.RemoveBlankLines();
   int num_lines = user_input.GetSize();
   StreamString sstr;
 
   // Check to see if we have any data; if not, just return.
   if (user_input.GetSize() == 0)
     return false;
if (!ExportFunctionDefinitionToInterpreter(auto_generated_class).Success())
     return false;
 
   // Store the name of the auto-generated class
 
   output.assign(auto_generated_class_name);
   return true;
 }
 
-StructuredData::GenericSP ScriptInterpreterPython::CreateFrameRecognizer(
-    const char *class_name) {
+StructuredData::GenericSP
+ScriptInterpreterPythonImpl::CreateFrameRecognizer(const char *class_name) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   void *ret_val;
 
   {
     Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN,
                    Locker::FreeLock);
     ret_val = LLDBSWIGPython_CreateFrameRecognizer(class_name,
                                                    m_dictionary_name.c_str());
   }
 
   return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
-lldb::ValueObjectListSP ScriptInterpreterPython::GetRecognizedArguments(
+lldb::ValueObjectListSP ScriptInterpreterPythonImpl::GetRecognizedArguments(
     const StructuredData::ObjectSP &os_plugin_object_sp,
     lldb::StackFrameSP frame_sp) {
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
-  if (!os_plugin_object_sp) return ValueObjectListSP();
+  if (!os_plugin_object_sp)
+    return ValueObjectListSP();
 
   StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
-  if (!generic) return nullptr;
+  if (!generic)
+    return nullptr;
 
   PythonObject implementor(PyRefType::Borrowed,
                            (PyObject *)generic->GetValue());
 
-  if (!implementor.IsAllocated()) return ValueObjectListSP();
+  if (!implementor.IsAllocated())
+    return ValueObjectListSP();
 
   PythonObject py_return(PyRefType::Owned,
                          (PyObject *)LLDBSwigPython_GetRecognizedArguments(
                              implementor.get(), frame_sp));
 
   // if it fails, print the error but otherwise go on
   if (PyErr_Occurred()) {
     PyErr_Print();
     PyErr_Clear();
   }
   if (py_return.get()) {
     PythonList result_list(PyRefType::Borrowed, py_return.get());
     ValueObjectListSP result = ValueObjectListSP(new ValueObjectList());
     for (size_t i = 0; i < result_list.GetSize(); i++) {
       PyObject *item = result_list.GetItemAtIndex(i).get();
       lldb::SBValue *sb_value_ptr =
           (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(item);
       auto valobj_sp = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
-      if (valobj_sp) result->Append(valobj_sp);
+      if (valobj_sp)
+        result->Append(valobj_sp);
     }
     return result;
   }
   return ValueObjectListSP();
 }
 
-StructuredData::GenericSP ScriptInterpreterPython::OSPlugin_CreatePluginObject(
+StructuredData::GenericSP
+ScriptInterpreterPythonImpl::OSPlugin_CreatePluginObject(
     const char *class_name, lldb::ProcessSP process_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!process_sp)
     return StructuredData::GenericSP();
 
   void *ret_val;
 
   {
     Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN,
                    Locker::FreeLock);
     ret_val = LLDBSWIGPythonCreateOSPlugin(
         class_name, m_dictionary_name.c_str(), process_sp);
   }
 
   return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
-StructuredData::DictionarySP ScriptInterpreterPython::OSPlugin_RegisterInfo(
+StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_RegisterInfo(
     StructuredData::ObjectSP os_plugin_object_sp) {
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   static char callee_name[] = "get_register_info";
 
   if (!os_plugin_object_sp)
     return StructuredData::DictionarySP();
 
StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_RegisterInfo(
   }
   if (py_return.get()) {
     PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
     return result_dict.CreateStructuredDictionary();
   }
   return StructuredData::DictionarySP();
 }
 
-StructuredData::ArraySP ScriptInterpreterPython::OSPlugin_ThreadsInfo(
+StructuredData::ArraySP ScriptInterpreterPythonImpl::OSPlugin_ThreadsInfo(
     StructuredData::ObjectSP os_plugin_object_sp) {
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   static char callee_name[] = "get_thread_info";
 
   if (!os_plugin_object_sp)
     return StructuredData::ArraySP();
 

 }
 template <> const char *GetPythonValueFormatString(long long) { return "L"; }
 template <> const char *GetPythonValueFormatString(unsigned long long) {
   return "K";
 }
 template <> const char *GetPythonValueFormatString(float t) { return "f"; }
 template <> const char *GetPythonValueFormatString(double t) { return "d"; }
 
-StructuredData::StringSP ScriptInterpreterPython::OSPlugin_RegisterContextData(
+StructuredData::StringSP
+ScriptInterpreterPythonImpl::OSPlugin_RegisterContextData(
     StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid) {
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   static char callee_name[] = "get_register_data";
   static char *param_format =
       const_cast<char *>(GetPythonValueFormatString(tid));
 
   if (!os_plugin_object_sp)
ScriptInterpreterPythonImpl::OSPlugin_RegisterContextData(
 
   if (py_return.get()) {
     PythonBytes result(PyRefType::Borrowed, py_return.get());
     return result.CreateStructuredString();
   }
   return StructuredData::StringSP();
 }
 
-StructuredData::DictionarySP ScriptInterpreterPython::OSPlugin_CreateThread(
+StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_CreateThread(
     StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid,
     lldb::addr_t context) {
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   static char callee_name[] = "create_thread";
   std::string param_format;
   param_format += GetPythonValueFormatString(tid);
   param_format += GetPythonValueFormatString(context);
StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_CreateThread(
 
   if (py_return.get()) {
     PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
     return result_dict.CreateStructuredDictionary();
   }
   return StructuredData::DictionarySP();
 }
 
-StructuredData::ObjectSP ScriptInterpreterPython::CreateScriptedThreadPlan(
+StructuredData::ObjectSP ScriptInterpreterPythonImpl::CreateScriptedThreadPlan(
     const char *class_name, lldb::ThreadPlanSP thread_plan_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::ObjectSP();
 
   if (!thread_plan_sp.get())
     return StructuredData::ObjectSP();
 
   Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
   ScriptInterpreter *script_interpreter =
       debugger.GetCommandInterpreter().GetScriptInterpreter();
-  ScriptInterpreterPython *python_interpreter =
-      static_cast<ScriptInterpreterPython *>(script_interpreter);
+  ScriptInterpreterPythonImpl *python_interpreter =
+      static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
 
   if (!script_interpreter)
     return StructuredData::ObjectSP();
 
   void *ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
     ret_val = LLDBSwigPythonCreateScriptedThreadPlan(
         class_name, python_interpreter->m_dictionary_name.c_str(),
         thread_plan_sp);
   }
 
   return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
-bool ScriptInterpreterPython::ScriptedThreadPlanExplainsStop(
+bool ScriptInterpreterPythonImpl::ScriptedThreadPlanExplainsStop(
     StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error) {
   bool explains_stop = true;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     explains_stop = LLDBSWIGPythonCallThreadPlan(
         generic->GetValue(), "explains_stop", event, script_error);
     if (script_error)
       return true;
   }
   return explains_stop;
 }
 
-bool ScriptInterpreterPython::ScriptedThreadPlanShouldStop(
+bool ScriptInterpreterPythonImpl::ScriptedThreadPlanShouldStop(
     StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error) {
   bool should_stop = true;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     should_stop = LLDBSWIGPythonCallThreadPlan(
         generic->GetValue(), "should_stop", event, script_error);
     if (script_error)
       return true;
   }
   return should_stop;
 }
 
-bool ScriptInterpreterPython::ScriptedThreadPlanIsStale(
+bool ScriptInterpreterPythonImpl::ScriptedThreadPlanIsStale(
     StructuredData::ObjectSP implementor_sp, bool &script_error) {
   bool is_stale = true;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     is_stale = LLDBSWIGPythonCallThreadPlan(generic->GetValue(), "is_stale",
                                             nullptr, script_error);
     if (script_error)
       return true;
   }
   return is_stale;
 }
 
-lldb::StateType ScriptInterpreterPython::ScriptedThreadPlanGetRunState(
+lldb::StateType ScriptInterpreterPythonImpl::ScriptedThreadPlanGetRunState(
     StructuredData::ObjectSP implementor_sp, bool &script_error) {
   bool should_step = false;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     should_step = LLDBSWIGPythonCallThreadPlan(
         generic->GetValue(), "should_step", NULL, script_error);
     if (script_error)
       should_step = true;
   }
   if (should_step)
     return lldb::eStateStepping;
   else
     return lldb::eStateRunning;
 }
 
 StructuredData::GenericSP
-ScriptInterpreterPython::CreateScriptedBreakpointResolver(
-    const char *class_name,
-    StructuredDataImpl *args_data,
+ScriptInterpreterPythonImpl::CreateScriptedBreakpointResolver(
+    const char *class_name, StructuredDataImpl *args_data,
     lldb::BreakpointSP &bkpt_sp) {
 
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!bkpt_sp.get())
     return StructuredData::GenericSP();
 
   Debugger &debugger = bkpt_sp->GetTarget().GetDebugger();
   ScriptInterpreter *script_interpreter =
       debugger.GetCommandInterpreter().GetScriptInterpreter();
-  ScriptInterpreterPython *python_interpreter =
-      static_cast<ScriptInterpreterPython *>(script_interpreter);
+  ScriptInterpreterPythonImpl *python_interpreter =
+      static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
 
   if (!script_interpreter)
     return StructuredData::GenericSP();
 
   void *ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
     ret_val = LLDBSwigPythonCreateScriptedBreakpointResolver(
         class_name, python_interpreter->m_dictionary_name.c_str(), args_data,
         bkpt_sp);
   }
 
   return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
-bool
-ScriptInterpreterPython::ScriptedBreakpointResolverSearchCallback(
-    StructuredData::GenericSP implementor_sp,
-    SymbolContext *sym_ctx) {
+bool ScriptInterpreterPythonImpl::ScriptedBreakpointResolverSearchCallback(
+    StructuredData::GenericSP implementor_sp, SymbolContext *sym_ctx) {
   bool should_continue = false;
 
   if (implementor_sp) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     should_continue = LLDBSwigPythonCallBreakpointResolver(
         implementor_sp->GetValue(), "__callback__", sym_ctx);
     if (PyErr_Occurred()) {
       PyErr_Print();
       PyErr_Clear();
     }
   }
   return should_continue;
 }
 
 lldb::SearchDepth
-ScriptInterpreterPython::ScriptedBreakpointResolverSearchDepth(
+ScriptInterpreterPythonImpl::ScriptedBreakpointResolverSearchDepth(
     StructuredData::GenericSP implementor_sp) {
   int depth_as_int = lldb::eSearchDepthModule;
   if (implementor_sp) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     depth_as_int = LLDBSwigPythonCallBreakpointResolver(
         implementor_sp->GetValue(), "__get_depth__", nullptr);
     if (PyErr_Occurred()) {
       PyErr_Print();
       PyErr_Clear();
     }
   }
   if (depth_as_int == lldb::eSearchDepthInvalid)
     return lldb::eSearchDepthModule;
 
   if (depth_as_int <= lldb::kLastSearchDepthKind)
-    return (lldb::SearchDepth) depth_as_int;
+    return (lldb::SearchDepth)depth_as_int;
   else
     return lldb::eSearchDepthModule;
 }
 
 StructuredData::ObjectSP
-ScriptInterpreterPython::LoadPluginModule(const FileSpec &file_spec,
+ScriptInterpreterPythonImpl::LoadPluginModule(const FileSpec &file_spec,
                                               lldb_private::Status &error) {
   if (!FileSystem::Instance().Exists(file_spec)) {
     error.SetErrorString("no such file");
     return StructuredData::ObjectSP();
   }
 
   StructuredData::ObjectSP module_sp;
 
   if (LoadScriptingModule(file_spec.GetPath().c_str(), true, true, error,
                           &module_sp))
     return module_sp;
 
   return StructuredData::ObjectSP();
 }
 
-StructuredData::DictionarySP ScriptInterpreterPython::GetDynamicSettings(
+StructuredData::DictionarySP ScriptInterpreterPythonImpl::GetDynamicSettings(
     StructuredData::ObjectSP plugin_module_sp, Target *target,
     const char *setting_name, lldb_private::Status &error) {
   if (!plugin_module_sp || !target || !setting_name || !setting_name[0])
     return StructuredData::DictionarySP();
   StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
   if (!generic)
     return StructuredData::DictionarySP();
 
   PythonObject reply_pyobj;
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
   TargetSP target_sp(target->shared_from_this());
   reply_pyobj.Reset(PyRefType::Owned,
                     (PyObject *)LLDBSWIGPython_GetDynamicSetting(
                         generic->GetValue(), setting_name, target_sp));
 
   PythonDictionary py_dict(PyRefType::Borrowed, reply_pyobj.get());
   return py_dict.CreateStructuredDictionary();
 }
 
 StructuredData::ObjectSP
-ScriptInterpreterPython::CreateSyntheticScriptedProvider(
+ScriptInterpreterPythonImpl::CreateSyntheticScriptedProvider(
     const char *class_name, lldb::ValueObjectSP valobj) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::ObjectSP();
 
   if (!valobj.get())
     return StructuredData::ObjectSP();
 
   ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return StructuredData::ObjectSP();
 
   Debugger &debugger = target->GetDebugger();
   ScriptInterpreter *script_interpreter =
       debugger.GetCommandInterpreter().GetScriptInterpreter();
-  ScriptInterpreterPython *python_interpreter =
-      (ScriptInterpreterPython *)script_interpreter;
+  ScriptInterpreterPythonImpl *python_interpreter =
+      (ScriptInterpreterPythonImpl *)script_interpreter;
 
   if (!script_interpreter)
     return StructuredData::ObjectSP();
 
   void *ret_val = nullptr;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPythonCreateSyntheticProvider(
         class_name, python_interpreter->m_dictionary_name.c_str(), valobj);
   }
 
   return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
 StructuredData::GenericSP
-ScriptInterpreterPython::CreateScriptCommandObject(const char *class_name) {
+ScriptInterpreterPythonImpl::CreateScriptCommandObject(const char *class_name) {
   DebuggerSP debugger_sp(
       GetCommandInterpreter().GetDebugger().shared_from_this());
 
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!debugger_sp.get())
     return StructuredData::GenericSP();
 
   void *ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPythonCreateCommandObject(
         class_name, m_dictionary_name.c_str(), debugger_sp);
   }
 
   return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
-bool ScriptInterpreterPython::GenerateTypeScriptFunction(
+bool ScriptInterpreterPythonImpl::GenerateTypeScriptFunction(
     const char *oneliner, std::string &output, const void *name_token) {
   StringList input;
   input.SplitIntoLines(oneliner, strlen(oneliner));
   return GenerateTypeScriptFunction(input, output, name_token);
 }
 
-bool ScriptInterpreterPython::GenerateTypeSynthClass(const char *oneliner,
-                                                     std::string &output,
-                                                     const void *name_token) {
+bool ScriptInterpreterPythonImpl::GenerateTypeSynthClass(
+    const char *oneliner, std::string &output, const void *name_token) {
   StringList input;
   input.SplitIntoLines(oneliner, strlen(oneliner));
   return GenerateTypeSynthClass(input, output, name_token);
 }
 
-Status ScriptInterpreterPython::GenerateBreakpointCommandCallbackData(
+Status ScriptInterpreterPythonImpl::GenerateBreakpointCommandCallbackData(
     StringList &user_input, std::string &output) {
   static uint32_t num_created_functions = 0;
   user_input.RemoveBlankLines();
   StreamString sstr;
   Status error;
   if (user_input.GetSize() == 0) {
     error.SetErrorString("No input data.");
     return error;
   }
 
   std::string auto_generated_function_name(GenerateUniqueName(
       "lldb_autogen_python_bp_callback_func_", num_created_functions));
   sstr.Printf("def %s (frame, bp_loc, internal_dict):",
               auto_generated_function_name.c_str());
 
   error = GenerateFunction(sstr.GetData(), user_input);
   if (!error.Success())
     return error;
 
   // Store the name of the auto-generated function to be called.
   output.assign(auto_generated_function_name);
   return error;
 }
 
-bool ScriptInterpreterPython::GenerateWatchpointCommandCallbackData(
+bool ScriptInterpreterPythonImpl::GenerateWatchpointCommandCallbackData(
     StringList &user_input, std::string &output) {
   static uint32_t num_created_functions = 0;
   user_input.RemoveBlankLines();
   StreamString sstr;
 
   if (user_input.GetSize() == 0)
     return false;
 
   std::string auto_generated_function_name(GenerateUniqueName(
       "lldb_autogen_python_wp_callback_func_", num_created_functions));
   sstr.Printf("def %s (frame, wp, internal_dict):",
               auto_generated_function_name.c_str());
 
   if (!GenerateFunction(sstr.GetData(), user_input).Success())
     return false;
 
   // Store the name of the auto-generated function to be called.
   output.assign(auto_generated_function_name);
   return true;
 }
 
-bool ScriptInterpreterPython::GetScriptedSummary(
+bool ScriptInterpreterPythonImpl::GetScriptedSummary(
     const char *python_function_name, lldb::ValueObjectSP valobj,
     StructuredData::ObjectSP &callee_wrapper_sp,
     const TypeSummaryOptions &options, std::string &retval) {
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   if (!valobj.get()) {
bool ScriptInterpreterPythonImpl::GetScriptedSummary(
   }
 
   if (new_callee && old_callee != new_callee)
     callee_wrapper_sp = std::make_shared<StructuredPythonObject>(new_callee);
 
   return ret_val;
 }
 
-void ScriptInterpreterPython::Clear() {
+void ScriptInterpreterPythonImpl::Clear() {
   // Release any global variables that might have strong references to
   // LLDB objects when clearing the python script interpreter.
-  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
-                ScriptInterpreterPython::Locker::FreeAcquiredLock);
+  Locker locker(this, Locker::AcquireLock, Locker::FreeAcquiredLock);
 
   // This may be called as part of Py_Finalize.  In that case the modules are
   // destroyed in random order and we can't guarantee that we can access these.
   if (Py_IsInitialized())
     PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process "
                        "= None; lldb.thread = None; lldb.frame = None");
 }
 
-bool ScriptInterpreterPython::BreakpointCallbackFunction(
+bool ScriptInterpreterPythonImpl::BreakpointCallbackFunction(
     void *baton, StoppointCallbackContext *context, user_id_t break_id,
     user_id_t break_loc_id) {
   CommandDataPython *bp_option_data = (CommandDataPython *)baton;
   const char *python_function_name = bp_option_data->script_source.c_str();
 
   if (!context)
     return true;
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return true;
 
   Debugger &debugger = target->GetDebugger();
   ScriptInterpreter *script_interpreter =
       debugger.GetCommandInterpreter().GetScriptInterpreter();
-  ScriptInterpreterPython *python_interpreter =
-      (ScriptInterpreterPython *)script_interpreter;
+  ScriptInterpreterPythonImpl *python_interpreter =
+      (ScriptInterpreterPythonImpl *)script_interpreter;
 
   if (!script_interpreter)
     return true;
 
   if (python_function_name && python_function_name[0]) {
     const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
     BreakpointSP breakpoint_sp = target->GetBreakpointByID(break_id);
     if (breakpoint_sp) {
if (breakpoint_sp) {
       }
     }
   }
   // We currently always true so we stop in case anything goes wrong when
   // trying to call the script function
   return true;
 }
 
-bool ScriptInterpreterPython::WatchpointCallbackFunction(
+bool ScriptInterpreterPythonImpl::WatchpointCallbackFunction(
     void *baton, StoppointCallbackContext *context, user_id_t watch_id) {
   WatchpointOptions::CommandData *wp_option_data =
       (WatchpointOptions::CommandData *)baton;
   const char *python_function_name = wp_option_data->script_source.c_str();
 
   if (!context)
     return true;
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return true;
 
   Debugger &debugger = target->GetDebugger();
   ScriptInterpreter *script_interpreter =
       debugger.GetCommandInterpreter().GetScriptInterpreter();
-  ScriptInterpreterPython *python_interpreter =
-      (ScriptInterpreterPython *)script_interpreter;
+  ScriptInterpreterPythonImpl *python_interpreter =
+      (ScriptInterpreterPythonImpl *)script_interpreter;
 
   if (!script_interpreter)
     return true;
 
   if (python_function_name && python_function_name[0]) {
     const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
     WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
     if (wp_sp) {
if (wp_sp) {
       }
     }
   }
   // We currently always true so we stop in case anything goes wrong when
   // trying to call the script function
   return true;
 }
 
-size_t ScriptInterpreterPython::CalculateNumChildren(
+size_t ScriptInterpreterPythonImpl::CalculateNumChildren(
     const StructuredData::ObjectSP &implementor_sp, uint32_t max) {
   if (!implementor_sp)
     return 0;
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return 0;
   void *implementor = generic->GetValue();
   if (!implementor)
     return 0;
 
   size_t ret_val = 0;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPython_CalculateNumChildren(implementor, max);
   }
 
   return ret_val;
 }
 
-lldb::ValueObjectSP ScriptInterpreterPython::GetChildAtIndex(
+lldb::ValueObjectSP ScriptInterpreterPythonImpl::GetChildAtIndex(
     const StructuredData::ObjectSP &implementor_sp, uint32_t idx) {
   if (!implementor_sp)
     return lldb::ValueObjectSP();
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return lldb::ValueObjectSP();
   void *implementor = generic->GetValue();
   if (!implementor)
     return lldb::ValueObjectSP();
 
-
   lldb::ValueObjectSP ret_val;
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     void *child_ptr = LLDBSwigPython_GetChildAtIndex(implementor, idx);
     if (child_ptr != nullptr && child_ptr != Py_None) {
       lldb::SBValue *sb_value_ptr =
           (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(child_ptr);
       if (sb_value_ptr == nullptr)
         Py_XDECREF(child_ptr);
       else
         ret_val = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
     } else {
       Py_XDECREF(child_ptr);
     }
   }
 
   return ret_val;
 }
 
-int ScriptInterpreterPython::GetIndexOfChildWithName(
+int ScriptInterpreterPythonImpl::GetIndexOfChildWithName(
     const StructuredData::ObjectSP &implementor_sp, const char *child_name) {
   if (!implementor_sp)
     return UINT32_MAX;
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return UINT32_MAX;
   void *implementor = generic->GetValue();
   if (!implementor)
     return UINT32_MAX;
 
   int ret_val = UINT32_MAX;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPython_GetIndexOfChildWithName(implementor, child_name);
   }
 
   return ret_val;
 }
 
-bool ScriptInterpreterPython::UpdateSynthProviderInstance(
+bool ScriptInterpreterPythonImpl::UpdateSynthProviderInstance(
     const StructuredData::ObjectSP &implementor_sp) {
   bool ret_val = false;
 
   if (!implementor_sp)
     return ret_val;
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return ret_val;
   void *implementor = generic->GetValue();
   if (!implementor)
     return ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPython_UpdateSynthProviderInstance(implementor);
   }
 
   return ret_val;
 }
 
-bool ScriptInterpreterPython::MightHaveChildrenSynthProviderInstance(
+bool ScriptInterpreterPythonImpl::MightHaveChildrenSynthProviderInstance(
     const StructuredData::ObjectSP &implementor_sp) {
   bool ret_val = false;
 
   if (!implementor_sp)
     return ret_val;
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return ret_val;
   void *implementor = generic->GetValue();
   if (!implementor)
     return ret_val;
 
-
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val =
         LLDBSwigPython_MightHaveChildrenSynthProviderInstance(implementor);
   }
 
   return ret_val;
 }
 
-lldb::ValueObjectSP ScriptInterpreterPython::GetSyntheticValue(
+lldb::ValueObjectSP ScriptInterpreterPythonImpl::GetSyntheticValue(
     const StructuredData::ObjectSP &implementor_sp) {
   lldb::ValueObjectSP ret_val(nullptr);
 
   if (!implementor_sp)
     return ret_val;
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
if (!implementor)
     } else {
       Py_XDECREF(child_ptr);
     }
   }
 
   return ret_val;
 }
 
-ConstString ScriptInterpreterPython::GetSyntheticTypeName(
+ConstString ScriptInterpreterPythonImpl::GetSyntheticTypeName(
     const StructuredData::ObjectSP &implementor_sp) {
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
   static char callee_name[] = "get_type_name";
 
   ConstString ret_val;
   bool got_string = false;
ConstString ScriptInterpreterPythonImpl::GetSyntheticTypeName(
   }
 
   if (got_string)
     ret_val.SetCStringWithLength(buffer.c_str(), buffer.size());
 
   return ret_val;
 }
 
-bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
-                                                     Process *process,
-                                                     std::string &output,
-                                                     Status &error) {
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, Process *process, std::string &output,
   bool ret_val;
   if (!process) {
     error.SetErrorString("no process");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   {
     ProcessSP process_sp(process->shared_from_this());
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSWIGPythonRunScriptKeywordProcess(
         impl_function, m_dictionary_name.c_str(), process_sp, output);
     if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
-bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
-                                                     Thread *thread,
-                                                     std::string &output,
-                                                     Status &error) {
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, Thread *thread, std::string &output,
   bool ret_val;
   if (!thread) {
     error.SetErrorString("no thread");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   {
     ThreadSP thread_sp(thread->shared_from_this());
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSWIGPythonRunScriptKeywordThread(
         impl_function, m_dictionary_name.c_str(), thread_sp, output);
     if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
-bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
-                                                     Target *target,
-                                                     std::string &output,
-                                                     Status &error) {
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, Target *target, std::string &output,
   bool ret_val;
   if (!target) {
     error.SetErrorString("no thread");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   {
     TargetSP target_sp(target->shared_from_this());
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSWIGPythonRunScriptKeywordTarget(
         impl_function, m_dictionary_name.c_str(), target_sp, output);
     if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
-bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
-                                                     StackFrame *frame,
-                                                     std::string &output,
-                                                     Status &error) {
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, StackFrame *frame, std::string &output,
   bool ret_val;
   if (!frame) {
     error.SetErrorString("no frame");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   {
     StackFrameSP frame_sp(frame->shared_from_this());
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSWIGPythonRunScriptKeywordFrame(
         impl_function, m_dictionary_name.c_str(), frame_sp, output);
     if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
-bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
-                                                     ValueObject *value,
-                                                     std::string &output,
-                                                     Status &error) {
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, ValueObject *value, std::string &output,
   bool ret_val;
   if (!value) {
     error.SetErrorString("no value");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
uint64_t replace_all(std::string &str, const std::string &oldStr,
   while ((pos = str.find(oldStr, pos)) != std::string::npos) {
     matches++;
     str.replace(pos, oldStr.length(), newStr);
     pos += newStr.length();
   }
   return matches;
 }
 
-bool ScriptInterpreterPython::LoadScriptingModule(
+bool ScriptInterpreterPythonImpl::LoadScriptingModule(
     const char *pathname, bool can_reload, bool init_session,
     lldb_private::Status &error, StructuredData::ObjectSP *module_sp) {
   if (!pathname || !pathname[0]) {
     error.SetErrorString("invalid pathname");
     return false;
   }
 
   lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
 
   {
     FileSpec target_file(pathname);
     FileSystem::Instance().Resolve(target_file);
     std::string basename(target_file.GetFilename().GetCString());
 
     StreamString command_stream;
 
     // Before executing Python code, lock the GIL.
-    Locker py_lock(this, Locker::AcquireLock |
-                             (init_session ? Locker::InitSession : 0) |
-                             Locker::NoSTDIN,
+    Locker py_lock(this,
+                   Locker::AcquireLock |
                    Locker::FreeAcquiredLock |
                        (init_session ? Locker::TearDownSession : 0));
     namespace fs = llvm::sys::fs;
     fs::file_status st;
     std::error_code ec = status(target_file.GetPath(), st);
 
     if (ec || st.type() == fs::file_type::status_error ||
         st.type() == fs::file_type::type_unknown ||
lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
     command_stream.Clear();
     command_stream.Printf("sys.modules.__contains__('%s')", basename.c_str());
     bool does_contain = false;
     // this call will succeed if the module was ever imported in any Debugger
     // in the lifetime of the process in which this LLDB framework is living
     bool was_imported_globally =
         (ExecuteOneLineWithReturn(
              command_stream.GetData(),
-             ScriptInterpreterPython::eScriptReturnTypeBool, &does_contain,
+             ScriptInterpreterPythonImpl::eScriptReturnTypeBool, &does_contain,
              ScriptInterpreter::ExecuteScriptOptions()
                  .SetEnableIO(false)
                  .SetSetLLDBGlobals(false)) &&
          does_contain);
     // this call will fail if the module was not imported in this Debugger
     // before
     command_stream.Clear();
     command_stream.Printf("sys.getrefcount(%s)", basename.c_str());
if (module_sp) {
           module_pyobj)
         *module_sp = std::make_shared<StructuredPythonObject>(module_pyobj);
     }
 
     return true;
   }
 }
 
-bool ScriptInterpreterPython::IsReservedWord(const char *word) {
+bool ScriptInterpreterPythonImpl::IsReservedWord(const char *word) {
   if (!word || !word[0])
     return false;
 
   llvm::StringRef word_sr(word);
 
   // filter out a few characters that would just confuse us and that are
   // clearly not keyword material anyway
   if (word_sr.find_first_of("'\"") != llvm::StringRef::npos)
     return false;
 
   StreamString command_stream;
   command_stream.Printf("keyword.iskeyword('%s')", word);
   bool result;
   ExecuteScriptOptions options;
   options.SetEnableIO(false);
   options.SetMaskoutErrors(true);
   options.SetSetLLDBGlobals(false);
   if (ExecuteOneLineWithReturn(command_stream.GetData(),
                                ScriptInterpreter::eScriptReturnTypeBool,
                                &result, options))
     return result;
   return false;
 }
 
-ScriptInterpreterPython::SynchronicityHandler::SynchronicityHandler(
+ScriptInterpreterPythonImpl::SynchronicityHandler::SynchronicityHandler(
     lldb::DebuggerSP debugger_sp, ScriptedCommandSynchronicity synchro)
     : m_debugger_sp(debugger_sp), m_synch_wanted(synchro),
       m_old_asynch(debugger_sp->GetAsyncExecution()) {
   if (m_synch_wanted == eScriptedCommandSynchronicitySynchronous)
     m_debugger_sp->SetAsyncExecution(false);
   else if (m_synch_wanted == eScriptedCommandSynchronicityAsynchronous)
     m_debugger_sp->SetAsyncExecution(true);
 }
 
-ScriptInterpreterPython::SynchronicityHandler::~SynchronicityHandler() {
+ScriptInterpreterPythonImpl::SynchronicityHandler::~SynchronicityHandler() {
   if (m_synch_wanted != eScriptedCommandSynchronicityCurrentValue)
     m_debugger_sp->SetAsyncExecution(m_old_asynch);
 }
 
-bool ScriptInterpreterPython::RunScriptBasedCommand(
+bool ScriptInterpreterPythonImpl::RunScriptBasedCommand(
     const char *impl_function, llvm::StringRef args,
     ScriptedCommandSynchronicity synchronicity,
     lldb_private::CommandReturnObject &cmd_retobj, Status &error,
     const lldb_private::ExecutionContext &exe_ctx) {
   if (!impl_function) {
     error.SetErrorString("no function to execute");
     return false;
   }
bool ScriptInterpreterPythonImpl::RunScriptBasedCommand(
   if (!ret_val)
     error.SetErrorString("unable to execute script function");
   else
     error.Clear();
 
   return ret_val;
 }
 
-bool ScriptInterpreterPython::RunScriptBasedCommand(
+bool ScriptInterpreterPythonImpl::RunScriptBasedCommand(
     StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
     ScriptedCommandSynchronicity synchronicity,
     lldb_private::CommandReturnObject &cmd_retobj, Status &error,
     const lldb_private::ExecutionContext &exe_ctx) {
   if (!impl_obj_sp || !impl_obj_sp->IsValid()) {
     error.SetErrorString("no function to execute");
     return false;
   }
else
     error.Clear();
 
   return ret_val;
 }
 
 // in Python, a special attribute __doc__ contains the docstring for an object
 // (function, method, class, ...) if any is defined Otherwise, the attribute's
 // value is None
-bool ScriptInterpreterPython::GetDocumentationForItem(const char *item,
+bool ScriptInterpreterPythonImpl::GetDocumentationForItem(const char *item,
                                                           std::string &dest) {
   dest.clear();
   if (!item || !*item)
     return false;
   std::string command(item);
   command += ".__doc__";
 
   char *result_ptr = nullptr; // Python is going to point this to valid data if
                               // ExecuteOneLineWithReturn returns successfully
if (ExecuteOneLineWithReturn(
     StreamString str_stream;
     str_stream.Printf(
         "Function %s was not found. Containing module might be missing.", item);
     dest = str_stream.GetString();
     return false;
   }
 }
 
-bool ScriptInterpreterPython::GetShortHelpForCommandObject(
+bool ScriptInterpreterPythonImpl::GetShortHelpForCommandObject(
     StructuredData::GenericSP cmd_obj_sp, std::string &dest) {
   bool got_string = false;
   dest.clear();
 
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   static char callee_name[] = "get_short_help";
 
if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
     PythonString py_string(PyRefType::Borrowed, py_return.get());
     llvm::StringRef return_data(py_string.GetString());
     dest.assign(return_data.data(), return_data.size());
     got_string = true;
   }
   return got_string;
 }
 
-uint32_t ScriptInterpreterPython::GetFlagsForCommandObject(
+uint32_t ScriptInterpreterPythonImpl::GetFlagsForCommandObject(
     StructuredData::GenericSP cmd_obj_sp) {
   uint32_t result = 0;
 
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   static char callee_name[] = "get_flags";
 
   if (!cmd_obj_sp)
uint32_t ScriptInterpreterPythonImpl::GetFlagsForCommandObject(
   if (py_return.IsAllocated() && PythonInteger::Check(py_return.get())) {
     PythonInteger int_value(PyRefType::Borrowed, py_return.get());
     result = int_value.GetInteger();
   }
 
   return result;
 }
 
-bool ScriptInterpreterPython::GetLongHelpForCommandObject(
+bool ScriptInterpreterPythonImpl::GetLongHelpForCommandObject(
     StructuredData::GenericSP cmd_obj_sp, std::string &dest) {
   bool got_string = false;
   dest.clear();
 
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   static char callee_name[] = "get_long_help";
 
if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
     dest.assign(str_data.data(), str_data.size());
     got_string = true;
   }
 
   return got_string;
 }
 
 std::unique_ptr<ScriptInterpreterLocker>
-ScriptInterpreterPython::AcquireInterpreterLock() {
+ScriptInterpreterPythonImpl::AcquireInterpreterLock() {
   std::unique_ptr<ScriptInterpreterLocker> py_lock(new Locker(
       this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN,
       Locker::FreeLock | Locker::TearDownSession));
   return py_lock;
 }
 
-void ScriptInterpreterPython::InitializePrivate() {
+void ScriptInterpreterPythonImpl::InitializePrivate() {
   if (g_initialized)
     return;
 
   g_initialized = true;
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
if (FileSpec file_spec = HostInfo::GetShlibDir())
     AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
 
   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");
 }
 
-void ScriptInterpreterPython::AddToSysPath(AddLocation location,
+void ScriptInterpreterPythonImpl::AddToSysPath(AddLocation location,
                                                std::string path) {
   std::string path_copy;
 
   std::string statement;
   if (location == AddLocation::Beginning) {
     statement.assign("sys.path.insert(0,\"");
     statement.append(path);
     statement.append("\")");
   } else {
     statement.assign("sys.path.append(\"");
     statement.append(path);
     statement.append("\")");
   }
   PyRun_SimpleString(statement.c_str());
 }
 
 // We are intentionally NOT calling Py_Finalize here (this would be the logical
 // place to call it).  Calling Py_Finalize here causes test suite runs to seg
 // fault:  The test suite runs in Python.  It registers SBDebugger::Terminate to
 // be called 'at_exit'.  When the test suite Python harness finishes up, it
 // calls Py_Finalize, which calls all the 'at_exit' registered functions.
 // SBDebugger::Terminate calls Debugger::Terminate, which calls lldb::Terminate,
 // which calls ScriptInterpreter::Terminate, which calls
-// ScriptInterpreterPython::Terminate.  So if we call Py_Finalize here, we end
-// up with Py_Finalize being called from within Py_Finalize, which results in a
-// seg fault. Since this function only gets called when lldb is shutting down
-// and going away anyway, the fact that we don't actually call Py_Finalize
+// ScriptInterpreterPythonImpl::Terminate.  So if we call Py_Finalize here, we
+// end up with Py_Finalize being called from within Py_Finalize, which results
+// in a seg fault. Since this function only gets called when lldb is shutting
+// down and going away anyway, the fact that we don't actually call Py_Finalize
 // should not cause any problems (everything should shut down/go away anyway
 // when the process exits).
 //
-// void ScriptInterpreterPython::Terminate() { Py_Finalize (); }
+// void ScriptInterpreterPythonImpl::Terminate() { Py_Finalize (); }
 
 #endif // LLDB_DISABLE_PYTHON

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h

+//===-- ScriptInterpreterPythonImpl.h ---------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifdef LLDB_DISABLE_PYTHON
+
+// Python is disabled in this build
+
+#else
+
+#include "lldb-python.h"
+
+#include "PythonDataObjects.h"
+#include "ScriptInterpreterPython.h"
+
+#include "lldb/Host/Terminal.h"
+#include "lldb/Utility/StreamString.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace lldb_private {
+class IOHandlerPythonInterpreter;
+class ScriptInterpreterPythonImpl : public ScriptInterpreterPython {
+public:
+  friend class IOHandlerPythonInterpreter;
+
+  ScriptInterpreterPythonImpl(CommandInterpreter &interpreter);
+
+  ~ScriptInterpreterPythonImpl() override;
+
+  bool Interrupt() override;
+
+  bool ExecuteOneLine(
+      llvm::StringRef command, CommandReturnObject *result,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  void ExecuteInterpreterLoop() override;
+
+  bool ExecuteOneLineWithReturn(
+      llvm::StringRef in_string,
+      ScriptInterpreter::ScriptReturnType return_type, void *ret_value,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  lldb_private::Status ExecuteMultipleLines(
+      const char *in_string,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  Status
+  ExportFunctionDefinitionToInterpreter(StringList &function_def) override;
+
+  bool GenerateTypeScriptFunction(StringList &input, std::string &output,
+                                  const void *name_token = nullptr) override;
+
+  bool GenerateTypeSynthClass(StringList &input, std::string &output,
+                              const void *name_token = nullptr) override;
+
+  bool GenerateTypeSynthClass(const char *oneliner, std::string &output,
+                              const void *name_token = nullptr) override;
+
+  // use this if the function code is just a one-liner script
+  bool GenerateTypeScriptFunction(const char *oneliner, std::string &output,
+                                  const void *name_token = nullptr) override;
+
+  bool GenerateScriptAliasFunction(StringList &input,
+                                   std::string &output) override;
+
+  StructuredData::ObjectSP
+  CreateSyntheticScriptedProvider(const char *class_name,
+                                  lldb::ValueObjectSP valobj) override;
+
+  StructuredData::GenericSP
+  CreateScriptCommandObject(const char *class_name) override;
+
+  StructuredData::ObjectSP
+  CreateScriptedThreadPlan(const char *class_name,
+                           lldb::ThreadPlanSP thread_plan) override;
+
+  bool ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp,
+                                      Event *event,
+                                      bool &script_error) override;
+
+  bool ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp,
+                                    Event *event, bool &script_error) override;
+
+  bool ScriptedThreadPlanIsStale(StructuredData::ObjectSP implementor_sp,
+                                 bool &script_error) override;
+
+  lldb::StateType
+  ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp,
+                                bool &script_error) override;
+
+  StructuredData::GenericSP
+  CreateScriptedBreakpointResolver(const char *class_name,
+                                   StructuredDataImpl *args_data,
+                                   lldb::BreakpointSP &bkpt_sp) override;
+  bool ScriptedBreakpointResolverSearchCallback(
+      StructuredData::GenericSP implementor_sp,
+      SymbolContext *sym_ctx) override;
+
+  lldb::SearchDepth ScriptedBreakpointResolverSearchDepth(
+      StructuredData::GenericSP implementor_sp) override;
+
+  StructuredData::GenericSP
+  CreateFrameRecognizer(const char *class_name) override;
+
+  lldb::ValueObjectListSP
+  GetRecognizedArguments(const StructuredData::ObjectSP &implementor,
+                         lldb::StackFrameSP frame_sp) override;
+
+  StructuredData::GenericSP
+  OSPlugin_CreatePluginObject(const char *class_name,
+                              lldb::ProcessSP process_sp) override;
+
+  StructuredData::DictionarySP
+  OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp) override;
+
+  StructuredData::ArraySP
+  OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp) override;
+
+  StructuredData::StringSP
+  OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp,
+                               lldb::tid_t thread_id) override;
+
+  StructuredData::DictionarySP
+  OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp,
+                        lldb::tid_t tid, lldb::addr_t context) override;
+
+  StructuredData::ObjectSP
+  LoadPluginModule(const FileSpec &file_spec,
+                   lldb_private::Status &error) override;
+
+  StructuredData::DictionarySP
+  GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target,
+                     const char *setting_name,
+                     lldb_private::Status &error) override;
+
+  size_t CalculateNumChildren(const StructuredData::ObjectSP &implementor,
+                              uint32_t max) override;
+
+  lldb::ValueObjectSP
+  GetChildAtIndex(const StructuredData::ObjectSP &implementor,
+                  uint32_t idx) override;
+
+  int GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor,
+                              const char *child_name) override;
+
+  bool UpdateSynthProviderInstance(
+      const StructuredData::ObjectSP &implementor) override;
+
+  bool MightHaveChildrenSynthProviderInstance(
+      const StructuredData::ObjectSP &implementor) override;
+
+  lldb::ValueObjectSP
+  GetSyntheticValue(const StructuredData::ObjectSP &implementor) override;
+
+  ConstString
+  GetSyntheticTypeName(const StructuredData::ObjectSP &implementor) override;
+
+  bool
+  RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
+                        ScriptedCommandSynchronicity synchronicity,
+                        lldb_private::CommandReturnObject &cmd_retobj,
+                        Status &error,
+                        const lldb_private::ExecutionContext &exe_ctx) override;
+
+  bool RunScriptBasedCommand(
+      StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
+      ScriptedCommandSynchronicity synchronicity,
+      lldb_private::CommandReturnObject &cmd_retobj, Status &error,
+      const lldb_private::ExecutionContext &exe_ctx) override;
+
+  Status GenerateFunction(const char *signature,
+                          const StringList &input) override;
+
+  Status GenerateBreakpointCommandCallbackData(StringList &input,
+                                               std::string &output) override;
+
+  bool GenerateWatchpointCommandCallbackData(StringList &input,
+                                             std::string &output) override;
+
+  bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj,
+                          StructuredData::ObjectSP &callee_wrapper_sp,
+                          const TypeSummaryOptions &options,
+                          std::string &retval) override;
+
+  void Clear() override;
+
+  bool GetDocumentationForItem(const char *item, std::string &dest) override;
+
+  bool GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp,
+                                    std::string &dest) override;
+
+  uint32_t
+  GetFlagsForCommandObject(StructuredData::GenericSP cmd_obj_sp) override;
+
+  bool GetLongHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp,
+                                   std::string &dest) override;
+
+  bool CheckObjectExists(const char *name) override {
+    if (!name || !name[0])
+      return false;
+    std::string temp;
+    return GetDocumentationForItem(name, temp);
+  }
+
+  bool RunScriptFormatKeyword(const char *impl_function, Process *process,
+                              std::string &output, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
+                              std::string &output, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, Target *target,
+                              std::string &output, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, StackFrame *frame,
+                              std::string &output, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, ValueObject *value,
+                              std::string &output, Status &error) override;
+
+  bool
+  LoadScriptingModule(const char *filename, bool can_reload, bool init_session,
+                      lldb_private::Status &error,
+                      StructuredData::ObjectSP *module_sp = nullptr) override;
+
+  bool IsReservedWord(const char *word) override;
+
+  std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock() override;
+
+  void CollectDataForBreakpointCommandCallback(
+      std::vector<BreakpointOptions *> &bp_options_vec,
+      CommandReturnObject &result) override;
+
+  void
+  CollectDataForWatchpointCommandCallback(WatchpointOptions *wp_options,
+                                          CommandReturnObject &result) override;
+
+  /// Set the callback body text into the callback for the breakpoint.
+  Status SetBreakpointCommandCallback(BreakpointOptions *bp_options,
+                                      const char *callback_body) override;
+
+  void SetBreakpointCommandCallbackFunction(BreakpointOptions *bp_options,
+                                            const char *function_name) override;
+
+  /// This one is for deserialization:
+  Status SetBreakpointCommandCallback(
+      BreakpointOptions *bp_options,
+      std::unique_ptr<BreakpointOptions::CommandData> &data_up) override;
+
+  /// Set a one-liner as the callback for the watchpoint.
+  void SetWatchpointCommandCallback(WatchpointOptions *wp_options,
+                                    const char *oneliner) override;
+
+  void ResetOutputFileHandle(FILE *new_fh) override;
+
+  const char *GetDictionaryName() { return m_dictionary_name.c_str(); }
+
+  PyThreadState *GetThreadState() { return m_command_thread_state; }
+
+  void SetThreadState(PyThreadState *s) {
+    if (s)
+      m_command_thread_state = s;
+  }
+
+  //----------------------------------------------------------------------
+  // IOHandlerDelegate
+  //----------------------------------------------------------------------
+  void IOHandlerActivated(IOHandler &io_handler, bool interactive) override;
+
+  void IOHandlerInputComplete(IOHandler &io_handler,
+                              std::string &data) override;
+
+  static lldb::ScriptInterpreterSP
+  CreateInstance(CommandInterpreter &interpreter);
+
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+
+  class Locker : public ScriptInterpreterLocker {
+  public:
+    enum OnEntry {
+      AcquireLock = 0x0001,
+      InitSession = 0x0002,
+      InitGlobals = 0x0004,
+      NoSTDIN = 0x0008
+    };
+
+    enum OnLeave {
+      FreeLock = 0x0001,
+      FreeAcquiredLock = 0x0002, // do not free the lock if we already held it
+                                 // when calling constructor
+      TearDownSession = 0x0004
+    };
+
+    Locker(ScriptInterpreterPythonImpl *py_interpreter = nullptr,
+           uint16_t on_entry = AcquireLock | InitSession,
+           uint16_t on_leave = FreeLock | TearDownSession, FILE *in = nullptr,
+           FILE *out = nullptr, FILE *err = nullptr);
+
+    ~Locker() override;
+
+  private:
+    bool DoAcquireLock();
+
+    bool DoInitSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
+
+    bool DoFreeLock();
+
+    bool DoTearDownSession();
+
+    bool m_teardown_session;
+    ScriptInterpreterPythonImpl *m_python_interpreter;
+    //      FILE*                    m_tmp_fh;
+    PyGILState_STATE m_GILState;
+  };
+
+  static bool BreakpointCallbackFunction(void *baton,
+                                         StoppointCallbackContext *context,
+                                         lldb::user_id_t break_id,
+                                         lldb::user_id_t break_loc_id);
+  static bool WatchpointCallbackFunction(void *baton,
+                                         StoppointCallbackContext *context,
+                                         lldb::user_id_t watch_id);
+  static void InitializePrivate();
+
+  class SynchronicityHandler {
+  private:
+    lldb::DebuggerSP m_debugger_sp;
+    ScriptedCommandSynchronicity m_synch_wanted;
+    bool m_old_asynch;
+
+  public:
+    SynchronicityHandler(lldb::DebuggerSP, ScriptedCommandSynchronicity);
+
+    ~SynchronicityHandler();
+  };
+
+  enum class AddLocation { Beginning, End };
+
+  static void AddToSysPath(AddLocation location, std::string path);
+
+  bool EnterSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
+
+  void LeaveSession();
+
+  void SaveTerminalState(int fd);
+
+  void RestoreTerminalState();
+
+  uint32_t IsExecutingPython() const { return m_lock_count > 0; }
+
+  uint32_t IncrementLockCount() { return ++m_lock_count; }
+
+  uint32_t DecrementLockCount() {
+    if (m_lock_count > 0)
+      --m_lock_count;
+    return m_lock_count;
+  }
+
+  enum ActiveIOHandler {
+    eIOHandlerNone,
+    eIOHandlerBreakpoint,
+    eIOHandlerWatchpoint
+  };
+
+  PythonObject &GetMainModule();
+
+  PythonDictionary &GetSessionDictionary();
+
+  PythonDictionary &GetSysModuleDictionary();
+
+  bool GetEmbeddedInterpreterModuleObjects();
+
+  bool SetStdHandle(File &file, const char *py_name, PythonFile &save_file,
+                    const char *mode);
+
+  PythonFile m_saved_stdin;
+  PythonFile m_saved_stdout;
+  PythonFile m_saved_stderr;
+  PythonObject m_main_module;
+  PythonDictionary m_session_dict;
+  PythonDictionary m_sys_module_dict;
+  PythonObject m_run_one_line_function;
+  PythonObject m_run_one_line_str_global;
+  std::string m_dictionary_name;
+  TerminalState m_terminal_state;
+  ActiveIOHandler m_active_io_handler;
+  bool m_session_is_active;
+  bool m_pty_slave_is_open;
+  bool m_valid_session;
+  uint32_t m_lock_count;
+  PyThreadState *m_command_thread_state;
+};
+
+class IOHandlerPythonInterpreter : public IOHandler {
+public:
+  IOHandlerPythonInterpreter(Debugger &debugger,
+                             ScriptInterpreterPythonImpl *python)
+      : IOHandler(debugger, IOHandler::Type::PythonInterpreter),
+        m_python(python) {}
+
+  ~IOHandlerPythonInterpreter() override {}
+
+  ConstString GetControlSequence(char ch) override {
+    if (ch == 'd')
+      return ConstString("quit()\n");
+    return ConstString();
+  }
+
+  void Run() override {
+    if (m_python) {
+      int stdin_fd = GetInputFD();
+      if (stdin_fd >= 0) {
+        Terminal terminal(stdin_fd);
+        TerminalState terminal_state;
+        const bool is_a_tty = terminal.IsATerminal();
+
+        if (is_a_tty) {
+          terminal_state.Save(stdin_fd, false);
+          terminal.SetCanonical(false);
+          terminal.SetEcho(true);
+        }
+
+        ScriptInterpreterPythonImpl::Locker locker(
+            m_python,
+            ScriptInterpreterPythonImpl::Locker::AcquireLock |
+                ScriptInterpreterPythonImpl::Locker::InitSession |
+                ScriptInterpreterPythonImpl::Locker::InitGlobals,
+            ScriptInterpreterPythonImpl::Locker::FreeAcquiredLock |
+                ScriptInterpreterPythonImpl::Locker::TearDownSession);
+
+        // The following call drops into the embedded interpreter loop and
+        // stays there until the user chooses to exit from the Python
+        // interpreter. This embedded interpreter will, as any Python code that
+        // performs I/O, unlock the GIL before a system call that can hang, and
+        // lock it when the syscall has returned.
+
+        // We need to surround the call to the embedded interpreter with calls
+        // to PyGILState_Ensure and PyGILState_Release (using the Locker
+        // above). This is because Python has a global lock which must be held
+        // whenever we want to touch any Python objects. Otherwise, if the user
+        // calls Python code, the interpreter state will be off, and things
+        // could hang (it's happened before).
+
+        StreamString run_string;
+        run_string.Printf("run_python_interpreter (%s)",
+                          m_python->GetDictionaryName());
+        PyRun_SimpleString(run_string.GetData());
+
+        if (is_a_tty)
+          terminal_state.Restore();
+      }
+    }
+    SetIsDone(true);
+  }
+
+  void Cancel() override {}
+
+  bool Interrupt() override { return m_python->Interrupt(); }
+
+  void GotEOF() override {}
+
+protected:
+  ScriptInterpreterPythonImpl *m_python;
+};
+
+} // namespace lldb_private
+
+#endif

lldb/trunk/source/Plugins/ScriptInterpreter/Python/lldb-python.h

 // features.h will define _POSIX_C_SOURCE if _GNU_SOURCE is defined.  This value
 // may be different from the value that Python defines it to be which results
 // in a warning.  Undefine _POSIX_C_SOURCE before including Python.h  The same
 // holds for _XOPEN_SOURCE.
 #undef _POSIX_C_SOURCE
 #undef _XOPEN_SOURCE
 #endif
 
+// Include locale before Python so _PY_PORT_CTYPE_UTF8_ISSUE doesn't cause
+// macro redefinitions.
+#if defined(__APPLE__)
+#include <locale>
+#endif
+
 // Include python for non windows machines
 #include <Python.h>
 #endif // LLDB_DISABLE_PYTHON
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H