[lldb/Bindings] Move bindings into their own subdirectory

All the code required to generate the language bindings for Python and
Lua lives under scripts, even though the majority of this code aren't
scripts at all, and surrounded by scripts that are totally unrelated.

I've reorganized these files and moved everything related to the
language bindings into a new top-level directory named bindings. This
makes the corresponding files self contained and much more discoverable.

Differential revision: https://reviews.llvm.org/D72437

5 files changed, 0 insertions, 2347 deletions

diff --git a/lldb/scripts/Python/createPythonInit.py b/lldb/scripts/Python/createPythonInit.py
deleted file mode 100644
index 3deb9159b70..00000000000
--- a/lldb/scripts/Python/createPythonInit.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import os
-import sys
-
-pkgRelDir = sys.argv[1]
-pkgFiles = sys.argv[2:]
-
-getFileName = lambda f: os.path.splitext(os.path.basename(f))[0]
-importNames = ', '.join('"{}"'.format(getFileName(f)) for f in pkgFiles)
-
-script = """__all__ = [{import_names}]
-for x in __all__:
-  __import__('lldb.{pkg_name}.' + x)
-""".format(import_names=importNames, pkg_name=pkgRelDir.replace("/", "."))
-
-pkgIniFile = os.path.normpath(os.path.join(pkgRelDir, "__init__.py"))
-with open(pkgIniFile, "w") as f:
-    f.write(script)
diff --git a/lldb/scripts/Python/python-extensions.swig b/lldb/scripts/Python/python-extensions.swig
deleted file mode 100644
index 0b23fdd4000..00000000000
--- a/lldb/scripts/Python/python-extensions.swig
+++ /dev/null
@@ -1,592 +0,0 @@
-%extend lldb::SBBreakpoint {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBBroadcaster {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBCommandReturnObject {
-        /* the write() and flush() calls are not part of the SB API proper, and are solely for Python usage
-        they are meant to make an SBCommandReturnObject into a file-like object so that instructions of the sort
-        print >>sb_command_return_object, "something"
-        will work correctly */
-
-        void lldb::SBCommandReturnObject::write (const char* str)
-        {
-            if (str)
-                $self->Printf("%s",str);
-        }
-        void lldb::SBCommandReturnObject::flush ()
-        {}
-}
-
-%extend lldb::SBCompileUnit {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBDeclaration {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBFunction {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBLineEntry {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBModule {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBSection {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-%extend lldb::SBStream {
-        /* the write() and flush() calls are not part of the SB API proper, and are solely for Python usage
-        they are meant to make an SBStream into a file-like object so that instructions of the sort
-        print >>sb_stream, "something"
-        will work correctly */
-
-        void lldb::SBStream::write (const char* str)
-        {
-            if (str)
-                $self->Printf("%s",str);
-        }
-        void lldb::SBStream::flush ()
-        {}
-}
-%extend lldb::SBSymbol {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBTarget {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBTypeFilter {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBTypeNameSpecifier {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBTypeSummary {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBTypeSynthetic {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%extend lldb::SBThread {
-    %pythoncode %{
-        def __eq__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return False
-
-            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
-
-        def __ne__(self, rhs):
-            if not isinstance(rhs, type(self)):
-                return True
-
-            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
-    %}
-}
-
-%pythoncode %{
-
-def command(command_name=None, doc=None):
-    import lldb
-    """A decorator function that registers an LLDB command line
-        command that is bound to the function it is attached to."""
-    def callable(function):
-        """Registers an lldb command for the decorated function."""
-        command = "command script add -f %s.%s %s" % (function.__module__, function.__name__, command_name or function.__name__)
-        lldb.debugger.HandleCommand(command)
-        if doc:
-            function.__doc__ = doc
-        return function
-
-    return callable
-
-class declaration(object):
-    '''A class that represents a source declaration location with file, line and column.'''
-    def __init__(self, file, line, col):
-        self.file = file
-        self.line = line
-        self.col = col
-
-class value_iter(object):
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        if self.index >= self.length:
-            raise StopIteration()
-        child_sbvalue = self.sbvalue.GetChildAtIndex(self.index)
-        self.index += 1
-        return value(child_sbvalue)
-
-    def next(self):
-        return self.__next__()
-
-    def __init__(self,value):
-        self.index = 0
-        self.sbvalue = value
-        if type(self.sbvalue) is value:
-            self.sbvalue = self.sbvalue.sbvalue
-        self.length = self.sbvalue.GetNumChildren()
-
-class value(object):
-    '''A class designed to wrap lldb.SBValue() objects so the resulting object
-    can be used as a variable would be in code. So if you have a Point structure
-    variable in your code in the current frame named "pt", you can initialize an instance
-    of this class with it:
-
-    pt = lldb.value(lldb.frame.FindVariable("pt"))
-    print pt
-    print pt.x
-    print pt.y
-
-    pt = lldb.value(lldb.frame.FindVariable("rectangle_array"))
-    print rectangle_array[12]
-    print rectangle_array[5].origin.x'''
-    def __init__(self, sbvalue):
-        self.sbvalue = sbvalue
-
-    def __nonzero__(self):
-        return self.sbvalue.__nonzero__()
-
-    def __bool__(self):
-        return self.sbvalue.__bool__()
-
-    def __str__(self):
-        return self.sbvalue.__str__()
-
-    def __getitem__(self, key):
-        # Allow array access if this value has children...
-        if type(key) is value:
-            key = int(key)
-        if type(key) is int:
-            child_sbvalue = (self.sbvalue.GetValueForExpressionPath("[%i]" % key))
-            if child_sbvalue and child_sbvalue.IsValid():
-                return value(child_sbvalue)
-            raise IndexError("Index '%d' is out of range" % key)
-        raise TypeError("No array item of type %s" % str(type(key)))
-
-    def __iter__(self):
-        return value_iter(self.sbvalue)
-
-    def __getattr__(self, name):
-        child_sbvalue = self.sbvalue.GetChildMemberWithName (name)
-        if child_sbvalue and child_sbvalue.IsValid():
-            return value(child_sbvalue)
-        raise AttributeError("Attribute '%s' is not defined" % name)
-
-    def __add__(self, other):
-        return int(self) + int(other)
-
-    def __sub__(self, other):
-        return int(self) - int(other)
-
-    def __mul__(self, other):
-        return int(self) * int(other)
-
-    def __floordiv__(self, other):
-        return int(self) // int(other)
-
-    def __mod__(self, other):
-        return int(self) % int(other)
-
-    def __divmod__(self, other):
-        return int(self) % int(other)
-
-    def __pow__(self, other):
-        return int(self) ** int(other)
-
-    def __lshift__(self, other):
-        return int(self) << int(other)
-
-    def __rshift__(self, other):
-        return int(self) >> int(other)
-
-    def __and__(self, other):
-        return int(self) & int(other)
-
-    def __xor__(self, other):
-        return int(self) ^ int(other)
-
-    def __or__(self, other):
-        return int(self) | int(other)
-
-    def __div__(self, other):
-        return int(self) / int(other)
-
-    def __truediv__(self, other):
-        return int(self) / int(other)
-
-    def __iadd__(self, other):
-        result = self.__add__(other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __isub__(self, other):
-        result = self.__sub__(other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __imul__(self, other):
-        result = self.__mul__(other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __idiv__(self, other):
-        result = self.__div__(other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __itruediv__(self, other):
-        result = self.__truediv__(other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __ifloordiv__(self, other):
-        result =  self.__floordiv__(self, other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __imod__(self, other):
-        result =  self.__and__(self, other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __ipow__(self, other):
-        result = self.__pow__(self, other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __ipow__(self, other, modulo):
-        result = self.__pow__(self, other, modulo)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __ilshift__(self, other):
-        result = self.__lshift__(other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __irshift__(self, other):
-        result =  self.__rshift__(other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __iand__(self, other):
-        result =  self.__and__(self, other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __ixor__(self, other):
-        result =  self.__xor__(self, other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __ior__(self, other):
-        result =  self.__ior__(self, other)
-        self.sbvalue.SetValueFromCString (str(result))
-        return result
-
-    def __neg__(self):
-        return -int(self)
-
-    def __pos__(self):
-        return +int(self)
-
-    def __abs__(self):
-        return abs(int(self))
-
-    def __invert__(self):
-        return ~int(self)
-
-    def __complex__(self):
-        return complex (int(self))
-
-    def __int__(self):
-        is_num,is_sign = is_numeric_type(self.sbvalue.GetType().GetCanonicalType().GetBasicType())
-        if is_num and not is_sign: return self.sbvalue.GetValueAsUnsigned()
-        return self.sbvalue.GetValueAsSigned()
-
-    def __long__(self):
-        return self.__int__()
-
-    def __float__(self):
-        return float (self.sbvalue.GetValueAsSigned())
-
-    def __oct__(self):
-        return '0%o' % self.sbvalue.GetValueAsUnsigned()
-
-    def __hex__(self):
-        return '0x%x' % self.sbvalue.GetValueAsUnsigned()
-
-    def __len__(self):
-        return self.sbvalue.GetNumChildren()
-
-    def __eq__(self, other):
-        if type(other) is int:
-                return int(self) == other
-        elif type(other) is str:
-                return str(self) == other
-        elif type(other) is value:
-                self_err = SBError()
-                other_err = SBError()
-                self_val = self.sbvalue.GetValueAsUnsigned(self_err)
-                if self_err.fail:
-                        raise ValueError("unable to extract value of self")
-                other_val = other.sbvalue.GetValueAsUnsigned(other_err)
-                if other_err.fail:
-                        raise ValueError("unable to extract value of other")
-                return self_val == other_val
-        raise TypeError("Unknown type %s, No equality operation defined." % str(type(other)))
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-%}
-
-%pythoncode %{
-
-class SBSyntheticValueProvider(object):
-    def __init__(self,valobj):
-        pass
-
-    def num_children(self):
-        return 0
-
-    def get_child_index(self,name):
-        return None
-
-    def get_child_at_index(self,idx):
-        return None
-
-    def update(self):
-        pass
-
-    def has_children(self):
-        return False
-
-
-%}
-
-%pythoncode %{
-
-# given an lldb.SBBasicType it returns a tuple
-# (is_numeric, is_signed)
-# the value of is_signed is undefined if is_numeric == false
-def is_numeric_type(basic_type):
-    if basic_type == eBasicTypeInvalid: return (False,False)
-    if basic_type == eBasicTypeVoid: return (False,False)
-    if basic_type == eBasicTypeChar: return (True,False)
-    if basic_type == eBasicTypeSignedChar: return (True,True)
-    if basic_type == eBasicTypeUnsignedChar: return (True,False)
-    if basic_type == eBasicTypeWChar: return (True,False)
-    if basic_type == eBasicTypeSignedWChar: return (True,True)
-    if basic_type == eBasicTypeUnsignedWChar: return (True,False)
-    if basic_type == eBasicTypeChar16: return (True,False)
-    if basic_type == eBasicTypeChar32: return (True,False)
-    if basic_type == eBasicTypeShort: return (True,True)
-    if basic_type == eBasicTypeUnsignedShort: return (True,False)
-    if basic_type == eBasicTypeInt: return (True,True)
-    if basic_type == eBasicTypeUnsignedInt: return (True,False)
-    if basic_type == eBasicTypeLong: return (True,True)
-    if basic_type == eBasicTypeUnsignedLong: return (True,False)
-    if basic_type == eBasicTypeLongLong: return (True,True)
-    if basic_type == eBasicTypeUnsignedLongLong: return (True,False)
-    if basic_type == eBasicTypeInt128: return (True,True)
-    if basic_type == eBasicTypeUnsignedInt128: return (True,False)
-    if basic_type == eBasicTypeBool: return (False,False)
-    if basic_type == eBasicTypeHalf: return (True,True)
-    if basic_type == eBasicTypeFloat: return (True,True)
-    if basic_type == eBasicTypeDouble: return (True,True)
-    if basic_type == eBasicTypeLongDouble: return (True,True)
-    if basic_type == eBasicTypeFloatComplex: return (True,True)
-    if basic_type == eBasicTypeDoubleComplex: return (True,True)
-    if basic_type == eBasicTypeLongDoubleComplex: return (True,True)
-    if basic_type == eBasicTypeObjCID: return (False,False)
-    if basic_type == eBasicTypeObjCClass: return (False,False)
-    if basic_type == eBasicTypeObjCSel: return (False,False)
-    if basic_type == eBasicTypeNullPtr: return (False,False)
-    #if basic_type == eBasicTypeOther:
-    return (False,False)
-
-%}
diff --git a/lldb/scripts/Python/python-swigsafecast.swig b/lldb/scripts/Python/python-swigsafecast.swig
deleted file mode 100644
index d5cafbfa67c..00000000000
--- a/lldb/scripts/Python/python-swigsafecast.swig
+++ /dev/null
@@ -1,154 +0,0 @@
-// leaving this undefined ensures we will get a linker error if we try to use SBTypeToSWIGWrapper()
-// for a type for which we did not specialze this function
-template <typename SBClass>
-PyObject*
-SBTypeToSWIGWrapper (SBClass* sb_object);
-
-template <typename SBClass>
-PyObject*
-SBTypeToSWIGWrapper (SBClass& sb_object)
-{
-    return SBTypeToSWIGWrapper(&sb_object);
-}
-
-template <typename SBClass>
-PyObject*
-SBTypeToSWIGWrapper (const SBClass& sb_object)
-{
-    return SBTypeToSWIGWrapper(&sb_object);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (PyObject* py_object)
-{
-    return py_object;
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (unsigned int* c_int)
-{
-    if (!c_int)
-        return NULL;
-    return PyInt_FromLong(*c_int);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBEvent* event_sb)
-{
-    return SWIG_NewPointerObj((void *) event_sb, SWIGTYPE_p_lldb__SBEvent, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBProcess* process_sb)
-{
-    return SWIG_NewPointerObj((void *) process_sb, SWIGTYPE_p_lldb__SBProcess, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBThread* thread_sb)
-{
-    return SWIG_NewPointerObj((void *) thread_sb, SWIGTYPE_p_lldb__SBThread, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBThreadPlan* thread_plan_sb)
-{
-    return SWIG_NewPointerObj((void *) thread_plan_sb, SWIGTYPE_p_lldb__SBThreadPlan, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBTarget* target_sb)
-{
-    return SWIG_NewPointerObj((void *) target_sb, SWIGTYPE_p_lldb__SBTarget, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBFrame* frame_sb)
-{
-    return SWIG_NewPointerObj((void *) frame_sb, SWIGTYPE_p_lldb__SBFrame, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBDebugger* debugger_sb)
-{
-    return SWIG_NewPointerObj((void *) debugger_sb, SWIGTYPE_p_lldb__SBDebugger, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBBreakpoint* breakpoint_sb)
-{
-    return SWIG_NewPointerObj((void *) breakpoint_sb, SWIGTYPE_p_lldb__SBBreakpoint, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBWatchpoint* watchpoint_sb)
-{
-    return SWIG_NewPointerObj((void *) watchpoint_sb, SWIGTYPE_p_lldb__SBWatchpoint, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBBreakpointLocation* breakpoint_location_sb)
-{
-    return SWIG_NewPointerObj((void *) breakpoint_location_sb, SWIGTYPE_p_lldb__SBBreakpointLocation, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBBreakpointName* breakpoint_name_sb)
-{
-    return SWIG_NewPointerObj((void *) breakpoint_name_sb, SWIGTYPE_p_lldb__SBBreakpointName, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBValue* value_sb)
-{
-    return SWIG_NewPointerObj((void *) value_sb, SWIGTYPE_p_lldb__SBValue, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBCommandReturnObject* cmd_ret_obj_sb)
-{
-    return SWIG_NewPointerObj((void *) cmd_ret_obj_sb, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBExecutionContext* ctx_sb)
-{
-    return SWIG_NewPointerObj((void *) ctx_sb, SWIGTYPE_p_lldb__SBExecutionContext, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBTypeSummaryOptions* summary_options_sb)
-{
-    return SWIG_NewPointerObj((void *) summary_options_sb, SWIGTYPE_p_lldb__SBTypeSummaryOptions, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBStructuredData* structured_data_sb)
-{
-    return SWIG_NewPointerObj((void *) structured_data_sb, SWIGTYPE_p_lldb__SBStructuredData, 0);
-}
-
-template <>
-PyObject*
-SBTypeToSWIGWrapper (lldb::SBSymbolContext* sym_ctx_sb)
-{
-    return SWIG_NewPointerObj((void *) sym_ctx_sb, SWIGTYPE_p_lldb__SBSymbolContext, 0);
-}
diff --git a/lldb/scripts/Python/python-typemaps.swig b/lldb/scripts/Python/python-typemaps.swig
deleted file mode 100644
index 2ba380bdf0d..00000000000
--- a/lldb/scripts/Python/python-typemaps.swig
+++ /dev/null
@@ -1,510 +0,0 @@
-/* Typemap definitions, to allow SWIG to properly handle 'char**' data types. */
-
-%typemap(in) char ** {
-  /* Check if is a list  */
-  if (PythonList::Check($input)) {
-    PythonList list(PyRefType::Borrowed, $input);
-    int size = list.GetSize();
-    int i = 0;
-    $1 = (char**)malloc((size+1)*sizeof(char*));
-    for (i = 0; i < size; i++) {
-      PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
-      if (!py_str.IsAllocated()) {
-        PyErr_SetString(PyExc_TypeError,"list must contain strings");
-        free($1);
-        return nullptr;
-      }
-
-      $1[i] = const_cast<char*>(py_str.GetString().data());
-    }
-    $1[i] = 0;
-  } else if ($input == Py_None) {
-    $1 =  NULL;
-  } else {
-    PyErr_SetString(PyExc_TypeError,"not a list");
-    return NULL;
-  }
-}
-
-%typemap(typecheck) char ** {
-  /* Check if is a list  */
-  $1 = 1;
-  if (PythonList::Check($input)) {
-    PythonList list(PyRefType::Borrowed, $input);
-    int size = list.GetSize();
-    int i = 0;
-    for (i = 0; i < size; i++) {
-      PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
-      if (!s.IsAllocated()) { $1 = 0; }
-    }
-  }
-  else
-  {
-    $1 = ( ($input == Py_None) ? 1 : 0);
-  }
-}
-
-%typemap(freearg) char** {
-  free((char *) $1);
-}
-
-%typemap(out) char** {
-  int len;
-  int i;
-  len = 0;
-  while ($1[len]) len++;
-  PythonList list(len);
-  for (i = 0; i < len; i++)
-    list.SetItemAtIndex(i, PythonString($1[i]));
-  $result = list.release();
-}
-
-
-%typemap(in) lldb::tid_t {
-  if (PythonInteger::Check($input))
-  {
-    PythonInteger py_int(PyRefType::Borrowed, $input);
-    $1 = static_cast<lldb::tid_t>(py_int.GetInteger());
-  }
-  else
-  {
-    PyErr_SetString(PyExc_ValueError, "Expecting an integer");
-    return nullptr;
-  }
-}
-
-%typemap(in) lldb::StateType {
-  if (PythonInteger::Check($input))
-  {
-    PythonInteger py_int(PyRefType::Borrowed, $input);
-    int64_t state_type_value = py_int.GetInteger() ;
-
-    if (state_type_value > lldb::StateType::kLastStateType) {
-      PyErr_SetString(PyExc_ValueError, "Not a valid StateType value");
-      return nullptr;
-    }
-    $1 = static_cast<lldb::StateType>(state_type_value);
-  }
-  else
-  {
-    PyErr_SetString(PyExc_ValueError, "Expecting an integer");
-    return nullptr;
-  }
-}
-
-/* Typemap definitions to allow SWIG to properly handle char buffer. */
-
-// typemap for a char buffer
-// See also SBThread::GetStopDescription.
-%typemap(in) (char *dst, size_t dst_len) {
-   if (!PyInt_Check($input)) {
-       PyErr_SetString(PyExc_ValueError, "Expecting an integer");
-       return NULL;
-   }
-   $2 = PyInt_AsLong($input);
-   if ($2 <= 0) {
-       PyErr_SetString(PyExc_ValueError, "Positive integer expected");
-       return NULL;
-   }
-   $1 = (char *) malloc($2);
-}
-// SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
-// as char data instead of byte data.
-%typemap(in) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
-
-// Return the char buffer.  Discarding any previous return result
-// See also SBThread::GetStopDescription.
-%typemap(argout) (char *dst, size_t dst_len) {
-   Py_XDECREF($result);   /* Blow away any previous result */
-   if (result == 0) {
-      PythonString string("");
-      $result = string.release();
-      Py_INCREF($result);
-   } else {
-      llvm::StringRef ref(static_cast<const char*>($1), result);
-      PythonString string(ref);
-      $result = string.release();
-   }
-   free($1);
-}
-// SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
-// as char data instead of byte data.
-%typemap(argout) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
-
-
-// typemap for an outgoing buffer
-// See also SBEvent::SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len).
-// Ditto for SBProcess::PutSTDIN(const char *src, size_t src_len).
-%typemap(in) (const char *cstr, uint32_t cstr_len),
-             (const char *src, size_t src_len) {
-   if (PythonString::Check($input)) {
-      PythonString str(PyRefType::Borrowed, $input);
-      $1 = (char*)str.GetString().data();
-      $2 = str.GetSize();
-   }
-   else if(PythonByteArray::Check($input)) {
-      PythonByteArray bytearray(PyRefType::Borrowed, $input);
-      $1 = (char*)bytearray.GetBytes().data();
-      $2 = bytearray.GetSize();
-   }
-   else if (PythonBytes::Check($input)) {
-      PythonBytes bytes(PyRefType::Borrowed, $input);
-      $1 = (char*)bytes.GetBytes().data();
-      $2 = bytes.GetSize();
-   }
-   else {
-      PyErr_SetString(PyExc_ValueError, "Expecting a string");
-      return NULL;
-   }
-}
-// For SBProcess::WriteMemory, SBTarget::GetInstructions and SBDebugger::DispatchInput.
-%typemap(in) (const void *buf, size_t size),
-             (const void *data, size_t data_len) {
-   if (PythonString::Check($input)) {
-      PythonString str(PyRefType::Borrowed, $input);
-      $1 = (void*)str.GetString().data();
-      $2 = str.GetSize();
-   }
-   else if(PythonByteArray::Check($input)) {
-      PythonByteArray bytearray(PyRefType::Borrowed, $input);
-      $1 = (void*)bytearray.GetBytes().data();
-      $2 = bytearray.GetSize();
-   }
-   else if (PythonBytes::Check($input)) {
-      PythonBytes bytes(PyRefType::Borrowed, $input);
-      $1 = (void*)bytes.GetBytes().data();
-      $2 = bytes.GetSize();
-   }
-   else {
-      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
-      return NULL;
-   }
-}
-
-// typemap for an incoming buffer
-// See also SBProcess::ReadMemory.
-%typemap(in) (void *buf, size_t size) {
-   if (PyInt_Check($input)) {
-      $2 = PyInt_AsLong($input);
-   } else if (PyLong_Check($input)) {
-      $2 = PyLong_AsLong($input);
-   } else {
-      PyErr_SetString(PyExc_ValueError, "Expecting an integer or long object");
-      return NULL;
-   }
-   if ($2 <= 0) {
-       PyErr_SetString(PyExc_ValueError, "Positive integer expected");
-       return NULL;
-   }
-   $1 = (void *) malloc($2);
-}
-
-// Return the buffer.  Discarding any previous return result
-// See also SBProcess::ReadMemory.
-%typemap(argout) (void *buf, size_t size) {
-   Py_XDECREF($result);   /* Blow away any previous result */
-   if (result == 0) {
-      $result = Py_None;
-      Py_INCREF($result);
-   } else {
-      PythonBytes bytes(static_cast<const uint8_t*>($1), result);
-      $result = bytes.release();
-   }
-   free($1);
-}
-
-%{
-namespace {
-template <class T>
-T PyLongAsT(PyObject *obj) {
-  static_assert(true, "unsupported type");
-}
-
-template <> uint64_t PyLongAsT<uint64_t>(PyObject *obj) {
-  return static_cast<uint64_t>(PyLong_AsUnsignedLongLong(obj));
-}
-
-template <> uint32_t PyLongAsT<uint32_t>(PyObject *obj) {
-  return static_cast<uint32_t>(PyLong_AsUnsignedLong(obj));
-}
-
-template <> int64_t PyLongAsT<int64_t>(PyObject *obj) {
-  return static_cast<int64_t>(PyLong_AsLongLong(obj));
-}
-
-template <> int32_t PyLongAsT<int32_t>(PyObject *obj) {
-  return static_cast<int32_t>(PyLong_AsLong(obj));
-}
-
-template <class T>
-bool SetNumberFromPyObject(T &number, PyObject *obj) {
-  if (PyInt_Check(obj))
-    number = static_cast<T>(PyInt_AsLong(obj));
-  else if (PyLong_Check(obj))
-    number = PyLongAsT<T>(obj);
-  else return false;
-
-  return true;
-}
-
-template <>
-bool SetNumberFromPyObject<double>(double &number, PyObject *obj) {
-  if (PyFloat_Check(obj)) {
-    number = PyFloat_AsDouble(obj);
-    return true;
-  }
-
-  return false;
-}
-
-} // namespace
-%}
-
-// these typemaps allow Python users to pass list objects
-// and have them turn into C++ arrays (this is useful, for instance
-// when creating SBData objects from lists of numbers)
-%typemap(in) (uint64_t* array, size_t array_len),
-             (uint32_t* array, size_t array_len),
-             (int64_t* array, size_t array_len),
-             (int32_t* array, size_t array_len),
-             (double* array, size_t array_len) {
-  /* Check if is a list  */
-  if (PyList_Check($input)) {
-    int size = PyList_Size($input);
-    int i = 0;
-    $2 = size;
-    $1 = ($1_type) malloc(size * sizeof($*1_type));
-    for (i = 0; i < size; i++) {
-      PyObject *o = PyList_GetItem($input,i);
-      if (!SetNumberFromPyObject($1[i], o)) {
-        PyErr_SetString(PyExc_TypeError,"list must contain numbers");
-        free($1);
-        return NULL;
-      }
-
-      if (PyErr_Occurred()) {
-        free($1);
-        return NULL;
-      }
-    }
-  } else if ($input == Py_None) {
-    $1 =  NULL;
-    $2 = 0;
-  } else {
-    PyErr_SetString(PyExc_TypeError,"not a list");
-    return NULL;
-  }
-}
-
-%typemap(freearg) (uint64_t* array, size_t array_len),
-                  (uint32_t* array, size_t array_len),
-                  (int64_t* array, size_t array_len),
-                  (int32_t* array, size_t array_len),
-                  (double* array, size_t array_len) {
-  free($1);
-}
-
-// these typemaps wrap SBModule::GetVersion() from requiring a memory buffer
-// to the more Pythonic style where a list is returned and no previous allocation
-// is necessary - this will break if more than 50 versions are ever returned
-%typemap(typecheck) (uint32_t *versions, uint32_t num_versions) {
-    $1 = ($input == Py_None ? 1 : 0);
-}
-
-%typemap(in, numinputs=0) (uint32_t *versions) {
-    $1 = (uint32_t*)malloc(sizeof(uint32_t) * 50);
-}
-
-%typemap(in, numinputs=0) (uint32_t num_versions) {
-    $1 = 50;
-}
-
-%typemap(argout) (uint32_t *versions, uint32_t num_versions) {
-    uint32_t count = result;
-    if (count >= $2)
-        count = $2;
-    PyObject* list = PyList_New(count);
-    for (uint32_t j = 0; j < count; j++)
-    {
-        PyObject* item = PyInt_FromLong($1[j]);
-        int ok = PyList_SetItem(list,j,item);
-        if (ok != 0)
-        {
-            $result = Py_None;
-            break;
-        }
-    }
-    $result = list;
-}
-
-%typemap(freearg) (uint32_t *versions) {
-    free($1);
-}
-
-
-// For Log::LogOutputCallback
-%typemap(in) (lldb::LogOutputCallback log_callback, void *baton) {
-  if (!($input == Py_None || PyCallable_Check(reinterpret_cast<PyObject*>($input)))) {
-    PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
-    return NULL;
-  }
-
-  // FIXME (filcab): We can't currently check if our callback is already
-  // LLDBSwigPythonCallPythonLogOutputCallback (to DECREF the previous
-  // baton) nor can we just remove all traces of a callback, if we want to
-  // revert to a file logging mechanism.
-
-  // Don't lose the callback reference
-  Py_INCREF($input);
-  $1 = LLDBSwigPythonCallPythonLogOutputCallback;
-  $2 = $input;
-}
-
-%typemap(typecheck) (lldb::LogOutputCallback log_callback, void *baton) {
-  $1 = $input == Py_None;
-  $1 = $1 || PyCallable_Check(reinterpret_cast<PyObject*>($input));
-}
-
-
-%typemap(in) lldb::FileSP {
-  PythonFile py_file(PyRefType::Borrowed, $input);
-  if (!py_file) {
-    PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
-  }
-  auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
-  if (!sp)
-    return nullptr;
-  $1 = sp;
-}
-
-%typemap(in) lldb::FileSP FORCE_IO_METHODS {
-  PythonFile py_file(PyRefType::Borrowed, $input);
-  if (!py_file) {
-    PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
-  }
-  auto sp = unwrapOrSetPythonException(py_file.ConvertToFileForcingUseOfScriptingIOMethods());
-  if (!sp)
-    return nullptr;
-  $1 = sp;
-}
-
-%typemap(in) lldb::FileSP BORROWED {
-  PythonFile py_file(PyRefType::Borrowed, $input);
-  if (!py_file) {
-    PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
-  }
-  auto sp = unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
-  if (!sp)
-    return nullptr;
-  $1 = sp;
-}
-
-%typemap(in) lldb::FileSP BORROWED_FORCE_IO_METHODS {
-  PythonFile py_file(PyRefType::Borrowed, $input);
-  if (!py_file) {
-    PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
-  }
-  auto sp = unwrapOrSetPythonException(py_file.ConvertToFileForcingUseOfScriptingIOMethods(/*borrowed=*/true));
-  if (!sp)
-    return nullptr;
-  $1 = sp;
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) lldb::FileSP {
-  if (PythonFile::Check($input)) {
-    $1 = 1;
-  } else {
-    PyErr_Clear();
-    $1 = 0;
-  }
-}
-
-%typemap(out) lldb::FileSP {
-  $result = nullptr;
-  lldb::FileSP &sp = $1;
-  if (sp) {
-    PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp));
-    if (!pyfile.IsValid())
-      return nullptr;
-    $result = pyfile.release();
-  }
-  if (!$result)
-  {
-      $result = Py_None;
-      Py_INCREF(Py_None);
-  }
-}
-
-%typemap(in) (const char* string, int len) {
-    if ($input == Py_None)
-    {
-        $1 = NULL;
-        $2 = 0;
-    }
-    else if (PythonString::Check($input))
-    {
-        PythonString py_str(PyRefType::Borrowed, $input);
-        llvm::StringRef str = py_str.GetString();
-        $1 = const_cast<char*>(str.data());
-        $2 = str.size();
-        // In Python 2, if $input is a PyUnicode object then this
-        // will trigger a Unicode -> String conversion, in which
-        // case the `PythonString` will now own the PyString.  Thus
-        // if it goes out of scope, the data will be deleted.  The
-        // only way to avoid this is to leak the Python object in
-        // that case.  Note that if there was no conversion, then
-        // releasing the string will not leak anything, since we
-        // created this as a borrowed reference.
-        py_str.release();
-    }
-    else
-    {
-        PyErr_SetString(PyExc_TypeError,"not a string-like object");
-        return NULL;
-    }
-}
-
-// These two pybuffer macros are copied out of swig/Lib/python/pybuffer.i,
-// and fixed so they will not crash if PyObject_GetBuffer fails.
-// https://github.com/swig/swig/issues/1640
-
-%define %pybuffer_mutable_binary(TYPEMAP, SIZE)
-%typemap(in) (TYPEMAP, SIZE) {
-  int res; Py_ssize_t size = 0; void *buf = 0;
-  Py_buffer view;
-  res = PyObject_GetBuffer($input, &view, PyBUF_WRITABLE);
-  if (res < 0) {
-    PyErr_Clear();
-    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
-  }
-  size = view.len;
-  buf = view.buf;
-  PyBuffer_Release(&view);
-  $1 = ($1_ltype) buf;
-  $2 = ($2_ltype) (size/sizeof($*1_type));
-}
-%enddef
-
-%define %pybuffer_binary(TYPEMAP, SIZE)
-%typemap(in) (TYPEMAP, SIZE) {
-  int res; Py_ssize_t size = 0; const void *buf = 0;
-  Py_buffer view;
-  res = PyObject_GetBuffer($input, &view, PyBUF_CONTIG_RO);
-  if (res < 0) {
-    PyErr_Clear();
-    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
-  }
-  size = view.len;
-  buf = view.buf;
-  PyBuffer_Release(&view);
-  $1 = ($1_ltype) buf;
-  $2 = ($2_ltype) (size / sizeof($*1_type));
-}
-%enddef
-
-%pybuffer_binary(const uint8_t *buf, size_t num_bytes);
-%pybuffer_mutable_binary(uint8_t *buf, size_t num_bytes);
diff --git a/lldb/scripts/Python/python-wrapper.swig b/lldb/scripts/Python/python-wrapper.swig
deleted file mode 100644
index 3a63165cf58..00000000000
--- a/lldb/scripts/Python/python-wrapper.swig
+++ /dev/null
@@ -1,1074 +0,0 @@
-%header %{
-
-template <typename T>
-PyObject *
-SBTypeToSWIGWrapper (T* item);
-
-class PyErr_Cleaner
-{
-public:
-    PyErr_Cleaner(bool print=false) :
-    m_print(print)
-    {
-    }
-
-    ~PyErr_Cleaner()
-    {
-        if (PyErr_Occurred())
-        {
-            if(m_print && !PyErr_ExceptionMatches(PyExc_SystemExit))
-                PyErr_Print();
-            PyErr_Clear();
-        }
-    }
-
-private:
-    bool m_print;
-};
-
-%}
-
-%wrapper %{
-
-// resolve a dotted Python name in the form
-// foo.bar.baz.Foobar to an actual Python object
-// if pmodule is NULL, the __main__ module will be used
-// as the starting point for the search
-
-
-// This function is called by lldb_private::ScriptInterpreterPython::BreakpointCallbackFunction(...)
-// and is used when a script command is attached to a breakpoint for execution.
-
-SWIGEXPORT llvm::Expected<bool>
-LLDBSwigPythonBreakpointCallbackFunction
-(
-    const char *python_function_name,
-    const char *session_dictionary_name,
-    const lldb::StackFrameSP& frame_sp,
-    const lldb::BreakpointLocationSP& bp_loc_sp,
-    lldb_private::StructuredDataImpl *args_impl
-)
-{
-    using namespace llvm;
-
-    lldb::SBFrame sb_frame (frame_sp);
-    lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
-
-    PyErr_Cleaner py_err_cleaner(true);
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-
-    unsigned max_positional_args;
-    if (auto arg_info = pfunc.GetArgInfo())
-        max_positional_args = arg_info.get().max_positional_args;
-    else
-        return arg_info.takeError();
-
-    PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_frame));
-    PythonObject bp_loc_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_bp_loc));
-
-    auto result = [&] () -> Expected<PythonObject> {
-        // If the called function doesn't take extra_args, drop them here:
-        if (max_positional_args < 4) {
-            return pfunc.Call(frame_arg, bp_loc_arg, dict);
-        } else {
-            lldb::SBStructuredData *args_value = new lldb::SBStructuredData(args_impl);
-            PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
-            return pfunc.Call(frame_arg, bp_loc_arg, args_arg, dict);
-        }
-    } ();
-
-    if (!result)
-        return result.takeError();
-
-    // Only False counts as false!
-    return result.get().get() != Py_False;
-}
-
-// This function is called by lldb_private::ScriptInterpreterPython::WatchpointCallbackFunction(...)
-// and is used when a script command is attached to a watchpoint for execution.
-
-SWIGEXPORT bool
-LLDBSwigPythonWatchpointCallbackFunction
-(
-    const char *python_function_name,
-    const char *session_dictionary_name,
-    const lldb::StackFrameSP& frame_sp,
-    const lldb::WatchpointSP& wp_sp
-)
-{
-    lldb::SBFrame sb_frame (frame_sp);
-    lldb::SBWatchpoint sb_wp(wp_sp);
-
-    bool stop_at_watchpoint = true;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-
-    if (!pfunc.IsAllocated())
-        return stop_at_watchpoint;
-
-    PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_frame));
-    PythonObject wp_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_wp));
-    PythonObject result = pfunc(frame_arg, wp_arg, dict);
-
-    if (result.get() == Py_False)
-        stop_at_watchpoint = false;
-
-    return stop_at_watchpoint;
-}
-
-SWIGEXPORT bool
-LLDBSwigPythonCallTypeScript
-(
-    const char *python_function_name,
-    const void *session_dictionary,
-    const lldb::ValueObjectSP& valobj_sp,
-    void** pyfunct_wrapper,
-    const lldb::TypeSummaryOptionsSP& options_sp,
-    std::string& retval
-)
-{
-    lldb::SBValue sb_value (valobj_sp);
-    lldb::SBTypeSummaryOptions sb_options(options_sp.get());
-
-    retval.clear();
-
-    if (!python_function_name || !session_dictionary)
-        return false;
-
-    PyObject *pfunc_impl = nullptr;
-
-    if (pyfunct_wrapper && *pyfunct_wrapper && PyFunction_Check (*pyfunct_wrapper))
-    {
-        pfunc_impl = (PyObject*)(*pyfunct_wrapper);
-        if (pfunc_impl->ob_refcnt == 1)
-        {
-            Py_XDECREF(pfunc_impl);
-            pfunc_impl = NULL;
-        }
-    }
-
-    PyObject *py_dict = (PyObject*)session_dictionary;
-    if (!PythonDictionary::Check(py_dict))
-        return true;
-
-    PythonDictionary dict(PyRefType::Borrowed, py_dict);
-
-    PyErr_Cleaner pyerr_cleanup(true);  // show Python errors
-
-    PythonCallable pfunc(PyRefType::Borrowed, pfunc_impl);
-
-    if (!pfunc.IsAllocated())
-    {
-        pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-        if (!pfunc.IsAllocated())
-            return false;
-
-        if (pyfunct_wrapper)
-        {
-            *pyfunct_wrapper = pfunc.get();
-            Py_XINCREF(pfunc.get());
-        }
-    }
-
-    PythonObject result;
-    auto argc = pfunc.GetArgInfo();
-    if (!argc) {
-        llvm::consumeError(argc.takeError());
-        return false;
-    }
-
-    PythonObject value_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_value));
-    PythonObject options_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_options));
-
-    if (argc.get().max_positional_args < 3)
-        result = pfunc(value_arg,dict);
-    else
-        result = pfunc(value_arg,dict,options_arg);
-
-    retval = result.Str().GetString().str();
-
-    return true;
-}
-
-SWIGEXPORT void*
-LLDBSwigPythonCreateSyntheticProvider
-(
-    const char *python_class_name,
-    const char *session_dictionary_name,
-    const lldb::ValueObjectSP& valobj_sp
-)
-{
-    if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
-        Py_RETURN_NONE;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name,dict);
-
-    if (!pfunc.IsAllocated())
-        Py_RETURN_NONE;
-
-    // I do not want the SBValue to be deallocated when going out of scope because python
-    // has ownership of it and will manage memory for this object by itself
-    lldb::SBValue *sb_value = new lldb::SBValue(valobj_sp);
-    sb_value->SetPreferSyntheticValue(false);
-
-    PythonObject val_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_value));
-    if (!val_arg.IsAllocated())
-        Py_RETURN_NONE;
-
-    PythonObject result = pfunc(val_arg, dict);
-
-    if (result.IsAllocated())
-        return result.release();
-
-    Py_RETURN_NONE;
-}
-
-SWIGEXPORT void*
-LLDBSwigPythonCreateCommandObject
-(
-    const char *python_class_name,
-    const char *session_dictionary_name,
-    const lldb::DebuggerSP debugger_sp
-)
-{
-    if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
-        Py_RETURN_NONE;
-
-    PyErr_Cleaner py_err_cleaner(true);
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
-
-    if (!pfunc.IsAllocated())
-        return nullptr;
-
-    lldb::SBDebugger debugger_sb(debugger_sp);
-    PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
-    PythonObject result = pfunc(debugger_arg, dict);
-
-    if (result.IsAllocated())
-        return result.release();
-
-    Py_RETURN_NONE;
-}
-
-SWIGEXPORT void*
-LLDBSwigPythonCreateScriptedThreadPlan
-(
-    const char *python_class_name,
-    const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args_impl,
-    std::string &error_string,
-    const lldb::ThreadPlanSP& thread_plan_sp
-)
-{
-    if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
-        Py_RETURN_NONE;
-
-    // I do not want the SBThreadPlan to be deallocated when going out of scope because python
-    // has ownership of it and will manage memory for this object by itself
-    lldb::SBThreadPlan *tp_value = new lldb::SBThreadPlan(thread_plan_sp);
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
-
-    if (!pfunc.IsAllocated()) {
-        error_string.append("could not find script class: ");
-        error_string.append(python_class_name);
-        return nullptr;
-    }
-
-    PythonObject tp_arg(PyRefType::Owned, SBTypeToSWIGWrapper(tp_value));
-
-    if (!tp_arg.IsAllocated())
-        Py_RETURN_NONE;
-
-    llvm::Expected<PythonCallable::ArgInfo> arg_info = pfunc.GetArgInfo();
-    if (!arg_info) {
-        llvm::handleAllErrors(
-            arg_info.takeError(),
-            [&](PythonException &E) {
-                error_string.append(E.ReadBacktrace());
-            },
-            [&](const llvm::ErrorInfoBase &E) {
-                error_string.append(E.message());
-            });
-        Py_RETURN_NONE;
-    }
-
-    PythonObject result = {};
-    if (arg_info.get().max_positional_args == 2) {
-        if (args_impl != nullptr) {
-           error_string.assign("args passed, but __init__ does not take an args dictionary");
-           Py_RETURN_NONE;
-        }
-        result = pfunc(tp_arg, dict);
-    } else if (arg_info.get().max_positional_args >= 3) {
-        lldb::SBStructuredData *args_value = new lldb::SBStructuredData(args_impl);
-        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
-        result = pfunc(tp_arg, args_arg, dict);
-    } else {
-        error_string.assign("wrong number of arguments in __init__, should be 2 or 3 (not including self)");
-        Py_RETURN_NONE;
-    }
-
-    // FIXME: At this point we should check that the class we found supports all the methods
-    // that we need.
-
-    if (result.IsAllocated())
-        return result.release();
-    Py_RETURN_NONE;
-}
-
-SWIGEXPORT bool
-LLDBSWIGPythonCallThreadPlan
-(
-    void *implementor,
-    const char *method_name,
-    lldb_private::Event *event,
-    bool &got_error
-)
-{
-    got_error = false;
-
-    PyErr_Cleaner py_err_cleaner(false);
-    PythonObject self(PyRefType::Borrowed, static_cast<PyObject*>(implementor));
-    auto pfunc = self.ResolveName<PythonCallable>(method_name);
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    PythonObject result;
-    if (event != nullptr)
-    {
-        lldb::SBEvent sb_event(event);
-        PythonObject event_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_event));
-        result = pfunc(event_arg);
-    }
-    else
-        result = pfunc();
-
-    if (PyErr_Occurred())
-    {
-        got_error = true;
-        printf ("Return value was neither false nor true for call to %s.\n", method_name);
-        PyErr_Print();
-        return false;
-    }
-
-    if (result.get() == Py_True)
-        return true;
-    else if (result.get() == Py_False)
-        return false;
-
-    // Somebody returned the wrong thing...
-    got_error = true;
-    printf ("Wrong return value type for call to %s.\n", method_name);
-    return false;
-}
-
-SWIGEXPORT void *
-LLDBSwigPythonCreateScriptedBreakpointResolver
-(
-    const char *python_class_name,
-    const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args_impl,
-    lldb::BreakpointSP &breakpoint_sp
-)
-{
-    if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
-        Py_RETURN_NONE;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
-
-    if (!pfunc.IsAllocated())
-        return nullptr;
-
-    lldb::SBBreakpoint *bkpt_value = new lldb::SBBreakpoint(breakpoint_sp);
-
-    PythonObject bkpt_arg(PyRefType::Owned, SBTypeToSWIGWrapper(bkpt_value));
-
-    lldb::SBStructuredData *args_value = new lldb::SBStructuredData(args_impl);
-    PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
-
-    PythonObject result = pfunc(bkpt_arg, args_arg, dict);
-    // FIXME: At this point we should check that the class we found supports all the methods
-    // that we need.
-
-    if (result.IsAllocated())
-    {
-        // Check that __callback__ is defined:
-        auto callback_func = result.ResolveName<PythonCallable>("__callback__");
-        if (callback_func.IsAllocated())
-            return result.release();
-        else
-            result.release();
-    }
-    Py_RETURN_NONE;
-}
-
-SWIGEXPORT unsigned int
-LLDBSwigPythonCallBreakpointResolver
-(
-    void *implementor,
-    const char *method_name,
-    lldb_private::SymbolContext *sym_ctx
-)
-{
-    PyErr_Cleaner py_err_cleaner(false);
-    PythonObject self(PyRefType::Borrowed, static_cast<PyObject*>(implementor));
-    auto pfunc = self.ResolveName<PythonCallable>(method_name);
-
-    if (!pfunc.IsAllocated())
-        return 0;
-
-    PythonObject result;
-    if (sym_ctx != nullptr) {
-      lldb::SBSymbolContext sb_sym_ctx(sym_ctx);
-      PythonObject sym_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_sym_ctx));
-      result = pfunc(sym_ctx_arg);
-    } else
-      result = pfunc();
-
-    if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        return 0;
-    }
-
-    // The callback will return a bool, but we're need to also return ints
-    // so we're squirrelling the bool through as an int...  And if you return
-    // nothing, we'll continue.
-    if (strcmp(method_name, "__callback__") == 0) {
-        if (result.get() == Py_False)
-          return 0;
-        else
-          return 1;
-    }
-
-    PythonInteger int_result = result.AsType<PythonInteger>();
-    if (!int_result.IsAllocated())
-        return 0;
-
-    unsigned int ret_val = int_result.GetInteger();
-
-    return ret_val;
-}
-
-// wrapper that calls an optional instance member of an object taking no arguments
-static PyObject*
-LLDBSwigPython_CallOptionalMember
-(
-    PyObject* implementor,
-    char* callee_name,
-    PyObject* ret_if_not_found = Py_None,
-    bool* was_found = NULL
-)
-{
-    PyErr_Cleaner py_err_cleaner(false);
-
-    PythonObject self(PyRefType::Borrowed, static_cast<PyObject*>(implementor));
-    auto pfunc = self.ResolveName<PythonCallable>(callee_name);
-
-    if (!pfunc.IsAllocated())
-    {
-        if (was_found)
-            *was_found = false;
-        Py_XINCREF(ret_if_not_found);
-        return ret_if_not_found;
-    }
-
-    if (was_found)
-        *was_found = true;
-
-    PythonObject result = pfunc();
-    return result.release();
-}
-
-SWIGEXPORT size_t
-LLDBSwigPython_CalculateNumChildren
-(
-    PyObject *implementor,
-    uint32_t max
-)
-{
-    PythonObject self(PyRefType::Borrowed, implementor);
-    auto pfunc = self.ResolveName<PythonCallable>("num_children");
-
-    if (!pfunc.IsAllocated())
-        return 0;
-
-    auto arg_info = pfunc.GetArgInfo();
-    if (!arg_info) {
-        llvm::consumeError(arg_info.takeError());
-        return 0;
-    }
-
-    PythonObject result;
-
-    if (arg_info.get().max_positional_args < 1)
-        result = pfunc();
-    else
-        result = pfunc(PythonInteger(max));
-
-    if (!result.IsAllocated())
-        return 0;
-
-    PythonInteger int_result = result.AsType<PythonInteger>();
-    if (!int_result.IsAllocated())
-        return 0;
-
-    size_t ret_val = int_result.GetInteger();
-
-    if (PyErr_Occurred()) //FIXME use Expected to catch python exceptions
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
-
-    if (arg_info.get().max_positional_args < 1)
-        ret_val = std::min(ret_val, static_cast<size_t>(max));
-
-    return ret_val;
-}
-
-SWIGEXPORT PyObject*
-LLDBSwigPython_GetChildAtIndex
-(
-    PyObject *implementor,
-    uint32_t idx
-)
-{
-    PyErr_Cleaner py_err_cleaner(true);
-
-    PythonObject self(PyRefType::Borrowed, implementor);
-    auto pfunc = self.ResolveName<PythonCallable>("get_child_at_index");
-
-    if (!pfunc.IsAllocated())
-        return nullptr;
-
-    PythonObject result = pfunc(PythonInteger(idx));
-
-    if (!result.IsAllocated())
-        return nullptr;
-
-    lldb::SBValue* sbvalue_ptr = nullptr;
-    if (SWIG_ConvertPtr(result.get(), (void**)&sbvalue_ptr, SWIGTYPE_p_lldb__SBValue, 0) == -1)
-        return nullptr;
-
-    if (sbvalue_ptr == nullptr)
-        return nullptr;
-
-    return result.release();
-}
-
-SWIGEXPORT int
-LLDBSwigPython_GetIndexOfChildWithName
-(
-    PyObject *implementor,
-    const char* child_name
-)
-{
-    PyErr_Cleaner py_err_cleaner(true);
-
-    PythonObject self(PyRefType::Borrowed, implementor);
-    auto pfunc = self.ResolveName<PythonCallable>("get_child_index");
-
-    if (!pfunc.IsAllocated())
-        return UINT32_MAX;
-
-    PythonObject result = pfunc(PythonString(child_name));
-
-    if (!result.IsAllocated())
-        return UINT32_MAX;
-
-    PythonInteger int_result = result.AsType<PythonInteger>();
-    if (!int_result.IsAllocated())
-        return UINT32_MAX;
-
-    int64_t retval = int_result.GetInteger();
-    if (retval >= 0)
-        return (uint32_t)retval;
-
-    return UINT32_MAX;
-}
-
-SWIGEXPORT bool
-LLDBSwigPython_UpdateSynthProviderInstance
-(
-    PyObject *implementor
-)
-{
-    bool ret_val = false;
-
-    static char callee_name[] = "update";
-
-    PyObject* py_return = LLDBSwigPython_CallOptionalMember(implementor,callee_name);
-
-    if (py_return == Py_True)
-        ret_val = true;
-
-    Py_XDECREF(py_return);
-
-    return ret_val;
-}
-
-SWIGEXPORT bool
-LLDBSwigPython_MightHaveChildrenSynthProviderInstance
-(
-    PyObject *implementor
-)
-{
-    bool ret_val = false;
-
-    static char callee_name[] = "has_children";
-
-    PyObject* py_return = LLDBSwigPython_CallOptionalMember(implementor,callee_name, Py_True);
-
-    if (py_return == Py_True)
-        ret_val = true;
-
-    Py_XDECREF(py_return);
-
-    return ret_val;
-}
-
-SWIGEXPORT PyObject*
-LLDBSwigPython_GetValueSynthProviderInstance
-(
-    PyObject *implementor
-)
-{
-    PyObject* ret_val = nullptr;
-
-    static char callee_name[] = "get_value";
-
-    PyObject* py_return = LLDBSwigPython_CallOptionalMember(implementor,callee_name, Py_None);
-
-    if (py_return == Py_None || py_return == nullptr)
-        ret_val = nullptr;
-
-    lldb::SBValue* sbvalue_ptr = NULL;
-
-    if (SWIG_ConvertPtr(py_return, (void**)&sbvalue_ptr, SWIGTYPE_p_lldb__SBValue, 0) == -1)
-        ret_val = nullptr;
-    else if (sbvalue_ptr == NULL)
-        ret_val = nullptr;
-    else
-        ret_val = py_return;
-
-    Py_XDECREF(py_return);
-    return ret_val;
-}
-
-SWIGEXPORT void*
-LLDBSWIGPython_CastPyObjectToSBValue
-(
-    PyObject* data
-)
-{
-    lldb::SBValue* sb_ptr = NULL;
-
-    int valid_cast = SWIG_ConvertPtr(data, (void**)&sb_ptr, SWIGTYPE_p_lldb__SBValue, 0);
-
-    if (valid_cast == -1)
-        return NULL;
-
-    return sb_ptr;
-}
-
-SWIGEXPORT bool
-LLDBSwigPythonCallCommand
-(
-    const char *python_function_name,
-    const char *session_dictionary_name,
-    lldb::DebuggerSP& debugger,
-    const char* args,
-    lldb_private::CommandReturnObject& cmd_retobj,
-    lldb::ExecutionContextRefSP exe_ctx_ref_sp
-)
-{
-    lldb::SBCommandReturnObject cmd_retobj_sb(cmd_retobj);
-    lldb::SBDebugger debugger_sb(debugger);
-    lldb::SBExecutionContext exe_ctx_sb(exe_ctx_ref_sp);
-
-    PyErr_Cleaner py_err_cleaner(true);
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    // pass the pointer-to cmd_retobj_sb or watch the underlying object disappear from under you
-    // see comment above for SBCommandReturnObjectReleaser for further details
-    auto argc = pfunc.GetArgInfo();
-    if (!argc) {
-        llvm::consumeError(argc.takeError());
-        return false;
-    }
-    PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
-    PythonObject exe_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(exe_ctx_sb));
-    PythonObject cmd_retobj_arg(PyRefType::Owned, SBTypeToSWIGWrapper(&cmd_retobj_sb));
-
-    if (argc.get().max_positional_args < 5u)
-        pfunc(debugger_arg, PythonString(args), cmd_retobj_arg, dict);
-    else
-        pfunc(debugger_arg, PythonString(args), exe_ctx_arg, cmd_retobj_arg, dict);
-
-    return true;
-}
-
-SWIGEXPORT bool
-LLDBSwigPythonCallCommandObject
-(
-    PyObject *implementor,
-    lldb::DebuggerSP& debugger,
-    const char* args,
-    lldb_private::CommandReturnObject& cmd_retobj,
-    lldb::ExecutionContextRefSP exe_ctx_ref_sp
-)
-{
-    lldb::SBCommandReturnObject cmd_retobj_sb(cmd_retobj);
-    lldb::SBDebugger debugger_sb(debugger);
-    lldb::SBExecutionContext exe_ctx_sb(exe_ctx_ref_sp);
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    PythonObject self(PyRefType::Borrowed, implementor);
-    auto pfunc = self.ResolveName<PythonCallable>("__call__");
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    // pass the pointer-to cmd_retobj_sb or watch the underlying object disappear from under you
-    // see comment above for SBCommandReturnObjectReleaser for further details
-    PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
-    PythonObject exe_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(exe_ctx_sb));
-    PythonObject cmd_retobj_arg(PyRefType::Owned, SBTypeToSWIGWrapper(&cmd_retobj_sb));
-
-    pfunc(debugger_arg, PythonString(args), exe_ctx_arg, cmd_retobj_arg);
-
-    return true;
-}
-
-SWIGEXPORT void*
-LLDBSWIGPythonCreateOSPlugin
-(
-    const char *python_class_name,
-    const char *session_dictionary_name,
-    const lldb::ProcessSP& process_sp
-)
-{
-    if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
-        Py_RETURN_NONE;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
-
-    if (!pfunc.IsAllocated())
-        Py_RETURN_NONE;
-
-    // I do not want the SBProcess to be deallocated when going out of scope because python
-    // has ownership of it and will manage memory for this object by itself
-    lldb::SBProcess *process_sb = new lldb::SBProcess(process_sp);
-    PythonObject process_arg(PyRefType::Owned, SBTypeToSWIGWrapper(process_sb));
-    if (!process_arg.IsAllocated())
-        Py_RETURN_NONE;
-
-    auto result = pfunc(process_arg);
-
-    if (result.IsAllocated())
-        return result.release();
-
-    Py_RETURN_NONE;
-}
-
-SWIGEXPORT void*
-LLDBSWIGPython_CreateFrameRecognizer
-(
-    const char *python_class_name,
-    const char *session_dictionary_name
-)
-{
-    if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
-        Py_RETURN_NONE;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
-
-    if (!pfunc.IsAllocated())
-        Py_RETURN_NONE;
-
-    auto result = pfunc();
-
-    if (result.IsAllocated())
-        return result.release();
-
-    Py_RETURN_NONE;
-}
-
-SWIGEXPORT PyObject*
-LLDBSwigPython_GetRecognizedArguments
-(
-    PyObject *implementor,
-    const lldb::StackFrameSP& frame_sp
-)
-{
-    static char callee_name[] = "get_recognized_arguments";
-
-    lldb::SBFrame frame_sb(frame_sp);
-    PyObject *arg = SBTypeToSWIGWrapper(frame_sb);
-
-    PythonString str(callee_name);
-    PyObject* result = PyObject_CallMethodObjArgs(implementor, str.get(), arg,
-                                                  NULL);
-    return result;
-}
-
-SWIGEXPORT void*
-LLDBSWIGPython_GetDynamicSetting (void* module, const char* setting, const lldb::TargetSP& target_sp)
-{
-    if (!module || !setting)
-        Py_RETURN_NONE;
-
-    PyErr_Cleaner py_err_cleaner(true);
-    PythonObject py_module(PyRefType::Borrowed, (PyObject *)module);
-    auto pfunc = py_module.ResolveName<PythonCallable>("get_dynamic_setting");
-
-    if (!pfunc.IsAllocated())
-        Py_RETURN_NONE;
-
-    lldb::SBTarget target_sb(target_sp);
-    PythonObject target_arg(PyRefType::Owned, SBTypeToSWIGWrapper(target_sb));
-    auto result = pfunc(target_arg, PythonString(setting));
-
-    return result.release();
-}
-
-SWIGEXPORT bool
-LLDBSWIGPythonRunScriptKeywordProcess
-(const char* python_function_name,
-const char* session_dictionary_name,
-lldb::ProcessSP& process,
-std::string& output)
-
-{
-    if (python_function_name == NULL || python_function_name[0] == '\0' || !session_dictionary_name)
-        return false;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    lldb::SBProcess process_sb(process);
-    PythonObject process_arg(PyRefType::Owned, SBTypeToSWIGWrapper(process_sb));
-    auto result = pfunc(process_arg, dict);
-
-    output = result.Str().GetString().str();
-
-    return true;
-}
-
-SWIGEXPORT bool
-LLDBSWIGPythonRunScriptKeywordThread
-(const char* python_function_name,
-const char* session_dictionary_name,
-lldb::ThreadSP& thread,
-std::string& output)
-
-{
-    if (python_function_name == NULL || python_function_name[0] == '\0' || !session_dictionary_name)
-        return false;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    lldb::SBThread thread_sb(thread);
-    PythonObject thread_arg(PyRefType::Owned, SBTypeToSWIGWrapper(thread_sb));
-    auto result = pfunc(thread_arg, dict);
-
-    output = result.Str().GetString().str();
-
-    return true;
-}
-
-SWIGEXPORT bool
-LLDBSWIGPythonRunScriptKeywordTarget
-(const char* python_function_name,
-const char* session_dictionary_name,
-lldb::TargetSP& target,
-std::string& output)
-
-{
-    if (python_function_name == NULL || python_function_name[0] == '\0' || !session_dictionary_name)
-        return false;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name,dict);
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    lldb::SBTarget target_sb(target);
-    PythonObject target_arg(PyRefType::Owned, SBTypeToSWIGWrapper(target_sb));
-    auto result = pfunc(target_arg, dict);
-
-    output = result.Str().GetString().str();
-
-    return true;
-}
-
-SWIGEXPORT bool
-LLDBSWIGPythonRunScriptKeywordFrame
-(const char* python_function_name,
-const char* session_dictionary_name,
-lldb::StackFrameSP& frame,
-std::string& output)
-
-{
-    if (python_function_name == NULL || python_function_name[0] == '\0' || !session_dictionary_name)
-        return false;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name,dict);
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    lldb::SBFrame frame_sb(frame);
-    PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(frame_sb));
-    auto result = pfunc(frame_arg, dict);
-
-    output = result.Str().GetString().str();
-
-    return true;
-}
-
-SWIGEXPORT bool
-LLDBSWIGPythonRunScriptKeywordValue
-(const char* python_function_name,
-const char* session_dictionary_name,
-lldb::ValueObjectSP& value,
-std::string& output)
-
-{
-    if (python_function_name == NULL || python_function_name[0] == '\0' || !session_dictionary_name)
-        return false;
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-
-    if (!pfunc.IsAllocated())
-        return false;
-
-    lldb::SBValue value_sb(value);
-    PythonObject value_arg(PyRefType::Owned, SBTypeToSWIGWrapper(value_sb));
-    auto result = pfunc(value_arg, dict);
-
-    output = result.Str().GetString().str();
-
-    return true;
-}
-
-SWIGEXPORT bool
-LLDBSwigPythonCallModuleInit
-(
-    const char *python_module_name,
-    const char *session_dictionary_name,
-    lldb::DebuggerSP& debugger
-)
-{
-    std::string python_function_name_string = python_module_name;
-    python_function_name_string += ".__lldb_init_module";
-    const char* python_function_name = python_function_name_string.c_str();
-
-    PyErr_Cleaner py_err_cleaner(true);
-
-    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
-    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
-
-    // This method is optional and need not exist.  So if we don't find it,
-    // it's actually a success, not a failure.
-    if (!pfunc.IsAllocated())
-        return true;
-
-    lldb::SBDebugger debugger_sb(debugger);
-    PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
-    pfunc(debugger_arg, dict);
-
-    return true;
-}
-%}
-
-
-%runtime %{
-// Forward declaration to be inserted at the start of LLDBWrapPython.h
-#include "lldb/API/SBDebugger.h"
-#include "lldb/API/SBValue.h"
-
-SWIGEXPORT lldb::ValueObjectSP
-LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data)
-{
-    lldb::ValueObjectSP valobj_sp;
-    if (data)
-    {
-        lldb::SBValue* sb_ptr = (lldb::SBValue *)data;
-        valobj_sp = sb_ptr->GetSP();
-    }
-    return valobj_sp;
-}
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void LLDBSwigPythonCallPythonLogOutputCallback(const char *str, void *baton);
-
-#ifdef __cplusplus
-}
-#endif
-%}
-
-%wrapper %{
-
-
-// For the LogOutputCallback functions
-void LLDBSwigPythonCallPythonLogOutputCallback(const char *str, void *baton) {
-    if (baton != Py_None) {
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-      PyObject *result = PyObject_CallFunction(reinterpret_cast<PyObject*>(baton), const_cast<char*>("s"), str);
-	  Py_XDECREF(result);
-      SWIG_PYTHON_THREAD_END_BLOCK;
-    }
-}
-%}