Port native Python API to support 3.x

[zturner]

Summary

With this change, liblldb is 95% of the way towards being able
to work under both Python 2.x and Python 3.x. This should
introduce no functional change for Python 2.x, but for Python
3.x there are some important changes. Primarily, these are:

1. PyString doesn't exist in Python 3. Everything is a PyUnicode. To account for this, PythonString now stores a PyBytes instead of a PyString.
2. PyInt doesn't exist in Python 3. Everything is a PyLong. To account for this, PythonInteger stores a PyLong instead of a PyInt. In Python 2.x, this requires doing a conversion to PyLong when creating a PythonInteger from a PyInt. In 3.x, there is no PyInt anyway, so we can assume everything is a PyLong.
3. PyFile_FromFile doesn't exist in Python 3. Instead there is a PyFile_FromFd. This is not addressed in this patch because it will require quite a large change to plumb fd's all the way through the system into the ScriptInterpreter. This is the only remaining piece of the puzzle to get LLDB supporting Python 3.x.

Being able to run the test suite is not addressed in this patch.
After the extension module can compile and you can enter an embedded
3.x interpreter, the test suite will be addressed in a followup.

[clayborg]

Few minor changes.

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

1183

"value_str.data()" might not be NULL terminate. Either use value_str.str().c_str() or use "%*s":

error.SetErrorStringWithFormat("%*s\n%s", (int)value_str.size(), value_str.data(), bt.c_str());

unittests/ScriptInterpreter/CMakeLists.txt

4

add newline

unittests/ScriptInterpreter/Python/CMakeLists.txt

7

add newline

[zturner]

Do you mind giving this a run on MacOSX and verifying it still compiles and test suite passes?

[zturner]

unittests/ScriptInterpreter/CMakeLists.txt

4

Missed this one in my updated patch, but I fixed it locally. Don't want to update a 3rd revision just for a newline though.

[zturner]

Ping. Does this look ok?

[clayborg]

Looks good.

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

public:
         bool
         IsNULLOrNone () const;
 
         StructuredData::ObjectSP CreateStructuredObject() const;
 
     protected:
         PyObject* m_py_obj;
     };
-    
     class PythonString: public PythonObject
     {
     public:
         PythonString ();
         PythonString (PyObject *o);
         PythonString (const PythonObject &object);
         PythonString (llvm::StringRef string);
         PythonString (const char *string);
         virtual ~PythonString ();
 
+        static bool Check(PyObject *py_obj);
+
         virtual bool
         Reset (PyObject* py_obj = NULL);
 
         llvm::StringRef
         GetString() const;
 
         size_t
         GetSize() const;
 
         void SetString(llvm::StringRef string);
 
         StructuredData::StringSP CreateStructuredString() const;
     };
