498b59e011
This patch does various things to silence the warnings that show up when generating the website documentation. First, this patch adds the missing definition for special member methods in every SBAPI class. If the class cannot implement one of the special member method, we just define it as a null operation (pass). This should fix the following warnings: ``` WARNING: missing attribute __int__ in object lldb.SB* WARNING: missing attribute __len__ in object lldb.SB* WARNING: missing attribute __hex__ in object lldb.SB* WARNING: missing attribute __oct__ in object lldb.SB* WARNING: missing attribute __iter__ in object lldb.SB* ``` Then, it un-skips the various `static` methods that we didn't generate the methods for, since it's not necessary thanks to the automod-api module. Finally, this comments out the `_static` directory in the sphinx config, since we don't need it anymore. Differential Revision: https://reviews.llvm.org/D159017 Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
644 lines
18 KiB
Plaintext
644 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
|
|
|
|
def __eq__(self, other):
|
|
return not self.__ne__(other)
|
|
|
|
def __int__(self):
|
|
pass
|
|
|
|
def __hex__(self):
|
|
pass
|
|
|
|
def __oct__(self):
|
|
pass
|
|
|
|
def __len__(self):
|
|
pass
|
|
|
|
def __iter__(self):
|
|
pass
|
|
|
|
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 __int__(self):
|
|
pass
|
|
|
|
def __hex__(self):
|
|
pass
|
|
|
|
def __oct__(self):
|
|
pass
|
|
|
|
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 __int__(self):
|
|
pass
|
|
|
|
def __hex__(self):
|
|
pass
|
|
|
|
def __oct__(self):
|
|
pass
|
|
|
|
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)
|
|
|
|
%}
|