To the Python bindings, add support for Python-like negative indexes.
While was using `script`, I tried to access a thread's bottom frame with
`thread.frame[-1]`, but that failed. This change updates the `__getitem__`
implementations to support negative indexes as one would expect in Python.
Differential Revision: https://reviews.llvm.org/D143282
return 0
def __getitem__(self, key):
- if type(key) is int and key < len(self):
- return self.sbbreakpoint.GetLocationAtIndex(key)
+ if isinstance(key, int):
+ count = len(self)
+ if -count <= key < count:
+ key %= count
+ return self.sbbreakpoint.GetLocationAtIndex(key)
return None
def get_locations_access_object(self):
'''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
- if key < len(self):
+ count = len(self)
+ if -count <= key < count:
+ key %= count
return self.GetInstructionAtIndex(key)
elif type(key) is SBAddress:
# Find an instruction using a lldb.SBAddress object
def __getitem__(self, key):
count = len(self)
if type(key) is int:
- if key < count:
+ if -count <= key < count:
+ key %= count
return self.sbmodule.GetSymbolAtIndex(key)
elif type(key) is str:
matches = []
def __getitem__(self, key):
count = len(self)
if type(key) is int:
- if key < count:
+ if -count <= key < count:
+ key %= count
return self.sbmodule.GetSectionAtIndex(key)
elif type(key) is str:
for idx in range(count):
def __getitem__(self, key):
count = len(self)
if type(key) is int:
- if key < count:
+ if -count <= key < count:
+ key %= count
return self.sbmodule.GetCompileUnitAtIndex(key)
elif type(key) is str:
is_full_path = key[0] == '/'
return 0
def __getitem__(self, key):
- if type(key) is int and key < len(self):
- return self.sbprocess.GetThreadAtIndex(key)
+ if isinstance(key, int):
+ count = len(self)
+ if -count <= key < count:
+ key %= count
+ return self.sbprocess.GetThreadAtIndex(key)
return None
def get_threads_access_object(self):
def __getitem__(self, key):
count = len(self)
- if type(key) is int:
- if key < count:
+ if isinstance(key, int):
+ if -count <= key < count:
+ key %= count
return self.GetContextAtIndex(key)
else:
raise IndexError
def __getitem__(self, key):
num_modules = self.sbtarget.GetNumModules()
if type(key) is int:
- if key < num_modules:
+ if -num_modules <= key < num_modules:
+ key %= num_modules
return self.sbtarget.GetModuleAtIndex(key)
elif type(key) is str:
if key.find('/') == -1:
return 0
def __getitem__(self, key):
- if type(key) is int and key < self.sbthread.GetNumFrames():
- return self.sbthread.GetFrameAtIndex(key)
+ if isinstance(key, int):
+ count = len(self)
+ if -count <= key < count:
+ key %= count
+ return self.sbthread.GetFrameAtIndex(key)
return None
def get_frames_access_object(self):
def __getitem__(self, key):
num_items = len(self)
if type(key) is int:
- if key < num_items:
+ if -num_items <= key < num_items:
+ key %= num_items
return self.get_at_index_function(self.sbcategory,key)
elif type(key) is str:
return self.get_by_name_function(self.sbcategory,SBTypeNameSpecifier(key))
def __getitem__(self, key):
num_elements = self.GetSize()
if type(key) is int:
- if key < num_elements:
+ if -num_elements <= key < num_elements:
+ key %= num_elements
return self.GetTypeEnumMemberAtIndex(key)
elif type(key) is str:
for idx in range(num_elements):
return 0
def __getitem__(self, key):
- if type(key) is int and key < len(self):
- return self.sbvalue.GetChildAtIndex(key)
+ if isinstance(key, int):
+ count = len(self)
+ if -count <= key < count:
+ key %= count
+ return self.sbvalue.GetChildAtIndex(key)
return None
def get_child_access_object(self):
# Access with "int" to get Nth item in the list
#------------------------------------------------------------
if type(key) is int:
- if key < count:
+ if -count <= key < count:
+ key %= count
return self.GetValueAtIndex(key)
#------------------------------------------------------------
# Access with "str" to get values by name
location = breakpoint.GetLocationAtIndex(0)
self.assertTrue(location.IsValid())
+ # Test negative index access.
+ self.assertTrue(breakpoint.location[-1].IsValid())
+
# Make sure the breakpoint's target is right:
self.assertEqual(target, breakpoint.GetTarget(), "Breakpoint reports its target correctly")
self.setTearDownCleanup(dictionary=d)
self.step_over_3_times(self.exe_name)
+ def test_negative_indexing(self):
+ """Test SBThread.frame with negative indexes."""
+ self.build()
+ self.validate_negative_indexing()
+
def setUp(self):
# Call super's setUp().
TestBase.setUp(self)
thread.RunToAddress(start_addr)
self.runCmd("process status")
#self.runCmd("thread backtrace")
+
+ def validate_negative_indexing(self):
+ exe = self.getBuildArtifact("a.out")
+
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target, VALID_TARGET)
+
+ breakpoint = target.BreakpointCreateByLocation(
+ "main.cpp", self.break_line)
+ self.assertTrue(breakpoint, VALID_BREAKPOINT)
+ self.runCmd("breakpoint list")
+
+ # Launch the process, and do not stop at the entry point.
+ process = target.LaunchSimple(
+ None, None, self.get_process_working_directory())
+
+ thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+ self.assertTrue(
+ thread.IsValid(),
+ "There should be a thread stopped due to breakpoint")
+ self.runCmd("process status")
+
+ pos_range = range(thread.num_frames)
+ neg_range = range(thread.num_frames, 0, -1)
+ for pos, neg in zip(pos_range, neg_range):
+ self.assertEqual(thread.frame[pos].idx, thread.frame[-neg].idx)