modify-python-lldb.py: clean up __iter__ and __len__ support

[labath]

Summary

Instead of modifying the swig-generated code, just add the appropriate
methods to the interface files in order to get the swig to do the
generation for us.

This is a straight-forward move from the python script to the interface
files. The single class which has nontrivial handling in the script
(SBModule) has been left for a separate patch.

For the cases where I did not find any tests exercising the
iteration/length methods (i.e., no tests failed after I stopped emitting
them), I tried to add basic tests for that functionality.

packages/Python/lldbsuite/test/python_api/debugger/TestDebuggerAPI.py

def test_debugger_api_boundary_condition(self):
         self.dbg.SetInternalVariable(None, None, None)
         self.dbg.GetInternalVariableValue(None, None)
         # FIXME (filcab): We must first allow for the swig bindings to know if
         # a Python callback is set. (Check python-typemaps.swig)
         # self.dbg.SetLoggingCallback(None)
         self.dbg.SetPrompt(None)
         self.dbg.SetCurrentPlatform(None)
         self.dbg.SetCurrentPlatformSDKRoot(None)
         
+        fresh_dbg = lldb.SBDebugger()
+        self.assertEquals(len(fresh_dbg), 0)
+
     @add_test_categories(['pyapi'])
     def test_debugger_delete_invalid_target(self):
         """SBDebugger.DeleteTarget() should not crash LLDB given and invalid target."""
         target = lldb.SBTarget()
         self.assertFalse(target.IsValid())
         self.dbg.DeleteTarget(target)

packages/Python/lldbsuite/test/python_api/default-constructor/sb_compileunit.py

 """
 Fuzz tests an object after the default construction to make sure it does not crash lldb.
 """
 
 import sys
 import lldb
 
 
 def fuzz_obj(obj):
     obj.GetFileSpec()
     obj.GetNumLineEntries()
     obj.GetLineEntryAtIndex(0xffffffff)
     obj.FindLineEntryIndex(0, 0xffffffff, None)
     obj.GetDescription(lldb.SBStream())
+    len(obj)
     for line_entry in obj:
         s = str(line_entry)

packages/Python/lldbsuite/test/python_api/default-constructor/sb_process.py

def fuzz_obj(obj):
     obj.GetBroadcaster()
     obj.GetDescription(lldb.SBStream())
     obj.LoadImage(lldb.SBFileSpec(), error)
     obj.UnloadImage(0)
     obj.Clear()
     obj.GetNumSupportedHardwareWatchpoints(error)
     for thread in obj:
         s = str(thread)
+    len(obj)

packages/Python/lldbsuite/test/python_api/default-constructor/sb_section.py

def fuzz_obj(obj):
     obj.GetByteSize()
     obj.GetFileOffset()
     obj.GetFileByteSize()
     obj.GetSectionData(1000, 100)
     obj.GetSectionType()
     obj.GetDescription(lldb.SBStream())
     for subsec in obj:
         s = str(subsec)
+    len(obj)

packages/Python/lldbsuite/test/python_api/default-constructor/sb_thread.py

def fuzz_obj(obj):
     obj.GetFrameAtIndex(200)
     obj.GetSelectedFrame()
     obj.SetSelectedFrame(999)
     obj.GetProcess()
     obj.GetDescription(lldb.SBStream())
     obj.Clear()
     for frame in obj:
         s = str(frame)
+    len(obj)

packages/Python/lldbsuite/test/python_api/symbol-context/TestSymbolContext.py

def test(self):
             substrs=['main.c'])
         self.assertTrue(lineEntry.GetLine() == self.line,
                         "The line entry's line number should match ")
 
         symbol = context.GetSymbol()
         self.assertTrue(
             function.GetName() == symbol.GetName() and symbol.GetName() == 'c',
             "The symbol name should be 'c'")
+
+        sc_list = lldb.SBSymbolContextList()
+        sc_list.Append(context)
+        self.assertEqual(len(sc_list), 1)
+        for sc in sc_list:
+            self.assertEqual(lineEntry, sc.GetLineEntry())

scripts/Python/modify-python-lldb.py

 TWO_SPACES = ' ' * 2
 EIGHT_SPACES = ' ' * 8
 one_liner_docstring_pattern = re.compile(
     '^(%s|%s)""".*"""$' %
     (TWO_SPACES, EIGHT_SPACES))
 
 # This supports the iteration protocol.
 iter_def = "    def __iter__(self): return lldb_iter(self, '%s', '%s')"
