%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


def _add_formatter(cmd: str, type_name: str, options: dict):
    import shlex

    type_name = shlex.quote(type_name)

    # Convert `option=True` to "--option", all others to "--option value".
    flag_list = []
    for key, value in options.items():
        flag = key.replace("_", "-")
        if value is True:
            flag_list.append(f"--{flag}")
        else:
            flag_list.extend((f"--{flag}", value))

    def decorator(obj):
        qualified = f"{obj.__module__}.{obj.__qualname__}"
        if isinstance(obj, type):
            flag_list.extend(("--python-class", qualified))
        elif callable(obj):
            flag_list.extend(("--python-function", qualified))

        result = SBCommandReturnObject()
        flags = " ".join(flag_list)
        interp = debugger.GetCommandInterpreter()
        interp.HandleCommand(f"{cmd} {flags} {type_name}", result)
        if not result.Succeeded():
            raise RuntimeError(result.GetError())
        return obj

    return decorator


def summary(type_name, **kwargs):
    """A decorator that registers a function as an LLDB type summary provider.

    @lldb.summary("MyType")
    def MyTypeSummary(valobj, _):
        return "summary string"
    """
    return _add_formatter("type summary add", type_name, kwargs)


def synthetic(type_name, **kwargs):
    """A decorator that registers a class as an LLDB synthetic child provider.

    @lldb.synthetic("MyType")
    class MyTypeSynthetic:
        def __init__(self, valobj, _):
            ...
    """
    return _add_formatter("type synthetic add", type_name, kwargs)


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 __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 __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):
        ty = self.sbvalue.GetType().GetCanonicalType()
        if ty.IsPointerType():
            return self.sbvalue.GetValueAsUnsigned()
        is_num,is_sign = is_numeric_type(ty.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 __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.'''
      for i in range(self.num_children()):
          yield self.get_child_at_index(i)

%}

%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)

%}