| /* Typemap definitions, to allow SWIG to properly handle 'char**' data types. |
| |
| NOTE: If there's logic to free memory in a %typemap(freearg), it will also be |
| run if you call SWIG_fail on an error path. Don't manually free() an argument |
| AND call SWIG_fail at the same time, because it will result in a double free. |
| |
| */ |
| |
| %inline %{ |
| |
| #include "../bindings/python/python-typemaps.h" |
| |
| %} |
| |
| %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"); |
| SWIG_fail; |
| } |
| |
| $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"); |
| SWIG_fail; |
| } |
| } |
| |
| %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); |
| } |
| |
| %typecheck(SWIG_TYPECHECK_POINTER) lldb::ScriptObjectPtr { |
| PythonObject obj(PyRefType::Borrowed, $input); |
| if (!obj.IsValid()) { |
| PyErr_Clear(); |
| $1 = 0; |
| } else { |
| $1 = 1; |
| } |
| } |
| |
| %typemap(in) lldb::ScriptObjectPtr { |
| if ($input == Py_None) { |
| $1 = nullptr; |
| } else { |
| PythonObject obj(PyRefType::Borrowed, $input); |
| if (!obj.IsValid()) { |
| PyErr_SetString(PyExc_TypeError, "Script object is not valid"); |
| SWIG_fail; |
| } |
| |
| auto lldb_module = PythonModule::Import("lldb"); |
| if (!lldb_module) { |
| std::string err_msg = llvm::toString(lldb_module.takeError()); |
| PyErr_SetString(PyExc_TypeError, err_msg.c_str()); |
| SWIG_fail; |
| } |
| |
| auto sb_structured_data_class = lldb_module.get().Get("SBStructuredData"); |
| if (!sb_structured_data_class) { |
| std::string err_msg = llvm::toString(sb_structured_data_class.takeError()); |
| PyErr_SetString(PyExc_TypeError, err_msg.c_str()); |
| SWIG_fail; |
| } |
| |
| if (obj.IsInstance(sb_structured_data_class.get())) { |
| $1 = obj.get(); |
| } else { |
| auto type = obj.GetType(); |
| if (!type) { |
| std::string err_msg = llvm::toString(type.takeError()); |
| PyErr_SetString(PyExc_TypeError, err_msg.c_str()); |
| SWIG_fail; |
| } |
| |
| auto type_name = As<std::string>(type.get().GetAttribute("__name__")); |
| if (!type_name) { |
| std::string err_msg = llvm::toString(type_name.takeError()); |
| PyErr_SetString(PyExc_TypeError, err_msg.c_str()); |
| SWIG_fail; |
| } |
| |
| if (llvm::StringRef(type_name.get()).starts_with("SB")) { |
| std::string error_msg = "Input type is invalid: " + type_name.get(); |
| PyErr_SetString(PyExc_TypeError, error_msg.c_str()); |
| SWIG_fail; |
| } else { |
| $1 = obj.get(); |
| } |
| } |
| } |
| } |
| |
| %typemap(out) lldb::ScriptObjectPtr { |
| $result = (PyObject*) $1; |
| if (!$result) |
| $result = Py_None; |
| Py_INCREF($result); |
| } |
| |
| %typemap(out) lldb::SBScriptObject { |
| $result = nullptr; |
| if (const void* impl = $1.GetPointer()) |
| $result = (PyObject*) impl; |
| if (!$result) { |
| $result = Py_None; |
| Py_INCREF(Py_None); |
| } else { |
| Py_INCREF($result); |
| } |
| } |
| |
| %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 { |
| PythonObject obj = Retain<PythonObject>($input); |
| lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj)); |
| if (PyErr_Occurred()) |
| SWIG_fail; |
| $1 = value; |
| } |
| |
| %typemap(in) lldb::StateType { |
| PythonObject obj = Retain<PythonObject>($input); |
| unsigned long long state_type_value = |
| unwrapOrSetPythonException(As<unsigned long long>(obj)); |
| if (PyErr_Occurred()) |
| SWIG_fail; |
| if (state_type_value > lldb::StateType::kLastStateType) { |
| PyErr_SetString(PyExc_ValueError, "Not a valid StateType value"); |
| SWIG_fail; |
| } |
| $1 = static_cast<lldb::StateType>(state_type_value); |
| } |
| |
| /* Typemap definitions to allow SWIG to properly handle char buffer. */ |
| |
| // typemap for a char buffer |
| %typemap(in) (char *dst, size_t dst_len) { |
| if (!PyLong_Check($input)) { |
| PyErr_SetString(PyExc_ValueError, "Expecting an integer"); |
| SWIG_fail; |
| } |
| $2 = PyLong_AsLong($input); |
| if ($2 <= 0) { |
| PyErr_SetString(PyExc_ValueError, "Positive integer expected"); |
| SWIG_fail; |
| } |
| $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 |
| %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 handling an snprintf-like API like SBThread::GetStopDescription. |
| %typemap(in) (char *dst_or_null, size_t dst_len) { |
| if (!PyLong_Check($input)) { |
| PyErr_SetString(PyExc_ValueError, "Expecting an integer"); |
| SWIG_fail; |
| } |
| $2 = PyLong_AsLong($input); |
| if ($2 <= 0) { |
| PyErr_SetString(PyExc_ValueError, "Positive integer expected"); |
| SWIG_fail; |
| } |
| $1 = (char *)malloc($2); |
| } |
| %typemap(argout) (char *dst_or_null, size_t dst_len) { |
| Py_XDECREF($result); /* Blow away any previous result */ |
| llvm::StringRef ref($1); |
| PythonString string(ref); |
| $result = string.release(); |
| free($1); |
| } |
| |
| |
| // 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"); |
| SWIG_fail; |
| } |
| } |
| // 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"); |
| SWIG_fail; |
| } |
| } |
| |
| // typemap for an incoming buffer |
| // See also SBProcess::ReadMemory. |
| %typemap(in) (void *buf, size_t size) { |
| if (PyLong_Check($input)) { |
| $2 = PyLong_AsLong($input); |
| } else { |
| PyErr_SetString(PyExc_ValueError, "Expecting an integer or long object"); |
| SWIG_fail; |
| } |
| if ($2 <= 0) { |
| PyErr_SetString(PyExc_ValueError, "Positive integer expected"); |
| SWIG_fail; |
| } |
| $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 (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"); |
| SWIG_fail; |
| } |
| |
| if (PyErr_Occurred()) { |
| SWIG_fail; |
| } |
| } |
| } else if ($input == Py_None) { |
| $1 = NULL; |
| $2 = 0; |
| } else { |
| PyErr_SetString(PyExc_TypeError, "not a list"); |
| SWIG_fail; |
| } |
| } |
| |
| %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 = PyLong_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!"); |
| SWIG_fail; |
| } |
| |
| // 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)); |
| } |
| |
| // For lldb::SBDebuggerDestroyCallback |
| %typemap(in) (lldb::SBDebuggerDestroyCallback destroy_callback, void *baton) { |
| if (!($input == Py_None || |
| PyCallable_Check(reinterpret_cast<PyObject *>($input)))) { |
| PyErr_SetString(PyExc_TypeError, "Need a callable object or None!"); |
| SWIG_fail; |
| } |
| |
| // FIXME (filcab): We can't currently check if our callback is already |
| // LLDBSwigPythonCallPythonSBDebuggerTerminateCallback (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 = LLDBSwigPythonCallPythonSBDebuggerTerminateCallback; |
| $2 = $input; |
| } |
| |
| %typemap(typecheck) (lldb::SBDebuggerDestroyCallback destroy_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"); |
| SWIG_fail; |
| } |
| auto sp = unwrapOrSetPythonException(py_file.ConvertToFile()); |
| if (!sp) |
| SWIG_fail; |
| $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"); |
| SWIG_fail; |
| } |
| auto sp = unwrapOrSetPythonException( |
| py_file.ConvertToFileForcingUseOfScriptingIOMethods()); |
| if (!sp) |
| SWIG_fail; |
| $1 = sp; |
| } |
| |
| %typemap(in) lldb::FileSP BORROWED { |
| PythonFile py_file(PyRefType::Borrowed, $input); |
| if (!py_file) { |
| PyErr_SetString(PyExc_TypeError, "not a file"); |
| SWIG_fail; |
| } |
| auto sp = |
| unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true)); |
| if (!sp) |
| SWIG_fail; |
| $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"); |
| SWIG_fail; |
| } |
| auto sp = unwrapOrSetPythonException( |
| py_file.ConvertToFileForcingUseOfScriptingIOMethods(/*borrowed=*/true)); |
| if (!sp) |
| SWIG_fail; |
| $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; |
| const lldb::FileSP &sp = $1; |
| if (sp) { |
| PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp)); |
| if (!pyfile.IsValid()) |
| SWIG_fail; |
| $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"); |
| SWIG_fail; |
| } |
| } |
| |
| // 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 |
| // |
| // I've also moved the call to PyBuffer_Release to the end of the SWIG wrapper, |
| // doing it right away is not legal according to the python buffer protocol. |
| |
| %define %pybuffer_mutable_binary(TYPEMAP, SIZE) |
| %typemap(in) (TYPEMAP, SIZE) (Py_buffer_RAII view) { |
| int res; |
| Py_ssize_t size = 0; |
| void *buf = 0; |
| res = PyObject_GetBuffer($input, &view.buffer, PyBUF_WRITABLE); |
| if (res < 0) { |
| PyErr_Clear(); |
| %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum); |
| } |
| size = view.buffer.len; |
| buf = view.buffer.buf; |
| $1 = ($1_ltype)buf; |
| $2 = ($2_ltype)(size / sizeof($*1_type)); |
| } |
| %enddef |
| |
| %define %pybuffer_binary(TYPEMAP, SIZE) |
| %typemap(in) (TYPEMAP, SIZE) (Py_buffer_RAII view) { |
| int res; |
| Py_ssize_t size = 0; |
| const void *buf = 0; |
| res = PyObject_GetBuffer($input, &view.buffer, PyBUF_CONTIG_RO); |
| if (res < 0) { |
| PyErr_Clear(); |
| %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum); |
| } |
| size = view.buffer.len; |
| buf = view.buffer.buf; |
| $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); |
| |
| %typemap(in) (const char **symbol_name, uint32_t num_names) { |
| using namespace lldb_private; |
| /* Check if is a list */ |
| if (PythonList::Check($input)) { |
| PythonList list(PyRefType::Borrowed, $input); |
| $2 = list.GetSize(); |
| int i = 0; |
| $1 = (char**)malloc(($2+1)*sizeof(char*)); |
| for (i = 0; i < $2; i++) { |
| PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>(); |
| if (!py_str.IsAllocated()) { |
| PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby"); |
| 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; |
| } |
| } |
| |
| // For lldb::SBPlatformLocateModuleCallback |
| %typemap(in) (lldb::SBPlatformLocateModuleCallback callback, |
| void *callback_baton) { |
| if (!($input == Py_None || |
| PyCallable_Check(reinterpret_cast<PyObject *>($input)))) { |
| PyErr_SetString(PyExc_TypeError, "Need a callable object or None!"); |
| SWIG_fail; |
| } |
| |
| if ($input == Py_None) { |
| $1 = nullptr; |
| $2 = nullptr; |
| } else { |
| PythonCallable callable = Retain<PythonCallable>($input); |
| if (!callable.IsValid()) { |
| PyErr_SetString(PyExc_TypeError, "Need a valid callable object"); |
| SWIG_fail; |
| } |
| |
| llvm::Expected<PythonCallable::ArgInfo> arg_info = callable.GetArgInfo(); |
| if (!arg_info) { |
| PyErr_SetString(PyExc_TypeError, |
| ("Could not get arguments: " + |
| llvm::toString(arg_info.takeError())).c_str()); |
| SWIG_fail; |
| } |
| |
| if (arg_info.get().max_positional_args != 3) { |
| PyErr_SetString(PyExc_TypeError, "Expected 3 argument callable object"); |
| SWIG_fail; |
| } |
| |
| // NOTE: When this is called multiple times, this will leak the Python |
| // callable object as other callbacks, because this does not call Py_DECREF |
| // the object. But it should be almost zero impact since this method is |
| // expected to be called only once. |
| |
| // Don't lose the callback reference |
| Py_INCREF($input); |
| |
| $1 = LLDBSwigPythonCallLocateModuleCallback; |
| $2 = $input; |
| } |
| } |
| |
| %typemap(typecheck) (lldb::SBPlatformLocateModuleCallback callback, |
| void *callback_baton) { |
| $1 = $input == Py_None; |
| $1 = $1 || PyCallable_Check(reinterpret_cast<PyObject *>($input)); |
| } |