From c751ddb87a679ac8b50001fe2ccf3251f4c27aaf Mon Sep 17 00:00:00 2001 From: Med Ismail Bennani Date: Wed, 5 Nov 2025 16:02:02 -0800 Subject: [PATCH 1/5] [lldb] Introduce SBFrameList for lazy frame iteration (#166651) This patch introduces `SBFrameList`, a new SBAPI class that allows iterating over stack frames lazily without calling `SBThread::GetFrameAtIndex` in a loop. The new `SBThread::GetFrames()` method returns an `SBFrameList` that supports Python iteration (`for frame in frame_list:`), indexing (`frame_list[0]`, `frame_list[-1]`), and length queries (`len()`). The implementation uses `StackFrameListSP` as the opaque pointer, sharing the thread's underlying frame list to ensure frames are materialized on-demand. This is particularly useful for ScriptedFrameProviders, where user scripts will be to iterate, filter, and replace frames lazily without materializing the entire stack upfront. Signed-off-by: Med Ismail Bennani (cherry picked from commit d584d00ed250e547c9910e0a93b7f9d07f2e71c3) --- .../interface/SBFrameListExtensions.i | 41 ++++ lldb/bindings/interface/SBThreadExtensions.i | 3 +- lldb/bindings/interfaces.swig | 2 + lldb/include/lldb/API/LLDB.h | 1 + lldb/include/lldb/API/SBDefines.h | 1 + lldb/include/lldb/API/SBFrame.h | 1 + lldb/include/lldb/API/SBFrameList.h | 82 ++++++++ lldb/include/lldb/API/SBStream.h | 1 + lldb/include/lldb/API/SBThread.h | 3 + lldb/include/lldb/Target/StackFrameList.h | 3 + lldb/include/lldb/Target/Thread.h | 4 +- lldb/source/API/CMakeLists.txt | 1 + lldb/source/API/SBFrameList.cpp | 97 +++++++++ lldb/source/API/SBThread.cpp | 21 ++ lldb/test/API/python_api/frame_list/Makefile | 3 + .../python_api/frame_list/TestSBFrameList.py | 194 ++++++++++++++++++ lldb/test/API/python_api/frame_list/main.cpp | 22 ++ 17 files changed, 477 insertions(+), 3 deletions(-) create mode 100644 lldb/bindings/interface/SBFrameListExtensions.i create mode 100644 lldb/include/lldb/API/SBFrameList.h create mode 100644 lldb/source/API/SBFrameList.cpp create mode 100644 lldb/test/API/python_api/frame_list/Makefile create mode 100644 lldb/test/API/python_api/frame_list/TestSBFrameList.py create mode 100644 lldb/test/API/python_api/frame_list/main.cpp diff --git a/lldb/bindings/interface/SBFrameListExtensions.i b/lldb/bindings/interface/SBFrameListExtensions.i new file mode 100644 index 0000000000000..1c6ac8d50a54c --- /dev/null +++ b/lldb/bindings/interface/SBFrameListExtensions.i @@ -0,0 +1,41 @@ +%extend lldb::SBFrameList { + +#ifdef SWIGPYTHON + %nothreadallow; +#endif + std::string lldb::SBFrameList::__str__ (){ + lldb::SBStream description; + if (!$self->GetDescription(description)) + return std::string(" lldb.SBFrameList()"); + 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 std::string(desc, desc_len); + } +#ifdef SWIGPYTHON + %clearnothreadallow; +#endif + +#ifdef SWIGPYTHON + %pythoncode %{ + def __iter__(self): + '''Iterate over all frames in a lldb.SBFrameList object.''' + return lldb_iter(self, 'GetSize', 'GetFrameAtIndex') + + def __len__(self): + return int(self.GetSize()) + + def __getitem__(self, key): + if type(key) is not int: + return None + if key < 0: + count = len(self) + if -count <= key < count: + key %= count + + frame = self.GetFrameAtIndex(key) + return frame if frame.IsValid() else None + %} +#endif +} diff --git a/lldb/bindings/interface/SBThreadExtensions.i b/lldb/bindings/interface/SBThreadExtensions.i index 267faad9d651f..288b4fccb80c5 100644 --- a/lldb/bindings/interface/SBThreadExtensions.i +++ b/lldb/bindings/interface/SBThreadExtensions.i @@ -41,7 +41,8 @@ STRING_EXTENSION_OUTSIDE(SBThread) def get_thread_frames(self): '''An accessor function that returns a list() that contains all frames in a lldb.SBThread object.''' frames = [] - for frame in self: + frame_list = self.GetFrames() + for frame in frame_list: frames.append(frame) return frames diff --git a/lldb/bindings/interfaces.swig b/lldb/bindings/interfaces.swig index e71ed136f20e6..95a732d29c7e0 100644 --- a/lldb/bindings/interfaces.swig +++ b/lldb/bindings/interfaces.swig @@ -118,6 +118,7 @@ %include "lldb/API/SBFileSpecList.h" %include "lldb/API/SBFormat.h" %include "lldb/API/SBFrame.h" +%include "lldb/API/SBFrameList.h" %include "lldb/API/SBFunction.h" %include "lldb/API/SBHostOS.h" %include "lldb/API/SBInstruction.h" @@ -192,6 +193,7 @@ %include "./interface/SBFileSpecExtensions.i" %include "./interface/SBFileSpecListExtensions.i" %include "./interface/SBFrameExtensions.i" +%include "./interface/SBFrameListExtensions.i" %include "./interface/SBFunctionExtensions.i" %include "./interface/SBInstructionExtensions.i" %include "./interface/SBInstructionListExtensions.i" diff --git a/lldb/include/lldb/API/LLDB.h b/lldb/include/lldb/API/LLDB.h index 6485f35302a1c..6ac35bb4a364b 100644 --- a/lldb/include/lldb/API/LLDB.h +++ b/lldb/include/lldb/API/LLDB.h @@ -37,6 +37,7 @@ #include "lldb/API/SBFileSpecList.h" #include "lldb/API/SBFormat.h" #include "lldb/API/SBFrame.h" +#include "lldb/API/SBFrameList.h" #include "lldb/API/SBFunction.h" #include "lldb/API/SBHostOS.h" #include "lldb/API/SBInstruction.h" diff --git a/lldb/include/lldb/API/SBDefines.h b/lldb/include/lldb/API/SBDefines.h index 85f6bbeea5bf9..5fcc685050c0b 100644 --- a/lldb/include/lldb/API/SBDefines.h +++ b/lldb/include/lldb/API/SBDefines.h @@ -76,6 +76,7 @@ class LLDB_API SBFileSpec; class LLDB_API SBFileSpecList; class LLDB_API SBFormat; class LLDB_API SBFrame; +class LLDB_API SBFrameList; class LLDB_API SBFunction; class LLDB_API SBHostOS; class LLDB_API SBInstruction; diff --git a/lldb/include/lldb/API/SBFrame.h b/lldb/include/lldb/API/SBFrame.h index 0f2c2c68087c8..d0b025efa4bdc 100644 --- a/lldb/include/lldb/API/SBFrame.h +++ b/lldb/include/lldb/API/SBFrame.h @@ -225,6 +225,7 @@ class LLDB_API SBFrame { protected: friend class SBBlock; friend class SBExecutionContext; + friend class SBFrameList; friend class SBInstruction; friend class SBThread; friend class SBValue; diff --git a/lldb/include/lldb/API/SBFrameList.h b/lldb/include/lldb/API/SBFrameList.h new file mode 100644 index 0000000000000..dba1c1de5d191 --- /dev/null +++ b/lldb/include/lldb/API/SBFrameList.h @@ -0,0 +1,82 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_API_SBFRAMELIST_H +#define LLDB_API_SBFRAMELIST_H + +#include "lldb/API/SBDefines.h" + +namespace lldb { + +/// Represents a list of SBFrame objects. +/// +/// SBFrameList provides a way to iterate over stack frames lazily, +/// materializing frames on-demand as they are accessed. This is more +/// efficient than eagerly creating all frames upfront. +class LLDB_API SBFrameList { +public: + SBFrameList(); + + SBFrameList(const lldb::SBFrameList &rhs); + + ~SBFrameList(); + + const lldb::SBFrameList &operator=(const lldb::SBFrameList &rhs); + + explicit operator bool() const; + + bool IsValid() const; + + /// Returns the number of frames in the list. + uint32_t GetSize() const; + + /// Returns the frame at the given index. + /// + /// \param[in] idx + /// The index of the frame to retrieve (0-based). + /// + /// \return + /// An SBFrame object for the frame at the specified index. + /// Returns an invalid SBFrame if idx is out of range. + lldb::SBFrame GetFrameAtIndex(uint32_t idx) const; + + /// Get the thread associated with this frame list. + /// + /// \return + /// An SBThread object representing the thread. + lldb::SBThread GetThread() const; + + /// Clear all frames from this list. + void Clear(); + + /// Get a description of this frame list. + /// + /// \param[in] description + /// The stream to write the description to. + /// + /// \return + /// True if the description was successfully written. + bool GetDescription(lldb::SBStream &description) const; + +protected: + friend class SBThread; + +private: + SBFrameList(const lldb::StackFrameListSP &frame_list_sp); + + void SetFrameList(const lldb::StackFrameListSP &frame_list_sp); + + // This needs to be a shared_ptr since an SBFrameList can be passed to + // scripting affordances like ScriptedFrameProviders but also out of + // convenience because Thread::GetStackFrameList returns a StackFrameListSP. + lldb::StackFrameListSP m_opaque_sp; +}; + +} // namespace lldb + +#endif // LLDB_API_SBFRAMELIST_H diff --git a/lldb/include/lldb/API/SBStream.h b/lldb/include/lldb/API/SBStream.h index d230da6123fb3..21f9d21e0e717 100644 --- a/lldb/include/lldb/API/SBStream.h +++ b/lldb/include/lldb/API/SBStream.h @@ -81,6 +81,7 @@ class LLDB_API SBStream { friend class SBFileSpec; friend class SBFileSpecList; friend class SBFrame; + friend class SBFrameList; friend class SBFunction; friend class SBInstruction; friend class SBInstructionList; diff --git a/lldb/include/lldb/API/SBThread.h b/lldb/include/lldb/API/SBThread.h index a53799e7e55c5..e71bdd3e402d7 100644 --- a/lldb/include/lldb/API/SBThread.h +++ b/lldb/include/lldb/API/SBThread.h @@ -182,6 +182,8 @@ class LLDB_API SBThread { lldb::SBFrame GetFrameAtIndex(uint32_t idx); + lldb::SBFrameList GetFrames(); + lldb::SBFrame GetSelectedFrame(); lldb::SBFrame SetSelectedFrame(uint32_t frame_idx); @@ -240,6 +242,7 @@ class LLDB_API SBThread { friend class SBSaveCoreOptions; friend class SBExecutionContext; friend class SBFrame; + friend class SBFrameList; friend class SBProcess; friend class SBDebugger; friend class SBValue; diff --git a/lldb/include/lldb/Target/StackFrameList.h b/lldb/include/lldb/Target/StackFrameList.h index 8d455dc831df3..cc1ccd2178059 100644 --- a/lldb/include/lldb/Target/StackFrameList.h +++ b/lldb/include/lldb/Target/StackFrameList.h @@ -101,6 +101,9 @@ class StackFrameList { /// Returns whether we have currently fetched all the frames of a stack. bool WereAllFramesFetched() const; + /// Get the thread associated with this frame list. + Thread &GetThread() const { return m_thread; } + protected: friend class Thread; friend class ScriptedThread; diff --git a/lldb/include/lldb/Target/Thread.h b/lldb/include/lldb/Target/Thread.h index d2a1cafe29234..05eabd0015263 100644 --- a/lldb/include/lldb/Target/Thread.h +++ b/lldb/include/lldb/Target/Thread.h @@ -1327,6 +1327,8 @@ class Thread : public std::enable_shared_from_this, /// an empty std::optional is returned in that case. std::optional GetPreviousFrameZeroPC(); + lldb::StackFrameListSP GetStackFrameList(); + protected: friend class ThreadPlan; friend class ThreadList; @@ -1368,8 +1370,6 @@ class Thread : public std::enable_shared_from_this, return StructuredData::ObjectSP(); } - lldb::StackFrameListSP GetStackFrameList(); - void SetTemporaryResumeState(lldb::StateType new_state) { m_temporary_resume_state = new_state; } diff --git a/lldb/source/API/CMakeLists.txt b/lldb/source/API/CMakeLists.txt index c53fc272e4e15..e7ce810e7ab10 100644 --- a/lldb/source/API/CMakeLists.txt +++ b/lldb/source/API/CMakeLists.txt @@ -79,6 +79,7 @@ add_lldb_library(liblldb SHARED ${option_framework} SBFileSpecList.cpp SBFormat.cpp SBFrame.cpp + SBFrameList.cpp SBFunction.cpp SBHostOS.cpp SBInstruction.cpp diff --git a/lldb/source/API/SBFrameList.cpp b/lldb/source/API/SBFrameList.cpp new file mode 100644 index 0000000000000..d5fa955c10f70 --- /dev/null +++ b/lldb/source/API/SBFrameList.cpp @@ -0,0 +1,97 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBFrameList.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBThread.h" +#include "lldb/Target/StackFrameList.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/Instrumentation.h" + +using namespace lldb; +using namespace lldb_private; + +SBFrameList::SBFrameList() : m_opaque_sp() { LLDB_INSTRUMENT_VA(this); } + +SBFrameList::SBFrameList(const SBFrameList &rhs) + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_INSTRUMENT_VA(this, rhs); +} + +SBFrameList::~SBFrameList() = default; + +const SBFrameList &SBFrameList::operator=(const SBFrameList &rhs) { + LLDB_INSTRUMENT_VA(this, rhs); + + if (this != &rhs) + m_opaque_sp = rhs.m_opaque_sp; + return *this; +} + +SBFrameList::SBFrameList(const lldb::StackFrameListSP &frame_list_sp) + : m_opaque_sp(frame_list_sp) {} + +void SBFrameList::SetFrameList(const lldb::StackFrameListSP &frame_list_sp) { + m_opaque_sp = frame_list_sp; +} + +SBFrameList::operator bool() const { + LLDB_INSTRUMENT_VA(this); + + return m_opaque_sp.get() != nullptr; +} + +bool SBFrameList::IsValid() const { + LLDB_INSTRUMENT_VA(this); + return this->operator bool(); +} + +uint32_t SBFrameList::GetSize() const { + LLDB_INSTRUMENT_VA(this); + + if (m_opaque_sp) + return m_opaque_sp->GetNumFrames(); + return 0; +} + +SBFrame SBFrameList::GetFrameAtIndex(uint32_t idx) const { + LLDB_INSTRUMENT_VA(this, idx); + + SBFrame sb_frame; + if (m_opaque_sp) + sb_frame.SetFrameSP(m_opaque_sp->GetFrameAtIndex(idx)); + return sb_frame; +} + +SBThread SBFrameList::GetThread() const { + LLDB_INSTRUMENT_VA(this); + + SBThread sb_thread; + if (m_opaque_sp) + sb_thread.SetThread(m_opaque_sp->GetThread().shared_from_this()); + return sb_thread; +} + +void SBFrameList::Clear() { + LLDB_INSTRUMENT_VA(this); + + if (m_opaque_sp) + m_opaque_sp->Clear(); +} + +bool SBFrameList::GetDescription(SBStream &description) const { + LLDB_INSTRUMENT_VA(this, description); + + if (!m_opaque_sp) + return false; + + Stream &strm = description.ref(); + m_opaque_sp->Dump(&strm); + return true; +} diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index be7fd4d8de62f..08a0976ead6c2 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -14,6 +14,7 @@ #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFormat.h" #include "lldb/API/SBFrame.h" +#include "lldb/API/SBFrameList.h" #include "lldb/API/SBProcess.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBStructuredData.h" @@ -1105,6 +1106,26 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { return sb_frame; } +lldb::SBFrameList SBThread::GetFrames() { + LLDB_INSTRUMENT_VA(this); + + SBFrameList sb_frame_list; + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); + if (!exe_ctx) { + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); + return SBFrameList(); + } + + if (exe_ctx->HasThreadScope()) { + StackFrameListSP frame_list_sp = + exe_ctx->GetThreadPtr()->GetStackFrameList(); + sb_frame_list.SetFrameList(frame_list_sp); + } + + return sb_frame_list; +} + lldb::SBFrame SBThread::GetSelectedFrame() { LLDB_INSTRUMENT_VA(this); diff --git a/lldb/test/API/python_api/frame_list/Makefile b/lldb/test/API/python_api/frame_list/Makefile new file mode 100644 index 0000000000000..99998b20bcb05 --- /dev/null +++ b/lldb/test/API/python_api/frame_list/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/lldb/test/API/python_api/frame_list/TestSBFrameList.py b/lldb/test/API/python_api/frame_list/TestSBFrameList.py new file mode 100644 index 0000000000000..f348ce492e547 --- /dev/null +++ b/lldb/test/API/python_api/frame_list/TestSBFrameList.py @@ -0,0 +1,194 @@ +""" +Test SBFrameList API. +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class FrameListAPITestCase(TestBase): + def test_frame_list_api(self): + """Test SBThread.GetFrames() returns a valid SBFrameList.""" + self.build() + self.frame_list_api() + + def test_frame_list_iterator(self): + """Test SBFrameList iterator functionality.""" + self.build() + self.frame_list_iterator() + + def test_frame_list_indexing(self): + """Test SBFrameList indexing and length.""" + self.build() + self.frame_list_indexing() + + def test_frame_list_get_thread(self): + """Test SBFrameList.GetThread() returns correct thread.""" + self.build() + self.frame_list_get_thread() + + def setUp(self): + TestBase.setUp(self) + self.main_source = "main.cpp" + + def frame_list_api(self): + """Test SBThread.GetFrames() returns a valid SBFrameList.""" + exe = self.getBuildArtifact("a.out") + + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Set break point at this line", lldb.SBFileSpec(self.main_source) + ) + + self.assertTrue( + thread.IsValid(), "There should be a thread stopped due to breakpoint" + ) + + # Test GetFrames() returns a valid SBFrameList + frame_list = thread.GetFrames() + self.assertTrue(frame_list.IsValid(), "Frame list should be valid") + self.assertGreater( + frame_list.GetSize(), 0, "Frame list should have at least one frame" + ) + + # Verify frame list size matches thread frame count + self.assertEqual( + frame_list.GetSize(), + thread.GetNumFrames(), + "Frame list size should match thread frame count", + ) + + # Verify frames are the same + for i in range(frame_list.GetSize()): + frame_from_list = frame_list.GetFrameAtIndex(i) + frame_from_thread = thread.GetFrameAtIndex(i) + self.assertTrue( + frame_from_list.IsValid(), f"Frame {i} from list should be valid" + ) + self.assertEqual( + frame_from_list.GetPC(), + frame_from_thread.GetPC(), + f"Frame {i} PC should match", + ) + + def frame_list_iterator(self): + """Test SBFrameList iterator functionality.""" + exe = self.getBuildArtifact("a.out") + + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Set break point at this line", lldb.SBFileSpec(self.main_source) + ) + + self.assertTrue( + thread.IsValid(), "There should be a thread stopped due to breakpoint" + ) + + frame_list = thread.GetFrames() + + # Test iteration + frame_count = 0 + for frame in frame_list: + self.assertTrue(frame.IsValid(), "Each frame should be valid") + frame_count += 1 + + self.assertEqual( + frame_count, + frame_list.GetSize(), + "Iterator should visit all frames", + ) + + # Test that we can iterate multiple times + second_count = 0 + for frame in frame_list: + second_count += 1 + + self.assertEqual( + frame_count, second_count, "Should be able to iterate multiple times" + ) + + def frame_list_indexing(self): + """Test SBFrameList indexing and length.""" + exe = self.getBuildArtifact("a.out") + + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Set break point at this line", lldb.SBFileSpec(self.main_source) + ) + + self.assertTrue( + thread.IsValid(), "There should be a thread stopped due to breakpoint" + ) + + frame_list = thread.GetFrames() + + # Test len() + self.assertEqual( + len(frame_list), frame_list.GetSize(), "len() should return frame count" + ) + + # Test positive indexing + first_frame = frame_list[0] + self.assertTrue(first_frame.IsValid(), "First frame should be valid") + self.assertEqual( + first_frame.GetPC(), + thread.GetFrameAtIndex(0).GetPC(), + "Indexed frame should match", + ) + + # Test negative indexing + if len(frame_list) > 0: + last_frame = frame_list[-1] + self.assertTrue(last_frame.IsValid(), "Last frame should be valid") + self.assertEqual( + last_frame.GetPC(), + thread.GetFrameAtIndex(len(frame_list) - 1).GetPC(), + "Negative indexing should work", + ) + + # Test out of bounds returns None + out_of_bounds = frame_list[10000] + self.assertIsNone(out_of_bounds, "Out of bounds index should return None") + + # Test bool conversion + self.assertTrue(bool(frame_list), "Non-empty frame list should be truthy") + + # Test Clear() + frame_list.Clear() + # Note: Clear() clears the underlying StackFrameList cache, + # but the frame list object itself should still be valid + self.assertTrue( + frame_list.IsValid(), "Frame list should still be valid after Clear()" + ) + + def frame_list_get_thread(self): + """Test SBFrameList.GetThread() returns correct thread.""" + exe = self.getBuildArtifact("a.out") + + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Set break point at this line", lldb.SBFileSpec(self.main_source) + ) + + self.assertTrue( + thread.IsValid(), "There should be a thread stopped due to breakpoint" + ) + + frame_list = thread.GetFrames() + self.assertTrue(frame_list.IsValid(), "Frame list should be valid") + + # Test GetThread() returns the correct thread + thread_from_list = frame_list.GetThread() + self.assertTrue( + thread_from_list.IsValid(), "Thread from frame list should be valid" + ) + self.assertEqual( + thread_from_list.GetThreadID(), + thread.GetThreadID(), + "Frame list should return the correct thread", + ) + + # Verify it's the same thread object + self.assertEqual( + thread_from_list.GetProcess().GetProcessID(), + thread.GetProcess().GetProcessID(), + "Thread should belong to same process", + ) diff --git a/lldb/test/API/python_api/frame_list/main.cpp b/lldb/test/API/python_api/frame_list/main.cpp new file mode 100644 index 0000000000000..e39944654a23e --- /dev/null +++ b/lldb/test/API/python_api/frame_list/main.cpp @@ -0,0 +1,22 @@ +#include + +int c(int val) { + // Set break point at this line + return val + 3; +} + +int b(int val) { + int result = c(val); + return result; +} + +int a(int val) { + int result = b(val); + return result; +} + +int main() { + int result = a(1); + printf("Result: %d\n", result); + return 0; +} From da34916372f7d7b1a4b76011bca6e871d06fe018 Mon Sep 17 00:00:00 2001 From: Med Ismail Bennani Date: Thu, 6 Nov 2025 11:37:42 -0800 Subject: [PATCH 2/5] [lldb/Target] Add SyntheticFrameProvider class (#166664) This patch introduces a new way to reconstruct the thread stackframe list. New `SyntheticFrameProvider` classes can lazy fetch a StackFrame at index using a provided StackFrameList. In can either be the real unwinder StackFrameList or we could also chain SyntheticFrameProviders to each others. This is the foundation work to implement ScriptedFrameProviders, which will come in a follow-up patch. Signed-off-by: Med Ismail Bennani Signed-off-by: Med Ismail Bennani (cherry picked from commit 71cb0bb8932e8a377c9bbce0b8618feb3764b844) --- lldb/include/lldb/Core/PluginManager.h | 18 ++ .../lldb/Target/SyntheticFrameProvider.h | 156 ++++++++++++++++++ lldb/include/lldb/lldb-forward.h | 3 + lldb/include/lldb/lldb-private-interfaces.h | 9 + lldb/source/Core/PluginManager.cpp | 55 ++++++ lldb/source/Target/CMakeLists.txt | 1 + lldb/source/Target/SyntheticFrameProvider.cpp | 100 +++++++++++ 7 files changed, 342 insertions(+) create mode 100644 lldb/include/lldb/Target/SyntheticFrameProvider.h create mode 100644 lldb/source/Target/SyntheticFrameProvider.cpp diff --git a/lldb/include/lldb/Core/PluginManager.h b/lldb/include/lldb/Core/PluginManager.h index bf69b21f99ea0..3e1b723cd9902 100644 --- a/lldb/include/lldb/Core/PluginManager.h +++ b/lldb/include/lldb/Core/PluginManager.h @@ -357,6 +357,24 @@ class PluginManager { GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang, Debugger &debugger); + // SyntheticFrameProvider + static bool + RegisterPlugin(llvm::StringRef name, llvm::StringRef description, + SyntheticFrameProviderCreateInstance create_native_callback, + ScriptedFrameProviderCreateInstance create_scripted_callback); + + static bool + UnregisterPlugin(SyntheticFrameProviderCreateInstance create_callback); + + static bool + UnregisterPlugin(ScriptedFrameProviderCreateInstance create_callback); + + static SyntheticFrameProviderCreateInstance + GetSyntheticFrameProviderCreateCallbackForPluginName(llvm::StringRef name); + + static ScriptedFrameProviderCreateInstance + GetScriptedFrameProviderCreateCallbackAtIndex(uint32_t idx); + // StructuredDataPlugin /// Register a StructuredDataPlugin class along with optional diff --git a/lldb/include/lldb/Target/SyntheticFrameProvider.h b/lldb/include/lldb/Target/SyntheticFrameProvider.h new file mode 100644 index 0000000000000..61a492f356ece --- /dev/null +++ b/lldb/include/lldb/Target/SyntheticFrameProvider.h @@ -0,0 +1,156 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_TARGET_SYNTHETICFRAMEPROVIDER_H +#define LLDB_TARGET_SYNTHETICFRAMEPROVIDER_H + +#include "lldb/Core/PluginInterface.h" +#include "lldb/Target/StackFrameList.h" +#include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/ScriptedMetadata.h" +#include "lldb/Utility/Status.h" +#include "lldb/lldb-forward.h" +#include "llvm/Support/Error.h" + +#include +#include + +namespace lldb_private { + +/// This struct contains the metadata needed to instantiate a frame provider +/// and optional filters to control which threads it applies to. +struct SyntheticFrameProviderDescriptor { + /// Metadata for instantiating the provider (e.g. script class name and args). + lldb::ScriptedMetadataSP scripted_metadata_sp; + + /// Optional list of thread specifications to which this provider applies. + /// If empty, the provider applies to all threads. A thread matches if it + /// satisfies ANY of the specs in this vector (OR logic). + std::vector thread_specs; + + SyntheticFrameProviderDescriptor() = default; + + SyntheticFrameProviderDescriptor(lldb::ScriptedMetadataSP metadata_sp) + : scripted_metadata_sp(metadata_sp) {} + + SyntheticFrameProviderDescriptor(lldb::ScriptedMetadataSP metadata_sp, + const std::vector &specs) + : scripted_metadata_sp(metadata_sp), thread_specs(specs) {} + + /// Get the name of this descriptor (the scripted class name). + llvm::StringRef GetName() const { + return scripted_metadata_sp ? scripted_metadata_sp->GetClassName() : ""; + } + + /// Check if this descriptor applies to the given thread. + bool AppliesToThread(Thread &thread) const { + // If no thread specs specified, applies to all threads. + if (thread_specs.empty()) + return true; + + // Check if the thread matches any of the specs (OR logic). + for (const auto &spec : thread_specs) { + if (spec.ThreadPassesBasicTests(thread)) + return true; + } + return false; + } + + /// Check if this descriptor has valid metadata for script-based providers. + bool IsValid() const { return scripted_metadata_sp != nullptr; } + + void Dump(Stream *s) const; +}; + +/// Base class for all synthetic frame providers. +/// +/// Synthetic frame providers allow modifying or replacing the stack frames +/// shown for a thread. This is useful for: +/// - Providing frames for custom calling conventions or languages. +/// - Reconstructing missing frames from crash dumps or core files. +/// - Adding diagnostic or synthetic frames for debugging. +/// - Visualizing state machines or async execution contexts. +class SyntheticFrameProvider : public PluginInterface { +public: + /// Try to create a SyntheticFrameProvider instance for the given input + /// frames and descriptor. + /// + /// This method iterates through all registered SyntheticFrameProvider + /// plugins and returns the first one that can handle the given descriptor. + /// + /// \param[in] input_frames + /// The input stack frame list that this provider will transform. + /// This could be real unwound frames or output from another provider. + /// + /// \param[in] descriptor + /// The descriptor containing metadata for the provider. + /// + /// \return + /// A shared pointer to a SyntheticFrameProvider if one could be created, + /// otherwise an \a llvm::Error. + static llvm::Expected + CreateInstance(lldb::StackFrameListSP input_frames, + const SyntheticFrameProviderDescriptor &descriptor); + + /// Try to create a SyntheticFrameProvider instance for the given input + /// frames using a specific C++ plugin. + /// + /// This method directly invokes a specific SyntheticFrameProvider plugin + /// by name, bypassing the descriptor-based plugin iteration. This is useful + /// for C++ plugins that don't require scripted metadata. + /// + /// \param[in] input_frames + /// The input stack frame list that this provider will transform. + /// This could be real unwound frames or output from another provider. + /// + /// \param[in] plugin_name + /// The name of the plugin to use for creating the provider. + /// + /// \param[in] thread_specs + /// Optional list of thread specifications to which this provider applies. + /// If empty, the provider applies to all threads. + /// + /// \return + /// A shared pointer to a SyntheticFrameProvider if one could be created, + /// otherwise an \a llvm::Error. + static llvm::Expected + CreateInstance(lldb::StackFrameListSP input_frames, + llvm::StringRef plugin_name, + const std::vector &thread_specs = {}); + + ~SyntheticFrameProvider() override; + + /// Get a single stack frame at the specified index. + /// + /// This method is called lazily - frames are only created when requested. + /// The provider can access its input frames via GetInputFrames() if needed. + /// + /// \param[in] idx + /// The index of the frame to create. + /// + /// \return + /// An Expected containing the StackFrameSP if successful. Returns an + /// error when the index is beyond the last frame to signal the end of + /// the frame list. + virtual llvm::Expected GetFrameAtIndex(uint32_t idx) = 0; + + /// Get the thread associated with this provider. + Thread &GetThread() { return m_input_frames->GetThread(); } + + /// Get the input frames that this provider transforms. + lldb::StackFrameListSP GetInputFrames() const { return m_input_frames; } + +protected: + SyntheticFrameProvider(lldb::StackFrameListSP input_frames); + + lldb::StackFrameListSP m_input_frames; +}; + +} // namespace lldb_private + +#endif // LLDB_TARGET_SYNTHETICFRAMEPROVIDER_H diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h index af5656b3dcad1..7af7cd8947531 100644 --- a/lldb/include/lldb/lldb-forward.h +++ b/lldb/include/lldb/lldb-forward.h @@ -235,6 +235,7 @@ class SymbolVendor; class Symtab; class SyntheticChildren; class SyntheticChildrenFrontEnd; +class SyntheticFrameProvider; class SystemRuntime; class Progress; class Target; @@ -411,6 +412,8 @@ typedef std::shared_ptr typedef std::shared_ptr ScriptInterpreterSP; typedef std::shared_ptr ScriptedFrameInterfaceSP; +typedef std::shared_ptr + SyntheticFrameProviderSP; typedef std::shared_ptr ScriptedMetadataSP; typedef std::unique_ptr ScriptedPlatformInterfaceUP; diff --git a/lldb/include/lldb/lldb-private-interfaces.h b/lldb/include/lldb/lldb-private-interfaces.h index c2d86ed93eb09..7d414b1106e0a 100644 --- a/lldb/include/lldb/lldb-private-interfaces.h +++ b/lldb/include/lldb/lldb-private-interfaces.h @@ -25,6 +25,7 @@ class Value; namespace lldb_private { class ScriptedInterfaceUsages; +struct SyntheticFrameProviderDescriptor; typedef lldb::ABISP (*ABICreateInstance)(lldb::ProcessSP process_sp, const ArchSpec &arch); typedef std::unique_ptr (*ArchitectureCreateInstance)( @@ -86,6 +87,14 @@ typedef lldb::RegisterTypeBuilderSP (*RegisterTypeBuilderCreateInstance)( Target &target); typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)( Debugger &debugger); +typedef llvm::Expected ( + *ScriptedFrameProviderCreateInstance)( + lldb::StackFrameListSP input_frames, + const lldb_private::SyntheticFrameProviderDescriptor &descriptor); +typedef llvm::Expected ( + *SyntheticFrameProviderCreateInstance)( + lldb::StackFrameListSP input_frames, + const std::vector &thread_specs); typedef SymbolFile *(*SymbolFileCreateInstance)(lldb::ObjectFileSP objfile_sp); typedef SymbolVendor *(*SymbolVendorCreateInstance)( const lldb::ModuleSP &module_sp, diff --git a/lldb/source/Core/PluginManager.cpp b/lldb/source/Core/PluginManager.cpp index c150c84c32871..47c7f4b422c41 100644 --- a/lldb/source/Core/PluginManager.cpp +++ b/lldb/source/Core/PluginManager.cpp @@ -1297,6 +1297,61 @@ PluginManager::GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang, return none_instance(debugger); } +#pragma mark SyntheticFrameProvider + +typedef PluginInstance + SyntheticFrameProviderInstance; +typedef PluginInstance + ScriptedFrameProviderInstance; +typedef PluginInstances + SyntheticFrameProviderInstances; +typedef PluginInstances + ScriptedFrameProviderInstances; + +static SyntheticFrameProviderInstances &GetSyntheticFrameProviderInstances() { + static SyntheticFrameProviderInstances g_instances; + return g_instances; +} + +static ScriptedFrameProviderInstances &GetScriptedFrameProviderInstances() { + static ScriptedFrameProviderInstances g_instances; + return g_instances; +} + +bool PluginManager::RegisterPlugin( + llvm::StringRef name, llvm::StringRef description, + SyntheticFrameProviderCreateInstance create_native_callback, + ScriptedFrameProviderCreateInstance create_scripted_callback) { + if (create_native_callback) + return GetSyntheticFrameProviderInstances().RegisterPlugin( + name, description, create_native_callback); + else if (create_scripted_callback) + return GetScriptedFrameProviderInstances().RegisterPlugin( + name, description, create_scripted_callback); + return false; +} + +bool PluginManager::UnregisterPlugin( + SyntheticFrameProviderCreateInstance create_callback) { + return GetSyntheticFrameProviderInstances().UnregisterPlugin(create_callback); +} + +bool PluginManager::UnregisterPlugin( + ScriptedFrameProviderCreateInstance create_callback) { + return GetScriptedFrameProviderInstances().UnregisterPlugin(create_callback); +} + +SyntheticFrameProviderCreateInstance +PluginManager::GetSyntheticFrameProviderCreateCallbackForPluginName( + llvm::StringRef name) { + return GetSyntheticFrameProviderInstances().GetCallbackForName(name); +} + +ScriptedFrameProviderCreateInstance +PluginManager::GetScriptedFrameProviderCreateCallbackAtIndex(uint32_t idx) { + return GetScriptedFrameProviderInstances().GetCallbackAtIndex(idx); +} + #pragma mark StructuredDataPlugin struct StructuredDataPluginInstance diff --git a/lldb/source/Target/CMakeLists.txt b/lldb/source/Target/CMakeLists.txt index 942a7839d4b46..5c71d49adda4a 100644 --- a/lldb/source/Target/CMakeLists.txt +++ b/lldb/source/Target/CMakeLists.txt @@ -38,6 +38,7 @@ add_lldb_library(lldbTarget RegisterNumber.cpp RemoteAwarePlatform.cpp ScriptedThreadPlan.cpp + SyntheticFrameProvider.cpp SectionLoadHistory.cpp SectionLoadList.cpp StackFrame.cpp diff --git a/lldb/source/Target/SyntheticFrameProvider.cpp b/lldb/source/Target/SyntheticFrameProvider.cpp new file mode 100644 index 0000000000000..241ce82c39be3 --- /dev/null +++ b/lldb/source/Target/SyntheticFrameProvider.cpp @@ -0,0 +1,100 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "lldb/Target/SyntheticFrameProvider.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/LLDBLog.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Status.h" + +using namespace lldb; +using namespace lldb_private; + +SyntheticFrameProvider::SyntheticFrameProvider(StackFrameListSP input_frames) + : m_input_frames(std::move(input_frames)) {} + +SyntheticFrameProvider::~SyntheticFrameProvider() = default; + +void SyntheticFrameProviderDescriptor::Dump(Stream *s) const { + if (!s) + return; + + s->Printf(" Name: %s\n", GetName().str().c_str()); + + // Show thread filter information. + if (thread_specs.empty()) { + s->PutCString(" Thread Filter: (applies to all threads)\n"); + } else { + s->Printf(" Thread Filter: %zu specification(s)\n", thread_specs.size()); + for (size_t i = 0; i < thread_specs.size(); ++i) { + const ThreadSpec &spec = thread_specs[i]; + s->Printf(" [%zu] ", i); + spec.GetDescription(s, lldb::eDescriptionLevelVerbose); + s->PutChar('\n'); + } + } +} + +llvm::Expected SyntheticFrameProvider::CreateInstance( + StackFrameListSP input_frames, + const SyntheticFrameProviderDescriptor &descriptor) { + if (!input_frames) + return llvm::createStringError( + "cannot create synthetic frame provider: invalid input frames"); + + // Iterate through all registered ScriptedFrameProvider plugins. + ScriptedFrameProviderCreateInstance create_callback = nullptr; + for (uint32_t idx = 0; + (create_callback = + PluginManager::GetScriptedFrameProviderCreateCallbackAtIndex( + idx)) != nullptr; + ++idx) { + auto provider_or_err = create_callback(input_frames, descriptor); + if (!provider_or_err) { + LLDB_LOG_ERROR(GetLog(LLDBLog::Target), provider_or_err.takeError(), + "Failed to create synthetic frame provider: {0}"); + continue; + } + + if (auto frame_provider_up = std::move(*provider_or_err)) + return std::move(frame_provider_up); + } + + return llvm::createStringError( + "cannot create synthetic frame provider: no suitable plugin found"); +} + +llvm::Expected SyntheticFrameProvider::CreateInstance( + StackFrameListSP input_frames, llvm::StringRef plugin_name, + const std::vector &thread_specs) { + if (!input_frames) + return llvm::createStringError( + "cannot create synthetic frame provider: invalid input frames"); + + // Look up the specific C++ plugin by name. + SyntheticFrameProviderCreateInstance create_callback = + PluginManager::GetSyntheticFrameProviderCreateCallbackForPluginName( + plugin_name); + + if (!create_callback) + return llvm::createStringError( + "cannot create synthetic frame provider: C++ plugin '%s' not found", + plugin_name.str().c_str()); + + auto provider_or_err = create_callback(input_frames, thread_specs); + if (!provider_or_err) + return provider_or_err.takeError(); + + if (auto frame_provider_sp = std::move(*provider_or_err)) + return std::move(frame_provider_sp); + + return llvm::createStringError( + "cannot create synthetic frame provider: C++ plugin '%s' returned null", + plugin_name.str().c_str()); +} From aa171f08db8c40d69c0a211d9941a7bafe7a504a Mon Sep 17 00:00:00 2001 From: Med Ismail Bennani Date: Thu, 6 Nov 2025 11:54:17 -0800 Subject: [PATCH 3/5] [lldb/Interpreter] Implement ScriptedFrameProvider{,Python}Interface (#166662) This patch implements the base and python interface for the ScriptedFrameProvider class. This is necessary to call python APIs from the ScriptedFrameProvider that will come in a follow-up. Signed-off-by: Med Ismail Bennani Signed-off-by: Med Ismail Bennani (cherry picked from commit 4cd17eeaeb13f44e7c0783e83716c06a2b9110a3) --- lldb/bindings/python/CMakeLists.txt | 1 + lldb/bindings/python/python-swigsafecast.swig | 5 + lldb/bindings/python/python-wrapper.swig | 12 ++ .../templates/scripted_frame_provider.py | 113 ++++++++++++++++++ lldb/include/lldb/API/SBFrameList.h | 14 +++ .../ScriptedFrameProviderInterface.h | 30 +++++ .../lldb/Interpreter/ScriptInterpreter.h | 10 ++ lldb/include/lldb/lldb-forward.h | 3 + lldb/source/Interpreter/ScriptInterpreter.cpp | 5 + .../Plugins/Process/scripted/ScriptedFrame.h | 1 - .../Python/Interfaces/CMakeLists.txt | 1 + .../ScriptInterpreterPythonInterfaces.h | 1 + .../ScriptedFrameProviderPythonInterface.cpp | 57 +++++++++ .../ScriptedFrameProviderPythonInterface.h | 44 +++++++ .../Interfaces/ScriptedPythonInterface.cpp | 17 +++ .../Interfaces/ScriptedPythonInterface.h | 13 ++ .../Python/SWIGPythonBridge.h | 2 + .../Python/ScriptInterpreterPython.cpp | 5 + .../Python/ScriptInterpreterPythonImpl.h | 3 + .../Python/PythonTestSuite.cpp | 10 ++ 20 files changed, 346 insertions(+), 1 deletion(-) create mode 100644 lldb/examples/python/templates/scripted_frame_provider.py create mode 100644 lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h create mode 100644 lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp create mode 100644 lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h diff --git a/lldb/bindings/python/CMakeLists.txt b/lldb/bindings/python/CMakeLists.txt index 42299064fd8f7..e7e8c56661b21 100644 --- a/lldb/bindings/python/CMakeLists.txt +++ b/lldb/bindings/python/CMakeLists.txt @@ -108,6 +108,7 @@ function(finish_swig_python swig_target lldb_python_bindings_dir lldb_python_tar "plugins" FILES "${LLDB_SOURCE_DIR}/examples/python/templates/parsed_cmd.py" + "${LLDB_SOURCE_DIR}/examples/python/templates/scripted_frame_provider.py" "${LLDB_SOURCE_DIR}/examples/python/templates/scripted_process.py" "${LLDB_SOURCE_DIR}/examples/python/templates/scripted_platform.py" "${LLDB_SOURCE_DIR}/examples/python/templates/operating_system.py" diff --git a/lldb/bindings/python/python-swigsafecast.swig b/lldb/bindings/python/python-swigsafecast.swig index 3ea24f1a31414..a86dc44ce4106 100644 --- a/lldb/bindings/python/python-swigsafecast.swig +++ b/lldb/bindings/python/python-swigsafecast.swig @@ -37,6 +37,11 @@ PythonObject SWIGBridge::ToSWIGWrapper(lldb::ThreadPlanSP thread_plan_sp) { SWIGTYPE_p_lldb__SBThreadPlan); } +PythonObject SWIGBridge::ToSWIGWrapper(lldb::StackFrameListSP frames_sp) { + return ToSWIGHelper(new lldb::SBFrameList(std::move(frames_sp)), + SWIGTYPE_p_lldb__SBFrameList); +} + PythonObject SWIGBridge::ToSWIGWrapper(lldb::BreakpointSP breakpoint_sp) { return ToSWIGHelper(new lldb::SBBreakpoint(std::move(breakpoint_sp)), SWIGTYPE_p_lldb__SBBreakpoint); diff --git a/lldb/bindings/python/python-wrapper.swig b/lldb/bindings/python/python-wrapper.swig index 64b7dc8381073..6ba0276fcb05e 100644 --- a/lldb/bindings/python/python-wrapper.swig +++ b/lldb/bindings/python/python-wrapper.swig @@ -556,6 +556,18 @@ void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBExecutionContext(PyOb return sb_ptr; } +void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data) { + lldb::SBFrameList *sb_ptr = NULL; + + int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr, + SWIGTYPE_p_lldb__SBFrameList, 0); + + if (valid_cast == -1) + return NULL; + + return sb_ptr; +} + bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommand( const char *python_function_name, const char *session_dictionary_name, lldb::DebuggerSP debugger, const char *args, diff --git a/lldb/examples/python/templates/scripted_frame_provider.py b/lldb/examples/python/templates/scripted_frame_provider.py new file mode 100644 index 0000000000000..20f4d76d188c2 --- /dev/null +++ b/lldb/examples/python/templates/scripted_frame_provider.py @@ -0,0 +1,113 @@ +from abc import ABCMeta, abstractmethod + +import lldb + + +class ScriptedFrameProvider(metaclass=ABCMeta): + """ + The base class for a scripted frame provider. + + A scripted frame provider allows you to provide custom stack frames for a + thread, which can be used to augment or replace the standard unwinding + mechanism. This is useful for: + + - Providing frames for custom calling conventions or languages + - Reconstructing missing frames from crash dumps or core files + - Adding diagnostic or synthetic frames for debugging + - Visualizing state machines or async execution contexts + + Most of the base class methods are `@abstractmethod` that need to be + overwritten by the inheriting class. + + Example usage: + + .. code-block:: python + + # Attach a frame provider to a thread + thread = process.GetSelectedThread() + error = thread.SetScriptedFrameProvider( + "my_module.MyFrameProvider", + lldb.SBStructuredData() + ) + """ + + @abstractmethod + def __init__(self, input_frames, args): + """Construct a scripted frame provider. + + Args: + input_frames (lldb.SBFrameList): The frame list to use as input. + This allows you to access frames by index. The frames are + materialized lazily as you access them. + args (lldb.SBStructuredData): A Dictionary holding arbitrary + key/value pairs used by the scripted frame provider. + """ + self.input_frames = None + self.args = None + self.thread = None + self.target = None + self.process = None + + if isinstance(input_frames, lldb.SBFrameList) and input_frames.IsValid(): + self.input_frames = input_frames + self.thread = input_frames.GetThread() + if self.thread and self.thread.IsValid(): + self.process = self.thread.GetProcess() + if self.process and self.process.IsValid(): + self.target = self.process.GetTarget() + + if isinstance(args, lldb.SBStructuredData) and args.IsValid(): + self.args = args + + @abstractmethod + def get_frame_at_index(self, index): + """Get a single stack frame at the given index. + + This method is called lazily when a specific frame is needed in the + thread's backtrace (e.g., via the 'bt' command). Each frame is + requested individually as needed. + + Args: + index (int): The frame index to retrieve (0 for youngest/top frame). + + Returns: + Dict or None: A frame dictionary describing the stack frame, or None + if no frame exists at this index. The dictionary should contain: + + Required fields: + - idx (int): The synthetic frame index (0 for youngest/top frame) + - pc (int): The program counter address for the synthetic frame + + Alternatively, you can return: + - A ScriptedFrame object for full control over frame behavior + - An integer representing an input frame index to reuse + - None to indicate no more frames exist + + Example: + + .. code-block:: python + + def get_frame_at_index(self, index): + # Return None when there are no more frames + if index >= self.total_frames: + return None + + # Re-use an input frame by returning its index + if self.should_use_input_frame(index): + return index # Returns input frame at this index + + # Or create a custom frame dictionary + if index == 0: + return { + "idx": 0, + "pc": 0x100001234, + } + + return None + + Note: + The frames are indexed from 0 (youngest/top) to N (oldest/bottom). + This method will be called repeatedly with increasing indices until + None is returned. + """ + pass diff --git a/lldb/include/lldb/API/SBFrameList.h b/lldb/include/lldb/API/SBFrameList.h index dba1c1de5d191..0039ffb1f863f 100644 --- a/lldb/include/lldb/API/SBFrameList.h +++ b/lldb/include/lldb/API/SBFrameList.h @@ -11,6 +11,16 @@ #include "lldb/API/SBDefines.h" +namespace lldb_private { +class ScriptInterpreter; +namespace python { +class SWIGBridge; +} +namespace lua { +class SWIGBridge; +} +} // namespace lldb_private + namespace lldb { /// Represents a list of SBFrame objects. @@ -66,6 +76,10 @@ class LLDB_API SBFrameList { protected: friend class SBThread; + friend class lldb_private::python::SWIGBridge; + friend class lldb_private::lua::SWIGBridge; + friend class lldb_private::ScriptInterpreter; + private: SBFrameList(const lldb::StackFrameListSP &frame_list_sp); diff --git a/lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h b/lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h new file mode 100644 index 0000000000000..2d9f713676f90 --- /dev/null +++ b/lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_INTERPRETER_INTERFACES_SCRIPTEDFRAMEPROVIDERINTERFACE_H +#define LLDB_INTERPRETER_INTERFACES_SCRIPTEDFRAMEPROVIDERINTERFACE_H + +#include "lldb/lldb-private.h" + +#include "ScriptedInterface.h" + +namespace lldb_private { +class ScriptedFrameProviderInterface : public ScriptedInterface { +public: + virtual llvm::Expected + CreatePluginObject(llvm::StringRef class_name, + lldb::StackFrameListSP input_frames, + StructuredData::DictionarySP args_sp) = 0; + + virtual StructuredData::ObjectSP GetFrameAtIndex(uint32_t index) { + return {}; + } +}; +} // namespace lldb_private + +#endif // LLDB_INTERPRETER_INTERFACES_SCRIPTEDFRAMEPROVIDERINTERFACE_H diff --git a/lldb/include/lldb/Interpreter/ScriptInterpreter.h b/lldb/include/lldb/Interpreter/ScriptInterpreter.h index 6c0054a1ec1d1..f4c204d5c08e5 100644 --- a/lldb/include/lldb/Interpreter/ScriptInterpreter.h +++ b/lldb/include/lldb/Interpreter/ScriptInterpreter.h @@ -16,6 +16,7 @@ #include "lldb/API/SBError.h" #include "lldb/API/SBEvent.h" #include "lldb/API/SBExecutionContext.h" +#include "lldb/API/SBFrameList.h" #include "lldb/API/SBLaunchInfo.h" #include "lldb/API/SBMemoryRegionInfo.h" #include "lldb/API/SBStream.h" @@ -28,6 +29,7 @@ #include "lldb/Host/StreamFile.h" #include "lldb/Interpreter/Interfaces/OperatingSystemInterface.h" #include "lldb/Interpreter/Interfaces/ScriptedFrameInterface.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" #include "lldb/Interpreter/Interfaces/ScriptedPlatformInterface.h" #include "lldb/Interpreter/Interfaces/ScriptedProcessInterface.h" #include "lldb/Interpreter/Interfaces/ScriptedThreadInterface.h" @@ -537,6 +539,11 @@ class ScriptInterpreter : public PluginInterface { return {}; } + virtual lldb::ScriptedFrameProviderInterfaceSP + CreateScriptedFrameProviderInterface() { + return {}; + } + virtual lldb::ScriptedThreadPlanInterfaceSP CreateScriptedThreadPlanInterface() { return {}; @@ -596,6 +603,9 @@ class ScriptInterpreter : public PluginInterface { lldb::ExecutionContextRefSP GetOpaqueTypeFromSBExecutionContext( const lldb::SBExecutionContext &exe_ctx) const; + lldb::StackFrameListSP + GetOpaqueTypeFromSBFrameList(const lldb::SBFrameList &exe_ctx) const; + protected: Debugger &m_debugger; lldb::ScriptLanguage m_script_lang; diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h index 7af7cd8947531..8b8d081ca2113 100644 --- a/lldb/include/lldb/lldb-forward.h +++ b/lldb/include/lldb/lldb-forward.h @@ -188,6 +188,7 @@ class Scalar; class ScriptInterpreter; class ScriptInterpreterLocker; class ScriptedFrameInterface; +class ScriptedFrameProviderInterface; class ScriptedMetadata; class ScriptedBreakpointInterface; class ScriptedPlatformInterface; @@ -412,6 +413,8 @@ typedef std::shared_ptr typedef std::shared_ptr ScriptInterpreterSP; typedef std::shared_ptr ScriptedFrameInterfaceSP; +typedef std::shared_ptr + ScriptedFrameProviderInterfaceSP; typedef std::shared_ptr SyntheticFrameProviderSP; typedef std::shared_ptr ScriptedMetadataSP; diff --git a/lldb/source/Interpreter/ScriptInterpreter.cpp b/lldb/source/Interpreter/ScriptInterpreter.cpp index 5c0e71389ca6c..8b03af03ed8d9 100644 --- a/lldb/source/Interpreter/ScriptInterpreter.cpp +++ b/lldb/source/Interpreter/ScriptInterpreter.cpp @@ -150,6 +150,11 @@ ScriptInterpreter::GetOpaqueTypeFromSBExecutionContext( return exe_ctx.m_exe_ctx_sp; } +lldb::StackFrameListSP ScriptInterpreter::GetOpaqueTypeFromSBFrameList( + const lldb::SBFrameList &frame_list) const { + return frame_list.m_opaque_sp; +} + lldb::ScriptLanguage ScriptInterpreter::StringToLanguage(const llvm::StringRef &language) { if (language.equals_insensitive(LanguageToString(eScriptLanguageNone))) diff --git a/lldb/source/Plugins/Process/scripted/ScriptedFrame.h b/lldb/source/Plugins/Process/scripted/ScriptedFrame.h index 6e01e2fd7653e..b6b77c4a7d160 100644 --- a/lldb/source/Plugins/Process/scripted/ScriptedFrame.h +++ b/lldb/source/Plugins/Process/scripted/ScriptedFrame.h @@ -9,7 +9,6 @@ #ifndef LLDB_SOURCE_PLUGINS_SCRIPTED_FRAME_H #define LLDB_SOURCE_PLUGINS_SCRIPTED_FRAME_H -#include "Plugins/Process/Utility/RegisterContextMemory.h" #include "ScriptedThread.h" #include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Target/DynamicRegisterInfo.h" diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/CMakeLists.txt b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/CMakeLists.txt index 09103573b89c5..50569cdefaafa 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/CMakeLists.txt +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/CMakeLists.txt @@ -23,6 +23,7 @@ add_lldb_library(lldbPluginScriptInterpreterPythonInterfaces PLUGIN OperatingSystemPythonInterface.cpp ScriptInterpreterPythonInterfaces.cpp ScriptedFramePythonInterface.cpp + ScriptedFrameProviderPythonInterface.cpp ScriptedPlatformPythonInterface.cpp ScriptedProcessPythonInterface.cpp ScriptedPythonInterface.cpp diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.h index 3814f46615078..b2a347951d0f2 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.h @@ -17,6 +17,7 @@ #include "OperatingSystemPythonInterface.h" #include "ScriptedBreakpointPythonInterface.h" +#include "ScriptedFrameProviderPythonInterface.h" #include "ScriptedFramePythonInterface.h" #include "ScriptedPlatformPythonInterface.h" #include "ScriptedProcessPythonInterface.h" diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp new file mode 100644 index 0000000000000..b866bf332b7b6 --- /dev/null +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "lldb/Host/Config.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/Log.h" +#include "lldb/lldb-enumerations.h" + +#if LLDB_ENABLE_PYTHON + +// LLDB Python header must be included first +#include "../lldb-python.h" + +#include "../SWIGPythonBridge.h" +#include "../ScriptInterpreterPythonImpl.h" +#include "ScriptedFrameProviderPythonInterface.h" +#include + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::python; +using Locker = ScriptInterpreterPythonImpl::Locker; + +ScriptedFrameProviderPythonInterface::ScriptedFrameProviderPythonInterface( + ScriptInterpreterPythonImpl &interpreter) + : ScriptedFrameProviderInterface(), ScriptedPythonInterface(interpreter) {} + +llvm::Expected +ScriptedFrameProviderPythonInterface::CreatePluginObject( + const llvm::StringRef class_name, lldb::StackFrameListSP input_frames, + StructuredData::DictionarySP args_sp) { + if (!input_frames) + return llvm::createStringError("Invalid frame list"); + + StructuredDataImpl sd_impl(args_sp); + return ScriptedPythonInterface::CreatePluginObject(class_name, nullptr, + input_frames, sd_impl); +} + +StructuredData::ObjectSP +ScriptedFrameProviderPythonInterface::GetFrameAtIndex(uint32_t index) { + Status error; + StructuredData::ObjectSP obj = Dispatch("get_frame_at_index", error, index); + + if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, + error)) + return {}; + + return obj; +} + +#endif diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h new file mode 100644 index 0000000000000..fd163984028d3 --- /dev/null +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h @@ -0,0 +1,44 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_INTERFACES_SCRIPTEDFRAMEPROVIDERPYTHONINTERFACE_H +#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_INTERFACES_SCRIPTEDFRAMEPROVIDERPYTHONINTERFACE_H + +#include "lldb/Host/Config.h" + +#if LLDB_ENABLE_PYTHON + +#include "ScriptedPythonInterface.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" +#include + +namespace lldb_private { +class ScriptedFrameProviderPythonInterface + : public ScriptedFrameProviderInterface, + public ScriptedPythonInterface { +public: + ScriptedFrameProviderPythonInterface( + ScriptInterpreterPythonImpl &interpreter); + + llvm::Expected + CreatePluginObject(llvm::StringRef class_name, + lldb::StackFrameListSP input_frames, + StructuredData::DictionarySP args_sp) override; + + llvm::SmallVector + GetAbstractMethodRequirements() const override { + return llvm::SmallVector( + {{"get_frame_at_index"}}); + } + + StructuredData::ObjectSP GetFrameAtIndex(uint32_t index) override; +}; +} // namespace lldb_private + +#endif // LLDB_ENABLE_PYTHON +#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_INTERFACES_SCRIPTEDFRAMEPROVIDERPYTHONINTERFACE_H diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp index 4fdf2b12a5500..af2e0b5df4d22 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp @@ -243,4 +243,21 @@ ScriptedPythonInterface::ExtractValueFromPythonObject( return static_cast(unsigned_val); } +template <> +lldb::StackFrameListSP +ScriptedPythonInterface::ExtractValueFromPythonObject( + python::PythonObject &p, Status &error) { + + lldb::SBFrameList *sb_frame_list = reinterpret_cast( + python::LLDBSWIGPython_CastPyObjectToSBFrameList(p.get())); + + if (!sb_frame_list) { + error = Status::FromErrorStringWithFormat( + "couldn't cast lldb::SBFrameList to lldb::StackFrameListSP."); + return {}; + } + + return m_interpreter.GetOpaqueTypeFromSBFrameList(*sb_frame_list); +} + #endif diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h index 2335b2ef0f171..ec1dd9910d8a6 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h @@ -444,6 +444,14 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { return python::SWIGBridge::ToSWIGWrapper(arg); } + python::PythonObject Transform(lldb::ThreadSP arg) { + return python::SWIGBridge::ToSWIGWrapper(arg); + } + + python::PythonObject Transform(lldb::StackFrameListSP arg) { + return python::SWIGBridge::ToSWIGWrapper(arg); + } + python::PythonObject Transform(lldb::ThreadPlanSP arg) { return python::SWIGBridge::ToSWIGWrapper(arg); } @@ -628,6 +636,11 @@ lldb::DescriptionLevel ScriptedPythonInterface::ExtractValueFromPythonObject( python::PythonObject &p, Status &error); +template <> +lldb::StackFrameListSP +ScriptedPythonInterface::ExtractValueFromPythonObject( + python::PythonObject &p, Status &error); + } // namespace lldb_private #endif // LLDB_ENABLE_PYTHON diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h index 7b39d29ba2b20..bf31ce9c7760e 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h @@ -93,6 +93,7 @@ class SWIGBridge { static PythonObject ToSWIGWrapper(const StructuredDataImpl &data_impl); static PythonObject ToSWIGWrapper(lldb::ThreadSP thread_sp); static PythonObject ToSWIGWrapper(lldb::StackFrameSP frame_sp); + static PythonObject ToSWIGWrapper(lldb::StackFrameListSP frames_sp); static PythonObject ToSWIGWrapper(lldb::DebuggerSP debugger_sp); static PythonObject ToSWIGWrapper(lldb::WatchpointSP watchpoint_sp); static PythonObject ToSWIGWrapper(lldb::BreakpointLocationSP bp_loc_sp); @@ -268,6 +269,7 @@ void *LLDBSWIGPython_CastPyObjectToSBSymbolContext(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBExecutionContext(PyObject *data); +void *LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data); } // namespace python } // namespace lldb_private diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp index b9c6707202243..5f736ed42c7a6 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp @@ -1565,6 +1565,11 @@ ScriptInterpreterPythonImpl::CreateScriptedFrameInterface() { return std::make_shared(*this); } +ScriptedFrameProviderInterfaceSP +ScriptInterpreterPythonImpl::CreateScriptedFrameProviderInterface() { + return std::make_shared(*this); +} + ScriptedThreadPlanInterfaceSP ScriptInterpreterPythonImpl::CreateScriptedThreadPlanInterface() { return std::make_shared(*this); diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h index a83fa54ab588a..e9fd86167dbce 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h @@ -101,6 +101,9 @@ class ScriptInterpreterPythonImpl : public ScriptInterpreterPython { lldb::ScriptedFrameInterfaceSP CreateScriptedFrameInterface() override; + lldb::ScriptedFrameProviderInterfaceSP + CreateScriptedFrameProviderInterface() override; + lldb::ScriptedThreadPlanInterfaceSP CreateScriptedThreadPlanInterface() override; diff --git a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp index f4b5a810f9e30..06b180be28d80 100644 --- a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp +++ b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp @@ -160,6 +160,11 @@ void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBExecutionContext( return nullptr; } +void * +lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data) { + return nullptr; +} + lldb::ValueObjectSP lldb_private::python::SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue( void *data) { @@ -328,6 +333,11 @@ lldb_private::python::SWIGBridge::ToSWIGWrapper(lldb::ProcessSP) { return python::PythonObject(); } +python::PythonObject +lldb_private::python::SWIGBridge::ToSWIGWrapper(lldb::StackFrameListSP) { + return python::PythonObject(); +} + python::PythonObject lldb_private::python::SWIGBridge::ToSWIGWrapper( const lldb_private::StructuredDataImpl &) { return python::PythonObject(); From c7bc87c49310b904f4a03567f27123c225118b0b Mon Sep 17 00:00:00 2001 From: Med Ismail Bennani Date: Tue, 11 Nov 2025 12:18:45 -0800 Subject: [PATCH 4/5] [lldb] Introduce ScriptedFrameProvider for real threads (#161870) This patch extends ScriptedFrame to work with real (non-scripted) threads, enabling frame providers to synthesize frames for native processes. Previously, ScriptedFrame only worked within ScriptedProcess/ScriptedThread contexts. This patch decouples ScriptedFrame from ScriptedThread, allowing users to augment or replace stack frames in real debugging sessions for use cases like custom calling conventions, reconstructing corrupted frames from core files, or adding diagnostic frames. Key changes: - ScriptedFrame::Create() now accepts ThreadSP instead of requiring ScriptedThread, extracting architecture from the target triple rather than ScriptedProcess.arch - Added SBTarget::RegisterScriptedFrameProvider() and ClearScriptedFrameProvider() APIs, with Target storing a SyntheticFrameProviderDescriptor template for new threads - Added "target frame-provider register/clear" commands for CLI access - Thread class gains LoadScriptedFrameProvider(), ClearScriptedFrameProvider(), and GetFrameProvider() methods for per-thread frame provider management - New SyntheticStackFrameList overrides FetchFramesUpTo() to lazily provide frames from either the frame provider or the real stack This enables practical use of the SyntheticFrameProvider infrastructure in real debugging workflows. rdar://161834688 Signed-off-by: Med Ismail Bennani Signed-off-by: Med Ismail Bennani (cherry picked from commit 1e467e44851a9da96c16c0dcd16725f996e6abf7) --- lldb/bindings/python/python-wrapper.swig | 12 + .../templates/scripted_frame_provider.py | 47 +++ .../python/templates/scripted_process.py | 47 ++- lldb/include/lldb/API/SBTarget.h | 30 ++ lldb/include/lldb/API/SBThread.h | 1 + lldb/include/lldb/API/SBThreadCollection.h | 1 + .../ScriptedFrameProviderInterface.h | 18 + .../lldb/Interpreter/ScriptInterpreter.h | 3 + lldb/include/lldb/Target/StackFrame.h | 7 +- lldb/include/lldb/Target/StackFrameList.h | 36 +- .../lldb/Target/SyntheticFrameProvider.h | 30 +- lldb/include/lldb/Target/Target.h | 38 ++ lldb/include/lldb/Target/Thread.h | 12 + lldb/include/lldb/Target/ThreadSpec.h | 2 + lldb/include/lldb/Utility/ScriptedMetadata.h | 27 ++ lldb/include/lldb/lldb-private-interfaces.h | 4 +- lldb/source/API/SBTarget.cpp | 82 +++++ lldb/source/Commands/CommandObjectTarget.cpp | 200 +++++++++++ lldb/source/Interpreter/ScriptInterpreter.cpp | 7 + lldb/source/Plugins/CMakeLists.txt | 1 + .../Process/scripted/ScriptedFrame.cpp | 85 +++-- .../Plugins/Process/scripted/ScriptedFrame.h | 33 +- .../Process/scripted/ScriptedThread.cpp | 6 +- .../ScriptInterpreterPythonInterfaces.cpp | 2 + .../ScriptedFrameProviderPythonInterface.cpp | 58 ++- .../ScriptedFrameProviderPythonInterface.h | 23 +- .../Interfaces/ScriptedPythonInterface.cpp | 13 + .../Interfaces/ScriptedPythonInterface.h | 121 ++++++- .../Python/SWIGPythonBridge.h | 1 + .../SyntheticFrameProvider/CMakeLists.txt | 1 + .../ScriptedFrameProvider/CMakeLists.txt | 12 + .../ScriptedFrameProvider.cpp | 215 +++++++++++ .../ScriptedFrameProvider.h | 53 +++ lldb/source/Target/StackFrameList.cpp | 35 ++ lldb/source/Target/SyntheticFrameProvider.cpp | 25 +- lldb/source/Target/Target.cpp | 55 +++ lldb/source/Target/Thread.cpp | 72 +++- lldb/source/Target/ThreadSpec.cpp | 4 + .../scripted_frame_provider/Makefile | 3 + .../TestScriptedFrameProvider.py | 339 ++++++++++++++++++ .../scripted_frame_provider/main.cpp | 55 +++ .../test_frame_providers.py | 176 +++++++++ .../Python/PythonTestSuite.cpp | 5 + 43 files changed, 1918 insertions(+), 79 deletions(-) create mode 100644 lldb/source/Plugins/SyntheticFrameProvider/CMakeLists.txt create mode 100644 lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/CMakeLists.txt create mode 100644 lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.cpp create mode 100644 lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.h create mode 100644 lldb/test/API/functionalities/scripted_frame_provider/Makefile create mode 100644 lldb/test/API/functionalities/scripted_frame_provider/TestScriptedFrameProvider.py create mode 100644 lldb/test/API/functionalities/scripted_frame_provider/main.cpp create mode 100644 lldb/test/API/functionalities/scripted_frame_provider/test_frame_providers.py diff --git a/lldb/bindings/python/python-wrapper.swig b/lldb/bindings/python/python-wrapper.swig index 6ba0276fcb05e..d98d46f98037b 100644 --- a/lldb/bindings/python/python-wrapper.swig +++ b/lldb/bindings/python/python-wrapper.swig @@ -422,6 +422,18 @@ void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBBreakpoint(PyObject * return sb_ptr; } +void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBThread(PyObject * data) { + lldb::SBThread *sb_ptr = nullptr; + + int valid_cast = + SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBThread, 0); + + if (valid_cast == -1) + return NULL; + + return sb_ptr; +} + void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrame(PyObject * data) { lldb::SBFrame *sb_ptr = nullptr; diff --git a/lldb/examples/python/templates/scripted_frame_provider.py b/lldb/examples/python/templates/scripted_frame_provider.py index 20f4d76d188c2..7a72f1a24c9da 100644 --- a/lldb/examples/python/templates/scripted_frame_provider.py +++ b/lldb/examples/python/templates/scripted_frame_provider.py @@ -31,7 +31,54 @@ class ScriptedFrameProvider(metaclass=ABCMeta): ) """ + @staticmethod + def applies_to_thread(thread): + """Determine if this frame provider should be used for a given thread. + + This static method is called before creating an instance of the frame + provider to determine if it should be applied to a specific thread. + Override this method to provide custom filtering logic. + + Args: + thread (lldb.SBThread): The thread to check. + + Returns: + bool: True if this frame provider should be used for the thread, + False otherwise. The default implementation returns True for + all threads. + + Example: + + .. code-block:: python + + @staticmethod + def applies_to_thread(thread): + # Only apply to thread 1 + return thread.GetIndexID() == 1 + """ + return True + + @staticmethod @abstractmethod + def get_description(): + """Get a description of this frame provider. + + This method should return a human-readable string describing what + this frame provider does. The description is used for debugging + and display purposes. + + Returns: + str: A description of the frame provider. + + Example: + + .. code-block:: python + + def get_description(self): + return "Crash log frame provider for thread 1" + """ + pass + def __init__(self, input_frames, args): """Construct a scripted frame provider. diff --git a/lldb/examples/python/templates/scripted_process.py b/lldb/examples/python/templates/scripted_process.py index 49059d533f38a..136edce165140 100644 --- a/lldb/examples/python/templates/scripted_process.py +++ b/lldb/examples/python/templates/scripted_process.py @@ -245,6 +245,7 @@ def __init__(self, process, args): key/value pairs used by the scripted thread. """ self.target = None + self.arch = None self.originating_process = None self.process = None self.args = None @@ -266,6 +267,9 @@ def __init__(self, process, args): and process.IsValid() ): self.target = process.target + triple = self.target.triple + if triple: + self.arch = triple.split("-")[0] self.originating_process = process self.process = self.target.GetProcess() self.get_register_info() @@ -352,17 +356,14 @@ def get_stackframes(self): def get_register_info(self): if self.register_info is None: self.register_info = dict() - if "x86_64" in self.originating_process.arch: + if "x86_64" in self.arch: self.register_info["sets"] = ["General Purpose Registers"] self.register_info["registers"] = INTEL64_GPR - elif ( - "arm64" in self.originating_process.arch - or self.originating_process.arch == "aarch64" - ): + elif "arm64" in self.arch or self.arch == "aarch64": self.register_info["sets"] = ["General Purpose Registers"] self.register_info["registers"] = ARM64_GPR else: - raise ValueError("Unknown architecture", self.originating_process.arch) + raise ValueError("Unknown architecture", self.arch) return self.register_info @abstractmethod @@ -405,11 +406,12 @@ def __init__(self, thread, args): """Construct a scripted frame. Args: - thread (ScriptedThread): The thread owning this frame. + thread (ScriptedThread/lldb.SBThread): The thread owning this frame. args (lldb.SBStructuredData): A Dictionary holding arbitrary key/value pairs used by the scripted frame. """ self.target = None + self.arch = None self.originating_thread = None self.thread = None self.args = None @@ -419,15 +421,17 @@ def __init__(self, thread, args): self.register_ctx = {} self.variables = [] - if ( - isinstance(thread, ScriptedThread) - or isinstance(thread, lldb.SBThread) - and thread.IsValid() + if isinstance(thread, ScriptedThread) or ( + isinstance(thread, lldb.SBThread) and thread.IsValid() ): - self.target = thread.target self.process = thread.process + self.target = self.process.target + triple = self.target.triple + if triple: + self.arch = triple.split("-")[0] + tid = thread.tid if isinstance(thread, ScriptedThread) else thread.id self.originating_thread = thread - self.thread = self.process.GetThreadByIndexID(thread.tid) + self.thread = self.process.GetThreadByIndexID(tid) self.get_register_info() @abstractmethod @@ -508,7 +512,18 @@ def get_variables(self, filters): def get_register_info(self): if self.register_info is None: - self.register_info = self.originating_thread.get_register_info() + if isinstance(self.originating_thread, ScriptedThread): + self.register_info = self.originating_thread.get_register_info() + elif isinstance(self.originating_thread, lldb.SBThread): + self.register_info = dict() + if "x86_64" in self.arch: + self.register_info["sets"] = ["General Purpose Registers"] + self.register_info["registers"] = INTEL64_GPR + elif "arm64" in self.arch or self.arch == "aarch64": + self.register_info["sets"] = ["General Purpose Registers"] + self.register_info["registers"] = ARM64_GPR + else: + raise ValueError("Unknown architecture", self.arch) return self.register_info @abstractmethod @@ -642,12 +657,12 @@ def get_stop_reason(self): # TODO: Passthrough stop reason from driving process if self.driving_thread.GetStopReason() != lldb.eStopReasonNone: - if "arm64" in self.originating_process.arch: + if "arm64" in self.arch: stop_reason["type"] = lldb.eStopReasonException stop_reason["data"]["desc"] = ( self.driving_thread.GetStopDescription(100) ) - elif self.originating_process.arch == "x86_64": + elif self.arch == "x86_64": stop_reason["type"] = lldb.eStopReasonSignal stop_reason["data"]["signal"] = signal.SIGTRAP else: diff --git a/lldb/include/lldb/API/SBTarget.h b/lldb/include/lldb/API/SBTarget.h index 4381781383075..04b904be6e441 100644 --- a/lldb/include/lldb/API/SBTarget.h +++ b/lldb/include/lldb/API/SBTarget.h @@ -19,6 +19,7 @@ #include "lldb/API/SBLaunchInfo.h" #include "lldb/API/SBStatisticsOptions.h" #include "lldb/API/SBSymbolContextList.h" +#include "lldb/API/SBThreadCollection.h" #include "lldb/API/SBType.h" #include "lldb/API/SBValue.h" #include "lldb/API/SBWatchpoint.h" @@ -979,6 +980,35 @@ class LLDB_API SBTarget { lldb::SBMutex GetAPIMutex() const; + /// Register a scripted frame provider for this target. + /// If a scripted frame provider with the same name and same argument + /// dictionary is already registered on this target, it will be overwritten. + /// + /// \param[in] class_name + /// The name of the Python class that implements the frame provider. + /// + /// \param[in] args_dict + /// A dictionary of arguments to pass to the frame provider class. + /// + /// \param[out] error + /// An error object indicating success or failure. + /// + /// \return + /// A unique identifier for the frame provider descriptor that was + /// registered. 0 if the registration failed. + uint32_t RegisterScriptedFrameProvider(const char *class_name, + lldb::SBStructuredData args_dict, + lldb::SBError &error); + + /// Remove a scripted frame provider from this target by name. + /// + /// \param[in] provider_id + /// The id of the frame provider class to remove. + /// + /// \return + /// An error object indicating success or failure. + lldb::SBError RemoveScriptedFrameProvider(uint32_t provider_id); + protected: friend class SBAddress; friend class SBAddressRange; diff --git a/lldb/include/lldb/API/SBThread.h b/lldb/include/lldb/API/SBThread.h index e71bdd3e402d7..a352e1805c4e9 100644 --- a/lldb/include/lldb/API/SBThread.h +++ b/lldb/include/lldb/API/SBThread.h @@ -252,6 +252,7 @@ class LLDB_API SBThread { friend class SBThreadPlan; friend class SBTrace; + friend class lldb_private::ScriptInterpreter; friend class lldb_private::python::SWIGBridge; SBThread(const lldb::ThreadSP &lldb_object_sp); diff --git a/lldb/include/lldb/API/SBThreadCollection.h b/lldb/include/lldb/API/SBThreadCollection.h index 5a052e6246026..d13dea0f11cd2 100644 --- a/lldb/include/lldb/API/SBThreadCollection.h +++ b/lldb/include/lldb/API/SBThreadCollection.h @@ -46,6 +46,7 @@ class LLDB_API SBThreadCollection { void SetOpaque(const lldb::ThreadCollectionSP &threads); private: + friend class SBTarget; friend class SBProcess; friend class SBThread; friend class SBSaveCoreOptions; diff --git a/lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h b/lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h index 2d9f713676f90..49b60131399d5 100644 --- a/lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h +++ b/lldb/include/lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h @@ -16,11 +16,29 @@ namespace lldb_private { class ScriptedFrameProviderInterface : public ScriptedInterface { public: + virtual bool AppliesToThread(llvm::StringRef class_name, + lldb::ThreadSP thread_sp) { + return true; + } + virtual llvm::Expected CreatePluginObject(llvm::StringRef class_name, lldb::StackFrameListSP input_frames, StructuredData::DictionarySP args_sp) = 0; + /// Get a description string for the frame provider. + /// + /// This is called by the descriptor to fetch a description from the + /// scripted implementation. Implementations should call a static method + /// on the scripting class to retrieve the description. + /// + /// \param class_name The name of the scripting class implementing the + /// provider. + /// + /// \return A string describing what this frame provider does, or an + /// empty string if no description is available. + virtual std::string GetDescription(llvm::StringRef class_name) { return {}; } + virtual StructuredData::ObjectSP GetFrameAtIndex(uint32_t index) { return {}; } diff --git a/lldb/include/lldb/Interpreter/ScriptInterpreter.h b/lldb/include/lldb/Interpreter/ScriptInterpreter.h index f4c204d5c08e5..f54b14d1f2dbb 100644 --- a/lldb/include/lldb/Interpreter/ScriptInterpreter.h +++ b/lldb/include/lldb/Interpreter/ScriptInterpreter.h @@ -21,6 +21,7 @@ #include "lldb/API/SBMemoryRegionInfo.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBSymbolContext.h" +#include "lldb/API/SBThread.h" #include "lldb/Breakpoint/BreakpointOptions.h" #include "lldb/Core/PluginInterface.h" #include "lldb/Core/SearchFilter.h" @@ -580,6 +581,8 @@ class ScriptInterpreter : public PluginInterface { lldb::StreamSP GetOpaqueTypeFromSBStream(const lldb::SBStream &stream) const; + lldb::ThreadSP GetOpaqueTypeFromSBThread(const lldb::SBThread &exe_ctx) const; + lldb::StackFrameSP GetOpaqueTypeFromSBFrame(const lldb::SBFrame &frame) const; SymbolContext diff --git a/lldb/include/lldb/Target/StackFrame.h b/lldb/include/lldb/Target/StackFrame.h index 939d4c91c346e..51b4e4d4f56ae 100644 --- a/lldb/include/lldb/Target/StackFrame.h +++ b/lldb/include/lldb/Target/StackFrame.h @@ -445,8 +445,11 @@ class StackFrame : public ExecutionContextScope, /// frames are included in this frame index count. uint32_t GetFrameIndex() const; - /// Set this frame's synthetic frame index. - void SetFrameIndex(uint32_t index) { m_frame_index = index; } + /// Set this frame's frame index. + void SetFrameIndex(uint32_t index) { + m_frame_index = index; + m_concrete_frame_index = index; + } /// Query this frame to find what frame it is in this Thread's /// StackFrameList, not counting inlined frames. diff --git a/lldb/include/lldb/Target/StackFrameList.h b/lldb/include/lldb/Target/StackFrameList.h index cc1ccd2178059..2bd1789b27e5d 100644 --- a/lldb/include/lldb/Target/StackFrameList.h +++ b/lldb/include/lldb/Target/StackFrameList.h @@ -20,13 +20,13 @@ namespace lldb_private { class ScriptedThread; -class StackFrameList { +class StackFrameList : public std::enable_shared_from_this { public: // Constructors and Destructors StackFrameList(Thread &thread, const lldb::StackFrameListSP &prev_frames_sp, bool show_inline_frames); - ~StackFrameList(); + virtual ~StackFrameList(); /// Get the number of visible frames. Frames may be created if \p can_create /// is true. Synthetic (inline) frames expanded from the concrete frame #0 @@ -106,6 +106,7 @@ class StackFrameList { protected: friend class Thread; + friend class ScriptedFrameProvider; friend class ScriptedThread; /// Use this API to build a stack frame list (used for scripted threads, for @@ -206,19 +207,23 @@ class StackFrameList { /// Whether or not to show synthetic (inline) frames. Immutable. const bool m_show_inlined_frames; + /// Returns true if fetching frames was interrupted, false otherwise. + virtual bool FetchFramesUpTo(uint32_t end_idx, + InterruptionControl allow_interrupt); + private: uint32_t SetSelectedFrameNoLock(lldb_private::StackFrame *frame); lldb::StackFrameSP GetFrameAtIndexNoLock(uint32_t idx, std::shared_lock &guard); + /// @{ /// These two Fetch frames APIs and SynthesizeTailCallFrames are called in /// GetFramesUpTo, they are the ones that actually add frames. They must be /// called with the writer end of the list mutex held. - - /// Returns true if fetching frames was interrupted, false otherwise. - bool FetchFramesUpTo(uint32_t end_idx, InterruptionControl allow_interrupt); + /// /// Not currently interruptible so returns void. + /// }@ void FetchOnlyConcreteFramesUpTo(uint32_t end_idx); void SynthesizeTailCallFrames(StackFrame &next_frame); @@ -226,6 +231,27 @@ class StackFrameList { const StackFrameList &operator=(const StackFrameList &) = delete; }; +/// A StackFrameList that wraps another StackFrameList and uses a +/// SyntheticFrameProvider to lazily provide frames from either the provider +/// or the underlying real stack frame list. +class SyntheticStackFrameList : public StackFrameList { +public: + SyntheticStackFrameList(Thread &thread, lldb::StackFrameListSP input_frames, + const lldb::StackFrameListSP &prev_frames_sp, + bool show_inline_frames); + +protected: + /// Override FetchFramesUpTo to lazily return frames from the provider + /// or from the actual stack frame list. + bool FetchFramesUpTo(uint32_t end_idx, + InterruptionControl allow_interrupt) override; + +private: + /// The input stack frame list that the provider transforms. + /// This could be a real StackFrameList or another SyntheticStackFrameList. + lldb::StackFrameListSP m_input_frames; +}; + } // namespace lldb_private #endif // LLDB_TARGET_STACKFRAMELIST_H diff --git a/lldb/include/lldb/Target/SyntheticFrameProvider.h b/lldb/include/lldb/Target/SyntheticFrameProvider.h index 61a492f356ece..2d5330cb03105 100644 --- a/lldb/include/lldb/Target/SyntheticFrameProvider.h +++ b/lldb/include/lldb/Target/SyntheticFrameProvider.h @@ -24,22 +24,25 @@ namespace lldb_private { /// This struct contains the metadata needed to instantiate a frame provider /// and optional filters to control which threads it applies to. -struct SyntheticFrameProviderDescriptor { +struct ScriptedFrameProviderDescriptor { /// Metadata for instantiating the provider (e.g. script class name and args). lldb::ScriptedMetadataSP scripted_metadata_sp; + /// Interface for calling static methods on the provider class. + lldb::ScriptedFrameProviderInterfaceSP interface_sp; + /// Optional list of thread specifications to which this provider applies. /// If empty, the provider applies to all threads. A thread matches if it /// satisfies ANY of the specs in this vector (OR logic). std::vector thread_specs; - SyntheticFrameProviderDescriptor() = default; + ScriptedFrameProviderDescriptor() = default; - SyntheticFrameProviderDescriptor(lldb::ScriptedMetadataSP metadata_sp) + ScriptedFrameProviderDescriptor(lldb::ScriptedMetadataSP metadata_sp) : scripted_metadata_sp(metadata_sp) {} - SyntheticFrameProviderDescriptor(lldb::ScriptedMetadataSP metadata_sp, - const std::vector &specs) + ScriptedFrameProviderDescriptor(lldb::ScriptedMetadataSP metadata_sp, + const std::vector &specs) : scripted_metadata_sp(metadata_sp), thread_specs(specs) {} /// Get the name of this descriptor (the scripted class name). @@ -47,6 +50,12 @@ struct SyntheticFrameProviderDescriptor { return scripted_metadata_sp ? scripted_metadata_sp->GetClassName() : ""; } + /// Get the description of this frame provider. + /// + /// \return A string describing what this frame provider does, or an + /// empty string if no description is available. + std::string GetDescription() const; + /// Check if this descriptor applies to the given thread. bool AppliesToThread(Thread &thread) const { // If no thread specs specified, applies to all threads. @@ -64,6 +73,13 @@ struct SyntheticFrameProviderDescriptor { /// Check if this descriptor has valid metadata for script-based providers. bool IsValid() const { return scripted_metadata_sp != nullptr; } + /// Get a unique identifier for this descriptor based on its contents. + /// The ID is computed from the class name and arguments dictionary, + /// not from the pointer address, so two descriptors with the same + /// contents will have the same ID. + uint32_t GetID() const; + + /// Dump a description of this descriptor to the given stream. void Dump(Stream *s) const; }; @@ -95,7 +111,7 @@ class SyntheticFrameProvider : public PluginInterface { /// otherwise an \a llvm::Error. static llvm::Expected CreateInstance(lldb::StackFrameListSP input_frames, - const SyntheticFrameProviderDescriptor &descriptor); + const ScriptedFrameProviderDescriptor &descriptor); /// Try to create a SyntheticFrameProvider instance for the given input /// frames using a specific C++ plugin. @@ -125,6 +141,8 @@ class SyntheticFrameProvider : public PluginInterface { ~SyntheticFrameProvider() override; + virtual std::string GetDescription() const = 0; + /// Get a single stack frame at the specified index. /// /// This method is called lazily - frames are only created when requested. diff --git a/lldb/include/lldb/Target/Target.h b/lldb/include/lldb/Target/Target.h index 476715ebb9ce1..9fe5f311a8a5b 100644 --- a/lldb/include/lldb/Target/Target.h +++ b/lldb/include/lldb/Target/Target.h @@ -37,6 +37,7 @@ #include "lldb/Target/PathMappingList.h" #include "lldb/Target/SectionLoadHistory.h" #include "lldb/Target/Statistics.h" +#include "lldb/Target/SyntheticFrameProvider.h" #include "lldb/Target/ThreadSpec.h" #include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/Args.h" @@ -780,6 +781,36 @@ class Target : public std::enable_shared_from_this, Status Attach(ProcessAttachInfo &attach_info, Stream *stream); // Optional stream to receive first stop info + /// Add or update a scripted frame provider descriptor for this target. + /// All new threads in this target will check if they match any descriptors + /// to create their frame providers. + /// + /// \param[in] descriptor + /// The descriptor to add or update. + /// + /// \return + /// The descriptor identifier if the registration succeeded, otherwise an + /// llvm::Error. + llvm::Expected AddScriptedFrameProviderDescriptor( + const ScriptedFrameProviderDescriptor &descriptor); + + /// Remove a scripted frame provider descriptor by id. + /// + /// \param[in] id + /// The id of the descriptor to remove. + /// + /// \return + /// True if a descriptor was removed, false if no descriptor with that + /// id existed. + bool RemoveScriptedFrameProviderDescriptor(uint32_t id); + + /// Clear all scripted frame provider descriptors for this target. + void ClearScriptedFrameProviderDescriptors(); + + /// Get all scripted frame provider descriptors for this target. + const llvm::DenseMap & + GetScriptedFrameProviderDescriptors() const; + // This part handles the breakpoints. BreakpointList &GetBreakpointList(bool internal = false); @@ -1743,6 +1774,13 @@ class Target : public std::enable_shared_from_this, TypeSystemMap m_scratch_type_system_map; std::map m_cant_make_scratch_type_system; + /// Map of scripted frame provider descriptors for this target. + /// Keys are the provider descriptors ids, values are the descriptors. + /// Used to initialize frame providers for new threads. + llvm::DenseMap + m_frame_provider_descriptors; + mutable std::recursive_mutex m_frame_provider_descriptors_mutex; + typedef std::map REPLMap; REPLMap m_repl_map; diff --git a/lldb/include/lldb/Target/Thread.h b/lldb/include/lldb/Target/Thread.h index 05eabd0015263..1ad7e8e7f6fa3 100644 --- a/lldb/include/lldb/Target/Thread.h +++ b/lldb/include/lldb/Target/Thread.h @@ -1329,6 +1329,15 @@ class Thread : public std::enable_shared_from_this, lldb::StackFrameListSP GetStackFrameList(); + llvm::Error + LoadScriptedFrameProvider(const ScriptedFrameProviderDescriptor &descriptor); + + void ClearScriptedFrameProvider(); + + lldb::SyntheticFrameProviderSP GetFrameProvider() const { + return m_frame_provider_sp; + } + protected: friend class ThreadPlan; friend class ThreadList; @@ -1432,6 +1441,9 @@ class Thread : public std::enable_shared_from_this, /// The Thread backed by this thread, if any. lldb::ThreadWP m_backed_thread; + /// The Scripted Frame Provider, if any. + lldb::SyntheticFrameProviderSP m_frame_provider_sp; + private: bool m_extended_info_fetched; // Have we tried to retrieve the m_extended_info // for this thread? diff --git a/lldb/include/lldb/Target/ThreadSpec.h b/lldb/include/lldb/Target/ThreadSpec.h index 7c7c832741196..63f8f8b5ec181 100644 --- a/lldb/include/lldb/Target/ThreadSpec.h +++ b/lldb/include/lldb/Target/ThreadSpec.h @@ -34,6 +34,8 @@ class ThreadSpec { public: ThreadSpec(); + ThreadSpec(Thread &thread); + static std::unique_ptr CreateFromStructuredData(const StructuredData::Dictionary &data_dict, Status &error); diff --git a/lldb/include/lldb/Utility/ScriptedMetadata.h b/lldb/include/lldb/Utility/ScriptedMetadata.h index 69c83edce909a..8523c95429718 100644 --- a/lldb/include/lldb/Utility/ScriptedMetadata.h +++ b/lldb/include/lldb/Utility/ScriptedMetadata.h @@ -10,7 +10,9 @@ #define LLDB_INTERPRETER_SCRIPTEDMETADATA_H #include "lldb/Utility/ProcessInfo.h" +#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StructuredData.h" +#include "llvm/ADT/Hashing.h" namespace lldb_private { class ScriptedMetadata { @@ -27,11 +29,36 @@ class ScriptedMetadata { } } + ScriptedMetadata(const ScriptedMetadata &other) + : m_class_name(other.m_class_name), m_args_sp(other.m_args_sp) {} + explicit operator bool() const { return !m_class_name.empty(); } llvm::StringRef GetClassName() const { return m_class_name; } StructuredData::DictionarySP GetArgsSP() const { return m_args_sp; } + /// Get a unique identifier for this metadata based on its contents. + /// The ID is computed from the class name and arguments dictionary, + /// not from the pointer address, so two metadata objects with the same + /// contents will have the same ID. + uint32_t GetID() const { + if (m_class_name.empty()) + return 0; + + // Hash the class name. + llvm::hash_code hash = llvm::hash_value(m_class_name); + + // Hash the arguments dictionary if present. + if (m_args_sp) { + StreamString ss; + m_args_sp->GetDescription(ss); + hash = llvm::hash_combine(hash, llvm::hash_value(ss.GetData())); + } + + // Return the lower 32 bits of the hash. + return static_cast(hash); + } + private: std::string m_class_name; StructuredData::DictionarySP m_args_sp; diff --git a/lldb/include/lldb/lldb-private-interfaces.h b/lldb/include/lldb/lldb-private-interfaces.h index 7d414b1106e0a..f60ecfdcfda00 100644 --- a/lldb/include/lldb/lldb-private-interfaces.h +++ b/lldb/include/lldb/lldb-private-interfaces.h @@ -25,7 +25,7 @@ class Value; namespace lldb_private { class ScriptedInterfaceUsages; -struct SyntheticFrameProviderDescriptor; +struct ScriptedFrameProviderDescriptor; typedef lldb::ABISP (*ABICreateInstance)(lldb::ProcessSP process_sp, const ArchSpec &arch); typedef std::unique_ptr (*ArchitectureCreateInstance)( @@ -90,7 +90,7 @@ typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)( typedef llvm::Expected ( *ScriptedFrameProviderCreateInstance)( lldb::StackFrameListSP input_frames, - const lldb_private::SyntheticFrameProviderDescriptor &descriptor); + const lldb_private::ScriptedFrameProviderDescriptor &descriptor); typedef llvm::Expected ( *SyntheticFrameProviderCreateInstance)( lldb::StackFrameListSP input_frames, diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp index 34f3c261719b2..9d43e09b0caa4 100644 --- a/lldb/source/API/SBTarget.cpp +++ b/lldb/source/API/SBTarget.cpp @@ -23,6 +23,7 @@ #include "lldb/API/SBStringList.h" #include "lldb/API/SBStructuredData.h" #include "lldb/API/SBSymbolContextList.h" +#include "lldb/API/SBThreadCollection.h" #include "lldb/API/SBTrace.h" #include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointIDList.h" @@ -39,6 +40,7 @@ #include "lldb/Core/Section.h" #include "lldb/Core/StructuredDataImpl.h" #include "lldb/Host/Host.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" #include "lldb/Symbol/DeclVendor.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolFile.h" @@ -50,6 +52,7 @@ #include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/Process.h" #include "lldb/Target/StackFrame.h" +#include "lldb/Target/SyntheticFrameProvider.h" #include "lldb/Target/Target.h" #include "lldb/Target/TargetList.h" #include "lldb/Utility/ArchSpec.h" @@ -59,6 +62,7 @@ #include "lldb/Utility/LLDBLog.h" #include "lldb/Utility/ProcessInfo.h" #include "lldb/Utility/RegularExpression.h" +#include "lldb/Utility/ScriptedMetadata.h" #include "lldb/ValueObject/ValueObjectConstResult.h" #include "lldb/ValueObject/ValueObjectList.h" #include "lldb/ValueObject/ValueObjectVariable.h" @@ -2445,3 +2449,81 @@ lldb::SBMutex SBTarget::GetAPIMutex() const { return lldb::SBMutex(target_sp); return lldb::SBMutex(); } + +uint32_t +SBTarget::RegisterScriptedFrameProvider(const char *class_name, + lldb::SBStructuredData args_dict, + lldb::SBError &error) { + LLDB_INSTRUMENT_VA(this, class_name, args_dict, error); + + TargetSP target_sp = GetSP(); + if (!target_sp) { + error.SetErrorString("invalid target"); + return 0; + } + + if (!class_name || !class_name[0]) { + error.SetErrorString("invalid class name"); + return 0; + } + + // Extract the dictionary from SBStructuredData. + StructuredData::DictionarySP dict_sp; + if (args_dict.IsValid() && args_dict.m_impl_up) { + StructuredData::ObjectSP obj_sp = args_dict.m_impl_up->GetObjectSP(); + if (obj_sp && obj_sp->GetType() != lldb::eStructuredDataTypeDictionary) { + error.SetErrorString("SBStructuredData argument isn't a dictionary"); + return 0; + } + dict_sp = std::make_shared(obj_sp); + } + + // Create the ScriptedMetadata. + ScriptedMetadataSP metadata_sp = + std::make_shared(class_name, dict_sp); + + // Create the interface for calling static methods. + ScriptedFrameProviderInterfaceSP interface_sp = + target_sp->GetDebugger() + .GetScriptInterpreter() + ->CreateScriptedFrameProviderInterface(); + + // Create a descriptor (applies to all threads by default). + ScriptedFrameProviderDescriptor descriptor(metadata_sp); + descriptor.interface_sp = interface_sp; + + llvm::Expected descriptor_id_or_err = + target_sp->AddScriptedFrameProviderDescriptor(descriptor); + if (!descriptor_id_or_err) { + error.SetErrorString( + llvm::toString(descriptor_id_or_err.takeError()).c_str()); + return 0; + } + + // Register the descriptor with the target. + return *descriptor_id_or_err; +} + +lldb::SBError SBTarget::RemoveScriptedFrameProvider(uint32_t provider_id) { + LLDB_INSTRUMENT_VA(this, provider_id); + + SBError error; + TargetSP target_sp = GetSP(); + if (!target_sp) { + error.SetErrorString("invalid target"); + return error; + } + + if (!provider_id) { + error.SetErrorString("invalid provider id"); + return error; + } + + if (!target_sp->RemoveScriptedFrameProviderDescriptor(provider_id)) { + error.SetErrorStringWithFormat("no frame provider named '%u' found", + provider_id); + return error; + } + + return {}; +} diff --git a/lldb/source/Commands/CommandObjectTarget.cpp b/lldb/source/Commands/CommandObjectTarget.cpp index 62d245734c288..3facb42eb577b 100644 --- a/lldb/source/Commands/CommandObjectTarget.cpp +++ b/lldb/source/Commands/CommandObjectTarget.cpp @@ -51,6 +51,7 @@ #include "lldb/Utility/ConstString.h" #include "lldb/Utility/FileSpec.h" #include "lldb/Utility/LLDBLog.h" +#include "lldb/Utility/ScriptedMetadata.h" #include "lldb/Utility/State.h" #include "lldb/Utility/Stream.h" #include "lldb/Utility/StructuredData.h" @@ -5345,6 +5346,202 @@ class CommandObjectTargetDump : public CommandObjectMultiword { ~CommandObjectTargetDump() override = default; }; +#pragma mark CommandObjectTargetFrameProvider + +#define LLDB_OPTIONS_target_frame_provider_register +#include "CommandOptions.inc" + +class CommandObjectTargetFrameProviderRegister : public CommandObjectParsed { +public: + CommandObjectTargetFrameProviderRegister(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "target frame-provider register", + "Register frame provider for all threads in this target.", nullptr, + eCommandRequiresTarget), + + m_class_options("target frame-provider", true, 'C', 'k', 'v', 0) { + m_all_options.Append(&m_class_options, LLDB_OPT_SET_1 | LLDB_OPT_SET_2, + LLDB_OPT_SET_ALL); + m_all_options.Finalize(); + + AddSimpleArgumentList(eArgTypeRunArgs, eArgRepeatOptional); + } + + ~CommandObjectTargetFrameProviderRegister() override = default; + + Options *GetOptions() override { return &m_all_options; } + + std::optional GetRepeatCommand(Args ¤t_command_args, + uint32_t index) override { + return std::string(""); + } + +protected: + void DoExecute(Args &launch_args, CommandReturnObject &result) override { + ScriptedMetadataSP metadata_sp = std::make_shared( + m_class_options.GetName(), m_class_options.GetStructuredData()); + + Target *target = m_exe_ctx.GetTargetPtr(); + if (!target) + target = &GetDebugger().GetDummyTarget(); + + // Create the interface for calling static methods. + ScriptedFrameProviderInterfaceSP interface_sp = + GetDebugger() + .GetScriptInterpreter() + ->CreateScriptedFrameProviderInterface(); + + // Create a descriptor from the metadata (applies to all threads by + // default). + ScriptedFrameProviderDescriptor descriptor(metadata_sp); + descriptor.interface_sp = interface_sp; + + auto id_or_err = target->AddScriptedFrameProviderDescriptor(descriptor); + if (!id_or_err) { + result.SetError(id_or_err.takeError()); + return; + } + + result.AppendMessageWithFormat( + "successfully registered scripted frame provider '%s' for target\n", + m_class_options.GetName().c_str()); + } + + OptionGroupPythonClassWithDict m_class_options; + OptionGroupOptions m_all_options; +}; + +class CommandObjectTargetFrameProviderClear : public CommandObjectParsed { +public: + CommandObjectTargetFrameProviderClear(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "target frame-provider clear", + "Clear all registered frame providers from this target.", nullptr, + eCommandRequiresTarget) {} + + ~CommandObjectTargetFrameProviderClear() override = default; + +protected: + void DoExecute(Args &command, CommandReturnObject &result) override { + Target *target = m_exe_ctx.GetTargetPtr(); + if (!target) { + result.AppendError("invalid target"); + return; + } + + target->ClearScriptedFrameProviderDescriptors(); + + result.SetStatus(eReturnStatusSuccessFinishResult); + } +}; + +class CommandObjectTargetFrameProviderList : public CommandObjectParsed { +public: + CommandObjectTargetFrameProviderList(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "target frame-provider list", + "List all registered frame providers for the target.", nullptr, + eCommandRequiresTarget) {} + + ~CommandObjectTargetFrameProviderList() override = default; + +protected: + void DoExecute(Args &command, CommandReturnObject &result) override { + Target *target = m_exe_ctx.GetTargetPtr(); + if (!target) + target = &GetDebugger().GetDummyTarget(); + + const auto &descriptors = target->GetScriptedFrameProviderDescriptors(); + if (descriptors.empty()) { + result.AppendMessage("no frame providers registered for this target."); + result.SetStatus(eReturnStatusSuccessFinishResult); + return; + } + + result.AppendMessageWithFormat("%u frame provider(s) registered:\n\n", + descriptors.size()); + + for (const auto &entry : descriptors) { + const ScriptedFrameProviderDescriptor &descriptor = entry.second; + descriptor.Dump(&result.GetOutputStream()); + result.GetOutputStream().PutChar('\n'); + } + + result.SetStatus(eReturnStatusSuccessFinishResult); + } +}; + +class CommandObjectTargetFrameProviderRemove : public CommandObjectParsed { +public: + CommandObjectTargetFrameProviderRemove(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "target frame-provider remove", + "Remove a registered frame provider from the target by id.", + "target frame-provider remove ", + eCommandRequiresTarget) { + AddSimpleArgumentList(eArgTypeUnsignedInteger, eArgRepeatPlus); + } + + ~CommandObjectTargetFrameProviderRemove() override = default; + +protected: + void DoExecute(Args &command, CommandReturnObject &result) override { + Target *target = m_exe_ctx.GetTargetPtr(); + if (!target) + target = &GetDebugger().GetDummyTarget(); + + std::vector removed_provider_ids; + for (size_t i = 0; i < command.GetArgumentCount(); i++) { + uint32_t provider_id = 0; + if (!llvm::to_integer(command[i].ref(), provider_id)) { + result.AppendError("target frame-provider remove requires integer " + "provider id argument"); + return; + } + + if (!target->RemoveScriptedFrameProviderDescriptor(provider_id)) { + result.AppendErrorWithFormat( + "no frame provider named '%u' found in target\n", provider_id); + return; + } + removed_provider_ids.push_back(provider_id); + } + + if (size_t num_removed_providers = removed_provider_ids.size()) { + result.AppendMessageWithFormat( + "Successfully removed %zu frame-providers.\n", num_removed_providers); + result.SetStatus(eReturnStatusSuccessFinishNoResult); + } else { + result.AppendError("0 frame providers removed.\n"); + } + } +}; + +class CommandObjectTargetFrameProvider : public CommandObjectMultiword { +public: + CommandObjectTargetFrameProvider(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "target frame-provider", + "Commands for registering and viewing frame providers for the " + "target.", + "target frame-provider [] ") { + LoadSubCommand("register", + CommandObjectSP(new CommandObjectTargetFrameProviderRegister( + interpreter))); + LoadSubCommand("clear", + CommandObjectSP( + new CommandObjectTargetFrameProviderClear(interpreter))); + LoadSubCommand( + "list", + CommandObjectSP(new CommandObjectTargetFrameProviderList(interpreter))); + LoadSubCommand( + "remove", CommandObjectSP( + new CommandObjectTargetFrameProviderRemove(interpreter))); + } + + ~CommandObjectTargetFrameProvider() override = default; +}; + #pragma mark CommandObjectMultiwordTarget // CommandObjectMultiwordTarget @@ -5360,6 +5557,9 @@ CommandObjectMultiwordTarget::CommandObjectMultiwordTarget( CommandObjectSP(new CommandObjectTargetDelete(interpreter))); LoadSubCommand("dump", CommandObjectSP(new CommandObjectTargetDump(interpreter))); + LoadSubCommand( + "frame-provider", + CommandObjectSP(new CommandObjectTargetFrameProvider(interpreter))); LoadSubCommand("list", CommandObjectSP(new CommandObjectTargetList(interpreter))); LoadSubCommand("select", diff --git a/lldb/source/Interpreter/ScriptInterpreter.cpp b/lldb/source/Interpreter/ScriptInterpreter.cpp index 8b03af03ed8d9..cee5f94b8aa29 100644 --- a/lldb/source/Interpreter/ScriptInterpreter.cpp +++ b/lldb/source/Interpreter/ScriptInterpreter.cpp @@ -106,6 +106,13 @@ ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const { return Status(); } +lldb::ThreadSP ScriptInterpreter::GetOpaqueTypeFromSBThread( + const lldb::SBThread &thread) const { + if (thread.m_opaque_sp) + return thread.m_opaque_sp->GetThreadSP(); + return nullptr; +} + lldb::StackFrameSP ScriptInterpreter::GetOpaqueTypeFromSBFrame(const lldb::SBFrame &frame) const { if (frame.m_opaque_sp) diff --git a/lldb/source/Plugins/CMakeLists.txt b/lldb/source/Plugins/CMakeLists.txt index 08f444e7b15e8..b6878b21ff71a 100644 --- a/lldb/source/Plugins/CMakeLists.txt +++ b/lldb/source/Plugins/CMakeLists.txt @@ -22,6 +22,7 @@ add_subdirectory(SymbolFile) add_subdirectory(SystemRuntime) add_subdirectory(SymbolLocator) add_subdirectory(SymbolVendor) +add_subdirectory(SyntheticFrameProvider) add_subdirectory(Trace) add_subdirectory(TraceExporter) add_subdirectory(TypeSystem) diff --git a/lldb/source/Plugins/Process/scripted/ScriptedFrame.cpp b/lldb/source/Plugins/Process/scripted/ScriptedFrame.cpp index 6519df9185df0..53d0c22e62ad7 100644 --- a/lldb/source/Plugins/Process/scripted/ScriptedFrame.cpp +++ b/lldb/source/Plugins/Process/scripted/ScriptedFrame.cpp @@ -7,8 +7,22 @@ //===----------------------------------------------------------------------===// #include "ScriptedFrame.h" - +#include "Plugins/Process/Utility/RegisterContextMemory.h" + +#include "lldb/Core/Address.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameInterface.h" +#include "lldb/Interpreter/Interfaces/ScriptedThreadInterface.h" +#include "lldb/Interpreter/ScriptInterpreter.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/Thread.h" #include "lldb/Utility/DataBufferHeap.h" +#include "lldb/Utility/LLDBLog.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/StructuredData.h" using namespace lldb; using namespace lldb_private; @@ -19,30 +33,44 @@ void ScriptedFrame::CheckInterpreterAndScriptObject() const { } llvm::Expected> -ScriptedFrame::Create(ScriptedThread &thread, +ScriptedFrame::Create(ThreadSP thread_sp, + ScriptedThreadInterfaceSP scripted_thread_interface_sp, StructuredData::DictionarySP args_sp, StructuredData::Generic *script_object) { - if (!thread.IsValid()) - return llvm::createStringError("Invalid scripted thread."); + if (!thread_sp || !thread_sp->IsValid()) + return llvm::createStringError("invalid thread"); + + ProcessSP process_sp = thread_sp->GetProcess(); + if (!process_sp || !process_sp->IsValid()) + return llvm::createStringError("invalid process"); - thread.CheckInterpreterAndScriptObject(); + ScriptInterpreter *script_interp = + process_sp->GetTarget().GetDebugger().GetScriptInterpreter(); + if (!script_interp) + return llvm::createStringError("no script interpreter"); - auto scripted_frame_interface = - thread.GetInterface()->CreateScriptedFrameInterface(); + auto scripted_frame_interface = script_interp->CreateScriptedFrameInterface(); if (!scripted_frame_interface) return llvm::createStringError("failed to create scripted frame interface"); llvm::StringRef frame_class_name; if (!script_object) { - std::optional class_name = - thread.GetInterface()->GetScriptedFramePluginName(); - if (!class_name || class_name->empty()) + // If no script object is provided and we have a scripted thread interface, + // try to get the frame class name from it. + if (scripted_thread_interface_sp) { + std::optional class_name = + scripted_thread_interface_sp->GetScriptedFramePluginName(); + if (!class_name || class_name->empty()) + return llvm::createStringError( + "failed to get scripted frame class name"); + frame_class_name = *class_name; + } else { return llvm::createStringError( - "failed to get scripted thread class name"); - frame_class_name = *class_name; + "no script object provided and no scripted thread interface"); + } } - ExecutionContext exe_ctx(thread); + ExecutionContext exe_ctx(thread_sp); auto obj_or_err = scripted_frame_interface->CreatePluginObject( frame_class_name, exe_ctx, args_sp, script_object); @@ -62,7 +90,7 @@ ScriptedFrame::Create(ScriptedThread &thread, SymbolContext sc; Address symbol_addr; if (pc != LLDB_INVALID_ADDRESS) { - symbol_addr.SetLoadAddress(pc, &thread.GetProcess()->GetTarget()); + symbol_addr.SetLoadAddress(pc, &process_sp->GetTarget()); symbol_addr.CalculateSymbolContext(&sc); } @@ -77,11 +105,11 @@ ScriptedFrame::Create(ScriptedThread &thread, if (!reg_info) return llvm::createStringError( - "failed to get scripted thread registers info"); + "failed to get scripted frame registers info"); std::shared_ptr register_info_sp = - DynamicRegisterInfo::Create( - *reg_info, thread.GetProcess()->GetTarget().GetArchitecture()); + DynamicRegisterInfo::Create(*reg_info, + process_sp->GetTarget().GetArchitecture()); lldb::RegisterContextSP reg_ctx_sp; @@ -96,32 +124,35 @@ ScriptedFrame::Create(ScriptedThread &thread, std::shared_ptr reg_ctx_memory = std::make_shared( - thread, frame_id, *register_info_sp, LLDB_INVALID_ADDRESS); + *thread_sp, frame_id, *register_info_sp, LLDB_INVALID_ADDRESS); if (!reg_ctx_memory) - return llvm::createStringError("failed to create a register context."); + return llvm::createStringError("failed to create a register context"); reg_ctx_memory->SetAllRegisterData(data_sp); reg_ctx_sp = reg_ctx_memory; } return std::make_shared( - thread, scripted_frame_interface, frame_id, pc, sc, reg_ctx_sp, + thread_sp, scripted_frame_interface, frame_id, pc, sc, reg_ctx_sp, register_info_sp, owned_script_object_sp); } -ScriptedFrame::ScriptedFrame(ScriptedThread &thread, +ScriptedFrame::ScriptedFrame(ThreadSP thread_sp, ScriptedFrameInterfaceSP interface_sp, lldb::user_id_t id, lldb::addr_t pc, SymbolContext &sym_ctx, lldb::RegisterContextSP reg_ctx_sp, std::shared_ptr reg_info_sp, StructuredData::GenericSP script_object_sp) - : StackFrame(thread.shared_from_this(), /*frame_idx=*/id, + : StackFrame(thread_sp, /*frame_idx=*/id, /*concrete_frame_idx=*/id, /*reg_context_sp=*/reg_ctx_sp, /*cfa=*/0, /*pc=*/pc, /*behaves_like_zeroth_frame=*/!id, /*symbol_ctx=*/&sym_ctx), m_scripted_frame_interface_sp(interface_sp), - m_script_object_sp(script_object_sp), m_register_info_sp(reg_info_sp) {} + m_script_object_sp(script_object_sp), m_register_info_sp(reg_info_sp) { + // FIXME: This should be part of the base class constructor. + m_stack_frame_kind = StackFrame::Kind::Synthetic; +} ScriptedFrame::~ScriptedFrame() {} @@ -164,7 +195,7 @@ std::shared_ptr ScriptedFrame::GetDynamicRegisterInfo() { if (!reg_info) return ScriptedInterface::ErrorWithMessage< std::shared_ptr>( - LLVM_PRETTY_FUNCTION, "Failed to get scripted frame registers info.", + LLVM_PRETTY_FUNCTION, "failed to get scripted frame registers info", error, LLDBLog::Thread); ThreadSP thread_sp = m_thread_wp.lock(); @@ -172,7 +203,7 @@ std::shared_ptr ScriptedFrame::GetDynamicRegisterInfo() { return ScriptedInterface::ErrorWithMessage< std::shared_ptr>( LLVM_PRETTY_FUNCTION, - "Failed to get scripted frame registers info: invalid thread.", error, + "failed to get scripted frame registers info: invalid thread", error, LLDBLog::Thread); ProcessSP process_sp = thread_sp->GetProcess(); @@ -180,8 +211,8 @@ std::shared_ptr ScriptedFrame::GetDynamicRegisterInfo() { return ScriptedInterface::ErrorWithMessage< std::shared_ptr>( LLVM_PRETTY_FUNCTION, - "Failed to get scripted frame registers info: invalid process.", - error, LLDBLog::Thread); + "failed to get scripted frame registers info: invalid process", error, + LLDBLog::Thread); m_register_info_sp = DynamicRegisterInfo::Create( *reg_info, process_sp->GetTarget().GetArchitecture()); diff --git a/lldb/source/Plugins/Process/scripted/ScriptedFrame.h b/lldb/source/Plugins/Process/scripted/ScriptedFrame.h index b6b77c4a7d160..e91e6160bac2f 100644 --- a/lldb/source/Plugins/Process/scripted/ScriptedFrame.h +++ b/lldb/source/Plugins/Process/scripted/ScriptedFrame.h @@ -10,21 +10,19 @@ #define LLDB_SOURCE_PLUGINS_SCRIPTED_FRAME_H #include "ScriptedThread.h" -#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Target/DynamicRegisterInfo.h" #include "lldb/Target/StackFrame.h" +#include "lldb/lldb-forward.h" +#include "llvm/Support/Error.h" +#include #include -namespace lldb_private { -class ScriptedThread; -} - namespace lldb_private { class ScriptedFrame : public lldb_private::StackFrame { public: - ScriptedFrame(ScriptedThread &thread, + ScriptedFrame(lldb::ThreadSP thread_sp, lldb::ScriptedFrameInterfaceSP interface_sp, lldb::user_id_t frame_idx, lldb::addr_t pc, SymbolContext &sym_ctx, lldb::RegisterContextSP reg_ctx_sp, @@ -33,8 +31,29 @@ class ScriptedFrame : public lldb_private::StackFrame { ~ScriptedFrame() override; + /// Create a ScriptedFrame from a object instanciated in the script + /// interpreter. + /// + /// \param[in] thread_sp + /// The thread this frame belongs to. + /// + /// \param[in] scripted_thread_interface_sp + /// The scripted thread interface (needed for ScriptedThread + /// compatibility). Can be nullptr for frames on real threads. + /// + /// \param[in] args_sp + /// Arguments to pass to the frame creation. + /// + /// \param[in] script_object + /// The optional script object representing this frame. + /// + /// \return + /// An Expected containing the ScriptedFrame shared pointer if successful, + /// otherwise an error. static llvm::Expected> - Create(ScriptedThread &thread, StructuredData::DictionarySP args_sp, + Create(lldb::ThreadSP thread_sp, + lldb::ScriptedThreadInterfaceSP scripted_thread_interface_sp, + StructuredData::DictionarySP args_sp, StructuredData::Generic *script_object = nullptr); bool IsInlined() override; diff --git a/lldb/source/Plugins/Process/scripted/ScriptedThread.cpp b/lldb/source/Plugins/Process/scripted/ScriptedThread.cpp index 491efac5aadef..1dd9c48f56a59 100644 --- a/lldb/source/Plugins/Process/scripted/ScriptedThread.cpp +++ b/lldb/source/Plugins/Process/scripted/ScriptedThread.cpp @@ -210,7 +210,7 @@ bool ScriptedThread::LoadArtificialStackFrames() { SymbolContext sc; symbol_addr.CalculateSymbolContext(&sc); - return std::make_shared(this->shared_from_this(), idx, idx, cfa, + return std::make_shared(shared_from_this(), idx, idx, cfa, cfa_is_valid, pc, StackFrame::Kind::Synthetic, artificial, behaves_like_zeroth_frame, &sc); @@ -231,8 +231,8 @@ bool ScriptedThread::LoadArtificialStackFrames() { return error.ToError(); } - auto frame_or_error = - ScriptedFrame::Create(*this, nullptr, object_sp->GetAsGeneric()); + auto frame_or_error = ScriptedFrame::Create( + shared_from_this(), GetInterface(), nullptr, object_sp->GetAsGeneric()); if (!frame_or_error) { ScriptedInterface::ErrorWithMessage( diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.cpp index d43036d6fe544..f6c707b2bd168 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptInterpreterPythonInterfaces.cpp @@ -31,6 +31,7 @@ void ScriptInterpreterPythonInterfaces::Initialize() { ScriptedStopHookPythonInterface::Initialize(); ScriptedBreakpointPythonInterface::Initialize(); ScriptedThreadPlanPythonInterface::Initialize(); + ScriptedFrameProviderPythonInterface::Initialize(); } void ScriptInterpreterPythonInterfaces::Terminate() { @@ -40,6 +41,7 @@ void ScriptInterpreterPythonInterfaces::Terminate() { ScriptedStopHookPythonInterface::Terminate(); ScriptedBreakpointPythonInterface::Terminate(); ScriptedThreadPlanPythonInterface::Terminate(); + ScriptedFrameProviderPythonInterface::Terminate(); } #endif diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp index b866bf332b7b6..3dde5036453f4 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "lldb/Core/PluginManager.h" #include "lldb/Host/Config.h" #include "lldb/Target/Thread.h" #include "lldb/Utility/Log.h" @@ -30,18 +31,45 @@ ScriptedFrameProviderPythonInterface::ScriptedFrameProviderPythonInterface( ScriptInterpreterPythonImpl &interpreter) : ScriptedFrameProviderInterface(), ScriptedPythonInterface(interpreter) {} +bool ScriptedFrameProviderPythonInterface::AppliesToThread( + llvm::StringRef class_name, lldb::ThreadSP thread_sp) { + // If there is any issue with this method, we will just assume it also applies + // to this thread which is the default behavior. + constexpr bool fail_value = true; + Status error; + StructuredData::ObjectSP obj = + CallStaticMethod(class_name, "applies_to_thread", error, thread_sp); + if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, + error)) + return fail_value; + + return obj->GetBooleanValue(fail_value); +} + llvm::Expected ScriptedFrameProviderPythonInterface::CreatePluginObject( const llvm::StringRef class_name, lldb::StackFrameListSP input_frames, StructuredData::DictionarySP args_sp) { if (!input_frames) - return llvm::createStringError("Invalid frame list"); + return llvm::createStringError("invalid frame list"); StructuredDataImpl sd_impl(args_sp); return ScriptedPythonInterface::CreatePluginObject(class_name, nullptr, input_frames, sd_impl); } +std::string ScriptedFrameProviderPythonInterface::GetDescription( + llvm::StringRef class_name) { + Status error; + StructuredData::ObjectSP obj = + CallStaticMethod(class_name, "get_description", error); + if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, + error)) + return {}; + + return obj->GetStringValue().str(); +} + StructuredData::ObjectSP ScriptedFrameProviderPythonInterface::GetFrameAtIndex(uint32_t index) { Status error; @@ -54,4 +82,32 @@ ScriptedFrameProviderPythonInterface::GetFrameAtIndex(uint32_t index) { return obj; } +bool ScriptedFrameProviderPythonInterface::CreateInstance( + lldb::ScriptLanguage language, ScriptedInterfaceUsages usages) { + if (language != eScriptLanguagePython) + return false; + + return true; +} + +void ScriptedFrameProviderPythonInterface::Initialize() { + const std::vector ci_usages = { + "target frame-provider register -C [-k key -v value ...]", + "target frame-provider list", + "target frame-provider remove ", + "target frame-provider clear"}; + const std::vector api_usages = { + "SBTarget.RegisterScriptedFrameProvider", + "SBTarget.RemoveScriptedFrameProvider", + "SBTarget.ClearScriptedFrameProvider"}; + PluginManager::RegisterPlugin( + GetPluginNameStatic(), + llvm::StringRef("Provide scripted stack frames for threads"), + CreateInstance, eScriptLanguagePython, {ci_usages, api_usages}); +} + +void ScriptedFrameProviderPythonInterface::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + #endif diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h index fd163984028d3..97a5cc7c669ea 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedFrameProviderPythonInterface.h @@ -14,17 +14,22 @@ #if LLDB_ENABLE_PYTHON #include "ScriptedPythonInterface.h" +#include "lldb/Core/PluginInterface.h" #include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" #include namespace lldb_private { class ScriptedFrameProviderPythonInterface : public ScriptedFrameProviderInterface, - public ScriptedPythonInterface { + public ScriptedPythonInterface, + public PluginInterface { public: ScriptedFrameProviderPythonInterface( ScriptInterpreterPythonImpl &interpreter); + bool AppliesToThread(llvm::StringRef class_name, + lldb::ThreadSP thread_sp) override; + llvm::Expected CreatePluginObject(llvm::StringRef class_name, lldb::StackFrameListSP input_frames, @@ -33,10 +38,24 @@ class ScriptedFrameProviderPythonInterface llvm::SmallVector GetAbstractMethodRequirements() const override { return llvm::SmallVector( - {{"get_frame_at_index"}}); + {{"get_description"}, {"get_frame_at_index"}}); } + std::string GetDescription(llvm::StringRef class_name) override; + StructuredData::ObjectSP GetFrameAtIndex(uint32_t index) override; + + static void Initialize(); + static void Terminate(); + + static bool CreateInstance(lldb::ScriptLanguage language, + ScriptedInterfaceUsages usages); + + static llvm::StringRef GetPluginNameStatic() { + return "ScriptedFrameProviderPythonInterface"; + } + + llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); } }; } // namespace lldb_private diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp index af2e0b5df4d22..ba4473cf9ec4d 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp @@ -93,6 +93,19 @@ ScriptedPythonInterface::ExtractValueFromPythonObject( return nullptr; } +template <> +lldb::ThreadSP +ScriptedPythonInterface::ExtractValueFromPythonObject( + python::PythonObject &p, Status &error) { + if (lldb::SBThread *sb_thread = reinterpret_cast( + python::LLDBSWIGPython_CastPyObjectToSBThread(p.get()))) + return m_interpreter.GetOpaqueTypeFromSBThread(*sb_thread); + error = Status::FromErrorString( + "Couldn't cast lldb::SBThread to lldb_private::Thread."); + + return nullptr; +} + template <> SymbolContext ScriptedPythonInterface::ExtractValueFromPythonObject( diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h index ec1dd9910d8a6..d7940d26d7cb0 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h @@ -325,6 +325,112 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { return m_object_instance_sp; } + /// Call a static method on a Python class without creating an instance. + /// + /// This method resolves a Python class by name and calls a static method + /// on it, returning the result. This is useful for calling class-level + /// methods that don't require an instance. + /// + /// \param class_name The fully-qualified name of the Python class. + /// \param method_name The name of the static method to call. + /// \param error Output parameter to receive error information if the call + /// fails. + /// \param args Arguments to pass to the static method. + /// + /// \return The return value of the static method call, or an error value. + template + T CallStaticMethod(llvm::StringRef class_name, llvm::StringRef method_name, + Status &error, Args &&...args) { + using namespace python; + using Locker = ScriptInterpreterPythonImpl::Locker; + + std::string caller_signature = + llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") + + llvm::Twine(class_name) + llvm::Twine(".") + + llvm::Twine(method_name) + llvm::Twine(")")) + .str(); + + if (class_name.empty()) + return ErrorWithMessage(caller_signature, "missing script class name", + error); + + Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN, + Locker::FreeLock); + + // Get the interpreter dictionary. + auto dict = + PythonModule::MainModule().ResolveName( + m_interpreter.GetDictionaryName()); + if (!dict.IsAllocated()) + return ErrorWithMessage( + caller_signature, + llvm::formatv("could not find interpreter dictionary: {0}", + m_interpreter.GetDictionaryName()) + .str(), + error); + + // Resolve the class. + auto class_obj = + PythonObject::ResolveNameWithDictionary( + class_name, dict); + if (!class_obj.IsAllocated()) + return ErrorWithMessage( + caller_signature, + llvm::formatv("could not find script class: {0}", class_name).str(), + error); + + // Get the static method from the class. + if (!class_obj.HasAttribute(method_name)) + return ErrorWithMessage( + caller_signature, + llvm::formatv("class {0} does not have method {1}", class_name, + method_name) + .str(), + error); + + PythonCallable method = + class_obj.GetAttributeValue(method_name).AsType(); + if (!method.IsAllocated()) + return ErrorWithMessage(caller_signature, + llvm::formatv("method {0}.{1} is not callable", + class_name, method_name) + .str(), + error); + + // Transform the arguments. + std::tuple original_args = std::forward_as_tuple(args...); + auto transformed_args = TransformArgs(original_args); + + // Call the static method. + llvm::Expected expected_return_object = + llvm::make_error("Not initialized.", + llvm::inconvertibleErrorCode()); + std::apply( + [&method, &expected_return_object](auto &&...args) { + llvm::consumeError(expected_return_object.takeError()); + expected_return_object = method(args...); + }, + transformed_args); + + if (llvm::Error e = expected_return_object.takeError()) { + error = Status::FromError(std::move(e)); + return ErrorWithMessage( + caller_signature, "python static method could not be called", error); + } + + PythonObject py_return = std::move(expected_return_object.get()); + + // Re-assign reference and pointer arguments if needed. + if (sizeof...(Args) > 0) + if (!ReassignPtrsOrRefsArgs(original_args, transformed_args)) + return ErrorWithMessage( + caller_signature, + "couldn't re-assign reference and pointer arguments", error); + + // Extract value from Python object (handles unallocated case). + return ExtractValueFromPythonObject(py_return, error); + } + protected: template T ExtractValueFromPythonObject(python::PythonObject &p, Status &error) { @@ -341,7 +447,7 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { llvm::Twine(method_name) + llvm::Twine(")")) .str(); if (!m_object_instance_sp) - return ErrorWithMessage(caller_signature, "Python object ill-formed", + return ErrorWithMessage(caller_signature, "python object ill-formed", error); Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN, @@ -353,7 +459,7 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { if (!implementor.IsAllocated()) return llvm::is_contained(GetAbstractMethods(), method_name) ? ErrorWithMessage(caller_signature, - "Python implementor not allocated.", + "python implementor not allocated", error) : T{}; @@ -374,20 +480,20 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { if (llvm::Error e = expected_return_object.takeError()) { error = Status::FromError(std::move(e)); return ErrorWithMessage(caller_signature, - "Python method could not be called.", error); + "python method could not be called", error); } PythonObject py_return = std::move(expected_return_object.get()); // Now that we called the python method with the transformed arguments, - // we need to interate again over both the original and transformed + // we need to iterate again over both the original and transformed // parameter pack, and transform back the parameter that were passed in // the original parameter pack as references or pointers. if (sizeof...(Args) > 0) if (!ReassignPtrsOrRefsArgs(original_args, transformed_args)) return ErrorWithMessage( caller_signature, - "Couldn't re-assign reference and pointer arguments.", error); + "couldn't re-assign reference and pointer arguments", error); if (!py_return.IsAllocated()) return {}; @@ -593,6 +699,11 @@ lldb::StreamSP ScriptedPythonInterface::ExtractValueFromPythonObject( python::PythonObject &p, Status &error); +template <> +lldb::ThreadSP +ScriptedPythonInterface::ExtractValueFromPythonObject( + python::PythonObject &p, Status &error); + template <> lldb::StackFrameSP ScriptedPythonInterface::ExtractValueFromPythonObject( diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h index bf31ce9c7760e..28f10b9f55b97 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h @@ -264,6 +264,7 @@ void *LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBError(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBEvent(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBStream(PyObject *data); +void *LLDBSWIGPython_CastPyObjectToSBThread(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBFrame(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBSymbolContext(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data); diff --git a/lldb/source/Plugins/SyntheticFrameProvider/CMakeLists.txt b/lldb/source/Plugins/SyntheticFrameProvider/CMakeLists.txt new file mode 100644 index 0000000000000..85b405e648c1f --- /dev/null +++ b/lldb/source/Plugins/SyntheticFrameProvider/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(ScriptedFrameProvider) diff --git a/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/CMakeLists.txt b/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/CMakeLists.txt new file mode 100644 index 0000000000000..fe67d39efdf11 --- /dev/null +++ b/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/CMakeLists.txt @@ -0,0 +1,12 @@ +add_lldb_library(lldbPluginScriptedFrameProvider PLUGIN + ScriptedFrameProvider.cpp + + LINK_COMPONENTS + Support + + LINK_LIBS + lldbCore + lldbInterpreter + lldbTarget + lldbUtility + ) diff --git a/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.cpp b/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.cpp new file mode 100644 index 0000000000000..17d0e925fadc6 --- /dev/null +++ b/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.cpp @@ -0,0 +1,215 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "ScriptedFrameProvider.h" +#include "Plugins/Process/scripted/ScriptedFrame.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" +#include "lldb/Interpreter/ScriptInterpreter.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/ScriptedMetadata.h" +#include "lldb/Utility/Status.h" +#include "llvm/Support/Error.h" +#include + +using namespace lldb; +using namespace lldb_private; + +void ScriptedFrameProvider::Initialize() { + PluginManager::RegisterPlugin(GetPluginNameStatic(), + "Provides synthetic frames via scripting", + nullptr, ScriptedFrameProvider::CreateInstance); +} + +void ScriptedFrameProvider::Terminate() { + PluginManager::UnregisterPlugin(ScriptedFrameProvider::CreateInstance); +} + +llvm::Expected +ScriptedFrameProvider::CreateInstance( + lldb::StackFrameListSP input_frames, + const ScriptedFrameProviderDescriptor &descriptor) { + if (!input_frames) + return llvm::createStringError( + "failed to create scripted frame provider: invalid input frames"); + + Thread &thread = input_frames->GetThread(); + ProcessSP process_sp = thread.GetProcess(); + if (!process_sp) + return nullptr; + + if (!descriptor.IsValid()) + return llvm::createStringError( + "failed to create scripted frame provider: invalid scripted metadata"); + + if (!descriptor.AppliesToThread(thread)) + return nullptr; + + ScriptInterpreter *script_interp = + process_sp->GetTarget().GetDebugger().GetScriptInterpreter(); + if (!script_interp) + return llvm::createStringError("cannot create scripted frame provider: No " + "script interpreter installed"); + + ScriptedFrameProviderInterfaceSP interface_sp = + script_interp->CreateScriptedFrameProviderInterface(); + if (!interface_sp) + return llvm::createStringError( + "cannot create scripted frame provider: script interpreter couldn't " + "create Scripted Frame Provider Interface"); + + const ScriptedMetadataSP scripted_metadata = descriptor.scripted_metadata_sp; + + // If we shouldn't attach a frame provider to this thread, just exit early. + if (!interface_sp->AppliesToThread(scripted_metadata->GetClassName(), + thread.shared_from_this())) + return nullptr; + + auto obj_or_err = interface_sp->CreatePluginObject( + scripted_metadata->GetClassName(), input_frames, + scripted_metadata->GetArgsSP()); + if (!obj_or_err) + return obj_or_err.takeError(); + + StructuredData::ObjectSP object_sp = *obj_or_err; + if (!object_sp || !object_sp->IsValid()) + return llvm::createStringError( + "cannot create scripted frame provider: failed to create valid scripted" + "frame provider object"); + + return std::make_shared(input_frames, interface_sp, + descriptor); +} + +ScriptedFrameProvider::ScriptedFrameProvider( + StackFrameListSP input_frames, + lldb::ScriptedFrameProviderInterfaceSP interface_sp, + const ScriptedFrameProviderDescriptor &descriptor) + : SyntheticFrameProvider(input_frames), m_interface_sp(interface_sp), + m_descriptor(descriptor) {} + +ScriptedFrameProvider::~ScriptedFrameProvider() = default; + +std::string ScriptedFrameProvider::GetDescription() const { + if (!m_interface_sp) + return {}; + + return m_interface_sp->GetDescription(m_descriptor.GetName()); +} + +llvm::Expected +ScriptedFrameProvider::GetFrameAtIndex(uint32_t idx) { + if (!m_interface_sp) + return llvm::createStringError( + "cannot get stack frame: scripted frame provider not initialized"); + + auto create_frame_from_dict = + [this](StructuredData::Dictionary *dict, + uint32_t index) -> llvm::Expected { + lldb::addr_t pc; + if (!dict->GetValueForKeyAsInteger("pc", pc)) + return llvm::createStringError( + "missing 'pc' key from scripted frame dictionary"); + + Address symbol_addr; + symbol_addr.SetLoadAddress(pc, &GetThread().GetProcess()->GetTarget()); + + const lldb::addr_t cfa = LLDB_INVALID_ADDRESS; + const bool cfa_is_valid = false; + const bool artificial = false; + const bool behaves_like_zeroth_frame = false; + SymbolContext sc; + symbol_addr.CalculateSymbolContext(&sc); + + ThreadSP thread_sp = GetThread().shared_from_this(); + return std::make_shared(thread_sp, index, index, cfa, + cfa_is_valid, pc, + StackFrame::Kind::Synthetic, artificial, + behaves_like_zeroth_frame, &sc); + }; + + auto create_frame_from_script_object = + [this]( + StructuredData::ObjectSP object_sp) -> llvm::Expected { + Status error; + if (!object_sp || !object_sp->GetAsGeneric()) + return llvm::createStringError("invalid script object"); + + ThreadSP thread_sp = GetThread().shared_from_this(); + auto frame_or_error = ScriptedFrame::Create(thread_sp, nullptr, nullptr, + object_sp->GetAsGeneric()); + + if (!frame_or_error) { + ScriptedInterface::ErrorWithMessage( + LLVM_PRETTY_FUNCTION, toString(frame_or_error.takeError()), error); + return error.ToError(); + } + + return *frame_or_error; + }; + + StructuredData::ObjectSP obj_sp = m_interface_sp->GetFrameAtIndex(idx); + + // None/null means no more frames or error. + if (!obj_sp || !obj_sp->IsValid()) + return llvm::createStringError("invalid script object returned for frame " + + llvm::Twine(idx)); + + StackFrameSP synth_frame_sp = nullptr; + if (StructuredData::UnsignedInteger *int_obj = + obj_sp->GetAsUnsignedInteger()) { + uint32_t real_frame_index = int_obj->GetValue(); + if (real_frame_index < m_input_frames->GetNumFrames()) { + synth_frame_sp = m_input_frames->GetFrameAtIndex(real_frame_index); + } + } else if (StructuredData::Dictionary *dict = obj_sp->GetAsDictionary()) { + // Check if it's a dictionary describing a frame. + auto frame_from_dict_or_err = create_frame_from_dict(dict, idx); + if (!frame_from_dict_or_err) { + return llvm::createStringError(llvm::Twine( + "couldn't create frame from dictionary at index " + llvm::Twine(idx) + + ": " + toString(frame_from_dict_or_err.takeError()))); + } + synth_frame_sp = *frame_from_dict_or_err; + } else if (obj_sp->GetAsGeneric()) { + // It's a ScriptedFrame object. + auto frame_from_script_obj_or_err = create_frame_from_script_object(obj_sp); + if (!frame_from_script_obj_or_err) { + return llvm::createStringError( + llvm::Twine("couldn't create frame from script object at index " + + llvm::Twine(idx) + ": " + + toString(frame_from_script_obj_or_err.takeError()))); + } + synth_frame_sp = *frame_from_script_obj_or_err; + } else { + return llvm::createStringError( + llvm::Twine("invalid return type from get_frame_at_index at index " + + llvm::Twine(idx))); + } + + if (!synth_frame_sp) + return llvm::createStringError( + llvm::Twine("failed to create frame at index " + llvm::Twine(idx))); + + synth_frame_sp->SetFrameIndex(idx); + + return synth_frame_sp; +} + +namespace lldb_private { +void lldb_initialize_ScriptedFrameProvider() { + ScriptedFrameProvider::Initialize(); +} + +void lldb_terminate_ScriptedFrameProvider() { + ScriptedFrameProvider::Terminate(); +} +} // namespace lldb_private diff --git a/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.h b/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.h new file mode 100644 index 0000000000000..3434bf26ade24 --- /dev/null +++ b/lldb/source/Plugins/SyntheticFrameProvider/ScriptedFrameProvider/ScriptedFrameProvider.h @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_PLUGINS_SYNTHETICFRAMEPROVIDER_SCRIPTEDFRAMEPROVIDER_SCRIPTEDFRAMEPROVIDER_H +#define LLDB_PLUGINS_SYNTHETICFRAMEPROVIDER_SCRIPTEDFRAMEPROVIDER_SCRIPTEDFRAMEPROVIDER_H + +#include "lldb/Target/SyntheticFrameProvider.h" +#include "lldb/Utility/ScriptedMetadata.h" +#include "lldb/Utility/Status.h" +#include "lldb/lldb-forward.h" +#include "llvm/Support/Error.h" + +namespace lldb_private { + +class ScriptedFrameProvider : public SyntheticFrameProvider { +public: + static llvm::StringRef GetPluginNameStatic() { + return "ScriptedFrameProvider"; + } + + static llvm::Expected + CreateInstance(lldb::StackFrameListSP input_frames, + const ScriptedFrameProviderDescriptor &descriptor); + + static void Initialize(); + + static void Terminate(); + + ScriptedFrameProvider(lldb::StackFrameListSP input_frames, + lldb::ScriptedFrameProviderInterfaceSP interface_sp, + const ScriptedFrameProviderDescriptor &descriptor); + ~ScriptedFrameProvider() override; + + llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); } + + std::string GetDescription() const override; + + /// Get a single stack frame at the specified index. + llvm::Expected GetFrameAtIndex(uint32_t idx) override; + +private: + lldb::ScriptedFrameProviderInterfaceSP m_interface_sp; + const ScriptedFrameProviderDescriptor &m_descriptor; +}; + +} // namespace lldb_private + +#endif // LLDB_PLUGINS_SYNTHETICFRAMEPROVIDER_SCRIPTEDFRAMEPROVIDER_SCRIPTEDFRAMEPROVIDER_H diff --git a/lldb/source/Target/StackFrameList.cpp b/lldb/source/Target/StackFrameList.cpp index 82bc0a797a600..150465b0a1865 100644 --- a/lldb/source/Target/StackFrameList.cpp +++ b/lldb/source/Target/StackFrameList.cpp @@ -20,6 +20,7 @@ #include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrameRecognizer.h" #include "lldb/Target/StopInfo.h" +#include "lldb/Target/SyntheticFrameProvider.h" #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" #include "lldb/Target/Unwind.h" @@ -55,6 +56,40 @@ StackFrameList::~StackFrameList() { Clear(); } +SyntheticStackFrameList::SyntheticStackFrameList( + Thread &thread, lldb::StackFrameListSP input_frames, + const lldb::StackFrameListSP &prev_frames_sp, bool show_inline_frames) + : StackFrameList(thread, prev_frames_sp, show_inline_frames), + m_input_frames(std::move(input_frames)) {} + +bool SyntheticStackFrameList::FetchFramesUpTo( + uint32_t end_idx, InterruptionControl allow_interrupt) { + // Check if the thread has a synthetic frame provider. + if (auto provider_sp = m_thread.GetFrameProvider()) { + // Use the synthetic frame provider to generate frames lazily. + // Keep fetching until we reach end_idx or the provider returns an error. + for (uint32_t idx = m_frames.size(); idx <= end_idx; idx++) { + if (allow_interrupt && + m_thread.GetProcess()->GetTarget().GetDebugger().InterruptRequested()) + return true; + auto frame_or_err = provider_sp->GetFrameAtIndex(idx); + if (!frame_or_err) { + // Provider returned error - we've reached the end. + LLDB_LOG_ERROR(GetLog(LLDBLog::Thread), frame_or_err.takeError(), + "Frame provider reached end at index {0}: {1}", idx); + SetAllFramesFetched(); + break; + } + m_frames.push_back(*frame_or_err); + } + + return false; // Not interrupted. + } + + // If no provider, fall back to the base implementation. + return StackFrameList::FetchFramesUpTo(end_idx, allow_interrupt); +} + void StackFrameList::CalculateCurrentInlinedDepth() { uint32_t cur_inlined_depth = GetCurrentInlinedDepth(); if (cur_inlined_depth == UINT32_MAX) { diff --git a/lldb/source/Target/SyntheticFrameProvider.cpp b/lldb/source/Target/SyntheticFrameProvider.cpp index 241ce82c39be3..97ff42d1ed53e 100644 --- a/lldb/source/Target/SyntheticFrameProvider.cpp +++ b/lldb/source/Target/SyntheticFrameProvider.cpp @@ -8,10 +8,12 @@ #include "lldb/Target/SyntheticFrameProvider.h" #include "lldb/Core/PluginManager.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" #include "lldb/Target/Thread.h" #include "lldb/Utility/LLDBLog.h" #include "lldb/Utility/Log.h" #include "lldb/Utility/Status.h" +#include "lldb/Utility/Stream.h" using namespace lldb; using namespace lldb_private; @@ -21,12 +23,17 @@ SyntheticFrameProvider::SyntheticFrameProvider(StackFrameListSP input_frames) SyntheticFrameProvider::~SyntheticFrameProvider() = default; -void SyntheticFrameProviderDescriptor::Dump(Stream *s) const { +void ScriptedFrameProviderDescriptor::Dump(Stream *s) const { if (!s) return; + s->Format(" ID: {0:x}\n", GetID()); s->Printf(" Name: %s\n", GetName().str().c_str()); + std::string description = GetDescription(); + if (!description.empty()) + s->Printf(" Description: %s\n", description.c_str()); + // Show thread filter information. if (thread_specs.empty()) { s->PutCString(" Thread Filter: (applies to all threads)\n"); @@ -41,9 +48,23 @@ void SyntheticFrameProviderDescriptor::Dump(Stream *s) const { } } +uint32_t ScriptedFrameProviderDescriptor::GetID() const { + if (!scripted_metadata_sp) + return 0; + + return scripted_metadata_sp->GetID(); +} + +std::string ScriptedFrameProviderDescriptor::GetDescription() const { + // If we have an interface, call get_description() to fetch it. + if (interface_sp && scripted_metadata_sp) + return interface_sp->GetDescription(scripted_metadata_sp->GetClassName()); + return {}; +} + llvm::Expected SyntheticFrameProvider::CreateInstance( StackFrameListSP input_frames, - const SyntheticFrameProviderDescriptor &descriptor) { + const ScriptedFrameProviderDescriptor &descriptor) { if (!input_frames) return llvm::createStringError( "cannot create synthetic frame provider: invalid input frames"); diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp index cd977fcaeeedd..8c13ab00aa0c9 100644 --- a/lldb/source/Target/Target.cpp +++ b/lldb/source/Target/Target.cpp @@ -3779,6 +3779,61 @@ Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) { return error; } +llvm::Expected Target::AddScriptedFrameProviderDescriptor( + const ScriptedFrameProviderDescriptor &descriptor) { + if (!descriptor.IsValid()) + return llvm::createStringError("invalid frame provider descriptor"); + + llvm::StringRef name = descriptor.GetName(); + if (name.empty()) + return llvm::createStringError( + "frame provider descriptor has no class name"); + + std::lock_guard guard( + m_frame_provider_descriptors_mutex); + + uint32_t descriptor_id = descriptor.GetID(); + m_frame_provider_descriptors[descriptor_id] = descriptor; + + // Clear frame providers on existing threads so they reload with new config. + if (ProcessSP process_sp = GetProcessSP()) + for (ThreadSP thread_sp : process_sp->Threads()) + thread_sp->ClearScriptedFrameProvider(); + + return descriptor_id; +} + +bool Target::RemoveScriptedFrameProviderDescriptor(uint32_t id) { + std::lock_guard guard( + m_frame_provider_descriptors_mutex); + bool removed = m_frame_provider_descriptors.erase(id); + + if (removed) + if (ProcessSP process_sp = GetProcessSP()) + for (ThreadSP thread_sp : process_sp->Threads()) + thread_sp->ClearScriptedFrameProvider(); + + return removed; +} + +void Target::ClearScriptedFrameProviderDescriptors() { + std::lock_guard guard( + m_frame_provider_descriptors_mutex); + + m_frame_provider_descriptors.clear(); + + if (ProcessSP process_sp = GetProcessSP()) + for (ThreadSP thread_sp : process_sp->Threads()) + thread_sp->ClearScriptedFrameProvider(); +} + +const llvm::DenseMap & +Target::GetScriptedFrameProviderDescriptors() const { + std::lock_guard guard( + m_frame_provider_descriptors_mutex); + return m_frame_provider_descriptors; +} + void Target::FinalizeFileActions(ProcessLaunchInfo &info) { Log *log = GetLog(LLDBLog::Process); diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp index 5e32b063cebdc..206192b9c407d 100644 --- a/lldb/source/Target/Thread.cpp +++ b/lldb/source/Target/Thread.cpp @@ -13,9 +13,12 @@ #include "lldb/Core/Module.h" #include "lldb/Core/StructuredDataImpl.h" #include "lldb/Host/Host.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameInterface.h" +#include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" #include "lldb/Interpreter/OptionValueFileSpecList.h" #include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/Property.h" +#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Symbol/Function.h" #include "lldb/Target/ABI.h" #include "lldb/Target/DynamicLoader.h" @@ -26,6 +29,7 @@ #include "lldb/Target/ScriptedThreadPlan.h" #include "lldb/Target/StackFrameRecognizer.h" #include "lldb/Target/StopInfo.h" +#include "lldb/Target/SyntheticFrameProvider.h" #include "lldb/Target/SystemRuntime.h" #include "lldb/Target/Target.h" #include "lldb/Target/ThreadPlan.h" @@ -46,6 +50,7 @@ #include "lldb/Utility/LLDBLog.h" #include "lldb/Utility/Log.h" #include "lldb/Utility/RegularExpression.h" +#include "lldb/Utility/ScriptedMetadata.h" #include "lldb/Utility/State.h" #include "lldb/Utility/Stream.h" #include "lldb/Utility/StreamString.h" @@ -258,6 +263,7 @@ void Thread::DestroyThread() { std::lock_guard guard(m_frame_mutex); m_curr_frames_sp.reset(); m_prev_frames_sp.reset(); + m_frame_provider_sp.reset(); m_prev_framezero_pc.reset(); } @@ -1491,13 +1497,76 @@ void Thread::CalculateExecutionContext(ExecutionContext &exe_ctx) { StackFrameListSP Thread::GetStackFrameList() { std::lock_guard guard(m_frame_mutex); - if (!m_curr_frames_sp) + if (m_curr_frames_sp) + return m_curr_frames_sp; + + // First, try to load a frame provider if we don't have one yet. + if (!m_frame_provider_sp) { + ProcessSP process_sp = GetProcess(); + if (process_sp) { + Target &target = process_sp->GetTarget(); + const auto &descriptors = target.GetScriptedFrameProviderDescriptors(); + + // Find first descriptor that applies to this thread. + for (const auto &entry : descriptors) { + const ScriptedFrameProviderDescriptor &descriptor = entry.second; + if (descriptor.IsValid() && descriptor.AppliesToThread(*this)) { + if (llvm::Error error = LoadScriptedFrameProvider(descriptor)) { + LLDB_LOG_ERROR(GetLog(LLDBLog::Thread), std::move(error), + "Failed to load scripted frame provider: {0}"); + } + break; // Use first matching descriptor (success or failure). + } + } + } + } + + // Create the frame list based on whether we have a provider. + if (m_frame_provider_sp) { + // We have a provider - create synthetic frame list. + StackFrameListSP input_frames = m_frame_provider_sp->GetInputFrames(); + m_curr_frames_sp = std::make_shared( + *this, input_frames, m_prev_frames_sp, true); + } else { + // No provider - use normal unwinder frames. m_curr_frames_sp = std::make_shared(*this, m_prev_frames_sp, true); + } return m_curr_frames_sp; } +llvm::Error Thread::LoadScriptedFrameProvider( + const ScriptedFrameProviderDescriptor &descriptor) { + std::lock_guard guard(m_frame_mutex); + + // Note: We don't create input_frames here - it will be created lazily + // by SyntheticStackFrameList when frames are first fetched. + // Creating them too early can cause crashes during thread initialization. + + // Create a temporary StackFrameList just to get the thread reference for the + // provider. The provider won't actually use this - it will get real input + // frames from SyntheticStackFrameList later. + StackFrameListSP temp_frames = + std::make_shared(*this, m_prev_frames_sp, true); + + auto provider_or_err = + SyntheticFrameProvider::CreateInstance(temp_frames, descriptor); + if (!provider_or_err) + return provider_or_err.takeError(); + + ClearScriptedFrameProvider(); + m_frame_provider_sp = *provider_or_err; + return llvm::Error::success(); +} + +void Thread::ClearScriptedFrameProvider() { + std::lock_guard guard(m_frame_mutex); + m_frame_provider_sp.reset(); + m_curr_frames_sp.reset(); + m_prev_frames_sp.reset(); +} + std::optional Thread::GetPreviousFrameZeroPC() { return m_prev_framezero_pc; } @@ -1518,6 +1587,7 @@ void Thread::ClearStackFrames() { m_prev_frames_sp.swap(m_curr_frames_sp); m_curr_frames_sp.reset(); + m_frame_provider_sp.reset(); m_extended_info.reset(); m_extended_info_fetched = false; } diff --git a/lldb/source/Target/ThreadSpec.cpp b/lldb/source/Target/ThreadSpec.cpp index ba4c3aa894553..624f64e3af800 100644 --- a/lldb/source/Target/ThreadSpec.cpp +++ b/lldb/source/Target/ThreadSpec.cpp @@ -19,6 +19,10 @@ const char *ThreadSpec::g_option_names[static_cast( ThreadSpec::ThreadSpec() : m_name(), m_queue_name() {} +ThreadSpec::ThreadSpec(Thread &thread) + : m_index(thread.GetIndexID()), m_tid(thread.GetID()), + m_name(thread.GetName()), m_queue_name(thread.GetQueueName()) {} + std::unique_ptr ThreadSpec::CreateFromStructuredData( const StructuredData::Dictionary &spec_dict, Status &error) { uint32_t index = UINT32_MAX; diff --git a/lldb/test/API/functionalities/scripted_frame_provider/Makefile b/lldb/test/API/functionalities/scripted_frame_provider/Makefile new file mode 100644 index 0000000000000..99998b20bcb05 --- /dev/null +++ b/lldb/test/API/functionalities/scripted_frame_provider/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/lldb/test/API/functionalities/scripted_frame_provider/TestScriptedFrameProvider.py b/lldb/test/API/functionalities/scripted_frame_provider/TestScriptedFrameProvider.py new file mode 100644 index 0000000000000..189ca2f147f9d --- /dev/null +++ b/lldb/test/API/functionalities/scripted_frame_provider/TestScriptedFrameProvider.py @@ -0,0 +1,339 @@ +""" +Test scripted frame provider functionality. +""" + +import os + +import lldb +from lldbsuite.test.lldbtest import TestBase +from lldbsuite.test import lldbutil + + +class ScriptedFrameProviderTestCase(TestBase): + NO_DEBUG_INFO_TESTCASE = True + + def setUp(self): + TestBase.setUp(self) + self.source = "main.cpp" + + def test_replace_all_frames(self): + """Test that we can replace the entire stack.""" + self.build() + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Break here", lldb.SBFileSpec(self.source), only_one_thread=False + ) + + # Import the test frame provider + script_path = os.path.join(self.getSourceDir(), "test_frame_providers.py") + self.runCmd("command script import " + script_path) + + # Attach the Replace provider + error = lldb.SBError() + provider_id = target.RegisterScriptedFrameProvider( + "test_frame_providers.ReplaceFrameProvider", + lldb.SBStructuredData(), + error, + ) + self.assertTrue(error.Success(), f"Failed to register provider: {error}") + self.assertNotEqual(provider_id, 0, "Provider ID should be non-zero") + + # Verify we have exactly 3 synthetic frames + self.assertEqual(thread.GetNumFrames(), 3, "Should have 3 synthetic frames") + + # Verify frame indices and PCs (dictionary-based frames don't have custom function names) + frame0 = thread.GetFrameAtIndex(0) + self.assertIsNotNone(frame0) + self.assertEqual(frame0.GetPC(), 0x1000) + + frame1 = thread.GetFrameAtIndex(1) + self.assertIsNotNone(frame1) + self.assertIn("thread_func", frame1.GetFunctionName()) + + frame2 = thread.GetFrameAtIndex(2) + self.assertIsNotNone(frame2) + self.assertEqual(frame2.GetPC(), 0x3000) + + def test_prepend_frames(self): + """Test that we can add frames before real stack.""" + self.build() + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Break here", lldb.SBFileSpec(self.source), only_one_thread=False + ) + + # Get original frame count and PC + original_frame_count = thread.GetNumFrames() + self.assertGreaterEqual( + original_frame_count, 2, "Should have at least 2 real frames" + ) + + # Import and attach Prepend provider + script_path = os.path.join(self.getSourceDir(), "test_frame_providers.py") + self.runCmd("command script import " + script_path) + + error = lldb.SBError() + provider_id = target.RegisterScriptedFrameProvider( + "test_frame_providers.PrependFrameProvider", + lldb.SBStructuredData(), + error, + ) + self.assertTrue(error.Success(), f"Failed to register provider: {error}") + self.assertNotEqual(provider_id, 0, "Provider ID should be non-zero") + + # Verify we have 2 more frames + new_frame_count = thread.GetNumFrames() + self.assertEqual(new_frame_count, original_frame_count + 2) + + # Verify first 2 frames are synthetic (check PCs, not function names) + frame0 = thread.GetFrameAtIndex(0) + self.assertEqual(frame0.GetPC(), 0x9000) + + frame1 = thread.GetFrameAtIndex(1) + self.assertEqual(frame1.GetPC(), 0xA000) + + # Verify frame 2 is the original real frame 0 + frame2 = thread.GetFrameAtIndex(2) + self.assertIn("thread_func", frame2.GetFunctionName()) + + def test_append_frames(self): + """Test that we can add frames after real stack.""" + self.build() + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Break here", lldb.SBFileSpec(self.source), only_one_thread=False + ) + + # Get original frame count + original_frame_count = thread.GetNumFrames() + + # Import and attach Append provider + script_path = os.path.join(self.getSourceDir(), "test_frame_providers.py") + self.runCmd("command script import " + script_path) + + error = lldb.SBError() + provider_id = target.RegisterScriptedFrameProvider( + "test_frame_providers.AppendFrameProvider", + lldb.SBStructuredData(), + error, + ) + self.assertTrue(error.Success(), f"Failed to register provider: {error}") + self.assertNotEqual(provider_id, 0, "Provider ID should be non-zero") + + # Verify we have 1 more frame + new_frame_count = thread.GetNumFrames() + self.assertEqual(new_frame_count, original_frame_count + 1) + + # Verify first frames are still real + frame0 = thread.GetFrameAtIndex(0) + self.assertIn("thread_func", frame0.GetFunctionName()) + + frame_n_plus_1 = thread.GetFrameAtIndex(new_frame_count - 1) + self.assertEqual(frame_n_plus_1.GetPC(), 0x10) + + def test_scripted_frame_objects(self): + """Test that provider can return ScriptedFrame objects.""" + self.build() + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Break here", lldb.SBFileSpec(self.source), only_one_thread=False + ) + + # Import the provider that returns ScriptedFrame objects + script_path = os.path.join(self.getSourceDir(), "test_frame_providers.py") + self.runCmd("command script import " + script_path) + + error = lldb.SBError() + provider_id = target.RegisterScriptedFrameProvider( + "test_frame_providers.ScriptedFrameObjectProvider", + lldb.SBStructuredData(), + error, + ) + self.assertTrue(error.Success(), f"Failed to register provider: {error}") + self.assertNotEqual(provider_id, 0, "Provider ID should be non-zero") + + # Verify we have 5 frames + self.assertEqual( + thread.GetNumFrames(), 5, "Should have 5 custom scripted frames" + ) + + # Verify frame properties from CustomScriptedFrame + frame0 = thread.GetFrameAtIndex(0) + self.assertIsNotNone(frame0) + self.assertEqual(frame0.GetFunctionName(), "custom_scripted_frame_0") + self.assertEqual(frame0.GetPC(), 0x5000) + self.assertTrue(frame0.IsSynthetic(), "Frame should be marked as synthetic") + + frame1 = thread.GetFrameAtIndex(1) + self.assertIsNotNone(frame1) + self.assertEqual(frame1.GetPC(), 0x6000) + + frame2 = thread.GetFrameAtIndex(2) + self.assertIsNotNone(frame2) + self.assertEqual(frame2.GetFunctionName(), "custom_scripted_frame_2") + self.assertEqual(frame2.GetPC(), 0x7000) + self.assertTrue(frame2.IsSynthetic(), "Frame should be marked as synthetic") + + def test_applies_to_thread(self): + """Test that applies_to_thread filters which threads get the provider.""" + self.build() + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Break here", lldb.SBFileSpec(self.source), only_one_thread=False + ) + + # We should have at least 2 threads (worker threads) at the breakpoint + num_threads = process.GetNumThreads() + self.assertGreaterEqual( + num_threads, 2, "Should have at least 2 threads at breakpoint" + ) + + # Import the test frame provider + script_path = os.path.join(self.getSourceDir(), "test_frame_providers.py") + self.runCmd("command script import " + script_path) + + # Collect original thread info before applying provider + thread_info = {} + for i in range(num_threads): + t = process.GetThreadAtIndex(i) + thread_info[t.GetIndexID()] = { + "frame_count": t.GetNumFrames(), + "pc": t.GetFrameAtIndex(0).GetPC(), + } + + # Register the ThreadFilterFrameProvider which only applies to thread ID 1 + error = lldb.SBError() + provider_id = target.RegisterScriptedFrameProvider( + "test_frame_providers.ThreadFilterFrameProvider", + lldb.SBStructuredData(), + error, + ) + self.assertTrue(error.Success(), f"Failed to register provider: {error}") + self.assertNotEqual(provider_id, 0, "Provider ID should be non-zero") + + # Check each thread + thread_id_1_found = False + for i in range(num_threads): + t = process.GetThreadAtIndex(i) + thread_id = t.GetIndexID() + + if thread_id == 1: + # Thread with ID 1 should have synthetic frame + thread_id_1_found = True + self.assertEqual( + t.GetNumFrames(), + 1, + f"Thread with ID 1 should have 1 synthetic frame", + ) + self.assertEqual( + t.GetFrameAtIndex(0).GetPC(), + 0xFFFF, + f"Thread with ID 1 should have synthetic PC 0xFFFF", + ) + else: + # Other threads should keep their original frames + self.assertEqual( + t.GetNumFrames(), + thread_info[thread_id]["frame_count"], + f"Thread with ID {thread_id} should not be affected by provider", + ) + self.assertEqual( + t.GetFrameAtIndex(0).GetPC(), + thread_info[thread_id]["pc"], + f"Thread with ID {thread_id} should have its original PC", + ) + + # We should have found at least one thread with ID 1 + self.assertTrue( + thread_id_1_found, + "Should have found a thread with ID 1 to test filtering", + ) + + def test_remove_frame_provider_by_id(self): + """Test that RemoveScriptedFrameProvider removes a specific provider by ID.""" + self.build() + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, "Break here", lldb.SBFileSpec(self.source), only_one_thread=False + ) + + # Import the test frame providers + script_path = os.path.join(self.getSourceDir(), "test_frame_providers.py") + self.runCmd("command script import " + script_path) + + # Get original frame count + original_frame_count = thread.GetNumFrames() + original_pc = thread.GetFrameAtIndex(0).GetPC() + + # Register the first provider and get its ID + error = lldb.SBError() + provider_id_1 = target.RegisterScriptedFrameProvider( + "test_frame_providers.ReplaceFrameProvider", + lldb.SBStructuredData(), + error, + ) + self.assertTrue(error.Success(), f"Failed to register provider 1: {error}") + + # Verify first provider is active (3 synthetic frames) + self.assertEqual(thread.GetNumFrames(), 3, "Should have 3 synthetic frames") + self.assertEqual( + thread.GetFrameAtIndex(0).GetPC(), 0x1000, "Should have first provider's PC" + ) + + # Register a second provider and get its ID + provider_id_2 = target.RegisterScriptedFrameProvider( + "test_frame_providers.PrependFrameProvider", + lldb.SBStructuredData(), + error, + ) + self.assertTrue(error.Success(), f"Failed to register provider 2: {error}") + + # Verify IDs are different + self.assertNotEqual( + provider_id_1, provider_id_2, "Provider IDs should be unique" + ) + + # Now remove the first provider by ID + result = target.RemoveScriptedFrameProvider(provider_id_1) + self.assertSuccess( + result, f"Should successfully remove provider with ID {provider_id_1}" + ) + + # After removing the first provider, the second provider should still be active + # The PrependFrameProvider adds 2 frames before the real stack + # Since ReplaceFrameProvider had 3 frames, and we removed it, we should now + # have the original frames (from real stack) with PrependFrameProvider applied + new_frame_count = thread.GetNumFrames() + self.assertEqual( + new_frame_count, + original_frame_count + 2, + "Should have original frames + 2 prepended frames", + ) + + # First two frames should be from PrependFrameProvider + self.assertEqual( + thread.GetFrameAtIndex(0).GetPC(), + 0x9000, + "First frame should be from PrependFrameProvider", + ) + self.assertEqual( + thread.GetFrameAtIndex(1).GetPC(), + 0xA000, + "Second frame should be from PrependFrameProvider", + ) + + # Remove the second provider + result = target.RemoveScriptedFrameProvider(provider_id_2) + self.assertSuccess( + result, f"Should successfully remove provider with ID {provider_id_2}" + ) + + # After removing both providers, frames should be back to original + self.assertEqual( + thread.GetNumFrames(), + original_frame_count, + "Should restore original frame count", + ) + self.assertEqual( + thread.GetFrameAtIndex(0).GetPC(), + original_pc, + "Should restore original PC", + ) + + # Try to remove a provider that doesn't exist + result = target.RemoveScriptedFrameProvider(999999) + self.assertTrue(result.Fail(), "Should fail to remove non-existent provider") diff --git a/lldb/test/API/functionalities/scripted_frame_provider/main.cpp b/lldb/test/API/functionalities/scripted_frame_provider/main.cpp new file mode 100644 index 0000000000000..f15cb282f9d25 --- /dev/null +++ b/lldb/test/API/functionalities/scripted_frame_provider/main.cpp @@ -0,0 +1,55 @@ +// Multi-threaded test program for testing frame providers. + +#include +#include +#include +#include + +std::mutex mtx; +std::condition_variable cv; +int ready_count = 0; +constexpr int NUM_THREADS = 2; + +void thread_func(int thread_num) { + std::cout << "Thread " << thread_num << " started\n"; + + { + std::unique_lock lock(mtx); + ready_count++; + if (ready_count == NUM_THREADS + 1) { + cv.notify_all(); + } else { + cv.wait(lock, [] { return ready_count == NUM_THREADS + 1; }); + } + } + + std::cout << "Thread " << thread_num << " at breakpoint\n"; // Break here +} + +int main(int argc, char **argv) { + std::thread threads[NUM_THREADS]; + + for (int i = 0; i < NUM_THREADS; i++) { + threads[i] = std::thread(thread_func, i); + } + + { + std::unique_lock lock(mtx); + ready_count++; + if (ready_count == NUM_THREADS + 1) { + cv.notify_all(); + } else { + cv.wait(lock, [] { return ready_count == NUM_THREADS + 1; }); + } + } + + std::cout << "Main thread at barrier\n"; + + // Join threads + for (int i = 0; i < NUM_THREADS; i++) { + threads[i].join(); + } + + std::cout << "All threads completed\n"; + return 0; +} diff --git a/lldb/test/API/functionalities/scripted_frame_provider/test_frame_providers.py b/lldb/test/API/functionalities/scripted_frame_provider/test_frame_providers.py new file mode 100644 index 0000000000000..91aa13e44339a --- /dev/null +++ b/lldb/test/API/functionalities/scripted_frame_provider/test_frame_providers.py @@ -0,0 +1,176 @@ +""" +Test frame providers for scripted frame provider functionality. + +These providers demonstrate various merge strategies: +- Replace: Replace entire stack +- Prepend: Add frames before real stack +- Append: Add frames after real stack + +It also shows the ability to mix a dictionary, a ScriptedFrame or an SBFrame +index to create stackframes +""" + +import lldb +from lldb.plugins.scripted_process import ScriptedFrame +from lldb.plugins.scripted_frame_provider import ScriptedFrameProvider + + +class ReplaceFrameProvider(ScriptedFrameProvider): + """Replace entire stack with custom frames.""" + + def __init__(self, input_frames, args): + super().__init__(input_frames, args) + self.frames = [ + { + "idx": 0, + "pc": 0x1000, + }, + 0, + { + "idx": 2, + "pc": 0x3000, + }, + ] + + @staticmethod + def get_description(): + """Return a description of this provider.""" + return "Replace entire stack with 3 custom frames" + + def get_frame_at_index(self, index): + if index >= len(self.frames): + return None + return self.frames[index] + + +class PrependFrameProvider(ScriptedFrameProvider): + """Prepend synthetic frames before real stack.""" + + def __init__(self, input_frames, args): + super().__init__(input_frames, args) + + @staticmethod + def get_description(): + """Return a description of this provider.""" + return "Prepend 2 synthetic frames before real stack" + + def get_frame_at_index(self, index): + if index == 0: + return {"pc": 0x9000} + elif index == 1: + return {"pc": 0xA000} + elif index - 2 < len(self.input_frames): + return index - 2 # Return real frame index + return None + + +class AppendFrameProvider(ScriptedFrameProvider): + """Append synthetic frames after real stack.""" + + def __init__(self, input_frames, args): + super().__init__(input_frames, args) + + @staticmethod + def get_description(): + """Return a description of this provider.""" + return "Append 1 synthetic frame after real stack" + + def get_frame_at_index(self, index): + if index < len(self.input_frames): + return index # Return real frame index + elif index == len(self.input_frames): + return { + "idx": 1, + "pc": 0x10, + } + return None + + +class CustomScriptedFrame(ScriptedFrame): + """Custom scripted frame with full control over frame behavior.""" + + def __init__(self, thread, idx, pc, function_name): + # Initialize structured data args + args = lldb.SBStructuredData() + super().__init__(thread, args) + + self.idx = idx + self.pc = pc + self.function_name = function_name + + def get_id(self): + """Return the frame index.""" + return self.idx + + def get_pc(self): + """Return the program counter.""" + return self.pc + + def get_function_name(self): + """Return the function name.""" + return self.function_name + + def is_artificial(self): + """Mark as artificial frame.""" + return False + + def is_hidden(self): + """Not hidden.""" + return False + + def get_register_context(self): + """No register context for this test.""" + return None + + +class ScriptedFrameObjectProvider(ScriptedFrameProvider): + """Provider that returns ScriptedFrame objects instead of dictionaries.""" + + def __init__(self, input_frames, args): + super().__init__(input_frames, args) + + @staticmethod + def get_description(): + """Return a description of this provider.""" + return "Provider returning custom ScriptedFrame objects" + + def get_frame_at_index(self, index): + """Return ScriptedFrame objects or dictionaries based on index.""" + if index == 0: + return CustomScriptedFrame( + self.thread, 0, 0x5000, "custom_scripted_frame_0" + ) + elif index == 1: + return {"pc": 0x6000} + elif index == 2: + return CustomScriptedFrame( + self.thread, 2, 0x7000, "custom_scripted_frame_2" + ) + elif index == 3: + return len(self.input_frames) - 2 # Real frame index + elif index == 4: + return len(self.input_frames) - 1 # Real frame index + return None + + +class ThreadFilterFrameProvider(ScriptedFrameProvider): + """Provider that only applies to thread with ID 1.""" + + @staticmethod + def applies_to_thread(thread): + """Only apply to thread with index ID 1.""" + return thread.GetIndexID() == 1 + + def __init__(self, input_frames, args): + super().__init__(input_frames, args) + + @staticmethod + def get_description(): + """Return a description of this provider.""" + return "Provider that only applies to thread ID 1" + + def get_frame_at_index(self, index): + """Return a single synthetic frame.""" + if index == 0: + return {"pc": 0xFFFF} + return None diff --git a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp index 06b180be28d80..fd5227cd853f1 100644 --- a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp +++ b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp @@ -135,6 +135,11 @@ lldb_private::python::LLDBSWIGPython_CastPyObjectToSBStream(PyObject *data) { return nullptr; } +void * +lldb_private::python::LLDBSWIGPython_CastPyObjectToSBThread(PyObject *data) { + return nullptr; +} + void * lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrame(PyObject *data) { return nullptr; From 3123a341435dddb8afedb5ca1794ca601a36fc81 Mon Sep 17 00:00:00 2001 From: Med Ismail Bennani Date: Tue, 11 Nov 2025 12:27:06 -0800 Subject: [PATCH 5/5] [lldb] Regenerate python static bindings Signed-off-by: Med Ismail Bennani --- .../python/static-binding/LLDBWrapPython.cpp | 6882 ++++++++++------- lldb/bindings/python/static-binding/lldb.py | 152 +- 2 files changed, 4103 insertions(+), 2931 deletions(-) diff --git a/lldb/bindings/python/static-binding/LLDBWrapPython.cpp b/lldb/bindings/python/static-binding/LLDBWrapPython.cpp index 2b6fdba913a3e..9348e2b002b10 100644 --- a/lldb/bindings/python/static-binding/LLDBWrapPython.cpp +++ b/lldb/bindings/python/static-binding/LLDBWrapPython.cpp @@ -1,13 +1,13 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (https://www.swig.org). - * Version 4.3.1 + * Version 4.4.0 * * Do not make changes to this file unless you know what you are doing - modify * the SWIG interface file instead. * ----------------------------------------------------------------------------- */ -#define SWIG_VERSION 0x040301 +#define SWIG_VERSION 0x040400 #define SWIGPYTHON #define SWIG_PYTHON_THREADS #define SWIG_PYTHON_DIRECTOR_NO_VTABLE @@ -138,9 +138,9 @@ #endif #if defined(__cplusplus) && __cplusplus >=201103L -# define SWIG_NULLPTR nullptr +# define SWIG_NOEXCEPT noexcept #else -# define SWIG_NULLPTR NULL +# define SWIG_NOEXCEPT throw() #endif /* ----------------------------------------------------------------------------- @@ -204,14 +204,6 @@ # include #endif -#if defined(SWIGPYTHON_BUILTIN) && defined(SWIG_HEAPTYPES) -/* SWIG_HEAPTYPES is not ready for use with SWIGPYTHON_BUILTIN, but if turned on manually requires the following */ -#if PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030c0000 -#include -#define Py_READONLY READONLY -#define Py_T_PYSSIZET T_PYSSIZET -#endif -#endif #if __GNUC__ >= 7 #pragma GCC diagnostic pop @@ -229,7 +221,7 @@ /* This should only be incremented when either the layout of swig_type_info changes, or for whatever reason, the runtime changes incompatibly */ -#define SWIG_RUNTIME_VERSION "4" +#define SWIG_RUNTIME_VERSION "5" /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ #ifdef SWIG_TYPE_TABLE @@ -427,8 +419,8 @@ typedef struct swig_type_info { typedef struct swig_cast_info { swig_type_info *type; /* pointer to type that is equivalent to this type */ swig_converter_func converter; /* function to cast the void pointers */ - struct swig_cast_info *next; /* pointer to next cast in linked list */ - struct swig_cast_info *prev; /* pointer to the previous cast */ + struct swig_cast_info *next; /* pointer to next array of casts | pointer to cast hashed by value */ + unsigned int value; /* index of the last valid element in the array | typename hash value */ } swig_cast_info; /* Structure used to store module information @@ -489,55 +481,147 @@ SWIG_TypeEquiv(const char *nb, const char *tb) { return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; } +/* + * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html) + */ +SWIGRUNTIME unsigned int SWIG_Hash(const char *str, unsigned int len) { + const unsigned char *data = (const unsigned char *)str; + unsigned int hash = len, i = 0, k; + int rem = (int)len; + + while (rem >= (int)sizeof(unsigned int)) { + k = *(unsigned int *)data; + k += i++; + hash ^= k; + hash *= 171717; + data += sizeof(unsigned int); + rem -= sizeof(unsigned int); + } + + switch (rem) { + case 3: k = (unsigned int)(data[2]) << 16; + k |= (unsigned int)(data[1]) << 8; + k |= (unsigned int)(data[0]); + k += i++; + hash ^= k; + hash *= 171717; + break; + case 2: k = (unsigned int)(data[1]) << 8; + k |= (unsigned int)(data[0]); + k += i++; + hash ^= k; + hash *= 171717; + break; + case 1: k = (unsigned int)(data[0]); + k += i++; + hash ^= k; + hash *= 171717; + break; + } + return hash; +} + /* Check the typename */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty) { + static const unsigned int scan_threshold = 4; if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (strcmp(iter->type->name, c) == 0) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; + swig_cast_info *head = ty->cast; + unsigned int hash_value = 0; + int hashed = 0; + + while (head) { + + if (strcmp(head->type->name, c) == 0) { + return head; } - iter = iter->next; + + if (head->value) { + swig_cast_info *iter; + swig_cast_info *last = head + head->value; + swig_cast_info *first = head + 1; + int search = 1; + + if (!hashed) { + if (head->value < scan_threshold) { + for (iter = first; iter <= last; iter++) { + if (strcmp(iter->type->name, c) == 0) { + return iter; + } + } + search = 0; + } else { + hashed = 1; + hash_value = SWIG_Hash(c, (unsigned int)strlen(c)); + } + } + + if (search) { + /* Binary search over sorted <'next'|'value'> pairs */ + do { + iter = first + ((last - first) >> 1); + if (iter->value < hash_value) { + first = iter + 1; + } else if (iter->value == hash_value) { + + if (strcmp(iter->next->type->name, c) == 0) { + return iter->next; + } + + /* Hash collision check */ + for (last = iter + 1; last->next && last->value == hash_value; last++) { + if (strcmp(last->next->type->name, c) == 0) { + return last->next; + } + } + for (first = iter - 1; first != head && first->value == hash_value; first--) { + if (strcmp(first->next->type->name, c) == 0) { + return first->next; + } + } + break; + } else + last = iter - 1; + } while (first <= last); + } + } + head = head->next; } } return 0; } /* - Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison + Check the type by type address */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) { if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (iter->type == from) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; + swig_cast_info *head = ty->cast; + while (head) { + if (head->type == from) { + return head; } - iter = iter->next; + + if (head->value) { + swig_cast_info *iter; + swig_cast_info *last = head + head->value; + swig_cast_info *first = head + 1; + + /* Binary search over sorted array of casts */ + do { + iter = first + ((last - first) >> 1); + if (iter->type < from) { + first = iter + 1; + } else if (iter->type == from) { + return iter; + } else + last = iter - 1; + } while (first <= last); + } + head = head->next; } } return 0; @@ -600,20 +684,24 @@ SWIG_TypePrettyName(const swig_type_info *type) { */ SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_cast_info *cast = ti->cast; + swig_cast_info *head = ti->cast; /* if (ti->clientdata == clientdata) return; */ ti->clientdata = clientdata; - while (cast) { - if (!cast->converter) { - swig_type_info *tc = cast->type; - if (!tc->clientdata) { - SWIG_TypeClientData(tc, clientdata); + while (head) { + swig_cast_info *cast; + for (cast = head; (cast - head) <= head->value; cast++) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } } } - cast = cast->next; + head = head->next; } } + SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { SWIG_TypeClientData(ti, clientdata); @@ -818,6 +906,12 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #define SWIG_NullReferenceError -13 +#if PY_VERSION_HEX >= 0x03030000 && !defined(SWIG_NO_HEAPTYPES) +#if !defined(SWIG_HEAPTYPES) +#define SWIG_HEAPTYPES +#endif +#endif + /* Compatibility macros for Python 3 */ #if PY_VERSION_HEX >= 0x03000000 @@ -845,6 +939,16 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { # define SWIG_Python_str_FromFormat PyString_FromFormat #endif +#if defined(SWIG_HEAPTYPES) +#if PY_VERSION_HEX < 0x030c0000 +#include +#define Py_READONLY READONLY +#define Py_T_PYSSIZET T_PYSSIZET +#endif +#endif + +#include /* For offsetof */ + /* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */ SWIGINTERN const char * @@ -870,7 +974,7 @@ SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes #endif } -SWIGINTERN PyObject* +SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c) { #if PY_VERSION_HEX >= 0x03000000 @@ -880,6 +984,8 @@ SWIG_Python_str_FromChar(const char *c) #endif } +#define SWIG_RUNTIME_MODULE "swig_runtime_data" SWIG_RUNTIME_VERSION + /* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */ # define SWIGPY_USE_CAPSULE #ifdef SWIGPYTHON_BUILTIN @@ -887,7 +993,7 @@ SWIG_Python_str_FromChar(const char *c) #else # define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME #endif -# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME) +#define SWIGPY_CAPSULE_NAME SWIG_RUNTIME_MODULE "." SWIGPY_CAPSULE_ATTR_NAME #if PY_VERSION_HEX < 0x03020000 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) @@ -895,7 +1001,7 @@ SWIG_Python_str_FromChar(const char *c) #define Py_hash_t long #endif -#ifdef Py_LIMITED_API +#if defined(Py_LIMITED_API) # define PyTuple_GET_ITEM PyTuple_GetItem /* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */ @@ -922,6 +1028,90 @@ SWIG_Python_str_FromChar(const char *c) # define SWIG_Py_XDECREF Py_XDECREF #endif +#if PY_VERSION_HEX >= 0x03000000 +#if PY_VERSION_HEX < 0x030d00a6 +SWIGINTERN PyObject * +SWIG_PyType_GetFullyQualifiedName(PyTypeObject *type) { + PyObject *result = NULL; + PyObject *qualname = PyObject_GetAttrString((PyObject *)type, "__qualname__"); + if (qualname) { + PyObject *mod = PyObject_GetAttrString((PyObject *)type, "__module__"); + if (mod) { + if (PyUnicode_Check(mod) && PyUnicode_CompareWithASCIIString(mod, "builtins") && PyUnicode_CompareWithASCIIString(mod, "__main__")) { + result = PyUnicode_FromFormat("%U%c%U", mod, '.', qualname); + SWIG_Py_DECREF(qualname); + } else { + result = qualname; + } + SWIG_Py_DECREF(mod); + } else { + result = qualname; + } + } + + return result; +} +#else +# define SWIG_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#endif +#endif + +/* gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 */ +#if PY_VERSION_HEX < 0x030d00a4 +SWIGINTERN PyObject * +SWIG_PyList_GetItemRef(PyObject *op, Py_ssize_t index) { + PyObject *item = PyList_GetItem(op, index); + Py_XINCREF(item); + return item; +} +#else +# define SWIG_PyList_GetItemRef PyList_GetItemRef +#endif + +/* gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef() to Python 3.13.0a1 + functions are renamed here for compatibility with abi3audit */ +#if PY_VERSION_HEX < 0x030d00a1 +SWIGINTERN int +SWIG_PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *item = PyDict_GetItemWithError(mp, key); +#else + PyObject *item = _PyDict_GetItemWithError(mp, key); +#endif + if (item != NULL) { + *result = (PyObject *)(item); + SWIG_Py_INCREF(*result); + return 1; + } + if (!PyErr_Occurred()) { + *result = NULL; + return 0; + } + *result = NULL; + return -1; +} + +SWIGINTERN int +SWIG_PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) { + int res; +#if PY_VERSION_HEX >= 0x03000000 + PyObject *key_obj = PyUnicode_FromString(key); +#else + PyObject *key_obj = PyString_FromString(key); +#endif + if (key_obj == NULL) { + *result = NULL; + return -1; + } + res = SWIG_PyDict_GetItemRef(mp, key_obj, result); + Py_DECREF(key_obj); + return res; +} +#else +# define SWIG_PyDict_GetItemRef PyDict_GetItemRef +# define SWIG_PyDict_GetItemStringRef PyDict_GetItemStringRef +#endif + /* ----------------------------------------------------------------------------- * error manipulation * ----------------------------------------------------------------------------- */ @@ -1148,8 +1338,8 @@ typedef struct swig_const_info { # error "This version of SWIG only supports Python >= 2.7" #endif -#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000 -# error "This version of SWIG only supports Python 3 >= 3.3" +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03050000 +# error "This version of SWIG only supports Python 3 >= 3.5" #endif /* Common SWIG API */ @@ -1200,7 +1390,6 @@ typedef struct swig_const_info { #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) #define SWIG_fail goto fail - /* Runtime API implementation */ /* Error manipulation */ @@ -1251,8 +1440,31 @@ SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { #endif -/* Append a value to the result obj */ +/* SWIG runtime data Python module */ +static PyObject *Swig_runtime_data_module_global = NULL; +/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */ +SWIGINTERN PyObject * +SWIG_runtime_data_module(void) { + if (!Swig_runtime_data_module_global) { +#if PY_VERSION_HEX >= 0x030d0000 + /* free-threading note: the GIL is always enabled when this function is first called + by SWIG_init, so there's no risk of race conditions */ + Swig_runtime_data_module_global = PyImport_AddModuleRef(SWIG_RUNTIME_MODULE); +#elif PY_VERSION_HEX >= 0x03000000 + Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE); + SWIG_Py_XINCREF(Swig_runtime_data_module_global); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + Swig_runtime_data_module_global = Py_InitModule(SWIG_RUNTIME_MODULE, swig_empty_runtime_method_table); + SWIG_Py_XINCREF(Swig_runtime_data_module_global); +#endif + } + assert(Swig_runtime_data_module_global); + return Swig_runtime_data_module_global; +} + +/* Append a value to the result obj */ SWIGINTERN PyObject* SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) { if (!result) { @@ -1377,7 +1589,7 @@ typedef struct swig_varlinkobject { } swig_varlinkobject; SWIGINTERN PyObject * -swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) { +SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) { #if PY_VERSION_HEX >= 0x03000000 return PyUnicode_InternFromString(""); #else @@ -1386,7 +1598,7 @@ swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) { } SWIGINTERN PyObject * -swig_varlink_str(PyObject *o) { +SwigVarLink_str(PyObject *o) { swig_varlinkobject *v = (swig_varlinkobject *) o; #if PY_VERSION_HEX >= 0x03000000 PyObject *str = PyUnicode_InternFromString("("); @@ -1425,7 +1637,7 @@ swig_varlink_str(PyObject *o) { } SWIGINTERN void -swig_varlink_dealloc(PyObject *o) { +SwigVarLink_dealloc(PyObject *o) { swig_varlinkobject *v = (swig_varlinkobject *) o; swig_globalvar *var = v->vars; while (var) { @@ -1437,7 +1649,7 @@ swig_varlink_dealloc(PyObject *o) { } SWIGINTERN PyObject * -swig_varlink_getattr(PyObject *o, char *n) { +SwigVarLink_getattr(PyObject *o, char *n) { swig_varlinkobject *v = (swig_varlinkobject *) o; PyObject *res = NULL; swig_globalvar *var = v->vars; @@ -1455,7 +1667,7 @@ swig_varlink_getattr(PyObject *o, char *n) { } SWIGINTERN int -swig_varlink_setattr(PyObject *o, char *n, PyObject *p) { +SwigVarLink_setattr(PyObject *o, char *n, PyObject *p) { swig_varlinkobject *v = (swig_varlinkobject *) o; int res = 1; swig_globalvar *var = v->vars; @@ -1472,13 +1684,9 @@ swig_varlink_setattr(PyObject *o, char *n, PyObject *p) { return res; } -#if !defined(SWIGPYTHON_BUILTIN) && PY_VERSION_HEX >= 0x03030000 -#define SWIG_HEAPTYPES -#endif - SWIGINTERN PyTypeObject* -swig_varlink_type(void) { - static char varlink__doc__[] = "Swig var link object"; +SwigVarLink_TypeOnce(void) { + static char SwigVarLink_doc[] = "Swig variable link object"; #ifndef SWIG_HEAPTYPES static PyTypeObject varlink_type; static int type_init = 0; @@ -1490,30 +1698,30 @@ swig_varlink_type(void) { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif - "swigvarlink", /* tp_name */ + SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */ sizeof(swig_varlinkobject), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor) swig_varlink_dealloc, /* tp_dealloc */ + (destructor) SwigVarLink_dealloc, /* tp_dealloc */ #if PY_VERSION_HEX < 0x030800b4 (printfunc)0, /* tp_print */ #else (Py_ssize_t)0, /* tp_vectorcall_offset */ #endif - (getattrfunc) swig_varlink_getattr, /* tp_getattr */ - (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + (getattrfunc) SwigVarLink_getattr, /* tp_getattr */ + (setattrfunc) SwigVarLink_setattr, /* tp_setattr */ 0, /* tp_compare */ - (reprfunc) swig_varlink_repr, /* tp_repr */ + (reprfunc) SwigVarLink_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ - (reprfunc) swig_varlink_str, /* tp_str */ + (reprfunc) SwigVarLink_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ 0, /* tp_flags */ - varlink__doc__, /* tp_doc */ + SwigVarLink_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -1544,37 +1752,50 @@ swig_varlink_type(void) { 0 /* tp_next */ #endif }; + PyObject *runtime_data_module = SWIG_runtime_data_module(); varlink_type = tmp; type_init = 1; if (PyType_Ready(&varlink_type) < 0) return NULL; + if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0) + SWIG_Py_INCREF((PyObject *)&varlink_type); } return &varlink_type; #else PyType_Slot slots[] = { - { Py_tp_dealloc, (void *)swig_varlink_dealloc }, - { Py_tp_repr, (void *)swig_varlink_repr }, - { Py_tp_getattr, (void *)swig_varlink_getattr }, - { Py_tp_setattr, (void *)swig_varlink_setattr }, - { Py_tp_str, (void *)swig_varlink_str }, - { Py_tp_doc, (void *)varlink__doc__ }, + { Py_tp_dealloc, (void *)SwigVarLink_dealloc }, + { Py_tp_repr, (void *)SwigVarLink_repr }, + { Py_tp_getattr, (void *)SwigVarLink_getattr }, + { Py_tp_setattr, (void *)SwigVarLink_setattr }, + { Py_tp_str, (void *)SwigVarLink_str }, + { Py_tp_doc, (void *)SwigVarLink_doc }, { 0, NULL } }; PyType_Spec spec = { - "swigvarlink", + SWIG_RUNTIME_MODULE ".SwigVarLink", sizeof(swig_varlinkobject), 0, Py_TPFLAGS_DEFAULT, slots }; - return (PyTypeObject *)PyType_FromSpec(&spec); + PyObject *pytype = PyType_FromSpec(&spec); + PyObject *runtime_data_module = SWIG_runtime_data_module(); + if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0) + SWIG_Py_INCREF(pytype); + return (PyTypeObject *)pytype; #endif } +SWIGRUNTIME PyTypeObject* +SwigVarLink_Type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigVarLink_TypeOnce(); + return type; +} + /* Create a variable linking object for use later */ SWIGINTERN PyObject * SWIG_Python_newvarlink(void) { - swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type()); + swig_varlinkobject *result = PyObject_New(swig_varlinkobject, SwigVarLink_Type()); if (result) { result->vars = 0; } @@ -1738,9 +1959,8 @@ typedef struct { swig_type_info *ty; int own; PyObject *next; -#ifdef SWIGPYTHON_BUILTIN - PyObject *dict; -#endif + PyObject *swigdict; + PyObject *weakreflist; } SwigPyObject; @@ -1751,11 +1971,11 @@ SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) { SwigPyObject *sobj = (SwigPyObject *)v; - if (!sobj->dict) - sobj->dict = PyDict_New(); + if (!sobj->swigdict) + sobj->swigdict = PyDict_New(); - SWIG_Py_XINCREF(sobj->dict); - return sobj->dict; + SWIG_Py_XINCREF(sobj->swigdict); + return sobj->swigdict; } #endif @@ -1828,7 +2048,7 @@ SwigPyObject_repr(SwigPyObject *v) } /* We need a version taking two PyObject* parameters so it's a valid - * PyCFunction to use in swigobject_methods[]. */ + * PyCFunction to use in SwigPyObject_methods[]. */ SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) { @@ -1836,26 +2056,33 @@ SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) } SWIGRUNTIME int -SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +SwigPyObject_compare(PyObject *v, PyObject *w) { - void *i = v->ptr; - void *j = w->ptr; + /* tp_compare is only called when both objects have the same type, so + * the casts are guaranteed to be ok. */ + void *i = ((SwigPyObject *)v)->ptr; + void *j = ((SwigPyObject *)w)->ptr; return (i < j) ? -1 : ((i > j) ? 1 : 0); } +SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *); + /* Added for Python 3.x, would it also be useful for Python 2.x? */ SWIGRUNTIME PyObject* -SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +SwigPyObject_richcompare(PyObject *v, PyObject *w, int op) { PyObject* res = NULL; if (!PyErr_Occurred()) { - if (op != Py_EQ && op != Py_NE) { + /* Per https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_richcompare + * the first argument is guaranteed to be an instance of SwigPyObject, but the + * second is not, so we typecheck that one. */ + if ((op != Py_EQ && op != Py_NE) || !SwigPyObject_Check(w)) { SWIG_Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); } - return res; + return res; } @@ -1864,7 +2091,7 @@ SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); #ifdef SWIGPYTHON_BUILTIN static swig_type_info *SwigPyObject_stype = 0; SWIGRUNTIME PyTypeObject* -SwigPyObject_type(void) { +SwigPyObject_Type(void) { SwigPyClientData *cd; assert(SwigPyObject_stype); cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; @@ -1874,7 +2101,7 @@ SwigPyObject_type(void) { } #else SWIGRUNTIME PyTypeObject* -SwigPyObject_type(void) { +SwigPyObject_Type(void) { static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); return type; } @@ -1882,29 +2109,29 @@ SwigPyObject_type(void) { SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op) { - PyTypeObject *target_tp = SwigPyObject_type(); + PyTypeObject *target_tp = SwigPyObject_Type(); PyTypeObject *op_type = Py_TYPE(op); #ifdef SWIGPYTHON_BUILTIN - if (PyType_IsSubtype(op_type, target_tp)) + /* Only builtin types have SwigPyObject as a base type */ + return PyType_IsSubtype(op_type, target_tp); +#else + /* Check for an exact match to SwigPyObject */ + if (op_type == target_tp) { return 1; - return (strcmp(op_type->tp_name, "SwigPyObject") == 0); + } else { + /* Fallback for multiple modules */ +#if PY_VERSION_HEX >= 0x03000000 + int cmp; + PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type); + if (!tpname) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyObject"); + SWIG_Py_DECREF(tpname); + return cmp == 0; #else -# ifdef Py_LIMITED_API - int cmp; - PyObject *tp_name; + return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyObject") == 0; #endif - if (op_type == target_tp) - return 1; -# ifdef Py_LIMITED_API - tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); - if (!tp_name) - return 0; - cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject"); - SWIG_Py_DECREF(tp_name); - return cmp == 0; -# else - return (strcmp(op_type->tp_name, "SwigPyObject") == 0); -# endif + } #endif } @@ -1966,9 +2193,7 @@ SwigPyObject_dealloc(PyObject *v) SWIG_Py_XDECREF(Swig_Capsule_global); } SWIG_Py_XDECREF(next); -#ifdef SWIGPYTHON_BUILTIN - SWIG_Py_XDECREF(sobj->dict); -#endif + SWIG_Py_XDECREF(sobj->swigdict); PyObject_Free(v); } @@ -2035,7 +2260,7 @@ SwigPyObject_own(PyObject *v, PyObject *args) } static PyMethodDef -swigobject_methods[] = { +SwigPyObject_methods[] = { {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"}, {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"}, {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"}, @@ -2047,7 +2272,7 @@ swigobject_methods[] = { SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void) { - static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + static char SwigPyObject_doc[] = "Swig object holding a C/C++ pointer"; #ifndef SWIG_HEAPTYPES static PyNumberMethods SwigPyObject_as_number = { (binaryfunc)0, /*nb_add*/ @@ -2103,7 +2328,7 @@ SwigPyObject_TypeOnce(void) { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif - "SwigPyObject", /* tp_name */ + SWIG_RUNTIME_MODULE ".SwigPyObject", /* tp_name */ sizeof(SwigPyObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyObject_dealloc, /* tp_dealloc */ @@ -2130,14 +2355,14 @@ SwigPyObject_TypeOnce(void) { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ - swigobject_doc, /* tp_doc */ + SwigPyObject_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ - 0, /* tp_weaklistoffset */ + offsetof(SwigPyObject, weakreflist), /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ - swigobject_methods, /* tp_methods */ + SwigPyObject_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ @@ -2180,46 +2405,69 @@ SwigPyObject_TypeOnce(void) { 0 /* tp_next */ #endif }; + PyObject *runtime_data_module = SWIG_runtime_data_module(); swigpyobject_type = tmp; type_init = 1; if (PyType_Ready(&swigpyobject_type) != 0) return NULL; + if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0) + SWIG_Py_INCREF((PyObject *)&swigpyobject_type); } return &swigpyobject_type; #else + static PyMemberDef SwigPyObject_members[] = { + { (char *)"__dictoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, swigdict), Py_READONLY, NULL }, + { (char *)"__weaklistoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, weakreflist), Py_READONLY, NULL }, + { NULL, 0, 0, 0, NULL } + }; PyType_Slot slots[] = { { Py_tp_dealloc, (void *)SwigPyObject_dealloc }, { Py_tp_repr, (void *)SwigPyObject_repr }, { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, - { Py_tp_doc, (void *)swigobject_doc }, + { Py_tp_doc, (void *)SwigPyObject_doc }, { Py_tp_richcompare, (void *)SwigPyObject_richcompare }, - { Py_tp_methods, (void *)swigobject_methods }, + { Py_tp_methods, (void *)SwigPyObject_methods }, { Py_nb_int, (void *)SwigPyObject_long }, + { Py_tp_members, (void *)SwigPyObject_members }, { 0, NULL } }; PyType_Spec spec = { - "SwigPyObject", + SWIG_RUNTIME_MODULE ".SwigPyObject", sizeof(SwigPyObject), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, slots }; - return (PyTypeObject *)PyType_FromSpec(&spec); + PyObject *pytype = PyType_FromSpec(&spec); + PyObject *runtime_data_module = SWIG_runtime_data_module(); +#if !defined(Py_LIMITED_API) +/* While this __dictoffset__ is only used with the builtin wrappers, SwigPyObject ought to be + identical when created for use by proxy class wrappers in case it is shared across multiple modules. */ +#if PY_VERSION_HEX < 0x03090000 + /* Workaround as __dictoffset__ and __weaklistoffset__ above are only supported from python-3.9 */ + if (pytype) { + ((PyTypeObject *)pytype)->tp_dictoffset = offsetof(SwigPyObject, swigdict); + ((PyTypeObject *)pytype)->tp_weaklistoffset = offsetof(SwigPyObject, weakreflist); + } +#endif +#endif + if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0) + SWIG_Py_INCREF(pytype); + return (PyTypeObject *)pytype; #endif } SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own) { - SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type()); + SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_Type()); if (sobj) { sobj->ptr = ptr; sobj->ty = ty; sobj->own = own; sobj->next = 0; -#ifdef SWIGPYTHON_BUILTIN - sobj->dict = 0; -#endif + sobj->swigdict = 0; + sobj->weakreflist = 0; if (own == SWIG_POINTER_OWN) { /* Obtain a reference to the Python capsule wrapping the module information, so that the * module information is correctly destroyed after all SWIG python objects have been freed @@ -2275,30 +2523,32 @@ SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); SWIGRUNTIME PyTypeObject* -SwigPyPacked_type(void) { +SwigPyPacked_Type(void) { static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); return type; } SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op) { -#ifdef Py_LIMITED_API - int cmp; - PyObject *tp_name; -#endif - PyTypeObject* op_type = Py_TYPE(op); - if (op_type == SwigPyPacked_TypeOnce()) + PyTypeObject *target_tp = SwigPyPacked_Type(); + PyTypeObject *op_type = Py_TYPE(op); + /* Check for an exact match to SwigPyPacked */ + if (op_type == target_tp) { return 1; -#ifdef Py_LIMITED_API - tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); - if (!tp_name) - return 0; - cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked"); - SWIG_Py_DECREF(tp_name); - return cmp == 0; + } else { + /* Fallback for multiple modules */ +#if PY_VERSION_HEX >= 0x03000000 + int cmp; + PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type); + if (!tpname) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyPacked"); + SWIG_Py_DECREF(tpname); + return cmp == 0; #else - return (strcmp(op_type->tp_name, "SwigPyPacked") == 0); + return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyPacked") == 0; #endif + } } SWIGRUNTIME void @@ -2313,19 +2563,19 @@ SwigPyPacked_dealloc(PyObject *v) SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void) { - static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static char SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer"; #ifndef SWIG_HEAPTYPES static PyTypeObject swigpypacked_type; static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { -#if PY_VERSION_HEX>=0x03000000 +#if PY_VERSION_HEX >= 0x03000000 PyVarObject_HEAD_INIT(NULL, 0) #else PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif - "SwigPyPacked", /* tp_name */ + SWIG_RUNTIME_MODULE ".SwigPyPacked", /* tp_name */ sizeof(SwigPyPacked), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ @@ -2336,7 +2586,7 @@ SwigPyPacked_TypeOnce(void) { #endif (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ -#if PY_VERSION_HEX>=0x03000000 +#if PY_VERSION_HEX >= 0x03000000 0, /* tp_reserved in 3.0.1 */ #else (cmpfunc)SwigPyPacked_compare, /* tp_compare */ @@ -2352,7 +2602,7 @@ SwigPyPacked_TypeOnce(void) { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ - swigpacked_doc, /* tp_doc */ + SwigPyPacked_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -2402,10 +2652,13 @@ SwigPyPacked_TypeOnce(void) { 0 /* tp_next */ #endif }; + PyObject *runtime_data_module = SWIG_runtime_data_module(); swigpypacked_type = tmp; type_init = 1; if (PyType_Ready(&swigpypacked_type) != 0) return NULL; + if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0) + SWIG_Py_INCREF((PyObject *)&swigpypacked_type); } return &swigpypacked_type; #else @@ -2414,24 +2667,28 @@ SwigPyPacked_TypeOnce(void) { { Py_tp_repr, (void *)SwigPyPacked_repr }, { Py_tp_str, (void *)SwigPyPacked_str }, { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, - { Py_tp_doc, (void *)swigpacked_doc }, + { Py_tp_doc, (void *)SwigPyPacked_doc }, { 0, NULL } }; PyType_Spec spec = { - "SwigPyPacked", + SWIG_RUNTIME_MODULE ".SwigPyPacked", sizeof(SwigPyPacked), 0, Py_TPFLAGS_DEFAULT, slots }; - return (PyTypeObject *)PyType_FromSpec(&spec); + PyObject *pytype = PyType_FromSpec(&spec); + PyObject *runtime_data_module = SWIG_runtime_data_module(); + if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0) + SWIG_Py_INCREF(pytype); + return (PyTypeObject *)pytype; #endif } SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) { - SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type()); + SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_Type()); if (sobj) { void *pack = malloc(size); if (pack) { @@ -2477,10 +2734,11 @@ SWIG_This(void) /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ /* TODO: I don't know how to implement the fast getset in Python 3 right now */ -#if PY_VERSION_HEX>=0x03000000 +#if PY_VERSION_HEX >= 0x03000000 #define SWIG_PYTHON_SLOW_GETSET_THIS #endif +/* Returns a borrowed reference to the 'this' object */ SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj) { @@ -2491,18 +2749,18 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) #ifdef SWIGPYTHON_BUILTIN (void)obj; -# ifdef PyWeakref_CheckProxy if (PyWeakref_CheckProxy(pyobj)) { #if PY_VERSION_HEX >= 0x030d0000 - PyWeakref_GetRef(pyobj, &pyobj); - Py_DECREF(pyobj); + if (PyWeakref_GetRef(pyobj, &pyobj) > 0) + Py_DECREF(pyobj); + else + pyobj = NULL; #else - pyobj = PyWeakref_GET_OBJECT(pyobj); + pyobj = PyWeakref_GetObject(pyobj); #endif if (pyobj && SwigPyObject_Check(pyobj)) return (SwigPyObject*) pyobj; } -# endif return NULL; #else @@ -2517,13 +2775,11 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) PyObject *dict = *dictptr; obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; } else { -#ifdef PyWeakref_CheckProxy if (PyWeakref_CheckProxy(pyobj)) { - PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; } -#endif - obj = PyObject_GetAttr(pyobj,SWIG_This()); + obj = PyObject_GetAttr(pyobj, SWIG_This()); if (obj) { SWIG_Py_DECREF(obj); } else { @@ -2533,7 +2789,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) } } #else - obj = PyObject_GetAttr(pyobj,SWIG_This()); + obj = PyObject_GetAttr(pyobj, SWIG_This()); if (obj) { SWIG_Py_DECREF(obj); } else { @@ -2874,17 +3130,15 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f newobj = (SwigPyObject *) newobj->next; newobj->next = next_self; newobj = (SwigPyObject *)next_self; -#ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; -#endif + newobj->swigdict = 0; + newobj->weakreflist = 0; } } else { newobj = PyObject_New(SwigPyObject, clientdata->pytype); -#ifdef SWIGPYTHON_BUILTIN if (newobj) { - newobj->dict = 0; + newobj->swigdict = 0; + newobj->weakreflist = 0; } -#endif } if (newobj) { newobj->ptr = ptr; @@ -2952,6 +3206,12 @@ SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { } +#if defined(SWIG_REFCNT_DEBUG) +#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0)) +#else +#define SWIG_PYOBJ_REFCNT(OBJ) +#endif + static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */ SWIGRUNTIME void @@ -2962,7 +3222,7 @@ SWIG_Python_DestroyModule(PyObject *obj) size_t i; if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */ return; - for (i =0; i < swig_module->size; ++i) { + for (i = 0; i < swig_module->size; ++i) { swig_type_info *ty = types[i]; if (ty->owndata) { SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; @@ -2970,27 +3230,32 @@ SWIG_Python_DestroyModule(PyObject *obj) if (data) SwigPyClientData_Del(data); } } - SWIG_Py_DECREF(SWIG_This()); + SWIG_PYOBJ_REFCNT(Swig_This_global); + SWIG_Py_XDECREF(Swig_This_global); Swig_This_global = NULL; - SWIG_Py_DECREF(SWIG_globals()); + + SWIG_PYOBJ_REFCNT(Swig_Globals_global); + SWIG_Py_XDECREF(Swig_Globals_global); Swig_Globals_global = NULL; - SWIG_Py_DECREF(SWIG_Python_TypeCache()); + + SWIG_PYOBJ_REFCNT(Swig_TypeCache_global); + SWIG_Py_XDECREF(Swig_TypeCache_global); Swig_TypeCache_global = NULL; + + SWIG_PYOBJ_REFCNT(Swig_Capsule_global); Swig_Capsule_global = NULL; + + SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global); + SWIG_Py_XDECREF(Swig_runtime_data_module_global); + Swig_runtime_data_module_global = NULL; } SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module) { -#if PY_VERSION_HEX >= 0x03000000 - /* Add a dummy module object into sys.modules */ - PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION); -#else - static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ - PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); -#endif + PyObject *runtime_data_module = SWIG_runtime_data_module(); PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); - if (pointer && module) { - if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) { + if (pointer && runtime_data_module) { + if (PyModule_AddObject(runtime_data_module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) { ++interpreter_counter; Swig_Capsule_global = pointer; } else { @@ -3004,10 +3269,10 @@ SWIG_Python_SetModule(swig_module_info *swig_module) { SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type) { - PyObject *cache = SWIG_Python_TypeCache(); - PyObject *key = SWIG_Python_str_FromChar(type); - PyObject *obj = PyDict_GetItem(cache, key); swig_type_info *descriptor; + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *obj; + SWIG_PyDict_GetItemStringRef(cache, type, &obj); if (obj) { descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); } else { @@ -3015,13 +3280,10 @@ SWIG_Python_TypeQuery(const char *type) descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); if (descriptor) { obj = PyCapsule_New((void*) descriptor, NULL, NULL); - if (obj) { - PyDict_SetItem(cache, key, obj); - SWIG_Py_DECREF(obj); - } + if (obj) PyDict_SetItemString(cache, type, obj); } } - SWIG_Py_DECREF(key); + SWIG_Py_XDECREF(obj); return descriptor; } @@ -3082,49 +3344,6 @@ SwigPyObject_GetDesc(PyObject *self) return ty ? ty->str : ""; } -SWIGRUNTIME void -SWIG_Python_TypeError(const char *type, PyObject *obj) -{ - (void) obj; - if (type) { -#if defined(SWIG_COBJECT_TYPES) - if (obj && SwigPyObject_Check(obj)) { - const char *otype = (const char *) SwigPyObject_GetDesc(obj); - if (otype) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", - type, otype); - return; - } - } else -#endif - { -#ifndef Py_LIMITED_API - /* tp_name is not accessible */ - const char *otype = (obj ? obj->ob_type->tp_name : 0); - if (otype) { - PyObject *str = PyObject_Str(obj); - PyObject *bytes = NULL; - const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0; - if (cstr) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", - type, otype, cstr); - } else { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", - type, otype); - } - SWIG_Py_XDECREF(bytes); - SWIG_Py_XDECREF(str); - return; - } -#endif - } - PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); - } else { - PyErr_Format(PyExc_TypeError, "unexpected type is received"); - } -} - - /* Convert a pointer value, signal an exception on a type mismatch */ SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { @@ -3138,7 +3357,7 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(arg #ifdef SWIGPYTHON_BUILTIN SWIGRUNTIME int SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { - PyTypeObject *tp = obj->ob_type; + PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; PyObject *encoded_name; descrsetfunc f; @@ -3154,7 +3373,13 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { if (!PyString_Check(name)) # endif { - PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); +#if PY_VERSION_HEX >= 0x03000000 + PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(Py_TYPE(name)); + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%S'", tpname); + SWIG_Py_DECREF(tpname); +#else + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%s'", Py_TYPE(name)->tp_name); +#endif return -1; } else { SWIG_Py_INCREF(name); @@ -3168,7 +3393,7 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { descr = _PyType_Lookup(tp, name); f = NULL; if (descr != NULL) - f = descr->ob_type->tp_descr_set; + f = Py_TYPE(descr)->tp_descr_set; if (!f) { if (PyString_Check(name)) { encoded_name = name; @@ -3178,7 +3403,15 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { if (!encoded_name) goto done; } - PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); +#if PY_VERSION_HEX >= 0x03000000 + { + PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, "'%S' object has no attribute '%s'", tpname, PyString_AsString(encoded_name)); + SWIG_Py_DECREF(tpname); + } +#else + PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", tp->tp_name, PyString_AsString(encoded_name)); +#endif SWIG_Py_DECREF(encoded_name); } else { res = f(descr, obj, value); @@ -3240,233 +3473,236 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #define SWIGTYPE_p_lldb__SBFileSpecList swig_types[32] #define SWIGTYPE_p_lldb__SBFormat swig_types[33] #define SWIGTYPE_p_lldb__SBFrame swig_types[34] -#define SWIGTYPE_p_lldb__SBFunction swig_types[35] -#define SWIGTYPE_p_lldb__SBHostOS swig_types[36] -#define SWIGTYPE_p_lldb__SBInstruction swig_types[37] -#define SWIGTYPE_p_lldb__SBInstructionList swig_types[38] -#define SWIGTYPE_p_lldb__SBLanguageRuntime swig_types[39] -#define SWIGTYPE_p_lldb__SBLaunchInfo swig_types[40] -#define SWIGTYPE_p_lldb__SBLineEntry swig_types[41] -#define SWIGTYPE_p_lldb__SBListener swig_types[42] -#define SWIGTYPE_p_lldb__SBMemoryRegionInfo swig_types[43] -#define SWIGTYPE_p_lldb__SBMemoryRegionInfoList swig_types[44] -#define SWIGTYPE_p_lldb__SBModule swig_types[45] -#define SWIGTYPE_p_lldb__SBModuleSpec swig_types[46] -#define SWIGTYPE_p_lldb__SBModuleSpecList swig_types[47] -#define SWIGTYPE_p_lldb__SBMutex swig_types[48] -#define SWIGTYPE_p_lldb__SBPlatform swig_types[49] -#define SWIGTYPE_p_lldb__SBPlatformConnectOptions swig_types[50] -#define SWIGTYPE_p_lldb__SBPlatformShellCommand swig_types[51] -#define SWIGTYPE_p_lldb__SBProcess swig_types[52] -#define SWIGTYPE_p_lldb__SBProcessInfo swig_types[53] -#define SWIGTYPE_p_lldb__SBProcessInfoList swig_types[54] -#define SWIGTYPE_p_lldb__SBProgress swig_types[55] -#define SWIGTYPE_p_lldb__SBQueue swig_types[56] -#define SWIGTYPE_p_lldb__SBQueueItem swig_types[57] -#define SWIGTYPE_p_lldb__SBReproducer swig_types[58] -#define SWIGTYPE_p_lldb__SBSaveCoreOptions swig_types[59] -#define SWIGTYPE_p_lldb__SBScriptObject swig_types[60] -#define SWIGTYPE_p_lldb__SBSection swig_types[61] -#define SWIGTYPE_p_lldb__SBSourceManager swig_types[62] -#define SWIGTYPE_p_lldb__SBStatisticsOptions swig_types[63] -#define SWIGTYPE_p_lldb__SBStream swig_types[64] -#define SWIGTYPE_p_lldb__SBStringList swig_types[65] -#define SWIGTYPE_p_lldb__SBStructuredData swig_types[66] -#define SWIGTYPE_p_lldb__SBSymbol swig_types[67] -#define SWIGTYPE_p_lldb__SBSymbolContext swig_types[68] -#define SWIGTYPE_p_lldb__SBSymbolContextList swig_types[69] -#define SWIGTYPE_p_lldb__SBTarget swig_types[70] -#define SWIGTYPE_p_lldb__SBThread swig_types[71] -#define SWIGTYPE_p_lldb__SBThreadCollection swig_types[72] -#define SWIGTYPE_p_lldb__SBThreadPlan swig_types[73] -#define SWIGTYPE_p_lldb__SBTrace swig_types[74] -#define SWIGTYPE_p_lldb__SBTraceCursor swig_types[75] -#define SWIGTYPE_p_lldb__SBType swig_types[76] -#define SWIGTYPE_p_lldb__SBTypeCategory swig_types[77] -#define SWIGTYPE_p_lldb__SBTypeEnumMember swig_types[78] -#define SWIGTYPE_p_lldb__SBTypeEnumMemberList swig_types[79] -#define SWIGTYPE_p_lldb__SBTypeFilter swig_types[80] -#define SWIGTYPE_p_lldb__SBTypeFormat swig_types[81] -#define SWIGTYPE_p_lldb__SBTypeList swig_types[82] -#define SWIGTYPE_p_lldb__SBTypeMember swig_types[83] -#define SWIGTYPE_p_lldb__SBTypeMemberFunction swig_types[84] -#define SWIGTYPE_p_lldb__SBTypeNameSpecifier swig_types[85] -#define SWIGTYPE_p_lldb__SBTypeStaticField swig_types[86] -#define SWIGTYPE_p_lldb__SBTypeSummary swig_types[87] -#define SWIGTYPE_p_lldb__SBTypeSummaryOptions swig_types[88] -#define SWIGTYPE_p_lldb__SBTypeSynthetic swig_types[89] -#define SWIGTYPE_p_lldb__SBUnixSignals swig_types[90] -#define SWIGTYPE_p_lldb__SBValue swig_types[91] -#define SWIGTYPE_p_lldb__SBValueList swig_types[92] -#define SWIGTYPE_p_lldb__SBVariablesOptions swig_types[93] -#define SWIGTYPE_p_lldb__SBWatchpoint swig_types[94] -#define SWIGTYPE_p_lldb__SBWatchpointOptions swig_types[95] -#define SWIGTYPE_p_long_double swig_types[96] -#define SWIGTYPE_p_long_long swig_types[97] -#define SWIGTYPE_p_p_void swig_types[98] -#define SWIGTYPE_p_pthread_rwlock_t swig_types[99] -#define SWIGTYPE_p_pthread_t swig_types[100] -#define SWIGTYPE_p_short swig_types[101] -#define SWIGTYPE_p_signed_char swig_types[102] -#define SWIGTYPE_p_size_t swig_types[103] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ABI_t swig_types[104] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Baton_t swig_types[105] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Block_t swig_types[106] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointLocation_t swig_types[107] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t swig_types[108] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointResolver_t swig_types[109] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointSite_t swig_types[110] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Breakpoint_t swig_types[111] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BroadcasterManager_t swig_types[112] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Broadcaster_t swig_types[113] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CommandObject_t swig_types[114] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CompileUnit_t swig_types[115] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Connection_t swig_types[116] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataBuffer_t swig_types[117] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataExtractor_t swig_types[118] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Debugger_t swig_types[119] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Disassembler_t swig_types[120] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t swig_types[121] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventData_t swig_types[122] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t swig_types[123] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t swig_types[124] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExpressionVariable_t swig_types[125] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__File_t swig_types[126] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t swig_types[127] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__FuncUnwinders_t swig_types[128] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Function_t swig_types[129] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOHandler_t swig_types[130] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOObject_t swig_types[131] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t swig_types[132] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t swig_types[133] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Instruction_t swig_types[134] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t swig_types[135] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__JITLoader_t swig_types[136] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__LanguageRuntime_t swig_types[137] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Listener_t swig_types[138] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__LockableStreamFile_t swig_types[139] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryHistory_t swig_types[140] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t swig_types[141] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Module_t swig_types[142] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectContainer_t swig_types[143] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[144] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFile_t swig_types[145] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t swig_types[146] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueProperties_t swig_types[147] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValue_t swig_types[148] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Platform_t swig_types[149] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t swig_types[150] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t swig_types[151] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Process_t swig_types[152] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t swig_types[153] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t swig_types[154] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__REPL_t swig_types[155] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t swig_types[156] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t swig_types[157] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterContext_t swig_types[158] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t swig_types[159] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegularExpression_t swig_types[160] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t swig_types[161] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t swig_types[162] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t swig_types[163] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t swig_types[164] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedMetadata_t swig_types[165] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t swig_types[166] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t swig_types[167] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t swig_types[168] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t swig_types[169] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SearchFilter_t swig_types[170] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SectionLoadList_t swig_types[171] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Section_t swig_types[172] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameList_t swig_types[173] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t swig_types[174] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrame_t swig_types[175] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StopInfo_t swig_types[176] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StreamFile_t swig_types[177] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Stream_t swig_types[178] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t swig_types[179] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t swig_types[180] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SupportFile_t swig_types[181] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t swig_types[182] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFileType_t swig_types[183] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t swig_types[184] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildren_t swig_types[185] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Target_t swig_types[186] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadCollection_t swig_types[187] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t swig_types[188] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t swig_types[189] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t swig_types[190] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Thread_t swig_types[191] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TraceCursor_t swig_types[192] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Trace_t swig_types[193] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t swig_types[194] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t swig_types[195] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t swig_types[196] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t swig_types[197] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeImpl_t swig_types[198] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t swig_types[199] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t swig_types[200] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t swig_types[201] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t swig_types[202] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystemClang_t swig_types[203] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystem_t swig_types[204] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Type_t swig_types[205] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnixSignals_t swig_types[206] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindAssembly_t swig_types[207] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindPlan_t swig_types[208] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UserExpression_t swig_types[209] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObjectList_t swig_types[210] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObject_t swig_types[211] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Value_t swig_types[212] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__VariableList_t swig_types[213] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Variable_t swig_types[214] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WatchpointResource_t swig_types[215] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Watchpoint_t swig_types[216] -#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WritableDataBuffer_t swig_types[217] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__AddressRange_t swig_types[218] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t swig_types[219] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicLoader_t swig_types[220] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__File_t swig_types[221] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__JITLoaderList_t swig_types[222] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t swig_types[223] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__OperatingSystem_t swig_types[224] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ProtocolServer_t swig_types[225] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t swig_types[226] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t swig_types[227] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SectionList_t swig_types[228] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SourceManager_t swig_types[229] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t swig_types[230] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__Stream_t swig_types[231] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t swig_types[232] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SymbolVendor_t swig_types[233] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SystemRuntime_t swig_types[234] -#define SWIGTYPE_p_std__unique_ptrT_lldb_private__TraceExporter_t swig_types[235] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointLocation_t swig_types[236] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Breakpoint_t swig_types[237] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BroadcasterManager_t swig_types[238] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Debugger_t swig_types[239] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Listener_t swig_types[240] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Module_t swig_types[241] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[242] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__OptionValue_t swig_types[243] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Process_t swig_types[244] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Queue_t swig_types[245] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Section_t swig_types[246] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrame_t swig_types[247] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t swig_types[248] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Target_t swig_types[249] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ThreadPlan_t swig_types[250] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Thread_t swig_types[251] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__TypeSystem_t swig_types[252] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Type_t swig_types[253] -#define SWIGTYPE_p_std__weak_ptrT_lldb_private__UnixSignals_t swig_types[254] -#define SWIGTYPE_p_unsigned_char swig_types[255] -#define SWIGTYPE_p_unsigned_int swig_types[256] -#define SWIGTYPE_p_unsigned_long_long swig_types[257] -#define SWIGTYPE_p_unsigned_short swig_types[258] -#define SWIGTYPE_p_void swig_types[259] -static swig_type_info *swig_types[261]; -static swig_module_info swig_module = {swig_types, 260, 0, 0, 0, 0}; +#define SWIGTYPE_p_lldb__SBFrameList swig_types[35] +#define SWIGTYPE_p_lldb__SBFunction swig_types[36] +#define SWIGTYPE_p_lldb__SBHostOS swig_types[37] +#define SWIGTYPE_p_lldb__SBInstruction swig_types[38] +#define SWIGTYPE_p_lldb__SBInstructionList swig_types[39] +#define SWIGTYPE_p_lldb__SBLanguageRuntime swig_types[40] +#define SWIGTYPE_p_lldb__SBLaunchInfo swig_types[41] +#define SWIGTYPE_p_lldb__SBLineEntry swig_types[42] +#define SWIGTYPE_p_lldb__SBListener swig_types[43] +#define SWIGTYPE_p_lldb__SBMemoryRegionInfo swig_types[44] +#define SWIGTYPE_p_lldb__SBMemoryRegionInfoList swig_types[45] +#define SWIGTYPE_p_lldb__SBModule swig_types[46] +#define SWIGTYPE_p_lldb__SBModuleSpec swig_types[47] +#define SWIGTYPE_p_lldb__SBModuleSpecList swig_types[48] +#define SWIGTYPE_p_lldb__SBMutex swig_types[49] +#define SWIGTYPE_p_lldb__SBPlatform swig_types[50] +#define SWIGTYPE_p_lldb__SBPlatformConnectOptions swig_types[51] +#define SWIGTYPE_p_lldb__SBPlatformShellCommand swig_types[52] +#define SWIGTYPE_p_lldb__SBProcess swig_types[53] +#define SWIGTYPE_p_lldb__SBProcessInfo swig_types[54] +#define SWIGTYPE_p_lldb__SBProcessInfoList swig_types[55] +#define SWIGTYPE_p_lldb__SBProgress swig_types[56] +#define SWIGTYPE_p_lldb__SBQueue swig_types[57] +#define SWIGTYPE_p_lldb__SBQueueItem swig_types[58] +#define SWIGTYPE_p_lldb__SBReproducer swig_types[59] +#define SWIGTYPE_p_lldb__SBSaveCoreOptions swig_types[60] +#define SWIGTYPE_p_lldb__SBScriptObject swig_types[61] +#define SWIGTYPE_p_lldb__SBSection swig_types[62] +#define SWIGTYPE_p_lldb__SBSourceManager swig_types[63] +#define SWIGTYPE_p_lldb__SBStatisticsOptions swig_types[64] +#define SWIGTYPE_p_lldb__SBStream swig_types[65] +#define SWIGTYPE_p_lldb__SBStringList swig_types[66] +#define SWIGTYPE_p_lldb__SBStructuredData swig_types[67] +#define SWIGTYPE_p_lldb__SBSymbol swig_types[68] +#define SWIGTYPE_p_lldb__SBSymbolContext swig_types[69] +#define SWIGTYPE_p_lldb__SBSymbolContextList swig_types[70] +#define SWIGTYPE_p_lldb__SBTarget swig_types[71] +#define SWIGTYPE_p_lldb__SBThread swig_types[72] +#define SWIGTYPE_p_lldb__SBThreadCollection swig_types[73] +#define SWIGTYPE_p_lldb__SBThreadPlan swig_types[74] +#define SWIGTYPE_p_lldb__SBTrace swig_types[75] +#define SWIGTYPE_p_lldb__SBTraceCursor swig_types[76] +#define SWIGTYPE_p_lldb__SBType swig_types[77] +#define SWIGTYPE_p_lldb__SBTypeCategory swig_types[78] +#define SWIGTYPE_p_lldb__SBTypeEnumMember swig_types[79] +#define SWIGTYPE_p_lldb__SBTypeEnumMemberList swig_types[80] +#define SWIGTYPE_p_lldb__SBTypeFilter swig_types[81] +#define SWIGTYPE_p_lldb__SBTypeFormat swig_types[82] +#define SWIGTYPE_p_lldb__SBTypeList swig_types[83] +#define SWIGTYPE_p_lldb__SBTypeMember swig_types[84] +#define SWIGTYPE_p_lldb__SBTypeMemberFunction swig_types[85] +#define SWIGTYPE_p_lldb__SBTypeNameSpecifier swig_types[86] +#define SWIGTYPE_p_lldb__SBTypeStaticField swig_types[87] +#define SWIGTYPE_p_lldb__SBTypeSummary swig_types[88] +#define SWIGTYPE_p_lldb__SBTypeSummaryOptions swig_types[89] +#define SWIGTYPE_p_lldb__SBTypeSynthetic swig_types[90] +#define SWIGTYPE_p_lldb__SBUnixSignals swig_types[91] +#define SWIGTYPE_p_lldb__SBValue swig_types[92] +#define SWIGTYPE_p_lldb__SBValueList swig_types[93] +#define SWIGTYPE_p_lldb__SBVariablesOptions swig_types[94] +#define SWIGTYPE_p_lldb__SBWatchpoint swig_types[95] +#define SWIGTYPE_p_lldb__SBWatchpointOptions swig_types[96] +#define SWIGTYPE_p_long_double swig_types[97] +#define SWIGTYPE_p_long_long swig_types[98] +#define SWIGTYPE_p_p_void swig_types[99] +#define SWIGTYPE_p_pthread_rwlock_t swig_types[100] +#define SWIGTYPE_p_pthread_t swig_types[101] +#define SWIGTYPE_p_short swig_types[102] +#define SWIGTYPE_p_signed_char swig_types[103] +#define SWIGTYPE_p_size_t swig_types[104] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ABI_t swig_types[105] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Baton_t swig_types[106] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Block_t swig_types[107] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointLocation_t swig_types[108] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t swig_types[109] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointResolver_t swig_types[110] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointSite_t swig_types[111] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Breakpoint_t swig_types[112] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BroadcasterManager_t swig_types[113] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Broadcaster_t swig_types[114] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CommandObject_t swig_types[115] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CompileUnit_t swig_types[116] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Connection_t swig_types[117] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataBuffer_t swig_types[118] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataExtractor_t swig_types[119] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Debugger_t swig_types[120] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Disassembler_t swig_types[121] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t swig_types[122] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventData_t swig_types[123] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t swig_types[124] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t swig_types[125] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExpressionVariable_t swig_types[126] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__File_t swig_types[127] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t swig_types[128] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__FuncUnwinders_t swig_types[129] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Function_t swig_types[130] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOHandler_t swig_types[131] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOObject_t swig_types[132] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t swig_types[133] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t swig_types[134] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Instruction_t swig_types[135] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t swig_types[136] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__JITLoader_t swig_types[137] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__LanguageRuntime_t swig_types[138] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Listener_t swig_types[139] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__LockableStreamFile_t swig_types[140] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryHistory_t swig_types[141] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t swig_types[142] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Module_t swig_types[143] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectContainer_t swig_types[144] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[145] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFile_t swig_types[146] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t swig_types[147] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueProperties_t swig_types[148] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValue_t swig_types[149] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Platform_t swig_types[150] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t swig_types[151] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t swig_types[152] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Process_t swig_types[153] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t swig_types[154] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t swig_types[155] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__REPL_t swig_types[156] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t swig_types[157] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t swig_types[158] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterContext_t swig_types[159] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t swig_types[160] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegularExpression_t swig_types[161] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t swig_types[162] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t swig_types[163] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t swig_types[164] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t swig_types[165] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t swig_types[166] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedMetadata_t swig_types[167] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t swig_types[168] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t swig_types[169] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t swig_types[170] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t swig_types[171] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SearchFilter_t swig_types[172] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SectionLoadList_t swig_types[173] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Section_t swig_types[174] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameList_t swig_types[175] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t swig_types[176] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrame_t swig_types[177] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StopInfo_t swig_types[178] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StreamFile_t swig_types[179] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Stream_t swig_types[180] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t swig_types[181] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t swig_types[182] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SupportFile_t swig_types[183] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t swig_types[184] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFileType_t swig_types[185] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t swig_types[186] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildren_t swig_types[187] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t swig_types[188] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Target_t swig_types[189] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadCollection_t swig_types[190] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t swig_types[191] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t swig_types[192] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t swig_types[193] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Thread_t swig_types[194] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TraceCursor_t swig_types[195] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Trace_t swig_types[196] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t swig_types[197] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t swig_types[198] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t swig_types[199] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t swig_types[200] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeImpl_t swig_types[201] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t swig_types[202] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t swig_types[203] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t swig_types[204] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t swig_types[205] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystemClang_t swig_types[206] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystem_t swig_types[207] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Type_t swig_types[208] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnixSignals_t swig_types[209] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindAssembly_t swig_types[210] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindPlan_t swig_types[211] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UserExpression_t swig_types[212] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObjectList_t swig_types[213] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObject_t swig_types[214] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Value_t swig_types[215] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__VariableList_t swig_types[216] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Variable_t swig_types[217] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WatchpointResource_t swig_types[218] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Watchpoint_t swig_types[219] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WritableDataBuffer_t swig_types[220] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__AddressRange_t swig_types[221] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t swig_types[222] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicLoader_t swig_types[223] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__File_t swig_types[224] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__JITLoaderList_t swig_types[225] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t swig_types[226] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__OperatingSystem_t swig_types[227] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ProtocolServer_t swig_types[228] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t swig_types[229] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t swig_types[230] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SectionList_t swig_types[231] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SourceManager_t swig_types[232] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t swig_types[233] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__Stream_t swig_types[234] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t swig_types[235] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SymbolVendor_t swig_types[236] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SystemRuntime_t swig_types[237] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__TraceExporter_t swig_types[238] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointLocation_t swig_types[239] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Breakpoint_t swig_types[240] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BroadcasterManager_t swig_types[241] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Debugger_t swig_types[242] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Listener_t swig_types[243] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Module_t swig_types[244] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[245] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__OptionValue_t swig_types[246] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Process_t swig_types[247] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Queue_t swig_types[248] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Section_t swig_types[249] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrame_t swig_types[250] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t swig_types[251] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Target_t swig_types[252] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ThreadPlan_t swig_types[253] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Thread_t swig_types[254] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__TypeSystem_t swig_types[255] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Type_t swig_types[256] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__UnixSignals_t swig_types[257] +#define SWIGTYPE_p_unsigned_char swig_types[258] +#define SWIGTYPE_p_unsigned_int swig_types[259] +#define SWIGTYPE_p_unsigned_long_long swig_types[260] +#define SWIGTYPE_p_unsigned_short swig_types[261] +#define SWIGTYPE_p_void swig_types[262] +static swig_type_info *swig_types[264]; +static swig_module_info swig_module = {swig_types, 263, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3737,7 +3973,7 @@ SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char* carray, size_t size) { if (carray) { - if (size > INT_MAX) { + if (size > (size_t)PY_SSIZE_T_MAX) { swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); return pchar_descriptor ? SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); @@ -3818,6 +4054,9 @@ SWIG_AsVal_double (PyObject *obj, double *val) } +#include + + #include @@ -3987,7 +4226,7 @@ SWIG_From_std_string (const std::string& s) SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc) { -#if PY_VERSION_HEX>=0x03000000 +#if PY_VERSION_HEX >= 0x03000000 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) if (PyBytes_Check(obj)) #else @@ -4002,7 +4241,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc) int ret = SWIG_OK; if (alloc) *alloc = SWIG_OLDOBJ; -#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR) +#if PY_VERSION_HEX >= 0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR) if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1) return SWIG_TypeError; #else @@ -4029,7 +4268,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc) #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once" #endif -#if PY_VERSION_HEX<0x03000000 +#if PY_VERSION_HEX < 0x03000000 if (PyUnicode_Check(obj)) { char *cstr; Py_ssize_t len; if (!alloc && cptr) { @@ -4467,6 +4706,16 @@ SWIGINTERN std::string lldb_SBFrame___repr__(lldb::SBFrame *self){ } return std::string(desc, desc_len); } +SWIGINTERN std::string lldb_SBFrameList___str__(lldb::SBFrameList *self){ + lldb::SBStream description; + if (!self->GetDescription(description)) + return std::string(" lldb.SBFrameList()"); + 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 std::string(desc, desc_len); + } SWIGINTERN std::string lldb_SBFunction___repr__(lldb::SBFunction *self){ lldb::SBStream stream; self->GetDescription (stream); @@ -5239,6 +5488,18 @@ void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBBreakpoint(PyObject * return sb_ptr; } +void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBThread(PyObject * data) { + lldb::SBThread *sb_ptr = nullptr; + + int valid_cast = + SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBThread, 0); + + if (valid_cast == -1) + return NULL; + + return sb_ptr; +} + void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrame(PyObject * data) { lldb::SBFrame *sb_ptr = nullptr; @@ -5373,6 +5634,18 @@ void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBExecutionContext(PyOb return sb_ptr; } +void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data) { + lldb::SBFrameList *sb_ptr = NULL; + + int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr, + SWIGTYPE_p_lldb__SBFrameList, 0); + + if (valid_cast == -1) + return NULL; + + return sb_ptr; +} + bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommand( const char *python_function_name, const char *session_dictionary_name, lldb::DebuggerSP debugger, const char *args, @@ -6110,7 +6383,7 @@ SWIGINTERN PyObject *_wrap_new_SBAddress(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6137,7 +6410,7 @@ SWIGINTERN PyObject *_wrap_delete_SBAddress(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6165,7 +6438,7 @@ SWIGINTERN PyObject *_wrap_SBAddress___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddress___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -6208,7 +6481,7 @@ SWIGINTERN PyObject *_wrap_SBAddress___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6236,7 +6509,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6263,7 +6536,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress_GetFileAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6291,7 +6564,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetFileAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAddress_GetLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -6329,7 +6602,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetLoadAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAddress_SetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; lldb::SBSection arg2 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -6379,7 +6652,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_SetAddress(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddress_SetLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; lldb::addr_t arg2 ; lldb::SBTarget *arg3 = 0 ; void *argp1 = 0 ; @@ -6424,7 +6697,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_SetLoadAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAddress_OffsetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -6459,7 +6732,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_OffsetAddress(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBAddress_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -6497,7 +6770,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetDescription(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAddress_GetSymbolContext(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -6532,7 +6805,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetSymbolContext(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBAddress_GetSection(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6560,7 +6833,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetSection(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddress_GetOffset(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6588,7 +6861,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetOffset(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress_GetModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6616,7 +6889,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetModule(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress_GetCompileUnit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6644,7 +6917,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetCompileUnit(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAddress_GetFunction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6672,7 +6945,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetFunction(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddress_GetBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6700,7 +6973,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetBlock(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress_GetSymbol(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6728,7 +7001,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetSymbol(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAddress_GetLineEntry(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6756,7 +7029,7 @@ SWIGINTERN PyObject *_wrap_SBAddress_GetLineEntry(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBAddress___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBAddress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6928,7 +7201,7 @@ SWIGINTERN PyObject *_wrap_new_SBAddressRange(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBAddressRange(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6955,7 +7228,7 @@ SWIGINTERN PyObject *_wrap_delete_SBAddressRange(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddressRange_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -6982,7 +7255,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRange_Clear(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddressRange_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7010,7 +7283,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRange_IsValid(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBAddressRange_GetBaseAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7038,7 +7311,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRange_GetBaseAddress(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBAddressRange_GetByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7066,7 +7339,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRange_GetByteSize(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBAddressRange___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; lldb::SBAddressRange *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -7109,7 +7382,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRange___eq__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddressRange___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; lldb::SBAddressRange *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -7152,7 +7425,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRange___ne__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBAddressRange_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::SBTarget arg3 ; void *argp1 = 0 ; @@ -7293,7 +7566,7 @@ SWIGINTERN PyObject *_wrap_new_SBAddressRangeList(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_delete_SBAddressRangeList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7320,7 +7593,7 @@ SWIGINTERN PyObject *_wrap_delete_SBAddressRangeList(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7348,7 +7621,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetSize(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBAddressRangeList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7375,7 +7648,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRangeList_Clear(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetAddressRangeAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -7410,7 +7683,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetAddressRangeAtIndex(PyObject *s SWIGINTERN PyObject *_wrap_SBAddressRangeList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg1 = 0 ; lldb::SBAddressRange *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -7446,7 +7719,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRangeList_Append__SWIG_0(PyObject *self, Py_ SWIGINTERN PyObject *_wrap_SBAddressRangeList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg1 = 0 ; lldb::SBAddressRangeList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -7526,7 +7799,7 @@ SWIGINTERN PyObject *_wrap_SBAddressRangeList_Append(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::SBTarget *arg3 = 0 ; void *argp1 = 0 ; @@ -7630,7 +7903,7 @@ SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_1(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; bool arg2 ; int res1 ; char *buf1 = 0 ; @@ -7667,7 +7940,7 @@ SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_2(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; bool arg2 ; bool arg3 ; int res1 ; @@ -7817,7 +8090,7 @@ SWIGINTERN PyObject *_wrap_new_SBAttachInfo(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBAttachInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7844,7 +8117,7 @@ SWIGINTERN PyObject *_wrap_delete_SBAttachInfo(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -7872,7 +8145,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessID(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; lldb::pid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -7906,8 +8179,8 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessID(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -7942,7 +8215,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; lldb::SBFileSpec arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8027,7 +8300,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBAttachInfo_GetWaitForLaunch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8055,7 +8328,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetWaitForLaunch(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8088,7 +8361,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; bool arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -8183,7 +8456,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBAttachInfo_GetIgnoreExisting(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8211,7 +8484,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetIgnoreExisting(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBAttachInfo_SetIgnoreExisting(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8245,7 +8518,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetIgnoreExisting(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBAttachInfo_GetResumeCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8273,7 +8546,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetResumeCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBAttachInfo_SetResumeCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8307,7 +8580,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetResumeCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8335,8 +8608,8 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessPluginName(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -8372,7 +8645,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessPluginName(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBAttachInfo_GetUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8400,7 +8673,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetUserID(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBAttachInfo_GetGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8428,7 +8701,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetGroupID(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBAttachInfo_UserIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8456,7 +8729,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_UserIDIsValid(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBAttachInfo_GroupIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8484,7 +8757,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GroupIDIsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBAttachInfo_SetUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8518,7 +8791,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetUserID(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBAttachInfo_SetGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8552,7 +8825,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetGroupID(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8580,7 +8853,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveUserID(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8608,7 +8881,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveGroupID(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveUserIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8636,7 +8909,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveUserIDIsValid(PyObject *self, P SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveGroupIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8664,7 +8937,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveGroupIDIsValid(PyObject *self, SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8698,7 +8971,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveUserID(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8732,7 +9005,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveGroupID(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBAttachInfo_GetParentProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8760,7 +9033,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetParentProcessID(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBAttachInfo_SetParentProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; lldb::pid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8794,7 +9067,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetParentProcessID(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBAttachInfo_ParentProcessIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8822,7 +9095,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_ParentProcessIDIsValid(PyObject *self, P SWIGINTERN PyObject *_wrap_SBAttachInfo_GetListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8850,7 +9123,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetListener(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAttachInfo_SetListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8887,7 +9160,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetListener(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBAttachInfo_GetShadowListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8915,7 +9188,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetShadowListener(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBAttachInfo_SetShadowListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -8952,7 +9225,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetShadowListener(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBAttachInfo_GetScriptedProcessClassName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -8980,8 +9253,8 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetScriptedProcessClassName(PyObject *se SWIGINTERN PyObject *_wrap_SBAttachInfo_SetScriptedProcessClassName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -9017,7 +9290,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_SetScriptedProcessClassName(PyObject *se SWIGINTERN PyObject *_wrap_SBAttachInfo_GetScriptedProcessDictionary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9045,7 +9318,7 @@ SWIGINTERN PyObject *_wrap_SBAttachInfo_GetScriptedProcessDictionary(PyObject *s SWIGINTERN PyObject *_wrap_SBAttachInfo_SetScriptedProcessDictionary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBAttachInfo *arg1 = 0 ; lldb::SBStructuredData arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -9174,7 +9447,7 @@ SWIGINTERN PyObject *_wrap_new_SBBlock(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9201,7 +9474,7 @@ SWIGINTERN PyObject *_wrap_delete_SBBlock(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBlock_IsInlined(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9229,7 +9502,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_IsInlined(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBlock___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9257,7 +9530,7 @@ SWIGINTERN PyObject *_wrap_SBBlock___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBlock_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9285,7 +9558,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9313,7 +9586,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedName(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9341,7 +9614,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteFile(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteLine(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9369,7 +9642,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteLine(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteColumn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9397,7 +9670,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteColumn(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBlock_GetParent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9425,7 +9698,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetParent(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBlock_GetSibling(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9453,7 +9726,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetSibling(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBlock_GetFirstChild(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9481,7 +9754,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetFirstChild(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBlock_GetNumRanges(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9509,7 +9782,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetNumRanges(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBlock_GetRangeStartAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -9544,7 +9817,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetRangeStartAddress(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBlock_GetRangeEndAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -9579,7 +9852,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetRangeEndAddress(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBBlock_GetRanges(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9607,7 +9880,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetRanges(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBlock_GetRangeIndexForBlockAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; lldb::SBAddress arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -9650,7 +9923,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetRangeIndexForBlockAddress(PyObject *self, SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; bool arg3 ; bool arg4 ; @@ -9719,7 +9992,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; bool arg3 ; bool arg4 ; @@ -9868,7 +10141,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetVariables(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBlock_GetContainingInlinedBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9896,7 +10169,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetContainingInlinedBlock(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBBlock_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -9934,7 +10207,7 @@ SWIGINTERN PyObject *_wrap_SBBlock_GetDescription(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBBlock___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10049,7 +10322,7 @@ SWIGINTERN PyObject *_wrap_new_SBBreakpoint(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBBreakpoint(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10076,7 +10349,7 @@ SWIGINTERN PyObject *_wrap_delete_SBBreakpoint(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBreakpoint___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBBreakpoint *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10119,7 +10392,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBreakpoint___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBBreakpoint *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10162,7 +10435,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBreakpoint_GetID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10190,7 +10463,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBreakpoint___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10218,7 +10491,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpoint_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10246,7 +10519,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBreakpoint_ClearAllBreakpointSites(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10273,7 +10546,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_ClearAllBreakpointSites(PyObject *self, SWIGINTERN PyObject *_wrap_SBBreakpoint_GetTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10301,7 +10574,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetTarget(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10336,7 +10609,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByAddress(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationIDByAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10371,7 +10644,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationIDByAddress(PyObject *self, SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::break_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10406,7 +10679,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByID(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBBreakpoint_GetLocationAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10441,7 +10714,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetLocationAtIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpoint_SetEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10475,7 +10748,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetEnabled(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpoint_IsEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10503,7 +10776,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_IsEnabled(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBBreakpoint_SetOneShot(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10537,7 +10810,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetOneShot(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpoint_IsOneShot(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10565,7 +10838,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_IsOneShot(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBBreakpoint_IsInternal(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10593,7 +10866,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_IsInternal(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpoint_GetHitCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10621,7 +10894,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetHitCount(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10655,7 +10928,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIgnoreCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpoint_GetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10683,8 +10956,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetIgnoreCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -10720,7 +10993,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCondition(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10748,7 +11021,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCondition(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBBreakpoint_SetAutoContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10782,7 +11055,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetAutoContinue(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpoint_GetAutoContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10810,7 +11083,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetAutoContinue(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::tid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10844,7 +11117,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadID(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10872,7 +11145,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadID(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10906,7 +11179,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadIndex(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10934,8 +11207,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadIndex(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -10971,7 +11244,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadName(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10999,8 +11272,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadName(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBBreakpoint_SetQueueName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11036,7 +11309,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetQueueName(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBBreakpoint_GetQueueName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -11064,8 +11337,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetQueueName(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11100,8 +11373,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(PyObje SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -11197,7 +11470,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction(PyObject *self SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCommandLineCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -11234,7 +11507,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCommandLineCommands(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCommandLineCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -11272,8 +11545,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCommandLineCommands(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackBody(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11310,8 +11583,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackBody(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBBreakpoint_AddName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11348,8 +11621,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_AddName(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBreakpoint_AddNameWithErrorHandling(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11386,8 +11659,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_AddNameWithErrorHandling(PyObject *self, SWIGINTERN PyObject *_wrap_SBBreakpoint_RemoveName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11423,8 +11696,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_RemoveName(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpoint_MatchesName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11461,7 +11734,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_MatchesName(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNames(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -11498,7 +11771,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNames(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumResolvedLocations(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -11526,7 +11799,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumResolvedLocations(PyObject *self, SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumLocations(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -11554,7 +11827,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumLocations(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -11591,7 +11864,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_0(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -11850,7 +12123,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent(PyObj SWIGINTERN PyObject *_wrap_SBBreakpoint_IsHardware(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -11878,7 +12151,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_IsHardware(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIsHardware(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -11913,7 +12186,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIsHardware(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBBreakpoint_AddLocation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -11951,7 +12224,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_AddLocation(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpoint_AddFacadeLocation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -11979,7 +12252,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_AddFacadeLocation(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBreakpoint_SerializeToStructuredData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12007,7 +12280,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpoint_SerializeToStructuredData(PyObject *self SWIGINTERN PyObject *_wrap_SBBreakpoint___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12077,7 +12350,7 @@ SWIGINTERN PyObject *_wrap_new_SBBreakpointList(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBBreakpointList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12104,7 +12377,7 @@ SWIGINTERN PyObject *_wrap_delete_SBBreakpointList(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpointList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12132,7 +12405,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointList_GetSize(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpointList_GetBreakpointAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12167,7 +12440,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointList_GetBreakpointAtIndex(PyObject *self, SWIGINTERN PyObject *_wrap_SBBreakpointList_FindBreakpointByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; lldb::break_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12202,7 +12475,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointList_FindBreakpointByID(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpointList_Append(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; lldb::SBBreakpoint *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12239,7 +12512,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointList_Append(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendIfUnique(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; lldb::SBBreakpoint *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12277,7 +12550,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendIfUnique(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; lldb::break_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12311,7 +12584,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendByID(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpointList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12425,7 +12698,7 @@ SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_delete_SBBreakpointLocation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12452,7 +12725,7 @@ SWIGINTERN PyObject *_wrap_delete_SBBreakpointLocation(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12480,7 +12753,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetID(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBBreakpointLocation___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12508,7 +12781,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation___nonzero__(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12536,7 +12809,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12564,7 +12837,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAddress(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12592,7 +12865,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetLoadAddress(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12626,7 +12899,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetEnabled(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12654,7 +12927,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsEnabled(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetHitCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12682,7 +12955,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetHitCount(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12710,7 +12983,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetIgnoreCount(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12744,8 +13017,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetIgnoreCount(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -12781,7 +13054,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCondition(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12809,7 +13082,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCondition(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetAutoContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12843,7 +13116,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetAutoContinue(PyObject *self, SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAutoContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12871,8 +13144,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAutoContinue(PyObject *self, SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -12907,8 +13180,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13004,8 +13277,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction(PyObje SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackBody(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -13042,7 +13315,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackBody(PyObject * SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCommandLineCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13079,7 +13352,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCommandLineCommands(PyObject SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCommandLineCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13117,7 +13390,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCommandLineCommands(PyObject SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; lldb::tid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13151,7 +13424,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadID(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13179,7 +13452,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadID(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13213,7 +13486,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadIndex(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13241,8 +13514,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadIndex(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -13278,7 +13551,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadName(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13306,8 +13579,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadName(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetQueueName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -13343,7 +13616,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetQueueName(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetQueueName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13371,7 +13644,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetQueueName(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsResolved(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13399,7 +13672,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsResolved(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -13445,7 +13718,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetDescription(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetBreakpoint(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13473,7 +13746,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetBreakpoint(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBBreakpointLocation___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpointLocation *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13531,7 +13804,7 @@ SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; lldb::SBTarget *arg1 = 0 ; - char *arg2 = (char *) 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -13571,7 +13844,7 @@ SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_1(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; lldb::SBBreakpoint *arg1 = 0 ; - char *arg2 = (char *) 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -13696,7 +13969,7 @@ SWIGINTERN PyObject *_wrap_new_SBBreakpointName(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBBreakpointName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13723,7 +13996,7 @@ SWIGINTERN PyObject *_wrap_delete_SBBreakpointName(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpointName___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; lldb::SBBreakpointName *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13766,7 +14039,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName___eq__(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpointName___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; lldb::SBBreakpointName *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13809,7 +14082,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName___ne__(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBBreakpointName___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13837,7 +14110,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName___nonzero__(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointName_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13865,7 +14138,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_IsValid(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpointName_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13893,7 +14166,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetName(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBBreakpointName_SetEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13927,7 +14200,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetEnabled(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointName_IsEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13955,7 +14228,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_IsEnabled(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBBreakpointName_SetOneShot(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13989,7 +14262,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetOneShot(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointName_IsOneShot(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14017,7 +14290,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_IsOneShot(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBBreakpointName_SetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14051,7 +14324,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetIgnoreCount(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointName_GetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14079,8 +14352,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetIgnoreCount(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointName_SetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -14116,7 +14389,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetCondition(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBBreakpointName_GetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14144,7 +14417,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetCondition(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAutoContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14178,7 +14451,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAutoContinue(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAutoContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14206,7 +14479,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAutoContinue(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; lldb::tid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14240,7 +14513,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadID(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14268,7 +14541,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadID(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14302,7 +14575,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14330,8 +14603,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -14367,7 +14640,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadName(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14395,8 +14668,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadName(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBreakpointName_SetQueueName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -14432,7 +14705,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetQueueName(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBBreakpointName_GetQueueName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14460,8 +14733,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetQueueName(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -14496,8 +14769,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(Py SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14593,7 +14866,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackFunction(PyObject * SWIGINTERN PyObject *_wrap_SBBreakpointName_SetCommandLineCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14630,7 +14903,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetCommandLineCommands(PyObject *sel SWIGINTERN PyObject *_wrap_SBBreakpointName_GetCommandLineCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14668,8 +14941,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetCommandLineCommands(PyObject *sel SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackBody(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -14706,7 +14979,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackBody(PyObject *self SWIGINTERN PyObject *_wrap_SBBreakpointName_GetHelpString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14734,8 +15007,8 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetHelpString(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBreakpointName_SetHelpString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -14771,7 +15044,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetHelpString(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14799,7 +15072,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowList(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14833,7 +15106,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowList(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowDelete(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14861,7 +15134,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowDelete(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowDelete(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14895,7 +15168,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowDelete(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowDisable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14923,7 +15196,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowDisable(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowDisable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14957,7 +15230,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowDisable(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBBreakpointName_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -14995,7 +15268,7 @@ SWIGINTERN PyObject *_wrap_SBBreakpointName_GetDescription(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBBreakpointName___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -15052,7 +15325,7 @@ SWIGINTERN PyObject *_wrap_new_SBBroadcaster__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_new_SBBroadcaster__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -15148,7 +15421,7 @@ SWIGINTERN PyObject *_wrap_new_SBBroadcaster(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -15175,7 +15448,7 @@ SWIGINTERN PyObject *_wrap_delete_SBBroadcaster(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBroadcaster___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -15203,7 +15476,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBBroadcaster_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -15231,7 +15504,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBroadcaster_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -15258,7 +15531,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; uint32_t arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -15299,7 +15572,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(PyObject * SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEventByType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -15386,7 +15659,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEventByType(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEvent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -15430,7 +15703,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEvent__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -15516,7 +15789,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEvent(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBroadcaster_AddInitialEventsToListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -15561,7 +15834,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_AddInitialEventsToListener(PyObject *se SWIGINTERN PyObject *_wrap_SBBroadcaster_AddListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -15607,7 +15880,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_AddListener(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBBroadcaster_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -15635,7 +15908,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_GetName(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBroadcaster_EventTypeHasListeners(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -15670,7 +15943,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_EventTypeHasListeners(PyObject *self, P SWIGINTERN PyObject *_wrap_SBBroadcaster_RemoveListener__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -15715,7 +15988,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_RemoveListener__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBBroadcaster_RemoveListener__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -15802,7 +16075,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster_RemoveListener(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBBroadcaster___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -15845,7 +16118,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster___eq__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBroadcaster___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -15888,7 +16161,7 @@ SWIGINTERN PyObject *_wrap_SBBroadcaster___ne__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBBroadcaster___lt__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -16018,7 +16291,7 @@ SWIGINTERN PyObject *_wrap_new_SBCommandInterpreter(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_delete_SBCommandInterpreter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16132,7 +16405,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent(P SWIGINTERN PyObject *_wrap_SBCommandInterpreter___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16160,7 +16433,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter___nonzero__(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16188,8 +16461,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCommandInterpreter_CommandExists(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -16226,8 +16499,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_CommandExists(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandInterpreter_UserCommandExists(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -16264,8 +16537,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_UserCommandExists(PyObject *self SWIGINTERN PyObject *_wrap_SBCommandInterpreter_AliasExists(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -16302,7 +16575,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_AliasExists(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16348,7 +16621,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetBroadcasterClass(PyObject *se SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16376,7 +16649,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasCommands(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasAliases(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16404,7 +16677,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasAliases(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasAliasOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16432,7 +16705,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasAliasOptions(PyObject *self, SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsInteractive(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16460,7 +16733,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsInteractive(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16488,7 +16761,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetProcess(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetDebugger(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -16516,7 +16789,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetDebugger(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; lldb::SBCommandReturnObject *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -16552,7 +16825,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__S SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; lldb::SBCommandReturnObject *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -16648,7 +16921,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory(Py SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; lldb::SBCommandReturnObject *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -16685,8 +16958,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDi SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBCommandReturnObject *arg3 = 0 ; bool arg4 ; void *argp1 = 0 ; @@ -16741,8 +17014,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_0(PyObject * SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBCommandReturnObject *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -16789,8 +17062,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_1(PyObject * SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBExecutionContext *arg3 = 0 ; lldb::SBCommandReturnObject *arg4 = 0 ; bool arg5 ; @@ -16856,8 +17129,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_2(PyObject * SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBExecutionContext *arg3 = 0 ; lldb::SBCommandReturnObject *arg4 = 0 ; void *argp1 = 0 ; @@ -17029,7 +17302,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommandsFromFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBExecutionContext *arg3 = 0 ; lldb::SBCommandInterpreterRunOptions *arg4 = 0 ; @@ -17104,8 +17377,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommandsFromFile(PyObject SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCompletion(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; int arg4 ; int arg5 ; @@ -17177,8 +17450,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCompletion(PyObject *self, SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCompletionWithDescriptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; int arg4 ; int arg5 ; @@ -17261,7 +17534,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCompletionWithDescriptions SWIGINTERN PyObject *_wrap_SBCommandInterpreter_WasInterrupted(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17289,7 +17562,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_WasInterrupted(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCommandInterpreter_InterruptCommand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17317,10 +17590,10 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_InterruptCommand(PyObject *self, SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetCommandOverrideCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; - lldb::CommandOverrideCallback arg3 = (lldb::CommandOverrideCallback) 0 ; - void *arg4 = (void *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; + lldb::CommandOverrideCallback arg3 = 0 ; + void *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -17369,7 +17642,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetCommandOverrideCallback(PyObj SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsActive(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17397,7 +17670,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsActive(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetIOHandlerControlSequence(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; char arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -17432,7 +17705,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetIOHandlerControlSequence(PyOb SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetPromptOnQuit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17460,7 +17733,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetPromptOnQuit(PyObject *self, SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetPromptOnQuit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -17494,7 +17767,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetPromptOnQuit(PyObject *self, SWIGINTERN PyObject *_wrap_SBCommandInterpreter_AllowExitCodeOnQuit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -17528,7 +17801,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_AllowExitCodeOnQuit(PyObject *se SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasCustomQuitExitCode(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17556,7 +17829,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasCustomQuitExitCode(PyObject * SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetQuitStatus(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17584,8 +17857,8 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetQuitStatus(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandInterpreter_ResolveCommand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBCommandReturnObject *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -17632,7 +17905,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_ResolveCommand(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetStatistics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17660,7 +17933,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetStatistics(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetTranscript(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17688,9 +17961,9 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetTranscript(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetPrintCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; - lldb::SBCommandPrintCallback arg2 = (lldb::SBCommandPrintCallback) 0 ; - void *arg3 = (void *) 0 ; + lldb::SBCommandInterpreter *arg1 = 0 ; + lldb::SBCommandPrintCallback arg2 = 0 ; + void *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; @@ -17815,7 +18088,7 @@ SWIGINTERN PyObject *_wrap_new_SBCommandInterpreterRunOptions(PyObject *self, Py SWIGINTERN PyObject *_wrap_delete_SBCommandInterpreterRunOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17842,7 +18115,7 @@ SWIGINTERN PyObject *_wrap_delete_SBCommandInterpreterRunOptions(PyObject *self, SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17870,7 +18143,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnContinue(PyOb SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnContinue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -17904,7 +18177,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnContinue(PyOb SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17932,7 +18205,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnError(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -17966,7 +18239,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnError(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnCrash(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -17994,7 +18267,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnCrash(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnCrash(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18028,7 +18301,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnCrash(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetEchoCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18056,7 +18329,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetEchoCommands(PyObje SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetEchoCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18090,7 +18363,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetEchoCommands(PyObje SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetEchoCommentCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18118,7 +18391,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetEchoCommentCommands SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetEchoCommentCommands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18152,7 +18425,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetEchoCommentCommands SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetPrintResults(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18180,7 +18453,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetPrintResults(PyObje SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetPrintResults(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18214,7 +18487,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetPrintResults(PyObje SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetPrintErrors(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18242,7 +18515,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetPrintErrors(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetPrintErrors(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18276,7 +18549,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetPrintErrors(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAddToHistory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18304,7 +18577,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAddToHistory(PyObje SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAddToHistory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18338,7 +18611,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAddToHistory(PyObje SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAutoHandleEvents(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18366,7 +18639,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAutoHandleEvents(Py SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAutoHandleEvents(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18400,7 +18673,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAutoHandleEvents(Py SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetSpawnThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18428,7 +18701,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetSpawnThread(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetSpawnThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18462,7 +18735,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetSpawnThread(PyObjec SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAllowRepeats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18490,7 +18763,7 @@ SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAllowRepeats(PyObje SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAllowRepeats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18611,7 +18884,7 @@ SWIGINTERN PyObject *_wrap_new_SBCommandReturnObject(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_delete_SBCommandReturnObject(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18638,7 +18911,7 @@ SWIGINTERN PyObject *_wrap_delete_SBCommandReturnObject(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCommandReturnObject___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18666,7 +18939,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject___nonzero__(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBCommandReturnObject_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18694,7 +18967,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_IsValid(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetCommand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18722,7 +18995,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetCommand(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; char *result = 0 ; @@ -18748,7 +19021,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutput__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; char *result = 0 ; @@ -18774,7 +19047,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetError__SWIG_0(PyObject *self SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetErrorData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18802,7 +19075,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetErrorData(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutOutput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18844,7 +19117,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutOutput__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutOutput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -18933,7 +19206,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutOutput(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutputSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18961,7 +19234,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutputSize(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetErrorSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -18989,7 +19262,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetErrorSize(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19031,7 +19304,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutError__SWIG_0(PyObject *self SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19120,7 +19393,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutError(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -19147,7 +19420,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Clear(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetStatus(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -19175,7 +19448,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetStatus(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetStatus(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::ReturnStatus arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19209,7 +19482,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetStatus(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Succeeded(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -19237,7 +19510,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Succeeded(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandReturnObject_HasResult(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -19265,8 +19538,8 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_HasResult(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandReturnObject_AppendMessage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -19302,8 +19575,8 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_AppendMessage(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCommandReturnObject_AppendWarning(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -19339,7 +19612,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_AppendWarning(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19377,7 +19650,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetDescription(PyObject *self, SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19418,7 +19691,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0( SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19459,7 +19732,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(P SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19497,7 +19770,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1( SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19535,8 +19808,8 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(P SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutCString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; + char *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19585,8 +19858,8 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutCString__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutCString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -19674,7 +19947,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutCString(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19750,7 +20023,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutput(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19826,9 +20099,9 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetError(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::SBError *arg2 = 0 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -19873,7 +20146,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_0(PyObject *self SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -19909,8 +20182,8 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_1(PyObject *self SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -20009,7 +20282,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetValues(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; lldb::DynamicValueType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -20044,7 +20317,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetValues(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommandReturnObject___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20072,7 +20345,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject___repr__(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -20194,7 +20467,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile(PyObject SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -20316,8 +20589,8 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile(PyObject SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Print(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -20353,8 +20626,8 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Print(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCommandReturnObject_write(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -20390,7 +20663,7 @@ SWIGINTERN PyObject *_wrap_SBCommandReturnObject_write(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCommandReturnObject_flush(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBCommandReturnObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20446,7 +20719,7 @@ SWIGINTERN PyObject *_wrap_new_SBCommunication__SWIG_0(PyObject *self, Py_ssize_ SWIGINTERN PyObject *_wrap_new_SBCommunication__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -20504,7 +20777,7 @@ SWIGINTERN PyObject *_wrap_new_SBCommunication(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBCommunication(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20531,7 +20804,7 @@ SWIGINTERN PyObject *_wrap_delete_SBCommunication(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBCommunication___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20559,7 +20832,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication___nonzero__(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCommunication_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20587,7 +20860,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_IsValid(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBCommunication_GetBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20633,7 +20906,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_GetBroadcasterClass(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCommunication_AdoptFileDesriptor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; int arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -20676,8 +20949,8 @@ SWIGINTERN PyObject *_wrap_SBCommunication_AdoptFileDesriptor(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCommunication_Connect(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBCommunication *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -20714,7 +20987,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_Connect(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBCommunication_Disconnect(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20742,7 +21015,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_Disconnect(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBCommunication_IsConnected(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20770,7 +21043,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_IsConnected(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCommunication_GetCloseOnEOF(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20798,7 +21071,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_GetCloseOnEOF(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBCommunication_SetCloseOnEOF(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -20832,8 +21105,8 @@ SWIGINTERN PyObject *_wrap_SBCommunication_SetCloseOnEOF(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBCommunication_Read(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; - void *arg2 = (void *) 0 ; + lldb::SBCommunication *arg1 = 0 ; + void *arg2 = 0 ; size_t arg3 ; uint32_t arg4 ; lldb::ConnectionStatus *arg5 = 0 ; @@ -20892,8 +21165,8 @@ SWIGINTERN PyObject *_wrap_SBCommunication_Read(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBCommunication_Write(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; - void *arg2 = (void *) 0 ; + lldb::SBCommunication *arg1 = 0 ; + void *arg2 = 0 ; size_t arg3 ; lldb::ConnectionStatus *arg4 = 0 ; void *argp1 = 0 ; @@ -20944,7 +21217,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_Write(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadStart(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -20972,7 +21245,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadStart(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadStop(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21000,7 +21273,7 @@ SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadStop(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadIsRunning(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21028,9 +21301,9 @@ SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadIsRunning(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCommunication_SetReadThreadBytesReceivedCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; - lldb::SBCommunication::ReadThreadBytesReceived arg2 = (lldb::SBCommunication::ReadThreadBytesReceived) 0 ; - void *arg3 = (void *) 0 ; + lldb::SBCommunication *arg1 = 0 ; + lldb::SBCommunication::ReadThreadBytesReceived arg2 = 0 ; + void *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res3 ; @@ -21155,7 +21428,7 @@ SWIGINTERN PyObject *_wrap_new_SBCompileUnit(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBCompileUnit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21182,7 +21455,7 @@ SWIGINTERN PyObject *_wrap_delete_SBCompileUnit(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBCompileUnit___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21210,7 +21483,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBCompileUnit_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21238,7 +21511,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBCompileUnit_GetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21266,7 +21539,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetFileSpec(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBCompileUnit_GetNumLineEntries(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21294,7 +21567,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetNumLineEntries(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBCompileUnit_GetLineEntryAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21329,7 +21602,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetLineEntryAtIndex(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; lldb::SBLineEntry *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -21374,7 +21647,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; lldb::SBLineEntry *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21411,10 +21684,10 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(PyObject *se SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; uint32_t arg2 ; uint32_t arg3 ; - lldb::SBFileSpec *arg4 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; @@ -21461,10 +21734,10 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_2(PyObject *se SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; uint32_t arg2 ; uint32_t arg3 ; - lldb::SBFileSpec *arg4 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg4 = 0 ; bool arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21631,7 +21904,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCompileUnit_GetSupportFileAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21666,7 +21939,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetSupportFileAtIndex(PyObject *self, P SWIGINTERN PyObject *_wrap_SBCompileUnit_GetNumSupportFiles(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21694,7 +21967,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetNumSupportFiles(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBCompileUnit_FindSupportFileIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; uint32_t arg2 ; lldb::SBFileSpec *arg3 = 0 ; bool arg4 ; @@ -21748,7 +22021,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_FindSupportFileIndex(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBCompileUnit_GetTypes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21782,7 +22055,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetTypes__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBCompileUnit_GetTypes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBTypeList result; @@ -21850,7 +22123,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetTypes(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBCompileUnit_GetLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -21878,7 +22151,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetLanguage(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBCompileUnit___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; lldb::SBCompileUnit *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21921,7 +22194,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit___eq__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBCompileUnit___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; lldb::SBCompileUnit *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21964,7 +22237,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit___ne__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBCompileUnit_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22002,7 +22275,7 @@ SWIGINTERN PyObject *_wrap_SBCompileUnit_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBCompileUnit___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22117,7 +22390,7 @@ SWIGINTERN PyObject *_wrap_new_SBSaveCoreOptions(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBSaveCoreOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22144,8 +22417,8 @@ SWIGINTERN PyObject *_wrap_delete_SBSaveCoreOptions(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -22182,7 +22455,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetPluginName(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22210,7 +22483,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetPluginName(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetStyle(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; lldb::SaveCoreStyle arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22244,7 +22517,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetStyle(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetStyle(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22272,7 +22545,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetStyle(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetOutputFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; lldb::SBFileSpec arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22314,7 +22587,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetOutputFile(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetOutputFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22342,7 +22615,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetOutputFile(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; lldb::SBProcess arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22385,7 +22658,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetProcess(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_AddThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; lldb::SBThread arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22428,7 +22701,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_AddThread(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_RemoveThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; lldb::SBThread arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22471,7 +22744,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_RemoveThread(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_AddMemoryRegionToSave(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; lldb::SBMemoryRegionInfo *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22509,7 +22782,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_AddMemoryRegionToSave(PyObject *sel SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetThreadsToSave(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22537,7 +22810,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetThreadsToSave(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetCurrentSizeInBytes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22575,7 +22848,7 @@ SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetCurrentSizeInBytes(PyObject *sel SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBSaveCoreOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22689,7 +22962,7 @@ SWIGINTERN PyObject *_wrap_new_SBData(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22716,7 +22989,7 @@ SWIGINTERN PyObject *_wrap_delete_SBData(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetAddressByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22744,7 +23017,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetAddressByteSize(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBData_SetAddressByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; uint8_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22778,7 +23051,7 @@ SWIGINTERN PyObject *_wrap_SBData_SetAddressByteSize(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBData_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22805,7 +23078,7 @@ SWIGINTERN PyObject *_wrap_SBData_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22833,7 +23106,7 @@ SWIGINTERN PyObject *_wrap_SBData___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22861,7 +23134,7 @@ SWIGINTERN PyObject *_wrap_SBData_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22889,7 +23162,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetByteSize(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetByteOrder(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -22917,7 +23190,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetByteOrder(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_SetByteOrder(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::ByteOrder arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -22951,7 +23224,7 @@ SWIGINTERN PyObject *_wrap_SBData_SetByteOrder(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetFloat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -22997,7 +23270,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetFloat(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetDouble(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23043,7 +23316,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetDouble(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetLongDouble(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23089,7 +23362,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetLongDouble(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBData_GetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23135,7 +23408,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetAddress(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt8(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23181,7 +23454,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt8(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt16(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23227,7 +23500,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt16(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt32(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23273,7 +23546,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt32(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt64(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23319,7 +23592,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt64(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBData_GetSignedInt8(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23365,7 +23638,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetSignedInt8(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBData_GetSignedInt16(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23411,7 +23684,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetSignedInt16(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBData_GetSignedInt32(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23457,7 +23730,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetSignedInt32(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBData_GetSignedInt64(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23503,7 +23776,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetSignedInt64(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBData_GetString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; void *argp1 = 0 ; @@ -23549,10 +23822,10 @@ SWIGINTERN PyObject *_wrap_SBData_GetString(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_ReadRawData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::offset_t arg3 ; - void *arg4 = (void *) 0 ; + void *arg4 = 0 ; size_t arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -23621,7 +23894,7 @@ SWIGINTERN PyObject *_wrap_SBData_ReadRawData(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -23666,7 +23939,7 @@ SWIGINTERN PyObject *_wrap_SBData_GetDescription__SWIG_0(PyObject *self, Py_ssiz SWIGINTERN PyObject *_wrap_SBData_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -23755,9 +24028,9 @@ SWIGINTERN PyObject *_wrap_SBData_GetDescription(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBData_SetData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; - void *arg3 = (void *) 0 ; + void *arg3 = 0 ; size_t arg4 ; lldb::ByteOrder arg5 ; uint8_t arg6 ; @@ -23828,9 +24101,9 @@ SWIGINTERN PyObject *_wrap_SBData_SetData(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBData_SetDataWithOwnership(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBError *arg2 = 0 ; - void *arg3 = (void *) 0 ; + void *arg3 = 0 ; size_t arg4 ; lldb::ByteOrder arg5 ; uint8_t arg6 ; @@ -23901,7 +24174,7 @@ SWIGINTERN PyObject *_wrap_SBData_SetDataWithOwnership(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBData_Append(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; lldb::SBData *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -23941,7 +24214,7 @@ SWIGINTERN PyObject *_wrap_SBData_CreateDataFromCString(PyObject *self, PyObject PyObject *resultobj = 0; lldb::ByteOrder arg1 ; uint32_t arg2 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; int val1 ; int ecode1 = 0 ; unsigned int val2 ; @@ -23987,7 +24260,7 @@ SWIGINTERN PyObject *_wrap_SBData_CreateDataFromUInt64Array(PyObject *self, PyOb PyObject *resultobj = 0; lldb::ByteOrder arg1 ; uint32_t arg2 ; - uint64_t *arg3 = (uint64_t *) 0 ; + uint64_t *arg3 = 0 ; size_t arg4 ; int val1 ; int ecode1 = 0 ; @@ -24056,7 +24329,7 @@ SWIGINTERN PyObject *_wrap_SBData_CreateDataFromUInt32Array(PyObject *self, PyOb PyObject *resultobj = 0; lldb::ByteOrder arg1 ; uint32_t arg2 ; - uint32_t *arg3 = (uint32_t *) 0 ; + uint32_t *arg3 = 0 ; size_t arg4 ; int val1 ; int ecode1 = 0 ; @@ -24125,7 +24398,7 @@ SWIGINTERN PyObject *_wrap_SBData_CreateDataFromSInt64Array(PyObject *self, PyOb PyObject *resultobj = 0; lldb::ByteOrder arg1 ; uint32_t arg2 ; - int64_t *arg3 = (int64_t *) 0 ; + int64_t *arg3 = 0 ; size_t arg4 ; int val1 ; int ecode1 = 0 ; @@ -24194,7 +24467,7 @@ SWIGINTERN PyObject *_wrap_SBData_CreateDataFromSInt32Array(PyObject *self, PyOb PyObject *resultobj = 0; lldb::ByteOrder arg1 ; uint32_t arg2 ; - int32_t *arg3 = (int32_t *) 0 ; + int32_t *arg3 = 0 ; size_t arg4 ; int val1 ; int ecode1 = 0 ; @@ -24263,7 +24536,7 @@ SWIGINTERN PyObject *_wrap_SBData_CreateDataFromDoubleArray(PyObject *self, PyOb PyObject *resultobj = 0; lldb::ByteOrder arg1 ; uint32_t arg2 ; - double *arg3 = (double *) 0 ; + double *arg3 = 0 ; size_t arg4 ; int val1 ; int ecode1 = 0 ; @@ -24330,8 +24603,8 @@ SWIGINTERN PyObject *_wrap_SBData_CreateDataFromDoubleArray(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBData_SetDataFromCString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBData *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -24368,8 +24641,8 @@ SWIGINTERN PyObject *_wrap_SBData_SetDataFromCString(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBData_SetDataFromUInt64Array(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; - uint64_t *arg2 = (uint64_t *) 0 ; + lldb::SBData *arg1 = 0 ; + uint64_t *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24429,8 +24702,8 @@ SWIGINTERN PyObject *_wrap_SBData_SetDataFromUInt64Array(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBData_SetDataFromUInt32Array(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; - uint32_t *arg2 = (uint32_t *) 0 ; + lldb::SBData *arg1 = 0 ; + uint32_t *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24490,8 +24763,8 @@ SWIGINTERN PyObject *_wrap_SBData_SetDataFromUInt32Array(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBData_SetDataFromSInt64Array(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; - int64_t *arg2 = (int64_t *) 0 ; + lldb::SBData *arg1 = 0 ; + int64_t *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24551,8 +24824,8 @@ SWIGINTERN PyObject *_wrap_SBData_SetDataFromSInt64Array(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBData_SetDataFromSInt32Array(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; - int32_t *arg2 = (int32_t *) 0 ; + lldb::SBData *arg1 = 0 ; + int32_t *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24612,8 +24885,8 @@ SWIGINTERN PyObject *_wrap_SBData_SetDataFromSInt32Array(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBData_SetDataFromDoubleArray(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; - double *arg2 = (double *) 0 ; + lldb::SBData *arg1 = 0 ; + double *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24673,7 +24946,7 @@ SWIGINTERN PyObject *_wrap_SBData_SetDataFromDoubleArray(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBData___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -24788,7 +25061,7 @@ SWIGINTERN PyObject *_wrap_new_SBDebugger(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBDebugger(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -24861,7 +25134,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SupportsLanguage(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -25153,8 +25426,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_Create__SWIG_1(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBDebugger_Create__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; bool arg1 ; - lldb::LogOutputCallback arg2 = (lldb::LogOutputCallback) 0 ; - void *arg3 = (void *) 0 ; + lldb::LogOutputCallback arg2 = 0 ; + void *arg3 = 0 ; bool val1 ; int ecode1 = 0 ; lldb::SBDebugger result; @@ -25295,7 +25568,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_MemoryPressureDetected(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBDebugger___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -25323,7 +25596,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger___nonzero__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBDebugger_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -25351,7 +25624,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBDebugger_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -25378,8 +25651,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBDebugger_GetSetting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -25415,7 +25688,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetSetting__SWIG_0(PyObject *self, Py_ssiz SWIGINTERN PyObject *_wrap_SBDebugger_GetSetting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBStructuredData result; @@ -25481,7 +25754,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetSetting(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDebugger_SetAsync(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25515,7 +25788,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetAsync(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBDebugger_GetAsync(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -25543,7 +25816,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetAsync(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBDebugger_SkipLLDBInitFiles(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25577,7 +25850,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SkipLLDBInitFiles(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_SkipAppInitFiles(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25611,8 +25884,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SkipAppInitFiles(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_SetInputString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -25649,7 +25922,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetInputString(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDebugger_SetInputFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25691,7 +25964,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetInputFile__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBDebugger_SetOutputFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25733,7 +26006,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetOutputFile__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBDebugger_SetErrorFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25775,7 +26048,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetErrorFile__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBDebugger_SetInputFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25863,7 +26136,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetInputFile(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDebugger_SetOutputFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -25951,7 +26224,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetOutputFile(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBDebugger_SetErrorFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -26039,7 +26312,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetErrorFile(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDebugger_GetInputFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26067,7 +26340,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetInputFile(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDebugger_GetOutputFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26095,7 +26368,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetOutputFile(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBDebugger_GetErrorFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26123,7 +26396,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetErrorFile(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDebugger_SaveInputTerminalState(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26150,7 +26423,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SaveInputTerminalState(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBDebugger_RestoreInputTerminalState(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26177,7 +26450,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_RestoreInputTerminalState(PyObject *self, SWIGINTERN PyObject *_wrap_SBDebugger_GetCommandInterpreter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26205,8 +26478,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetCommandInterpreter(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBDebugger_HandleCommand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -26242,7 +26515,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_HandleCommand(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBDebugger_RequestInterrupt(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26269,7 +26542,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_RequestInterrupt(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_CancelInterruptRequest(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26296,7 +26569,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_CancelInterruptRequest(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBDebugger_InterruptRequested(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26324,7 +26597,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_InterruptRequested(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_GetListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26352,7 +26625,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetListener(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBDebugger_HandleProcessEvent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBProcess *arg2 = 0 ; lldb::SBEvent *arg3 = 0 ; lldb::SBFile arg4 ; @@ -26431,7 +26704,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_HandleProcessEvent__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBDebugger_HandleProcessEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBProcess *arg2 = 0 ; lldb::SBEvent *arg3 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg4 ; @@ -26584,10 +26857,10 @@ SWIGINTERN PyObject *_wrap_SBDebugger_HandleProcessEvent(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_CreateTarget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - char *arg4 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + char *arg4 = 0 ; bool arg5 ; lldb::SBError *arg6 = 0 ; void *argp1 = 0 ; @@ -26662,9 +26935,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_CreateTarget__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBDebugger_CreateTargetWithFileAndTargetTriple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -26711,9 +26984,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_CreateTargetWithFileAndTargetTriple(PyObje SWIGINTERN PyObject *_wrap_SBDebugger_CreateTargetWithFileAndArch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -26760,8 +27033,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_CreateTargetWithFileAndArch(PyObject *self SWIGINTERN PyObject *_wrap_SBDebugger_CreateTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -26860,7 +27133,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_CreateTarget(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDebugger_GetDummyTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -26888,7 +27161,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetDummyTarget(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDebugger_DeleteTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -26926,7 +27199,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_DeleteTarget(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDebugger_GetTargetAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -26961,7 +27234,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetTargetAtIndex(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetIndexOfTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27004,7 +27277,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetIndexOfTarget(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_FindTargetWithProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::pid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27039,9 +27312,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_FindTargetWithProcessID(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBDebugger_FindTargetWithFileAndArch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -27088,7 +27361,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_FindTargetWithFileAndArch(PyObject *self, SWIGINTERN PyObject *_wrap_SBDebugger_GetNumTargets(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27116,7 +27389,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetNumTargets(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBDebugger_GetSelectedTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27144,7 +27417,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetSelectedTarget(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_SetSelectedTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27181,7 +27454,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetSelectedTarget(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetSelectedPlatform(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27209,7 +27482,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetSelectedPlatform(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBDebugger_SetSelectedPlatform(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBPlatform *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27246,7 +27519,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetSelectedPlatform(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBDebugger_GetNumPlatforms(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27274,7 +27547,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetNumPlatforms(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBDebugger_GetPlatformAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27309,7 +27582,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetPlatformAtIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_GetNumAvailablePlatforms(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27337,7 +27610,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetNumAvailablePlatforms(PyObject *self, P SWIGINTERN PyObject *_wrap_SBDebugger_GetAvailablePlatformInfoAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27372,7 +27645,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetAvailablePlatformInfoAtIndex(PyObject * SWIGINTERN PyObject *_wrap_SBDebugger_GetSourceManager(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27400,8 +27673,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetSourceManager(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_SetCurrentPlatform(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -27438,8 +27711,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetCurrentPlatform(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_SetCurrentPlatformSDKRoot(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -27476,7 +27749,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetCurrentPlatformSDKRoot(PyObject *self, SWIGINTERN PyObject *_wrap_SBDebugger_SetUseExternalEditor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27511,7 +27784,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetUseExternalEditor(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBDebugger_GetUseExternalEditor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27539,7 +27812,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetUseExternalEditor(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBDebugger_SetUseColor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27574,7 +27847,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetUseColor(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBDebugger_GetUseColor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27602,7 +27875,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetUseColor(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBDebugger_SetShowInlineDiagnostics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27637,7 +27910,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetShowInlineDiagnostics(PyObject *self, P SWIGINTERN PyObject *_wrap_SBDebugger_SetUseSourceCache(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27672,7 +27945,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetUseSourceCache(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetUseSourceCache(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27700,7 +27973,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetUseSourceCache(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetDefaultArchitecture(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; size_t arg2 ; int res1 ; char *buf1 = 0 ; @@ -27738,7 +28011,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetDefaultArchitecture(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBDebugger_SetDefaultArchitecture(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -27769,8 +28042,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetDefaultArchitecture(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptingLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -27807,7 +28080,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptingLanguage(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptInterpreterInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::ScriptLanguage arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27977,9 +28250,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_StateIsStoppedState(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBDebugger_EnableLog(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; - char **arg3 = (char **) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; + char **arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -28046,9 +28319,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_EnableLog(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDebugger_SetLoggingCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - lldb::LogOutputCallback arg2 = (lldb::LogOutputCallback) 0 ; - void *arg3 = (void *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + lldb::LogOutputCallback arg2 = 0 ; + void *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; @@ -28091,9 +28364,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetLoggingCallback(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_SetDestroyCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - lldb::SBDebuggerDestroyCallback arg2 = (lldb::SBDebuggerDestroyCallback) 0 ; - void *arg3 = (void *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + lldb::SBDebuggerDestroyCallback arg2 = 0 ; + void *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; @@ -28136,9 +28409,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetDestroyCallback(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_AddDestroyCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - lldb::SBDebuggerDestroyCallback arg2 = (lldb::SBDebuggerDestroyCallback) 0 ; - void *arg3 = (void *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + lldb::SBDebuggerDestroyCallback arg2 = 0 ; + void *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; @@ -28182,7 +28455,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_AddDestroyCallback(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_RemoveDestroyCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::callback_token_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28217,8 +28490,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_RemoveDestroyCallback(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInput(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - void *arg2 = (void *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + void *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28263,7 +28536,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInput(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInputInterrupt(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28290,7 +28563,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInputInterrupt(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInputEndOfFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28317,7 +28590,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInputEndOfFile(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBDebugger_GetInstanceName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28373,9 +28646,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_FindDebuggerWithID(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_SetInternalVariable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + char *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -28425,8 +28698,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetInternalVariable(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBDebugger_GetInternalVariableValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; + char *arg1 = 0 ; + char *arg2 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -28466,7 +28739,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetInternalVariableValue(PyObject *self, P SWIGINTERN PyObject *_wrap_SBDebugger_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28504,7 +28777,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetDescription(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDebugger_GetTerminalWidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28532,7 +28805,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetTerminalWidth(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_SetTerminalWidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28566,7 +28839,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetTerminalWidth(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetTerminalHeight(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28594,7 +28867,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetTerminalHeight(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_SetTerminalHeight(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28628,7 +28901,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetTerminalHeight(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28656,7 +28929,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBDebugger_GetPrompt(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28684,8 +28957,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetPrompt(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDebugger_SetPrompt(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -28721,7 +28994,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetPrompt(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDebugger_GetReproducerPath(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28749,7 +29022,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetReproducerPath(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28777,7 +29050,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptLanguage(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_SetScriptLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::ScriptLanguage arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28811,7 +29084,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetScriptLanguage(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetREPLLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28839,7 +29112,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetREPLLanguage(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBDebugger_SetREPLLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::LanguageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28873,7 +29146,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetREPLLanguage(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBDebugger_GetCloseInputOnEOF(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28901,7 +29174,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetCloseInputOnEOF(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_SetCloseInputOnEOF(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28935,8 +29208,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_SetCloseInputOnEOF(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_GetCategory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -28972,7 +29245,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetCategory__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBDebugger_GetCategory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::LanguageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -29052,8 +29325,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetCategory(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBDebugger_CreateCategory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -29090,8 +29363,8 @@ SWIGINTERN PyObject *_wrap_SBDebugger_CreateCategory(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDebugger_DeleteCategory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBDebugger *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -29128,7 +29401,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_DeleteCategory(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDebugger_GetNumCategories(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29156,7 +29429,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetNumCategories(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetCategoryAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -29191,7 +29464,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetCategoryAtIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_GetDefaultCategory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29219,7 +29492,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetDefaultCategory(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_GetFormatForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -29262,7 +29535,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetFormatForType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetSummaryForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -29305,7 +29578,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetSummaryForType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetFilterForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -29348,7 +29621,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetFilterForType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger_GetSyntheticForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -29391,7 +29664,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetSyntheticForType(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBDebugger_ResetStatistics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29418,7 +29691,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_ResetStatistics(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBDebugger_RunCommandInterpreter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; bool arg2 ; bool arg3 ; lldb::SBCommandInterpreterRunOptions *arg4 = 0 ; @@ -29528,9 +29801,9 @@ SWIGINTERN PyObject *_wrap_SBDebugger_RunCommandInterpreter(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBDebugger_RunREPL(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::LanguageType arg2 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -29574,7 +29847,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_RunREPL(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBDebugger_LoadTraceFromFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; void *argp1 = 0 ; @@ -29623,7 +29896,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_LoadTraceFromFile(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDebugger___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29651,7 +29924,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger___repr__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBDebugger_GetInputFileHandle(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29692,7 +29965,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetInputFileHandle(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBDebugger_GetOutputFileHandle(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29733,7 +30006,7 @@ SWIGINTERN PyObject *_wrap_SBDebugger_GetOutputFileHandle(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBDebugger_GetErrorFileHandle(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebugger *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29861,7 +30134,7 @@ SWIGINTERN PyObject *_wrap_new_SBDeclaration(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBDeclaration(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29888,7 +30161,7 @@ SWIGINTERN PyObject *_wrap_delete_SBDeclaration(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDeclaration___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29916,7 +30189,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDeclaration_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29944,7 +30217,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDeclaration_GetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -29972,7 +30245,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_GetFileSpec(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDeclaration_GetLine(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30000,7 +30273,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_GetLine(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDeclaration_GetColumn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30028,7 +30301,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_GetColumn(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDeclaration_SetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; lldb::SBFileSpec arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -30070,7 +30343,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_SetFileSpec(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBDeclaration_SetLine(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -30104,7 +30377,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_SetLine(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDeclaration_SetColumn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -30138,7 +30411,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_SetColumn(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBDeclaration___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; lldb::SBDeclaration *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -30181,7 +30454,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration___eq__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDeclaration___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; lldb::SBDeclaration *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -30224,7 +30497,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration___ne__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBDeclaration_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -30262,7 +30535,7 @@ SWIGINTERN PyObject *_wrap_SBDeclaration_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBDeclaration___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30348,7 +30621,7 @@ SWIGINTERN PyObject *_wrap_new_SBError__SWIG_1(PyObject *self, Py_ssize_t nobjs, SWIGINTERN PyObject *_wrap_new_SBError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -30415,7 +30688,7 @@ SWIGINTERN PyObject *_wrap_new_SBError(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30442,7 +30715,7 @@ SWIGINTERN PyObject *_wrap_delete_SBError(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_GetCString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30470,7 +30743,7 @@ SWIGINTERN PyObject *_wrap_SBError_GetCString(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30497,7 +30770,7 @@ SWIGINTERN PyObject *_wrap_SBError_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_Fail(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30525,7 +30798,7 @@ SWIGINTERN PyObject *_wrap_SBError_Fail(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_Success(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30553,7 +30826,7 @@ SWIGINTERN PyObject *_wrap_SBError_Success(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_GetError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30581,7 +30854,7 @@ SWIGINTERN PyObject *_wrap_SBError_GetError(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_GetErrorData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30609,7 +30882,7 @@ SWIGINTERN PyObject *_wrap_SBError_GetErrorData(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBError_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30637,7 +30910,7 @@ SWIGINTERN PyObject *_wrap_SBError_GetType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_SetError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; uint32_t arg2 ; lldb::ErrorType arg3 ; void *argp1 = 0 ; @@ -30679,7 +30952,7 @@ SWIGINTERN PyObject *_wrap_SBError_SetError(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_SetErrorToErrno(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30706,7 +30979,7 @@ SWIGINTERN PyObject *_wrap_SBError_SetErrorToErrno(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBError_SetErrorToGenericError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -30733,8 +31006,8 @@ SWIGINTERN PyObject *_wrap_SBError_SetErrorToGenericError(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBError_SetErrorString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBError *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -30770,11 +31043,11 @@ SWIGINTERN PyObject *_wrap_SBError_SetErrorString(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - char *arg4 = (char *) 0 ; - char *arg5 = (char *) 0 ; + lldb::SBError *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + char *arg4 = 0 ; + char *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -30840,10 +31113,10 @@ SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - char *arg4 = (char *) 0 ; + lldb::SBError *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + char *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -30899,9 +31172,9 @@ SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_1(PyObject *se SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBError *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -30947,8 +31220,8 @@ SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_2(PyObject *se SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBError *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -31080,7 +31353,7 @@ SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBError___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31108,7 +31381,7 @@ SWIGINTERN PyObject *_wrap_SBError___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31136,7 +31409,7 @@ SWIGINTERN PyObject *_wrap_SBError_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBError_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -31174,7 +31447,7 @@ SWIGINTERN PyObject *_wrap_SBError_GetDescription(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBError___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBError *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31289,7 +31562,7 @@ SWIGINTERN PyObject *_wrap_new_SBEnvironment(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBEnvironment(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31316,8 +31589,8 @@ SWIGINTERN PyObject *_wrap_delete_SBEnvironment(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBEnvironment_Get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -31354,7 +31627,7 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_Get(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBEnvironment_GetNumValues(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31382,7 +31655,7 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_GetNumValues(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBEnvironment_GetNameAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -31417,7 +31690,7 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_GetNameAtIndex(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBEnvironment_GetValueAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -31452,7 +31725,7 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_GetValueAtIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBEnvironment_GetEntries(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31480,8 +31753,8 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_GetEntries(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBEnvironment_PutEntry(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -31517,7 +31790,7 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_PutEntry(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBEnvironment_SetEntries(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -31562,9 +31835,9 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_SetEntries(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBEnvironment_Set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -31619,8 +31892,8 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_Set(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBEnvironment_Unset(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -31657,7 +31930,7 @@ SWIGINTERN PyObject *_wrap_SBEnvironment_Unset(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBEnvironment_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBEnvironment *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31743,7 +32016,7 @@ SWIGINTERN PyObject *_wrap_new_SBEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, SWIGINTERN PyObject *_wrap_new_SBEvent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; uint32_t arg1 ; - char *arg2 = (char *) 0 ; + char *arg2 = 0 ; uint32_t arg3 ; unsigned int val1 ; int ecode1 = 0 ; @@ -31841,7 +32114,7 @@ SWIGINTERN PyObject *_wrap_new_SBEvent(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBEvent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31868,7 +32141,7 @@ SWIGINTERN PyObject *_wrap_delete_SBEvent(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBEvent___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31896,7 +32169,7 @@ SWIGINTERN PyObject *_wrap_SBEvent___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBEvent_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31924,7 +32197,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBEvent_GetDataFlavor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31952,7 +32225,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_GetDataFlavor(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBEvent_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -31980,7 +32253,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_GetType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBEvent_GetBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32008,7 +32281,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_GetBroadcaster(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBEvent_GetBroadcasterClass(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32036,7 +32309,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_GetBroadcasterClass(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBEvent_BroadcasterMatchesRef(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -32074,7 +32347,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_BroadcasterMatchesRef(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBEvent_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32132,7 +32405,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_GetCStringFromEvent(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBEvent_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -32169,7 +32442,7 @@ SWIGINTERN PyObject *_wrap_SBEvent_GetDescription__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBEvent_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBEvent *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -32496,7 +32769,7 @@ SWIGINTERN PyObject *_wrap_new_SBExecutionContext(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_delete_SBExecutionContext(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBExecutionContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32523,7 +32796,7 @@ SWIGINTERN PyObject *_wrap_delete_SBExecutionContext(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBExecutionContext_GetTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBExecutionContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32551,7 +32824,7 @@ SWIGINTERN PyObject *_wrap_SBExecutionContext_GetTarget(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBExecutionContext_GetProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBExecutionContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32579,7 +32852,7 @@ SWIGINTERN PyObject *_wrap_SBExecutionContext_GetProcess(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBExecutionContext_GetThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBExecutionContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32607,7 +32880,7 @@ SWIGINTERN PyObject *_wrap_SBExecutionContext_GetThread(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBExecutionContext_GetFrame(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBExecutionContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32722,7 +32995,7 @@ SWIGINTERN PyObject *_wrap_new_SBExpressionOptions(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_delete_SBExpressionOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32749,7 +33022,7 @@ SWIGINTERN PyObject *_wrap_delete_SBExpressionOptions(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetCoerceResultToId(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32777,7 +33050,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetCoerceResultToId(PyObject *sel SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -32810,7 +33083,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -32877,7 +33150,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetCoerceResultToId(PyObject *sel SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetUnwindOnError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -32905,7 +33178,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetUnwindOnError(PyObject *self, SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -32938,7 +33211,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetUnwindOnError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33005,7 +33278,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetUnwindOnError(PyObject *self, SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetIgnoreBreakpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -33033,7 +33306,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetIgnoreBreakpoints(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33066,7 +33339,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(PyOb SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33133,7 +33406,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetIgnoreBreakpoints(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetFetchDynamicValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -33161,7 +33434,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetFetchDynamicValue(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; lldb::DynamicValueType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33194,7 +33467,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(PyOb SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33261,7 +33534,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetFetchDynamicValue(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTimeoutInMicroSeconds(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -33289,7 +33562,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTimeoutInMicroSeconds(PyObject SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33322,7 +33595,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0( SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33389,7 +33662,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTimeoutInMicroSeconds(PyObject SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -33417,7 +33690,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33450,7 +33723,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33517,7 +33790,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTryAllThreads(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -33545,7 +33818,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTryAllThreads(PyObject *self, SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33578,7 +33851,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTryAllThreads__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33645,7 +33918,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTryAllThreads(PyObject *self, SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetStopOthers(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -33673,7 +33946,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetStopOthers(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetStopOthers__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33706,7 +33979,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetStopOthers__SWIG_0(PyObject *s SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetStopOthers__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33773,7 +34046,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetStopOthers(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTrapExceptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -33801,7 +34074,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTrapExceptions(PyObject *self, SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33834,7 +34107,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(PyObjec SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTrapExceptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33901,7 +34174,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTrapExceptions(PyObject *self, SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetLanguage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; lldb::LanguageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -33934,7 +34207,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetLanguage__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetLanguage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; lldb::SBSourceLanguageName arg2 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -34029,7 +34302,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetLanguage(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetPlaygroundTransformEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34057,7 +34330,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetPlaygroundTransformEnabled(PyO SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformEnabled__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34090,7 +34363,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformEnabled__SW SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformEnabled__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34157,7 +34430,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformEnabled(PyO SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetPlaygroundTransformHighPerformance(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34185,7 +34458,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetPlaygroundTransformHighPerform SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformHighPerformance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34218,7 +34491,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformHighPerform SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformHighPerformance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34285,7 +34558,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPlaygroundTransformHighPerform SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetREPLMode(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34313,7 +34586,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetREPLMode(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetREPLMode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34346,7 +34619,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetREPLMode__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetREPLMode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34413,7 +34686,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetREPLMode(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetGenerateDebugInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34441,7 +34714,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetGenerateDebugInfo(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34474,7 +34747,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(PyOb SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34541,7 +34814,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetGenerateDebugInfo(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetSuppressPersistentResult(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34569,7 +34842,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetSuppressPersistentResult(PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34602,7 +34875,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34669,7 +34942,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetSuppressPersistentResult(PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetPrefix(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34697,8 +34970,8 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetPrefix(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPrefix(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -34734,7 +35007,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPrefix(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34767,7 +35040,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(PyObje SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34834,7 +35107,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAutoApplyFixIts(PyObject *self SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetAutoApplyFixIts(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34862,7 +35135,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetAutoApplyFixIts(PyObject *self SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetRetriesWithFixIts(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34896,7 +35169,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetRetriesWithFixIts(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetRetriesWithFixIts(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34924,7 +35197,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetRetriesWithFixIts(PyObject *se SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTopLevel(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -34952,7 +35225,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTopLevel(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTopLevel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -34985,7 +35258,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTopLevel__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTopLevel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -35052,7 +35325,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTopLevel(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetAllowJIT(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35080,7 +35353,7 @@ SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetAllowJIT(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAllowJIT(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBExpressionOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -35174,7 +35447,7 @@ SWIGINTERN PyObject *_wrap_new_SBFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, SWIGINTERN PyObject *_wrap_new_SBFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - char *arg2 = (char *) 0 ; + char *arg2 = 0 ; bool arg3 ; int val1 ; int ecode1 = 0 ; @@ -35274,7 +35547,7 @@ SWIGINTERN PyObject *_wrap_new_SBFile(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBFile *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35301,10 +35574,10 @@ SWIGINTERN PyObject *_wrap_delete_SBFile(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFile_Read(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; - uint8_t *arg2 = (uint8_t *) 0 ; + lldb::SBFile *arg1 = 0 ; + uint8_t *arg2 = 0 ; size_t arg3 ; - size_t *arg4 = (size_t *) 0 ; + size_t *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; Py_buffer_RAII view2 ; @@ -35355,10 +35628,10 @@ SWIGINTERN PyObject *_wrap_SBFile_Read(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFile_Write(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; - uint8_t *arg2 = (uint8_t *) 0 ; + lldb::SBFile *arg1 = 0 ; + uint8_t *arg2 = 0 ; size_t arg3 ; - size_t *arg4 = (size_t *) 0 ; + size_t *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; Py_buffer_RAII view2 ; @@ -35409,7 +35682,7 @@ SWIGINTERN PyObject *_wrap_SBFile_Write(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFile_Flush(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBFile *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35437,7 +35710,7 @@ SWIGINTERN PyObject *_wrap_SBFile_Flush(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFile_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBFile *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35465,7 +35738,7 @@ SWIGINTERN PyObject *_wrap_SBFile_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFile_Close(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBFile *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35493,7 +35766,7 @@ SWIGINTERN PyObject *_wrap_SBFile_Close(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFile___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBFile *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35521,7 +35794,7 @@ SWIGINTERN PyObject *_wrap_SBFile___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFile_GetFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBFile *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35719,7 +35992,7 @@ SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_1(PyObject *self, Py_ssize_t nob SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -35748,7 +36021,7 @@ SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_2(PyObject *self, Py_ssize_t nob SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; bool arg2 ; int res1 ; char *buf1 = 0 ; @@ -35838,7 +36111,7 @@ SWIGINTERN PyObject *_wrap_new_SBFileSpec(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35865,7 +36138,7 @@ SWIGINTERN PyObject *_wrap_delete_SBFileSpec(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFileSpec___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -35893,7 +36166,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec___nonzero__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFileSpec___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -35936,7 +36209,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFileSpec___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -35979,7 +36252,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFileSpec_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36007,7 +36280,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFileSpec_Exists(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36035,7 +36308,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_Exists(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFileSpec_ResolveExecutableLocation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36063,7 +36336,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_ResolveExecutableLocation(PyObject *self, SWIGINTERN PyObject *_wrap_SBFileSpec_GetFilename(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36091,7 +36364,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_GetFilename(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFileSpec_GetDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36119,8 +36392,8 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_GetDirectory(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBFileSpec_SetFilename(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -36156,8 +36429,8 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_SetFilename(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFileSpec_SetDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -36193,8 +36466,8 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_SetDirectory(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBFileSpec_GetPath(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -36239,8 +36512,8 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_GetPath(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFileSpec_ResolvePath(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; + char *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; int res1 ; char *buf1 = 0 ; @@ -36288,7 +36561,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_ResolvePath(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFileSpec_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -36326,8 +36599,8 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_GetDescription(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBFileSpec_AppendPathComponent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -36363,7 +36636,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpec_AppendPathComponent(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBFileSpec___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36478,7 +36751,7 @@ SWIGINTERN PyObject *_wrap_new_SBFileSpecList(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBFileSpecList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36505,7 +36778,7 @@ SWIGINTERN PyObject *_wrap_delete_SBFileSpecList(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFileSpecList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36533,7 +36806,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpecList_GetSize(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFileSpecList_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -36571,7 +36844,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpecList_GetDescription(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBFileSpecList_Append(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -36608,7 +36881,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpecList_Append(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFileSpecList_AppendIfUnique(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -36646,7 +36919,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpecList_AppendIfUnique(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBFileSpecList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36673,7 +36946,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpecList_Clear(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFileSpecList_FindFileIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; uint32_t arg2 ; lldb::SBFileSpec *arg3 = 0 ; bool arg4 ; @@ -36727,7 +37000,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpecList_FindFileIndex(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBFileSpecList_GetFileSpecAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -36762,7 +37035,7 @@ SWIGINTERN PyObject *_wrap_SBFileSpecList_GetFileSpecAtIndex(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBFileSpecList___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpecList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36819,7 +37092,7 @@ SWIGINTERN PyObject *_wrap_new_SBFormat__SWIG_0(PyObject *self, Py_ssize_t nobjs SWIGINTERN PyObject *_wrap_new_SBFormat__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; lldb::SBError *arg2 = 0 ; int res1 ; char *buf1 = 0 ; @@ -36931,7 +37204,7 @@ SWIGINTERN PyObject *_wrap_new_SBFormat(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFormat *arg1 = (lldb::SBFormat *) 0 ; + lldb::SBFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -36958,7 +37231,7 @@ SWIGINTERN PyObject *_wrap_delete_SBFormat(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFormat___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFormat *arg1 = (lldb::SBFormat *) 0 ; + lldb::SBFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37073,7 +37346,7 @@ SWIGINTERN PyObject *_wrap_new_SBFrame(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBFrame(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37100,7 +37373,7 @@ SWIGINTERN PyObject *_wrap_delete_SBFrame(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_IsEqual(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -37138,7 +37411,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsEqual(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37166,7 +37439,7 @@ SWIGINTERN PyObject *_wrap_SBFrame___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37194,7 +37467,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetFrameID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37222,7 +37495,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetFrameID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetCFA(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37250,7 +37523,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetCFA(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetPC(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37278,7 +37551,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetPC(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_SetPC(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -37313,7 +37586,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_SetPC(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetSP(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37341,7 +37614,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetSP(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetFP(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37369,7 +37642,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetFP(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetPCAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37397,7 +37670,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetPCAddress(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_GetSymbolContext(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -37432,7 +37705,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetSymbolContext(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBFrame_GetModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37460,7 +37733,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetModule(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetCompileUnit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37488,7 +37761,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetCompileUnit(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFrame_GetFunction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37516,7 +37789,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetFunction(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetSymbol(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37544,7 +37817,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetSymbol(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37572,7 +37845,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetBlock(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetFunctionName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; char *result = 0 ; @@ -37598,7 +37871,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetFunctionName__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBFrame_GetDisplayFunctionName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37626,7 +37899,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetDisplayFunctionName(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBFrame_GetFunctionName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; char *result = 0 ; @@ -37688,7 +37961,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetFunctionName(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBFrame_GuessLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37716,7 +37989,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GuessLanguage(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_IsSwiftThunk(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37744,7 +38017,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsSwiftThunk(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_IsInlined__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -37770,7 +38043,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsInlined__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBFrame_IsInlined__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -37832,7 +38105,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsInlined(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_IsArtificial__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -37858,7 +38131,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsArtificial__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBFrame_IsArtificial__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -37920,7 +38193,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsArtificial(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_IsSynthetic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37948,7 +38221,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsSynthetic(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_IsHidden(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -37976,8 +38249,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_IsHidden(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -38013,8 +38286,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; lldb::DynamicValueType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -38058,8 +38331,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_1(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; lldb::DynamicValueType arg3 ; bool arg4 ; void *argp1 = 0 ; @@ -38111,8 +38384,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_2(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBExpressionOptions *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -38253,7 +38526,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBFrame_GetLanguageSpecificData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -38281,7 +38554,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetLanguageSpecificData(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBFrame_GetFrameBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -38309,7 +38582,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetFrameBlock(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_GetLineEntry(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -38337,7 +38610,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetLineEntry(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_GetThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -38365,7 +38638,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetThread(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_Disassemble(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -38393,7 +38666,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_Disassemble(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -38420,7 +38693,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -38463,7 +38736,7 @@ SWIGINTERN PyObject *_wrap_SBFrame___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -38506,7 +38779,7 @@ SWIGINTERN PyObject *_wrap_SBFrame___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; bool arg2 ; bool arg3 ; bool arg4 ; @@ -38564,7 +38837,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; bool arg2 ; bool arg3 ; bool arg4 ; @@ -38630,7 +38903,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_1(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; lldb::SBVariablesOptions *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -38771,7 +39044,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetVariables(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_GetRegisters(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -38799,8 +39072,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetRegisters(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_FindRegister(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -38837,8 +39110,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_FindRegister(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_FindVariable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -38874,8 +39147,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_FindVariable__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBFrame_FindVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; lldb::DynamicValueType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -38969,8 +39242,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_FindVariable(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFrame_GetValueForVariablePath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; lldb::DynamicValueType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -39014,8 +39287,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetValueForVariablePath__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBFrame_GetValueForVariablePath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -39101,8 +39374,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetValueForVariablePath(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBFrame_FindValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; lldb::ValueType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -39146,8 +39419,8 @@ SWIGINTERN PyObject *_wrap_SBFrame_FindValue__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBFrame_FindValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBFrame *arg1 = 0 ; + char *arg2 = 0 ; lldb::ValueType arg3 ; lldb::DynamicValueType arg4 ; void *argp1 = 0 ; @@ -39261,7 +39534,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_FindValue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFrame_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -39299,7 +39572,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetDescription(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFrame_GetDescriptionWithFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; lldb::SBFormat *arg2 = 0 ; lldb::SBStream *arg3 = 0 ; void *argp1 = 0 ; @@ -39348,7 +39621,7 @@ SWIGINTERN PyObject *_wrap_SBFrame_GetDescriptionWithFormat(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBFrame___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39385,6 +39658,356 @@ SWIGINTERN PyObject *SBFrame_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } +SWIGINTERN PyObject *_wrap_new_SBFrameList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + lldb::SBFrameList *result = 0 ; + + (void)self; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (lldb::SBFrameList *)new lldb::SBFrameList(); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SBFrameList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + lldb::SBFrameList *result = 0 ; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFrameList, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFrameList" "', argument " "1"" of type '" "lldb::SBFrameList const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFrameList" "', argument " "1"" of type '" "lldb::SBFrameList const &""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (lldb::SBFrameList *)new lldb::SBFrameList((lldb::SBFrameList const &)*arg1); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SBFrameList(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFrameList", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SBFrameList__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_SBFrameList__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFrameList'.\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBFrameList::SBFrameList()\n" + " lldb::SBFrameList::SBFrameList(lldb::SBFrameList const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_SBFrameList(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFrameList" "', argument " "1"" of type '" "lldb::SBFrameList *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + delete arg1; + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList___nonzero__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList___nonzero__" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (bool)((lldb::SBFrameList const *)arg1)->operator bool(); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList_IsValid(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_IsValid" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (bool)((lldb::SBFrameList const *)arg1)->IsValid(); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList_GetSize(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint32_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetSize" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (uint32_t)((lldb::SBFrameList const *)arg1)->GetSize(); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList_GetFrameAtIndex(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + uint32_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + lldb::SBFrame result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SBFrameList_GetFrameAtIndex", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetFrameAtIndex" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFrameList_GetFrameAtIndex" "', argument " "2"" of type '" "uint32_t""'"); + } + arg2 = static_cast< uint32_t >(val2); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = ((lldb::SBFrameList const *)arg1)->GetFrameAtIndex(arg2); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList_GetThread(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + lldb::SBThread result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetThread" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = ((lldb::SBFrameList const *)arg1)->GetThread(); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList_Clear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_Clear" "', argument " "1"" of type '" "lldb::SBFrameList *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + (arg1)->Clear(); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList_GetDescription(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + lldb::SBStream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SBFrameList_GetDescription", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetDescription" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrameList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrameList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); + } + arg2 = reinterpret_cast< lldb::SBStream * >(argp2); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (bool)((lldb::SBFrameList const *)arg1)->GetDescription(*arg2); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBFrameList___str__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBFrameList *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList___str__" "', argument " "1"" of type '" "lldb::SBFrameList *""'"); + } + arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1); + result = lldb_SBFrameList___str__(arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SBFrameList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj = NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFrameList, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SBFrameList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_SBFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; lldb::SBFunction *result = 0 ; @@ -39463,7 +40086,7 @@ SWIGINTERN PyObject *_wrap_new_SBFunction(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBFunction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39490,7 +40113,7 @@ SWIGINTERN PyObject *_wrap_delete_SBFunction(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFunction___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39518,7 +40141,7 @@ SWIGINTERN PyObject *_wrap_SBFunction___nonzero__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFunction_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39546,7 +40169,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFunction_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39574,7 +40197,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFunction_GetDisplayName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39602,7 +40225,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetDisplayName(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBFunction_GetMangledName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39630,7 +40253,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetMangledName(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBFunction_GetInstructions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -39672,9 +40295,9 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetInstructions__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBFunction_GetInstructions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; lldb::SBTarget arg2 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; @@ -39773,7 +40396,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetInstructions(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBFunction_GetStartAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39801,7 +40424,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetStartAddress(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBFunction_GetEndAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39829,7 +40452,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetEndAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBFunction_GetRanges(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39857,7 +40480,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetRanges(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBFunction_GetArgumentName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -39892,7 +40515,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetArgumentName(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBFunction_GetPrologueByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39920,7 +40543,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetPrologueByteSize(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBFunction_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39948,7 +40571,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFunction_GetBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -39976,7 +40599,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetBlock(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFunction_GetLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40004,7 +40627,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetLanguage(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFunction_GetIsOptimized(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40032,7 +40655,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetIsOptimized(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBFunction_GetCanThrow(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40060,7 +40683,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetCanThrow(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBFunction___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; lldb::SBFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40103,7 +40726,7 @@ SWIGINTERN PyObject *_wrap_SBFunction___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFunction___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; lldb::SBFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40146,7 +40769,7 @@ SWIGINTERN PyObject *_wrap_SBFunction___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBFunction_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40184,7 +40807,7 @@ SWIGINTERN PyObject *_wrap_SBFunction_GetDescription(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBFunction___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40305,7 +40928,7 @@ SWIGINTERN PyObject *_wrap_SBHostOS_GetUserHomeDirectory(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCreated(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -40335,10 +40958,10 @@ SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCreated(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCreate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - lldb::thread_func_t arg2 = (lldb::thread_func_t) 0 ; - void *arg3 = (void *) 0 ; - lldb::SBError *arg4 = (lldb::SBError *) 0 ; + char *arg1 = 0 ; + lldb::thread_func_t arg2 = 0 ; + void *arg3 = 0 ; + lldb::SBError *arg4 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -40387,7 +41010,7 @@ SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCreate(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCancel(PyObject *self, PyObject *args) { PyObject *resultobj = 0; lldb::thread_t arg1 ; - lldb::SBError *arg2 = (lldb::SBError *) 0 ; + lldb::SBError *arg2 = 0 ; void *argp1 ; int res1 = 0 ; void *argp2 = 0 ; @@ -40430,7 +41053,7 @@ SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCancel(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBHostOS_ThreadDetach(PyObject *self, PyObject *args) { PyObject *resultobj = 0; lldb::thread_t arg1 ; - lldb::SBError *arg2 = (lldb::SBError *) 0 ; + lldb::SBError *arg2 = 0 ; void *argp1 ; int res1 = 0 ; void *argp2 = 0 ; @@ -40473,8 +41096,8 @@ SWIGINTERN PyObject *_wrap_SBHostOS_ThreadDetach(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBHostOS_ThreadJoin(PyObject *self, PyObject *args) { PyObject *resultobj = 0; lldb::thread_t arg1 ; - lldb::thread_result_t *arg2 = (lldb::thread_result_t *) 0 ; - lldb::SBError *arg3 = (lldb::SBError *) 0 ; + lldb::thread_result_t *arg2 = 0 ; + lldb::SBError *arg3 = 0 ; void *argp1 ; int res1 = 0 ; void *argp2 = 0 ; @@ -40541,7 +41164,7 @@ SWIGINTERN PyObject *_wrap_new_SBHostOS(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBHostOS(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBHostOS *arg1 = (lldb::SBHostOS *) 0 ; + lldb::SBHostOS *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40655,7 +41278,7 @@ SWIGINTERN PyObject *_wrap_new_SBInstruction(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBInstruction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40682,7 +41305,7 @@ SWIGINTERN PyObject *_wrap_delete_SBInstruction(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBInstruction___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40710,7 +41333,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBInstruction_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40738,7 +41361,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBInstruction_GetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -40766,7 +41389,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBInstruction_GetMnemonic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40809,7 +41432,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetMnemonic(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBInstruction_GetOperands(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40852,7 +41475,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetOperands(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBInstruction_GetComment(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40895,7 +41518,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetComment(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBInstruction_GetControlFlowKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40938,7 +41561,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetControlFlowKind(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBInstruction_GetData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -40981,7 +41604,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetData(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBInstruction_GetByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41009,7 +41632,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetByteSize(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBInstruction_DoesBranch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41037,7 +41660,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_DoesBranch(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBInstruction_HasDelaySlot(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41065,7 +41688,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_HasDelaySlot(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBInstruction_CanSetBreakpoint(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41093,7 +41716,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_CanSetBreakpoint(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBInstruction_Print__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -41134,7 +41757,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_Print__SWIG_0(PyObject *self, Py_ssize_ SWIGINTERN PyObject *_wrap_SBInstruction_Print__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -41222,7 +41845,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_Print(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBInstruction_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -41260,7 +41883,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBInstruction_EmulateWithFrame(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -41306,8 +41929,8 @@ SWIGINTERN PyObject *_wrap_SBInstruction_EmulateWithFrame(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBInstruction_DumpEmulation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBInstruction *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -41344,9 +41967,9 @@ SWIGINTERN PyObject *_wrap_SBInstruction_DumpEmulation(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBInstruction_TestEmulation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -41393,7 +42016,7 @@ SWIGINTERN PyObject *_wrap_SBInstruction_TestEmulation(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBInstruction___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBInstruction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41508,7 +42131,7 @@ SWIGINTERN PyObject *_wrap_new_SBInstructionList(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBInstructionList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41535,7 +42158,7 @@ SWIGINTERN PyObject *_wrap_delete_SBInstructionList(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBInstructionList___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41563,7 +42186,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList___nonzero__(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBInstructionList_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41591,7 +42214,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_IsValid(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBInstructionList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41619,7 +42242,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_GetSize(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -41654,7 +42277,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionAtIndex(PyObject *sel SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionsCount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; lldb::SBAddress *arg3 = 0 ; bool arg4 ; @@ -41710,7 +42333,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionsCount__SWIG_0(PyObje SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionsCount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; lldb::SBAddress *arg3 = 0 ; void *argp1 = 0 ; @@ -41816,7 +42439,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionsCount(PyObject *self SWIGINTERN PyObject *_wrap_SBInstructionList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -41843,7 +42466,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_Clear(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBInstructionList_AppendInstruction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; lldb::SBInstruction arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -41885,7 +42508,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_AppendInstruction(PyObject *self, P SWIGINTERN PyObject *_wrap_SBInstructionList_Print__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -41926,7 +42549,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_Print__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBInstructionList_Print__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -42014,7 +42637,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_Print(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBInstructionList_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -42051,7 +42674,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_GetDescription__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBInstructionList_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::SBExecutionContext *arg3 = 0 ; void *argp1 = 0 ; @@ -42150,8 +42773,8 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_GetDescription(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBInstructionList_DumpEmulationForAllInstructions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -42188,7 +42811,7 @@ SWIGINTERN PyObject *_wrap_SBInstructionList_DumpEmulationForAllInstructions(PyO SWIGINTERN PyObject *_wrap_SBInstructionList___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstructionList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42227,7 +42850,7 @@ SWIGINTERN PyObject *SBInstructionList_swiginit(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_SBLanguageRuntime_GetLanguageTypeFromString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -42500,7 +43123,7 @@ SWIGINTERN PyObject *_wrap_new_SBLanguageRuntime(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBLanguageRuntime(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLanguageRuntime *arg1 = (lldb::SBLanguageRuntime *) 0 ; + lldb::SBLanguageRuntime *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42538,7 +43161,7 @@ SWIGINTERN PyObject *SBLanguageRuntime_swiginit(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_SBLaunchInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char **arg1 = (char **) 0 ; + char **arg1 = 0 ; PyObject *swig_obj[1] ; lldb::SBLaunchInfo *result = 0 ; @@ -42589,7 +43212,7 @@ SWIGINTERN PyObject *_wrap_new_SBLaunchInfo(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBLaunchInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42616,7 +43239,7 @@ SWIGINTERN PyObject *_wrap_delete_SBLaunchInfo(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42644,7 +43267,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetProcessID(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42672,7 +43295,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetUserID(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42700,7 +43323,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetGroupID(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBLaunchInfo_UserIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42728,7 +43351,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_UserIDIsValid(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBLaunchInfo_GroupIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42756,7 +43379,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GroupIDIsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -42790,7 +43413,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetUserID(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -42824,7 +43447,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetGroupID(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetExecutableFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42852,7 +43475,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetExecutableFile(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetExecutableFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; lldb::SBFileSpec arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -42902,7 +43525,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetExecutableFile(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42930,7 +43553,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetListener(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -42967,7 +43590,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetListener(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShadowListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -42995,7 +43618,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShadowListener(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShadowListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43032,7 +43655,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShadowListener(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetNumArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43060,7 +43683,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetNumArguments(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetArgumentAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43095,8 +43718,8 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetArgumentAtIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; - char **arg2 = (char **) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; + char **arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43160,7 +43783,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetArguments(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetNumEnvironmentEntries(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43188,7 +43811,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetNumEnvironmentEntries(PyObject *self, SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43223,8 +43846,8 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex(PyObject *sel SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetEnvironmentEntries(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; - char **arg2 = (char **) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; + char **arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43288,7 +43911,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetEnvironmentEntries(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetEnvironment(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; lldb::SBEnvironment *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -43333,7 +43956,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetEnvironment(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetEnvironment(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43361,7 +43984,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetEnvironment(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43388,7 +44011,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43416,8 +44039,8 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetWorkingDirectory(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -43453,7 +44076,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetWorkingDirectory(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetLaunchFlags(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43481,7 +44104,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetLaunchFlags(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetLaunchFlags(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43515,7 +44138,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetLaunchFlags(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetProcessPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43543,8 +44166,8 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetProcessPluginName(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetProcessPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -43580,7 +44203,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetProcessPluginName(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShell(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43608,8 +44231,8 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShell(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShell(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -43645,7 +44268,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShell(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShellExpandArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43673,7 +44296,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShellExpandArguments(PyObject *self, SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShellExpandArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43707,7 +44330,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShellExpandArguments(PyObject *self, SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetResumeCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -43735,7 +44358,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetResumeCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetResumeCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43769,7 +44392,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetResumeCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddCloseFileAction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -43804,7 +44427,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddCloseFileAction(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddDuplicateFileAction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; @@ -43847,9 +44470,9 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddDuplicateFileAction(PyObject *self, P SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddOpenFileAction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; int arg2 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; bool arg4 ; bool arg5 ; void *argp1 = 0 ; @@ -43909,7 +44532,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddOpenFileAction(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddSuppressFileAction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; int arg2 ; bool arg3 ; bool arg4 ; @@ -43960,8 +44583,8 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddSuppressFileAction(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetLaunchEventData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -43997,7 +44620,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetLaunchEventData(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetLaunchEventData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44025,7 +44648,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetLaunchEventData(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetDetachOnError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44053,7 +44676,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetDetachOnError(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetDetachOnError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44087,7 +44710,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetDetachOnError(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetScriptedProcessClassName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44115,8 +44738,8 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetScriptedProcessClassName(PyObject *se SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetScriptedProcessClassName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -44152,7 +44775,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetScriptedProcessClassName(PyObject *se SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetScriptedProcessDictionary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44180,7 +44803,7 @@ SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetScriptedProcessDictionary(PyObject *s SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetScriptedProcessDictionary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBLaunchInfo *arg1 = 0 ; lldb::SBStructuredData arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44309,7 +44932,7 @@ SWIGINTERN PyObject *_wrap_new_SBLineEntry(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBLineEntry(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44336,7 +44959,7 @@ SWIGINTERN PyObject *_wrap_delete_SBLineEntry(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLineEntry_GetStartAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44364,7 +44987,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_GetStartAddress(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBLineEntry_GetEndAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44392,7 +45015,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_GetEndAddress(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBLineEntry_GetSameLineContiguousAddressRangeEnd(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44427,7 +45050,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_GetSameLineContiguousAddressRangeEnd(PyOb SWIGINTERN PyObject *_wrap_SBLineEntry___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44455,7 +45078,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry___nonzero__(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBLineEntry_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44483,7 +45106,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLineEntry_GetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44511,7 +45134,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_GetFileSpec(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBLineEntry_GetLine(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44539,7 +45162,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_GetLine(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLineEntry_GetColumn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44567,7 +45190,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_GetColumn(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBLineEntry_SetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; lldb::SBFileSpec arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44609,7 +45232,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_SetFileSpec(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBLineEntry_SetLine(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44643,7 +45266,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_SetLine(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLineEntry_SetColumn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44677,7 +45300,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_SetColumn(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBLineEntry___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; lldb::SBLineEntry *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44720,7 +45343,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLineEntry___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; lldb::SBLineEntry *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44763,7 +45386,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBLineEntry_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -44801,7 +45424,7 @@ SWIGINTERN PyObject *_wrap_SBLineEntry_GetDescription(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBLineEntry___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44858,7 +45481,7 @@ SWIGINTERN PyObject *_wrap_new_SBListener__SWIG_0(PyObject *self, Py_ssize_t nob SWIGINTERN PyObject *_wrap_new_SBListener__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -44954,7 +45577,7 @@ SWIGINTERN PyObject *_wrap_new_SBListener(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBListener(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -44981,7 +45604,7 @@ SWIGINTERN PyObject *_wrap_delete_SBListener(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBListener_AddEvent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -45018,7 +45641,7 @@ SWIGINTERN PyObject *_wrap_SBListener_AddEvent(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBListener_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -45045,7 +45668,7 @@ SWIGINTERN PyObject *_wrap_SBListener_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBListener___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -45073,7 +45696,7 @@ SWIGINTERN PyObject *_wrap_SBListener___nonzero__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBListener_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -45101,9 +45724,9 @@ SWIGINTERN PyObject *_wrap_SBListener_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBListener_StartListeningForEventClass(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBDebugger *arg2 = 0 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; uint32_t arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -45158,9 +45781,9 @@ SWIGINTERN PyObject *_wrap_SBListener_StartListeningForEventClass(PyObject *self SWIGINTERN PyObject *_wrap_SBListener_StopListeningForEventClass(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBDebugger *arg2 = 0 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; uint32_t arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -45215,7 +45838,7 @@ SWIGINTERN PyObject *_wrap_SBListener_StopListeningForEventClass(PyObject *self, SWIGINTERN PyObject *_wrap_SBListener_StartListeningForEvents(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -45261,7 +45884,7 @@ SWIGINTERN PyObject *_wrap_SBListener_StartListeningForEvents(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBListener_StopListeningForEvents(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -45307,7 +45930,7 @@ SWIGINTERN PyObject *_wrap_SBListener_StopListeningForEvents(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBListener_WaitForEvent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; uint32_t arg2 ; lldb::SBEvent *arg3 = 0 ; void *argp1 = 0 ; @@ -45353,7 +45976,7 @@ SWIGINTERN PyObject *_wrap_SBListener_WaitForEvent(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBListener_WaitForEventForBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; uint32_t arg2 ; lldb::SBBroadcaster *arg3 = 0 ; lldb::SBEvent *arg4 = 0 ; @@ -45410,7 +46033,7 @@ SWIGINTERN PyObject *_wrap_SBListener_WaitForEventForBroadcaster(PyObject *self, SWIGINTERN PyObject *_wrap_SBListener_WaitForEventForBroadcasterWithType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; uint32_t arg2 ; lldb::SBBroadcaster *arg3 = 0 ; uint32_t arg4 ; @@ -45475,7 +46098,7 @@ SWIGINTERN PyObject *_wrap_SBListener_WaitForEventForBroadcasterWithType(PyObjec SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEvent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -45513,7 +46136,7 @@ SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEvent(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEventForBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; lldb::SBEvent *arg3 = 0 ; void *argp1 = 0 ; @@ -45562,7 +46185,7 @@ SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEventForBroadcaster(PyObject *se SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEventForBroadcasterWithType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; uint32_t arg3 ; lldb::SBEvent *arg4 = 0 ; @@ -45619,7 +46242,7 @@ SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEventForBroadcasterWithType(PyOb SWIGINTERN PyObject *_wrap_SBListener_GetNextEvent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -45657,7 +46280,7 @@ SWIGINTERN PyObject *_wrap_SBListener_GetNextEvent(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBListener_GetNextEventForBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; lldb::SBEvent *arg3 = 0 ; void *argp1 = 0 ; @@ -45706,7 +46329,7 @@ SWIGINTERN PyObject *_wrap_SBListener_GetNextEventForBroadcaster(PyObject *self, SWIGINTERN PyObject *_wrap_SBListener_GetNextEventForBroadcasterWithType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBBroadcaster *arg2 = 0 ; uint32_t arg3 ; lldb::SBEvent *arg4 = 0 ; @@ -45763,7 +46386,7 @@ SWIGINTERN PyObject *_wrap_SBListener_GetNextEventForBroadcasterWithType(PyObjec SWIGINTERN PyObject *_wrap_SBListener_HandleBroadcastEvent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBListener *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -45859,7 +46482,7 @@ SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_1(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; lldb::addr_t arg2 ; lldb::addr_t arg3 ; uint32_t arg4 ; @@ -45928,7 +46551,7 @@ SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_2(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; lldb::addr_t arg2 ; lldb::addr_t arg3 ; uint32_t arg4 ; @@ -46090,7 +46713,7 @@ SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_delete_SBMemoryRegionInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46117,7 +46740,7 @@ SWIGINTERN PyObject *_wrap_delete_SBMemoryRegionInfo(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46144,7 +46767,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_Clear(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetRegionBase(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46172,7 +46795,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetRegionBase(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetRegionEnd(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46200,7 +46823,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetRegionEnd(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsReadable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46228,7 +46851,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsReadable(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsWritable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46256,7 +46879,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsWritable(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsExecutable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46284,7 +46907,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsExecutable(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsMapped(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46312,7 +46935,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsMapped(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46340,7 +46963,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetName(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46368,7 +46991,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList(PyObject *s SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetNumDirtyPages(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46396,7 +47019,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetNumDirtyPages(PyObject *self, P SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -46431,7 +47054,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex(PyObjec SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetPageSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46459,7 +47082,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetPageSize(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; lldb::SBMemoryRegionInfo *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -46502,7 +47125,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___eq__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; lldb::SBMemoryRegionInfo *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -46545,7 +47168,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___ne__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -46583,7 +47206,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetDescription(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46698,7 +47321,7 @@ SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfoList(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_delete_SBMemoryRegionInfoList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46725,7 +47348,7 @@ SWIGINTERN PyObject *_wrap_delete_SBMemoryRegionInfoList(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -46753,7 +47376,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetSize(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; lldb::addr_t arg2 ; lldb::SBMemoryRegionInfo *arg3 = 0 ; void *argp1 = 0 ; @@ -46799,7 +47422,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddre SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; uint32_t arg2 ; lldb::SBMemoryRegionInfo *arg3 = 0 ; void *argp1 = 0 ; @@ -46845,7 +47468,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex(PyObjec SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; lldb::SBMemoryRegionInfo *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -46881,7 +47504,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Append__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; lldb::SBMemoryRegionInfoList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -46963,7 +47586,7 @@ SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Append(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47168,7 +47791,7 @@ SWIGINTERN PyObject *_wrap_new_SBModule(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47195,7 +47818,7 @@ SWIGINTERN PyObject *_wrap_delete_SBModule(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47223,7 +47846,7 @@ SWIGINTERN PyObject *_wrap_SBModule___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47251,7 +47874,7 @@ SWIGINTERN PyObject *_wrap_SBModule_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47278,7 +47901,7 @@ SWIGINTERN PyObject *_wrap_SBModule_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_IsFileBacked(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47306,7 +47929,7 @@ SWIGINTERN PyObject *_wrap_SBModule_IsFileBacked(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_GetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47334,7 +47957,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetFileSpec(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_GetPlatformFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47362,7 +47985,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetPlatformFileSpec(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModule_SetPlatformFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47400,7 +48023,7 @@ SWIGINTERN PyObject *_wrap_SBModule_SetPlatformFileSpec(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModule_GetRemoteInstallFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47428,7 +48051,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetRemoteInstallFileSpec(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBModule_SetRemoteInstallFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47466,7 +48089,7 @@ SWIGINTERN PyObject *_wrap_SBModule_SetRemoteInstallFileSpec(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBModule_GetByteOrder(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47494,7 +48117,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetByteOrder(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_GetAddressByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47522,7 +48145,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetAddressByteSize(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModule_GetTriple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47550,7 +48173,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetTriple(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_GetUUIDBytes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47578,7 +48201,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetUUIDBytes(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_GetUUIDString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47606,7 +48229,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetUUIDString(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBModule___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBModule *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47649,7 +48272,7 @@ SWIGINTERN PyObject *_wrap_SBModule___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBModule *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47692,8 +48315,8 @@ SWIGINTERN PyObject *_wrap_SBModule___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_FindSection(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -47730,7 +48353,7 @@ SWIGINTERN PyObject *_wrap_SBModule_FindSection(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_ResolveFileAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47765,7 +48388,7 @@ SWIGINTERN PyObject *_wrap_SBModule_ResolveFileAddress(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModule_ResolveSymbolContextForAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -47811,7 +48434,7 @@ SWIGINTERN PyObject *_wrap_SBModule_ResolveSymbolContextForAddress(PyObject *sel SWIGINTERN PyObject *_wrap_SBModule_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47849,7 +48472,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetDescription(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBModule_GetNumCompileUnits(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47877,7 +48500,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetNumCompileUnits(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModule_GetCompileUnitAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47912,7 +48535,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetCompileUnitAtIndex(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBModule_FindCompileUnits(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -47950,7 +48573,7 @@ SWIGINTERN PyObject *_wrap_SBModule_FindCompileUnits(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBModule_GetNumSymbols(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -47978,7 +48601,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetNumSymbols(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBModule_GetSymbolAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48013,8 +48636,8 @@ SWIGINTERN PyObject *_wrap_SBModule_GetSymbolAtIndex(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBModule_FindSymbol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; lldb::SymbolType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48058,8 +48681,8 @@ SWIGINTERN PyObject *_wrap_SBModule_FindSymbol__SWIG_0(PyObject *self, Py_ssize_ SWIGINTERN PyObject *_wrap_SBModule_FindSymbol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -48145,8 +48768,8 @@ SWIGINTERN PyObject *_wrap_SBModule_FindSymbol(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_FindSymbols__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; lldb::SymbolType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48190,8 +48813,8 @@ SWIGINTERN PyObject *_wrap_SBModule_FindSymbols__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBModule_FindSymbols__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -48277,7 +48900,7 @@ SWIGINTERN PyObject *_wrap_SBModule_FindSymbols(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_GetNumSections(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -48305,7 +48928,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetNumSections(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBModule_GetSectionAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48340,8 +48963,8 @@ SWIGINTERN PyObject *_wrap_SBModule_GetSectionAtIndex(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBModule_FindFunctions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48385,8 +49008,8 @@ SWIGINTERN PyObject *_wrap_SBModule_FindFunctions__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBModule_FindFunctions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -48472,9 +49095,9 @@ SWIGINTERN PyObject *_wrap_SBModule_FindFunctions(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBModule_FindGlobalVariables(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; uint32_t arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48529,9 +49152,9 @@ SWIGINTERN PyObject *_wrap_SBModule_FindGlobalVariables(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModule_FindFirstGlobalVariable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -48578,8 +49201,8 @@ SWIGINTERN PyObject *_wrap_SBModule_FindFirstGlobalVariable(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBModule_FindFirstType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -48616,8 +49239,8 @@ SWIGINTERN PyObject *_wrap_SBModule_FindFirstType(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBModule_FindTypes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModule *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -48654,7 +49277,7 @@ SWIGINTERN PyObject *_wrap_SBModule_FindTypes(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_GetTypeByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::user_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48689,7 +49312,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetTypeByID(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_GetBasicType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::BasicType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48724,7 +49347,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetBasicType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModule_GetTypes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48758,7 +49381,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetTypes__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBModule_GetTypes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBTypeList result; @@ -48826,8 +49449,8 @@ SWIGINTERN PyObject *_wrap_SBModule_GetTypes(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_GetVersion(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; - uint32_t *arg2 = (uint32_t *) 0 ; + lldb::SBModule *arg1 = 0 ; + uint32_t *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -48883,7 +49506,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetVersion(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModule_GetSymbolFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -48911,7 +49534,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetSymbolFileSpec(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBModule_GetObjectFileHeaderAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -48939,7 +49562,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetObjectFileHeaderAddress(PyObject *self, P SWIGINTERN PyObject *_wrap_SBModule_GetObjectFileEntryPointAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -48967,7 +49590,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GetObjectFileEntryPointAddress(PyObject *sel SWIGINTERN PyObject *_wrap_SBModule_IsTypeSystemCompatible(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; lldb::LanguageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49037,7 +49660,7 @@ SWIGINTERN PyObject *_wrap_SBModule_GarbageCollectAllocatedModules(PyObject *sel SWIGINTERN PyObject *_wrap_SBModule___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49152,7 +49775,7 @@ SWIGINTERN PyObject *_wrap_new_SBModuleSpec(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBModuleSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49179,7 +49802,7 @@ SWIGINTERN PyObject *_wrap_delete_SBModuleSpec(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModuleSpec___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49207,7 +49830,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBModuleSpec_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49235,7 +49858,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBModuleSpec_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49262,7 +49885,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBModuleSpec_GetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49290,7 +49913,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetFileSpec(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBModuleSpec_SetFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49327,7 +49950,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetFileSpec(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBModuleSpec_GetPlatformFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49355,7 +49978,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetPlatformFileSpec(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBModuleSpec_SetPlatformFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49392,7 +50015,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetPlatformFileSpec(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBModuleSpec_GetSymbolFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49420,7 +50043,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetSymbolFileSpec(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBModuleSpec_SetSymbolFileSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49457,7 +50080,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetSymbolFileSpec(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49485,8 +50108,8 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectName(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -49522,7 +50145,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectName(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBModuleSpec_GetTriple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49550,8 +50173,8 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetTriple(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBModuleSpec_SetTriple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -49587,7 +50210,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetTriple(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBModuleSpec_GetUUIDBytes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49615,7 +50238,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetUUIDBytes(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBModuleSpec_GetUUIDLength(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49643,8 +50266,8 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetUUIDLength(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBModuleSpec_SetUUIDBytes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; - uint8_t *arg2 = (uint8_t *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; + uint8_t *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49686,7 +50309,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetUUIDBytes(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectOffset(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49714,7 +50337,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectOffset(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectOffset(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49748,7 +50371,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectOffset(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49776,7 +50399,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectSize(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49810,7 +50433,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectSize(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBModuleSpec_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -49848,7 +50471,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpec_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBModuleSpec___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBModuleSpec *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49963,7 +50586,7 @@ SWIGINTERN PyObject *_wrap_new_SBModuleSpecList(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBModuleSpecList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -49990,7 +50613,7 @@ SWIGINTERN PyObject *_wrap_delete_SBModuleSpecList(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetModuleSpecifications(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -50021,7 +50644,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetModuleSpecifications(PyObject *se SWIGINTERN PyObject *_wrap_SBModuleSpecList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; lldb::SBModuleSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -50057,7 +50680,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_Append__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBModuleSpecList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; lldb::SBModuleSpecList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -50137,7 +50760,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_Append(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBModuleSpecList_FindFirstMatchingSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; lldb::SBModuleSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -50175,7 +50798,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_FindFirstMatchingSpec(PyObject *self SWIGINTERN PyObject *_wrap_SBModuleSpecList_FindMatchingSpecs(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; lldb::SBModuleSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -50213,7 +50836,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_FindMatchingSpecs(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50241,7 +50864,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetSize(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetSpecAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -50276,7 +50899,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetSpecAtIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -50314,7 +50937,7 @@ SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetDescription(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBModuleSpecList___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50429,7 +51052,7 @@ SWIGINTERN PyObject *_wrap_new_SBMutex(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBMutex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMutex *arg1 = (lldb::SBMutex *) 0 ; + lldb::SBMutex *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50456,7 +51079,7 @@ SWIGINTERN PyObject *_wrap_delete_SBMutex(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBMutex_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMutex *arg1 = (lldb::SBMutex *) 0 ; + lldb::SBMutex *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50484,7 +51107,7 @@ SWIGINTERN PyObject *_wrap_SBMutex_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBMutex_lock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMutex *arg1 = (lldb::SBMutex *) 0 ; + lldb::SBMutex *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50511,7 +51134,7 @@ SWIGINTERN PyObject *_wrap_SBMutex_lock(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBMutex_unlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBMutex *arg1 = (lldb::SBMutex *) 0 ; + lldb::SBMutex *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50549,7 +51172,7 @@ SWIGINTERN PyObject *SBMutex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIGINTERN PyObject *_wrap_new_SBPlatformConnectOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -50641,7 +51264,7 @@ SWIGINTERN PyObject *_wrap_new_SBPlatformConnectOptions(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_delete_SBPlatformConnectOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50668,7 +51291,7 @@ SWIGINTERN PyObject *_wrap_delete_SBPlatformConnectOptions(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetURL(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50696,8 +51319,8 @@ SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetURL(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_SetURL(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -50733,7 +51356,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_SetURL(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetRsyncEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50761,9 +51384,9 @@ SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetRsyncEnabled(PyObject *se SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_EnableRsync(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -50817,7 +51440,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_EnableRsync(PyObject *self, SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_DisableRsync(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50844,7 +51467,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_DisableRsync(PyObject *self, SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetLocalCacheDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -50872,8 +51495,8 @@ SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetLocalCacheDirectory(PyObj SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_SetLocalCacheDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatformConnectOptions *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -50920,8 +51543,8 @@ SWIGINTERN PyObject *SBPlatformConnectOptions_swiginit(PyObject *SWIGUNUSEDPARM( SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; + char *arg1 = 0 ; + char *arg2 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -50960,7 +51583,7 @@ SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -51065,7 +51688,7 @@ SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_delete_SBPlatformShellCommand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51092,7 +51715,7 @@ SWIGINTERN PyObject *_wrap_delete_SBPlatformShellCommand(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51119,7 +51742,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_Clear(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetShell(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51147,8 +51770,8 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetShell(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetShell(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -51184,7 +51807,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetShell(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetCommand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51212,8 +51835,8 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetCommand(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetCommand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -51249,7 +51872,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetCommand(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51277,8 +51900,8 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetWorkingDirectory(PyObject * SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -51314,7 +51937,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetWorkingDirectory(PyObject * SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetTimeoutSeconds(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51342,7 +51965,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetTimeoutSeconds(PyObject *se SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetTimeoutSeconds(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -51376,7 +51999,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetTimeoutSeconds(PyObject *se SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetSignal(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51404,7 +52027,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetSignal(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetStatus(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51432,7 +52055,7 @@ SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetStatus(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetOutput(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + lldb::SBPlatformShellCommand *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51489,7 +52112,7 @@ SWIGINTERN PyObject *_wrap_new_SBPlatform__SWIG_0(PyObject *self, Py_ssize_t nob SWIGINTERN PyObject *_wrap_new_SBPlatform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -51585,7 +52208,7 @@ SWIGINTERN PyObject *_wrap_new_SBPlatform(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBPlatform(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51630,7 +52253,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetHostPlatform(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBPlatform___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51658,7 +52281,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform___nonzero__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBPlatform_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51686,7 +52309,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51713,7 +52336,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_GetWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51741,8 +52364,8 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetWorkingDirectory(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBPlatform_SetWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatform *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -51779,7 +52402,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_SetWorkingDirectory(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBPlatform_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51807,7 +52430,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_ConnectRemote(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBPlatformConnectOptions *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -51845,7 +52468,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_ConnectRemote(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBPlatform_DisconnectRemote(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51872,7 +52495,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_DisconnectRemote(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBPlatform_IsConnected(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51900,7 +52523,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_IsConnected(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBPlatform_GetTriple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51928,7 +52551,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetTriple(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBPlatform_GetHostname(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51956,7 +52579,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetHostname(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBPlatform_GetOSBuild(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -51984,7 +52607,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetOSBuild(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBPlatform_GetOSDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -52012,7 +52635,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetOSDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBPlatform_GetOSMajorVersion(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -52040,7 +52663,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetOSMajorVersion(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBPlatform_GetOSMinorVersion(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -52068,7 +52691,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetOSMinorVersion(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBPlatform_GetOSUpdateVersion(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -52096,8 +52719,8 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetOSUpdateVersion(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBPlatform_SetSDKRoot(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatform *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -52133,7 +52756,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_SetSDKRoot(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBPlatform_Put(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; void *argp1 = 0 ; @@ -52182,7 +52805,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Put(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_Get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; void *argp1 = 0 ; @@ -52231,7 +52854,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Get(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_Install(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; void *argp1 = 0 ; @@ -52280,7 +52903,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Install(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_Run(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBPlatformShellCommand *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -52318,7 +52941,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Run(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_Launch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBLaunchInfo *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -52356,7 +52979,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Launch(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_Attach(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBAttachInfo *arg2 = 0 ; lldb::SBDebugger *arg3 = 0 ; lldb::SBTarget *arg4 = 0 ; @@ -52427,7 +53050,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Attach(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_GetAllProcesses(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -52465,7 +53088,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetAllProcesses(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBPlatform_Kill(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; lldb::pid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -52500,8 +53123,8 @@ SWIGINTERN PyObject *_wrap_SBPlatform_Kill(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBPlatform_MakeDirectory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatform *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -52545,8 +53168,8 @@ SWIGINTERN PyObject *_wrap_SBPlatform_MakeDirectory__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBPlatform_MakeDirectory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatform *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -52632,8 +53255,8 @@ SWIGINTERN PyObject *_wrap_SBPlatform_MakeDirectory(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBPlatform_GetFilePermissions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatform *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -52670,8 +53293,8 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetFilePermissions(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBPlatform_SetFilePermissions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBPlatform *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -52716,7 +53339,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_SetFilePermissions(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBPlatform_GetUnixSignals(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -52744,7 +53367,7 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetUnixSignals(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBPlatform_GetEnvironment(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatform *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -52772,9 +53395,9 @@ SWIGINTERN PyObject *_wrap_SBPlatform_GetEnvironment(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBPlatform_SetLocateModuleCallback(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; - lldb::SBPlatformLocateModuleCallback arg2 = (lldb::SBPlatformLocateModuleCallback) 0 ; - void *arg3 = (void *) 0 ; + lldb::SBPlatform *arg1 = 0 ; + lldb::SBPlatformLocateModuleCallback arg2 = 0 ; + void *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; @@ -52930,7 +53553,7 @@ SWIGINTERN PyObject *_wrap_new_SBProcess(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -52975,7 +53598,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetBroadcasterClassName(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBProcess_GetPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53003,7 +53626,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetPluginName(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBProcess_GetShortPluginName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53031,7 +53654,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetShortPluginName(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53058,7 +53681,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53086,7 +53709,7 @@ SWIGINTERN PyObject *_wrap_SBProcess___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcess_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53114,7 +53737,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53142,7 +53765,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetTarget(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetByteOrder(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53170,8 +53793,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetByteOrder(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBProcess_PutSTDIN(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -53217,8 +53840,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_PutSTDIN(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetSTDOUT(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -53271,8 +53894,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetSTDOUT(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetSTDERR(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -53325,8 +53948,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetSTDERR(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetAsyncProfileData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -53379,7 +54002,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetAsyncProfileData(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBProcess_ReportEventState__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; lldb::SBFile arg3 ; void *argp1 = 0 ; @@ -53431,7 +54054,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_ReportEventState__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBProcess_ReportEventState__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg3 ; void *argp1 = 0 ; @@ -53538,7 +54161,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_ReportEventState(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBProcess_AppendEventStateReport(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBEvent *arg2 = 0 ; lldb::SBCommandReturnObject *arg3 = 0 ; void *argp1 = 0 ; @@ -53586,7 +54209,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_AppendEventStateReport(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBProcess_RemoteAttachToProcessWithID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::pid_t arg2 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -53632,13 +54255,13 @@ SWIGINTERN PyObject *_wrap_SBProcess_RemoteAttachToProcessWithID(PyObject *self, SWIGINTERN PyObject *_wrap_SBProcess_RemoteLaunch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char **arg2 = (char **) 0 ; - char **arg3 = (char **) 0 ; - char *arg4 = (char *) 0 ; - char *arg5 = (char *) 0 ; - char *arg6 = (char *) 0 ; - char *arg7 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char **arg2 = 0 ; + char **arg3 = 0 ; + char *arg4 = 0 ; + char *arg5 = 0 ; + char *arg6 = 0 ; + char *arg7 = 0 ; uint32_t arg8 ; bool arg9 ; lldb::SBError *arg10 = 0 ; @@ -53792,7 +54415,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_RemoteLaunch(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBProcess_GetNumThreads(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53820,7 +54443,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetNumThreads(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBProcess_GetThreadAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -53855,7 +54478,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetThreadAtIndex(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBProcess_GetThreadByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::tid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -53890,7 +54513,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetThreadByID(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBProcess_GetThreadByIndexID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -53925,7 +54548,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetThreadByIndexID(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_GetSelectedThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -53953,7 +54576,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetSelectedThread(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_CreateOSPluginThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::tid_t arg2 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -53996,7 +54619,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_CreateOSPluginThread(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBThread *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54034,7 +54657,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThread(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThreadByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::tid_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54069,7 +54692,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThreadByID(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThreadByIndexID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54104,7 +54727,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThreadByIndexID(PyObject *self, SWIGINTERN PyObject *_wrap_SBProcess_GetNumQueues(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54132,7 +54755,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetNumQueues(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBProcess_GetQueueAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54167,7 +54790,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetQueueAtIndex(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBProcess_GetState(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54195,7 +54818,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetState(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetExitStatus(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54223,7 +54846,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetExitStatus(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBProcess_GetExitDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54251,7 +54874,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetExitDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_GetProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54279,7 +54902,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetProcessID(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBProcess_GetUniqueID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54307,7 +54930,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetUniqueID(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcess_GetAddressByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54335,7 +54958,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetAddressByteSize(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_Destroy(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54363,7 +54986,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Destroy(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_Continue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54391,7 +55014,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Continue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_ContinueInDirection(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::RunDirection arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54426,7 +55049,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_ContinueInDirection(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBProcess_Stop(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54454,7 +55077,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Stop(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_Kill(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54482,7 +55105,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Kill(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_Detach__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBError result; @@ -54508,7 +55131,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Detach__SWIG_0(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_SBProcess_Detach__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54584,7 +55207,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Detach(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_Signal(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54619,7 +55242,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_Signal(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetUnixSignals(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54647,7 +55270,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetUnixSignals(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBProcess_SendAsyncInterrupt(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -54674,7 +55297,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SendAsyncInterrupt(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_GetStopID__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54708,7 +55331,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetStopID__SWIG_0(PyObject *self, Py_ssize_ SWIGINTERN PyObject *_wrap_SBProcess_GetStopID__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; uint32_t result; @@ -54776,7 +55399,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetStopID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetStopEventForStopID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54811,7 +55434,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetStopEventForStopID(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBProcess_ForceScriptedState(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::StateType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -54850,9 +55473,9 @@ SWIGINTERN PyObject *_wrap_SBProcess_ForceScriptedState(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_ReadMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; - void *arg3 = (void *) 0 ; + void *arg3 = 0 ; size_t arg4 ; lldb::SBError *arg5 = 0 ; void *argp1 = 0 ; @@ -54922,9 +55545,9 @@ SWIGINTERN PyObject *_wrap_SBProcess_ReadMemory(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcess_WriteMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; - void *arg3 = (void *) 0 ; + void *arg3 = 0 ; size_t arg4 ; lldb::SBError *arg5 = 0 ; void *argp1 = 0 ; @@ -54988,9 +55611,9 @@ SWIGINTERN PyObject *_wrap_SBProcess_WriteMemory(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcess_ReadCStringFromMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; - void *arg3 = (void *) 0 ; + void *arg3 = 0 ; size_t arg4 ; lldb::SBError *arg5 = 0 ; void *argp1 = 0 ; @@ -55061,7 +55684,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_ReadCStringFromMemory(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBProcess_ReadUnsignedFromMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; uint32_t arg3 ; lldb::SBError *arg4 = 0 ; @@ -55115,7 +55738,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_ReadUnsignedFromMemory(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBProcess_ReadPointerFromMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -55161,8 +55784,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_ReadPointerFromMemory(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBProcess_FindRangesInMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - void *arg2 = (void *) 0 ; + lldb::SBProcess *arg1 = 0 ; + void *arg2 = 0 ; uint64_t arg3 ; lldb::SBAddressRangeList *arg4 = 0 ; uint32_t arg5 ; @@ -55246,8 +55869,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_FindRangesInMemory(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_FindInMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - void *arg2 = (void *) 0 ; + lldb::SBProcess *arg1 = 0 ; + void *arg2 = 0 ; uint64_t arg3 ; lldb::SBAddressRange *arg4 = 0 ; uint32_t arg5 ; @@ -55609,7 +56232,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_EventIsStructuredDataEvent(PyObject *self, SWIGINTERN PyObject *_wrap_SBProcess_GetBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -55655,7 +56278,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetBroadcasterClass(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBProcess_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -55693,7 +56316,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetDescription(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBProcess_GetExtendedCrashInformation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -55721,7 +56344,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetExtendedCrashInformation(PyObject *self, SWIGINTERN PyObject *_wrap_SBProcess_GetNumSupportedHardwareWatchpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -55759,7 +56382,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetNumSupportedHardwareWatchpoints(PyObject SWIGINTERN PyObject *_wrap_SBProcess_LoadImage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -55807,7 +56430,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_LoadImage__SWIG_0(PyObject *self, Py_ssize_ SWIGINTERN PyObject *_wrap_SBProcess_LoadImage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; lldb::SBError *arg4 = 0 ; @@ -55925,7 +56548,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_LoadImage(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_LoadImageUsingPaths(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBStringList *arg3 = 0 ; lldb::SBFileSpec *arg4 = 0 ; @@ -55996,7 +56619,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_LoadImageUsingPaths(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBProcess_UnloadImage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -56031,8 +56654,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_UnloadImage(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcess_SendEventData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -56069,7 +56692,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SendEventData(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBProcess_GetNumExtendedBacktraceTypes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -56097,7 +56720,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetNumExtendedBacktraceTypes(PyObject *self SWIGINTERN PyObject *_wrap_SBProcess_GetExtendedBacktraceTypeAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -56132,7 +56755,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetExtendedBacktraceTypeAtIndex(PyObject *s SWIGINTERN PyObject *_wrap_SBProcess_GetHistoryThreads(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -56167,7 +56790,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetHistoryThreads(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_IsInstrumentationRuntimePresent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::InstrumentationRuntimeType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -56202,9 +56825,9 @@ SWIGINTERN PyObject *_wrap_SBProcess_IsInstrumentationRuntimePresent(PyObject *s SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; lldb::SaveCoreStyle arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -56258,8 +56881,8 @@ SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBProcess *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -56295,7 +56918,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_1(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBSaveCoreOptions *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -56401,7 +57024,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SaveCore(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess_GetMemoryRegionInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; lldb::SBMemoryRegionInfo *arg3 = 0 ; void *argp1 = 0 ; @@ -56447,7 +57070,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetMemoryRegionInfo(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBProcess_GetMemoryRegions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -56475,7 +57098,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetMemoryRegions(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBProcess_GetProcessInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -56503,7 +57126,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetProcessInfo(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBProcess_GetCoreFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -56531,7 +57154,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetCoreFile(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcess_GetAddressMask__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::AddressMaskType arg2 ; lldb::AddressMaskRange arg3 ; void *argp1 = 0 ; @@ -56573,7 +57196,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetAddressMask__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBProcess_GetAddressMask__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::AddressMaskType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -56661,7 +57284,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetAddressMask(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBProcess_SetAddressMask__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::AddressMaskType arg2 ; lldb::addr_t arg3 ; lldb::AddressMaskRange arg4 ; @@ -56710,7 +57333,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SetAddressMask__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBProcess_SetAddressMask__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::AddressMaskType arg2 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -56817,7 +57440,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SetAddressMask(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBProcess_SetAddressableBits__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::AddressMaskType arg2 ; uint32_t arg3 ; lldb::AddressMaskRange arg4 ; @@ -56866,7 +57489,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SetAddressableBits__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBProcess_SetAddressableBits__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::AddressMaskType arg2 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -56973,7 +57596,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_SetAddressableBits(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcess_FixAddress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; lldb::AddressMaskType arg3 ; void *argp1 = 0 ; @@ -57015,7 +57638,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_FixAddress__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBProcess_FixAddress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -57103,7 +57726,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_FixAddress(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcess_AllocateMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; size_t arg2 ; uint32_t arg3 ; lldb::SBError *arg4 = 0 ; @@ -57157,7 +57780,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_AllocateMemory(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBProcess_DeallocateMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -57192,7 +57815,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_DeallocateMemory(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBProcess_GetScriptedImplementation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57230,7 +57853,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetScriptedImplementation(PyObject *self, P SWIGINTERN PyObject *_wrap_SBProcess_GetStatus(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -57267,7 +57890,7 @@ SWIGINTERN PyObject *_wrap_SBProcess_GetStatus(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProcess___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57382,7 +58005,7 @@ SWIGINTERN PyObject *_wrap_new_SBProcessInfo(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBProcessInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57409,7 +58032,7 @@ SWIGINTERN PyObject *_wrap_delete_SBProcessInfo(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcessInfo___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57437,7 +58060,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBProcessInfo_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57465,7 +58088,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcessInfo_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57493,7 +58116,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetName(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcessInfo_GetExecutableFile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57521,7 +58144,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetExecutableFile(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBProcessInfo_GetProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57549,7 +58172,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetProcessID(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBProcessInfo_GetUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57577,7 +58200,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetUserID(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBProcessInfo_GetGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57605,7 +58228,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetGroupID(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBProcessInfo_UserIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57633,7 +58256,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_UserIDIsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcessInfo_GroupIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57661,7 +58284,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GroupIDIsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBProcessInfo_GetEffectiveUserID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57689,7 +58312,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetEffectiveUserID(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBProcessInfo_GetEffectiveGroupID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57717,7 +58340,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetEffectiveGroupID(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBProcessInfo_EffectiveUserIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57745,7 +58368,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_EffectiveUserIDIsValid(PyObject *self, SWIGINTERN PyObject *_wrap_SBProcessInfo_EffectiveGroupIDIsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57773,7 +58396,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_EffectiveGroupIDIsValid(PyObject *self, SWIGINTERN PyObject *_wrap_SBProcessInfo_GetParentProcessID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57801,7 +58424,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfo_GetParentProcessID(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBProcessInfo_GetTriple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBProcessInfo *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57858,7 +58481,7 @@ SWIGINTERN PyObject *_wrap_new_SBProcessInfoList__SWIG_0(PyObject *self, Py_ssiz SWIGINTERN PyObject *_wrap_delete_SBProcessInfoList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) 0 ; + lldb::SBProcessInfoList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57943,7 +58566,7 @@ SWIGINTERN PyObject *_wrap_new_SBProcessInfoList(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProcessInfoList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) 0 ; + lldb::SBProcessInfoList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -57971,7 +58594,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfoList_GetSize(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBProcessInfoList_GetProcessInfoAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) 0 ; + lldb::SBProcessInfoList *arg1 = 0 ; uint32_t arg2 ; lldb::SBProcessInfo *arg3 = 0 ; void *argp1 = 0 ; @@ -58017,7 +58640,7 @@ SWIGINTERN PyObject *_wrap_SBProcessInfoList_GetProcessInfoAtIndex(PyObject *sel SWIGINTERN PyObject *_wrap_SBProcessInfoList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) 0 ; + lldb::SBProcessInfoList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58055,8 +58678,8 @@ SWIGINTERN PyObject *SBProcessInfoList_swiginit(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_SBProgress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; + char *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBDebugger *arg3 = 0 ; int res1 ; char *buf1 = 0 ; @@ -58106,8 +58729,8 @@ SWIGINTERN PyObject *_wrap_new_SBProgress__SWIG_0(PyObject *self, Py_ssize_t nob SWIGINTERN PyObject *_wrap_new_SBProgress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; + char *arg1 = 0 ; + char *arg2 = 0 ; uint64_t arg3 ; lldb::SBDebugger *arg4 = 0 ; int res1 ; @@ -58223,7 +58846,7 @@ SWIGINTERN PyObject *_wrap_new_SBProgress(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBProgress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProgress *arg1 = (lldb::SBProgress *) 0 ; + lldb::SBProgress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58250,9 +58873,9 @@ SWIGINTERN PyObject *_wrap_delete_SBProgress(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBProgress_Increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProgress *arg1 = (lldb::SBProgress *) 0 ; + lldb::SBProgress *arg1 = 0 ; uint64_t arg2 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long long val2 ; @@ -58294,7 +58917,7 @@ SWIGINTERN PyObject *_wrap_SBProgress_Increment__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBProgress_Increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBProgress *arg1 = (lldb::SBProgress *) 0 ; + lldb::SBProgress *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -58379,7 +59002,7 @@ SWIGINTERN PyObject *_wrap_SBProgress_Increment(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBProgress_Finalize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBProgress *arg1 = (lldb::SBProgress *) 0 ; + lldb::SBProgress *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58493,7 +59116,7 @@ SWIGINTERN PyObject *_wrap_new_SBQueue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBQueue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58520,7 +59143,7 @@ SWIGINTERN PyObject *_wrap_delete_SBQueue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58548,7 +59171,7 @@ SWIGINTERN PyObject *_wrap_SBQueue___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58576,7 +59199,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58603,7 +59226,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue_GetProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58631,7 +59254,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetProcess(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue_GetQueueID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58659,7 +59282,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetQueueID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58687,7 +59310,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue_GetIndexID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58715,7 +59338,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetIndexID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueue_GetNumThreads(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58743,7 +59366,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetNumThreads(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBQueue_GetThreadAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -58778,7 +59401,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetThreadAtIndex(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBQueue_GetNumPendingItems(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58806,7 +59429,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetNumPendingItems(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBQueue_GetPendingItemAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -58841,7 +59464,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetPendingItemAtIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBQueue_GetNumRunningItems(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58869,7 +59492,7 @@ SWIGINTERN PyObject *_wrap_SBQueue_GetNumRunningItems(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBQueue_GetKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBQueue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58926,7 +59549,7 @@ SWIGINTERN PyObject *_wrap_new_SBQueueItem(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBQueueItem(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58953,7 +59576,7 @@ SWIGINTERN PyObject *_wrap_delete_SBQueueItem(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueueItem___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -58981,7 +59604,7 @@ SWIGINTERN PyObject *_wrap_SBQueueItem___nonzero__(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBQueueItem_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59009,7 +59632,7 @@ SWIGINTERN PyObject *_wrap_SBQueueItem_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueueItem_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59036,7 +59659,7 @@ SWIGINTERN PyObject *_wrap_SBQueueItem_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueueItem_GetKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59064,7 +59687,7 @@ SWIGINTERN PyObject *_wrap_SBQueueItem_GetKind(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueueItem_SetKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; lldb::QueueItemKind arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -59098,7 +59721,7 @@ SWIGINTERN PyObject *_wrap_SBQueueItem_SetKind(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBQueueItem_GetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59126,7 +59749,7 @@ SWIGINTERN PyObject *_wrap_SBQueueItem_GetAddress(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBQueueItem_SetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; lldb::SBAddress arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -59168,8 +59791,8 @@ SWIGINTERN PyObject *_wrap_SBQueueItem_SetAddress(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBQueueItem_GetExtendedBacktraceThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBQueueItem *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -59217,7 +59840,7 @@ SWIGINTERN PyObject *SBQueueItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje SWIGINTERN PyObject *_wrap_SBReproducer_Capture(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -59248,7 +59871,7 @@ SWIGINTERN PyObject *_wrap_SBReproducer_Capture(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBReproducer_PassiveReplay(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -59307,7 +59930,7 @@ SWIGINTERN PyObject *_wrap_SBReproducer_SetAutoGenerate(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBReproducer_SetWorkingDirectory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -59355,7 +59978,7 @@ SWIGINTERN PyObject *_wrap_new_SBReproducer(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBReproducer(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBReproducer *arg1 = (lldb::SBReproducer *) 0 ; + lldb::SBReproducer *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59393,7 +60016,7 @@ SWIGINTERN PyObject *SBReproducer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj SWIGINTERN PyObject *_wrap_new_SBScriptObject__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::ScriptObjectPtr arg1 = (lldb::ScriptObjectPtr) (lldb::ScriptObjectPtr)0 ; + lldb::ScriptObjectPtr arg1 = (lldb::ScriptObjectPtr)0 ; lldb::ScriptLanguage arg2 ; int val2 ; int ecode2 = 0 ; @@ -59547,7 +60170,7 @@ SWIGINTERN PyObject *_wrap_new_SBScriptObject(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBScriptObject(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::SBScriptObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59574,7 +60197,7 @@ SWIGINTERN PyObject *_wrap_delete_SBScriptObject(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBScriptObject___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::SBScriptObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59602,7 +60225,7 @@ SWIGINTERN PyObject *_wrap_SBScriptObject___nonzero__(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBScriptObject___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::SBScriptObject *arg1 = 0 ; lldb::SBScriptObject *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -59645,7 +60268,7 @@ SWIGINTERN PyObject *_wrap_SBScriptObject___ne__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBScriptObject_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::SBScriptObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59673,7 +60296,7 @@ SWIGINTERN PyObject *_wrap_SBScriptObject_IsValid(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBScriptObject_GetPointer(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::SBScriptObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59706,7 +60329,7 @@ SWIGINTERN PyObject *_wrap_SBScriptObject_GetPointer(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBScriptObject_GetLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::SBScriptObject *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59821,7 +60444,7 @@ SWIGINTERN PyObject *_wrap_new_SBSection(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBSection(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59848,7 +60471,7 @@ SWIGINTERN PyObject *_wrap_delete_SBSection(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSection___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59876,7 +60499,7 @@ SWIGINTERN PyObject *_wrap_SBSection___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBSection_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59904,7 +60527,7 @@ SWIGINTERN PyObject *_wrap_SBSection_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSection_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59932,7 +60555,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSection_GetParent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -59960,8 +60583,8 @@ SWIGINTERN PyObject *_wrap_SBSection_GetParent(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSection_FindSubSection(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBSection *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -59998,7 +60621,7 @@ SWIGINTERN PyObject *_wrap_SBSection_FindSubSection(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSection_GetNumSubSections(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60026,7 +60649,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetNumSubSections(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSection_GetSubSectionAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -60061,7 +60684,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetSubSectionAtIndex(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBSection_GetFileAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60089,7 +60712,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetFileAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSection_GetLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -60127,7 +60750,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetLoadAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSection_GetByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60155,7 +60778,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetByteSize(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBSection_GetFileOffset(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60183,7 +60806,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetFileOffset(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBSection_GetFileByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60211,7 +60834,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetFileByteSize(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBSection_GetSectionData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBData result; @@ -60237,7 +60860,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetSectionData__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBSection_GetSectionData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; uint64_t arg2 ; uint64_t arg3 ; void *argp1 = 0 ; @@ -60327,7 +60950,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetSectionData(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSection_GetSectionType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60355,7 +60978,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetSectionType(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSection_GetPermissions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60383,7 +61006,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetPermissions(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSection_GetTargetByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60411,7 +61034,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetTargetByteSize(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSection_GetAlignment(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60439,7 +61062,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetAlignment(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBSection___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; lldb::SBSection *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -60482,7 +61105,7 @@ SWIGINTERN PyObject *_wrap_SBSection___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSection___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; lldb::SBSection *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -60525,7 +61148,7 @@ SWIGINTERN PyObject *_wrap_SBSection___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSection_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -60563,7 +61186,7 @@ SWIGINTERN PyObject *_wrap_SBSection_GetDescription(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSection___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60732,7 +61355,7 @@ SWIGINTERN PyObject *_wrap_new_SBSourceManager(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBSourceManager(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) 0 ; + lldb::SBSourceManager *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -60759,12 +61382,12 @@ SWIGINTERN PyObject *_wrap_delete_SBSourceManager(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) 0 ; + lldb::SBSourceManager *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; uint32_t arg4 ; uint32_t arg5 ; - char *arg6 = (char *) 0 ; + char *arg6 = 0 ; lldb::SBStream *arg7 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -60843,13 +61466,13 @@ SWIGINTERN PyObject *_wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers(PyO SWIGINTERN PyObject *_wrap_SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) 0 ; + lldb::SBSourceManager *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; uint32_t arg4 ; uint32_t arg5 ; uint32_t arg6 ; - char *arg7 = (char *) 0 ; + char *arg7 = 0 ; lldb::SBStream *arg8 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61022,7 +61645,7 @@ SWIGINTERN PyObject *_wrap_new_SBStatisticsOptions(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_delete_SBStatisticsOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61049,7 +61672,7 @@ SWIGINTERN PyObject *_wrap_delete_SBStatisticsOptions(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetSummaryOnly(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61083,7 +61706,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetSummaryOnly(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetSummaryOnly(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61111,7 +61734,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetSummaryOnly(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeTargets(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61145,7 +61768,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeTargets(PyObject *self, SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeTargets(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61173,7 +61796,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeTargets(PyObject *self, SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeModules(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61207,7 +61830,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeModules(PyObject *self, SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeModules(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61235,7 +61858,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeModules(PyObject *self, SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeTranscript(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61269,7 +61892,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeTranscript(PyObject *se SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeTranscript(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61297,7 +61920,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeTranscript(PyObject *se SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetReportAllAvailableDebugInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61331,7 +61954,7 @@ SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetReportAllAvailableDebugInfo(Py SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetReportAllAvailableDebugInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + lldb::SBStatisticsOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61388,7 +62011,7 @@ SWIGINTERN PyObject *_wrap_new_SBStream(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBStream(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61415,7 +62038,7 @@ SWIGINTERN PyObject *_wrap_delete_SBStream(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStream___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61443,7 +62066,7 @@ SWIGINTERN PyObject *_wrap_SBStream___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBStream_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61471,7 +62094,7 @@ SWIGINTERN PyObject *_wrap_SBStream_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStream_GetData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61499,7 +62122,7 @@ SWIGINTERN PyObject *_wrap_SBStream_GetData(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStream_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61527,8 +62150,8 @@ SWIGINTERN PyObject *_wrap_SBStream_GetSize(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStream_Print(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStream *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -61564,8 +62187,8 @@ SWIGINTERN PyObject *_wrap_SBStream_Print(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStream *arg1 = 0 ; + char *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61608,7 +62231,7 @@ SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; lldb::SBFile arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61649,7 +62272,7 @@ SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_1(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -61756,7 +62379,7 @@ SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBStream_RedirectToFileDescriptor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; int arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -61798,7 +62421,7 @@ SWIGINTERN PyObject *_wrap_SBStream_RedirectToFileDescriptor(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBStream_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -61825,7 +62448,7 @@ SWIGINTERN PyObject *_wrap_SBStream_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStream_RedirectToFileHandle(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -61871,8 +62494,8 @@ SWIGINTERN PyObject *_wrap_SBStream_RedirectToFileHandle(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBStream_write(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStream *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -61908,7 +62531,7 @@ SWIGINTERN PyObject *_wrap_SBStream_write(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStream_flush(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62022,7 +62645,7 @@ SWIGINTERN PyObject *_wrap_new_SBStringList(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBStringList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62049,7 +62672,7 @@ SWIGINTERN PyObject *_wrap_delete_SBStringList(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBStringList___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62077,7 +62700,7 @@ SWIGINTERN PyObject *_wrap_SBStringList___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBStringList_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62105,8 +62728,8 @@ SWIGINTERN PyObject *_wrap_SBStringList_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBStringList_AppendString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStringList *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -62142,8 +62765,8 @@ SWIGINTERN PyObject *_wrap_SBStringList_AppendString(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBStringList_AppendList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; - char **arg2 = (char **) 0 ; + lldb::SBStringList *arg1 = 0 ; + char **arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -62206,7 +62829,7 @@ SWIGINTERN PyObject *_wrap_SBStringList_AppendList__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBStringList_AppendList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -62307,7 +62930,7 @@ SWIGINTERN PyObject *_wrap_SBStringList_AppendList(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBStringList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62335,7 +62958,7 @@ SWIGINTERN PyObject *_wrap_SBStringList_GetSize(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBStringList_GetStringAtIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -62369,7 +62992,7 @@ SWIGINTERN PyObject *_wrap_SBStringList_GetStringAtIndex__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBStringList_GetStringAtIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -62451,7 +63074,7 @@ SWIGINTERN PyObject *_wrap_SBStringList_GetStringAtIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBStringList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62623,7 +63246,7 @@ SWIGINTERN PyObject *_wrap_new_SBStructuredData(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBStructuredData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62650,7 +63273,7 @@ SWIGINTERN PyObject *_wrap_delete_SBStructuredData(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBStructuredData___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62678,7 +63301,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData___nonzero__(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBStructuredData_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62706,7 +63329,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_IsValid(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBStructuredData_SetFromJSON__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -62743,8 +63366,8 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetFromJSON__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBStructuredData_SetFromJSON__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -62825,7 +63448,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetFromJSON(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBStructuredData_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62852,7 +63475,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_Clear(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBStructuredData_GetAsJSON(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -62890,7 +63513,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetAsJSON(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBStructuredData_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -62928,7 +63551,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetDescription(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBStructuredData_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62956,7 +63579,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetType(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBStructuredData_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -62984,7 +63607,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetSize(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBStructuredData_GetKeys(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63022,8 +63645,8 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetKeys(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBStructuredData_GetValueForKey(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -63060,7 +63683,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetValueForKey(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBStructuredData_GetItemAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63095,7 +63718,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetItemAtIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63129,7 +63752,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_0(PyOb SWIGINTERN PyObject *_wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; uint64_t result; @@ -63197,7 +63820,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetUnsignedIntegerValue(PyObject *se SWIGINTERN PyObject *_wrap_SBStructuredData_GetSignedIntegerValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; int64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63231,7 +63854,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetSignedIntegerValue__SWIG_0(PyObje SWIGINTERN PyObject *_wrap_SBStructuredData_GetSignedIntegerValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int64_t result; @@ -63299,7 +63922,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetSignedIntegerValue(PyObject *self SWIGINTERN PyObject *_wrap_SBStructuredData_GetIntegerValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63333,7 +63956,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetIntegerValue__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBStructuredData_GetIntegerValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; uint64_t result; @@ -63401,7 +64024,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetIntegerValue(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBStructuredData_GetFloatValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; double arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63435,7 +64058,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetFloatValue__SWIG_0(PyObject *self SWIGINTERN PyObject *_wrap_SBStructuredData_GetFloatValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; double result; @@ -63503,7 +64126,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetFloatValue(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBStructuredData_GetBooleanValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63537,7 +64160,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetBooleanValue__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBStructuredData_GetBooleanValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -63605,8 +64228,8 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetBooleanValue(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBStructuredData_GetStringValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63659,7 +64282,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetStringValue(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBStructuredData_GetGenericValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -63697,8 +64320,8 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_GetGenericValue(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBStructuredData_SetValueForKey(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63745,7 +64368,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetValueForKey(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBStructuredData_SetUnsignedIntegerValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63779,7 +64402,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetUnsignedIntegerValue(PyObject *se SWIGINTERN PyObject *_wrap_SBStructuredData_SetSignedIntegerValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; int64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63813,7 +64436,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetSignedIntegerValue(PyObject *self SWIGINTERN PyObject *_wrap_SBStructuredData_SetFloatValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; double arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63847,7 +64470,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetFloatValue(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBStructuredData_SetBooleanValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63881,8 +64504,8 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetBooleanValue(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBStructuredData_SetStringValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -63918,7 +64541,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetStringValue(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBStructuredData_SetGenericValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; SwigValueWrapper< lldb::SBScriptObject > arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -63960,7 +64583,7 @@ SWIGINTERN PyObject *_wrap_SBStructuredData_SetGenericValue(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBStructuredData___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStructuredData *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64017,7 +64640,7 @@ SWIGINTERN PyObject *_wrap_new_SBSymbol__SWIG_0(PyObject *self, Py_ssize_t nobjs SWIGINTERN PyObject *_wrap_delete_SBSymbol(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64102,7 +64725,7 @@ SWIGINTERN PyObject *_wrap_new_SBSymbol(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64130,7 +64753,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBSymbol_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64158,7 +64781,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64186,7 +64809,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol_GetDisplayName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64214,7 +64837,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetDisplayName(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBSymbol_GetMangledName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64242,7 +64865,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetMangledName(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBSymbol_GetInstructions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -64284,9 +64907,9 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetInstructions__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBSymbol_GetInstructions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; lldb::SBTarget arg2 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; @@ -64385,7 +65008,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetInstructions(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSymbol_GetStartAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64413,7 +65036,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetStartAddress(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSymbol_GetEndAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64441,7 +65064,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetEndAddress(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBSymbol_GetValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64469,7 +65092,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetValue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64497,7 +65120,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetSize(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol_GetPrologueByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64525,7 +65148,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetPrologueByteSize(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbol_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64553,7 +65176,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; lldb::SBSymbol *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -64596,7 +65219,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; lldb::SBSymbol *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -64639,7 +65262,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -64677,7 +65300,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_GetDescription(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBSymbol_IsExternal(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64705,7 +65328,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_IsExternal(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBSymbol_IsSynthetic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64733,7 +65356,7 @@ SWIGINTERN PyObject *_wrap_SBSymbol_IsSynthetic(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBSymbol___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64848,7 +65471,7 @@ SWIGINTERN PyObject *_wrap_new_SBSymbolContext(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBSymbolContext(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64875,7 +65498,7 @@ SWIGINTERN PyObject *_wrap_delete_SBSymbolContext(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBSymbolContext___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64903,7 +65526,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext___nonzero__(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbolContext_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64931,7 +65554,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_IsValid(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBSymbolContext_GetModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64959,7 +65582,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetModule(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBSymbolContext_GetCompileUnit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -64987,7 +65610,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetCompileUnit(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBSymbolContext_GetFunction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65015,7 +65638,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetFunction(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbolContext_GetBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65043,7 +65666,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetBlock(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSymbolContext_GetLineEntry(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65071,7 +65694,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetLineEntry(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbolContext_GetSymbol(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65099,7 +65722,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetSymbol(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBSymbolContext_SetModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBModule arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65141,7 +65764,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_SetModule(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBSymbolContext_SetCompileUnit(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBCompileUnit arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65183,7 +65806,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_SetCompileUnit(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBSymbolContext_SetFunction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBFunction arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65225,7 +65848,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_SetFunction(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbolContext_SetBlock(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBBlock arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65267,7 +65890,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_SetBlock(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBSymbolContext_SetLineEntry(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBLineEntry arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65309,7 +65932,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_SetLineEntry(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbolContext_SetSymbol(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBSymbol arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65351,7 +65974,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_SetSymbol(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBSymbolContext_GetParentOfInlinedScope(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; lldb::SBAddress *arg3 = 0 ; void *argp1 = 0 ; @@ -65400,7 +66023,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetParentOfInlinedScope(PyObject *sel SWIGINTERN PyObject *_wrap_SBSymbolContext_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65438,7 +66061,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContext_GetDescription(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBSymbolContext___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbolContext *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65553,7 +66176,7 @@ SWIGINTERN PyObject *_wrap_new_SBSymbolContextList(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_delete_SBSymbolContextList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65580,7 +66203,7 @@ SWIGINTERN PyObject *_wrap_delete_SBSymbolContextList(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBSymbolContextList___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65608,7 +66231,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList___nonzero__(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBSymbolContextList_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65636,7 +66259,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList_IsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65664,7 +66287,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetSize(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetContextAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65699,7 +66322,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetContextAtIndex(PyObject *self, SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65737,7 +66360,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetDescription(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBSymbolContextList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; lldb::SBSymbolContext *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65773,7 +66396,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList_Append__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBSymbolContextList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; lldb::SBSymbolContextList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -65855,7 +66478,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList_Append(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBSymbolContextList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65882,7 +66505,7 @@ SWIGINTERN PyObject *_wrap_SBSymbolContextList_Clear(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBSymbolContextList___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -65997,7 +66620,7 @@ SWIGINTERN PyObject *_wrap_new_SBTarget(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66024,7 +66647,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTarget(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66052,7 +66675,7 @@ SWIGINTERN PyObject *_wrap_SBTarget___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66229,7 +66852,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetBroadcasterClassName(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTarget_GetProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66257,7 +66880,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetProcess(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_SetCollectingStats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -66291,7 +66914,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_SetCollectingStats(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_GetCollectingStats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66319,7 +66942,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetCollectingStats(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_GetStatistics__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBStructuredData result; @@ -66345,7 +66968,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetStatistics__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBTarget_GetStatistics__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBStatisticsOptions arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -66427,7 +67050,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetStatistics(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_ResetStatistics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66454,7 +67077,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_ResetStatistics(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTarget_GetPlatform(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66482,7 +67105,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetPlatform(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_GetEnvironment(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66510,7 +67133,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetEnvironment(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTarget_Install(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -66538,14 +67161,14 @@ SWIGINTERN PyObject *_wrap_SBTarget_Install(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_Launch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; - char **arg3 = (char **) 0 ; - char **arg4 = (char **) 0 ; - char *arg5 = (char *) 0 ; - char *arg6 = (char *) 0 ; - char *arg7 = (char *) 0 ; - char *arg8 = (char *) 0 ; + char **arg3 = 0 ; + char **arg4 = 0 ; + char *arg5 = 0 ; + char *arg6 = 0 ; + char *arg7 = 0 ; + char *arg8 = 0 ; uint32_t arg9 ; bool arg10 ; lldb::SBError *arg11 = 0 ; @@ -66708,8 +67331,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_Launch__SWIG_0(PyObject *self, Py_ssize_t no SWIGINTERN PyObject *_wrap_SBTarget_LoadCore__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -66745,8 +67368,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_LoadCore__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBTarget_LoadCore__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -66842,10 +67465,10 @@ SWIGINTERN PyObject *_wrap_SBTarget_LoadCore(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_LaunchSimple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char **arg2 = (char **) 0 ; - char **arg3 = (char **) 0 ; - char *arg4 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char **arg2 = 0 ; + char **arg3 = 0 ; + char *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res4 ; @@ -66942,7 +67565,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_LaunchSimple(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_Launch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBLaunchInfo *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -67112,7 +67735,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_Launch(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_Attach(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAttachInfo *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -67161,7 +67784,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_Attach(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_AttachToProcessWithID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; lldb::pid_t arg3 ; lldb::SBError *arg4 = 0 ; @@ -67218,9 +67841,9 @@ SWIGINTERN PyObject *_wrap_SBTarget_AttachToProcessWithID(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTarget_AttachToProcessWithName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; bool arg4 ; lldb::SBError *arg5 = 0 ; void *argp1 = 0 ; @@ -67286,10 +67909,10 @@ SWIGINTERN PyObject *_wrap_SBTarget_AttachToProcessWithName(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTarget_ConnectRemote(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBListener *arg2 = 0 ; - char *arg3 = (char *) 0 ; - char *arg4 = (char *) 0 ; + char *arg3 = 0 ; + char *arg4 = 0 ; lldb::SBError *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67357,7 +67980,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_ConnectRemote(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_GetExecutable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -67385,9 +68008,9 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetExecutable(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_AppendImageSearchPath(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; lldb::SBError *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67444,7 +68067,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_AppendImageSearchPath(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBModule *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67481,10 +68104,10 @@ SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - char *arg4 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + char *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -67540,11 +68163,11 @@ SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_1(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - char *arg4 = (char *) 0 ; - char *arg5 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + char *arg4 = 0 ; + char *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -67610,7 +68233,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_2(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBModuleSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67740,7 +68363,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_AddModule(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_GetNumModules(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -67768,7 +68391,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetNumModules(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_GetModuleAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67803,7 +68426,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetModuleAtIndex(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTarget_RemoveModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBModule arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67846,7 +68469,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_RemoveModule(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_GetDebugger(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -67874,7 +68497,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetDebugger(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_FindModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67912,7 +68535,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindModule(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_FindCompileUnits(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -67950,7 +68573,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindCompileUnits(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTarget_GetByteOrder(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -67978,7 +68601,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetByteOrder(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_GetAddressByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68006,7 +68629,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetAddressByteSize(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_GetTriple(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68034,7 +68657,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetTriple(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_GetABIName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68062,7 +68685,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetABIName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_GetLabel(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68090,8 +68713,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetLabel(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_SetLabel(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -68128,7 +68751,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_SetLabel(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_GetMinimumOpcodeByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68156,7 +68779,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetMinimumOpcodeByteSize(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBTarget_GetMaximumOpcodeByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68184,7 +68807,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetMaximumOpcodeByteSize(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBTarget_GetDataByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68212,7 +68835,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetDataByteSize(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTarget_GetCodeByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68240,7 +68863,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetCodeByteSize(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68268,7 +68891,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay(PyObject SWIGINTERN PyObject *_wrap_SBTarget_SetSectionLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBSection arg2 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -68319,7 +68942,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_SetSectionLoadAddress(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTarget_ClearSectionLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBSection arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -68362,7 +68985,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_ClearSectionLoadAddress(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTarget_SetModuleLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBModule arg2 ; uint64_t arg3 ; void *argp1 = 0 ; @@ -68413,7 +69036,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_SetModuleLoadAddress(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_ClearModuleLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBModule arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -68456,8 +69079,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_ClearModuleLoadAddress(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTarget_FindFunctions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -68501,8 +69124,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindFunctions__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBTarget_FindFunctions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -68588,8 +69211,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindFunctions(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalVariables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -68633,8 +69256,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalVariables__SWIG_0(PyObject *self, SWIGINTERN PyObject *_wrap_SBTarget_FindFirstGlobalVariable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -68671,8 +69294,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindFirstGlobalVariable(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalVariables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::MatchType arg4 ; void *argp1 = 0 ; @@ -68786,8 +69409,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalVariables(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalFunctions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::MatchType arg4 ; void *argp1 = 0 ; @@ -68840,7 +69463,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalFunctions(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -68867,7 +69490,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_ResolveFileAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -68902,7 +69525,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_ResolveFileAddress(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_ResolveLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -68937,7 +69560,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_ResolveLoadAddress(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_ResolvePastLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; uint32_t arg2 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -68980,7 +69603,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_ResolvePastLoadAddress(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTarget_ResolveSymbolContextForAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -69026,9 +69649,9 @@ SWIGINTERN PyObject *_wrap_SBTarget_ResolveSymbolContextForAddress(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_ReadMemory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress arg2 ; - void *arg3 = (void *) 0 ; + void *arg3 = 0 ; size_t arg4 ; lldb::SBError *arg5 = 0 ; void *argp1 = 0 ; @@ -69106,8 +69729,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_ReadMemory(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -69151,7 +69774,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -69196,7 +69819,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(PyObject SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; lldb::addr_t arg4 ; @@ -69249,7 +69872,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(PyObject SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; lldb::addr_t arg4 ; @@ -69313,7 +69936,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(PyObject SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; uint32_t arg4 ; @@ -69385,7 +70008,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(PyObject SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; uint32_t arg4 ; @@ -69658,9 +70281,9 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation(PyObject *self, P SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -69706,8 +70329,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -69743,8 +70366,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_1(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBFileSpecList *arg3 = 0 ; lldb::SBFileSpecList *arg4 = 0 ; void *argp1 = 0 ; @@ -69802,8 +70425,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_2(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::SBFileSpecList *arg4 = 0 ; lldb::SBFileSpecList *arg5 = 0 ; @@ -69869,8 +70492,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_3(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::LanguageType arg4 ; lldb::SBFileSpecList *arg5 = 0 ; @@ -69944,8 +70567,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_4(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::LanguageType arg4 ; lldb::addr_t arg5 ; @@ -70213,8 +70836,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char **arg2 = (char **) 0 ; + lldb::SBTarget *arg1 = 0 ; + char **arg2 = 0 ; uint32_t arg3 ; uint32_t arg4 ; lldb::SBFileSpecList *arg5 = 0 ; @@ -70297,8 +70920,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char **arg2 = (char **) 0 ; + lldb::SBTarget *arg1 = 0 ; + char **arg2 = 0 ; uint32_t arg3 ; uint32_t arg4 ; lldb::LanguageType arg5 ; @@ -70389,8 +71012,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_1(PyObject *se SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char **arg2 = (char **) 0 ; + lldb::SBTarget *arg1 = 0 ; + char **arg2 = 0 ; uint32_t arg3 ; uint32_t arg4 ; lldb::LanguageType arg5 ; @@ -70652,9 +71275,9 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -70700,8 +71323,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(PyObject *se SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -70737,8 +71360,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(PyObject *se SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBFileSpecList *arg3 = 0 ; lldb::SBFileSpecList *arg4 = 0 ; void *argp1 = 0 ; @@ -70796,8 +71419,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(PyObject *se SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::LanguageType arg3 ; lldb::SBFileSpecList *arg4 = 0 ; lldb::SBFileSpecList *arg5 = 0 ; @@ -70961,10 +71584,10 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; - char *arg4 = (char *) 0 ; + char *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -71020,8 +71643,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(PyObje SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -71068,8 +71691,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(PyObje SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBFileSpecList *arg3 = 0 ; lldb::SBFileSpecList *arg4 = 0 ; void *argp1 = 0 ; @@ -71127,8 +71750,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(PyObje SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBFileSpecList *arg3 = 0 ; lldb::SBFileSpecList *arg4 = 0 ; lldb::SBStringList *arg5 = 0 ; @@ -71301,7 +71924,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex(PyObject *self SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateForException__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::LanguageType arg2 ; bool arg3 ; bool arg4 ; @@ -71351,7 +71974,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateForException__SWIG_0(PyObjec SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateForException__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::LanguageType arg2 ; bool arg3 ; bool arg4 ; @@ -71489,7 +72112,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateForException(PyObject *self, SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -71524,7 +72147,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByAddress(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySBAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -71562,8 +72185,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySBAddress(PyObject *self, SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; lldb::SBFileSpecList *arg4 = 0 ; lldb::SBFileSpecList *arg5 = 0 ; @@ -71640,8 +72263,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateFromScript__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; lldb::SBFileSpecList *arg4 = 0 ; lldb::SBFileSpecList *arg5 = 0 ; @@ -71786,7 +72409,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateFromScript(PyObject *self, P SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBBreakpointList *arg3 = 0 ; void *argp1 = 0 ; @@ -71834,7 +72457,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(PyObject * SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsCreateFromFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBStringList *arg3 = 0 ; lldb::SBBreakpointList *arg4 = 0 ; @@ -71954,7 +72577,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsCreateFromFile(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -71991,7 +72614,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBBreakpointList *arg3 = 0 ; bool arg4 ; @@ -72047,7 +72670,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(PyObject *sel SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; lldb::SBBreakpointList *arg3 = 0 ; void *argp1 = 0 ; @@ -72172,7 +72795,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTarget_GetNumBreakpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72200,7 +72823,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetNumBreakpoints(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTarget_GetBreakpointAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72235,7 +72858,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetBreakpointAtIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_BreakpointDelete(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::break_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72270,7 +72893,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_BreakpointDelete(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTarget_FindBreakpointByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::break_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72305,8 +72928,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindBreakpointByID(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_FindBreakpointsByName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBBreakpointList *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72354,7 +72977,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindBreakpointsByName(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTarget_GetBreakpointNames(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBStringList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72391,8 +73014,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetBreakpointNames(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_DeleteBreakpointName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -72428,7 +73051,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_DeleteBreakpointName(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_EnableAllBreakpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72456,7 +73079,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_EnableAllBreakpoints(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_DisableAllBreakpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72484,7 +73107,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_DisableAllBreakpoints(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTarget_DeleteAllBreakpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72512,7 +73135,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_DeleteAllBreakpoints(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_GetNumWatchpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72540,7 +73163,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetNumWatchpoints(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTarget_GetWatchpointAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72575,7 +73198,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetWatchpointAtIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_DeleteWatchpoint(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::watch_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72610,7 +73233,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_DeleteWatchpoint(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTarget_FindWatchpointByID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::watch_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -72645,7 +73268,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindWatchpointByID(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_WatchAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::addr_t arg2 ; size_t arg3 ; bool arg4 ; @@ -72715,7 +73338,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_WatchAddress(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_WatchpointCreateByAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::addr_t arg2 ; size_t arg3 ; lldb::SBWatchpointOptions arg4 ; @@ -72785,7 +73408,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_WatchpointCreateByAddress(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTarget_EnableAllWatchpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72813,7 +73436,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_EnableAllWatchpoints(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_DisableAllWatchpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72841,7 +73464,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_DisableAllWatchpoints(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTarget_DeleteAllWatchpoints(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72869,7 +73492,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_DeleteAllWatchpoints(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTarget_GetBroadcaster(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -72897,8 +73520,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetBroadcaster(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTarget_FindFirstType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -72935,8 +73558,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindFirstType(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_FindTypes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -72973,7 +73596,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindTypes(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_GetBasicType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::BasicType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -73008,8 +73631,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetBasicType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBAddress arg3 ; lldb::SBType arg4 ; void *argp1 = 0 ; @@ -73078,8 +73701,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromAddress(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBData arg3 ; lldb::SBType arg4 ; void *argp1 = 0 ; @@ -73148,9 +73771,9 @@ SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromData(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromExpression(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -73197,7 +73820,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromExpression(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTarget_GetSourceManager(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -73225,7 +73848,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetSourceManager(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress arg2 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -73275,10 +73898,10 @@ SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_0(PyObject *self, Py_ SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress arg2 ; uint32_t arg3 ; - char *arg4 = (char *) 0 ; + char *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; @@ -73336,10 +73959,10 @@ SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_1(PyObject *self, Py_ SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress arg2 ; lldb::SBAddress arg3 ; - char *arg4 = (char *) 0 ; + char *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; @@ -73487,9 +74110,9 @@ SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTarget_GetInstructions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress arg2 ; - void *arg3 = (void *) 0 ; + void *arg3 = 0 ; size_t arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -73550,10 +74173,10 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetInstructions(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTarget_GetInstructionsWithFlavor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBAddress arg2 ; - char *arg3 = (char *) 0 ; - void *arg4 = (void *) 0 ; + char *arg3 = 0 ; + void *arg4 = 0 ; size_t arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -73624,8 +74247,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetInstructionsWithFlavor(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTarget_FindSymbols__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SymbolType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -73669,8 +74292,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindSymbols__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBTarget_FindSymbols__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -73756,7 +74379,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_FindSymbols(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -73799,7 +74422,7 @@ SWIGINTERN PyObject *_wrap_SBTarget___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -73842,7 +74465,7 @@ SWIGINTERN PyObject *_wrap_SBTarget___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -73888,8 +74511,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetDescription(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTarget_EvaluateExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -73925,8 +74548,8 @@ SWIGINTERN PyObject *_wrap_SBTarget_EvaluateExpression__SWIG_0(PyObject *self, P SWIGINTERN PyObject *_wrap_SBTarget_EvaluateExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBExpressionOptions *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74021,7 +74644,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_EvaluateExpression(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_GetStackRedZoneSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74049,7 +74672,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetStackRedZoneSize(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTarget_IsLoaded(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBModule *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74087,7 +74710,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_IsLoaded(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_GetLaunchInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74115,7 +74738,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetLaunchInfo(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_SetLaunchInfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBLaunchInfo *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74152,7 +74775,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_SetLaunchInfo(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTarget_GetTrace(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74180,7 +74803,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetTrace(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTarget_CreateTrace(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74218,7 +74841,7 @@ SWIGINTERN PyObject *_wrap_SBTarget_CreateTrace(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTarget_GetAPIMutex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74244,9 +74867,109 @@ SWIGINTERN PyObject *_wrap_SBTarget_GetAPIMutex(PyObject *self, PyObject *args) } +SWIGINTERN PyObject *_wrap_SBTarget_RegisterScriptedFrameProvider(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = 0 ; + lldb::SBStructuredData arg3 ; + lldb::SBError *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + uint32_t result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SBTarget_RegisterScriptedFrameProvider", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "1"" of type '" "lldb::SBTarget *""'"); + } + arg1 = reinterpret_cast< lldb::SBTarget * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "3"" of type '" "lldb::SBStructuredData""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "3"" of type '" "lldb::SBStructuredData""'"); + } else { + lldb::SBStructuredData * temp = reinterpret_cast< lldb::SBStructuredData * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "4"" of type '" "lldb::SBError &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "4"" of type '" "lldb::SBError &""'"); + } + arg4 = reinterpret_cast< lldb::SBError * >(argp4); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (uint32_t)(arg1)->RegisterScriptedFrameProvider((char const *)arg2,SWIG_STD_MOVE(arg3),*arg4); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SBTarget_RemoveScriptedFrameProvider(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBTarget *arg1 = 0 ; + uint32_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + lldb::SBError result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SBTarget_RemoveScriptedFrameProvider", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_RemoveScriptedFrameProvider" "', argument " "1"" of type '" "lldb::SBTarget *""'"); + } + arg1 = reinterpret_cast< lldb::SBTarget * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_RemoveScriptedFrameProvider" "', argument " "2"" of type '" "uint32_t""'"); + } + arg2 = static_cast< uint32_t >(val2); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (arg1)->RemoveScriptedFrameProvider(arg2); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_SBTarget___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74379,7 +75102,7 @@ SWIGINTERN PyObject *_wrap_new_SBThread(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74406,7 +75129,7 @@ SWIGINTERN PyObject *_wrap_delete_SBThread(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetQueue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74434,7 +75157,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetQueue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74462,7 +75185,7 @@ SWIGINTERN PyObject *_wrap_SBThread___nonzero__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBThread_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74490,7 +75213,7 @@ SWIGINTERN PyObject *_wrap_SBThread_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74517,7 +75240,7 @@ SWIGINTERN PyObject *_wrap_SBThread_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetStopReason(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74545,7 +75268,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopReason(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonDataCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74573,7 +75296,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonDataCount(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonDataAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74608,7 +75331,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonDataAtIndex(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonExtendedInfoAsJSON(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74646,7 +75369,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonExtendedInfoAsJSON(PyObject *se SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonExtendedBacktraces(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::InstrumentationRuntimeType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74681,8 +75404,8 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonExtendedBacktraces(PyObject *se SWIGINTERN PyObject *_wrap_SBThread_GetStopDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74729,7 +75452,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThread_GetStopReturnValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74757,7 +75480,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopReturnValue(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThread_GetStopErrorValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74785,7 +75508,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopErrorValue(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBThread_GetStopReturnOrErrorValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; bool *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -74823,7 +75546,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStopReturnOrErrorValue(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBThread_GetThreadID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74851,7 +75574,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetThreadID(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBThread_GetIndexID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74879,7 +75602,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetIndexID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74907,7 +75630,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetQueueName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74935,7 +75658,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetQueueName(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBThread_GetQueueID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -74963,8 +75686,8 @@ SWIGINTERN PyObject *_wrap_SBThread_GetQueueID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetInfoItemByPathAsString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStream *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75012,7 +75735,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetInfoItemByPathAsString(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::RunMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75045,7 +75768,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75070,7 +75793,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_1(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::RunMode arg2 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -75177,7 +75900,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOver(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::RunMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75210,7 +75933,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75235,8 +75958,8 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_1(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; lldb::RunMode arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75279,8 +76002,8 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_2(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -75315,8 +76038,8 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_3(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::SBError *arg4 = 0 ; lldb::RunMode arg5 ; @@ -75378,8 +76101,8 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_4(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::SBError *arg4 = 0 ; void *argp1 = 0 ; @@ -75565,7 +76288,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInto(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_StepOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75590,7 +76313,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOut__SWIG_0(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_SBThread_StepOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75667,7 +76390,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOut(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_StepOutOfFrame__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75703,7 +76426,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOutOfFrame__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBThread_StepOutOfFrame__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -75801,7 +76524,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOutOfFrame(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBThread_StepInstruction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -75834,7 +76557,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInstruction__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBThread_StepInstruction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; bool arg2 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -75931,7 +76654,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepInstruction(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBThread_StepOverUntil(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; uint32_t arg4 ; @@ -75988,8 +76711,8 @@ SWIGINTERN PyObject *_wrap_SBThread_StepOverUntil(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -76025,8 +76748,8 @@ SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -76070,8 +76793,8 @@ SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(PyObject SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; bool arg4 ; void *argp1 = 0 ; @@ -76201,7 +76924,7 @@ SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan(PyObject *self, SWIGINTERN PyObject *_wrap_SBThread_JumpToLine(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBFileSpec *arg2 = 0 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -76247,7 +76970,7 @@ SWIGINTERN PyObject *_wrap_SBThread_JumpToLine(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_RunToAddress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::addr_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -76280,7 +77003,7 @@ SWIGINTERN PyObject *_wrap_SBThread_RunToAddress__SWIG_0(PyObject *self, Py_ssiz SWIGINTERN PyObject *_wrap_SBThread_RunToAddress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::addr_t arg2 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -76377,7 +77100,7 @@ SWIGINTERN PyObject *_wrap_SBThread_RunToAddress(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBThread_ReturnFromFrame(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBFrame *arg2 = 0 ; lldb::SBValue *arg3 = 0 ; void *argp1 = 0 ; @@ -76426,7 +77149,7 @@ SWIGINTERN PyObject *_wrap_SBThread_ReturnFromFrame(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBThread_UnwindInnermostExpression(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -76454,7 +77177,7 @@ SWIGINTERN PyObject *_wrap_SBThread_UnwindInnermostExpression(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBThread_Suspend__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -76480,7 +77203,7 @@ SWIGINTERN PyObject *_wrap_SBThread_Suspend__SWIG_0(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_SBThread_Suspend__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -76558,7 +77281,7 @@ SWIGINTERN PyObject *_wrap_SBThread_Suspend(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_Resume__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -76584,7 +77307,7 @@ SWIGINTERN PyObject *_wrap_SBThread_Resume__SWIG_0(PyObject *self, Py_ssize_t no SWIGINTERN PyObject *_wrap_SBThread_Resume__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -76662,7 +77385,7 @@ SWIGINTERN PyObject *_wrap_SBThread_Resume(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_IsSuspended(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -76690,7 +77413,7 @@ SWIGINTERN PyObject *_wrap_SBThread_IsSuspended(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBThread_IsStopped(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -76718,7 +77441,7 @@ SWIGINTERN PyObject *_wrap_SBThread_IsStopped(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetNumFrames(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -76746,7 +77469,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetNumFrames(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBThread_GetFrameAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -76779,9 +77502,37 @@ SWIGINTERN PyObject *_wrap_SBThread_GetFrameAtIndex(PyObject *self, PyObject *ar } +SWIGINTERN PyObject *_wrap_SBThread_GetFrames(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + lldb::SBThread *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + lldb::SBFrameList result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetFrames" "', argument " "1"" of type '" "lldb::SBThread *""'"); + } + arg1 = reinterpret_cast< lldb::SBThread * >(argp1); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (arg1)->GetFrames(); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_NewPointerObj((new lldb::SBFrameList(result)), SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_SBThread_GetSelectedFrame(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -76809,7 +77560,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetSelectedFrame(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBThread_SetSelectedFrame(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -76937,7 +77688,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetThreadFromEvent(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThread_GetProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -76965,7 +77716,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetProcess(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBThread *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -77008,7 +77759,7 @@ SWIGINTERN PyObject *_wrap_SBThread___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBThread *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -77051,7 +77802,7 @@ SWIGINTERN PyObject *_wrap_SBThread___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -77088,7 +77839,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetDescription__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBThread_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -77185,7 +77936,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetDescription(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBThread_GetDescriptionWithFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBFormat *arg2 = 0 ; lldb::SBStream *arg3 = 0 ; void *argp1 = 0 ; @@ -77234,7 +77985,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetDescriptionWithFormat(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBThread_GetStatus(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -77272,8 +78023,8 @@ SWIGINTERN PyObject *_wrap_SBThread_GetStatus(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread_GetExtendedBacktraceThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThread *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -77310,7 +78061,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetExtendedBacktraceThread(PyObject *self, P SWIGINTERN PyObject *_wrap_SBThread_GetExtendedBacktraceOriginatingIndexID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77338,7 +78089,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetExtendedBacktraceOriginatingIndexID(PyObj SWIGINTERN PyObject *_wrap_SBThread_GetCurrentException(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77366,7 +78117,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetCurrentException(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThread_GetCurrentExceptionBacktrace(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77394,7 +78145,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetCurrentExceptionBacktrace(PyObject *self, SWIGINTERN PyObject *_wrap_SBThread_SafeToCallFunctions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77422,7 +78173,7 @@ SWIGINTERN PyObject *_wrap_SBThread_SafeToCallFunctions(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThread_GetSiginfo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77450,7 +78201,7 @@ SWIGINTERN PyObject *_wrap_SBThread_GetSiginfo(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThread___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77565,7 +78316,7 @@ SWIGINTERN PyObject *_wrap_new_SBThreadCollection(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_delete_SBThreadCollection(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + lldb::SBThreadCollection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77592,7 +78343,7 @@ SWIGINTERN PyObject *_wrap_delete_SBThreadCollection(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBThreadCollection___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + lldb::SBThreadCollection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77620,7 +78371,7 @@ SWIGINTERN PyObject *_wrap_SBThreadCollection___nonzero__(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBThreadCollection_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + lldb::SBThreadCollection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77648,7 +78399,7 @@ SWIGINTERN PyObject *_wrap_SBThreadCollection_IsValid(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBThreadCollection_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + lldb::SBThreadCollection *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77676,7 +78427,7 @@ SWIGINTERN PyObject *_wrap_SBThreadCollection_GetSize(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBThreadCollection_GetThreadAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + lldb::SBThreadCollection *arg1 = 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -77770,7 +78521,7 @@ SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_1(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; lldb::SBThread *arg1 = 0 ; - char *arg2 = (char *) 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -77810,7 +78561,7 @@ SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_2(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; lldb::SBThread *arg1 = 0 ; - char *arg2 = (char *) 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -77922,7 +78673,7 @@ SWIGINTERN PyObject *_wrap_new_SBThreadPlan(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBThreadPlan(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77949,7 +78700,7 @@ SWIGINTERN PyObject *_wrap_delete_SBThreadPlan(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThreadPlan___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -77977,7 +78728,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBThreadPlan_IsValid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -78003,7 +78754,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_IsValid__SWIG_0(PyObject *self, Py_ssize SWIGINTERN PyObject *_wrap_SBThreadPlan_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -78030,7 +78781,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReason(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -78058,7 +78809,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReason(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReasonDataCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -78086,7 +78837,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReasonDataCount(PyObject *self, P SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReasonDataAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -78121,7 +78872,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReasonDataAtIndex(PyObject *self, SWIGINTERN PyObject *_wrap_SBThreadPlan_GetThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -78149,7 +78900,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_GetThread(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBThreadPlan_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -78187,7 +78938,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThreadPlan_SetPlanComplete(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -78221,7 +78972,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_SetPlanComplete(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThreadPlan_IsPlanComplete(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -78249,7 +79000,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_IsPlanComplete(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBThreadPlan_IsPlanStale(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -78277,7 +79028,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_IsPlanStale(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBThreadPlan_IsValid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; bool result; @@ -78339,7 +79090,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopOthers(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -78367,7 +79118,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopOthers(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBThreadPlan_SetStopOthers(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -78401,7 +79152,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_SetStopOthers(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -78446,7 +79197,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_0( SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; lldb::addr_t arg3 ; lldb::SBError *arg4 = 0 ; @@ -78565,7 +79316,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOverRange(PyObject SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; lldb::addr_t arg3 ; void *argp1 = 0 ; @@ -78610,7 +79361,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_0(Py SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; lldb::SBAddress *arg2 = 0 ; lldb::addr_t arg3 ; lldb::SBError *arg4 = 0 ; @@ -78729,7 +79480,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepInRange(PyObject * SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; uint32_t arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -78771,7 +79522,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(PyObje SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -78805,7 +79556,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(PyObje SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; uint32_t arg2 ; bool arg3 ; lldb::SBError *arg4 = 0 ; @@ -78939,7 +79690,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut(PyObject *self SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepSingleInstruction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; bool arg2 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -78985,7 +79736,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepSingleInstruction( SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; lldb::SBAddress arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -79027,7 +79778,7 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_0(P SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; lldb::SBAddress arg2 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -79129,8 +79880,8 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForRunToAddress(PyObject SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -79166,8 +79917,8 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(P SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -79214,8 +79965,8 @@ SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(P SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBThreadPlan *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; lldb::SBError *arg4 = 0 ; void *argp1 = 0 ; @@ -79427,7 +80178,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_LoadTraceFromFile(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTrace_CreateNewCursor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::SBThread *arg3 = 0 ; void *argp1 = 0 ; @@ -79476,7 +80227,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_CreateNewCursor(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTrace_SaveToDisk__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; bool arg4 ; @@ -79532,7 +80283,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_SaveToDisk__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBTrace_SaveToDisk__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; lldb::SBError *arg2 = 0 ; lldb::SBFileSpec *arg3 = 0 ; void *argp1 = 0 ; @@ -79640,7 +80391,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_SaveToDisk(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTrace_GetStartConfigurationHelp(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -79668,7 +80419,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_GetStartConfigurationHelp(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBTrace_Start__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; lldb::SBStructuredData *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -79705,7 +80456,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_Start__SWIG_0(PyObject *self, Py_ssize_t nobj SWIGINTERN PyObject *_wrap_SBTrace_Start__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; lldb::SBThread *arg2 = 0 ; lldb::SBStructuredData *arg3 = 0 ; void *argp1 = 0 ; @@ -79801,7 +80552,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_Start(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTrace_Stop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBError result; @@ -79827,7 +80578,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_Stop__SWIG_0(PyObject *self, Py_ssize_t nobjs SWIGINTERN PyObject *_wrap_SBTrace_Stop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; lldb::SBThread *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -79904,7 +80655,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_Stop(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTrace___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -79932,7 +80683,7 @@ SWIGINTERN PyObject *_wrap_SBTrace___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTrace_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -79960,7 +80711,7 @@ SWIGINTERN PyObject *_wrap_SBTrace_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTrace(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBTrace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80016,7 +80767,7 @@ SWIGINTERN PyObject *_wrap_new_SBTraceCursor(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTraceCursor_SetForwards(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -80050,7 +80801,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_SetForwards(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTraceCursor_IsForwards(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80078,7 +80829,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_IsForwards(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTraceCursor_Next(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80105,7 +80856,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_Next(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTraceCursor_HasValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80133,7 +80884,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_HasValue(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTraceCursor_GoToId(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; lldb::user_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -80168,7 +80919,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GoToId(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTraceCursor_HasId(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; lldb::user_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -80203,7 +80954,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_HasId(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTraceCursor_GetId(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80231,7 +80982,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GetId(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTraceCursor_Seek(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; int64_t arg2 ; lldb::TraceCursorSeekType arg3 ; void *argp1 = 0 ; @@ -80274,7 +81025,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_Seek(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTraceCursor_GetItemKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80302,7 +81053,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GetItemKind(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTraceCursor_IsError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80330,7 +81081,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_IsError(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTraceCursor_GetError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80358,7 +81109,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GetError(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTraceCursor_IsEvent(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80386,7 +81137,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_IsEvent(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTraceCursor_GetEventType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80414,7 +81165,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GetEventType(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTraceCursor_GetEventTypeAsString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80442,7 +81193,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GetEventTypeAsString(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTraceCursor_IsInstruction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80470,7 +81221,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_IsInstruction(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTraceCursor_GetLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80498,7 +81249,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GetLoadAddress(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTraceCursor_GetCPU(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80526,7 +81277,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_GetCPU(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTraceCursor_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80554,7 +81305,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTraceCursor___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80582,7 +81333,7 @@ SWIGINTERN PyObject *_wrap_SBTraceCursor___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_delete_SBTraceCursor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::SBTraceCursor *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80696,7 +81447,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeMember(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTypeMember(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80723,7 +81474,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeMember(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeMember___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80751,7 +81502,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeMember_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80779,7 +81530,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeMember_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80807,7 +81558,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_GetName(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeMember_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80835,7 +81586,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_GetType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeMember_GetOffsetInBytes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80863,7 +81614,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_GetOffsetInBytes(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeMember_GetOffsetInBits(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80891,7 +81642,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_GetOffsetInBits(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeMember_IsBitfield(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80919,7 +81670,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_IsBitfield(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeMember_GetBitfieldSizeInBits(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -80947,7 +81698,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_GetBitfieldSizeInBits(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTypeMember_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -80993,7 +81744,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMember_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeMember___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBTypeMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81108,7 +81859,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeMemberFunction(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_delete_SBTypeMemberFunction(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81135,7 +81886,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeMemberFunction(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeMemberFunction___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81163,7 +81914,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction___nonzero__(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81191,7 +81942,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_IsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81219,7 +81970,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetName(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetDemangledName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81247,7 +81998,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetDemangledName(PyObject *self, SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetMangledName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81275,7 +82026,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetMangledName(PyObject *self, P SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81303,7 +82054,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetReturnType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81331,7 +82082,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetReturnType(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetNumberOfArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81359,7 +82110,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetNumberOfArguments(PyObject *s SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -81394,7 +82145,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex(PyObject SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81422,7 +82173,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetKind(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -81468,7 +82219,7 @@ SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetDescription(PyObject *self, P SWIGINTERN PyObject *_wrap_SBTypeMemberFunction___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBTypeMemberFunction *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81583,7 +82334,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeStaticField(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBTypeStaticField(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTypeStaticField *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81610,7 +82361,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeStaticField(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeStaticField___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTypeStaticField *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81638,7 +82389,7 @@ SWIGINTERN PyObject *_wrap_SBTypeStaticField___nonzero__(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeStaticField_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTypeStaticField *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81666,7 +82417,7 @@ SWIGINTERN PyObject *_wrap_SBTypeStaticField_IsValid(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTypeStaticField *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81694,7 +82445,7 @@ SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetName(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetMangledName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTypeStaticField *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81722,7 +82473,7 @@ SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetMangledName(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTypeStaticField *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81750,7 +82501,7 @@ SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetType(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetConstantValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTypeStaticField *arg1 = 0 ; lldb::SBTarget arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -81880,7 +82631,7 @@ SWIGINTERN PyObject *_wrap_new_SBType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81907,7 +82658,7 @@ SWIGINTERN PyObject *_wrap_delete_SBType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81935,7 +82686,7 @@ SWIGINTERN PyObject *_wrap_SBType___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81963,7 +82714,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_GetByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -81991,7 +82742,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetByteSize(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_GetByteAlign(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82019,7 +82770,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetByteAlign(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_IsPointerType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82047,7 +82798,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsPointerType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_IsReferenceType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82075,7 +82826,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsReferenceType(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBType_IsFunctionType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82103,7 +82854,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsFunctionType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_IsPolymorphicClass(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82131,7 +82882,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsPolymorphicClass(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBType_IsArrayType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82159,7 +82910,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsArrayType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_IsVectorType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82187,7 +82938,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsVectorType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_IsTypedefType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82215,7 +82966,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsTypedefType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_IsAnonymousType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82243,7 +82994,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsAnonymousType(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBType_IsScopedEnumerationType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82271,7 +83022,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsScopedEnumerationType(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBType_IsAggregateType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82299,7 +83050,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsAggregateType(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBType_GetPointerType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82327,7 +83078,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetPointerType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_GetPointeeType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82355,7 +83106,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetPointeeType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_GetReferenceType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82383,7 +83134,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetReferenceType(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBType_GetTypedefedType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82411,7 +83162,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetTypedefedType(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBType_GetDereferencedType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82439,7 +83190,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetDereferencedType(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBType_GetUnqualifiedType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82467,7 +83218,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetUnqualifiedType(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBType_GetArrayElementType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82495,7 +83246,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetArrayElementType(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBType_GetArrayType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -82530,7 +83281,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetArrayType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_GetVectorElementType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82558,7 +83309,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetVectorElementType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBType_GetCanonicalType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82586,7 +83337,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetCanonicalType(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBType_GetEnumerationIntegerType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82614,7 +83365,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetEnumerationIntegerType(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBType_GetBasicType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::BasicType result; @@ -82640,7 +83391,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetBasicType__SWIG_0(PyObject *self, Py_ssize_ SWIGINTERN PyObject *_wrap_SBType_GetBasicType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; lldb::BasicType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -82716,7 +83467,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetBasicType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_GetNumberOfFields(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82744,7 +83495,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetNumberOfFields(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBType_GetNumberOfDirectBaseClasses(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82772,7 +83523,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetNumberOfDirectBaseClasses(PyObject *self, P SWIGINTERN PyObject *_wrap_SBType_GetNumberOfVirtualBaseClasses(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82800,7 +83551,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetNumberOfVirtualBaseClasses(PyObject *self, SWIGINTERN PyObject *_wrap_SBType_GetFieldAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -82835,7 +83586,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetFieldAtIndex(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBType_GetDirectBaseClassAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -82870,7 +83621,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetDirectBaseClassAtIndex(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBType_GetVirtualBaseClassAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -82905,8 +83656,8 @@ SWIGINTERN PyObject *_wrap_SBType_GetVirtualBaseClassAtIndex(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBType_GetStaticFieldWithName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBType *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -82943,7 +83694,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetStaticFieldWithName(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBType_GetEnumMembers(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82971,7 +83722,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetEnumMembers(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_GetNumberOfTemplateArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -82999,7 +83750,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetNumberOfTemplateArguments(PyObject *self, P SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -83034,7 +83785,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentType(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; lldb::SBTarget arg2 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -83085,7 +83836,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentValue(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -83120,7 +83871,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentKind(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBType_GetFunctionReturnType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83148,7 +83899,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetFunctionReturnType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBType_GetFunctionArgumentTypes(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83176,7 +83927,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetFunctionArgumentTypes(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBType_GetNumberOfMemberFunctions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83204,7 +83955,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetNumberOfMemberFunctions(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBType_GetMemberFunctionAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -83239,7 +83990,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetMemberFunctionAtIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBType_GetModule(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83267,7 +84018,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetModule(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83295,7 +84046,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_GetDisplayTypeName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83323,7 +84074,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetDisplayTypeName(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBType_GetTypeClass(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83351,7 +84102,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetTypeClass(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_IsTypeComplete(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83379,7 +84130,7 @@ SWIGINTERN PyObject *_wrap_SBType_IsTypeComplete(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_GetTypeFlags(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83407,7 +84158,7 @@ SWIGINTERN PyObject *_wrap_SBType_GetTypeFlags(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -83453,8 +84204,8 @@ SWIGINTERN PyObject *_wrap_SBType_GetDescription(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBType_FindDirectNestedType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBType *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -83491,7 +84242,7 @@ SWIGINTERN PyObject *_wrap_SBType_FindDirectNestedType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBType___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; lldb::SBType *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -83534,7 +84285,7 @@ SWIGINTERN PyObject *_wrap_SBType___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; lldb::SBType *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -83577,7 +84328,7 @@ SWIGINTERN PyObject *_wrap_SBType___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBType___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83692,7 +84443,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeList(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTypeList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + lldb::SBTypeList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83719,7 +84470,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeList(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeList___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + lldb::SBTypeList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83747,7 +84498,7 @@ SWIGINTERN PyObject *_wrap_SBTypeList___nonzero__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeList_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + lldb::SBTypeList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83775,7 +84526,7 @@ SWIGINTERN PyObject *_wrap_SBTypeList_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeList_Append(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + lldb::SBTypeList *arg1 = 0 ; lldb::SBType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -83817,7 +84568,7 @@ SWIGINTERN PyObject *_wrap_SBTypeList_Append(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeList_GetTypeAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + lldb::SBTypeList *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -83852,7 +84603,7 @@ SWIGINTERN PyObject *_wrap_SBTypeList_GetTypeAtIndex(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + lldb::SBTypeList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83967,7 +84718,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeCategory(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTypeCategory(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -83994,7 +84745,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeCategory(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeCategory___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84022,7 +84773,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory___nonzero__(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTypeCategory_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84050,7 +84801,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_IsValid(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeCategory_GetEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84078,7 +84829,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetEnabled(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeCategory_SetEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84112,7 +84863,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_SetEnabled(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeCategory_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84140,7 +84891,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetName(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeCategory_GetLanguageAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84175,7 +84926,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetLanguageAtIndex(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumLanguages(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84203,7 +84954,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumLanguages(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTypeCategory_AddLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::LanguageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84237,7 +84988,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_AddLanguage(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTypeCategory_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -84283,7 +85034,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetDescription(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumFormats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84311,7 +85062,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumFormats(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumSummaries(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84339,7 +85090,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumSummaries(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumFilters(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84367,7 +85118,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumFilters(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumSynthetics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -84395,7 +85146,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumSynthetics(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84430,7 +85181,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(P SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84465,7 +85216,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(P SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84500,7 +85251,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex( SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84535,7 +85286,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtInde SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFilterForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84578,7 +85329,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFilterForType(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFormatForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84621,7 +85372,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFormatForType(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSummaryForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84664,7 +85415,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSummaryForType(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSyntheticForType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84707,7 +85458,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSyntheticForType(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFilterAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84742,7 +85493,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFilterAtIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFormatAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84777,7 +85528,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFormatAtIndex(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSummaryAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84812,7 +85563,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSummaryAtIndex(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSyntheticAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84847,7 +85598,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSyntheticAtIndex(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; lldb::SBTypeFormat arg3 ; void *argp1 = 0 ; @@ -84906,7 +85657,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeFormat(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -84949,7 +85700,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeFormat(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeSummary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; lldb::SBTypeSummary arg3 ; void *argp1 = 0 ; @@ -85008,7 +85759,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeSummary(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeSummary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -85051,7 +85802,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeSummary(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeFilter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; lldb::SBTypeFilter arg3 ; void *argp1 = 0 ; @@ -85110,7 +85861,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeFilter(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeFilter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -85153,7 +85904,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeFilter(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeSynthetic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; lldb::SBTypeSynthetic arg3 ; void *argp1 = 0 ; @@ -85212,7 +85963,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeSynthetic(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeSynthetic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeNameSpecifier arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -85255,7 +86006,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeSynthetic(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTypeCategory___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeCategory *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -85298,7 +86049,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory___eq__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeCategory___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; lldb::SBTypeCategory *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -85341,7 +86092,7 @@ SWIGINTERN PyObject *_wrap_SBTypeCategory___ne__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeCategory___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85456,7 +86207,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeEnumMember(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_delete_SBTypeEnumMember(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85483,7 +86234,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeEnumMember(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeEnumMember___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85511,7 +86262,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMember___nonzero__(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeEnumMember_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85539,7 +86290,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMember_IsValid(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetValueAsSigned(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85567,7 +86318,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetValueAsSigned(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetValueAsUnsigned(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85595,7 +86346,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetValueAsUnsigned(PyObject *self, P SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85623,7 +86374,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetName(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85651,7 +86402,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetType(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -85697,7 +86448,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetDescription(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeEnumMember___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBTypeEnumMember *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85812,7 +86563,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeEnumMemberList(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_delete_SBTypeEnumMemberList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + lldb::SBTypeEnumMemberList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85839,7 +86590,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeEnumMemberList(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + lldb::SBTypeEnumMemberList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85867,7 +86618,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList___nonzero__(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + lldb::SBTypeEnumMemberList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -85895,7 +86646,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_IsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_Append(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + lldb::SBTypeEnumMemberList *arg1 = 0 ; lldb::SBTypeEnumMember arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -85937,7 +86688,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_Append(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + lldb::SBTypeEnumMemberList *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -85972,7 +86723,7 @@ SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(PyObjec SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + lldb::SBTypeEnumMemberList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86124,7 +86875,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeFilter(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTypeFilter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86151,7 +86902,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeFilter(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeFilter___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86179,7 +86930,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeFilter_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86207,7 +86958,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeFilter_GetNumberOfExpressionPaths(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86235,7 +86986,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_GetNumberOfExpressionPaths(PyObject *sel SWIGINTERN PyObject *_wrap_SBTypeFilter_GetExpressionPathAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -86270,9 +87021,9 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_GetExpressionPathAtIndex(PyObject *self, SWIGINTERN PyObject *_wrap_SBTypeFilter_ReplaceExpressionPathAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; uint32_t arg2 ; - char *arg3 = (char *) 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; @@ -86316,8 +87067,8 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_ReplaceExpressionPathAtIndex(PyObject *s SWIGINTERN PyObject *_wrap_SBTypeFilter_AppendExpressionPath(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -86353,7 +87104,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_AppendExpressionPath(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBTypeFilter_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86380,7 +87131,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeFilter_GetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86408,7 +87159,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_GetOptions(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeFilter_SetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -86442,7 +87193,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_SetOptions(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeFilter_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -86488,7 +87239,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeFilter_IsEqualTo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; lldb::SBTypeFilter *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -86526,7 +87277,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter_IsEqualTo(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeFilter___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; lldb::SBTypeFilter *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -86569,7 +87320,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeFilter___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; lldb::SBTypeFilter *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -86612,7 +87363,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFilter___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeFilter___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86729,7 +87480,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_2(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; uint32_t arg2 ; int res1 ; char *buf1 = 0 ; @@ -86766,7 +87517,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_3(PyObject *self, Py_ssize_t n SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -86905,7 +87656,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeFormat(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTypeFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86932,7 +87683,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeFormat(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeFormat___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86960,7 +87711,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeFormat_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -86988,7 +87739,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeFormat_GetFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87016,7 +87767,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_GetFormat(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeFormat_GetTypeName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87044,7 +87795,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_GetTypeName(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeFormat_GetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87072,7 +87823,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_GetOptions(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeFormat_SetFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; lldb::Format arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -87106,8 +87857,8 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_SetFormat(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeFormat_SetTypeName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -87143,7 +87894,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_SetTypeName(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeFormat_SetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -87177,7 +87928,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_SetOptions(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeFormat_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -87223,7 +87974,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeFormat_IsEqualTo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; lldb::SBTypeFormat *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -87261,7 +88012,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat_IsEqualTo(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeFormat___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; lldb::SBTypeFormat *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -87304,7 +88055,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeFormat___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; lldb::SBTypeFormat *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -87347,7 +88098,7 @@ SWIGINTERN PyObject *_wrap_SBTypeFormat___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBTypeFormat___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87404,7 +88155,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; bool arg2 ; int res1 ; char *buf1 = 0 ; @@ -87441,7 +88192,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_1(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -87470,7 +88221,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_2(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; lldb::FormatterMatchType arg2 ; int res1 ; char *buf1 = 0 ; @@ -87647,7 +88398,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_delete_SBTypeNameSpecifier(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87674,7 +88425,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeNameSpecifier(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87702,7 +88453,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___nonzero__(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87730,7 +88481,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87758,7 +88509,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetName(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87786,7 +88537,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetType(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetMatchType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87814,7 +88565,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetMatchType(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsRegex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -87842,7 +88593,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsRegex(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -87888,7 +88639,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetDescription(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsEqualTo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; lldb::SBTypeNameSpecifier *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -87926,7 +88677,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsEqualTo(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; lldb::SBTypeNameSpecifier *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -87969,7 +88720,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___eq__(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; lldb::SBTypeNameSpecifier *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -88012,7 +88763,7 @@ SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___ne__(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88127,7 +88878,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeSummaryOptions(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_delete_SBTypeSummaryOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::SBTypeSummaryOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88154,7 +88905,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeSummaryOptions(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::SBTypeSummaryOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88182,7 +88933,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions___nonzero__(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::SBTypeSummaryOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88210,7 +88961,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_IsValid(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_GetLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::SBTypeSummaryOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88238,7 +88989,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_GetLanguage(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_GetCapping(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::SBTypeSummaryOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88266,7 +89017,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_GetCapping(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_SetLanguage(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::SBTypeSummaryOptions *arg1 = 0 ; lldb::LanguageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -88300,7 +89051,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_SetLanguage(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_SetCapping(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::SBTypeSummaryOptions *arg1 = 0 ; lldb::TypeSummaryCapping arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -88363,7 +89114,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeSummary__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; uint32_t arg2 ; int res1 ; char *buf1 = 0 ; @@ -88400,7 +89151,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(PyObjec SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithSummaryString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -88469,7 +89220,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithSummaryString(PyObject *self, SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; uint32_t arg2 ; int res1 ; char *buf1 = 0 ; @@ -88506,7 +89257,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithFunctionName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -88575,7 +89326,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithFunctionName(PyObject *self, SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; uint32_t arg2 ; int res1 ; char *buf1 = 0 ; @@ -88612,7 +89363,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(PyObject * SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithScriptCode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -88739,7 +89490,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeSummary(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTypeSummary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88766,7 +89517,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeSummary(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeSummary___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88794,7 +89545,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeSummary_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88822,7 +89573,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeSummary_IsFunctionCode(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88850,7 +89601,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_IsFunctionCode(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSummary_IsFunctionName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88878,7 +89629,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_IsFunctionName(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSummary_IsSummaryString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88906,7 +89657,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_IsSummaryString(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeSummary_GetData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -88934,8 +89685,8 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_GetData(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeSummary_SetSummaryString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -88971,8 +89722,8 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_SetSummaryString(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTypeSummary_SetFunctionName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -89008,8 +89759,8 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_SetFunctionName(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeSummary_SetFunctionCode(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -89045,7 +89796,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_SetFunctionCode(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBTypeSummary_GetPtrMatchDepth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89073,7 +89824,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_GetPtrMatchDepth(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTypeSummary_SetPtrMatchDepth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -89107,7 +89858,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_SetPtrMatchDepth(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTypeSummary_GetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89135,7 +89886,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_GetOptions(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeSummary_SetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -89169,7 +89920,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_SetOptions(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBTypeSummary_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -89215,7 +89966,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSummary_DoesPrintValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; lldb::SBValue arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -89258,7 +90009,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_DoesPrintValue(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSummary_IsEqualTo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; lldb::SBTypeSummary *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -89296,7 +90047,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary_IsEqualTo(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeSummary___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; lldb::SBTypeSummary *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -89339,7 +90090,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary___eq__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeSummary___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; lldb::SBTypeSummary *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -89382,7 +90133,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSummary___ne__(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBTypeSummary___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89439,7 +90190,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeSynthetic__SWIG_0(PyObject *self, Py_ssize_ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; uint32_t arg2 ; int res1 ; char *buf1 = 0 ; @@ -89476,7 +90227,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithClassName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -89545,7 +90296,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithClassName(PyObject *self, P SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; uint32_t arg2 ; int res1 ; char *buf1 = 0 ; @@ -89582,7 +90333,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(PyObject SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -89709,7 +90460,7 @@ SWIGINTERN PyObject *_wrap_new_SBTypeSynthetic(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBTypeSynthetic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89736,7 +90487,7 @@ SWIGINTERN PyObject *_wrap_delete_SBTypeSynthetic(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeSynthetic___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89764,7 +90515,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic___nonzero__(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89792,7 +90543,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsValid(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsClassCode(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89820,7 +90571,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsClassCode(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsClassName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89848,7 +90599,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsClassName(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89876,8 +90627,8 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetData(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetClassName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -89913,8 +90664,8 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetClassName(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetClassCode(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -89950,7 +90701,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetClassCode(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -89978,7 +90729,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetOptions(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90012,7 +90763,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetOptions(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -90058,7 +90809,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetDescription(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsEqualTo(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; lldb::SBTypeSynthetic *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90096,7 +90847,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsEqualTo(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBTypeSynthetic___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; lldb::SBTypeSynthetic *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90139,7 +90890,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic___eq__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeSynthetic___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; lldb::SBTypeSynthetic *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90182,7 +90933,7 @@ SWIGINTERN PyObject *_wrap_SBTypeSynthetic___ne__(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBTypeSynthetic___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90297,7 +91048,7 @@ SWIGINTERN PyObject *_wrap_new_SBUnixSignals(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBUnixSignals(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90324,7 +91075,7 @@ SWIGINTERN PyObject *_wrap_delete_SBUnixSignals(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBUnixSignals_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90351,7 +91102,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBUnixSignals___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90379,7 +91130,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals___nonzero__(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBUnixSignals_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90407,7 +91158,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalAsCString(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90442,8 +91193,8 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalAsCString(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalNumberFromName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -90480,7 +91231,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalNumberFromName(PyObject *self, SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldSuppress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90515,7 +91266,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldSuppress(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldSuppress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -90558,7 +91309,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldSuppress(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldStop(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90593,7 +91344,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldStop(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldStop(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -90636,7 +91387,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldStop(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldNotify(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90671,7 +91422,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldNotify(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldNotify(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; bool arg3 ; void *argp1 = 0 ; @@ -90714,7 +91465,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldNotify(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBUnixSignals_GetNumSignals(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90742,7 +91493,7 @@ SWIGINTERN PyObject *_wrap_SBUnixSignals_GetNumSignals(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + lldb::SBUnixSignals *arg1 = 0 ; int32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -90864,7 +91615,7 @@ SWIGINTERN PyObject *_wrap_new_SBValue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90891,7 +91642,7 @@ SWIGINTERN PyObject *_wrap_delete_SBValue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90919,7 +91670,7 @@ SWIGINTERN PyObject *_wrap_SBValue___nonzero__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90947,7 +91698,7 @@ SWIGINTERN PyObject *_wrap_SBValue_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -90974,7 +91725,7 @@ SWIGINTERN PyObject *_wrap_SBValue_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91002,7 +91753,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetError(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91030,7 +91781,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91058,7 +91809,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetTypeName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91086,7 +91837,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetTypeName(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetDisplayTypeName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91114,7 +91865,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetDisplayTypeName(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBValue_GetByteSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91142,7 +91893,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetByteSize(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_IsInScope(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91170,7 +91921,7 @@ SWIGINTERN PyObject *_wrap_SBValue_IsInScope(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91198,7 +91949,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetFormat(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_SetFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::Format arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -91232,7 +91983,7 @@ SWIGINTERN PyObject *_wrap_SBValue_SetFormat(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91260,7 +92011,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValue(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBError *arg2 = 0 ; int64_t arg3 ; void *argp1 = 0 ; @@ -91305,7 +92056,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_0(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -91342,7 +92093,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_1(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBError *arg2 = 0 ; uint64_t arg3 ; void *argp1 = 0 ; @@ -91387,7 +92138,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBError *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -91424,7 +92175,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_1(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; int64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -91458,7 +92209,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_2(PyObject *self, Py_s SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int64_t result; @@ -91562,7 +92313,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; uint64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -91596,7 +92347,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_2(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; uint64_t result; @@ -91700,7 +92451,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBValue_GetValueAsAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91728,7 +92479,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueAsAddress(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBValue_GetValueType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91756,7 +92507,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBValue_GetValueDidChange(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91784,7 +92535,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueDidChange(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBValue_GetSummary__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; char *result = 0 ; @@ -91810,7 +92561,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetSummary__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBValue_GetSummary__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::SBTypeSummaryOptions *arg3 = 0 ; void *argp1 = 0 ; @@ -91904,7 +92655,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetSummary(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetObjectDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91932,7 +92683,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetObjectDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBValue_GetDynamicValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::DynamicValueType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -91967,7 +92718,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetDynamicValue(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBValue_GetStaticValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -91995,7 +92746,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetStaticValue(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBValue_GetNonSyntheticValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92023,7 +92774,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetNonSyntheticValue(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBValue_GetSyntheticValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92051,7 +92802,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetSyntheticValue(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBValue_GetPreferDynamicValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92079,7 +92830,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetPreferDynamicValue(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBValue_SetPreferDynamicValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::DynamicValueType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -92113,7 +92864,7 @@ SWIGINTERN PyObject *_wrap_SBValue_SetPreferDynamicValue(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBValue_GetPreferSyntheticValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92141,7 +92892,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetPreferSyntheticValue(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBValue_SetPreferSyntheticValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -92175,7 +92926,7 @@ SWIGINTERN PyObject *_wrap_SBValue_SetPreferSyntheticValue(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBValue_IsDynamic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92203,7 +92954,7 @@ SWIGINTERN PyObject *_wrap_SBValue_IsDynamic(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_IsSynthetic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92231,7 +92982,7 @@ SWIGINTERN PyObject *_wrap_SBValue_IsSynthetic(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_IsSyntheticChildrenGenerated(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92259,7 +93010,7 @@ SWIGINTERN PyObject *_wrap_SBValue_IsSyntheticChildrenGenerated(PyObject *self, SWIGINTERN PyObject *_wrap_SBValue_SetSyntheticChildrenGenerated(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -92293,7 +93044,7 @@ SWIGINTERN PyObject *_wrap_SBValue_SetSyntheticChildrenGenerated(PyObject *self, SWIGINTERN PyObject *_wrap_SBValue_GetLocation(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92321,8 +93072,8 @@ SWIGINTERN PyObject *_wrap_SBValue_GetLocation(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_SetValueFromCString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -92358,8 +93109,8 @@ SWIGINTERN PyObject *_wrap_SBValue_SetValueFromCString__SWIG_0(PyObject *self, P SWIGINTERN PyObject *_wrap_SBValue_SetValueFromCString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -92455,7 +93206,7 @@ SWIGINTERN PyObject *_wrap_SBValue_SetValueFromCString(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBValue_GetTypeFormat(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92483,7 +93234,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetTypeFormat(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBValue_GetTypeSummary(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92511,7 +93262,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetTypeSummary(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBValue_GetTypeFilter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92539,7 +93290,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetTypeFilter(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBValue_GetTypeSynthetic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -92567,7 +93318,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetTypeSynthetic(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBValue_GetChildAtIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -92601,8 +93352,8 @@ SWIGINTERN PyObject *_wrap_SBValue_GetChildAtIndex__SWIG_0(PyObject *self, Py_ss SWIGINTERN PyObject *_wrap_SBValue_CreateChildAtOffset(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; uint32_t arg3 ; lldb::SBType arg4 ; void *argp1 = 0 ; @@ -92663,7 +93414,7 @@ SWIGINTERN PyObject *_wrap_SBValue_CreateChildAtOffset(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBValue_Cast(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -92706,9 +93457,9 @@ SWIGINTERN PyObject *_wrap_SBValue_Cast(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -92754,9 +93505,9 @@ SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromExpression__SWIG_0(PyObject *s SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; lldb::SBExpressionOptions *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -92870,8 +93621,8 @@ SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromExpression(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; lldb::addr_t arg3 ; lldb::SBType arg4 ; void *argp1 = 0 ; @@ -92932,8 +93683,8 @@ SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromAddress(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBData arg3 ; lldb::SBType arg4 ; void *argp1 = 0 ; @@ -93002,8 +93753,8 @@ SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromData(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBValue_CreateBoolValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -93048,7 +93799,7 @@ SWIGINTERN PyObject *_wrap_SBValue_CreateBoolValue(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBValue_GetChildAtIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; uint32_t arg2 ; lldb::DynamicValueType arg3 ; bool arg4 ; @@ -93158,8 +93909,8 @@ SWIGINTERN PyObject *_wrap_SBValue_GetChildAtIndex(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBValue_GetIndexOfChildWithName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -93196,8 +93947,8 @@ SWIGINTERN PyObject *_wrap_SBValue_GetIndexOfChildWithName(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBValue_GetChildMemberWithName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -93233,8 +93984,8 @@ SWIGINTERN PyObject *_wrap_SBValue_GetChildMemberWithName__SWIG_0(PyObject *self SWIGINTERN PyObject *_wrap_SBValue_GetChildMemberWithName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; lldb::DynamicValueType arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -93328,8 +94079,8 @@ SWIGINTERN PyObject *_wrap_SBValue_GetChildMemberWithName(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBValue_GetValueForExpressionPath(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -93366,7 +94117,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetValueForExpressionPath(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBValue_AddressOf(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93394,7 +94145,7 @@ SWIGINTERN PyObject *_wrap_SBValue_AddressOf(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetLoadAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93422,7 +94173,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetLoadAddress(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBValue_GetAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93450,7 +94201,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetAddress(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; uint32_t arg2 ; uint32_t arg3 ; void *argp1 = 0 ; @@ -93492,7 +94243,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -93526,7 +94277,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_1(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; lldb::SBData result; @@ -93616,7 +94367,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBValue_GetData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93644,7 +94395,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetData(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_SetData(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBData *arg2 = 0 ; lldb::SBError *arg3 = 0 ; void *argp1 = 0 ; @@ -93693,8 +94444,8 @@ SWIGINTERN PyObject *_wrap_SBValue_SetData(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_Clone(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -93731,7 +94482,7 @@ SWIGINTERN PyObject *_wrap_SBValue_Clone(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetDeclaration(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93759,7 +94510,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetDeclaration(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBValue_MightHaveChildren(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93787,7 +94538,7 @@ SWIGINTERN PyObject *_wrap_SBValue_MightHaveChildren(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBValue_IsRuntimeSupportValue(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93815,7 +94566,7 @@ SWIGINTERN PyObject *_wrap_SBValue_IsRuntimeSupportValue(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBValue_GetNumChildren__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; uint32_t result; @@ -93841,7 +94592,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetNumChildren__SWIG_0(PyObject *self, Py_ssi SWIGINTERN PyObject *_wrap_SBValue_GetNumChildren__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -93917,7 +94668,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetNumChildren(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBValue_GetOpaqueType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93945,7 +94696,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetOpaqueType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBValue_GetTarget(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -93973,7 +94724,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetTarget(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetProcess(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94001,7 +94752,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetProcess(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetThread(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94029,7 +94780,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetThread(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetFrame(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94057,7 +94808,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetFrame(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_Dereference(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94085,7 +94836,7 @@ SWIGINTERN PyObject *_wrap_SBValue_Dereference(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_TypeIsPointerType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94113,7 +94864,7 @@ SWIGINTERN PyObject *_wrap_SBValue_TypeIsPointerType(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBValue_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94141,7 +94892,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetType(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_Persist(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94169,7 +94920,7 @@ SWIGINTERN PyObject *_wrap_SBValue_Persist(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -94207,7 +94958,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetDescription(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBValue_GetExpressionPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -94244,7 +94995,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetExpressionPath__SWIG_0(PyObject *self, Py_ SWIGINTERN PyObject *_wrap_SBValue_GetExpressionPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; @@ -94341,8 +95092,8 @@ SWIGINTERN PyObject *_wrap_SBValue_GetExpressionPath(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -94378,8 +95129,8 @@ SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_0(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBExpressionOptions *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -94426,10 +95177,10 @@ SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_1(PyObject *self, Py SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValue *arg1 = 0 ; + char *arg2 = 0 ; lldb::SBExpressionOptions *arg3 = 0 ; - char *arg4 = (char *) 0 ; + char *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -94555,7 +95306,7 @@ SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBValue_Watch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; bool arg2 ; bool arg3 ; bool arg4 ; @@ -94616,7 +95367,7 @@ SWIGINTERN PyObject *_wrap_SBValue_Watch__SWIG_0(PyObject *self, Py_ssize_t nobj SWIGINTERN PyObject *_wrap_SBValue_Watch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; bool arg2 ; bool arg3 ; bool arg4 ; @@ -94743,7 +95494,7 @@ SWIGINTERN PyObject *_wrap_SBValue_Watch(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue_WatchPointee(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; bool arg2 ; bool arg3 ; bool arg4 ; @@ -94805,7 +95556,7 @@ SWIGINTERN PyObject *_wrap_SBValue_WatchPointee(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBValue_GetVTable(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94833,7 +95584,7 @@ SWIGINTERN PyObject *_wrap_SBValue_GetVTable(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValue___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94948,7 +95699,7 @@ SWIGINTERN PyObject *_wrap_new_SBValueList(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBValueList(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -94975,7 +95726,7 @@ SWIGINTERN PyObject *_wrap_delete_SBValueList(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValueList___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95003,7 +95754,7 @@ SWIGINTERN PyObject *_wrap_SBValueList___nonzero__(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBValueList_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95031,7 +95782,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_IsValid(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValueList_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95058,7 +95809,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_Clear(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValueList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; lldb::SBValue *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95094,7 +95845,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_Append__SWIG_0(PyObject *self, Py_ssize_t SWIGINTERN PyObject *_wrap_SBValueList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; lldb::SBValueList *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95174,7 +95925,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_Append(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValueList_GetSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95202,7 +95953,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_GetSize(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBValueList_GetValueAtIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95237,8 +95988,8 @@ SWIGINTERN PyObject *_wrap_SBValueList_GetValueAtIndex(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBValueList_GetFirstValueByName(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBValueList *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -95275,7 +96026,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_GetFirstValueByName(PyObject *self, PyObj SWIGINTERN PyObject *_wrap_SBValueList_FindValueObjectByUID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; lldb::user_id_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95310,7 +96061,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_FindValueObjectByUID(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBValueList_GetError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95338,7 +96089,7 @@ SWIGINTERN PyObject *_wrap_SBValueList_GetError(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBValueList___str__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95449,7 +96200,7 @@ SWIGINTERN PyObject *_wrap_new_SBVariablesOptions(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_delete_SBVariablesOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95476,7 +96227,7 @@ SWIGINTERN PyObject *_wrap_delete_SBVariablesOptions(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBVariablesOptions___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95504,7 +96255,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions___nonzero__(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBVariablesOptions_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95532,7 +96283,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_IsValid(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95560,7 +96311,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeArguments(PyObject *self SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95594,7 +96345,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeArguments(PyObject *self SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeRecognizedArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; lldb::SBTarget *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95632,7 +96383,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeRecognizedArguments(PyOb SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeRecognizedArguments(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95666,7 +96417,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeRecognizedArguments(PyOb SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeLocals(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95694,7 +96445,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeLocals(PyObject *self, P SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeLocals(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95728,7 +96479,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeLocals(PyObject *self, P SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeStatics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95756,7 +96507,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeStatics(PyObject *self, SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeStatics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95790,7 +96541,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeStatics(PyObject *self, SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetInScopeOnly(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95818,7 +96569,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetInScopeOnly(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetInScopeOnly(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95852,7 +96603,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetInScopeOnly(PyObject *self, PyO SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95880,7 +96631,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues(PyO SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -95914,7 +96665,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues(PyO SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetUseDynamic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -95942,7 +96693,7 @@ SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetUseDynamic(PyObject *self, PyOb SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetUseDynamic(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBVariablesOptions *arg1 = 0 ; lldb::DynamicValueType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -96063,7 +96814,7 @@ SWIGINTERN PyObject *_wrap_new_SBWatchpoint(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_delete_SBWatchpoint(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96090,7 +96841,7 @@ SWIGINTERN PyObject *_wrap_delete_SBWatchpoint(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBWatchpoint___nonzero__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96118,7 +96869,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint___nonzero__(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBWatchpoint___eq__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; lldb::SBWatchpoint *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -96161,7 +96912,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint___eq__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBWatchpoint___ne__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; lldb::SBWatchpoint *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -96204,7 +96955,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint___ne__(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBWatchpoint_IsValid(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96232,7 +96983,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_IsValid(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBWatchpoint_GetError(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96260,7 +97011,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetError(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBWatchpoint_GetID(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96288,7 +97039,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetID(PyObject *self, PyObject *args) { SWIGINTERN PyObject *_wrap_SBWatchpoint_GetHardwareIndex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96316,7 +97067,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetHardwareIndex(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchAddress(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96344,7 +97095,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchAddress(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchSize(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96372,7 +97123,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchSize(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBWatchpoint_SetEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -96406,7 +97157,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_SetEnabled(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_SBWatchpoint_IsEnabled(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96434,7 +97185,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_IsEnabled(PyObject *self, PyObject *args SWIGINTERN PyObject *_wrap_SBWatchpoint_GetHitCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96462,7 +97213,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetHitCount(PyObject *self, PyObject *ar SWIGINTERN PyObject *_wrap_SBWatchpoint_GetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96490,7 +97241,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetIgnoreCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBWatchpoint_SetIgnoreCount(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -96524,7 +97275,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_SetIgnoreCount(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBWatchpoint_GetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96552,8 +97303,8 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetCondition(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBWatchpoint_SetCondition(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; - char *arg2 = (char *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; + char *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -96589,7 +97340,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_SetCondition(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBWatchpoint_GetDescription(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; lldb::SBStream *arg2 = 0 ; lldb::DescriptionLevel arg3 ; void *argp1 = 0 ; @@ -96635,7 +97386,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetDescription(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBWatchpoint_Clear(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96755,7 +97506,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchpointFromEvent(PyObject *self, P SWIGINTERN PyObject *_wrap_SBWatchpoint_GetType(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96783,7 +97534,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetType(PyObject *self, PyObject *args) SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchValueKind(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96811,7 +97562,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchValueKind(PyObject *self, PyObje SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchSpec(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96839,7 +97590,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchSpec(PyObject *self, PyObject *a SWIGINTERN PyObject *_wrap_SBWatchpoint_IsWatchingReads(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96867,7 +97618,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_IsWatchingReads(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_SBWatchpoint_IsWatchingWrites(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -96895,7 +97646,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpoint_IsWatchingWrites(PyObject *self, PyObjec SWIGINTERN PyObject *_wrap_SBWatchpoint___repr__(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -97010,7 +97761,7 @@ SWIGINTERN PyObject *_wrap_new_SBWatchpointOptions(PyObject *self, PyObject *arg SWIGINTERN PyObject *_wrap_delete_SBWatchpointOptions(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + lldb::SBWatchpointOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -97037,7 +97788,7 @@ SWIGINTERN PyObject *_wrap_delete_SBWatchpointOptions(PyObject *self, PyObject * SWIGINTERN PyObject *_wrap_SBWatchpointOptions_SetWatchpointTypeRead(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + lldb::SBWatchpointOptions *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -97071,7 +97822,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpointOptions_SetWatchpointTypeRead(PyObject *s SWIGINTERN PyObject *_wrap_SBWatchpointOptions_GetWatchpointTypeRead(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + lldb::SBWatchpointOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -97099,7 +97850,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpointOptions_GetWatchpointTypeRead(PyObject *s SWIGINTERN PyObject *_wrap_SBWatchpointOptions_SetWatchpointTypeWrite(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + lldb::SBWatchpointOptions *arg1 = 0 ; lldb::WatchpointWriteType arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -97133,7 +97884,7 @@ SWIGINTERN PyObject *_wrap_SBWatchpointOptions_SetWatchpointTypeWrite(PyObject * SWIGINTERN PyObject *_wrap_SBWatchpointOptions_GetWatchpointTypeWrite(PyObject *self, PyObject *args) { PyObject *resultobj = 0; - lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + lldb::SBWatchpointOptions *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -99080,6 +99831,48 @@ static PyMethodDef SwigMethods[] = { { "SBFrame___repr__", _wrap_SBFrame___repr__, METH_O, "SBFrame___repr__(SBFrame self) -> std::string"}, { "SBFrame_swigregister", SBFrame_swigregister, METH_O, NULL}, { "SBFrame_swiginit", SBFrame_swiginit, METH_VARARGS, NULL}, + { "new_SBFrameList", _wrap_new_SBFrameList, METH_VARARGS, "\n" + "SBFrameList()\n" + "new_SBFrameList(SBFrameList rhs) -> SBFrameList\n" + ""}, + { "delete_SBFrameList", _wrap_delete_SBFrameList, METH_O, "delete_SBFrameList(SBFrameList self)"}, + { "SBFrameList___nonzero__", _wrap_SBFrameList___nonzero__, METH_O, "SBFrameList___nonzero__(SBFrameList self) -> bool"}, + { "SBFrameList_IsValid", _wrap_SBFrameList_IsValid, METH_O, "SBFrameList_IsValid(SBFrameList self) -> bool"}, + { "SBFrameList_GetSize", _wrap_SBFrameList_GetSize, METH_O, "Returns the number of frames in the list."}, + { "SBFrameList_GetFrameAtIndex", _wrap_SBFrameList_GetFrameAtIndex, METH_VARARGS, "\n" + "Returns the frame at the given index.\n" + "\n" + ":type idx: int, in\n" + ":param idx:\n" + " The index of the frame to retrieve (0-based).\n" + "\n" + ":rtype: :py:class:`SBFrame`\n" + ":return: \n" + " An SBFrame object for the frame at the specified index.\n" + " Returns an invalid SBFrame if idx is out of range.\n" + ""}, + { "SBFrameList_GetThread", _wrap_SBFrameList_GetThread, METH_O, "\n" + "Get the thread associated with this frame list.\n" + "\n" + ":rtype: :py:class:`SBThread`\n" + ":return: \n" + " An SBThread object representing the thread.\n" + ""}, + { "SBFrameList_Clear", _wrap_SBFrameList_Clear, METH_O, "Clear all frames from this list."}, + { "SBFrameList_GetDescription", _wrap_SBFrameList_GetDescription, METH_VARARGS, "\n" + "Get a description of this frame list.\n" + "\n" + ":type description: :py:class:`SBStream`, in\n" + ":param description:\n" + " The stream to write the description to.\n" + "\n" + ":rtype: boolean\n" + ":return: \n" + " True if the description was successfully written.\n" + ""}, + { "SBFrameList___str__", _wrap_SBFrameList___str__, METH_O, "SBFrameList___str__(SBFrameList self) -> std::string"}, + { "SBFrameList_swigregister", SBFrameList_swigregister, METH_O, NULL}, + { "SBFrameList_swiginit", SBFrameList_swiginit, METH_VARARGS, NULL}, { "new_SBFunction", _wrap_new_SBFunction, METH_VARARGS, "\n" "SBFunction()\n" "new_SBFunction(SBFunction rhs) -> SBFunction\n" @@ -101787,6 +102580,39 @@ static PyMethodDef SwigMethods[] = { " An error if a Trace already exists or the trace couldn't be created.\n" ""}, { "SBTarget_GetAPIMutex", _wrap_SBTarget_GetAPIMutex, METH_O, "SBTarget_GetAPIMutex(SBTarget self) -> SBMutex"}, + { "SBTarget_RegisterScriptedFrameProvider", _wrap_SBTarget_RegisterScriptedFrameProvider, METH_VARARGS, "\n" + "Register a scripted frame provider for this target.\n" + "If a scripted frame provider with the same name and same argument\n" + "dictionary is already registered on this target, it will be overwritten.\n" + "\n" + ":type class_name: string, in\n" + ":param class_name:\n" + " The name of the Python class that implements the frame provider.\n" + "\n" + ":type args_dict: :py:class:`SBStructuredData`, in\n" + ":param args_dict:\n" + " A dictionary of arguments to pass to the frame provider class.\n" + "\n" + ":type error: :py:class:`SBError`, out\n" + ":param error:\n" + " An error object indicating success or failure.\n" + "\n" + ":rtype: int\n" + ":return: \n" + " A unique identifier for the frame provider descriptor that was\n" + " registered. 0 if the registration failed.\n" + ""}, + { "SBTarget_RemoveScriptedFrameProvider", _wrap_SBTarget_RemoveScriptedFrameProvider, METH_VARARGS, "\n" + "Remove a scripted frame provider from this target by name.\n" + "\n" + ":type provider_id: int, in\n" + ":param provider_id:\n" + " The id of the frame provider class to remove.\n" + "\n" + ":rtype: :py:class:`SBError`\n" + ":return: \n" + " An error object indicating success or failure.\n" + ""}, { "SBTarget___repr__", _wrap_SBTarget___repr__, METH_O, "SBTarget___repr__(SBTarget self) -> std::string"}, { "SBTarget_swigregister", SBTarget_swigregister, METH_O, NULL}, { "SBTarget_swiginit", SBTarget_swiginit, METH_VARARGS, NULL}, @@ -101992,6 +102818,7 @@ static PyMethodDef SwigMethods[] = { { "SBThread_IsStopped", _wrap_SBThread_IsStopped, METH_O, "SBThread_IsStopped(SBThread self) -> bool"}, { "SBThread_GetNumFrames", _wrap_SBThread_GetNumFrames, METH_O, "SBThread_GetNumFrames(SBThread self) -> uint32_t"}, { "SBThread_GetFrameAtIndex", _wrap_SBThread_GetFrameAtIndex, METH_VARARGS, "SBThread_GetFrameAtIndex(SBThread self, uint32_t idx) -> SBFrame"}, + { "SBThread_GetFrames", _wrap_SBThread_GetFrames, METH_O, "SBThread_GetFrames(SBThread self) -> SBFrameList"}, { "SBThread_GetSelectedFrame", _wrap_SBThread_GetSelectedFrame, METH_O, "SBThread_GetSelectedFrame(SBThread self) -> SBFrame"}, { "SBThread_SetSelectedFrame", _wrap_SBThread_SetSelectedFrame, METH_VARARGS, "SBThread_SetSelectedFrame(SBThread self, uint32_t frame_idx) -> SBFrame"}, { "SBThread_EventIsThreadEvent", _wrap_SBThread_EventIsThreadEvent, METH_O, "SBThread_EventIsThreadEvent(SBEvent event) -> bool"}, @@ -103908,6 +104735,7 @@ static swig_type_info _swigt__p_lldb__SBFileSpec = {"_p_lldb__SBFileSpec", "lldb static swig_type_info _swigt__p_lldb__SBFileSpecList = {"_p_lldb__SBFileSpecList", "lldb::SBFileSpecList *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_lldb__SBFormat = {"_p_lldb__SBFormat", "lldb::SBFormat *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_lldb__SBFrame = {"_p_lldb__SBFrame", "lldb::SBFrame *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_lldb__SBFrameList = {"_p_lldb__SBFrameList", "lldb::SBFrameList *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_lldb__SBFunction = {"_p_lldb__SBFunction", "lldb::SBFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_lldb__SBHostOS = {"_p_lldb__SBHostOS", "lldb::SBHostOS *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_lldb__SBInstruction = {"_p_lldb__SBInstruction", "lldb::SBInstruction *", 0, 0, (void*)0, 0}; @@ -104038,6 +104866,7 @@ static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptInterpreter static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t = {"_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t", "lldb::ScriptSummaryFormatSP *|std::shared_ptr< lldb_private::ScriptSummaryFormat > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t", "lldb::ScriptedBreakpointInterfaceSP *|std::shared_ptr< lldb_private::ScriptedBreakpointInterface > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t", "lldb::ScriptedFrameInterfaceSP *|std::shared_ptr< lldb_private::ScriptedFrameInterface > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t", "lldb::ScriptedFrameProviderInterfaceSP *|std::shared_ptr< lldb_private::ScriptedFrameProviderInterface > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t = {"_p_std__shared_ptrT_lldb_private__ScriptedMetadata_t", "lldb::ScriptedMetadataSP *|std::shared_ptr< lldb_private::ScriptedMetadata > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t", "lldb::ScriptedStopHookInterfaceSP *|std::shared_ptr< lldb_private::ScriptedStopHookInterface > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t = {"_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t", "lldb::ScriptedSyntheticChildrenSP *|std::shared_ptr< lldb_private::ScriptedSyntheticChildren > *", 0, 0, (void*)0, 0}; @@ -104059,6 +104888,7 @@ static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SymbolContextSpec static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t = {"_p_std__shared_ptrT_lldb_private__SymbolFileType_t", "lldb::SymbolFileTypeSP *|std::shared_ptr< lldb_private::SymbolFileType > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t = {"_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t", "lldb::SyntheticChildrenFrontEndSP *|std::shared_ptr< lldb_private::SyntheticChildrenFrontEnd > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t = {"_p_std__shared_ptrT_lldb_private__SyntheticChildren_t", "lldb::SyntheticChildrenSP *|std::shared_ptr< lldb_private::SyntheticChildren > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t = {"_p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t", "lldb::SyntheticFrameProviderSP *|std::shared_ptr< lldb_private::SyntheticFrameProvider > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Target_t = {"_p_std__shared_ptrT_lldb_private__Target_t", "lldb::TargetSP *|std::shared_ptr< lldb_private::Target > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t = {"_p_std__shared_ptrT_lldb_private__ThreadCollection_t", "lldb::ThreadCollectionSP *|std::shared_ptr< lldb_private::ThreadCollection > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t = {"_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t", "lldb::ThreadPlanTracerSP *|std::shared_ptr< lldb_private::ThreadPlanTracer > *", 0, 0, (void*)0, 0}; @@ -104170,6 +105000,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_lldb__SBFileSpecList, &_swigt__p_lldb__SBFormat, &_swigt__p_lldb__SBFrame, + &_swigt__p_lldb__SBFrameList, &_swigt__p_lldb__SBFunction, &_swigt__p_lldb__SBHostOS, &_swigt__p_lldb__SBInstruction, @@ -104300,6 +105131,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t, &_swigt__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t, &_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t, + &_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t, &_swigt__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t, &_swigt__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t, &_swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t, @@ -104321,6 +105153,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t, &_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t, &_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t, + &_swigt__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t, &_swigt__p_std__shared_ptrT_lldb_private__Target_t, &_swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t, &_swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t, @@ -104432,6 +105265,7 @@ static swig_cast_info _swigc__p_lldb__SBFileSpec[] = { {&_swigt__p_lldb__SBFile static swig_cast_info _swigc__p_lldb__SBFileSpecList[] = { {&_swigt__p_lldb__SBFileSpecList, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_lldb__SBFormat[] = { {&_swigt__p_lldb__SBFormat, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_lldb__SBFrame[] = { {&_swigt__p_lldb__SBFrame, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_lldb__SBFrameList[] = { {&_swigt__p_lldb__SBFrameList, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_lldb__SBFunction[] = { {&_swigt__p_lldb__SBFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_lldb__SBHostOS[] = { {&_swigt__p_lldb__SBHostOS, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_lldb__SBInstruction[] = { {&_swigt__p_lldb__SBInstruction, 0, 0, 0},{0, 0, 0, 0}}; @@ -104562,6 +105396,7 @@ static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptInterpreter static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -104583,6 +105418,7 @@ static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SymbolContextSpec static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SymbolFileType_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildren_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Target_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Target_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadCollection_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -104694,6 +105530,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_lldb__SBFileSpecList, _swigc__p_lldb__SBFormat, _swigc__p_lldb__SBFrame, + _swigc__p_lldb__SBFrameList, _swigc__p_lldb__SBFunction, _swigc__p_lldb__SBHostOS, _swigc__p_lldb__SBInstruction, @@ -104824,6 +105661,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t, _swigc__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t, _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t, + _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t, _swigc__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t, _swigc__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t, _swigc__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t, @@ -104845,6 +105683,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_std__shared_ptrT_lldb_private__SymbolFileType_t, _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t, _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildren_t, + _swigc__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t, _swigc__p_std__shared_ptrT_lldb_private__Target_t, _swigc__p_std__shared_ptrT_lldb_private__ThreadCollection_t, _swigc__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t, @@ -104932,7 +105771,7 @@ static swig_const_info swig_const_table[] = { #endif /* ----------------------------------------------------------------------------- * Type initialization: - * This problem is tough by the requirement that no dynamic + * This problem is made tough by the requirement that no dynamic * memory is used. Also, since swig_type_info structures store pointers to * swig_cast_info structures and swig_cast_info structures store pointers back * to swig_type_info structures, we need some lookup code at initialization. @@ -104947,15 +105786,20 @@ static swig_const_info swig_const_table[] = { * array. We just loop through that array, and handle each type individually. * First we lookup if this type has been already loaded, and if so, use the * loaded structure instead of the generated one. Then we have to fill in the - * cast linked list. The cast data is initially stored in something like a + * cast dependencies. The cast data is initially stored in something like a * two-dimensional array. Each row corresponds to a type (there are the same * number of rows as there are in the swig_type_initial array). Each entry in * a column is one of the swig_cast_info structures for that type. * The cast_initial array is actually an array of arrays, because each row has - * a variable number of columns. So to actually build the cast linked list, - * we find the array of casts associated with the type, and loop through it - * adding the casts to the list. The one last trick we need to do is making - * sure the type pointer in the swig_cast_info struct is correct. + * a variable number of columns. + * + * We loop through the cast[] array associated with the type and mark casts + * which have not been defined in previously loaded modules by assigning + * cast pointer value to cast->next. We also hash cast->type->name string + * and store the value in the cast->value field. If we encounter swig_cast_info + * structure that represents a cast to self we move it to the beginning + * of the cast array. One trick we need to do is making sure the type pointer + * in the swig_cast_info struct is correct. * * First off, we lookup the cast->type name to see if it is already loaded. * There are three cases to handle: @@ -104967,8 +105811,71 @@ static swig_const_info swig_const_table[] = { * cast->type) are loaded, THEN the cast info has already been loaded by * the previous module so we just ignore it. * 3) Finally, if cast->type has not already been loaded, then we add that - * swig_cast_info to the linked list (because the cast->type) pointer will + * swig_cast_info to the list (because the cast->type) pointer will * be correct. + * + * Once the cast array has been set up AND it does have new casts that need + * to be added we sort non-self cast entries to move filtered out entries + * to the end of the array and to arrange the rest in the increasing order + * of their type pointer values. We store the index of the last added entry + * in the cast->value field of the entry[0] (overwriting the name hash). Then + * we sort fields of the remaining entries to arrange hash values + * in the increasing order. This way cast->next->type->name field matches + * the cast->value hash. + * + * Example: + * Array of casts for type stored at 0x5000, cast to type stored at 0x3000 + * has already been loaded + * + * After sweep-and-hash: After sort-by-type: After sort-by-hash: + * ________________ ________________ ________________ + * | | | | | | + * Entry | type = 0x5000 | | type = 0x5000 | | type = 0x5000 | + * 0 | | | | | | + * | next = Entry0 | | next = Entry0 | | next = Entry0 | + * | value = 1212 | | value = 3 | | value = 3 | + * | | | | | | + * |================| |================| |================| + * | | | | | | + * Entry | type = 0x2000 | | type = 0x1000 | | type = 0x1000 | + * 1 | | | | | | + * | next = Entry1 | | next = Entry1 | | next = Entry3 | + * | value = 3434 | | value = 4545 | | value = 2323 | + * |________________| |________________| |________________| + * | | | | | | + * Entry | type = 0x3000 | | type = 0x2000 | | type = 0x2000 | + * 2 | | | | | | + * | next = 0 | | next = Entry2 | | next = Entry2 | + * | value = 0 | | value = 3434 | | value = 3434 | + * |________________| |________________| |________________| + * | | | | | | + * Entry | type = 0x1000 | | type = 0x4000 | | type = 0x4000 | + * 3 | | | | | | + * | next = Entry3 | | next = Entry3 | | next = Entry1 | + * | value = 4545 | | value = 2323 | | value = 4545 | + * |________________| |________________| |________________| + * | | | | | | + * Entry | type = 0x4000 | | type = 0x3000 | | type = 0x3000 | + * 4 | | | | | | + * | next = Entry4 | | next = 0 | | next = 0 | + * | value = 2323 | | value = 0 | | value = 0 | + * |________________| |________________| |________________| + * + * Once the cast array has been initialized, we use cast[0]->next field to link + * it into the list of cast arrays for the type. + * ____ ____ ____ + * type->cast->|next|->|next|->|next|->0 + * |----| |----| |----| + * |----| |----| |----| + * |----| |----| |----| + * + * Subsequent cast resolution works as follows: + * + * 1. Check whether the type matches the first entry in the current cast array. + * 2. If not, then do a binary search over the (0:cast->value] interval using + * either type address or the hash value of the type name. + * 3. If not found, then move over to the next cast array (cast[0]->next). + * * ----------------------------------------------------------------------------- */ #ifdef __cplusplus @@ -104986,6 +105893,46 @@ extern "C" { #define SWIG_INIT_CLIENT_DATA_TYPE void * #endif +/* + * Sort function that puts cast entries with nonzero 'next' at the front + * of the array while ordering them by addresses of their 'type' structs. + */ +SWIGINTERN int SWIG_CastCmpStruct(const void *pa, const void *pb) { + swig_cast_info *pca = (swig_cast_info *)pa; + swig_cast_info *pcb = (swig_cast_info *)pb; + if (pca->type < pcb->type) + return (pca->next || pcb->next == 0) ? -1 : 1; + if (pca->type > pcb->type) + return (pcb->next || pca->next == 0) ? 1 : -1; + return 0; +} + +/* + * Shell-sort 'next' and 'value' field pairs to order them by 'value'. + */ +SWIGINTERN void SWIG_CastHashSort(swig_cast_info *cast, int size) { + const int hmax = size/9; + int h, i; + for(h = 1; h <= hmax; h = 3*h+1); + for(; h > 0; h /= 3) + { + for(i = h; i < size; ++i) + { + swig_cast_info *p = cast[i].next; + unsigned int hash = cast[i].value; + int j = i; + while(j >= h && hash < cast[j-h].value) + { + cast[j].next = cast[j-h].next; + cast[j].value = cast[j-h].value; + j -= h; + } + cast[j].next = p; + cast[j].value = hash; + } + } +} + SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) { size_t i; @@ -105037,8 +105984,9 @@ SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) { #endif for (i = 0; i < swig_module.size; ++i) { swig_type_info *type = 0; - swig_type_info *ret; - swig_cast_info *cast; + swig_type_info *target_type; + swig_cast_info *cast, *first; + int num_mapped = 0; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); @@ -105064,48 +106012,101 @@ SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) { } /* Insert casting types */ - cast = swig_module.cast_initial[i]; + cast = first = swig_module.cast_initial[i]; while (cast->type) { /* Don't need to add information already in the list */ - ret = 0; + target_type = 0; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); #endif if (swig_module.next != &swig_module) { - ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); + target_type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); + if (target_type) { + /* Target type already defined in another module */ #ifdef SWIGRUNTIME_DEBUG - if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); + printf("SWIG_InitializeModule: found cast %s\n", target_type->name); #endif - } - if (ret) { - if (type == swig_module.type_initial[i]) { + if (type == swig_module.type_initial[i]) { #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: skip old type %s\n", ret->name); + printf("SWIG_InitializeModule: skip old type %s\n", target_type->name); #endif - cast->type = ret; - ret = 0; - } else { - /* Check for casting already in the list */ - swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); + cast->type = target_type; + target_type = 0; + } else { + /* Check if this cast is already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(target_type->name, type); #ifdef SWIGRUNTIME_DEBUG - if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", target_type->name); #endif - if (!ocast) ret = 0; + if (!ocast) target_type = 0; + } } } - if (!ret) { + if (!target_type) { #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); #endif - if (type->cast) { - type->cast->prev = cast; - cast->next = type->cast; + /* Set inclusion mark for sorting */ + cast->next = cast; + num_mapped++; + + if (type == cast->type) { +#ifdef SWIGRUNTIME_DEBUG + printf("%s : self cast at pos [%li]\n", type->name, cast - first); +#endif + if (cast - first) { + /* Move cast to itself to the first entry in the array */ + + swig_cast_info tmp = *cast; + *cast = *first; + *first = tmp; + } + first++; + + } else { + cast->value = SWIG_Hash(cast->type->name, (unsigned int)strlen(cast->type->name)); } - type->cast = cast; } cast++; } + + if (num_mapped) { + if (cast - first) { + swig_cast_info *tmp; + + /* Sort casts by type address for binary search in SWIG_TypeCheckStruct */ + qsort(first, cast - first, sizeof(swig_cast_info), SWIG_CastCmpStruct); + + /* Remap back links for added entries */ + cast = swig_module.cast_initial[i] + num_mapped; + for (tmp = first; tmp < cast; tmp++) { + tmp->next = tmp; + } + } + + /* Set the value field of the first entry to the index of the last added entry */ + cast = swig_module.cast_initial[i]; + cast->value = num_mapped - 1; + + num_mapped -= (int)(first - cast); + if (num_mapped > 1) { + /* Sort <'next','value'> pairs by 'value' for binary search in SWIG_TypeCheck */ + + SWIG_CastHashSort(first, num_mapped); + } + + first = type->cast; + if (first) { + /* Link the current set into the list of cast arrays */ + cast->next = first->next; + first->next = cast; + } else { + cast->next = 0; + type->cast = cast; + } + } + /* Set entry in modules->types array equal to the type */ swig_module.types[i] = type; } @@ -105136,7 +106137,6 @@ SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) { SWIGRUNTIME void SWIG_PropagateClientData(void) { size_t i; - swig_cast_info *equiv; static int init_run = 0; if (init_run) return; @@ -105144,13 +106144,16 @@ SWIG_PropagateClientData(void) { for (i = 0; i < swig_module.size; i++) { if (swig_module.types[i]->clientdata) { - equiv = swig_module.types[i]->cast; - while (equiv) { - if (!equiv->converter) { - if (equiv->type && !equiv->type->clientdata) - SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + swig_cast_info *head, *cast; + head = swig_module.types[i]->cast; + while (head) { + for (cast = head; (cast - head) <= head->value; cast++) { + if (!cast->converter) { + if (cast->type && !cast->type->clientdata) + SWIG_TypeClientData(cast->type, swig_module.types[i]->clientdata); + } } - equiv = equiv->next; + head = head->next; } } } @@ -105254,6 +106257,8 @@ extern "C" { * Partial Init method * -----------------------------------------------------------------------------*/ +SWIGINTERN int SWIG_mod_exec(PyObject *module); + #ifdef __cplusplus extern "C" #endif @@ -105265,21 +106270,46 @@ PyObject* void #endif SWIG_init(void) { - PyObject *m, *d, *md, *globals; - #if PY_VERSION_HEX >= 0x03000000 + static PyModuleDef_Slot SwigSlots[] = { + { + Py_mod_exec, (void *)SWIG_mod_exec + }, +#ifdef SWIGPYTHON_NOGIL +#ifdef Py_GIL_DISABLED + { + Py_mod_gil, Py_MOD_GIL_NOT_USED + }, +#endif +#endif + { + 0, NULL + } + }; + static struct PyModuleDef SWIG_module = { PyModuleDef_HEAD_INIT, SWIG_name, NULL, - -1, + 0, SwigMethods, - NULL, + SwigSlots, NULL, NULL, NULL }; + + return PyModuleDef_Init(&SWIG_module); +#else + PyObject *m = Py_InitModule(SWIG_name, SwigMethods); + if (m && SWIG_mod_exec(m) != 0) { + Py_DECREF(m); + } #endif +} + +SWIGINTERN int SWIG_mod_exec(PyObject *m) { + PyObject *d, *md, *globals; #if defined(SWIGPYTHON_BUILTIN) static SwigPyClientData SwigPyObject_clientdata = { @@ -105317,27 +106347,31 @@ SWIG_init(void) { (void)self; /* Metaclass is used to implement static member variables */ - metatype = SwigPyObjectType(); + metatype = SwigPyObjectType_Type(); assert(metatype); + + SwigPyStaticVar_Type(); #endif (void)globals; /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */ + SWIG_runtime_data_module(); SWIG_This(); SWIG_Python_TypeCache(); - SwigPyPacked_type(); + SwigPyPacked_Type(); + SwigVarLink_Type(); #ifndef SWIGPYTHON_BUILTIN - SwigPyObject_type(); + SwigPyObject_Type(); #endif /* Fix SwigMethods to carry the callback ptrs when needed */ SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); -#if PY_VERSION_HEX >= 0x03000000 - m = PyModule_Create(&SWIG_module); -#else - m = Py_InitModule(SWIG_name, SwigMethods); +#ifdef SWIGPYTHON_NOGIL +#ifdef Py_GIL_DISABLED + PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED); +#endif #endif md = d = PyModule_GetDict(m); @@ -105356,19 +106390,15 @@ SWIG_init(void) { SwigPyObject_clientdata.pytype = swigpyobject; } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); -# if PY_VERSION_HEX >= 0x03000000 - return NULL; -# else - return; -# endif + return -1; } /* All objects have a 'this' attribute */ - this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + this_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &this_getset_def); (void)this_descr; /* All objects have a 'thisown' attribute */ - thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + thisown_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &thisown_getset_def); (void)thisown_descr; public_interface = PyList_New(0); @@ -106331,10 +107361,6 @@ SWIG_init(void) { /* Initialize threading */ SWIG_PYTHON_INITIALIZE_THREADS; -#if PY_VERSION_HEX >= 0x03000000 - return m; -#else - return; -#endif + return 0; } diff --git a/lldb/bindings/python/static-binding/lldb.py b/lldb/bindings/python/static-binding/lldb.py index 16640c4fcb339..bba8664d9e600 100644 --- a/lldb/bindings/python/static-binding/lldb.py +++ b/lldb/bindings/python/static-binding/lldb.py @@ -1,5 +1,5 @@ # This file was automatically generated by SWIG (https://www.swig.org). -# Version 4.3.1 +# Version 4.4.0 # # Do not make changes to this file unless you know what you are doing - modify # the SWIG interface file instead. @@ -99,7 +99,7 @@ class _SwigNonDynamicMeta(type): #3.0.18. def _to_int(hex): return hex // 0x10 % 0x10 * 10 + hex % 0x10 -swig_version = (_to_int(0x040301 // 0x10000), _to_int(0x040301 // 0x100), _to_int(0x040301)) +swig_version = (_to_int(0x040400 // 0x10000), _to_int(0x040400 // 0x100), _to_int(0x040400)) del _to_int @@ -7638,6 +7638,108 @@ def __getitem__(self, key): # Register SBFrame in _lldb: _lldb.SBFrame_swigregister(SBFrame) +class SBFrameList(object): + r""" + Represents a list of SBFrame objects. + + SBFrameList provides a way to iterate over stack frames lazily, + materializing frames on-demand as they are accessed. This is more + efficient than eagerly creating all frames upfront. + """ + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(SBFrameList self) -> SBFrameList + __init__(SBFrameList self, SBFrameList rhs) -> SBFrameList + """ + _lldb.SBFrameList_swiginit(self, _lldb.new_SBFrameList(*args)) + __swig_destroy__ = _lldb.delete_SBFrameList + + def __nonzero__(self): + return _lldb.SBFrameList___nonzero__(self) + __bool__ = __nonzero__ + + + + def IsValid(self): + r"""IsValid(SBFrameList self) -> bool""" + return _lldb.SBFrameList_IsValid(self) + + def GetSize(self): + r"""Returns the number of frames in the list.""" + return _lldb.SBFrameList_GetSize(self) + + def GetFrameAtIndex(self, idx): + r""" + Returns the frame at the given index. + + :type idx: int, in + :param idx: + The index of the frame to retrieve (0-based). + + :rtype: :py:class:`SBFrame` + :return: + An SBFrame object for the frame at the specified index. + Returns an invalid SBFrame if idx is out of range. + """ + return _lldb.SBFrameList_GetFrameAtIndex(self, idx) + + def GetThread(self): + r""" + Get the thread associated with this frame list. + + :rtype: :py:class:`SBThread` + :return: + An SBThread object representing the thread. + """ + return _lldb.SBFrameList_GetThread(self) + + def Clear(self): + r"""Clear all frames from this list.""" + return _lldb.SBFrameList_Clear(self) + + def GetDescription(self, description): + r""" + Get a description of this frame list. + + :type description: :py:class:`SBStream`, in + :param description: + The stream to write the description to. + + :rtype: boolean + :return: + True if the description was successfully written. + """ + return _lldb.SBFrameList_GetDescription(self, description) + + def __str__(self): + r"""__str__(SBFrameList self) -> std::string""" + return _lldb.SBFrameList___str__(self) + + def __iter__(self): + '''Iterate over all frames in a lldb.SBFrameList object.''' + return lldb_iter(self, 'GetSize', 'GetFrameAtIndex') + + def __len__(self): + return int(self.GetSize()) + + def __getitem__(self, key): + if type(key) is not int: + return None + if key < 0: + count = len(self) + if -count <= key < count: + key %= count + + frame = self.GetFrameAtIndex(key) + return frame if frame.IsValid() else None + + +# Register SBFrameList in _lldb: +_lldb.SBFrameList_swigregister(SBFrameList) class SBFunction(object): r""" Represents a generic function, which can be inlined or not. @@ -13956,6 +14058,45 @@ def GetAPIMutex(self): r"""GetAPIMutex(SBTarget self) -> SBMutex""" return _lldb.SBTarget_GetAPIMutex(self) + def RegisterScriptedFrameProvider(self, class_name, args_dict, error): + r""" + Register a scripted frame provider for this target. + If a scripted frame provider with the same name and same argument + dictionary is already registered on this target, it will be overwritten. + + :type class_name: string, in + :param class_name: + The name of the Python class that implements the frame provider. + + :type args_dict: :py:class:`SBStructuredData`, in + :param args_dict: + A dictionary of arguments to pass to the frame provider class. + + :type error: :py:class:`SBError`, out + :param error: + An error object indicating success or failure. + + :rtype: int + :return: + A unique identifier for the frame provider descriptor that was + registered. 0 if the registration failed. + """ + return _lldb.SBTarget_RegisterScriptedFrameProvider(self, class_name, args_dict, error) + + def RemoveScriptedFrameProvider(self, provider_id): + r""" + Remove a scripted frame provider from this target by name. + + :type provider_id: int, in + :param provider_id: + The id of the frame provider class to remove. + + :rtype: :py:class:`SBError` + :return: + An error object indicating success or failure. + """ + return _lldb.SBTarget_RemoveScriptedFrameProvider(self, provider_id) + def __repr__(self): r"""__repr__(SBTarget self) -> std::string""" return _lldb.SBTarget___repr__(self) @@ -14500,6 +14641,10 @@ def GetFrameAtIndex(self, idx): r"""GetFrameAtIndex(SBThread self, uint32_t idx) -> SBFrame""" return _lldb.SBThread_GetFrameAtIndex(self, idx) + def GetFrames(self): + r"""GetFrames(SBThread self) -> SBFrameList""" + return _lldb.SBThread_GetFrames(self) + def GetSelectedFrame(self): r"""GetSelectedFrame(SBThread self) -> SBFrame""" return _lldb.SBThread_GetSelectedFrame(self) @@ -14683,7 +14828,8 @@ def get_frames_access_object(self): def get_thread_frames(self): '''An accessor function that returns a list() that contains all frames in a lldb.SBThread object.''' frames = [] - for frame in self: + frame_list = self.GetFrames() + for frame in frame_list: frames.append(frame) return frames