contrib/llvm-project/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     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
 313 class 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
 529 class 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
 556 def 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 %}