6813ef3737
This patch re-lands f0731d5b61 with more fixes and improvements.
First, this patch removes `__eq__` implementations from classes that
didn't implemented `operator!=` on the C++ implementation.
This patch removes sphinx document generation for special members such
as `__len__`, since there is no straightforward way to skip class that
don't implement them. We also don't want to introduce a change in
behavior by implementing artifical special members for classes that are
missing them.
Finally, this patch improve the ergonomics of some classes by
implementing special members where it makes sense, i.e. `hex(SBFrame)`
is equivalent to `SBFrame.GetPC()`.
Differential Revision: https://reviews.llvm.org/D159017
Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
608 lines
18 KiB
Plaintext
608 lines
18 KiB
Plaintext
%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 == 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)
|
|
|
|
%}
|