Re-land "[lldb/docs] Silence warnings when generating website"

This reverts commit 18f1c1ace7 and fix the
build failure issues introduced because of the `STRING_EXTENSION_OUTSIDE`
swig macros.

Differential Revision: https://reviews.llvm.org/D159017

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>

lldb/bindings/interface/SBAddressExtensions.i

@@ -7,6 +7,12 @@ STRING_EXTENSION_OUTSIDE(SBAddress)
     %pythoncode%{
     def __eq__(self, other):
       return not self.__ne__(other)
+
+    def __len__(self):
+        pass
+
+    def __iter__(self):
+        pass
     %}
 
     %pythoncode %{

lldb/bindings/interface/SBAttachInfoExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBAttachInfo)
+
+%extend lldb::SBAttachInfo {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBBlockExtensions.i

@@ -3,6 +3,21 @@ STRING_EXTENSION_OUTSIDE(SBBlock)
 %extend lldb::SBBlock {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __int__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         def get_range_at_index(self, idx):
             if idx < self.GetNumRanges():
                 return [self.GetRangeStartAddress(idx), self.GetRangeEndAddress(idx)]

lldb/bindings/interface/SBBreakpointExtensions.i

@@ -44,6 +44,15 @@ STRING_EXTENSION_OUTSIDE(SBBreakpoint)
             object.'''
             return self.GetNumLocations()
 
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         locations = property(get_breakpoint_location_list, None, doc='''A read only property that returns a list() of lldb.SBBreakpointLocation objects for this breakpoint.''')
         location = property(get_locations_access_object, None, doc='''A read only property that returns an object that can access locations by index (not location ID) (location = bkpt.location[12]).''')
         id = property(GetID, None, doc='''A read only property that returns the ID of this breakpoint.''')

lldb/bindings/interface/SBBreakpointListExtensions.i

@@ -0,0 +1,29 @@
+STRING_EXTENSION_OUTSIDE(SBBreakpointList)
+
+%extend lldb::SBBreakpointList {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+        return not self.__ne__(other)
+
+    def __int__(self):
+        pass
+
+    def __len__(self):
+        '''Return the number of breakpoints in a lldb.SBBreakpointList object.'''
+        return self.GetSize()
+
+    def __hex__(self):
+        pass
+
+    def __oct__(self):
+        pass
+
+    def __iter__(self):
+        '''Iterate over all breakpoints in a lldb.SBBreakpointList object.'''
+        return lldb_iter(self, 'GetSize', 'GetBreakpointAtIndex')
+    %}
+#endif
+}

lldb/bindings/interface/SBBreakpointLocationExtensions.i

@@ -1 +1,27 @@
 STRING_EXTENSION_LEVEL_OUTSIDE(SBBreakpointLocation, lldb::eDescriptionLevelFull)
+
+%extend lldb::SBBreakpointLocation {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBBreakpointNameExtensions.i

@@ -1 +1,27 @@
 STRING_EXTENSION_OUTSIDE(SBBreakpointName)
+
+%extend lldb::SBBreakpointName {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBBroadcastExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBBroadcaster)
+
+%extend lldb::SBBroadcaster {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBCommandInterpreterExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBCommandInterpreter)
+
+%extend lldb::SBCommandInterpreter {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBCommandInterpreterRunOptionsExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBCommandInterpreterRunOptions)
+
+%extend lldb::SBCommandInterpreterRunOptions {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBCommandReturnObjectExtensions.i

@@ -1,6 +1,30 @@
 STRING_EXTENSION_OUTSIDE(SBCommandReturnObject)
 
 %extend lldb::SBCommandReturnObject {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+
     // transfer_ownership does nothing, and is here for compatibility with
     // old scripts.  Ownership is tracked by reference count in the ordinary way.
 

lldb/bindings/interface/SBCommunicationExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBCommunication)
+
+%extend lldb::SBCommunication {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBCompileUnitExtensions.i

@@ -3,6 +3,15 @@ STRING_EXTENSION_OUTSIDE(SBCompileUnit)
 %extend lldb::SBCompileUnit {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __iter__(self):
             '''Iterate over all line entries in a lldb.SBCompileUnit object.'''
             return lldb_iter(self, 'GetNumLineEntries', 'GetLineEntryAtIndex')

lldb/bindings/interface/SBDataExtensions.i

@@ -3,6 +3,23 @@ STRING_EXTENSION_OUTSIDE(SBData)
 %extend lldb::SBData {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            return self.GetByteSize()
+
+        def __iter__(self):
+            pass
 
         class read_data_helper:
             def __init__(self, sbdata, readerfunc, item_size):

lldb/bindings/interface/SBDebuggerExtensions.i

@@ -24,6 +24,15 @@ STRING_EXTENSION_OUTSIDE(SBDebugger)
                 file = sys.stderr
             self.SetErrorFile(SBFile.Create(file, borrow=True))
 
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __iter__(self):
             '''Iterate over all targets in a lldb.SBDebugger object.'''
             return lldb_iter(self, 'GetNumTargets', 'GetTargetAtIndex')

lldb/bindings/interface/SBDeclarationExtensions.i

@@ -3,6 +3,21 @@ STRING_EXTENSION_OUTSIDE(SBDeclaration)
 %extend lldb::SBDeclaration {
 #ifdef SWIGPYTHON
         %pythoncode %{
+            def __int__(self):
+                pass
+
+            def __hex__(self):
+                pass
+
+            def __oct__(self):
+                pass
+
+            def __len__(self):
+                pass
+
+            def __iter__(self):
+                pass
+
             file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
             line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
             column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')

lldb/bindings/interface/SBEnvironmentExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBEnvironment)
+
+%extend lldb::SBEnvironment {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBErrorExtensions.i

@@ -3,6 +3,24 @@ STRING_EXTENSION_OUTSIDE(SBError)
 %extend lldb::SBError {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            return self.GetError()
+
+        def __hex__(self):
+            return self.GetError()
+
+        def __oct__(self):
+            return self.GetError()
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         value = property(GetError, None, doc='''A read only property that returns the same result as GetError().''')
         fail = property(Fail, None, doc='''A read only property that returns the same result as Fail().''')
         success = property(Success, None, doc='''A read only property that returns the same result as Success().''')

lldb/bindings/interface/SBEventExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBEvent)
+
+%extend lldb::SBEvent {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBExecutionContextExtensions.i

@@ -1,6 +1,21 @@
 %extend lldb::SBExecutionContext {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         target = property(GetTarget, None, doc='''A read only property that returns the same result as GetTarget().''')
         process = property(GetProcess, None, doc='''A read only property that returns the same result as GetProcess().''')
         thread = property(GetThread, None, doc='''A read only property that returns the same result as GetThread().''')

lldb/bindings/interface/SBExpressionOptionsExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBExpressionOptions)
+
+%extend lldb::SBExpressionOptions {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBFileExtensions.i

@@ -11,6 +11,24 @@
 
 #ifdef SWIGPYTHON
     %pythoncode {
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         @classmethod
         def Create(cls, file, borrow=False, force_io_methods=False):
             """

lldb/bindings/interface/SBFileSpecExtensions.i

@@ -3,6 +3,24 @@ STRING_EXTENSION_OUTSIDE(SBFileSpec)
 %extend lldb::SBFileSpec {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         fullpath = property(str, None, doc='''A read only property that returns the fullpath as a python string.''')
         basename = property(GetFilename, None, doc='''A read only property that returns the path basename as a python string.''')
         dirname = property(GetDirectory, None, doc='''A read only property that returns the path directory name as a python string.''')

lldb/bindings/interface/SBFileSpecListExtensions.i

@@ -0,0 +1,29 @@
+STRING_EXTENSION_OUTSIDE(SBFileSpecList)
+
+%extend lldb::SBFileSpecList {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      '''Return the number of FileSpec in a lldb.SBFileSpecList object.'''
+      return self.GetSize()
+
+    def __iter__(self):
+      '''Iterate over all FileSpecs in a lldb.SBFileSpecList object.'''
+      return lldb_iter(self, 'GetSize', 'GetFileSpecAtIndex')
+    %}
+#endif
+}

lldb/bindings/interface/SBFrameExtensions.i

@@ -3,6 +3,24 @@ STRING_EXTENSION_OUTSIDE(SBFrame)
 %extend lldb::SBFrame {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         def get_all_variables(self):
             return self.GetVariables(True,True,True,True)
 

lldb/bindings/interface/SBFunctionExtensions.i

@@ -3,6 +3,24 @@ STRING_EXTENSION_OUTSIDE(SBFunction)
 %extend lldb::SBFunction {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         def get_instructions_from_current_target (self):
             return self.GetInstructions (target)
 

lldb/bindings/interface/SBHostOSExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBHostOS)
+
+%extend lldb::SBHostOS {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBInstructionExtensions.i

@@ -3,6 +3,26 @@ STRING_EXTENSION_OUTSIDE(SBInstruction)
 %extend lldb::SBInstruction {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            """ Returns the address of the instruction. """
+            return self.GetAddress()
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            """ Returns the size of the instruction. """
+            return self.GetByteSize()
+
+        def __iter__(self):
+            pass
+
         def __mnemonic_property__ (self):
             return self.GetMnemonic (target)
         def __operands_property__ (self):

lldb/bindings/interface/SBInstructionListExtensions.i

@@ -3,6 +3,15 @@ STRING_EXTENSION_OUTSIDE(SBInstructionList)
 %extend lldb::SBInstructionList {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __iter__(self):
             '''Iterate over all instructions in a lldb.SBInstructionList
             object.'''

lldb/bindings/interface/SBLanguageRuntimeExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBLanguageRuntime)
+
+%extend lldb::SBLanguageRuntime {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBLaunchInfoExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBLaunchInfo)
+
+%extend lldb::SBLaunchInfo {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBLineEntryExtensions.i

@@ -3,6 +3,24 @@ STRING_EXTENSION_OUTSIDE(SBLineEntry)
 %extend lldb::SBLineEntry {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            return self.GetLine()
+
+        def __hex__(self):
+            return self.GetStartAddress()
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
         line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
         column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')

lldb/bindings/interface/SBListenerExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBListener)
+
+%extend lldb::SBListener {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBMemoryRegionInfoExtensions.i

@@ -1 +1,27 @@
 STRING_EXTENSION_OUTSIDE(SBMemoryRegionInfo)
+
+%extend lldb::SBMemoryRegionInfo {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      return self.GetRegionBase()
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      return self.GetRegionEnd() - self.GetRegionBase()
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBMemoryRegionInfoListExtensions.i

@@ -0,0 +1,29 @@
+STRING_EXTENSION_OUTSIDE(SBMemoryRegionInfoList)
+
+%extend lldb::SBMemoryRegionInfoList {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      '''Return the number of memory region info in a lldb.SBMemoryRegionInfoList object.'''
+      return self.GetSize()
+
+    def __iter__(self):
+      '''Iterate over all the memory regions in a lldb.SBMemoryRegionInfoList object.'''
+      return lldb_iter(self, 'GetSize', 'GetMemoryRegionAtIndex')
+    %}
+#endif
+}

lldb/bindings/interface/SBModuleExtensions.i

@@ -28,6 +28,18 @@ STRING_EXTENSION_OUTSIDE(SBModule)
 %extend lldb::SBModule {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __len__(self):
             '''Return the number of symbols in a lldb.SBModule object.'''
             return self.GetNumSymbols()

lldb/bindings/interface/SBModuleSpecExtensions.i

@@ -1,3 +1,27 @@
 STRING_EXTENSION_OUTSIDE(SBModuleSpec)
 
-STRING_EXTENSION_OUTSIDE(SBModuleSpecList)
+%extend lldb::SBModuleSpec {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBModuleSpecListExtensions.i

@@ -0,0 +1,30 @@
+STRING_EXTENSION_OUTSIDE(SBModuleSpecList)
+
+%extend lldb::SBModuleSpecList {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      '''Return the number of ModuleSpec in a lldb.SBModuleSpecList object.'''
+      return self.GetSize()
+
+    def __iter__(self):
+      '''Iterate over all ModuleSpecs in a lldb.SBModuleSpecList object.'''
+      return lldb_iter(self, 'GetSize', 'GetSpecAtIndex')
+    %}
+#endif
+}
+

lldb/bindings/interface/SBPlatformConnectOptionsExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBPlatformConnectOptions)
+
+%extend lldb::SBPlatformConnectOptions {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBPlatformExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBPlatform)
+
+%extend lldb::SBPlatform {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBPlatformShellCommandExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBPlatformShellCommand)
+
+%extend lldb::SBPlatformShellCommand {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBProcessDocstrings.i

@@ -209,6 +209,10 @@ SBProcess supports thread iteration. For example (from test/lldbutil.py), ::
     lldb.LLDB_INVALID_ADDRESS if the allocation failed."
 ) lldb::SBProcess::AllocateMemory;
 
+%feature("autodoc", "Get default process broadcaster class name (lldb.process)."
+) lldb::SBProcess::GetBroadcasterClass;
+
+
 %feature("autodoc", "
     Deallocates the block of memory (previously allocated using
     AllocateMemory) given in the argument."

lldb/bindings/interface/SBProcessExtensions.i

@@ -79,6 +79,14 @@ STRING_EXTENSION_OUTSIDE(SBProcess)
             '''Return the number of threads in a lldb.SBProcess object.'''
             return self.GetNumThreads()
 
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
 
         threads = property(get_process_thread_list, None, doc='''A read only property that returns a list() of lldb.SBThread objects for this process.''')
         thread = property(get_threads_access_object, None, doc='''A read only property that returns an object that can access threads by thread index (thread = lldb.process.thread[12]).''')

lldb/bindings/interface/SBProcessInfoExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBProcessInfo)
+
+%extend lldb::SBProcessInfo {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBQueueExtensions.i

@@ -0,0 +1,28 @@
+STRING_EXTENSION_OUTSIDE(SBQueue)
+
+%extend lldb::SBQueue {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}
+

lldb/bindings/interface/SBQueueItemExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBQueueItem)
+
+%extend lldb::SBQueueItem {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      return self.GetAddress()
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBReproducerExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBReproducer)
+
+%extend lldb::SBReproducer {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBScriptObjectExtensions.i

@@ -1,6 +1,26 @@
+STRING_EXTENSION_OUTSIDE(SBScriptObject)
+
 %extend lldb::SBScriptObject {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         ptr = property(GetPointer, None, doc='''A read only property that returns the underlying script object.''')
         lang = property(GetLanguage, None, doc='''A read only property that returns the script language associated with with this script object.''')
     %}

lldb/bindings/interface/SBSectionExtensions.i

@@ -3,6 +3,18 @@ STRING_EXTENSION_OUTSIDE(SBSection)
 %extend lldb::SBSection {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __iter__(self):
             '''Iterate over all subsections in a lldb.SBSection object.'''
             return lldb_iter(self, 'GetNumSubSections', 'GetSubSectionAtIndex')

lldb/bindings/interface/SBSourceManagerExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBSourceManager)
+
+%extend lldb::SBSourceManager {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+	    def __eq__(self, other):
+	      return not self.__ne__(other)
+
+	    def __int__(self):
+	      pass
+
+	    def __hex__(self):
+	      pass
+
+	    def __oct__(self):
+	      pass
+
+	    def __len__(self):
+	      pass
+
+	    def __iter__(self):
+	      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBStreamExtensions.i

@@ -1,4 +1,28 @@
 %extend lldb::SBStream {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+	    def __eq__(self, other):
+	      return not self.__ne__(other)
+
+	    def __int__(self):
+	      pass
+
+	    def __hex__(self):
+	      pass
+
+	    def __oct__(self):
+	      pass
+
+	    def __len__(self):
+	      return self.GetSize()
+
+	    def __iter__(self):
+	      pass
+    %}
+#endif
+
     %feature("autodoc", "DEPRECATED, use RedirectToFile") RedirectToFileHandle;
     void
     RedirectToFileHandle (lldb::FileSP file, bool transfer_fh_ownership) {

lldb/bindings/interface/SBStringListExtensions.i

@@ -1,6 +1,15 @@
 %extend lldb::SBStringList {
 #ifdef SWIGPYTHON
     %pythoncode%{
+    def __int__(self):
+        pass
+
+    def __hex__(self):
+        pass
+
+    def __oct__(self):
+        pass
+
     def __iter__(self):
         '''Iterate over all strings in a lldb.SBStringList object.'''
         return lldb_iter(self, 'GetSize', 'GetStringAtIndex')

lldb/bindings/interface/SBStructuredDataExtensions.i

@@ -0,0 +1,29 @@
+STRING_EXTENSION_OUTSIDE(SBStructuredData)
+
+%extend lldb::SBStructuredData {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      return self.GetSignedInteger()
+
+    def __hex__(self):
+      return hex(self.GetSignedInteger())
+
+    def __oct__(self):
+      return oct(self.GetSignedInteger())
+
+    def __len__(self):
+      '''Return the number of element in a lldb.SBStructuredData object.'''
+      return self.GetSize()
+
+    def __iter__(self):
+        '''Iterate over all the elements in a lldb.SBStructuredData object.'''
+        return lldb_iter(self, 'GetSize', 'GetItemAtIndex')
+    %}
+#endif
+}

lldb/bindings/interface/SBSymbolContextExtensions.i

@@ -3,6 +3,24 @@ STRING_EXTENSION_OUTSIDE(SBSymbolContext)
 %extend lldb::SBSymbolContext {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         module = property(GetModule, SetModule, doc='''A read/write property that allows the getting/setting of the module (lldb.SBModule) in this symbol context.''')
         compile_unit = property(GetCompileUnit, SetCompileUnit, doc='''A read/write property that allows the getting/setting of the compile unit (lldb.SBCompileUnit) in this symbol context.''')
         function = property(GetFunction, SetFunction, doc='''A read/write property that allows the getting/setting of the function (lldb.SBFunction) in this symbol context.''')

lldb/bindings/interface/SBSymbolContextListExtensions.i

@@ -11,6 +11,15 @@ STRING_EXTENSION_OUTSIDE(SBSymbolContextList)
         def __len__(self):
             return int(self.GetSize())
 
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __getitem__(self, key):
             count = len(self)
             if isinstance(key, int):

lldb/bindings/interface/SBSymbolExtensions.i

@@ -3,6 +3,24 @@ STRING_EXTENSION_OUTSIDE(SBSymbol)
 %extend lldb::SBSymbol {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            return self.GetStartAddress()
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         def get_instructions_from_current_target (self):
             return self.GetInstructions (target)
 

lldb/bindings/interface/SBTargetExtensions.i

@@ -32,6 +32,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTarget, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTarget {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         class modules_access(object):
             '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
             def __init__(self, sbtarget):

lldb/bindings/interface/SBThreadCollectionExtensions.i

@@ -0,0 +1,29 @@
+STRING_EXTENSION_OUTSIDE(SBThreadCollection)
+
+%extend lldb::SBThreadCollection {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __iter__(self):
+        '''Iterate over all threads in a lldb.SBThreadCollection object.'''
+        return lldb_iter(self, 'GetSize', 'GetThreadAtIndex')
+
+    def __len__(self):
+        '''Return the number of threads in a lldb.SBThreadCollection object.'''
+        return self.GetSize()
+    %}
+#endif
+}

lldb/bindings/interface/SBThreadExtensions.i

@@ -3,6 +3,18 @@ STRING_EXTENSION_OUTSIDE(SBThread)
 %extend lldb::SBThread {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __iter__(self):
             '''Iterate over all frames in a lldb.SBThread object.'''
             return lldb_iter(self, 'GetNumFrames', 'GetFrameAtIndex')

lldb/bindings/interface/SBThreadPlanExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBThreadPlan)
+
+%extend lldb::SBThreadPlan {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBTraceCursorExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBTraceCursor)
+
+%extend lldb::SBTraceCursor {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+      def __eq__(self, other):
+        return not self.__ne__(other)
+
+      def __int__(self):
+        pass
+
+      def __hex__(self):
+        pass
+
+      def __oct__(self):
+        pass
+
+      def __len__(self):
+        pass
+
+      def __iter__(self):
+        pass
+    %}
+#endif
+}

lldb/bindings/interface/SBTraceExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBTrace)
+
+%extend lldb::SBTrace {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+    def __eq__(self, other):
+      return not self.__ne__(other)
+
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      pass
+
+    def __iter__(self):
+      pass
+    %}
+#endif
+}

lldb/bindings/interface/SBTypeCategoryExtensions.i

@@ -3,6 +3,23 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeCategory, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeCategory {
 #ifdef SWIGPYTHON
         %pythoncode %{
+            def __eq__(self, other):
+                return not self.__ne__(other)
+
+            def __int__(self):
+                pass
+
+            def __hex__(self):
+                pass
+
+            def __oct__(self):
+                pass
+
+            def __len__(self):
+                pass
+
+            def __iter__(self):
+                pass
 
             class formatters_access_class(object):
                 '''A helper object that will lazily hand out formatters for a specific category.'''

lldb/bindings/interface/SBTypeEnumMemberExtensions.i

@@ -2,6 +2,26 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeEnumMember, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeEnumMember {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __iter__(self):
+            '''Iterate over all members in a lldb.SBTypeEnumMemberList object.'''
+            return lldb_iter(self, 'GetSize', 'GetTypeEnumMemberAtIndex')
+
+        def __len__(self):
+            '''Return the number of members in a lldb.SBTypeEnumMemberList object.'''
+            return self.GetSize()
+
         name = property(GetName, None, doc='''A read only property that returns the name for this enum member as a string.''')
         type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this enum member.''')
         signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this enum member as a signed integer.''')
@@ -13,6 +33,18 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeEnumMember, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeEnumMemberList {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __iter__(self):
             '''Iterate over all members in a lldb.SBTypeEnumMemberList object.'''
             return lldb_iter(self, 'GetSize', 'GetTypeEnumMemberAtIndex')

lldb/bindings/interface/SBTypeExtensions.i

@@ -2,6 +2,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeMember, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeMember {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            pass
+
+        def __iter__(self):
+            pass
+
         name = property(GetName, None, doc='''A read only property that returns the name for this member as a string.''')
         type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this member.''')
         byte_offset = property(GetOffsetInBytes, None, doc='''A read only property that returns offset in bytes for this member as an integer.''')
