source/osxcpp.py

import re

# C++ STL formatters for LLDB
# These formatters are based upon the version of the STL that ships
# with Mac OS X Snow Leopard 10.6.8 and OS X Lion 10.7.0
# The STL implementation *might* change on other releases of Apple's
# operating system and library infrastructure, and might be different on
# other operating systems

class StdListSynthProvider:

	def __init__(self, valobj, dict):
		self.valobj = valobj
		self.update()

	def num_children(self):
		next_val = self.next.GetValueAsUnsigned(0)
		prev_val = self.prev.GetValueAsUnsigned(0)
		# After a std::list has been initialized, both next and prev will be non-NULL
		if next_val == 0 or prev_val == 0:
			return 0
		if next_val == self.node_address:
			return 0
		if next_val == prev_val:
			return 1
		size = 2
		current = self.next
		while current.GetChildMemberWithName('_M_next').GetValueAsUnsigned(0) != self.node_address:
			size = size + 1
			current = current.GetChildMemberWithName('_M_next')
		return (size - 1)

	def get_child_index(self,name):
		return int(name.lstrip('[').rstrip(']'))

	def get_child_at_index(self,index):
		if index >= self.num_children():
			return None;
		offset = index
		current = self.next
		while offset > 0:
			current = current.GetChildMemberWithName('_M_next')
			offset = offset - 1
		return current.CreateChildAtOffset('['+str(index)+']',2*current.GetType().GetByteSize(),self.data_type)

	def extract_type_name(self,name):
		self.type_name = name[16:]
		index = 2
		count_of_template = 1
		while index < len(self.type_name):
			if self.type_name[index] == '<':
				count_of_template = count_of_template + 1
			elif self.type_name[index] == '>':
				count_of_template = count_of_template - 1
			elif self.type_name[index] == ',' and count_of_template == 1:
				self.type_name = self.type_name[:index]
				break
			index = index + 1
		self.type_name_nospaces = self.type_name.replace(", ", ",")

	def update(self):
		impl = self.valobj.GetChildMemberWithName('_M_impl')
		node = impl.GetChildMemberWithName('_M_node')
		self.extract_type_name(impl.GetType().GetName())
		self.node_address = self.valobj.AddressOf().GetValueAsUnsigned(0)
		self.next = node.GetChildMemberWithName('_M_next')
		self.prev = node.GetChildMemberWithName('_M_prev')
		self.data_type = node.GetTarget().FindFirstType(self.type_name)
		# tries to fight against a difference in formatting type names between gcc and clang
		if self.data_type.IsValid() == False:
			self.data_type = node.GetTarget().FindFirstType(self.type_name_nospaces)
		self.data_size = self.data_type.GetByteSize()

class StdVectorSynthProvider:

	def __init__(self, valobj, dict):
		self.valobj = valobj;
		self.update()

	def num_children(self):
		start_val = self.start.GetValueAsUnsigned(0)
		finish_val = self.finish.GetValueAsUnsigned(0)
		end_val  = self.end.GetValueAsUnsigned(0)
		# 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

		num_children = (finish_val-start_val)/self.data_size
		return num_children

	def get_child_index(self,name):
		return int(name.lstrip('[').rstrip(']'))

	def get_child_at_index(self,index):
		if index >= self.num_children():
			return None;
		offset = index * self.data_size
		return self.start.CreateChildAtOffset('['+str(index)+']',offset,self.data_type)

	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()
		self.data_size = self.data_type.GetByteSize()


class StdMapSynthProvider:

	def __init__(self, valobj, dict):
		self.valobj = valobj;
		self.update()

	def update(self):
		self.Mt = self.valobj.GetChildMemberWithName('_M_t')
		self.Mimpl = self.Mt.GetChildMemberWithName('_M_impl')
		self.Mheader = self.Mimpl.GetChildMemberWithName('_M_header')
		# from libstdc++ implementation of _M_root for rbtree
		self.Mroot = self.Mheader.GetChildMemberWithName('_M_parent')
		# the stuff into the tree is actually a std::pair<const key, value>
		# life would be much easier if gcc had a coherent way to print out
		# template names in debug info
		self.expand_clang_type_name()
		self.expand_gcc_type_name()
		self.data_type = self.Mt.GetTarget().FindFirstType(self.clang_type_name)
		if self.data_type.IsValid() == False:
			self.data_type = self.Mt.GetTarget().FindFirstType(self.gcc_type_name)
		self.data_size = self.data_type.GetByteSize()
		self.skip_size = self.Mheader.GetType().GetByteSize()

	def expand_clang_type_name(self):
		type_name = self.Mimpl.GetType().GetName()
		index = type_name.find("std::pair<")
		type_name = type_name[index+5:]
		index = 6
		template_count = 1
		while index < len(type_name):
			if type_name[index] == '<':
				template_count = template_count + 1
			elif type_name[index] == '>' and template_count == 1:
				type_name = type_name[:index+1]
				break
			elif type_name[index] == '>':
				template_count = template_count - 1
			index = index + 1;
		self.clang_type_name = type_name

	def expand_gcc_type_name(self):
		type_name = self.Mt.GetType().GetName()
		index = type_name.find("std::pair<")
		type_name = type_name[index+5:]
		index = 6
		template_count = 1
		while index < len(type_name):
			if type_name[index] == '<':
				template_count = template_count + 1
			elif type_name[index] == '>' and template_count == 1:
				type_name = type_name[:index+1]
				break
			elif type_name[index] == '>':
				template_count = template_count - 1
			elif type_name[index] == ' ' and template_count == 1 and type_name[index-1] == ',':
			    type_name = type_name[0:index] + type_name[index+1:]
			    index = index - 1
			index = index + 1;
		self.gcc_type_name = type_name

	def num_children(self):
		root_ptr_val = self.node_ptr_value(self.Mroot)
		if root_ptr_val == 0:
			return 0;
		return self.Mimpl.GetChildMemberWithName('_M_node_count').GetValueAsUnsigned(0)

	def get_child_index(self,name):
		return int(name.lstrip('[').rstrip(']'))

	def get_child_at_index(self,index):
		if index >= self.num_children():
			return None;
		offset = index
		current = self.left(self.Mheader);
		while offset > 0:
			current = self.increment_node(current)
			offset = offset - 1;
		# skip all the base stuff and get at the data
		return current.CreateChildAtOffset('['+str(index)+']',self.skip_size,self.data_type)

	# utility functions
	def node_ptr_value(self,node):
		return node.GetValueAsUnsigned(0)

	def right(self,node):
		return node.GetChildMemberWithName("_M_right");

	def left(self,node):
		return node.GetChildMemberWithName("_M_left");

	def parent(self,node):
		return node.GetChildMemberWithName("_M_parent");

	# from libstdc++ implementation of iterator for rbtree
	def increment_node(self,node):
		if self.node_ptr_value(self.right(node)) != 0:
			x = self.right(node);
			while self.node_ptr_value(self.left(x)) != 0:
				x = self.left(x);
			return x;
		else:
			x = node;
			y = self.parent(x)
			while(self.node_ptr_value(x) == self.node_ptr_value(self.right(y))):
				x = y;
				y = self.parent(y);
			if self.node_ptr_value(self.right(x)) != self.node_ptr_value(y):
				x = y;
			return x;