-    
     class PythonInteger: public PythonObject
     {
     public:
         
         PythonInteger ();
         PythonInteger (PyObject* py_obj);
         PythonInteger (const PythonObject &object);
         PythonInteger (int64_t value);
         virtual ~PythonInteger ();
-        
+        static bool Check(PyObject *py_obj);
+
         virtual bool
         Reset (PyObject* py_obj = NULL);
 
         int64_t GetInteger() const;
 
         void
         SetInteger (int64_t value);
 
         StructuredData::IntegerSP CreateStructuredInteger() const;
     };
     
     class PythonList: public PythonObject
     {
     public:
-        
-        PythonList (bool create_empty);
+      PythonList();
         PythonList (PyObject* py_obj);
         PythonList (const PythonObject &object);
-        PythonList (uint32_t count);
         virtual ~PythonList ();
-        
+        static bool Check(PyObject *py_obj);
+
         virtual bool
         Reset (PyObject* py_obj = NULL);
 
         uint32_t GetSize() const;
 
         PythonObject GetItemAtIndex(uint32_t index) const;
 
         void
         SetItemAtIndex (uint32_t index, const PythonObject &object);
         
         void
         AppendItem (const PythonObject &object);
 
         StructuredData::ArraySP CreateStructuredArray() const;
     };
     
     class PythonDictionary: public PythonObject
     {
     public:
-        
-        explicit PythonDictionary (bool create_empty);
+      PythonDictionary();
         PythonDictionary (PyObject* object);
         PythonDictionary (const PythonObject &object);
         virtual ~PythonDictionary ();
-        
+        static bool Check(PyObject *py_obj);
+
         virtual bool
         Reset (PyObject* object = NULL);
 
         uint32_t GetSize() const;
 
         PythonObject
         GetItemForKey (const PythonString &key) const;
         

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

 {
     if (IsNULLOrNone())
         return PyObjectType::None;
 
     if (PyList_Check(m_py_obj))
         return PyObjectType::List;
     if (PyDict_Check(m_py_obj))
         return PyObjectType::Dictionary;
+    if (PyUnicode_Check(m_py_obj))
+        return PyObjectType::String;
+    if (PyLong_Check(m_py_obj))
+        return PyObjectType::Integer;
+#if PY_MAJOR_VERSION < 3
+    // These functions don't exist in Python 3.x.  PyString is PyUnicode
+    // and PyInt is PyLong.
     if (PyString_Check(m_py_obj))
         return PyObjectType::String;
-    if (PyInt_Check(m_py_obj) || PyLong_Check(m_py_obj))
+    if (PyInt_Check(m_py_obj))
         return PyObjectType::Integer;
+#endif
     return PyObjectType::Unknown;
 }
 
 PythonString
 PythonObject::Repr ()
 {
     if (!m_py_obj)
         return PythonString ();

 }
 
 PythonString::PythonString (const PythonObject &object) :
     PythonObject()
 {
     Reset(object.get()); // Use "Reset()" to ensure that py_obj is a string
 }
 
-PythonString::PythonString (llvm::StringRef string) :
-    PythonObject(PyString_FromStringAndSize(string.data(), string.size()))
+PythonString::PythonString(llvm::StringRef string)
+    : PythonObject()
 {
+    SetString(string);
 }
 
-PythonString::PythonString(const char *string) :
-    PythonObject(PyString_FromString(string))
+PythonString::PythonString(const char *string)
+    : PythonObject()
 {
+    SetString(llvm::StringRef(string));
 }
 
 PythonString::PythonString () :
     PythonObject()
 {
 }
 
 PythonString::~PythonString ()
 {
 }
 
 bool
-PythonString::Reset (PyObject *py_obj)
+PythonString::Check(PyObject *py_obj)
 {
-    if (py_obj && PyString_Check(py_obj))
-        return PythonObject::Reset(py_obj);
-    
+    if (!py_obj)
+        return false;
+#if PY_MAJOR_VERSION >= 3
+    // Python 3 does not have PyString objects, only PyUnicode.
+    return PyUnicode_Check(py_obj);
+#else
+    return PyUnicode_Check(py_obj) || PyString_Check(py_obj);
+#endif
+}
+bool
+PythonString::Reset(PyObject *py_obj)
+{
+    if (!PythonString::Check(py_obj))
+    {
         PythonObject::Reset(nullptr);
-    return py_obj == nullptr;
+        return false;
+    }
+
+// Convert this to a PyBytes object, and only store the PyBytes.  Note that in
+// Python 2.x, PyString and PyUnicode are interchangeable, and PyBytes is an alias
+// of PyString.  So on 2.x, if we get into this branch, we already have a PyBytes.
+    //#if PY_MAJOR_VERSION >= 3
+    if (PyUnicode_Check(py_obj))
+    {
+        PyObject *unicode = py_obj;
+        py_obj = PyUnicode_AsUTF8String(py_obj);
+        Py_XDECREF(unicode);
+    }
+    //#endif
+
+    assert(PyBytes_Check(py_obj) && "PythonString::Reset received a non-string");
+    return PythonObject::Reset(py_obj);
 }
 
 llvm::StringRef
 PythonString::GetString() const
 {
     if (m_py_obj)
-        return llvm::StringRef(PyString_AsString(m_py_obj), GetSize());
+    {
+        Py_ssize_t size;
+        char *c;
+        PyBytes_AsStringAndSize(m_py_obj, &c, &size);
+        return llvm::StringRef(c, size);
+    }
     return llvm::StringRef();
 }
 
 size_t
 PythonString::GetSize() const
 {
     if (m_py_obj)
-        return PyString_Size(m_py_obj);
+        return PyBytes_Size(m_py_obj);
     return 0;
 }
 
 void
 PythonString::SetString (llvm::StringRef string)
 {
+#if PY_MAJOR_VERSION >= 3
+    PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
+    PyObject *bytes = PyUnicode_AsUTF8String(unicode);
+    PythonObject::Reset(bytes);
+    Py_XDECREF(unicode);
+#else
     PythonObject::Reset(PyString_FromStringAndSize(string.data(), string.size()));
+#endif
 }
 
 StructuredData::StringSP
 PythonString::CreateStructuredString() const
 {
     StructuredData::StringSP result(new StructuredData::String);
     result->SetValue(GetString());
     return result;

 }
 
 
 PythonInteger::~PythonInteger ()
 {
 }
 
 bool
-PythonInteger::Reset (PyObject *py_obj)
+PythonInteger::Check(PyObject *py_obj)
+{
+    if (!py_obj)
+        return false;
+
+#if PY_MAJOR_VERSION >= 3
+    // Python 3 does not have PyInt_Check.  There is only one type of
+    // integral value, long.
+    return PyLong_Check(py_obj);
+#else
+    return PyLong_Check(py_obj) || PyInt_Check(py_obj);
+#endif
+}
+
+bool
+PythonInteger::Reset(PyObject *py_obj)
 {
-    if (py_obj)
+    if (!PythonInteger::Check(py_obj))
     {
-        if (PyInt_Check (py_obj) || PyLong_Check(py_obj))
-            return PythonObject::Reset(py_obj);
+        PythonObject::Reset(nullptr);
+        return false;
     }
-    
-    PythonObject::Reset(nullptr);
-    return py_obj == nullptr;
+#if PY_MAJOR_VERSION < 3
+    // Always store this as a PyLong, which makes interoperability between
+    // Python 2.x and Python 3.x easier.  This is only necessary in 2.x,
+    // since 3.x doesn't even have a PyInt.
+    if (PyInt_Check(py_obj))
+    {
+        PyObject *py_long = PyLong_FromLongLong(PyInt_AsLong(py_obj));
+        Py_XDECREF(py_obj);
+        py_obj = py_long;
+    }
+#endif
+
+    assert(PyLong_Check(py_obj) && "Couldn't get a PyLong from this PyObject");
+
+    return PythonObject::Reset(py_obj);
 }
 
 int64_t
 PythonInteger::GetInteger() const
 {
     if (m_py_obj)
     {
-        if (PyInt_Check(m_py_obj))
-            return PyInt_AsLong(m_py_obj);
-        else if (PyLong_Check(m_py_obj))
-            return PyLong_AsLongLong(m_py_obj);
+        assert(PyLong_Check(m_py_obj) && "PythonInteger::GetInteger has a PyObject that isn't a PyLong");
+
     }
     return UINT64_MAX;
 }
 
 void
 PythonInteger::SetInteger (int64_t value)
 {
     PythonObject::Reset(PyLong_FromLongLong(value));
 }
 
 StructuredData::IntegerSP
 PythonInteger::CreateStructuredInteger() const
 {
     StructuredData::IntegerSP result(new StructuredData::Integer);
     result->SetValue(GetInteger());
     return result;
 }
 
 //----------------------------------------------------------------------
 // PythonList
 //----------------------------------------------------------------------
 
-PythonList::PythonList (bool create_empty) :
-    PythonObject(create_empty ? PyList_New(0) : nullptr)
-{
-}
-
-PythonList::PythonList (uint32_t count) :
-    PythonObject(PyList_New(count))
+PythonList::PythonList()
+    : PythonObject(PyList_New(0))
 {
 }
 
 PythonList::PythonList (PyObject *py_obj) :
     PythonObject()
 {
     Reset(py_obj); // Use "Reset()" to ensure that py_obj is a list
 }
 
 
 PythonList::PythonList (const PythonObject &object) :
     PythonObject()
 {
     Reset(object.get()); // Use "Reset()" to ensure that py_obj is a list
 }
 
 PythonList::~PythonList ()
 {
 }
 
 bool
-PythonList::Reset (PyObject *py_obj)
+PythonList::Check(PyObject *py_obj)
 {
-    if (py_obj && PyList_Check(py_obj))
-        return PythonObject::Reset(py_obj);
-    
+    if (!py_obj)
+        return false;
+    return PyList_Check(py_obj);
+}
+bool
+PythonList::Reset(PyObject *py_obj)
+{
+    if (!PythonList::Check(py_obj))
+    {
         PythonObject::Reset(nullptr);
-    return py_obj == nullptr;
+        return false;
+    }
+
+    return PythonObject::Reset(py_obj);
 }
 
 uint32_t
 PythonList::GetSize() const
 {
     if (m_py_obj)
         return PyList_GET_SIZE(m_py_obj);
     return 0;
PythonList::CreateStructuredArray() const
     }
     return result;
 }
 
 //----------------------------------------------------------------------
 // PythonDictionary
 //----------------------------------------------------------------------
 