-module_iter = "    def module_iter(self): return lldb_iter(self, '%s', '%s')"
-breakpoint_iter = "    def breakpoint_iter(self): return lldb_iter(self, '%s', '%s')"
-watchpoint_iter = "    def watchpoint_iter(self): return lldb_iter(self, '%s', '%s')"
 section_iter = "    def section_iter(self): return lldb_iter(self, '%s', '%s')"
 compile_unit_iter = "    def compile_unit_iter(self): return lldb_iter(self, '%s', '%s')"
 
 # Called to implement the built-in function len().
 # Eligible objects are those containers with unambiguous iteration support.
 len_def = "    def __len__(self): return self.%s()"
 
 # A convenience iterator for SBSymbol!
 symbol_in_section_iter_def = '''
     def symbol_in_section_iter(self, section):
         """Given a module and its contained section, returns an iterator on the
         symbols within the section."""
         for sym in self:
             if in_range(sym, section):
                 yield sym
 '''
 
 #
 # This dictionary defines a mapping from classname to (getsize, getelem) tuple.
 #
-d = {'SBBreakpoint': ('GetNumLocations', 'GetLocationAtIndex'),
-     'SBCompileUnit': ('GetNumLineEntries', 'GetLineEntryAtIndex'),
-     'SBDebugger': ('GetNumTargets', 'GetTargetAtIndex'),
-     'SBModule': ('GetNumSymbols', 'GetSymbolAtIndex'),
-     'SBProcess': ('GetNumThreads', 'GetThreadAtIndex'),
-     'SBSection': ('GetNumSubSections', 'GetSubSectionAtIndex'),
-     'SBThread': ('GetNumFrames', 'GetFrameAtIndex'),
-
-     'SBInstructionList': ('GetSize', 'GetInstructionAtIndex'),
-     'SBStringList': ('GetSize', 'GetStringAtIndex',),
-     'SBSymbolContextList': ('GetSize', 'GetContextAtIndex'),
-     'SBTypeList': ('GetSize', 'GetTypeAtIndex'),
-     'SBValueList': ('GetSize', 'GetValueAtIndex'),
-
-     'SBType': ('GetNumberChildren', 'GetChildAtIndex'),
-     'SBValue': ('GetNumChildren', 'GetChildAtIndex'),
-
-     # SBTarget needs special processing, see below.
-     'SBTarget': {'module': ('GetNumModules', 'GetModuleAtIndex'),
-                  'breakpoint': ('GetNumBreakpoints', 'GetBreakpointAtIndex'),
-                  'watchpoint': ('GetNumWatchpoints', 'GetWatchpointAtIndex')
-                  },
+d = {'SBModule': ('GetNumSymbols', 'GetSymbolAtIndex'),
 
      # SBModule has an additional section_iter(), see below.
      'SBModule-section': ('GetNumSections', 'GetSectionAtIndex'),
      # And compile_unit_iter().
      'SBModule-compile-unit': ('GetNumCompileUnits', 'GetCompileUnitAtIndex'),
      # As well as symbol_in_section_iter().
      'SBModule-symbol-in-section': symbol_in_section_iter_def
      }
if state == NORMAL:
                 # Adding support for iteration for the matched SB class.
                 state |= DEFINING_ITERATOR
 
     if state & DEFINING_ITERATOR:
         match = init_pattern.search(line)
         if match:
             # We found the beginning of the __init__ method definition.
             # This is a good spot to insert the iter support.
-            #
-            # But note that SBTarget has three types of iterations.
-            if cls == "SBTarget":
-                new_content.add_line(module_iter % (d[cls]['module']))
-                new_content.add_line(breakpoint_iter % (d[cls]['breakpoint']))
-                new_content.add_line(watchpoint_iter % (d[cls]['watchpoint']))
-            else:
-                if (state & DEFINING_ITERATOR):
-                    new_content.add_line(iter_def % d[cls])
-                    new_content.add_line(len_def % d[cls][0])
+
 
             # SBModule has extra SBSection, SBCompileUnit iterators and
             # symbol_in_section_iter()!
             if cls == "SBModule":
                 new_content.add_line(section_iter % d[cls + '-section'])
                 new_content.add_line(compile_unit_iter %
                                      d[cls + '-compile-unit'])
                 new_content.add_line(d[cls + '-symbol-in-section'])

scripts/interface/SBBreakpoint.i

%pythoncode %{
         
         def get_breakpoint_location_list(self):
             '''An accessor function that returns a list() that contains all locations in a lldb.SBBreakpoint object.'''
             locations = []
             accessor = self.get_locations_access_object()
             for idx in range(len(accessor)):
                 locations.append(accessor[idx])
             return locations
-        
+        def __iter__(self):
+            '''Iterate over all breakpoint locations in a lldb.SBBreakpoint
+            object.'''
+            return lldb_iter(self, 'GetNumLocations', 'GetLocationAtIndex')
+
+        def __len__(self):
+            '''Return the number of breakpoint locations in a lldb.SBBreakpoint
+            object.'''
+            return self.GetNumLocations()
+
         __swig_getmethods__["locations"] = get_breakpoint_location_list
         if _newclass: locations = property(get_breakpoint_location_list, None, doc='''A read only property that returns a list() of lldb.SBBreakpointLocation objects for this breakpoint.''')
         
         __swig_getmethods__["location"] = get_locations_access_object
         if _newclass: 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]).''')
 
         __swig_getmethods__["id"] = GetID
         if _newclass: id = property(GetID, None, doc='''A read only property that returns the ID of this breakpoint.''')

scripts/interface/SBCompileUnit.i

public:
     
     bool
     operator == (const lldb::SBCompileUnit &rhs) const;
     
     bool
     operator != (const lldb::SBCompileUnit &rhs) const;
     
     %pythoncode %{
+        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()
+
         __swig_getmethods__["file"] = GetFileSpec
         if _newclass: 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.''')
         
         __swig_getmethods__["num_line_entries"] = GetNumLineEntries
         if _newclass: 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.''')
     %}
 };
 
 } // namespace lldb

scripts/interface/SBDebugger.i

RunCommandInterpreter (bool auto_handle_events,
                            bool spawn_thread,
                            SBCommandInterpreterRunOptions &options,
                            int  &num_errors,
                            bool &quit_requested,
                            bool &stopped_for_crash);
 
     lldb::SBError
     RunREPL (lldb::LanguageType language, const char *repl_options);
+
+    %pythoncode%{
+    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()
+    %}
+
 }; // class SBDebugger
 
 } // namespace lldb

scripts/interface/SBInstructionList.i

public:
 
     bool
     GetDescription (lldb::SBStream &description);
     
     bool
     DumpEmulationForAllInstructions (const char *triple);
 
     %pythoncode %{
+        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())
 
         def __getitem__(self, key):
             '''Access instructions by integer index for array access or by lldb.SBAddress to find an instruction that matches a section offset address object.'''
             if type(key) is int:
                 # Find an instruction by index

scripts/interface/SBProcess.i

%pythoncode %{
         
         def get_process_thread_list(self):
             '''An accessor function that returns a list() that contains all threads in a lldb.SBProcess object.'''
             threads = []
             accessor = self.get_threads_access_object()
             for idx in range(len(accessor)):
                 threads.append(accessor[idx])
             return threads
-        
+        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()
+
+        
         __swig_getmethods__["threads"] = get_process_thread_list
         if _newclass: threads = property(get_process_thread_list, None, doc='''A read only property that returns a list() of lldb.SBThread objects for this process.''')
         
         __swig_getmethods__["thread"] = get_threads_access_object
         if _newclass: 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]).''')
 
         __swig_getmethods__["is_alive"] = __get_is_alive__
         if _newclass: 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.''')

scripts/interface/SBSection.i

public:
     
     bool
     operator == (const lldb::SBSection &rhs);
 
     bool
     operator != (const lldb::SBSection &rhs);
      
     %pythoncode %{
+        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()
+
         def get_addr(self):
             return SBAddress(self, 0)
 
         __swig_getmethods__["name"] = GetName
         if _newclass: name = property(GetName, None, doc='''A read only property that returns the name of this section as a string.''')
 
         __swig_getmethods__["addr"] = get_addr
         if _newclass: addr = property(get_addr, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this section.''')

