lldb/bindings/python/python-extensions.swig

   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
 271 def 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
 285 class 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
 292 class 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
 321 class 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
 537 class 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
 570 def 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 %}