[ldlb/SWIG] Refactor extensions to be non Python-specific.

[JDevlieghere]

Summary

The current SWIG extensions for the string conversion operator is Python specific because it uses the PythonObjects. This means that the code cannot be reused for Lua. I propose to rewrite this extension by using ConstString instead.

[JDevlieghere]

lldb/scripts/extensions.swig

4 ↗

(On Diff #236722)

of course this should be factored out and reused across different SB classes.

lldb/scripts/lldb.swig

101

This is unfortunate but not worse that what's already done for PythonDataObjects.h.

[JDevlieghere]

lldb/scripts/extensions.swig

9 ↗

(On Diff #236722)

I don't think this is the responsibility of the bindings, but for now I've kept it to make this a non-functional change.

[JDevlieghere]

Include ConstString.h once in extensions.swig.

[labath]

I think this is a great direction to move in. If the extensions are written in C(++) then swig can automatically wrap everything we need.

I am wondering if we can avoid constifying each string we return this way though...

lldb/scripts/extensions.swig

16–17 ↗

(On Diff #236763)

Would it be possible to return std::string from here? I don't think this is really a public API (it's not accessible from C++, and swig should convert it into a native string before anything can get its hand on it), so I don't we need to be constrained by the SB API rules. And I believe swig already knows how to handle a std::string...

4 ↗

(On Diff #236722)

Yes, but for now I'd put this code into SBTarget.i, since it's clearly SBTarget specific. If we have some generic extension code (produced by factoring this function for instance), then we can put it into some more generic place.

9 ↗

(On Diff #236722)

FWIW, I don't find it particularly bad, especially when it gets factored into a function...

[JDevlieghere]

• Use std::string
• Move extension into the corresponding interface file

[labath]

cool

lldb/scripts/interface/SBTarget.i

1085–1086

delete?

lldb/scripts/Python/python-extensions.swig

%extend lldb::SBSymbolContextList {
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 return PythonString(llvm::StringRef(desc, desc_len)).release();
         }
         %clearnothreadallow;
 }
 
 %extend lldb::SBTarget {
-        %nothreadallow;
-        PyObject *lldb::SBTarget::__str__ (){
-                lldb::SBStream description;
-                $self->GetDescription (description, lldb::eDescriptionLevelBrief);
-                const char *desc = description.GetData();
-                size_t desc_len = description.GetSize();
-                if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
-                    --desc_len;
-                return PythonString(llvm::StringRef(desc, desc_len)).release();
-        }
-        %clearnothreadallow;
-
     %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):

lldb/scripts/interface/SBTarget.i

 //===-- SWIG Interface for SBTarget -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 namespace lldb {
 
-
 %feature("docstring",
 "Represents the target program running under the debugger.
 
 SBTarget supports module, breakpoint, and watchpoint iterations. For example,
 
     for m in target.module_iter():
         print m
 
#endif
     operator != (const lldb::SBTarget &rhs) const;
 
     lldb::SBValue
     EvaluateExpression (const char *expr);
 
     lldb::SBValue
     EvaluateExpression (const char *expr, const lldb::SBExpressionOptions &options);
 
+  %extend {
+    %nothreadallow;
+    std::string lldb::SBTarget::__str__(){
+      lldb::SBStream stream;
+      $self->GetDescription (stream, lldb::eDescriptionLevelBrief);
+
+      const char *desc = stream.GetData();
+      size_t desc_len = stream.GetSize();
+      if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
+        --desc_len;
+
+      return std::string(desc, desc_len);
+    }
+    %clearnothreadallow;
+  }
+
 #ifdef SWIGPYTHON
     %pythoncode %{
         class modules_access(object):
             '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
             def __init__(self, sbtarget):
                 self.sbtarget = sbtarget
 
             def __len__(self):
%pythoncode %{
         triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this target as a string.''')
         data_byte_size = property(GetDataByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the data address space for this target.''')
         code_byte_size = property(GetCodeByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the code address space for this target.''')
         platform = property(GetPlatform, None, doc='''A read only property that returns the platform associated with with this target.''')
     %}
 #endif
 };
 } // namespace lldb
+
+

lldb/scripts/lldb.swig

 def lldb_iter(obj, getsize, getelem):
     """A generator adaptor to support iteration for lldb container objects."""
     size = getattr(obj, getsize)
     elem = getattr(obj, getelem)
     for i in range(size()):
         yield elem(i)
 %}
 
+%include <std_string.i>
 %include "./Python/python-typemaps.swig"
 %include "./headers.swig"
 
 %{
 #include "../source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
 #include "../scripts/Python/python-swigsafecast.swig"
 using namespace lldb_private;
 using namespace lldb_private::python;
 using namespace lldb;
 %}
 
 %include "./interfaces.swig"
 %include "./Python/python-extensions.swig"

lldb/scripts/lldb_lua.swig

 /*
    lldb.swig
 
    This is the input file for SWIG, to create the appropriate C++ wrappers and
    functions for various scripting languages, to enable them to call the
    liblldb Script Bridge functions.
 */
 
 %module lldb
 
+%include <std_string.i>
 %include "./headers.swig"
 
 %{
 using namespace lldb_private;
 using namespace lldb;
 %}
 
 %include "./interfaces.swig"