1%extend lldb::SBBreakpoint {
2    %pythoncode %{
3        def __eq__(self, rhs):
4            if not isinstance(rhs, type(self)):
5                return False
6
7            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
8
9        def __ne__(self, rhs):
10            if not isinstance(rhs, type(self)):
11                return True
12
13            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
14    %}
15}
16
17%extend lldb::SBBroadcaster {
18    %pythoncode %{
19        def __eq__(self, rhs):
20            if not isinstance(rhs, type(self)):
21                return False
22
23            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
24
25        def __ne__(self, rhs):
26            if not isinstance(rhs, type(self)):
27                return True
28
29            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
30    %}
31}
32
33%extend lldb::SBCommandReturnObject {
34        /* the write() and flush() calls are not part of the SB API proper, and are solely for Python usage
35        they are meant to make an SBCommandReturnObject into a file-like object so that instructions of the sort
36        print >>sb_command_return_object, "something"
37        will work correctly */
38
39        void lldb::SBCommandReturnObject::write (const char* str)
40        {
41            if (str)
42                $self->Printf("%s",str);
43        }
44        void lldb::SBCommandReturnObject::flush ()
45        {}
46}
47
48%extend lldb::SBCompileUnit {
49    %pythoncode %{
50        def __eq__(self, rhs):
51            if not isinstance(rhs, type(self)):
52                return False
53
54            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
55
56        def __ne__(self, rhs):
57            if not isinstance(rhs, type(self)):
58                return True
59
60            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
61    %}
62}
63
64%extend lldb::SBDeclaration {
65    %pythoncode %{
66        def __eq__(self, rhs):
67            if not isinstance(rhs, type(self)):
68                return False
69
70            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
71
72        def __ne__(self, rhs):
73            if not isinstance(rhs, type(self)):
74                return True
75
76            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
77    %}
78}
79
80%extend lldb::SBFunction {
81    %pythoncode %{
82        def __eq__(self, rhs):
83            if not isinstance(rhs, type(self)):
84                return False
85
86            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
87
88        def __ne__(self, rhs):
89            if not isinstance(rhs, type(self)):
90                return True
91
92            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
93    %}
94}
95
96%extend lldb::SBLineEntry {
97    %pythoncode %{
98        def __eq__(self, rhs):
99            if not isinstance(rhs, type(self)):
100                return False
101
102            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
103
104        def __ne__(self, rhs):
105            if not isinstance(rhs, type(self)):
106                return True
107
108            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
109    %}
110}
111
112%extend lldb::SBModule {
113    %pythoncode %{
114        def __eq__(self, rhs):
115            if not isinstance(rhs, type(self)):
116                return False
117
118            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
119
120        def __ne__(self, rhs):
121            if not isinstance(rhs, type(self)):
122                return True
123
124            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
125    %}
126}
127
128%extend lldb::SBSection {
129    %pythoncode %{
130        def __eq__(self, rhs):
131            if not isinstance(rhs, type(self)):
132                return False
133
134            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
135
136        def __ne__(self, rhs):
137            if not isinstance(rhs, type(self)):
138                return True
139
140            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
141    %}
142}
143%extend lldb::SBStream {
144        /* the write() and flush() calls are not part of the SB API proper, and are solely for Python usage
145        they are meant to make an SBStream into a file-like object so that instructions of the sort
146        print >>sb_stream, "something"
147        will work correctly */
148
149        void lldb::SBStream::write (const char* str)
150        {
151            if (str)
152                $self->Printf("%s",str);
153        }
154        void lldb::SBStream::flush ()
155        {}
156}
157%extend lldb::SBSymbol {
158    %pythoncode %{
159        def __eq__(self, rhs):
160            if not isinstance(rhs, type(self)):
161                return False
162
163            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
164
165        def __ne__(self, rhs):
166            if not isinstance(rhs, type(self)):
167                return True
168
169            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
170    %}
171}
172
173%extend lldb::SBTarget {
174    %pythoncode %{
175        def __eq__(self, rhs):
176            if not isinstance(rhs, type(self)):
177                return False
178
179            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
180
181        def __ne__(self, rhs):
182            if not isinstance(rhs, type(self)):
183                return True
184
185            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
186    %}
187}
188
189%extend lldb::SBTypeFilter {
190    %pythoncode %{
191        def __eq__(self, rhs):
192            if not isinstance(rhs, type(self)):
193                return False
194
195            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
196
197        def __ne__(self, rhs):
198            if not isinstance(rhs, type(self)):
199                return True
200
201            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
202    %}
203}
204
205%extend lldb::SBTypeNameSpecifier {
206    %pythoncode %{
207        def __eq__(self, rhs):
208            if not isinstance(rhs, type(self)):
209                return False
210
211            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
212
213        def __ne__(self, rhs):
214            if not isinstance(rhs, type(self)):
215                return True
216
217            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
218    %}
219}
220
221%extend lldb::SBTypeSummary {
222    %pythoncode %{
223        def __eq__(self, rhs):
224            if not isinstance(rhs, type(self)):
225                return False
226
227            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
228
229        def __ne__(self, rhs):
230            if not isinstance(rhs, type(self)):
231                return True
232
233            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
234    %}
235}
236
237%extend lldb::SBTypeSynthetic {
238    %pythoncode %{
239        def __eq__(self, rhs):
240            if not isinstance(rhs, type(self)):
241                return False
242
243            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
244
245        def __ne__(self, rhs):
246            if not isinstance(rhs, type(self)):
247                return True
248
249            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
250    %}
251}
252
253%extend lldb::SBThread {
254    %pythoncode %{
255        def __eq__(self, rhs):
256            if not isinstance(rhs, type(self)):
257                return False
258
259            return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
260
261        def __ne__(self, rhs):
262            if not isinstance(rhs, type(self)):
263                return True
264
265            return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)
266    %}
267}
268
269%pythoncode %{
270
271def command(command_name=None, doc=None):
272    import lldb
273    """A decorator function that registers an LLDB command line
274        command that is bound to the function it is attached to."""
275    def callable(function):
276        """Registers an lldb command for the decorated function."""
277        command = "command script add -f %s.%s %s" % (function.__module__, function.__name__, command_name or function.__name__)
278        lldb.debugger.HandleCommand(command)
279        if doc:
280            function.__doc__ = doc
281        return function
282
283    return callable
284
285class declaration(object):
286    '''A class that represents a source declaration location with file, line and column.'''
287    def __init__(self, file, line, col):
288        self.file = file
289        self.line = line
290        self.col = col
291
292class value_iter(object):
293    '''Allows iterating over the children of an :py:class:`SBValue`.'''
294    def __iter__(self):
295        return self
296
297    def __next__(self):
298        if self.index >= self.length:
299            raise StopIteration()
300        child_sbvalue = self.sbvalue.GetChildAtIndex(self.index)
301        self.index += 1
302        return value(child_sbvalue)
303
304    def next(self):
305        return self.__next__()
306
307    def __init__(self,value):
308        self.index = 0
309        self.sbvalue = value
310        if type(self.sbvalue) is value:
311            self.sbvalue = self.sbvalue.sbvalue
312        self.length = self.sbvalue.GetNumChildren()
313
314class value(object):
315    '''Wraps :py:class:`SBValue` objects so the resulting object can be used as a variable would be in code.
316
317    So if you have a Point structure variable in your code in the current frame named "pt",
318    you can initialize an instance of this class with it: ::
319
320        pt = lldb.value(lldb.frame.FindVariable("pt"))
321        print pt
322        print pt.x
323        print pt.y
324
325        pt = lldb.value(lldb.frame.FindVariable("rectangle_array"))
326        print rectangle_array[12]
327        print rectangle_array[5].origin.x'''
328    def __init__(self, sbvalue):
329        self.sbvalue = sbvalue
330
331    def __nonzero__(self):
332        return self.sbvalue.__nonzero__()
333
334    def __bool__(self):
335        return self.sbvalue.__bool__()
336
337    def __str__(self):
338        return self.sbvalue.__str__()
339
340    def __getitem__(self, key):
341        # Allow array access if this value has children...
342        if type(key) is value:
343            key = int(key)
344        if type(key) is int:
345            child_sbvalue = (self.sbvalue.GetValueForExpressionPath("[%i]" % key))
346            if child_sbvalue and child_sbvalue.IsValid():
347                return value(child_sbvalue)
348            raise IndexError("Index '%d' is out of range" % key)
349        raise TypeError("No array item of type %s" % str(type(key)))
350
351    def __iter__(self):
352        return value_iter(self.sbvalue)
353
354    def __getattr__(self, name):
355        child_sbvalue = self.sbvalue.GetChildMemberWithName (name)
356        if child_sbvalue and child_sbvalue.IsValid():
357            return value(child_sbvalue)
358        raise AttributeError("Attribute '%s' is not defined" % name)
359
360    def __add__(self, other):
361        return int(self) + int(other)
362
363    def __sub__(self, other):
364        return int(self) - int(other)
365
366    def __mul__(self, other):
367        return int(self) * int(other)
368
369    def __floordiv__(self, other):
370        return int(self) // int(other)
371
372    def __mod__(self, other):
373        return int(self) % int(other)
374
375    def __divmod__(self, other):
376        return int(self) % int(other)
377
378    def __pow__(self, other):
379        return int(self) ** int(other)
380
381    def __lshift__(self, other):
382        return int(self) << int(other)
383
384    def __rshift__(self, other):
385        return int(self) >> int(other)
386
387    def __and__(self, other):
388        return int(self) & int(other)
389
390    def __xor__(self, other):
391        return int(self) ^ int(other)
392
393    def __or__(self, other):
394        return int(self) | int(other)
395
396    def __div__(self, other):
397        return int(self) / int(other)
398
399    def __truediv__(self, other):
400        return int(self) / int(other)
401
402    def __iadd__(self, other):
403        result = self.__add__(other)
404        self.sbvalue.SetValueFromCString (str(result))
405        return result
406
407    def __isub__(self, other):
408        result = self.__sub__(other)
409        self.sbvalue.SetValueFromCString (str(result))
410        return result
411
412    def __imul__(self, other):
413        result = self.__mul__(other)
414        self.sbvalue.SetValueFromCString (str(result))
415        return result
416
417    def __idiv__(self, other):
418        result = self.__div__(other)
419        self.sbvalue.SetValueFromCString (str(result))
420        return result
421
422    def __itruediv__(self, other):
423        result = self.__truediv__(other)
424        self.sbvalue.SetValueFromCString (str(result))
425        return result
426
427    def __ifloordiv__(self, other):
428        result =  self.__floordiv__(self, other)
429        self.sbvalue.SetValueFromCString (str(result))
430        return result
431
432    def __imod__(self, other):
433        result =  self.__and__(self, other)
434        self.sbvalue.SetValueFromCString (str(result))
435        return result
436
437    def __ipow__(self, other):
438        result = self.__pow__(self, other)
439        self.sbvalue.SetValueFromCString (str(result))
440        return result
441
442    def __ipow__(self, other, modulo):
443        result = self.__pow__(self, other, modulo)
444        self.sbvalue.SetValueFromCString (str(result))
445        return result
446
447    def __ilshift__(self, other):
448        result = self.__lshift__(other)
449        self.sbvalue.SetValueFromCString (str(result))
450        return result
451
452    def __irshift__(self, other):
453        result =  self.__rshift__(other)
454        self.sbvalue.SetValueFromCString (str(result))
455        return result
456
457    def __iand__(self, other):
458        result =  self.__and__(self, other)
459        self.sbvalue.SetValueFromCString (str(result))
460        return result
461
462    def __ixor__(self, other):
463        result =  self.__xor__(self, other)
464        self.sbvalue.SetValueFromCString (str(result))
465        return result
466
467    def __ior__(self, other):
468        result =  self.__ior__(self, other)
469        self.sbvalue.SetValueFromCString (str(result))
470        return result
471
472    def __neg__(self):
473        return -int(self)
474
475    def __pos__(self):
476        return +int(self)
477
478    def __abs__(self):
479        return abs(int(self))
480
481    def __invert__(self):
482        return ~int(self)
483
484    def __complex__(self):
485        return complex (int(self))
486
487    def __int__(self):
488        is_num,is_sign = is_numeric_type(self.sbvalue.GetType().GetCanonicalType().GetBasicType())
489        if is_num and not is_sign: return self.sbvalue.GetValueAsUnsigned()
490        return self.sbvalue.GetValueAsSigned()
491
492    def __long__(self):
493        return self.__int__()
494
495    def __float__(self):
496        return float (self.sbvalue.GetValueAsSigned())
497
498    def __oct__(self):
499        return '0%o' % self.sbvalue.GetValueAsUnsigned()
500
501    def __hex__(self):
502        return '0x%x' % self.sbvalue.GetValueAsUnsigned()
503
504    def __len__(self):
505        return self.sbvalue.GetNumChildren()
506
507    def __eq__(self, other):
508        if type(other) is int:
509                return int(self) == other
510        elif type(other) is str:
511                return str(self) == other
512        elif type(other) is value:
513                self_err = SBError()
514                other_err = SBError()
515                self_val = self.sbvalue.GetValueAsUnsigned(self_err)
516                if self_err.fail:
517                        raise ValueError("unable to extract value of self")
518                other_val = other.sbvalue.GetValueAsUnsigned(other_err)
519                if other_err.fail:
520                        raise ValueError("unable to extract value of other")
521                return self_val == other_val
522        raise TypeError("Unknown type %s, No equality operation defined." % str(type(other)))
523
524    def __ne__(self, other):
525        return not self.__eq__(other)
526%}
527
528%pythoncode %{
529
530class SBSyntheticValueProvider(object):
531    def __init__(self,valobj):
532        pass
533
534    def num_children(self):
535        return 0
536
537    def get_child_index(self,name):
538        return None
539
540    def get_child_at_index(self,idx):
541        return None
542
543    def update(self):
544        pass
545
546    def has_children(self):
547        return False
548
549
550%}
551
552%pythoncode %{
553
554# given an lldb.SBBasicType it returns a tuple
555# (is_numeric, is_signed)
556# the value of is_signed is undefined if is_numeric == false
557def is_numeric_type(basic_type):
558    if basic_type == eBasicTypeInvalid: return (False,False)
559    if basic_type == eBasicTypeVoid: return (False,False)
560    if basic_type == eBasicTypeChar: return (True,False)
561    if basic_type == eBasicTypeSignedChar: return (True,True)
562    if basic_type == eBasicTypeUnsignedChar: return (True,False)
563    if basic_type == eBasicTypeWChar: return (True,False)
564    if basic_type == eBasicTypeSignedWChar: return (True,True)
565    if basic_type == eBasicTypeUnsignedWChar: return (True,False)
566    if basic_type == eBasicTypeChar16: return (True,False)
567    if basic_type == eBasicTypeChar32: return (True,False)
568    if basic_type == eBasicTypeShort: return (True,True)
569    if basic_type == eBasicTypeUnsignedShort: return (True,False)
570    if basic_type == eBasicTypeInt: return (True,True)
571    if basic_type == eBasicTypeUnsignedInt: return (True,False)
572    if basic_type == eBasicTypeLong: return (True,True)
573    if basic_type == eBasicTypeUnsignedLong: return (True,False)
574    if basic_type == eBasicTypeLongLong: return (True,True)
575    if basic_type == eBasicTypeUnsignedLongLong: return (True,False)
576    if basic_type == eBasicTypeInt128: return (True,True)
577    if basic_type == eBasicTypeUnsignedInt128: return (True,False)
578    if basic_type == eBasicTypeBool: return (False,False)
579    if basic_type == eBasicTypeHalf: return (True,True)
580    if basic_type == eBasicTypeFloat: return (True,True)
581    if basic_type == eBasicTypeDouble: return (True,True)
582    if basic_type == eBasicTypeLongDouble: return (True,True)
583    if basic_type == eBasicTypeFloatComplex: return (True,True)
584    if basic_type == eBasicTypeDoubleComplex: return (True,True)
585    if basic_type == eBasicTypeLongDoubleComplex: return (True,True)
586    if basic_type == eBasicTypeObjCID: return (False,False)
587    if basic_type == eBasicTypeObjCClass: return (False,False)
588    if basic_type == eBasicTypeObjCSel: return (False,False)
589    if basic_type == eBasicTypeNullPtr: return (False,False)
590    #if basic_type == eBasicTypeOther:
591    return (False,False)
592
593%}
594