| %extend lldb::SBBreakpoint { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBBroadcaster { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBCommandReturnObject { | |
| /* the write() and flush() calls are not part of the SB API proper, and are solely for Python usage | |
| they are meant to make an SBCommandReturnObject into a file-like object so that instructions of the sort | |
| print >>sb_command_return_object, "something" | |
| will work correctly */ | |
| void lldb::SBCommandReturnObject::write (const char* str) | |
| { | |
| if (str) | |
| $self->Printf("%s",str); | |
| } | |
| void lldb::SBCommandReturnObject::flush () | |
| {} | |
| } | |
| %extend lldb::SBCompileUnit { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBDeclaration { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBFunction { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBLineEntry { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBModule { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBSection { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBStream { | |
| /* the write() and flush() calls are not part of the SB API proper, and are solely for Python usage | |
| they are meant to make an SBStream into a file-like object so that instructions of the sort | |
| print >>sb_stream, "something" | |
| will work correctly */ | |
| void lldb::SBStream::write (const char* str) | |
| { | |
| if (str) | |
| $self->Printf("%s",str); | |
| } | |
| void lldb::SBStream::flush () | |
| {} | |
| } | |
| %extend lldb::SBSymbol { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBTarget { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBTypeFilter { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBTypeNameSpecifier { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBTypeSummary { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBTypeSynthetic { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %extend lldb::SBThread { | |
| %pythoncode %{ | |
| def __eq__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return False | |
| return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs) | |
| def __ne__(self, rhs): | |
| if not isinstance(rhs, type(self)): | |
| return True | |
| return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs) | |
| %} | |
| } | |
| %pythoncode %{ | |
| def command(command_name=None, doc=None): | |
| import lldb | |
| """A decorator function that registers an LLDB command line | |
| command that is bound to the function it is attached to.""" | |
| def callable(function): | |
| """Registers an lldb command for the decorated function.""" | |
| command = "command script add -f %s.%s %s" % (function.__module__, function.__name__, command_name or function.__name__) | |
| lldb.debugger.HandleCommand(command) | |
| if doc: | |
| function.__doc__ = doc | |
| return function | |
| return callable | |
| class declaration(object): | |
| '''A class that represents a source declaration location with file, line and column.''' | |
| def __init__(self, file, line, col): | |
| self.file = file | |
| self.line = line | |
| self.col = col | |
| class value_iter(object): | |
| '''Allows iterating over the children of an :py:class:`SBValue`.''' | |
| def __iter__(self): | |
| return self | |
| def __next__(self): | |
| if self.index >= self.length: | |
| raise StopIteration() | |
| child_sbvalue = self.sbvalue.GetChildAtIndex(self.index) | |
| self.index += 1 | |
| return value(child_sbvalue) | |
| def next(self): | |
| return self.__next__() | |
| def __eq__(self, other): | |
| return not self.__ne__(other) | |
| def __len__(self): | |
| return self.length | |
| def __init__(self,value): | |
| self.index = 0 | |
| self.length = 0 | |
| self.sbvalue = value | |
| if type(self.sbvalue) is value: | |
| self.sbvalue = self.sbvalue.sbvalue | |
| self.length = self.sbvalue.GetNumChildren() | |
| class value(object): | |
| '''Wraps :py:class:`SBValue` objects so the resulting object can be used as a variable would be in code. | |
| So if you have a Point structure variable in your code in the current frame named "pt", | |
| you can initialize an instance of this class with it: :: | |
| pt = lldb.value(lldb.frame.FindVariable("pt")) | |
| print pt | |
| print pt.x | |
| print pt.y | |
| pt = lldb.value(lldb.frame.FindVariable("rectangle_array")) | |
| print rectangle_array[12] | |
| print rectangle_array[5].origin.x''' | |
| def __init__(self, sbvalue): | |
| self.sbvalue = sbvalue | |
| def __nonzero__(self): | |
| return self.sbvalue.__nonzero__() | |
| def __bool__(self): | |
| return self.sbvalue.__bool__() | |
| def __str__(self): | |
| return self.sbvalue.__str__() | |
| def __getitem__(self, key): | |
| # Allow array access if this value has children... | |
| if type(key) is value: | |
| key = int(key) | |
| if type(key) is int: | |
| child_sbvalue = (self.sbvalue.GetValueForExpressionPath("[%i]" % key)) | |
| if child_sbvalue and child_sbvalue.IsValid(): | |
| return value(child_sbvalue) | |
| raise IndexError("Index '%d' is out of range" % key) | |
| raise TypeError("No array item of type %s" % str(type(key))) | |
| def __iter__(self): | |
| return value_iter(self.sbvalue) | |
| def __getattr__(self, name): | |
| child_sbvalue = self.sbvalue.GetChildMemberWithName (name) | |
| if child_sbvalue and child_sbvalue.IsValid(): | |
| return value(child_sbvalue) | |
| raise AttributeError("Attribute '%s' is not defined" % name) | |
| def __add__(self, other): | |
| return int(self) + int(other) | |
| def __sub__(self, other): | |
| return int(self) - int(other) | |
| def __mul__(self, other): | |
| return int(self) * int(other) | |
| def __floordiv__(self, other): | |
| return int(self) // int(other) | |
| def __mod__(self, other): | |
| return int(self) % int(other) | |
| def __divmod__(self, other): | |
| return int(self) % int(other) | |
| def __pow__(self, other): | |
| return int(self) ** int(other) | |
| def __lshift__(self, other): | |
| return int(self) << int(other) | |
| def __rshift__(self, other): | |
| return int(self) >> int(other) | |
| def __and__(self, other): | |
| return int(self) & int(other) | |
| def __xor__(self, other): | |
| return int(self) ^ int(other) | |
| def __or__(self, other): | |
| return int(self) | int(other) | |
| def __div__(self, other): | |
| return int(self) / int(other) | |
| def __truediv__(self, other): | |
| return int(self) / int(other) | |
| def __iadd__(self, other): | |
| result = self.__add__(other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __isub__(self, other): | |
| result = self.__sub__(other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __imul__(self, other): | |
| result = self.__mul__(other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __idiv__(self, other): | |
| result = self.__div__(other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __itruediv__(self, other): | |
| result = self.__truediv__(other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __ifloordiv__(self, other): | |
| result = self.__floordiv__(self, other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __imod__(self, other): | |
| result = self.__and__(self, other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __ipow__(self, other): | |
| result = self.__pow__(self, other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __ipow__(self, other, modulo): | |
| result = self.__pow__(self, other, modulo) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __ilshift__(self, other): | |
| result = self.__lshift__(other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __irshift__(self, other): | |
| result = self.__rshift__(other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __iand__(self, other): | |
| result = self.__and__(self, other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __ixor__(self, other): | |
| result = self.__xor__(self, other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __ior__(self, other): | |
| result = self.__ior__(self, other) | |
| self.sbvalue.SetValueFromCString (str(result)) | |
| return result | |
| def __neg__(self): | |
| return -int(self) | |
| def __pos__(self): | |
| return +int(self) | |
| def __abs__(self): | |
| return abs(int(self)) | |
| def __invert__(self): | |
| return ~int(self) | |
| def __complex__(self): | |
| return complex (int(self)) | |
| def __int__(self): | |
| is_num,is_sign = is_numeric_type(self.sbvalue.GetType().GetCanonicalType().GetBasicType()) | |
| if is_num and not is_sign: return self.sbvalue.GetValueAsUnsigned() | |
| return self.sbvalue.GetValueAsSigned() | |
| def __long__(self): | |
| return self.__int__() | |
| def __float__(self): | |
| return float (self.sbvalue.GetValueAsSigned()) | |
| def __oct__(self): | |
| return '0%o' % self.sbvalue.GetValueAsUnsigned() | |
| def __hex__(self): | |
| return '0x%x' % self.sbvalue.GetValueAsUnsigned() | |
| def __len__(self): | |
| return self.sbvalue.GetNumChildren() | |
| def __eq__(self, other): | |
| if type(other) is int: | |
| return int(self) == other | |
| elif type(other) is str: | |
| return str(self) == other | |
| elif type(other) is value: | |
| self_err = SBError() | |
| other_err = SBError() | |
| self_val = self.sbvalue.GetValueAsUnsigned(self_err) | |
| if self_err.fail: | |
| raise ValueError("unable to extract value of self") | |
| other_val = other.sbvalue.GetValueAsUnsigned(other_err) | |
| if other_err.fail: | |
| raise ValueError("unable to extract value of other") | |
| return self_val == other_val | |
| raise TypeError("Unknown type %s, No equality operation defined." % str(type(other))) | |
| def __ne__(self, other): | |
| return not self.__eq__(other) | |
| %} | |
| %pythoncode %{ | |
| class SBSyntheticValueProvider(object): | |
| def __init__(self,valobj): | |
| pass | |
| def num_children(self): | |
| return 0 | |
| def get_child_index(self,name): | |
| return None | |
| def get_child_at_index(self,idx): | |
| return None | |
| def update(self): | |
| pass | |
| def has_children(self): | |
| return False | |
| def __len__(self): | |
| return self.num_children() | |
| def __iter__(self): | |
| '''Iterate over all children in a lldb.SBSyntheticValueProvider object.''' | |
| return lldb_iter(self, 'num_children', 'get_child_at_index') | |
| %} | |
| %pythoncode %{ | |
| # given an lldb.SBBasicType it returns a tuple | |
| # (is_numeric, is_signed) | |
| # the value of is_signed is undefined if is_numeric == false | |
| def is_numeric_type(basic_type): | |
| if basic_type == eBasicTypeInvalid: return (False,False) | |
| if basic_type == eBasicTypeVoid: return (False,False) | |
| if basic_type == eBasicTypeChar: return (True,False) | |
| if basic_type == eBasicTypeSignedChar: return (True,True) | |
| if basic_type == eBasicTypeUnsignedChar: return (True,False) | |
| if basic_type == eBasicTypeWChar: return (True,False) | |
| if basic_type == eBasicTypeSignedWChar: return (True,True) | |
| if basic_type == eBasicTypeUnsignedWChar: return (True,False) | |
| if basic_type == eBasicTypeChar16: return (True,False) | |
| if basic_type == eBasicTypeChar32: return (True,False) | |
| if basic_type == eBasicTypeChar8: return (True,False) | |
| if basic_type == eBasicTypeShort: return (True,True) | |
| if basic_type == eBasicTypeUnsignedShort: return (True,False) | |
| if basic_type == eBasicTypeInt: return (True,True) | |
| if basic_type == eBasicTypeUnsignedInt: return (True,False) | |
| if basic_type == eBasicTypeLong: return (True,True) | |
| if basic_type == eBasicTypeUnsignedLong: return (True,False) | |
| if basic_type == eBasicTypeLongLong: return (True,True) | |
| if basic_type == eBasicTypeUnsignedLongLong: return (True,False) | |
| if basic_type == eBasicTypeInt128: return (True,True) | |
| if basic_type == eBasicTypeUnsignedInt128: return (True,False) | |
| if basic_type == eBasicTypeBool: return (False,False) | |
| if basic_type == eBasicTypeHalf: return (True,True) | |
| if basic_type == eBasicTypeFloat: return (True,True) | |
| if basic_type == eBasicTypeDouble: return (True,True) | |
| if basic_type == eBasicTypeLongDouble: return (True,True) | |
| if basic_type == eBasicTypeFloat128: return (True,True) | |
| if basic_type == eBasicTypeFloatComplex: return (True,True) | |
| if basic_type == eBasicTypeDoubleComplex: return (True,True) | |
| if basic_type == eBasicTypeLongDoubleComplex: return (True,True) | |
| if basic_type == eBasicTypeObjCID: return (False,False) | |
| if basic_type == eBasicTypeObjCClass: return (False,False) | |
| if basic_type == eBasicTypeObjCSel: return (False,False) | |
| if basic_type == eBasicTypeNullPtr: return (False,False) | |
| #if basic_type == eBasicTypeOther: | |
| return (False,False) | |
| %} |