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    def __iter__(self):
294        return self
295
296    def __next__(self):
297        if self.index >= self.length:
298            raise StopIteration()
299        child_sbvalue = self.sbvalue.GetChildAtIndex(self.index)
300        self.index += 1
301        return value(child_sbvalue)
302
303    def next(self):
304        return self.__next__()
305
306    def __init__(self,value):
307        self.index = 0
308        self.sbvalue = value
309        if type(self.sbvalue) is value:
310            self.sbvalue = self.sbvalue.sbvalue
311        self.length = self.sbvalue.GetNumChildren()
312
313class value(object):
314    '''A class designed to wrap lldb.SBValue() objects so the resulting object
315    can be used as a variable would be in code. So if you have a Point structure
316    variable in your code in the current frame named "pt", you can initialize an instance
317    of this class with it:
318
319    pt = lldb.value(lldb.frame.FindVariable("pt"))
320    print pt
321    print pt.x
322    print pt.y
323
324    pt = lldb.value(lldb.frame.FindVariable("rectangle_array"))
325    print rectangle_array[12]
326    print rectangle_array[5].origin.x'''
327    def __init__(self, sbvalue):
328        self.sbvalue = sbvalue
329
330    def __nonzero__(self):
331        return self.sbvalue.__nonzero__()
332
333    def __bool__(self):
334        return self.sbvalue.__bool__()
335
336    def __str__(self):
337        return self.sbvalue.__str__()
338
339    def __getitem__(self, key):
340        # Allow array access if this value has children...
341        if type(key) is value:
342            key = int(key)
343        if type(key) is int:
344            child_sbvalue = (self.sbvalue.GetValueForExpressionPath("[%i]" % key))
345            if child_sbvalue and child_sbvalue.IsValid():
346                return value(child_sbvalue)
347            raise IndexError("Index '%d' is out of range" % key)
348        raise TypeError("No array item of type %s" % str(type(key)))
349
350    def __iter__(self):
351        return value_iter(self.sbvalue)
352
353    def __getattr__(self, name):
354        child_sbvalue = self.sbvalue.GetChildMemberWithName (name)
355        if child_sbvalue and child_sbvalue.IsValid():
356            return value(child_sbvalue)
357        raise AttributeError("Attribute '%s' is not defined" % name)
358
359    def __add__(self, other):
360        return int(self) + int(other)
361
362    def __sub__(self, other):
363        return int(self) - int(other)
364
365    def __mul__(self, other):
366        return int(self) * int(other)
367
368    def __floordiv__(self, other):
369        return int(self) // int(other)
370
371    def __mod__(self, other):
372        return int(self) % int(other)
373
374    def __divmod__(self, other):
375        return int(self) % int(other)
376
377    def __pow__(self, other):
378        return int(self) ** int(other)
379
380    def __lshift__(self, other):
381        return int(self) << int(other)
382
383    def __rshift__(self, other):
384        return int(self) >> int(other)
385
386    def __and__(self, other):
387        return int(self) & int(other)
388
389    def __xor__(self, other):
390        return int(self) ^ int(other)
391
392    def __or__(self, other):
393        return int(self) | int(other)
394
395    def __div__(self, other):
396        return int(self) / int(other)
397
398    def __truediv__(self, other):
399        return int(self) / int(other)
400
401    def __iadd__(self, other):
402        result = self.__add__(other)
403        self.sbvalue.SetValueFromCString (str(result))
404        return result
405
406    def __isub__(self, other):
407        result = self.__sub__(other)
408        self.sbvalue.SetValueFromCString (str(result))
409        return result
410
411    def __imul__(self, other):
412        result = self.__mul__(other)
413        self.sbvalue.SetValueFromCString (str(result))
414        return result
415
416    def __idiv__(self, other):
417        result = self.__div__(other)
418        self.sbvalue.SetValueFromCString (str(result))
419        return result
420
421    def __itruediv__(self, other):
422        result = self.__truediv__(other)
423        self.sbvalue.SetValueFromCString (str(result))
424        return result
425
426    def __ifloordiv__(self, other):
427        result =  self.__floordiv__(self, other)
428        self.sbvalue.SetValueFromCString (str(result))
429        return result
430
431    def __imod__(self, other):
432        result =  self.__and__(self, other)
433        self.sbvalue.SetValueFromCString (str(result))
434        return result
435
436    def __ipow__(self, other):
437        result = self.__pow__(self, other)
438        self.sbvalue.SetValueFromCString (str(result))
439        return result
440
441    def __ipow__(self, other, modulo):
442        result = self.__pow__(self, other, modulo)
443        self.sbvalue.SetValueFromCString (str(result))
444        return result
445
446    def __ilshift__(self, other):
447        result = self.__lshift__(other)
448        self.sbvalue.SetValueFromCString (str(result))
449        return result
450
451    def __irshift__(self, other):
452        result =  self.__rshift__(other)
453        self.sbvalue.SetValueFromCString (str(result))
454        return result
455
456    def __iand__(self, other):
457        result =  self.__and__(self, other)
458        self.sbvalue.SetValueFromCString (str(result))
459        return result
460
461    def __ixor__(self, other):
462        result =  self.__xor__(self, other)
463        self.sbvalue.SetValueFromCString (str(result))
464        return result
465
466    def __ior__(self, other):
467        result =  self.__ior__(self, other)
468        self.sbvalue.SetValueFromCString (str(result))
469        return result
470
471    def __neg__(self):
472        return -int(self)
473
474    def __pos__(self):
475        return +int(self)
476
477    def __abs__(self):
478        return abs(int(self))
479
480    def __invert__(self):
481        return ~int(self)
482
483    def __complex__(self):
484        return complex (int(self))
485
486    def __int__(self):
487        is_num,is_sign = is_numeric_type(self.sbvalue.GetType().GetCanonicalType().GetBasicType())
488        if is_num and not is_sign: return self.sbvalue.GetValueAsUnsigned()
489        return self.sbvalue.GetValueAsSigned()
490
491    def __long__(self):
492        return self.__int__()
493
494    def __float__(self):
495        return float (self.sbvalue.GetValueAsSigned())
496
497    def __oct__(self):
498        return '0%o' % self.sbvalue.GetValueAsUnsigned()
499
500    def __hex__(self):
501        return '0x%x' % self.sbvalue.GetValueAsUnsigned()
502
503    def __len__(self):
504        return self.sbvalue.GetNumChildren()
505
506    def __eq__(self, other):
507        if type(other) is int:
508                return int(self) == other
509        elif type(other) is str:
510                return str(self) == other
511        elif type(other) is value:
512                self_err = SBError()
513                other_err = SBError()
514                self_val = self.sbvalue.GetValueAsUnsigned(self_err)
515                if self_err.fail:
516                        raise ValueError("unable to extract value of self")
517                other_val = other.sbvalue.GetValueAsUnsigned(other_err)
518                if other_err.fail:
519                        raise ValueError("unable to extract value of other")
520                return self_val == other_val
521        raise TypeError("Unknown type %s, No equality operation defined." % str(type(other)))
522
523    def __ne__(self, other):
524        return not self.__eq__(other)
525%}
526
527%pythoncode %{
528
529class SBSyntheticValueProvider(object):
530    def __init__(self,valobj):
531        pass
532
533    def num_children(self):
534        return 0
535
536    def get_child_index(self,name):
537        return None
538
539    def get_child_at_index(self,idx):
540        return None
541
542    def update(self):
543        pass
544
545    def has_children(self):
546        return False
547
548
549%}
550
551%pythoncode %{
552
553# given an lldb.SBBasicType it returns a tuple
554# (is_numeric, is_signed)
555# the value of is_signed is undefined if is_numeric == false
556def is_numeric_type(basic_type):
557    if basic_type == eBasicTypeInvalid: return (False,False)
558    if basic_type == eBasicTypeVoid: return (False,False)
559    if basic_type == eBasicTypeChar: return (True,False)
560    if basic_type == eBasicTypeSignedChar: return (True,True)
561    if basic_type == eBasicTypeUnsignedChar: return (True,False)
562    if basic_type == eBasicTypeWChar: return (True,False)
563    if basic_type == eBasicTypeSignedWChar: return (True,True)
564    if basic_type == eBasicTypeUnsignedWChar: return (True,False)
565    if basic_type == eBasicTypeChar16: return (True,False)
566    if basic_type == eBasicTypeChar32: return (True,False)
567    if basic_type == eBasicTypeShort: return (True,True)
568    if basic_type == eBasicTypeUnsignedShort: return (True,False)
569    if basic_type == eBasicTypeInt: return (True,True)
570    if basic_type == eBasicTypeUnsignedInt: return (True,False)
571    if basic_type == eBasicTypeLong: return (True,True)
572    if basic_type == eBasicTypeUnsignedLong: return (True,False)
573    if basic_type == eBasicTypeLongLong: return (True,True)
574    if basic_type == eBasicTypeUnsignedLongLong: return (True,False)
575    if basic_type == eBasicTypeInt128: return (True,True)
576    if basic_type == eBasicTypeUnsignedInt128: return (True,False)
577    if basic_type == eBasicTypeBool: return (False,False)
578    if basic_type == eBasicTypeHalf: return (True,True)
579    if basic_type == eBasicTypeFloat: return (True,True)
580    if basic_type == eBasicTypeDouble: return (True,True)
581    if basic_type == eBasicTypeLongDouble: return (True,True)
582    if basic_type == eBasicTypeFloatComplex: return (True,True)
583    if basic_type == eBasicTypeDoubleComplex: return (True,True)
584    if basic_type == eBasicTypeLongDoubleComplex: return (True,True)
585    if basic_type == eBasicTypeObjCID: return (False,False)
586    if basic_type == eBasicTypeObjCClass: return (False,False)
587    if basic_type == eBasicTypeObjCSel: return (False,False)
588    if basic_type == eBasicTypeNullPtr: return (False,False)
589    #if basic_type == eBasicTypeOther:
590    return (False,False)
591
592%}
593