-PythonDictionary::PythonDictionary (bool create_empty) :
-PythonObject(create_empty ? PyDict_New() : nullptr)
+PythonDictionary::PythonDictionary()
+    : PythonObject(PyDict_New())
 {
 }
 
 PythonDictionary::PythonDictionary (PyObject *py_obj) :
     PythonObject(py_obj)
 {
     Reset(py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
 }
 
 
 PythonDictionary::PythonDictionary (const PythonObject &object) :
     PythonObject()
 {
     Reset(object.get()); // Use "Reset()" to ensure that py_obj is a dictionary
 }
 
 PythonDictionary::~PythonDictionary ()
 {
 }
 
 bool
-PythonDictionary::Reset (PyObject *py_obj)
+PythonDictionary::Check(PyObject *py_obj)
 {
-    if (py_obj && PyDict_Check(py_obj))
-        return PythonObject::Reset(py_obj);
-    
+    if (!py_obj)
+        return false;
+    return PyDict_Check(py_obj);
+}
+
+bool
+PythonDictionary::Reset(PyObject *py_obj)
+{
+    if (!PythonDictionary::Check(py_obj))
+    {
         PythonObject::Reset(nullptr);
-    return py_obj == nullptr;
+        return false;
+    }
+
+    return PythonObject::Reset(py_obj);
 }
 
 uint32_t
 PythonDictionary::GetSize() const
 {
     if (m_py_obj)
         return PyDict_Size(m_py_obj);
     return 0;

 
 
 const char *
 PythonDictionary::GetItemForKeyAsString (const PythonString &key, const char *fail_value) const
 {
     if (m_py_obj && key)
     {
         PyObject *py_obj = PyDict_GetItem(m_py_obj, key.get());
-        if (py_obj && PyString_Check(py_obj))
-            return PyString_AsString(py_obj);
+        if (py_obj && PythonString::Check(py_obj))
+        {
+            PythonString str(py_obj);
+            return str.GetString().data();
+        }
     }
     return fail_value;
 }
 
 int64_t
 PythonDictionary::GetItemForKeyAsInteger (const PythonString &key, int64_t fail_value) const
 {
     if (m_py_obj && key)
     {
         PyObject *py_obj = PyDict_GetItem(m_py_obj, key.get());
-        if (py_obj)
+        if (PythonInteger::Check(py_obj))
         {
-            if (PyInt_Check(py_obj))
-                return PyInt_AsLong(py_obj);
-
-            if (PyLong_Check(py_obj))
-                return PyLong_AsLong(py_obj);
+            PythonInteger int_obj(py_obj);
+            return int_obj.GetInteger();
         }
     }
     return fail_value;
 }
 
 PythonList
 PythonDictionary::GetKeys () const
 {
     if (m_py_obj)
         return PythonList(PyDict_Keys(m_py_obj));
-    return PythonList(true);
+    return PythonList();
 }
 
 PythonString
 PythonDictionary::GetKeyAtPosition (uint32_t pos) const
 {
     PyObject *key, *value;
     Py_ssize_t pos_iter = 0;
     

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
 #endif
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static ScriptInterpreterPython::SWIGInitCallback g_swig_init_callback = nullptr;
 static ScriptInterpreterPython::SWIGBreakpointCallbackFunction g_swig_breakpoint_callback = nullptr;
 static ScriptInterpreterPython::SWIGWatchpointCallbackFunction g_swig_watchpoint_callback = nullptr;
 static ScriptInterpreterPython::SWIGPythonTypeScriptCallbackFunction g_swig_typescript_callback = nullptr;

 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Frame g_swig_run_script_keyword_frame = nullptr;
 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Value g_swig_run_script_keyword_value = nullptr;
 static ScriptInterpreterPython::SWIGPython_GetDynamicSetting g_swig_plugin_get = nullptr;
 static ScriptInterpreterPython::SWIGPythonCreateScriptedThreadPlan g_swig_thread_plan_script = nullptr;
 static ScriptInterpreterPython::SWIGPythonCallThreadPlan g_swig_call_thread_plan = nullptr;
 
 static bool g_initialized = false;
 
+#if PY_MAJOR_VERSION >= 3 && defined(LLDB_PYTHON_HOME)
+typedef wchar_t PythonHomeChar;
+#else
+typedef char PythonHomeChar;
+#endif
+
+PythonHomeChar *
+GetDesiredPythonHome()
+{
+#if defined(LLDB_PYTHON_HOME)
+#if PY_MAJOR_VERSION >= 3
+    size_t size = 0;
+    static PythonHomeChar *g_python_home = Py_DecodeLocale(LLDB_PYTHON_HOME, &size);
+    return g_python_home;
+#else
+    static PythonHomeChar *g_python_home = LLDB_PYTHON_HOME;
+    return g_python_home;
+#endif
+#else
+    return nullptr;
+#endif
+}
+
 static std::string
 ReadPythonBacktrace (PyObject* py_backtrace);
 
 ScriptInterpreterPython::Locker::Locker (ScriptInterpreterPython *py_interpreter,
                                          uint16_t on_entry,
                                          uint16_t on_leave,
                                          FILE *in,
                                          FILE *out,
ScriptInterpreterPython::Locker::DoAcquireLock()
     if (log)
         log->Printf("Ensured PyGILState. Previous state = %slocked\n", 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_Current);
+    m_python_interpreter->SetThreadState(PyThreadState_Get());
     m_python_interpreter->IncrementLockCount();
     return true;
 }
 
 bool
 ScriptInterpreterPython::Locker::DoInitSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err)
 {
     if (!m_python_interpreter)

 
 bool
 ScriptInterpreterPython::Interrupt()
 {
     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT));
 
     if (IsExecutingPython())
     {
-        PyThreadState* state = _PyThreadState_Current;
+        PyThreadState *state = PyThreadState_Get();
         if (!state)
             state = GetThreadState();
         if (state)
         {
             long tid = state->thread_id;
-            _PyThreadState_Current = state;
+            PyThreadState_Swap(state);
             int num_threads = PyThreadState_SetAsyncExc(tid, PyExc_KeyboardInterrupt);
             if (log)
                 log->Printf("ScriptInterpreterPython::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");
ScriptInterpreterPython::ExecuteMultipleLines (const char *in_string, const ExecuteScriptOptions &options)
     }
 
     py_error = PyErr_Occurred();
     if (py_error != nullptr)
         PyErr_Clear();
     
     if (in_string != nullptr)
     {
-        struct _node *compiled_node = PyParser_SimpleParseString (in_string, Py_file_input);
+#if PY_MAJOR_VERSION >= 3
+        PyObject *code_object = Py_CompileString(in_string, "temp.py", Py_file_input);
+#else
+        PyCodeObject *code_object = nullptr;
+        struct _node *compiled_node = PyParser_SimpleParseString(in_string, Py_file_input);
         if (compiled_node)
-        {
-            PyCodeObject *compiled_code = PyNode_Compile (compiled_node, "temp.py");
-            if (compiled_code)
-            {
-              return_value.Reset(PyEval_EvalCode (compiled_code, globals.get(), locals.get()));
-            }
-        }
+            code_object = PyNode_Compile(compiled_node, "temp.py");
+#endif
+        if (code_object)
+            return_value.Reset(PyEval_EvalCode(code_object, globals.get(), locals.get()));
     }
 
     py_error = PyErr_Occurred ();
     if (py_error != nullptr)
     {
 //        puts(in_string);
 //        _PyObject_Dump (py_error);
 //        PyErr_Print();
 //        success = false;
         
         PyObject *type = nullptr;
         PyObject *value = nullptr;
         PyObject *traceback = nullptr;
         PyErr_Fetch (&type,&value,&traceback);
         
         // get the backtrace
         std::string bt = ReadPythonBacktrace(traceback);
         
         if (value && value != Py_None)
-            error.SetErrorStringWithFormat("%s\n%s", PyString_AsString(PyObject_Str(value)),bt.c_str());
+        {
+            PythonString str(value);
+            llvm::StringRef value_str(str.GetString());
+            error.SetErrorStringWithFormat("%s\n%s", value_str.str().c_str(), bt.c_str());
+        }
         else
             error.SetErrorStringWithFormat("%s",bt.c_str());
         Py_XDECREF(type);
         Py_XDECREF(value);
         Py_XDECREF(traceback);
         if (options.GetMaskoutErrors())
         {
             PyErr_Clear();
if (py_backtrace && py_backtrace != Py_None)
                     if (printTB && printTB != Py_None)
                     {
                         printTB_args = Py_BuildValue("OOO",py_backtrace,Py_None,stringIO_buffer);
                         printTB_result = PyObject_CallObject(printTB, printTB_args);
                         stringIO_getvalue = PyObject_GetAttrString(stringIO_buffer, "getvalue");
                         if (stringIO_getvalue && stringIO_getvalue != Py_None)
                         {
                             printTB_string = PyObject_CallObject (stringIO_getvalue,nullptr);
-                            if (printTB_string && printTB_string != Py_None && PyString_Check(printTB_string))
-                                retval.assign(PyString_AsString(printTB_string));
+                            if (printTB_string && PythonString::Check(printTB_string))
+                            {
+                                PythonString str(printTB_string);
+                                llvm::StringRef string_data(str.GetString());
+                                retval.assign(string_data.data(), string_data.size());
+                            }
                         }
                     }
                 }
             }
         }
     }
     Py_XDECREF(traceback_module);
     Py_XDECREF(stringIO_module);
ScriptInterpreterPython::GetShortHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
     PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
     
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {
         PyErr_Print();
         PyErr_Clear();
     }
-    
-    if (py_return != nullptr && py_return != Py_None)
-    {
-        if (PyString_Check(py_return))
-        {
-            dest.assign(PyString_AsString(py_return));
-            got_string = true;
-        }
-    }
+    if (py_return != Py_None && PythonString::Check(py_return))
+        PythonString py_string(py_return);
+        llvm::StringRef return_data(py_string.GetString());
+        dest.assign(return_data.data(), return_data.size());
     Py_XDECREF(py_return);
     
     return got_string;
 }
 
 uint32_t
 ScriptInterpreterPython::GetFlagsForCommandObject (StructuredData::GenericSP cmd_obj_sp)
 {
ScriptInterpreterPython::GetFlagsForCommandObject (StructuredData::GenericSP cmd_obj_sp)
     PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
     
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {
         PyErr_Print();
         PyErr_Clear();
     }
-    
-    if (py_return != nullptr && py_return != Py_None)
+    if (py_return != Py_None && PythonInteger::Check(py_return))
     {
-        if (PyInt_Check(py_return))
-            result = (uint32_t)PyInt_AsLong(py_return);
-        else if (PyLong_Check(py_return))
-            result = (uint32_t)PyLong_AsLong(py_return);
+        PythonInteger int_value(py_return);
+        result = int_value.GetInteger();
     }
     Py_XDECREF(py_return);
     
     return result;
 }
 
 bool
 ScriptInterpreterPython::GetLongHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
