[lldb/docs] Silence warnings when generating website

[mib]

Summary

This patch does various things to silence the warnings that show up when
generating the website documentation.

First, this patch adds the missing definition for special member methods
in every SBAPI class. If the class cannot implement one of the special
member method, we just define it as a null operation (pass).

This should fix the following warnings:

WARNING: missing attribute __int__ in object lldb.SB*
WARNING: missing attribute __len__ in object lldb.SB*
WARNING: missing attribute __hex__ in object lldb.SB*
WARNING: missing attribute __oct__ in object lldb.SB*
WARNING: missing attribute __iter__ in object lldb.SB*

Then, it un-skips the various static methods that we didn't generate
the methods for, since it's not necessary thanks to the automod-api module.

Finally, this comments out the _static directory in the sphinx config,
since we don't need it anymore.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

Overall this LGTM. It's really unfortunate we have to define things like __hex__ for every class. Is there a way to either (1) silence this warning on (2) have SWIG generate this for us?

[mib]

lldb/docs/conf.py

46

@JDevlieghere AFAIK, if we want to silence the warnings, we should disable generating special members (such as __hex__) however I think this would be a missed opportunity since they can make using SB classes in python more ergonomic, for example using hex(SBAddress) instead of hex(SBAddress.GetLoadAddress)

lldb/bindings/interface/SBAddressExtensions.i

 STRING_EXTENSION_OUTSIDE(SBAddress)
 
 %extend lldb::SBAddress {
 #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 __len__(self):
+        pass
+
+    def __iter__(self):
+        pass
     %}
 
     %pythoncode %{
         __runtime_error_str = 'This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'
 
         def __get_load_addr_property__ (self):
             '''Get the load address for a lldb.SBAddress using the current target. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'''
             if not target:

lldb/bindings/interface/SBAttachInfoExtensions.i

+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

 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)]
             return []
 
         class ranges_access(object):
             '''A helper object that will lazily hand out an array of lldb.SBAddress that represent address ranges for a block.'''
             def __init__(self, sbblock):

lldb/bindings/interface/SBBreakpointExtensions.i

%pythoncode %{
             object.'''
             return lldb_iter(self, 'GetNumLocations', 'GetLocationAtIndex')
 
         def __len__(self):
             '''Return the number of breakpoint locations in a lldb.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.''')
         enabled = property(IsEnabled, SetEnabled, doc='''A read/write property that configures whether this breakpoint is enabled or not.''')
         one_shot = property(IsOneShot, SetOneShot, doc='''A read/write property that configures whether this breakpoint is one-shot (deleted when hit) or not.''')
         num_locations = property(GetNumLocations, None, doc='''A read only property that returns the count of locations of this breakpoint.''')
     %}
 #endif
 }

lldb/bindings/interface/SBBreakpointListExtensions.i

+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

 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

 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

+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

+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

+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

 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.
 
     void SetImmediateOutputFile(lldb::FileSP BORROWED, bool transfer_ownership) {
         self->SetImmediateOutputFile(BORROWED);
     }
     void SetImmediateErrorFile(lldb::FileSP BORROWED, bool transfer_ownership) {
         self->SetImmediateErrorFile(BORROWED);

lldb/bindings/interface/SBCommunicationExtensions.i

+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

 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')
 
         def __len__(self):
             '''Return the number of line entries in a lldb.SBCompileUnit
             object.'''
             return self.GetNumLineEntries()
 
         file = property(GetFileSpec, None, doc='''A read only property that returns the same result an lldb object that represents the source file (lldb.SBFileSpec) for the compile unit.''')
         num_line_entries = property(GetNumLineEntries, None, doc='''A read only property that returns the number of line entries in a compile unit as an integer.''')
     %}
 #endif
 }

lldb/bindings/interface/SBDataExtensions.i

 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):
                 self.sbdata = sbdata
                 self.readerfunc = readerfunc
                 self.item_size = item_size
             def __getitem__(self,key):
                 if isinstance(key,slice):

lldb/bindings/interface/SBDebuggerExtensions.i

%pythoncode %{
 
         def SetErrorFileHandle(self, file, transfer_ownership):
             "DEPRECATED, use SetErrorFile"
             if file is None:
                 import sys
                 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')
 
         def __len__(self):
             '''Return the number of targets in a lldb.SBDebugger object.'''
             return self.GetNumTargets()
     %}

lldb/bindings/interface/SBDeclarationExtensions.i

 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.''')
         %}
 #endif
 }

lldb/bindings/interface/SBEnvironmentExtensions.i