@@ -14,6 +32,32 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeMember, lldb::eDescriptionLevelBrief)
 
 STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeMemberFunction, lldb::eDescriptionLevelBrief)
 
+%extend lldb::SBTypeMemberFunction {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+      def __eq__(self, other):
+        return not self.__ne__(other)
+
+      def __int__(self):
+        pass
+
+      def __hex__(self):
+        pass
+
+      def __oct__(self):
+        pass
+
+      def __len__(self):
+        pass
+
+      def __iter__(self):
+        pass
+    %}
+#endif
+}
+
 STRING_EXTENSION_LEVEL_OUTSIDE(SBType, lldb::eDescriptionLevelBrief)
 
 %extend lldb::SBType {
@@ -28,6 +72,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBType, lldb::eDescriptionLevelBrief)
                 return template_args
             return None
 
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
+        def __len__(self):
+            return self.GetByteSize()
+
+        def __iter__(self):
+            pass
+
         module = property(GetModule, None, doc='''A read only property that returns the module in which type is defined.''')
         name = property(GetName, None, doc='''A read only property that returns the name for this type as a string.''')
         size = property(GetByteSize, None, doc='''A read only property that returns size in bytes for this type as an integer.''')
@@ -121,6 +183,18 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBType, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeList {
 #ifdef SWIGPYTHON
     %pythoncode%{
+    def __eq__(self, other):
+        return not self.__ne__(other)
+
+    def __int__(self):
+        pass
+
+    def __hex__(self):
+        pass
+
+    def __oct__(self):
+        pass
+
     def __iter__(self):
         '''Iterate over all types in a lldb.SBTypeList object.'''
         return lldb_iter(self, 'GetSize', 'GetTypeAtIndex')

lldb/bindings/interface/SBTypeFilterExtensions.i

@@ -2,6 +2,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeFilter, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeFilter {
 #ifdef SWIGPYTHON
         %pythoncode %{
+            def __eq__(self, other):
+                return not self.__ne__(other)
+
+            def __int__(self):
+                pass
+
+            def __hex__(self):
+                pass
+
+            def __oct__(self):
+                pass
+
+            def __len__(self):
+                pass
+
+            def __iter__(self):
+                pass
+
             options = property(GetOptions, SetOptions)
             count = property(GetNumberOfExpressionPaths)
         %}

lldb/bindings/interface/SBTypeFormatExtensions.i

@@ -2,6 +2,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeFormat, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeFormat {
 #ifdef SWIGPYTHON
         %pythoncode %{
+            def __eq__(self, other):
+                return not self.__ne__(other)
+
+            def __int__(self):
+                pass
+
+            def __hex__(self):
+                pass
+
+            def __oct__(self):
+                pass
+
+            def __len__(self):
+                pass
+
+            def __iter__(self):
+                pass
+
             format = property(GetFormat, SetFormat)
             options = property(GetOptions, SetOptions)
         %}

lldb/bindings/interface/SBTypeNameSpecifierExtensions.i

@@ -2,6 +2,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeNameSpecifier, lldb::eDescriptionLevelBrief
 %extend lldb::SBTypeNameSpecifier {
 #ifdef SWIGPYTHON
         %pythoncode %{
+            def __eq__(self, other):
+                return not self.__ne__(other)
+
+            def __int__(self):
+                pass
+
+            def __hex__(self):
+                pass
+
+            def __oct__(self):
+                pass
+
+            def __len__(self):
+                pass
+
+            def __iter__(self):
+                pass
+
             name = property(GetName)
             is_regex = property(IsRegex)
         %}

lldb/bindings/interface/SBTypeSummaryExtensions.i

@@ -2,6 +2,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeSummary, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeSummary {
 #ifdef SWIGPYTHON
         %pythoncode %{
+            def __eq__(self, other):
+                return not self.__ne__(other)
+
+            def __int__(self):
+                pass
+
+            def __hex__(self):
+                pass
+
+            def __oct__(self):
+                pass
+
+            def __len__(self):
+                pass
+
+            def __iter__(self):
+                pass
+
             options = property(GetOptions, SetOptions)
             is_summary_string = property(IsSummaryString)
             is_function_name = property(IsFunctionName)

lldb/bindings/interface/SBTypeSummaryOptionsExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBTypeSummaryOptions)
+
+%extend lldb::SBTypeSummaryOptions {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+      def __eq__(self, other):
+        return not self.__ne__(other)
+
+      def __int__(self):
+        pass
+
+      def __hex__(self):
+        pass
+
+      def __oct__(self):
+        pass
+
+      def __len__(self):
+        pass
+
+      def __iter__(self):
+        pass
+    %}
+#endif
+}

lldb/bindings/interface/SBTypeSyntheticExtensions.i

@@ -2,6 +2,24 @@ STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeSynthetic, lldb::eDescriptionLevelBrief)
 %extend lldb::SBTypeSynthetic {
 #ifdef SWIGPYTHON
         %pythoncode %{
+            def __eq__(self, other):
+                return not self.__ne__(other)
+
+            def __int__(self):
+                pass
+
+            def __hex__(self):
+                pass
+
+            def __oct__(self):
+                pass
+
+            def __len__(self):
+                pass
+
+            def __iter__(self):
+                pass
+
             options = property(GetOptions, SetOptions)
             contains_code = property(IsClassCode, None)
             synthetic_data = property(GetData, None)

lldb/bindings/interface/SBUnixSignalsExtensions.i

@@ -1,6 +1,25 @@
 %extend lldb::SBUnixSignals {
 #ifdef SWIGPYTHON
     %pythoncode %{
+        def __iter__(self):
+            '''Iterate over all signals in a lldb.SBUnixSignals object.'''
+            return lldb_iter(self, 'GetNumSignals', 'GetSignalAtIndex')
+
+        def __len__(self):
+            return int(self.GetNumSignals())
+
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def get_unix_signals_list(self):
             signals = []
             for idx in range(0, self.GetNumSignals()):

lldb/bindings/interface/SBValueExtensions.i

@@ -37,6 +37,18 @@ STRING_EXTENSION_OUTSIDE(SBValue)
                 children.append(accessor[idx])
             return children
 
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            return self.GetAddress()
+
+        def __oct__(self):
+            pass
+
         def __iter__(self):
             '''Iterate over all child values of a lldb.SBValue object.'''
             return lldb_iter(self, 'GetNumChildren', 'GetChildAtIndex')

lldb/bindings/interface/SBValueListExtensions.i

@@ -34,6 +34,18 @@
         def __len__(self):
             return int(self.GetSize())
 
+        def __eq__(self, other):
+            return not self.__ne__(other)
+
+        def __int__(self):
+            pass
+
+        def __hex__(self):
+            pass
+
+        def __oct__(self):
+            pass
+
         def __getitem__(self, key):
             count = len(self)
             #------------------------------------------------------------

lldb/bindings/interface/SBVariablesOptionsExtensions.i

@@ -0,0 +1,27 @@
+STRING_EXTENSION_OUTSIDE(SBVariablesOptions)
+
+%extend lldb::SBVariablesOptions {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+      def __eq__(self, other):
+        return not self.__ne__(other)
+
+      def __int__(self):
+        pass
+
+      def __hex__(self):
+        pass
+
+      def __oct__(self):
+        pass
+
+      def __len__(self):
+        pass
+
+      def __iter__(self):
+        pass
+    %}
+#endif
+}

lldb/bindings/interface/SBWatchpointExtensions.i

@@ -1 +1,27 @@
 STRING_EXTENSION_LEVEL_OUTSIDE(SBWatchpoint, lldb::eDescriptionLevelVerbose)
+
+%extend lldb::SBWatchpoint {
+#ifdef SWIGPYTHON
+    // operator== is a free function, which swig does not handle, so we inject
+    // our own equality operator here
+    %pythoncode%{
+      def __eq__(self, other):
+        return not self.__ne__(other)
+
+      def __int__(self):
+        pass
+
+      def __hex__(self):
+        return self.GetWatchAddress()
+
+      def __oct__(self):
+        pass
+
+      def __len__(self):
+        return self.GetWatchSize()
+
+      def __iter__(self):
+        pass
+    %}
+#endif
+}

lldb/bindings/interfaces.swig

@@ -155,46 +155,78 @@
 
 /* Extensions for SB classes */
 %include "./interface/SBAddressExtensions.i"
+%include "./interface/SBAttachInfoExtensions.i"
 %include "./interface/SBBlockExtensions.i"
 %include "./interface/SBBreakpointExtensions.i"
+%include "./interface/SBBreakpointListExtensions.i"
 %include "./interface/SBBreakpointLocationExtensions.i"
 %include "./interface/SBBreakpointNameExtensions.i"
+%include "./interface/SBBroadcastExtensions.i"
+%include "./interface/SBCommandInterpreterExtensions.i"
+%include "./interface/SBCommandInterpreterRunOptionsExtensions.i"
 %include "./interface/SBCommandReturnObjectExtensions.i"
+%include "./interface/SBCommunicationExtensions.i"
 %include "./interface/SBCompileUnitExtensions.i"
 %include "./interface/SBDataExtensions.i"
 %include "./interface/SBDebuggerExtensions.i"
 %include "./interface/SBDeclarationExtensions.i"
+%include "./interface/SBEnvironmentExtensions.i"
 %include "./interface/SBErrorExtensions.i"
+%include "./interface/SBEventExtensions.i"
 %include "./interface/SBExecutionContextExtensions.i"
+%include "./interface/SBExpressionOptionsExtensions.i"
 %include "./interface/SBFileExtensions.i"
 %include "./interface/SBFileSpecExtensions.i"
+%include "./interface/SBFileSpecListExtensions.i"
 %include "./interface/SBFrameExtensions.i"
 %include "./interface/SBFunctionExtensions.i"
+%include "./interface/SBHostOSExtensions.i"
 %include "./interface/SBInstructionExtensions.i"
 %include "./interface/SBInstructionListExtensions.i"
+%include "./interface/SBLanguageRuntimeExtensions.i"
+%include "./interface/SBLaunchInfoExtensions.i"
 %include "./interface/SBLineEntryExtensions.i"
+%include "./interface/SBListenerExtensions.i"
 %include "./interface/SBMemoryRegionInfoExtensions.i"
+%include "./interface/SBMemoryRegionInfoListExtensions.i"
 %include "./interface/SBModuleExtensions.i"
 %include "./interface/SBModuleSpecExtensions.i"
+%include "./interface/SBModuleSpecListExtensions.i"
+%include "./interface/SBPlatformConnectOptionsExtensions.i"
+%include "./interface/SBPlatformExtensions.i"
+%include "./interface/SBPlatformShellCommandExtensions.i"
 %include "./interface/SBProcessExtensions.i"
+%include "./interface/SBProcessInfoExtensions.i"
+%include "./interface/SBQueueExtensions.i"
+%include "./interface/SBQueueItemExtensions.i"
+%include "./interface/SBReproducerExtensions.i"
 %include "./interface/SBScriptObjectExtensions.i"
 %include "./interface/SBSectionExtensions.i"
+%include "./interface/SBSourceManagerExtensions.i"
 %include "./interface/SBStreamExtensions.i"
 %include "./interface/SBStringListExtensions.i"
-%include "./interface/SBSymbolExtensions.i"
+%include "./interface/SBStructuredDataExtensions.i"
+%include "./interface/SBSymbolContextExtensions.i"
 %include "./interface/SBSymbolContextExtensions.i"
 %include "./interface/SBSymbolContextListExtensions.i"
+%include "./interface/SBSymbolExtensions.i"
 %include "./interface/SBTargetExtensions.i"
+%include "./interface/SBThreadCollectionExtensions.i"
 %include "./interface/SBThreadExtensions.i"
-%include "./interface/SBTypeExtensions.i"
+%include "./interface/SBThreadPlanExtensions.i"
+%include "./interface/SBTraceCursorExtensions.i"
+%include "./interface/SBTraceExtensions.i"
 %include "./interface/SBTypeCategoryExtensions.i"
 %include "./interface/SBTypeEnumMemberExtensions.i"
+%include "./interface/SBTypeExtensions.i"
 %include "./interface/SBTypeFilterExtensions.i"
 %include "./interface/SBTypeFormatExtensions.i"
 %include "./interface/SBTypeNameSpecifierExtensions.i"
 %include "./interface/SBTypeSummaryExtensions.i"
+%include "./interface/SBTypeSummaryOptionsExtensions.i"
 %include "./interface/SBTypeSyntheticExtensions.i"
 %include "./interface/SBUnixSignalsExtensions.i"
 %include "./interface/SBValueExtensions.i"
 %include "./interface/SBValueListExtensions.i"
+%include "./interface/SBVariablesOptionsExtensions.i"
 %include "./interface/SBWatchpointExtensions.i"

lldb/bindings/python/python-extensions.swig

@@ -289,6 +289,24 @@ class declaration(object):
         self.line = line
         self.col = col
 
+    def __eq__(self, other):
+        return not self.__ne__(other)
+
+    def __int__(self):
+        pass
+
+    def __hex__(self):
+        pass
+
+    def __oct__(self):
+        pass
+
+    def __len__(self):
+        pass
+
+    def __iter__(self):
+        pass
+
 class value_iter(object):
     '''Allows iterating over the children of an :py:class:`SBValue`.'''
     def __iter__(self):
@@ -304,8 +322,24 @@ class value_iter(object):
     def next(self):
         return self.__next__()
 
+    def __eq__(self, other):
+        return not self.__ne__(other)
+
+    def __int__(self):
+        pass
+
+    def __hex__(self):
+        pass
+
+    def __oct__(self):
+        pass
+
+    def __len__(self):
+        return self.length
+
     def __init__(self,value):
         self.index = 0
+        self.length = 0
         self.sbvalue = value
         if type(self.sbvalue) is value:
             self.sbvalue = self.sbvalue.sbvalue
@@ -546,6 +580,21 @@ class SBSyntheticValueProvider(object):
     def has_children(self):
         return False
 
+    def __int__(self):
+      pass
+
+    def __hex__(self):
+      pass
+
+    def __oct__(self):
+      pass
+
+    def __len__(self):
+      return self.num_children()
+
+    def __iter__(self):
+      '''Iterate over all children in a lldb.SBSyntheticValueProvider object.'''
+      return lldb_iter(self, 'num_children', 'get_child_at_index')
 
 %}
 

lldb/bindings/python/python.swig

@@ -106,6 +106,21 @@ def lldb_iter(obj, getsize, getelem):
     elem = getattr(obj, getelem)
     for i in range(size()):
         yield elem(i)
+
+def __int__(self):
+  pass
+
+def __hex__(self):
+  pass
+
+def __oct__(self):
+  pass
+
+def __len__(self):
+  pass
+
+def __iter__(self):
+  pass
 %}
 
 %include <std_string.i>

lldb/docs/conf.py

@@ -170,7 +170,7 @@ html_title = "🐛 LLDB"
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+# html_static_path = ["_static"]
 
 html_extra_path = [".htaccess"]
 

lldb/docs/python_api.rst

@@ -5,94 +5,10 @@ LLDB Python API
   The long list of "skip" filters out several global functions that are
   generated by SWIG (but which are not useful as they are only the
   backend for their respective static functions in the classes).
-  Without this list
 .. automodapi:: lldb
   :no-inheritance-diagram:
-  :skip: SBBreakpoint_EventIsBreakpointEvent
-  :skip: SBBreakpoint_GetBreakpointEventTypeFromEvent
-  :skip: SBBreakpoint_GetBreakpointFromEvent
-  :skip: SBBreakpoint_GetBreakpointLocationAtIndexFromEvent
-  :skip: SBBreakpoint_GetNumBreakpointLocationsFromEvent
-  :skip: SBCommandInterpreter_EventIsCommandInterpreterEvent
-  :skip: SBCommandInterpreter_GetArgumentDescriptionAsCString
-  :skip: SBCommandInterpreter_GetArgumentTypeAsCString
-  :skip: SBCommandInterpreter_GetBroadcasterClass
-  :skip: SBCommunication_GetBroadcasterClass
-  :skip: SBData_CreateDataFromCString
-  :skip: SBData_CreateDataFromDoubleArray
-  :skip: SBData_CreateDataFromSInt32Array
-  :skip: SBData_CreateDataFromSInt64Array
-  :skip: SBData_CreateDataFromUInt32Array
-  :skip: SBData_CreateDataFromUInt64Array
-  :skip: SBDebugger_Create
-  :skip: SBDebugger_Create
-  :skip: SBDebugger_Destroy
-  :skip: SBDebugger_FindDebuggerWithID
-  :skip: SBDebugger_GetBuildConfiguration
-  :skip: SBDebugger_GetDefaultArchitecture
-  :skip: SBDebugger_GetInternalVariableValue
-  :skip: SBDebugger_GetVersionString
-  :skip: SBDebugger_Initialize
-  :skip: SBDebugger_InitializeWithErrorHandling
-  :skip: SBDebugger_MemoryPressureDetected
-  :skip: SBDebugger_SetDefaultArchitecture
-  :skip: SBDebugger_SetInternalVariable
-  :skip: SBDebugger_StateAsCString
-  :skip: SBDebugger_StateIsRunningState
-  :skip: SBDebugger_StateIsStoppedState
-  :skip: SBDebugger_Terminate
-  :skip: SBEvent_GetCStringFromEvent
-  :skip: SBFileSpec_ResolvePath
-  :skip: SBFile_MakeBorrowed
-  :skip: SBFile_MakeBorrowedForcingIOMethods
-  :skip: SBFile_MakeForcingIOMethods
-  :skip: SBHostOS_GetLLDBPath
-  :skip: SBHostOS_GetLLDBPythonPath
-  :skip: SBHostOS_GetProgramFileSpec
-  :skip: SBHostOS_GetUserHomeDirectory
-  :skip: SBHostOS_ThreadCancel
-  :skip: SBHostOS_ThreadCreate
-  :skip: SBHostOS_ThreadCreated
-  :skip: SBHostOS_ThreadDetach
-  :skip: SBHostOS_ThreadJoin
-  :skip: SBLanguageRuntime_GetLanguageTypeFromString
-  :skip: SBLanguageRuntime_GetNameForLanguageType
-  :skip: SBModuleSpecList_GetModuleSpecifications
-  :skip: SBModule_GarbageCollectAllocatedModules
-  :skip: SBModule_GetNumberAllocatedModules
-  :skip: SBPlatform_GetHostPlatform
-  :skip: SBProcess_EventIsProcessEvent
-  :skip: SBProcess_EventIsStructuredDataEvent
-  :skip: SBProcess_GetBroadcasterClassName
-  :skip: SBProcess_GetInterruptedFromEvent
-  :skip: SBProcess_GetNumRestartedReasonsFromEvent
-  :skip: SBProcess_GetProcessFromEvent
-  :skip: SBProcess_GetRestartedFromEvent
-  :skip: SBProcess_GetRestartedReasonAtIndexFromEvent
-  :skip: SBProcess_GetStateFromEvent
-  :skip: SBProcess_GetStructuredDataFromEvent
-  :skip: SBReproducer_Capture
-  :skip: SBReproducer_PassiveReplay
-  :skip: SBReproducer_SetAutoGenerate
-  :skip: SBReproducer_SetWorkingDirectory
-  :skip: SBTarget_EventIsTargetEvent
-  :skip: SBTarget_GetBroadcasterClassName
-  :skip: SBTarget_GetModuleAtIndexFromEvent
-  :skip: SBTarget_GetNumModulesFromEvent
-  :skip: SBTarget_GetTargetFromEvent
-  :skip: SBThread_EventIsThreadEvent
-  :skip: SBThread_GetBroadcasterClassName
-  :skip: SBThread_GetStackFrameFromEvent
-  :skip: SBThread_GetThreadFromEvent
-  :skip: SBTypeSummary_CreateWithFunctionName
-  :skip: SBTypeSummary_CreateWithScriptCode
-  :skip: SBTypeSummary_CreateWithSummaryString
-  :skip: SBTypeSynthetic_CreateWithClassName
-  :skip: SBTypeSynthetic_CreateWithScriptCode
-  :skip: SBWatchpoint_EventIsWatchpointEvent
-  :skip: SBWatchpoint_GetWatchpointEventTypeFromEvent
-  :skip: SBWatchpoint_GetWatchpointFromEvent
   :skip: command
+  :skip: declaration
   :skip: in_range
   :skip: is_numeric_type
   :skip: lldb_iter