ScriptInterpreterPython::GetLongHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
     PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
     
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {
         PyErr_Print();
         PyErr_Clear();
     }
-    
-    if (py_return != nullptr && py_return != Py_None)
+    if (py_return != Py_None && PythonString::Check(py_return))
     {
-        if (PyString_Check(py_return))
-        {
-            dest.assign(PyString_AsString(py_return));
-            got_string = true;
-        }
-    }
+        PythonString str(py_return);
+        llvm::StringRef str_data(str.GetString());
+        dest.assign(str_data.data(), str_data.size());
     Py_XDECREF(py_return);
     
     return got_string;
 }
 
 std::unique_ptr<ScriptInterpreterLocker>
 ScriptInterpreterPython::AcquireInterpreterLock ()
 {
ScriptInterpreterPython::InitializePrivate ()
     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
 
     // Python will muck with STDIN terminal state, so save off any current TTY
     // settings so we can restore them.
     TerminalState stdin_tty_state;
     stdin_tty_state.Save(STDIN_FILENO, false);
 
 #if defined(LLDB_PYTHON_HOME)
-    Py_SetPythonHome(LLDB_PYTHON_HOME);
+    Py_SetPythonHome(GetDesiredPythonHome());
 #endif
+
     PyGILState_STATE gstate;
     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
     bool threads_already_initialized = false;
     if (PyEval_ThreadsInitialized ()) {
         gstate = PyGILState_Ensure ();
         if (log)
             log->Printf("Ensured PyGILState. Previous state = %slocked\n", gstate == PyGILState_UNLOCKED ? "un" : "");
         threads_already_initialized = true;

unittests/CMakeLists.txt

function(add_lldb_unittest test_name)
 
   lldb_link_common_libs(${test_name} EXE)
   target_link_libraries(${test_name} ${CLANG_USED_LIBS} ${LLDB_SYSTEM_LIBS})
   llvm_config(${test_name} ${LLVM_LINK_COMPONENTS})
 endfunction()
 
 add_subdirectory(Host)
 add_subdirectory(Interpreter)
+add_subdirectory(ScriptInterpreter)
 add_subdirectory(Utility)

unittests/ScriptInterpreter/CMakeLists.txt

+if (NOT LLDB_DISABLE_PYTHON)
+  add_subdirectory(Python)
+endif()
 No newline at end of file

unittests/ScriptInterpreter/Python/CMakeLists.txt

+add_lldb_unittest(ScriptInterpreterPythonTests
+  PythonDataObjectsTests.cpp
+  )
+
+  target_link_libraries(ScriptInterpreterPythonTests lldbPluginScriptInterpreterPython ${PYTHON_LIBRARY})
+  
 No newline at end of file

unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

+//===-- PythonDataObjectsTests.cpp ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Host/HostInfo.h"
+#include "Plugins/ScriptInterpreter/Python/lldb-python.h"
+#include "Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
+#include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
+
+using namespace lldb_private;
+
+class PythonDataObjectsTest : public testing::Test
+{
+  public:
+    void
+    SetUp() override
+    {
+        HostInfoBase::Initialize();
+        // ScriptInterpreterPython::Initialize() depends on things like HostInfo being initialized
+        // so it can compute the python directory etc, so we need to do this after
+        // SystemInitializerCommon::Initialize().
+        ScriptInterpreterPython::Initialize();
+    }
+
+    void
+    TearDown() override
+    {
+        ScriptInterpreterPython::Terminate();
+    }
+};
+
+TEST_F(PythonDataObjectsTest, TestPythonInteger)
+{
+// Test that integers behave correctly when wrapped by a PythonInteger.
+
+#if PY_MAJOR_VERSION < 3
+    // Verify that `PythonInt` works correctly when given a PyInt object.
+    // Note that PyInt doesn't exist in Python 3.x, so this is only for 2.x
+    PyObject *py_int = PyInt_FromLong(12);
+    EXPECT_TRUE(PythonInteger::Check(py_int));
+    PythonInteger python_int(py_int);
+
+    EXPECT_EQ(PyObjectType::Integer, python_int.GetObjectType());
+    EXPECT_EQ(12, python_int.GetInteger());
+#endif
+
+    // Verify that `PythonInt` works correctly when given a PyLong object.
+    PyObject *py_long = PyLong_FromLong(12);
+    EXPECT_TRUE(PythonInteger::Check(py_long));
+    PythonInteger python_long(py_long);
+    EXPECT_EQ(PyObjectType::Integer, python_long.GetObjectType());
+
+    // Verify that you can reset the value and that it is reflected properly.
+    python_long.SetInteger(40);
+    EXPECT_EQ(40, python_long.GetInteger());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonString)
+{
+    // Test that strings behave correctly when wrapped by a PythonString.
+
+    static const char *test_string = "PythonDataObjectsTest::TestPythonString";
+    static const char *test_string2 = "PythonDataObjectsTest::TestPythonString";
+
+#if PY_MAJOR_VERSION < 3
+    // Verify that `PythonString` works correctly when given a PyString object.
+    // Note that PyString doesn't exist in Python 3.x, so this is only for 2.x
+    PyObject *py_string = PyString_FromString(test_string);
+    EXPECT_TRUE(PythonString::Check(py_string));
+    PythonString python_string(py_string);
+
+    EXPECT_EQ(PyObjectType::String, python_string.GetObjectType());
+    EXPECT_STREQ(test_string, python_string.GetString().data());
+#endif
+
+    // Verify that `PythonString` works correctly when given a PyUnicode object.
+    PyObject *py_unicode = PyUnicode_FromString(test_string);
+    EXPECT_TRUE(PythonString::Check(py_unicode));
+    PythonString python_unicode(py_unicode);
+
+    EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType());
+    EXPECT_STREQ(test_string, python_unicode.GetString().data());
+
+    // Verify that you can reset the value and that it is reflected properly.
+    python_unicode.SetString(test_string2);
+    EXPECT_STREQ(test_string2, python_unicode.GetString().data());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonListPrebuilt)
+{
+    // Test that a list which is built through the native
+    // Python API behaves correctly when wrapped by a PythonList.
+    static const int list_size = 2;
+    static const long long_idx0 = 5;
+    static const char *const string_idx1 = "String Index 1";
+
+    PyObject *list_items[list_size];
+
+    PyObject *py_list = PyList_New(2);
+    list_items[0] = PyLong_FromLong(long_idx0);
+    list_items[1] = PyString_FromString(string_idx1);
+
+    for (int i = 0; i < list_size; ++i)
+        PyList_SetItem(py_list, i, list_items[i]);
+
+    EXPECT_TRUE(PythonList::Check(py_list));
+
+    PythonList list(py_list);
+    EXPECT_EQ(list_size, list.GetSize());
+    EXPECT_EQ(PyObjectType::List, list.GetObjectType());
+
+    // PythonList doesn't yet support getting objects by type.
+    // For now, we have to call CreateStructuredArray and use
+    // those objects.  That will be in a different test.
+    // TODO: Add the ability for GetItemByIndex() to return a
+    // typed object.
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonDictionaryPrebuilt)
+{
+    // Test that a dictionary which is built through the native
+    // Python API behaves correctly when wrapped by a PythonDictionary.
+    static const int dict_entries = 2;
+
+    PyObject *keys[dict_entries];
+    PyObject *values[dict_entries];
+
+    keys[0] = PyString_FromString("Key 0");
+    keys[1] = PyLong_FromLong(1);
+    values[0] = PyLong_FromLong(0);
+    values[1] = PyString_FromString("Value 1");
+
+    PyObject *py_dict = PyDict_New();
+    for (int i = 0; i < dict_entries; ++i)
+        PyDict_SetItem(py_dict, keys[i], values[i]);
+
+    EXPECT_TRUE(PythonDictionary::Check(py_dict));
+
+    PythonDictionary dict(py_dict);
+    EXPECT_EQ(dict.GetSize(), dict_entries);
+    EXPECT_EQ(PyObjectType::Dictionary, dict.GetObjectType());
+
+    // PythonDictionary doesn't yet support getting objects by type.
+    // For now, we have to call CreateStructuredDictionary and use
+    // those objects.  That will be in a different test.
+    // TODO: Add the ability for GetItemByKey() to return a
+    // typed object.
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonListManipulation)
+{
+    // Test that manipulation of a PythonList behaves correctly when
+    // wrapped by a PythonDictionary.
+
+    static const long long_idx0 = 5;
+    static const char *const string_idx1 = "String Index 1";
+
+    PyObject *py_list = PyList_New(0);
+    PythonList list(py_list);
+    PythonInteger integer(long_idx0);
+    PythonString string(string_idx1);
+
+    list.AppendItem(integer);
+    list.AppendItem(string);
+    EXPECT_EQ(2, list.GetSize());
+
+    // PythonList doesn't yet support getting typed objects out, so we
+    // can't easily test that the first item is an integer with the correct
+    // value, etc.
+    // TODO: Add the ability for GetItemByIndex() to return a
+    // typed object.
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonDictionaryManipulation)
+{
+    // Test that manipulation of a dictionary behaves correctly when wrapped
+    // by a PythonDictionary.
+    static const int dict_entries = 2;
+
+    PyObject *keys[dict_entries];
+    PyObject *values[dict_entries];
+
+    keys[0] = PyString_FromString("Key 0");
+    keys[1] = PyString_FromString("Key 1");
+    values[0] = PyLong_FromLong(1);
+    values[1] = PyString_FromString("Value 1");
+
+    PyObject *py_dict = PyDict_New();
+
+    PythonDictionary dict(py_dict);
+    for (int i = 0; i < 2; ++i)
+        dict.SetItemForKey(PythonString(keys[i]), values[i]);
+
+    EXPECT_EQ(dict_entries, dict.GetSize());
+
+    // PythonDictionary doesn't yet support getting objects by type.
+    // For now, we have to call CreateStructuredDictionary and use
+    // those objects.  That will be in a different test.
+    // TODO: Add the ability for GetItemByKey() to return a
+    // typed object.
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonListToStructuredObject)
+{
+    // Test that a PythonList is properly converted to a StructuredArray.
+    // This includes verifying that a list can contain a nested list as
+    // well as a nested dictionary.
+
+    static const int item_count = 4;
+    static const long long_idx0 = 5;
+    static const char *const string_idx1 = "String Index 1";
+
+    static const long nested_list_long_idx0 = 6;
+    static const char *const nested_list_str_idx1 = "Nested String Index 1";
+
+    static const char *const nested_dict_key0 = "Nested Key 0";
+    static const char *const nested_dict_value0 = "Nested Value 0";
+    static const char *const nested_dict_key1 = "Nested Key 1";
+    static const long nested_dict_value1 = 2;
+
+    PythonList list;
+    PythonList nested_list;
+    PythonDictionary nested_dict;
+
+    nested_list.AppendItem(PythonInteger(nested_list_long_idx0));
+    nested_list.AppendItem(PythonString(nested_list_str_idx1));
+    nested_dict.SetItemForKey(PythonString(nested_dict_key0), PythonString(nested_dict_value0));
+    nested_dict.SetItemForKey(PythonString(nested_dict_key1), PythonInteger(nested_dict_value1));
+
+    list.AppendItem(PythonInteger(long_idx0));
+    list.AppendItem(PythonString(string_idx1));
+    list.AppendItem(nested_list);
+    list.AppendItem(nested_dict);
+
+    EXPECT_EQ(item_count, list.GetSize());
+
+    StructuredData::ArraySP array_sp = list.CreateStructuredArray();
+    EXPECT_EQ(list.GetSize(), array_sp->GetSize());
+    EXPECT_EQ(StructuredData::Type::eTypeInteger, array_sp->GetItemAtIndex(0)->GetType());
+    EXPECT_EQ(StructuredData::Type::eTypeString, array_sp->GetItemAtIndex(1)->GetType());
+    EXPECT_EQ(StructuredData::Type::eTypeArray, array_sp->GetItemAtIndex(2)->GetType());
+    EXPECT_EQ(StructuredData::Type::eTypeDictionary, array_sp->GetItemAtIndex(3)->GetType());
+
+    auto list_int_sp = std::static_pointer_cast<StructuredData::Integer>(array_sp->GetItemAtIndex(0));
+    auto list_str_sp = std::static_pointer_cast<StructuredData::String>(array_sp->GetItemAtIndex(1));
+    auto list_list_sp = std::static_pointer_cast<StructuredData::Array>(array_sp->GetItemAtIndex(2));
+    auto list_dict_sp = std::static_pointer_cast<StructuredData::Dictionary>(array_sp->GetItemAtIndex(3));
+
+    // Verify that the first item (long) has the correct value
+    EXPECT_EQ(long_idx0, list_int_sp->GetValue());
+
+    // Verify that the second item (string) has the correct value
+    EXPECT_STREQ(string_idx1, list_str_sp->GetValue().c_str());
+
+    // Verify that the third item is a list with the correct length and element types
+    EXPECT_EQ(nested_list.GetSize(), list_list_sp->GetSize());
+    EXPECT_EQ(StructuredData::Type::eTypeInteger, list_list_sp->GetItemAtIndex(0)->GetType());
+    EXPECT_EQ(StructuredData::Type::eTypeString, list_list_sp->GetItemAtIndex(1)->GetType());
+    // Verify that the values of each element in the list are correct
+    auto nested_list_value_0 = std::static_pointer_cast<StructuredData::Integer>(list_list_sp->GetItemAtIndex(0));
+    auto nested_list_value_1 = std::static_pointer_cast<StructuredData::String>(list_list_sp->GetItemAtIndex(1));
+    EXPECT_EQ(nested_list_long_idx0, nested_list_value_0->GetValue());
+    EXPECT_STREQ(nested_list_str_idx1, nested_list_value_1->GetValue().c_str());
+
+    // Verify that the fourth item is a dictionary with the correct length
+    EXPECT_EQ(nested_dict.GetSize(), list_dict_sp->GetSize());
+    auto dict_keys = std::static_pointer_cast<StructuredData::Array>(list_dict_sp->GetKeys());
+
+    // Verify that all of the keys match the values and types of keys we inserted
+    EXPECT_EQ(StructuredData::Type::eTypeString, dict_keys->GetItemAtIndex(0)->GetType());
+    EXPECT_EQ(StructuredData::Type::eTypeString, dict_keys->GetItemAtIndex(1)->GetType());
+    auto nested_key_0 = std::static_pointer_cast<StructuredData::String>(dict_keys->GetItemAtIndex(0));
+    auto nested_key_1 = std::static_pointer_cast<StructuredData::String>(dict_keys->GetItemAtIndex(1));
+    EXPECT_STREQ(nested_dict_key0, nested_key_0->GetValue().c_str());
+    EXPECT_STREQ(nested_dict_key1, nested_key_1->GetValue().c_str());
+
+    // Verify that for each key, the value has the correct type and value as what we inserted.
+    auto nested_dict_value_0 = list_dict_sp->GetValueForKey(nested_key_0->GetValue());
+    auto nested_dict_value_1 = list_dict_sp->GetValueForKey(nested_key_1->GetValue());
+    EXPECT_EQ(StructuredData::Type::eTypeString, nested_dict_value_0->GetType());
+    EXPECT_EQ(StructuredData::Type::eTypeInteger, nested_dict_value_1->GetType());
+    auto nested_dict_str_value_0 = std::static_pointer_cast<StructuredData::String>(nested_dict_value_0);
+    auto nested_dict_int_value_1 = std::static_pointer_cast<StructuredData::Integer>(nested_dict_value_1);
+    EXPECT_STREQ(nested_dict_value0, nested_dict_str_value_0->GetValue().c_str());
+    EXPECT_EQ(nested_dict_value1, nested_dict_int_value_1->GetValue());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredObject)
+{
+    // Test that a PythonDictionary is properly converted to a
+    // StructuredDictionary.  This includes verifying that a dictionary
+    // can contain a nested dictionary as well as a nested list.
+
+    static const int dict_item_count = 4;
+    static const char *const dict_keys[dict_item_count] = {"Key 0 (str)", "Key 1 (long)", "Key 2 (dict)",
+                                                           "Key 3 (list)"};
+
+    static const StructuredData::Type dict_value_types[dict_item_count] = {
+        StructuredData::Type::eTypeString, StructuredData::Type::eTypeInteger, StructuredData::Type::eTypeDictionary,
+        StructuredData::Type::eTypeArray};
+
+    static const char *const nested_dict_keys[2] = {"Nested Key 0 (str)", "Nested Key 1 (long)"};
+
+    static const StructuredData::Type nested_dict_value_types[2] = {
+        StructuredData::Type::eTypeString, StructuredData::Type::eTypeInteger,
+    };
+
+    static const StructuredData::Type nested_list_value_types[2] = {StructuredData::Type::eTypeInteger,
+                                                                    StructuredData::Type::eTypeString};
+
+    static const char *const dict_value0 = "Value 0";
+    static const long dict_value1 = 2;
+
+    static const long nested_list_value0 = 5;
+    static const char *const nested_list_value1 = "Nested list string";
+
+    static const char *const nested_dict_value0 = "Nested Dict Value 0";
+    static const long nested_dict_value1 = 7;
+
+    PythonDictionary dict;
+    PythonDictionary nested_dict;
+    PythonList nested_list;
+
+    nested_dict.SetItemForKey(PythonString(nested_dict_keys[0]), PythonString(nested_dict_value0));
+    nested_dict.SetItemForKey(PythonString(nested_dict_keys[1]), PythonInteger(nested_dict_value1));
+
+    nested_list.AppendItem(PythonInteger(nested_list_value0));
+    nested_list.AppendItem(PythonString(nested_list_value1));
+
+    dict.SetItemForKey(PythonString(dict_keys[0]), PythonString(dict_value0));
+    dict.SetItemForKey(PythonString(dict_keys[1]), PythonInteger(dict_value1));
+    dict.SetItemForKey(PythonString(dict_keys[2]), nested_dict);
+    dict.SetItemForKey(PythonString(dict_keys[3]), nested_list);
+
+    StructuredData::DictionarySP dict_sp = dict.CreateStructuredDictionary();
+    EXPECT_EQ(dict_item_count, dict_sp->GetSize());
+    auto dict_keys_array = std::static_pointer_cast<StructuredData::Array>(dict_sp->GetKeys());
+
+    std::vector<StructuredData::StringSP> converted_keys;
+    std::vector<StructuredData::ObjectSP> converted_values;
+    // Verify that all of the keys match the values and types of keys we inserted
+    // (Keys are always strings, so this is easy)
+    for (int i = 0; i < dict_sp->GetSize(); ++i)
+    {
+        EXPECT_EQ(StructuredData::Type::eTypeString, dict_keys_array->GetItemAtIndex(i)->GetType());
+        auto converted_key = std::static_pointer_cast<StructuredData::String>(dict_keys_array->GetItemAtIndex(i));
+        converted_keys.push_back(converted_key);
+        converted_values.push_back(dict_sp->GetValueForKey(converted_key->GetValue().c_str()));
+
+        EXPECT_STREQ(dict_keys[i], converted_key->GetValue().c_str());
+        EXPECT_EQ(dict_value_types[i], converted_values[i]->GetType());
+    }
+
+    auto dict_string_value = std::static_pointer_cast<StructuredData::String>(converted_values[0]);
+    auto dict_int_value = std::static_pointer_cast<StructuredData::Integer>(converted_values[1]);
+    auto dict_dict_value = std::static_pointer_cast<StructuredData::Dictionary>(converted_values[2]);
+    auto dict_list_value = std::static_pointer_cast<StructuredData::Array>(converted_values[3]);
+
+    // The first two dictionary values are easy to test, because they are just a string and an integer.
+    EXPECT_STREQ(dict_value0, dict_string_value->GetValue().c_str());
+    EXPECT_EQ(dict_value1, dict_int_value->GetValue());
+
+    // For the nested dictionary, repeat the same process as before.
+    EXPECT_EQ(2, dict_dict_value->GetSize());
+    auto nested_dict_keys_array = std::static_pointer_cast<StructuredData::Array>(dict_dict_value->GetKeys());
+
+    std::vector<StructuredData::StringSP> nested_converted_keys;
+    std::vector<StructuredData::ObjectSP> nested_converted_values;
+    // Verify that all of the keys match the values and types of keys we inserted
+    // (Keys are always strings, so this is easy)
+    for (int i = 0; i < dict_dict_value->GetSize(); ++i)
+    {
+        EXPECT_EQ(StructuredData::Type::eTypeString, nested_dict_keys_array->GetItemAtIndex(i)->GetType());
+        auto converted_key =
+            std::static_pointer_cast<StructuredData::String>(nested_dict_keys_array->GetItemAtIndex(i));
+        nested_converted_keys.push_back(converted_key);
+        nested_converted_values.push_back(dict_dict_value->GetValueForKey(converted_key->GetValue().c_str()));
+
+        EXPECT_STREQ(nested_dict_keys[i], converted_key->GetValue().c_str());
+        EXPECT_EQ(nested_dict_value_types[i], converted_values[i]->GetType());
+    }
+
+    auto converted_nested_dict_value_0 = std::static_pointer_cast<StructuredData::String>(nested_converted_values[0]);
+    auto converted_nested_dict_value_1 = std::static_pointer_cast<StructuredData::Integer>(nested_converted_values[1]);
+
+    // The first two dictionary values are easy to test, because they are just a string and an integer.
+    EXPECT_STREQ(nested_dict_value0, converted_nested_dict_value_0->GetValue().c_str());
+    EXPECT_EQ(nested_dict_value1, converted_nested_dict_value_1->GetValue());
+
+    // For the nested list, just verify the size, type and value of each item
+    nested_converted_values.clear();
+    EXPECT_EQ(2, dict_list_value->GetSize());
+    for (int i = 0; i < dict_list_value->GetSize(); ++i)
+    {
+        auto converted_value = dict_list_value->GetItemAtIndex(i);
+        EXPECT_EQ(nested_list_value_types[i], converted_value->GetType());
+        nested_converted_values.push_back(converted_value);
+    }
+
+    auto converted_nested_list_value_0 = std::static_pointer_cast<StructuredData::Integer>(nested_converted_values[0]);
+    auto converted_nested_list_value_1 = std::static_pointer_cast<StructuredData::String>(nested_converted_values[1]);
+    EXPECT_EQ(nested_list_value0, converted_nested_list_value_0->GetValue());
+    EXPECT_STREQ(nested_list_value1, converted_nested_list_value_1->GetValue().c_str());
+}