+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

 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().''')
         description = property(GetCString, None, doc='''A read only property that returns the same result as GetCString().''')
         type = property(GetType, None, doc='''A read only property that returns the same result as GetType().''')
     %}
 #endif
 }

lldb/bindings/interface/SBEventExtensions.i

+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

 %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().''')
         frame = property(GetFrame, None, doc='''A read only property that returns the same result as GetFrame().''')
     %}
 #endif
 }

lldb/bindings/interface/SBExpressionOptionsExtensions.i

+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

 %extend lldb::SBFile {
     static lldb::SBFile MakeBorrowed(lldb::FileSP BORROWED) {
         return lldb::SBFile(BORROWED);
     }
     static lldb::SBFile MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS) {
         return lldb::SBFile(FORCE_IO_METHODS);
     }
     static lldb::SBFile MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS) {
         return lldb::SBFile(BORROWED_FORCE_IO_METHODS);
     }
 
 #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):
             """
             Create a SBFile from a python file object, with options.
 
             If borrow is set then the underlying file will
             not be closed when the SBFile is closed or destroyed.
 

lldb/bindings/interface/SBFileSpecExtensions.i

 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.''')
         exists = property(Exists, None, doc='''A read only property that returns a boolean value that indicates if the file exists.''')
     %}
 #endif
 }

lldb/bindings/interface/SBFileSpecListExtensions.i

+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

 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)
 
         def get_parent_frame(self):
             parent_idx = self.idx + 1
             if parent_idx >= 0 and parent_idx < len(self.thread.frame):
                 return self.thread.frame[parent_idx]
             else:

lldb/bindings/interface/SBFunctionExtensions.i

 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)
 
         addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this function.''')
         end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this function.''')
         block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the top level lexical block (lldb.SBBlock) for this function.''')
         instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this function.''')
         mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this function as a string.''')
         name = property(GetName, None, doc='''A read only property that returns the name for this function as a string.''')
         prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''')
         type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the return type (lldb.SBType) for this function.''')
     %}
 #endif
 }

lldb/bindings/interface/SBHostOSExtensions.i

+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

 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):
             return self.GetOperands (target)
         def __comment_property__ (self):
             return self.GetComment (target)
         def __file_addr_property__ (self):
             return self.GetAddress ().GetFileAddress()

lldb/bindings/interface/SBInstructionListExtensions.i

 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.'''
             return lldb_iter(self, 'GetSize', 'GetInstructionAtIndex')
 
         def __len__(self):
             '''Access len of the instruction list.'''
             return int(self.GetSize())

lldb/bindings/interface/SBLanguageRuntimeExtensions.i

+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

+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

 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.''')
         addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this line entry.''')
         end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this line entry.''')
     %}
 #endif
 }

lldb/bindings/interface/SBListenerExtensions.i

+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

 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

+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

 %}
 #endif
 
 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()
 
         def __iter__(self):
             '''Iterate over all symbols in a lldb.SBModule object.'''
             return lldb_iter(self, 'GetNumSymbols', 'GetSymbolAtIndex')
 

lldb/bindings/interface/SBModuleSpecExtensions.i

 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

+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

+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

+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

+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/SBProcessExtensions.i

%pythoncode %{
         def __iter__(self):
             '''Iterate over all threads in a lldb.SBProcess object.'''
             return lldb_iter(self, 'GetNumThreads', 'GetThreadAtIndex')
 
         def __len__(self):
             '''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]).''')
         is_alive = property(__get_is_alive__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently alive.''')
         is_running = property(__get_is_running__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently running.''')
         is_stopped = property(__get_is_stopped__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently stopped.''')
         id = property(GetProcessID, None, doc='''A read only property that returns the process ID as an integer.''')
         target = property(GetTarget, None, doc='''A read only property that an lldb object that represents the target (lldb.SBTarget) that owns this process.''')

lldb/bindings/interface/SBProcessInfoExtensions.i

+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

+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

+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

+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

+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.''')
     %}
 #endif
 }

lldb/bindings/interface/SBSectionExtensions.i

 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')
 
         def __len__(self):
             '''Return the number of subsections in a lldb.SBSection object.'''
             return self.GetNumSubSections()
 

lldb/bindings/interface/SBSourceManagerExtensions.i

+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

 %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) {
         self->RedirectToFile(file);
     }
 }

lldb/bindings/interface/SBStringListExtensions.i

 %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')
 
     def __len__(self):
         '''Return the number of strings in a lldb.SBStringList object.'''
         return self.GetSize()
     %}
 #endif
 }

lldb/bindings/interface/SBStructuredDataExtensions.i

+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

 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.''')
         block = property(GetBlock, SetBlock, doc='''A read/write property that allows the getting/setting of the block (lldb.SBBlock) in this symbol context.''')
         symbol = property(GetSymbol, SetSymbol, doc='''A read/write property that allows the getting/setting of the symbol (lldb.SBSymbol) in this symbol context.''')
         line_entry = property(GetLineEntry, SetLineEntry, doc='''A read/write property that allows the getting/setting of the line entry (lldb.SBLineEntry) in this symbol context.''')
     %}
 #endif
 }

lldb/bindings/interface/SBSymbolContextListExtensions.i

 STRING_EXTENSION_OUTSIDE(SBSymbolContextList)
 
 %extend lldb::SBSymbolContextList {
 #ifdef SWIGPYTHON
     %pythoncode %{
         def __iter__(self):
             '''Iterate over all symbol contexts in a lldb.SBSymbolContextList
             object.'''
             return lldb_iter(self, 'GetSize', 'GetContextAtIndex')
 
         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):
                 if -count <= key < count:
                     key %= count
                     return self.GetContextAtIndex(key)
                 else:
                     raise IndexError

lldb/bindings/interface/SBSymbolExtensions.i

 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)
 
         name = property(GetName, None, doc='''A read only property that returns the name for this symbol as a string.''')
         mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this symbol as a string.''')
         type = property(GetType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eSymbolType") that represents the type of this symbol.''')
         addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this symbol.''')
         end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this symbol.''')
         prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''')
         instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this symbol.''')
         external = property(IsExternal, None, doc='''A read only property that returns a boolean value that indicates if this symbol is externally visiable (exported) from the module that contains it.''')
         synthetic = property(IsSynthetic, None, doc='''A read only property that returns a boolean value that indicates if this symbol was synthetically created from information in module that contains it.''')
     %}
 #endif
 }

lldb/bindings/interface/SBTargetExtensions.i

 }
 #endif
 
 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):
                 self.sbtarget = sbtarget
 
             def __len__(self):
                 if self.sbtarget:
                     return int(self.sbtarget.GetNumModules())

lldb/bindings/interface/SBThreadCollectionExtensions.i

+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

 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')
 
         def __len__(self):
             '''Return the number of frames in a lldb.SBThread object.'''
             return self.GetNumFrames()
 

lldb/bindings/interface/SBThreadPlanExtensions.i

+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

+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

+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

 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.'''
                 def __init__(self, sbcategory, get_count_function, get_at_index_function, get_by_name_function):
                     self.sbcategory = sbcategory
                     self.get_count_function = get_count_function
                     self.get_at_index_function = get_at_index_function
                     self.get_by_name_function = get_by_name_function

lldb/bindings/interface/SBTypeEnumMemberExtensions.i

 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.''')
         unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this enum member as a unsigned integer.''')
     %}
 #endif
 }
 
 %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')
 
         def __len__(self):
             '''Return the number of members in a lldb.SBTypeEnumMemberList object.'''
             return self.GetSize()
 

lldb/bindings/interface/SBTypeExtensions.i

 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.''')
         bit_offset = property(GetOffsetInBits, None, doc='''A read only property that returns offset in bits for this member as an integer.''')
         is_bitfield = property(IsBitfield, None, doc='''A read only property that returns true if this member is a bitfield.''')
         bitfield_bit_size = property(GetBitfieldSizeInBits, None, doc='''A read only property that returns the bitfield size in bits for this member as an integer, or zero if this member is not a bitfield.''')
     %}
 #endif
 }
 
 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 {
 #ifdef SWIGPYTHON
     %pythoncode %{
         def template_arg_array(self):
             num_args = self.num_template_args
             if num_args:
                 template_args = []
                 for i in range(num_args):
                     template_args.append(self.GetTemplateArgumentType(i))
                 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.''')
         is_pointer = property(IsPointerType, None, doc='''A read only property that returns a boolean value that indicates if this type is a pointer type.''')
         is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a reference type.''')
         is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a function type.''')
         num_fields = property(GetNumberOfFields, None, doc='''A read only property that returns number of fields in this type as an integer.''')
         num_bases = property(GetNumberOfDirectBaseClasses, None, doc='''A read only property that returns number of direct base classes in this type as an integer.''')
%pythoncode %{
         enum_members = property(get_enum_members_array, None, doc='''A read only property that returns a list() of all lldb.SBTypeEnumMember objects that represent the enum members for this type.''')
         %}
 #endif
 }
 
 %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')
 
     def __len__(self):
         '''Return the number of types in a lldb.SBTypeList object.'''
         return self.GetSize()
     %}
 #endif
 }

lldb/bindings/interface/SBTypeFilterExtensions.i

 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)
         %}
 #endif
 }

lldb/bindings/interface/SBTypeFormatExtensions.i

 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)
         %}
 #endif
 }

lldb/bindings/interface/SBTypeNameSpecifierExtensions.i

 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)
         %}
 #endif
 }

lldb/bindings/interface/SBTypeSummaryExtensions.i

 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)
             is_function_name = property(IsFunctionCode)
             summary_data = property(GetData)
         %}
 #endif
 }

lldb/bindings/interface/SBTypeSummaryOptionsExtensions.i

+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

 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)
         %}
 #endif
 }

lldb/bindings/interface/SBUnixSignalsExtensions.i

 %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()):
                 signals.append(self.GetSignalAtIndex(sig))
             return signals
 
         threads = property(get_unix_signals_list, None, doc='''A read only property that returns a list() of valid signal numbers for this platform.''')
     %}
 #endif
 }

lldb/bindings/interface/SBValueExtensions.i

%pythoncode %{
         def get_value_child_list(self):
             '''An accessor function that returns a list() that contains all children in a lldb.SBValue object.'''
             children = []
             accessor = self.get_child_access_object()
             for idx in range(len(accessor)):
                 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')
 
         def __len__(self):
             '''Return the number of child values of a lldb.SBValue object.'''
             return self.GetNumChildren()
 

lldb/bindings/interface/SBValueListExtensions.i

#ifdef SWIGPYTHON
     %pythoncode %{
         def __iter__(self):
             '''Iterate over all values in a lldb.SBValueList object.'''
             return lldb_iter(self, 'GetSize', 'GetValueAtIndex')
 
         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)
             #------------------------------------------------------------
             # Access with "int" to get Nth item in the list
             #------------------------------------------------------------
             if type(key) is int:
                 if -count <= key < count:
                     key %= count

lldb/bindings/interface/SBVariablesOptionsExtensions.i

+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

 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

 %include "lldb/API/SBUnixSignals.h"
 %include "lldb/API/SBValue.h"
 %include "lldb/API/SBValueList.h"
 %include "lldb/API/SBVariablesOptions.h"
 %include "lldb/API/SBWatchpoint.h"
 
 /* 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

 
 class declaration(object):
     '''A class that represents a source declaration location with file, line and column.'''
     def __init__(self, file, line, col):
         self.file = file
         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):
         return self
 
     def __next__(self):
         if self.index >= self.length:
             raise StopIteration()
         child_sbvalue = self.sbvalue.GetChildAtIndex(self.index)
         self.index += 1
         return value(child_sbvalue)
 
     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
         self.length = self.sbvalue.GetNumChildren()
 
 class value(object):
     '''Wraps :py:class:`SBValue` objects so the resulting object can be used as a variable would be in code.
 
def get_child_at_index(self,idx):
         return None
 
     def update(self):
         pass
 
     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')
 
 %}
 
 %pythoncode %{
 
 # given an lldb.SBBasicType it returns a tuple
 # (is_numeric, is_signed)
 # the value of is_signed is undefined if is_numeric == false

lldb/bindings/python/python.swig

 # Iterator for lldb container objects
 # ===================================
 def lldb_iter(obj, getsize, getelem):
     """A generator adaptor to support iteration for lldb container objects."""
     size = getattr(obj, getsize)
     elem = getattr(obj, getelem)
     for i in range(size()):
         yield elem(i)
+
+def __int__(self):
+  pass
+
+def __hex__(self):
+  pass
+
+def __oct__(self):
+  pass
+
+def __len__(self):
+  pass
+
+def __iter__(self):
+  pass
 %}
 
 %include <std_string.i>
 %include "python-typemaps.swig"
 %include "macros.swig"
 %include "headers.swig"
 
 %{

lldb/docs/conf.py

 # If your documentation needs a minimal Sphinx version, state it here.
 # needs_sphinx = '1.0'
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = ["sphinx.ext.todo", "sphinx.ext.mathjax", "sphinx.ext.intersphinx"]
 
 autodoc_default_options = {
     "special-members": "__int__, __len__, __hex__, __oct__, __iter__",
 }
 
 # Unless we only generate the basic manpage we need the plugin for generating
 # the Python API documentation.
 if not building_man_page:
     try:
         import sphinx_automodapi.automodapi
     except ModuleNotFoundError:

 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
 # html_favicon = None
 
 # 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"]
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
 html_last_updated_fmt = "%b %d, %Y"
 
 # If true, SmartyPants will be used to convert quotes and dashes to

lldb/docs/python_api.rst

 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: in_range
-  :skip: is_numeric_type
-  :skip: lldb_iter