StdVectorSynthProvider.py   [plain text]

class StdVectorSynthProvider:

	def __init__(self, valobj, dict):
		self.valobj = valobj;
		self.update() # initialize this provider

	def num_children(self):
		start_val = self.start.GetValueAsUnsigned(0) # read _M_start
		finish_val = self.finish.GetValueAsUnsigned(0) # read _M_finish
		end_val  = self.end.GetValueAsUnsigned(0) # read _M_end_of_storage
		
		# Before a vector has been constructed, it will contain bad values
		# so we really need to be careful about the length we return since
		# unitialized data can cause us to return a huge number. We need
		# to also check for any of the start, finish or end of storage values
		# being zero (NULL). If any are, then this vector has not been 
		# initialized yet and we should return zero

		# Make sure nothing is NULL
		if start_val == 0 or finish_val == 0 or end_val == 0:
			return 0
		# Make sure start is less than finish
		if start_val >= finish_val:
			return 0
		# Make sure finish is less than or equal to end of storage
		if finish_val > end_val:
			return 0

		# pointer arithmetic: (_M_finish - _M_start) would return the number of
		# items of type T contained in the vector. because Python has no way to know
		# that we want to subtract two pointers instead of two integers, we have to divide
		# by sizeof(T) to be equivalent to the C++ pointer expression
		num_children = (finish_val-start_val)/self.data_size
		return num_children

	# we assume we are getting children named [0] thru [N-1]
	# if for some reason our child name is not in this format,
	# do not bother to show it, and return an invalid value
	def get_child_index(self,name):
		try:
			return int(name.lstrip('[').rstrip(']'))
		except:
			return -1;

	def get_child_at_index(self,index):
		# LLDB itself should never query for children < 0, but this might come
		# from someone asking for a nonexisting child and getting -1 as index
		if index < 0:
			return None
		if index >= self.num_children():
			return None;
		# *(_M_start + index), or equivalently _M_start[index] is C++ code to
		# read the index-th item of the vector. in Python we must make an offset
		# that is index * sizeof(T), and then grab the value at that offset from
		# _M_start
		offset = index * self.data_size # index * sizeof(T)
		return self.start.CreateChildAtOffset('['+str(index)+']',offset,self.data_type) # *(_M_start + index)

	# an std::vector contains an object named _M_impl, which in turn contains
	# three pointers, _M_start, _M_end and _M_end_of_storage. _M_start points to the
	# beginning of the data area, _M_finish points to where the current vector elements
	# finish, and _M_end_of_storage is the end of the currently alloc'ed memory portion
	# (to allow resizing, a vector may allocate more memory than required)
	def update(self):
		impl = self.valobj.GetChildMemberWithName('_M_impl')
		self.start = impl.GetChildMemberWithName('_M_start')
		self.finish = impl.GetChildMemberWithName('_M_finish')
		self.end = impl.GetChildMemberWithName('_M_end_of_storage')
		self.data_type = self.start.GetType().GetPointeeType() # _M_start is defined as a T*
		self.data_size = self.data_type.GetByteSize() # sizeof(T)