scripts/interface/SBStringList.i

public:
     uint32_t
     GetSize () const;
 
     const char *
     GetStringAtIndex (size_t idx);
 
     void
     Clear ();
+
+    %pythoncode%{
+    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()
+    %}
 };
 
 } // namespace lldb

scripts/interface/SBSymbolContextList.i

public:
 
     bool
     GetDescription (lldb::SBStream &description);
 
     void
     Clear();
     
     %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 __getitem__(self, key):
             count = len(self)
             if type(key) is int:
                 if key < count:
                     return self.GetContextAtIndex(key)

scripts/interface/SBTarget.i

%pythoncode %{
 
         def get_modules_array(self):
             '''An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.'''
             modules = []
             for idx in range(self.GetNumModules()):
                 modules.append(self.GetModuleAtIndex(idx))
             return modules
 
+        def module_iter(self):
+            '''Returns an iterator over all modules in a lldb.SBTarget
+            object.'''
+            return lldb_iter(self, 'GetNumModules', 'GetModuleAtIndex')
+
+        def breakpoint_iter(self):
+            '''Returns an iterator over all breakpoints in a lldb.SBTarget
+            object.'''
+            return lldb_iter(self, 'GetNumBreakpoints', 'GetBreakpointAtIndex')
+
+        def watchpoint_iter(self):
+            '''Returns an iterator over all watchpoints in a lldb.SBTarget
+            object.'''
+            return lldb_iter(self, 'GetNumWatchpoints', 'GetWatchpointAtIndex')
+
         __swig_getmethods__["modules"] = get_modules_array
         if _newclass: modules = property(get_modules_array, None, doc='''A read only property that returns a list() of lldb.SBModule objects contained in this target. This list is a list all modules that the target currently is tracking (the main executable and all dependent shared libraries).''')
 
         __swig_getmethods__["module"] = get_modules_access_object
         if _newclass: module = property(get_modules_access_object, None, doc=r'''A read only property that returns an object that implements python operator overloading with the square brackets().\n    target.module[<int>] allows array access to any modules.\n    target.module[<str>] allows access to modules by basename, full path, or uuid string value.\n    target.module[uuid.UUID()] allows module access by UUID.\n    target.module[re] allows module access using a regular expression that matches the module full path.''')
 
         __swig_getmethods__["process"] = GetProcess
         if _newclass: process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns.''')

scripts/interface/SBThread.i

~SBThread();
     on a given thread at a particular point in time.  It is recommended that
     this is checked before performing an inferior function call on a given
     thread.
     ") SafeToCallFunctions;
     bool
     SafeToCallFunctions ();
 
     %pythoncode %{
+        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()
+
         class frames_access(object):
             '''A helper object that will lazily hand out frames for a thread when supplied an index.'''
             def __init__(self, sbthread):
                 self.sbthread = sbthread
 
             def __len__(self):
                 if self.sbthread:
                     return int(self.sbthread.GetNumFrames())

scripts/interface/SBType.i

public:
 
     lldb::SBType
     GetTypeAtIndex (uint32_t index);
 
     uint32_t
     GetSize();
 
     ~SBTypeList();
+
+    %pythoncode%{
+    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()
+    %}
 };
 
 } // namespace lldb

scripts/interface/SBValue.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 __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()
+        
         __swig_getmethods__["children"] = get_value_child_list
         if _newclass: children = property(get_value_child_list, None, doc='''A read only property that returns a list() of lldb.SBValue objects for the children of the value.''')
         
         __swig_getmethods__["child"] = get_child_access_object
         if _newclass: child = property(get_child_access_object, None, doc='''A read only property that returns an object that can access children of a variable by index (child_value = value.children[12]).''')
 
         __swig_getmethods__["name"] = GetName
         if _newclass: name = property(GetName, None, doc='''A read only property that returns the name of this value as a string.''')

scripts/interface/SBValueList.i

public:
 
     lldb::SBValue
     FindValueObjectByUID (lldb::user_id_t uid);
     
     lldb::SBValue
     GetFirstValueByName (const char* name) const;
     
     %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 __getitem__(self, key):
             count = len(self)
             #------------------------------------------------------------
             # Access with "int" to get Nth item in the list
             #------------------------------------------------------------