import lldb
def CFString_SummaryProvider (valobj,dict):
provider = CFStringSynthProvider(valobj,dict);
if provider.invalid == False:
return '@'+provider.get_child_at_index(provider.get_child_index("content")).GetSummary();
return ''
class CFStringSynthProvider:
def __init__(self,valobj,dict):
self.valobj = valobj;
self.update()
def num_children(self):
if self.invalid:
return 0;
return 6;
def read_unicode(self, pointer):
process = self.valobj.GetTarget().GetProcess()
error = lldb.SBError()
pystr = u''
while True:
content = process.ReadMemory(pointer, 2, error)
new_bytes = bytearray(content)
b0 = new_bytes[0]
b1 = new_bytes[1]
pointer = pointer + 2
if b0 == 0 and b1 == 0:
break
if self.is_little:
value = b1 * 256 + b0
else:
value = b0 * 256 + b1
pystr = pystr + unichr(value)
return pystr
def handle_special(self):
if self.lp64 == False:
return self.handle_unicode_string_safe()
offset = 12
pointer = self.valobj.GetValueAsUnsigned(0) + offset
pystr = self.read_unicode(pointer)
return self.valobj.CreateValueFromExpression("content",
"(char*)\"" + pystr.encode('utf-8') + "\"")
def handle_unicode_string_safe(self):
return self.valobj.CreateValueFromExpression("content",
"(char*)\"" + self.valobj.GetObjectDescription() + "\"");
def handle_unicode_string(self):
if self.inline:
pointer = self.valobj.GetValueAsUnsigned(0) + self.size_of_cfruntime_base();
if self.explicit == False:
return self.handle_unicode_string_safe();
else:
pointer = pointer + 8;
else:
pointer = self.valobj.GetValueAsUnsigned(0) + self.size_of_cfruntime_base();
vopointer = self.valobj.CreateChildAtOffset("dummy",
pointer,self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType());
pointer = vopointer.GetValueAsUnsigned(0)
pystr = self.read_unicode(pointer)
return self.valobj.CreateValueFromExpression("content",
"(char*)\"" + pystr.encode('utf-8') + "\"")
def handle_UTF8_inline(self):
offset = int(self.valobj.GetValue(), 0) + self.size_of_cfruntime_base();
if self.explicit == False:
offset = offset + 1;
return self.valobj.CreateValueFromAddress("content",
offset, self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar)).AddressOf();
def handle_UTF8_not_inline(self):
offset = self.size_of_cfruntime_base();
return self.valobj.CreateChildAtOffset("content",
offset,self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType());
def get_child_at_index(self,index):
if index == 0:
return self.valobj.CreateValueFromExpression("mutable",
str(int(self.mutable)));
if index == 1:
return self.valobj.CreateValueFromExpression("inline",
str(int(self.inline)));
if index == 2:
return self.valobj.CreateValueFromExpression("explicit",
str(int(self.explicit)));
if index == 3:
return self.valobj.CreateValueFromExpression("unicode",
str(int(self.unicode)));
if index == 4:
return self.valobj.CreateValueFromExpression("special",
str(int(self.special)));
if index == 5:
if self.unicode == True:
return self.handle_unicode_string();
elif self.special == True:
return self.handle_special();
elif self.inline == True:
return self.handle_UTF8_inline();
else:
return self.handle_UTF8_not_inline();
def get_child_index(self,name):
if name == "content":
return self.num_children() - 1;
if name == "mutable":
return 0;
if name == "inline":
return 1;
if name == "explicit":
return 2;
if name == "unicode":
return 3;
if name == "special":
return 4;
def is_64bit(self):
return self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8
def is_little_endian(self):
return self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle
def size_of_cfruntime_base(self):
if self.lp64 == True:
return 8+4+4;
else:
return 4+4;
def offset_of_info_bits(self):
if self.lp64 == True:
offset = 8;
else:
offset = 4;
if self.is_little == False:
offset = offset + 3;
return offset;
def read_info_bits(self):
cfinfo = self.valobj.CreateChildAtOffset("cfinfo",
self.offset_of_info_bits(),
self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar));
cfinfo.SetFormat(11)
info = cfinfo.GetValue();
if info != None:
self.invalid = False;
return int(info,0);
else:
self.invalid = True;
return None;
def is_mutable(self):
return (self.info_bits & 1) == 1;
def is_inline(self):
return (self.info_bits & 0x60) == 0;
def has_explicit_length(self):
return (self.info_bits & (1 | 4)) != 4;
def is_special_case(self):
return self.info_bits == 0;
def is_unicode(self):
return (self.info_bits & 0x10) == 0x10;
def adjust_for_architecture(self):
self.lp64 = self.is_64bit();
self.is_little = self.is_little_endian();
def compute_flags(self):
self.info_bits = self.read_info_bits();
if self.info_bits == None:
return;
self.mutable = self.is_mutable();
self.inline = self.is_inline();
self.explicit = self.has_explicit_length();
self.unicode = self.is_unicode();
self.special = self.is_special_case();
def update(self):
self.adjust_for_architecture();
self.compute_flags();