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