Scalar.cpp revision 84cdc15005983e5244d665fa779e33c2b6fac95f
1//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "lldb/Core/Scalar.h" 11 12#include <math.h> 13 14#include "lldb/Interpreter/Args.h" 15#include "lldb/Core/Error.h" 16#include "lldb/Core/Stream.h" 17#include "lldb/Core/DataExtractor.h" 18 19using namespace lldb; 20using namespace lldb_private; 21 22//---------------------------------------------------------------------- 23// Promote to max type currently follows the ANSI C rule for type 24// promotion in expressions. 25//---------------------------------------------------------------------- 26static Scalar::Type 27PromoteToMaxType 28( 29 const Scalar& lhs, // The const left hand side object 30 const Scalar& rhs, // The const right hand side object 31 Scalar& temp_value, // A modifiable temp value than can be used to hold either the promoted lhs or rhs object 32 const Scalar* &promoted_lhs_ptr, // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted) 33 const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted) 34) 35{ 36 Scalar result; 37 // Initialize the promoted values for both the right and left hand side values 38 // to be the objects themselves. If no promotion is needed (both right and left 39 // have the same type), then the temp_value will not get used. 40 promoted_lhs_ptr = &lhs; 41 promoted_rhs_ptr = &rhs; 42 // Extract the types of both the right and left hand side values 43 Scalar::Type lhs_type = lhs.GetType(); 44 Scalar::Type rhs_type = rhs.GetType(); 45 46 if (lhs_type > rhs_type) 47 { 48 // Right hand side need to be promoted 49 temp_value = rhs; // Copy right hand side into the temp value 50 if (temp_value.Promote(lhs_type)) // Promote it 51 promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side 52 } 53 else if (lhs_type < rhs_type) 54 { 55 // Left hand side need to be promoted 56 temp_value = lhs; // Copy left hand side value into the temp value 57 if (temp_value.Promote(rhs_type)) // Promote it 58 promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side 59 } 60 61 // Make sure our type promotion worked as exptected 62 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType()) 63 return promoted_lhs_ptr->GetType(); // Return the resulting max type 64 65 // Return the void type (zero) if we fail to promote either of the values. 66 return Scalar::e_void; 67} 68 69 70//---------------------------------------------------------------------- 71// Scalar constructor 72//---------------------------------------------------------------------- 73Scalar::Scalar() : 74 m_type(e_void), 75 m_data() 76{ 77} 78 79//---------------------------------------------------------------------- 80// Scalar copy constructor 81//---------------------------------------------------------------------- 82Scalar::Scalar(const Scalar& rhs) : 83 m_type(rhs.m_type), 84 m_data(rhs.m_data) // TODO: verify that for C++ this will correctly copy the union?? 85{ 86} 87 88//Scalar::Scalar(const RegisterValue& reg) : 89// m_type(e_void), 90// m_data() 91//{ 92// switch (reg.info.encoding) 93// { 94// case eEncodingUint: // unsigned integer 95// switch (reg.info.byte_size) 96// { 97// case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break; 98// case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break; 99// case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break; 100// case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break; 101// break; 102// } 103// break; 104// 105// case eEncodingSint: // signed integer 106// switch (reg.info.byte_size) 107// { 108// case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break; 109// case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break; 110// case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break; 111// case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break; 112// break; 113// } 114// break; 115// 116// case eEncodingIEEE754: // float 117// switch (reg.info.byte_size) 118// { 119// case 4: m_type = e_float; m_data.flt = reg.value.float32; break; 120// case 8: m_type = e_double; m_data.dbl = reg.value.float64; break; 121// break; 122// } 123// break; 124// case eEncodingVector: // vector registers 125// break; 126// } 127//} 128 129bool 130Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const 131{ 132 size_t byte_size = GetByteSize(); 133 if (byte_size > 0) 134 { 135 if (limit_byte_size < byte_size) 136 { 137 if (eByteOrderHost == eByteOrderLittle) 138 { 139 // On little endian systems if we want fewer bytes from the 140 // current type we just specify fewer bytes since the LSByte 141 // is first... 142 data.SetData((uint8_t*)&m_data, limit_byte_size, eByteOrderHost); 143 } 144 else if (eByteOrderHost == eByteOrderBig) 145 { 146 // On big endian systems if we want fewer bytes from the 147 // current type have to advance our initial byte pointer and 148 // trim down the number of bytes since the MSByte is first 149 data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, eByteOrderHost); 150 } 151 } 152 else 153 { 154 // We want all of the data 155 data.SetData((uint8_t*)&m_data, byte_size, eByteOrderHost); 156 } 157 return true; 158 } 159 data.Clear(); 160 return false; 161} 162 163size_t 164Scalar::GetByteSize() const 165{ 166 switch (m_type) 167 { 168 default: 169 case e_void: 170 break; 171 case e_sint: return sizeof(m_data.sint); 172 case e_uint: return sizeof(m_data.uint); 173 case e_slong: return sizeof(m_data.slong); 174 case e_ulong: return sizeof(m_data.ulong); 175 case e_slonglong: return sizeof(m_data.slonglong); 176 case e_ulonglong: return sizeof(m_data.ulonglong); 177 case e_float: return sizeof(m_data.flt); 178 case e_double: return sizeof(m_data.dbl); 179 case e_long_double: return sizeof(m_data.ldbl); 180 } 181 return 0; 182} 183 184bool 185Scalar::IsZero() const 186{ 187 switch (m_type) 188 { 189 default: 190 case e_void: 191 break; 192 case e_sint: return m_data.sint == 0; 193 case e_uint: return m_data.uint == 0; 194 case e_slong: return m_data.slong == 0; 195 case e_ulong: return m_data.ulong == 0; 196 case e_slonglong: return m_data.slonglong == 0; 197 case e_ulonglong: return m_data.ulonglong == 0; 198 case e_float: return m_data.flt == 0.0f; 199 case e_double: return m_data.dbl == 0.0; 200 case e_long_double: return m_data.ldbl == 0.0; 201 } 202 return false; 203} 204 205void 206Scalar::GetValue (Stream *s, bool show_type) const 207{ 208 if (show_type) 209 s->Printf("(%s) ", GetTypeAsCString()); 210 211 switch (m_type) 212 { 213 case e_void: 214 default: 215 break; 216 case e_sint: s->Printf("%i", m_data.sint); break; 217 case e_uint: s->Printf("0x%8.8x", m_data.uint); break; 218 case e_slong: s->Printf("%li", m_data.slong); break; 219 case e_ulong: s->Printf("0x%8.8lx", m_data.ulong); break; 220 case e_slonglong: s->Printf("%lli", m_data.slonglong); break; 221 case e_ulonglong: s->Printf("0x%16.16llx", m_data.ulonglong); break; 222 case e_float: s->Printf("%f", m_data.flt); break; 223 case e_double: s->Printf("%g", m_data.dbl); break; 224 case e_long_double: s->Printf("%Lg", m_data.ldbl); break; 225 } 226} 227 228const char * 229Scalar::GetTypeAsCString() const 230{ 231 switch (m_type) 232 { 233 default: 234 break; 235 case e_void: return "void"; 236 case e_sint: return "int"; 237 case e_uint: return "unsigned int"; 238 case e_slong: return "long"; 239 case e_ulong: return "unsigned long"; 240 case e_slonglong: return "long long"; 241 case e_ulonglong: return "unsigned long long"; 242 case e_float: return "float"; 243 case e_double: return "double"; 244 case e_long_double: return "long double"; 245 } 246 return "<invalid Scalar type>"; 247} 248 249 250 251//---------------------------------------------------------------------- 252// Scalar copy constructor 253//---------------------------------------------------------------------- 254Scalar& 255Scalar::operator=(const Scalar& rhs) 256{ 257 if (this != &rhs) 258 { 259 m_type = rhs.m_type; 260 ::memcpy (&m_data, &rhs.m_data, sizeof(m_data)); 261 } 262 return *this; 263} 264 265Scalar& 266Scalar::operator= (const int v) 267{ 268 m_type = e_sint; 269 m_data.sint = v; 270 return *this; 271} 272 273 274Scalar& 275Scalar::operator= (unsigned int v) 276{ 277 m_type = e_uint; 278 m_data.uint = v; 279 return *this; 280} 281 282Scalar& 283Scalar::operator= (long v) 284{ 285 m_type = e_slong; 286 m_data.slong = v; 287 return *this; 288} 289 290Scalar& 291Scalar::operator= (unsigned long v) 292{ 293 m_type = e_ulong; 294 m_data.ulong = v; 295 return *this; 296} 297 298Scalar& 299Scalar::operator= (long long v) 300{ 301 m_type = e_slonglong; 302 m_data.slonglong = v; 303 return *this; 304} 305 306Scalar& 307Scalar::operator= (unsigned long long v) 308{ 309 m_type = e_ulonglong; 310 m_data.ulonglong = v; 311 return *this; 312} 313 314Scalar& 315Scalar::operator= (float v) 316{ 317 m_type = e_float; 318 m_data.flt = v; 319 return *this; 320} 321 322Scalar& 323Scalar::operator= (double v) 324{ 325 m_type = e_double; 326 m_data.dbl = v; 327 return *this; 328} 329 330Scalar& 331Scalar::operator= (long double v) 332{ 333 m_type = e_long_double; 334 m_data.ldbl = v; 335 return *this; 336} 337 338//---------------------------------------------------------------------- 339// Destructor 340//---------------------------------------------------------------------- 341Scalar::~Scalar() 342{ 343} 344 345bool 346Scalar::Promote(Scalar::Type type) 347{ 348 bool success = false; 349 switch (m_type) 350 { 351 case e_void: 352 break; 353 354 case e_sint: 355 switch (type) 356 { 357 default: 358 case e_void: break; 359 case e_sint: success = true; break; 360 case e_uint: m_data.uint = m_data.sint; success = true; break; 361 case e_slong: m_data.slong = m_data.sint; success = true; break; 362 case e_ulong: m_data.ulong = m_data.sint; success = true; break; 363 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break; 364 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break; 365 case e_float: m_data.flt = m_data.sint; success = true; break; 366 case e_double: m_data.dbl = m_data.sint; success = true; break; 367 case e_long_double: m_data.ldbl = m_data.sint; success = true; break; 368 } 369 break; 370 371 case e_uint: 372 switch (type) 373 { 374 default: 375 case e_void: 376 case e_sint: break; 377 case e_uint: success = true; break; 378 case e_slong: m_data.slong = m_data.uint; success = true; break; 379 case e_ulong: m_data.ulong = m_data.uint; success = true; break; 380 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break; 381 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break; 382 case e_float: m_data.flt = m_data.uint; success = true; break; 383 case e_double: m_data.dbl = m_data.uint; success = true; break; 384 case e_long_double: m_data.ldbl = m_data.uint; success = true; break; 385 } 386 break; 387 388 case e_slong: 389 switch (type) 390 { 391 default: 392 case e_void: 393 case e_sint: 394 case e_uint: break; 395 case e_slong: success = true; break; 396 case e_ulong: m_data.ulong = m_data.slong; success = true; break; 397 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break; 398 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break; 399 case e_float: m_data.flt = m_data.slong; success = true; break; 400 case e_double: m_data.dbl = m_data.slong; success = true; break; 401 case e_long_double: m_data.ldbl = m_data.slong; success = true; break; 402 } 403 break; 404 405 case e_ulong: 406 switch (type) 407 { 408 default: 409 case e_void: 410 case e_sint: 411 case e_uint: 412 case e_slong: break; 413 case e_ulong: success = true; break; 414 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break; 415 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break; 416 case e_float: m_data.flt = m_data.ulong; success = true; break; 417 case e_double: m_data.dbl = m_data.ulong; success = true; break; 418 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break; 419 } 420 break; 421 422 case e_slonglong: 423 switch (type) 424 { 425 default: 426 case e_void: 427 case e_sint: 428 case e_uint: 429 case e_slong: 430 case e_ulong: break; 431 case e_slonglong: success = true; break; 432 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break; 433 case e_float: m_data.flt = m_data.slonglong; success = true; break; 434 case e_double: m_data.dbl = m_data.slonglong; success = true; break; 435 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break; 436 } 437 break; 438 439 case e_ulonglong: 440 switch (type) 441 { 442 default: 443 case e_void: 444 case e_sint: 445 case e_uint: 446 case e_slong: 447 case e_ulong: 448 case e_slonglong: break; 449 case e_ulonglong: success = true; break; 450 case e_float: m_data.flt = m_data.ulonglong; success = true; break; 451 case e_double: m_data.dbl = m_data.ulonglong; success = true; break; 452 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; 453 } 454 break; 455 456 case e_float: 457 switch (type) 458 { 459 default: 460 case e_void: 461 case e_sint: 462 case e_uint: 463 case e_slong: 464 case e_ulong: 465 case e_slonglong: 466 case e_ulonglong: break; 467 case e_float: success = true; break; 468 case e_double: m_data.dbl = m_data.flt; success = true; break; 469 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; 470 } 471 break; 472 473 case e_double: 474 switch (type) 475 { 476 default: 477 case e_void: 478 case e_sint: 479 case e_uint: 480 case e_slong: 481 case e_ulong: 482 case e_slonglong: 483 case e_ulonglong: 484 case e_float: break; 485 case e_double: success = true; break; 486 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break; 487 } 488 break; 489 490 case e_long_double: 491 switch (type) 492 { 493 default: 494 case e_void: 495 case e_sint: 496 case e_uint: 497 case e_slong: 498 case e_ulong: 499 case e_slonglong: 500 case e_ulonglong: 501 case e_float: 502 case e_double: break; 503 case e_long_double: success = true; break; 504 } 505 break; 506 } 507 508 if (success) 509 m_type = type; 510 return success; 511} 512 513const char * 514Scalar::GetValueTypeAsCString (Scalar::Type type) 515{ 516 switch (type) 517 { 518 default: break; 519 case e_void: return "void"; 520 case e_sint: return "int"; 521 case e_uint: return "unsigned int"; 522 case e_slong: return "long"; 523 case e_ulong: return "unsigned long"; 524 case e_slonglong: return "long long"; 525 case e_ulonglong: return "unsigned long long"; 526 case e_float: return "float"; 527 case e_double: return "double"; 528 case e_long_double: return "long double"; 529 } 530 return "???"; 531} 532 533 534Scalar::Type 535Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size) 536{ 537 if (byte_size <= sizeof(int)) 538 return e_sint; 539 if (byte_size <= sizeof(long)) 540 return e_slong; 541 if (byte_size <= sizeof(long long)) 542 return e_slonglong; 543 return e_void; 544} 545 546Scalar::Type 547Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size) 548{ 549 if (byte_size <= sizeof(unsigned int)) 550 return e_uint; 551 if (byte_size <= sizeof(unsigned long)) 552 return e_ulong; 553 if (byte_size <= sizeof(unsigned long long)) 554 return e_ulonglong; 555 return e_void; 556} 557 558Scalar::Type 559Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size) 560{ 561 if (byte_size == sizeof(float)) 562 return e_float; 563 if (byte_size == sizeof(double)) 564 return e_double; 565 if (byte_size == sizeof(long double)) 566 return e_long_double; 567 return e_void; 568} 569 570bool 571Scalar::Cast(Scalar::Type type) 572{ 573 bool success = false; 574 switch (m_type) 575 { 576 case e_void: 577 break; 578 579 case e_sint: 580 switch (type) 581 { 582 default: 583 case e_void: break; 584 case e_sint: success = true; break; 585 case e_uint: m_data.uint = m_data.sint; success = true; break; 586 case e_slong: m_data.slong = m_data.sint; success = true; break; 587 case e_ulong: m_data.ulong = m_data.sint; success = true; break; 588 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break; 589 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break; 590 case e_float: m_data.flt = m_data.sint; success = true; break; 591 case e_double: m_data.dbl = m_data.sint; success = true; break; 592 case e_long_double: m_data.ldbl = m_data.sint; success = true; break; 593 } 594 break; 595 596 case e_uint: 597 switch (type) 598 { 599 default: 600 case e_void: 601 case e_sint: m_data.sint = m_data.uint; success = true; break; 602 case e_uint: success = true; break; 603 case e_slong: m_data.slong = m_data.uint; success = true; break; 604 case e_ulong: m_data.ulong = m_data.uint; success = true; break; 605 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break; 606 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break; 607 case e_float: m_data.flt = m_data.uint; success = true; break; 608 case e_double: m_data.dbl = m_data.uint; success = true; break; 609 case e_long_double: m_data.ldbl = m_data.uint; success = true; break; 610 } 611 break; 612 613 case e_slong: 614 switch (type) 615 { 616 default: 617 case e_void: 618 case e_sint: m_data.sint = m_data.slong; success = true; break; 619 case e_uint: m_data.uint = m_data.slong; success = true; break; 620 case e_slong: success = true; break; 621 case e_ulong: m_data.ulong = m_data.slong; success = true; break; 622 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break; 623 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break; 624 case e_float: m_data.flt = m_data.slong; success = true; break; 625 case e_double: m_data.dbl = m_data.slong; success = true; break; 626 case e_long_double: m_data.ldbl = m_data.slong; success = true; break; 627 } 628 break; 629 630 case e_ulong: 631 switch (type) 632 { 633 default: 634 case e_void: 635 case e_sint: m_data.sint = m_data.ulong; success = true; break; 636 case e_uint: m_data.uint = m_data.ulong; success = true; break; 637 case e_slong: m_data.slong = m_data.ulong; success = true; break; 638 case e_ulong: success = true; break; 639 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break; 640 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break; 641 case e_float: m_data.flt = m_data.ulong; success = true; break; 642 case e_double: m_data.dbl = m_data.ulong; success = true; break; 643 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break; 644 } 645 break; 646 647 case e_slonglong: 648 switch (type) 649 { 650 default: 651 case e_void: 652 case e_sint: m_data.sint = m_data.slonglong; success = true; break; 653 case e_uint: m_data.uint = m_data.slonglong; success = true; break; 654 case e_slong: m_data.slong = m_data.slonglong; success = true; break; 655 case e_ulong: m_data.ulong = m_data.slonglong; success = true; break; 656 case e_slonglong: success = true; break; 657 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break; 658 case e_float: m_data.flt = m_data.slonglong; success = true; break; 659 case e_double: m_data.dbl = m_data.slonglong; success = true; break; 660 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break; 661 } 662 break; 663 664 case e_ulonglong: 665 switch (type) 666 { 667 default: 668 case e_void: 669 case e_sint: m_data.sint = m_data.ulonglong; success = true; break; 670 case e_uint: m_data.uint = m_data.ulonglong; success = true; break; 671 case e_slong: m_data.slong = m_data.ulonglong; success = true; break; 672 case e_ulong: m_data.ulong = m_data.ulonglong; success = true; break; 673 case e_slonglong: m_data.slonglong = m_data.ulonglong; success = true; break; 674 case e_ulonglong: success = true; break; 675 case e_float: m_data.flt = m_data.ulonglong; success = true; break; 676 case e_double: m_data.dbl = m_data.ulonglong; success = true; break; 677 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; 678 } 679 break; 680 681 case e_float: 682 switch (type) 683 { 684 default: 685 case e_void: 686 case e_sint: m_data.sint = m_data.flt; success = true; break; 687 case e_uint: m_data.uint = m_data.flt; success = true; break; 688 case e_slong: m_data.slong = m_data.flt; success = true; break; 689 case e_ulong: m_data.ulong = m_data.flt; success = true; break; 690 case e_slonglong: m_data.slonglong = m_data.flt; success = true; break; 691 case e_ulonglong: m_data.ulonglong = m_data.flt; success = true; break; 692 case e_float: success = true; break; 693 case e_double: m_data.dbl = m_data.flt; success = true; break; 694 case e_long_double: m_data.ldbl = m_data.flt; success = true; break; 695 } 696 break; 697 698 case e_double: 699 switch (type) 700 { 701 default: 702 case e_void: 703 case e_sint: m_data.sint = m_data.dbl; success = true; break; 704 case e_uint: m_data.uint = m_data.dbl; success = true; break; 705 case e_slong: m_data.slong = m_data.dbl; success = true; break; 706 case e_ulong: m_data.ulong = m_data.dbl; success = true; break; 707 case e_slonglong: m_data.slonglong = m_data.dbl; success = true; break; 708 case e_ulonglong: m_data.ulonglong = m_data.dbl; success = true; break; 709 case e_float: m_data.flt = m_data.dbl; success = true; break; 710 case e_double: success = true; break; 711 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break; 712 } 713 break; 714 715 case e_long_double: 716 switch (type) 717 { 718 default: 719 case e_void: 720 case e_sint: m_data.sint = m_data.ldbl; success = true; break; 721 case e_uint: m_data.uint = m_data.ldbl; success = true; break; 722 case e_slong: m_data.slong = m_data.ldbl; success = true; break; 723 case e_ulong: m_data.ulong = m_data.ldbl; success = true; break; 724 case e_slonglong: m_data.slonglong = m_data.ldbl; success = true; break; 725 case e_ulonglong: m_data.ulonglong = m_data.ldbl; success = true; break; 726 case e_float: m_data.flt = m_data.ldbl; success = true; break; 727 case e_double: m_data.dbl = m_data.ldbl; success = true; break; 728 case e_long_double: success = true; break; 729 } 730 break; 731 } 732 733 if (success) 734 m_type = type; 735 return success; 736} 737 738int 739Scalar::SInt(int fail_value) const 740{ 741 switch (m_type) 742 { 743 default: 744 case e_void: break; 745 case e_sint: return m_data.sint; 746 case e_uint: return (int)m_data.uint; 747 case e_slong: return (int)m_data.slong; 748 case e_ulong: return (int)m_data.ulong; 749 case e_slonglong: return (int)m_data.slonglong; 750 case e_ulonglong: return (int)m_data.ulonglong; 751 case e_float: return (int)m_data.flt; 752 case e_double: return (int)m_data.dbl; 753 case e_long_double: return (int)m_data.ldbl; 754 } 755 return fail_value; 756} 757 758unsigned int 759Scalar::UInt(unsigned int fail_value) const 760{ 761 switch (m_type) 762 { 763 default: 764 case e_void: break; 765 case e_sint: return (unsigned int)m_data.sint; 766 case e_uint: return (unsigned int)m_data.uint; 767 case e_slong: return (unsigned int)m_data.slong; 768 case e_ulong: return (unsigned int)m_data.ulong; 769 case e_slonglong: return (unsigned int)m_data.slonglong; 770 case e_ulonglong: return (unsigned int)m_data.ulonglong; 771 case e_float: return (unsigned int)m_data.flt; 772 case e_double: return (unsigned int)m_data.dbl; 773 case e_long_double: return (unsigned int)m_data.ldbl; 774 } 775 return fail_value; 776} 777 778 779long 780Scalar::SLong(long fail_value) const 781{ 782 switch (m_type) 783 { 784 default: 785 case e_void: break; 786 case e_sint: return (long)m_data.sint; 787 case e_uint: return (long)m_data.uint; 788 case e_slong: return (long)m_data.slong; 789 case e_ulong: return (long)m_data.ulong; 790 case e_slonglong: return (long)m_data.slonglong; 791 case e_ulonglong: return (long)m_data.ulonglong; 792 case e_float: return (long)m_data.flt; 793 case e_double: return (long)m_data.dbl; 794 case e_long_double: return (long)m_data.ldbl; 795 } 796 return fail_value; 797} 798 799 800 801unsigned long 802Scalar::ULong(unsigned long fail_value) const 803{ 804 switch (m_type) 805 { 806 default: 807 case e_void: break; 808 case e_sint: return (unsigned long)m_data.sint; 809 case e_uint: return (unsigned long)m_data.uint; 810 case e_slong: return (unsigned long)m_data.slong; 811 case e_ulong: return (unsigned long)m_data.ulong; 812 case e_slonglong: return (unsigned long)m_data.slonglong; 813 case e_ulonglong: return (unsigned long)m_data.ulonglong; 814 case e_float: return (unsigned long)m_data.flt; 815 case e_double: return (unsigned long)m_data.dbl; 816 case e_long_double: return (unsigned long)m_data.ldbl; 817 } 818 return fail_value; 819} 820 821uint64_t 822Scalar::GetRawBits64(uint64_t fail_value) const 823{ 824 switch (m_type) 825 { 826 default: 827 case e_void: 828 break; 829 830 case e_sint: 831 case e_uint: 832 return m_data.uint; 833 834 case e_slong: 835 case e_ulong: 836 return m_data.ulong; 837 838 case e_slonglong: 839 case e_ulonglong: 840 return m_data.ulonglong; 841 842 case e_float: 843 if (sizeof(m_data.flt) == sizeof(int)) 844 return m_data.uint; 845 else if (sizeof(m_data.flt) == sizeof(unsigned long)) 846 return m_data.ulong; 847 else if (sizeof(m_data.flt) == sizeof(unsigned long long)) 848 return m_data.ulonglong; 849 break; 850 851 case e_double: 852 if (sizeof(m_data.dbl) == sizeof(int)) 853 return m_data.uint; 854 else if (sizeof(m_data.dbl) == sizeof(unsigned long)) 855 return m_data.ulong; 856 else if (sizeof(m_data.dbl) == sizeof(unsigned long long)) 857 return m_data.ulonglong; 858 break; 859 860 case e_long_double: 861 if (sizeof(m_data.ldbl) == sizeof(int)) 862 return m_data.uint; 863 else if (sizeof(m_data.ldbl) == sizeof(unsigned long)) 864 return m_data.ulong; 865 else if (sizeof(m_data.ldbl) == sizeof(unsigned long long)) 866 return m_data.ulonglong; 867 break; 868 } 869 return fail_value; 870} 871 872 873 874long long 875Scalar::SLongLong(long long fail_value) const 876{ 877 switch (m_type) 878 { 879 default: 880 case e_void: break; 881 case e_sint: return (long long)m_data.sint; 882 case e_uint: return (long long)m_data.uint; 883 case e_slong: return (long long)m_data.slong; 884 case e_ulong: return (long long)m_data.ulong; 885 case e_slonglong: return (long long)m_data.slonglong; 886 case e_ulonglong: return (long long)m_data.ulonglong; 887 case e_float: return (long long)m_data.flt; 888 case e_double: return (long long)m_data.dbl; 889 case e_long_double: return (long long)m_data.ldbl; 890 } 891 return fail_value; 892} 893 894 895unsigned long long 896Scalar::ULongLong(unsigned long long fail_value) const 897{ 898 switch (m_type) 899 { 900 default: 901 case e_void: break; 902 case e_sint: return (unsigned long long)m_data.sint; 903 case e_uint: return (unsigned long long)m_data.uint; 904 case e_slong: return (unsigned long long)m_data.slong; 905 case e_ulong: return (unsigned long long)m_data.ulong; 906 case e_slonglong: return (unsigned long long)m_data.slonglong; 907 case e_ulonglong: return (unsigned long long)m_data.ulonglong; 908 case e_float: return (unsigned long long)m_data.flt; 909 case e_double: return (unsigned long long)m_data.dbl; 910 case e_long_double: return (unsigned long long)m_data.ldbl; 911 } 912 return fail_value; 913} 914 915 916float 917Scalar::Float(float fail_value) const 918{ 919 switch (m_type) 920 { 921 default: 922 case e_void: break; 923 case e_sint: return (float)m_data.sint; 924 case e_uint: return (float)m_data.uint; 925 case e_slong: return (float)m_data.slong; 926 case e_ulong: return (float)m_data.ulong; 927 case e_slonglong: return (float)m_data.slonglong; 928 case e_ulonglong: return (float)m_data.ulonglong; 929 case e_float: return (float)m_data.flt; 930 case e_double: return (float)m_data.dbl; 931 case e_long_double: return (float)m_data.ldbl; 932 } 933 return fail_value; 934} 935 936 937double 938Scalar::Double(double fail_value) const 939{ 940 switch (m_type) 941 { 942 default: 943 case e_void: break; 944 case e_sint: return (double)m_data.sint; 945 case e_uint: return (double)m_data.uint; 946 case e_slong: return (double)m_data.slong; 947 case e_ulong: return (double)m_data.ulong; 948 case e_slonglong: return (double)m_data.slonglong; 949 case e_ulonglong: return (double)m_data.ulonglong; 950 case e_float: return (double)m_data.flt; 951 case e_double: return (double)m_data.dbl; 952 case e_long_double: return (double)m_data.ldbl; 953 } 954 return fail_value; 955} 956 957 958long double 959Scalar::LongDouble(long double fail_value) const 960{ 961 switch (m_type) 962 { 963 default: 964 case e_void: break; 965 case e_sint: return (long double)m_data.sint; 966 case e_uint: return (long double)m_data.uint; 967 case e_slong: return (long double)m_data.slong; 968 case e_ulong: return (long double)m_data.ulong; 969 case e_slonglong: return (long double)m_data.slonglong; 970 case e_ulonglong: return (long double)m_data.ulonglong; 971 case e_float: return (long double)m_data.flt; 972 case e_double: return (long double)m_data.dbl; 973 case e_long_double: return (long double)m_data.ldbl; 974 } 975 return fail_value; 976} 977 978 979Scalar& 980Scalar::operator+= (const Scalar& rhs) 981{ 982 Scalar temp_value; 983 const Scalar* a; 984 const Scalar* b; 985 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void) 986 { 987 switch (m_type) 988 { 989 default: 990 case e_void: break; 991 case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break; 992 case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break; 993 case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break; 994 case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; 995 case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; 996 case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; 997 case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break; 998 case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; 999 case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; 1000 } 1001 } 1002 return *this; 1003} 1004 1005Scalar& 1006Scalar::operator<<= (const Scalar& rhs) 1007{ 1008 switch (m_type) 1009 { 1010 default: 1011 case e_void: 1012 case e_float: 1013 case e_double: 1014 case e_long_double: 1015 m_type = e_void; 1016 break; 1017 1018 case e_sint: 1019 switch (rhs.m_type) 1020 { 1021 default: 1022 case e_void: 1023 case e_float: 1024 case e_double: 1025 case e_long_double: 1026 m_type = e_void; 1027 break; 1028 case e_sint: m_data.sint <<= rhs.m_data.sint; break; 1029 case e_uint: m_data.sint <<= rhs.m_data.uint; break; 1030 case e_slong: m_data.sint <<= rhs.m_data.slong; break; 1031 case e_ulong: m_data.sint <<= rhs.m_data.ulong; break; 1032 case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break; 1033 case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break; 1034 } 1035 break; 1036 1037 case e_uint: 1038 switch (rhs.m_type) 1039 { 1040 default: 1041 case e_void: 1042 case e_float: 1043 case e_double: 1044 case e_long_double: 1045 m_type = e_void; 1046 break; 1047 case e_sint: m_data.uint <<= rhs.m_data.sint; break; 1048 case e_uint: m_data.uint <<= rhs.m_data.uint; break; 1049 case e_slong: m_data.uint <<= rhs.m_data.slong; break; 1050 case e_ulong: m_data.uint <<= rhs.m_data.ulong; break; 1051 case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break; 1052 case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break; 1053 } 1054 break; 1055 1056 case e_slong: 1057 switch (rhs.m_type) 1058 { 1059 default: 1060 case e_void: 1061 case e_float: 1062 case e_double: 1063 case e_long_double: 1064 m_type = e_void; 1065 break; 1066 case e_sint: m_data.slong <<= rhs.m_data.sint; break; 1067 case e_uint: m_data.slong <<= rhs.m_data.uint; break; 1068 case e_slong: m_data.slong <<= rhs.m_data.slong; break; 1069 case e_ulong: m_data.slong <<= rhs.m_data.ulong; break; 1070 case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break; 1071 case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break; 1072 } 1073 break; 1074 1075 case e_ulong: 1076 switch (rhs.m_type) 1077 { 1078 default: 1079 case e_void: 1080 case e_float: 1081 case e_double: 1082 case e_long_double: 1083 m_type = e_void; 1084 break; 1085 case e_sint: m_data.ulong <<= rhs.m_data.sint; break; 1086 case e_uint: m_data.ulong <<= rhs.m_data.uint; break; 1087 case e_slong: m_data.ulong <<= rhs.m_data.slong; break; 1088 case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break; 1089 case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break; 1090 case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break; 1091 } 1092 break; 1093 case e_slonglong: 1094 switch (rhs.m_type) 1095 { 1096 default: 1097 case e_void: 1098 case e_float: 1099 case e_double: 1100 case e_long_double: 1101 m_type = e_void; 1102 break; 1103 case e_sint: m_data.slonglong <<= rhs.m_data.sint; break; 1104 case e_uint: m_data.slonglong <<= rhs.m_data.uint; break; 1105 case e_slong: m_data.slonglong <<= rhs.m_data.slong; break; 1106 case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break; 1107 case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break; 1108 case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break; 1109 } 1110 break; 1111 1112 case e_ulonglong: 1113 switch (rhs.m_type) 1114 { 1115 default: 1116 case e_void: 1117 case e_float: 1118 case e_double: 1119 case e_long_double: 1120 m_type = e_void; 1121 break; 1122 case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break; 1123 case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break; 1124 case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break; 1125 case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break; 1126 case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break; 1127 case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break; 1128 } 1129 break; 1130 } 1131 return *this; 1132} 1133 1134bool 1135Scalar::ShiftRightLogical(const Scalar& rhs) 1136{ 1137 switch (m_type) 1138 { 1139 default: 1140 case e_void: 1141 case e_float: 1142 case e_double: 1143 case e_long_double: 1144 m_type = e_void; 1145 break; 1146 1147 case e_sint: 1148 case e_uint: 1149 switch (rhs.m_type) 1150 { 1151 default: 1152 case e_void: 1153 case e_float: 1154 case e_double: 1155 case e_long_double: 1156 m_type = e_void; 1157 break; 1158 case e_sint: m_data.uint >>= rhs.m_data.sint; break; 1159 case e_uint: m_data.uint >>= rhs.m_data.uint; break; 1160 case e_slong: m_data.uint >>= rhs.m_data.slong; break; 1161 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; 1162 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; 1163 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; 1164 } 1165 break; 1166 1167 case e_slong: 1168 case e_ulong: 1169 switch (rhs.m_type) 1170 { 1171 default: 1172 case e_void: 1173 case e_float: 1174 case e_double: 1175 case e_long_double: 1176 m_type = e_void; 1177 break; 1178 case e_sint: m_data.ulong >>= rhs.m_data.sint; break; 1179 case e_uint: m_data.ulong >>= rhs.m_data.uint; break; 1180 case e_slong: m_data.ulong >>= rhs.m_data.slong; break; 1181 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; 1182 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; 1183 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; 1184 } 1185 break; 1186 1187 case e_slonglong: 1188 case e_ulonglong: 1189 switch (rhs.m_type) 1190 { 1191 default: 1192 case e_void: 1193 case e_float: 1194 case e_double: 1195 case e_long_double: 1196 m_type = e_void; 1197 break; 1198 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; 1199 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; 1200 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; 1201 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; 1202 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; 1203 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; 1204 } 1205 break; 1206 } 1207 return m_type != e_void; 1208} 1209 1210 1211Scalar& 1212Scalar::operator>>= (const Scalar& rhs) 1213{ 1214 switch (m_type) 1215 { 1216 default: 1217 case e_void: 1218 case e_float: 1219 case e_double: 1220 case e_long_double: 1221 m_type = e_void; 1222 break; 1223 1224 case e_sint: 1225 switch (rhs.m_type) 1226 { 1227 default: 1228 case e_void: 1229 case e_float: 1230 case e_double: 1231 case e_long_double: 1232 m_type = e_void; 1233 break; 1234 case e_sint: m_data.sint >>= rhs.m_data.sint; break; 1235 case e_uint: m_data.sint >>= rhs.m_data.uint; break; 1236 case e_slong: m_data.sint >>= rhs.m_data.slong; break; 1237 case e_ulong: m_data.sint >>= rhs.m_data.ulong; break; 1238 case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break; 1239 case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break; 1240 } 1241 break; 1242 1243 case e_uint: 1244 switch (rhs.m_type) 1245 { 1246 default: 1247 case e_void: 1248 case e_float: 1249 case e_double: 1250 case e_long_double: 1251 m_type = e_void; 1252 break; 1253 case e_sint: m_data.uint >>= rhs.m_data.sint; break; 1254 case e_uint: m_data.uint >>= rhs.m_data.uint; break; 1255 case e_slong: m_data.uint >>= rhs.m_data.slong; break; 1256 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; 1257 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; 1258 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; 1259 } 1260 break; 1261 1262 case e_slong: 1263 switch (rhs.m_type) 1264 { 1265 default: 1266 case e_void: 1267 case e_float: 1268 case e_double: 1269 case e_long_double: 1270 m_type = e_void; 1271 break; 1272 case e_sint: m_data.slong >>= rhs.m_data.sint; break; 1273 case e_uint: m_data.slong >>= rhs.m_data.uint; break; 1274 case e_slong: m_data.slong >>= rhs.m_data.slong; break; 1275 case e_ulong: m_data.slong >>= rhs.m_data.ulong; break; 1276 case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break; 1277 case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break; 1278 } 1279 break; 1280 1281 case e_ulong: 1282 switch (rhs.m_type) 1283 { 1284 default: 1285 case e_void: 1286 case e_float: 1287 case e_double: 1288 case e_long_double: 1289 m_type = e_void; 1290 break; 1291 case e_sint: m_data.ulong >>= rhs.m_data.sint; break; 1292 case e_uint: m_data.ulong >>= rhs.m_data.uint; break; 1293 case e_slong: m_data.ulong >>= rhs.m_data.slong; break; 1294 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; 1295 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; 1296 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; 1297 } 1298 break; 1299 case e_slonglong: 1300 switch (rhs.m_type) 1301 { 1302 default: 1303 case e_void: 1304 case e_float: 1305 case e_double: 1306 case e_long_double: 1307 m_type = e_void; 1308 break; 1309 case e_sint: m_data.slonglong >>= rhs.m_data.sint; break; 1310 case e_uint: m_data.slonglong >>= rhs.m_data.uint; break; 1311 case e_slong: m_data.slonglong >>= rhs.m_data.slong; break; 1312 case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break; 1313 case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break; 1314 case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break; 1315 } 1316 break; 1317 1318 case e_ulonglong: 1319 switch (rhs.m_type) 1320 { 1321 default: 1322 case e_void: 1323 case e_float: 1324 case e_double: 1325 case e_long_double: 1326 m_type = e_void; 1327 break; 1328 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; 1329 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; 1330 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; 1331 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; 1332 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; 1333 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; 1334 } 1335 break; 1336 } 1337 return *this; 1338} 1339 1340 1341Scalar& 1342Scalar::operator&= (const Scalar& rhs) 1343{ 1344 switch (m_type) 1345 { 1346 default: 1347 case e_void: 1348 case e_float: 1349 case e_double: 1350 case e_long_double: 1351 m_type = e_void; 1352 break; 1353 1354 case e_sint: 1355 switch (rhs.m_type) 1356 { 1357 default: 1358 case e_void: 1359 case e_float: 1360 case e_double: 1361 case e_long_double: 1362 m_type = e_void; 1363 break; 1364 case e_sint: m_data.sint &= rhs.m_data.sint; break; 1365 case e_uint: m_data.sint &= rhs.m_data.uint; break; 1366 case e_slong: m_data.sint &= rhs.m_data.slong; break; 1367 case e_ulong: m_data.sint &= rhs.m_data.ulong; break; 1368 case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break; 1369 case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break; 1370 } 1371 break; 1372 1373 case e_uint: 1374 switch (rhs.m_type) 1375 { 1376 default: 1377 case e_void: 1378 case e_float: 1379 case e_double: 1380 case e_long_double: 1381 m_type = e_void; 1382 break; 1383 case e_sint: m_data.uint &= rhs.m_data.sint; break; 1384 case e_uint: m_data.uint &= rhs.m_data.uint; break; 1385 case e_slong: m_data.uint &= rhs.m_data.slong; break; 1386 case e_ulong: m_data.uint &= rhs.m_data.ulong; break; 1387 case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break; 1388 case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break; 1389 } 1390 break; 1391 1392 case e_slong: 1393 switch (rhs.m_type) 1394 { 1395 default: 1396 case e_void: 1397 case e_float: 1398 case e_double: 1399 case e_long_double: 1400 m_type = e_void; 1401 break; 1402 case e_sint: m_data.slong &= rhs.m_data.sint; break; 1403 case e_uint: m_data.slong &= rhs.m_data.uint; break; 1404 case e_slong: m_data.slong &= rhs.m_data.slong; break; 1405 case e_ulong: m_data.slong &= rhs.m_data.ulong; break; 1406 case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break; 1407 case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break; 1408 } 1409 break; 1410 1411 case e_ulong: 1412 switch (rhs.m_type) 1413 { 1414 default: 1415 case e_void: 1416 case e_float: 1417 case e_double: 1418 case e_long_double: 1419 m_type = e_void; 1420 break; 1421 case e_sint: m_data.ulong &= rhs.m_data.sint; break; 1422 case e_uint: m_data.ulong &= rhs.m_data.uint; break; 1423 case e_slong: m_data.ulong &= rhs.m_data.slong; break; 1424 case e_ulong: m_data.ulong &= rhs.m_data.ulong; break; 1425 case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break; 1426 case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break; 1427 } 1428 break; 1429 case e_slonglong: 1430 switch (rhs.m_type) 1431 { 1432 default: 1433 case e_void: 1434 case e_float: 1435 case e_double: 1436 case e_long_double: 1437 m_type = e_void; 1438 break; 1439 case e_sint: m_data.slonglong &= rhs.m_data.sint; break; 1440 case e_uint: m_data.slonglong &= rhs.m_data.uint; break; 1441 case e_slong: m_data.slonglong &= rhs.m_data.slong; break; 1442 case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break; 1443 case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break; 1444 case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break; 1445 } 1446 break; 1447 1448 case e_ulonglong: 1449 switch (rhs.m_type) 1450 { 1451 default: 1452 case e_void: 1453 case e_float: 1454 case e_double: 1455 case e_long_double: 1456 m_type = e_void; 1457 break; 1458 case e_sint: m_data.ulonglong &= rhs.m_data.sint; break; 1459 case e_uint: m_data.ulonglong &= rhs.m_data.uint; break; 1460 case e_slong: m_data.ulonglong &= rhs.m_data.slong; break; 1461 case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break; 1462 case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break; 1463 case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break; 1464 } 1465 break; 1466 } 1467 return *this; 1468} 1469 1470 1471 1472bool 1473Scalar::AbsoluteValue() 1474{ 1475 switch (m_type) 1476 { 1477 default: 1478 case e_void: 1479 break; 1480 1481 case e_sint: 1482 if (m_data.sint < 0) 1483 m_data.sint = -m_data.sint; 1484 return true; 1485 1486 case e_slong: 1487 if (m_data.slong < 0) 1488 m_data.slong = -m_data.slong; 1489 return true; 1490 1491 case e_slonglong: 1492 if (m_data.slonglong < 0) 1493 m_data.slonglong = -m_data.slonglong; 1494 return true; 1495 1496 case e_uint: 1497 case e_ulong: 1498 case e_ulonglong: return true; 1499 case e_float: m_data.flt = fabsf(m_data.flt); return true; 1500 case e_double: m_data.dbl = fabs(m_data.dbl); return true; 1501 case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true; 1502 } 1503 return false; 1504} 1505 1506 1507bool 1508Scalar::UnaryNegate() 1509{ 1510 switch (m_type) 1511 { 1512 default: 1513 case e_void: break; 1514 case e_sint: m_data.sint = -m_data.sint; return true; 1515 case e_uint: m_data.uint = -m_data.uint; return true; 1516 case e_slong: m_data.slong = -m_data.slong; return true; 1517 case e_ulong: m_data.ulong = -m_data.ulong; return true; 1518 case e_slonglong: m_data.slonglong = -m_data.slonglong; return true; 1519 case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true; 1520 case e_float: m_data.flt = -m_data.flt; return true; 1521 case e_double: m_data.dbl = -m_data.dbl; return true; 1522 case e_long_double: m_data.ldbl = -m_data.ldbl; return true; 1523 } 1524 return false; 1525} 1526 1527bool 1528Scalar::OnesComplement() 1529{ 1530 switch (m_type) 1531 { 1532 case e_sint: m_data.sint = ~m_data.sint; return true; 1533 case e_uint: m_data.uint = ~m_data.uint; return true; 1534 case e_slong: m_data.slong = ~m_data.slong; return true; 1535 case e_ulong: m_data.ulong = ~m_data.ulong; return true; 1536 case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true; 1537 case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true; 1538 1539 default: 1540 case e_void: 1541 case e_float: 1542 case e_double: 1543 case e_long_double: 1544 break; 1545 } 1546 return false; 1547} 1548 1549 1550const Scalar 1551lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs) 1552{ 1553 Scalar result; 1554 Scalar temp_value; 1555 const Scalar* a; 1556 const Scalar* b; 1557 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1558 { 1559 switch (result.m_type) 1560 { 1561 default: 1562 case Scalar::e_void: break; 1563 case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break; 1564 case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break; 1565 case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break; 1566 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; 1567 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; 1568 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; 1569 case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break; 1570 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; 1571 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; 1572 } 1573 } 1574 return result; 1575} 1576 1577 1578const Scalar 1579lldb_private::operator- (const Scalar& lhs, const Scalar& rhs) 1580{ 1581 Scalar result; 1582 Scalar temp_value; 1583 const Scalar* a; 1584 const Scalar* b; 1585 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1586 { 1587 switch (result.m_type) 1588 { 1589 default: 1590 case Scalar::e_void: break; 1591 case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break; 1592 case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break; 1593 case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break; 1594 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break; 1595 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break; 1596 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break; 1597 case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break; 1598 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break; 1599 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break; 1600 } 1601 } 1602 return result; 1603} 1604 1605const Scalar 1606lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs) 1607{ 1608 Scalar result; 1609 Scalar temp_value; 1610 const Scalar* a; 1611 const Scalar* b; 1612 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1613 { 1614 switch (result.m_type) 1615 { 1616 default: 1617 case Scalar::e_void: break; 1618 1619 case Scalar::e_sint: if (b->m_data.sint != 0) { result.m_data.sint = a->m_data.sint/ b->m_data.sint; return result; } break; 1620 case Scalar::e_uint: if (b->m_data.uint != 0) { result.m_data.uint = a->m_data.uint / b->m_data.uint; return result; } break; 1621 case Scalar::e_slong: if (b->m_data.slong != 0) { result.m_data.slong = a->m_data.slong / b->m_data.slong; return result; } break; 1622 case Scalar::e_ulong: if (b->m_data.ulong != 0) { result.m_data.ulong = a->m_data.ulong / b->m_data.ulong; return result; } break; 1623 case Scalar::e_slonglong: if (b->m_data.slonglong != 0) { result.m_data.slonglong = a->m_data.slonglong / b->m_data.slonglong; return result; } break; 1624 case Scalar::e_ulonglong: if (b->m_data.ulonglong != 0) { result.m_data.ulonglong = a->m_data.ulonglong / b->m_data.ulonglong; return result; } break; 1625 case Scalar::e_float: if (b->m_data.flt != 0.0f) { result.m_data.flt = a->m_data.flt / b->m_data.flt; return result; } break; 1626 case Scalar::e_double: if (b->m_data.dbl != 0.0) { result.m_data.dbl = a->m_data.dbl / b->m_data.dbl; return result; } break; 1627 case Scalar::e_long_double: if (b->m_data.ldbl != 0.0) { result.m_data.ldbl = a->m_data.ldbl / b->m_data.ldbl; return result; } break; 1628 } 1629 } 1630 // For division only, the only way it should make it here is if a promotion failed, 1631 // or if we are trying to do a divide by zero. 1632 result.m_type = Scalar::e_void; 1633 return result; 1634} 1635 1636const Scalar 1637lldb_private::operator* (const Scalar& lhs, const Scalar& rhs) 1638{ 1639 Scalar result; 1640 Scalar temp_value; 1641 const Scalar* a; 1642 const Scalar* b; 1643 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1644 { 1645 switch (result.m_type) 1646 { 1647 default: 1648 case Scalar::e_void: break; 1649 case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break; 1650 case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break; 1651 case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break; 1652 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break; 1653 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break; 1654 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break; 1655 case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break; 1656 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break; 1657 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break; 1658 } 1659 } 1660 return result; 1661} 1662 1663const Scalar 1664lldb_private::operator& (const Scalar& lhs, const Scalar& rhs) 1665{ 1666 Scalar result; 1667 Scalar temp_value; 1668 const Scalar* a; 1669 const Scalar* b; 1670 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1671 { 1672 switch (result.m_type) 1673 { 1674 case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break; 1675 case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break; 1676 case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break; 1677 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break; 1678 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break; 1679 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break; 1680 1681 default: 1682 case Scalar::e_void: 1683 case Scalar::e_float: 1684 case Scalar::e_double: 1685 case Scalar::e_long_double: 1686 // No bitwise AND on floats, doubles of long doubles 1687 result.m_type = Scalar::e_void; 1688 break; 1689 } 1690 } 1691 return result; 1692} 1693 1694const Scalar 1695lldb_private::operator| (const Scalar& lhs, const Scalar& rhs) 1696{ 1697 Scalar result; 1698 Scalar temp_value; 1699 const Scalar* a; 1700 const Scalar* b; 1701 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1702 { 1703 switch (result.m_type) 1704 { 1705 case Scalar::e_sint: result.m_data.sint = a->m_data.sint | b->m_data.sint; break; 1706 case Scalar::e_uint: result.m_data.uint = a->m_data.uint | b->m_data.uint; break; 1707 case Scalar::e_slong: result.m_data.slong = a->m_data.slong | b->m_data.slong; break; 1708 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong | b->m_data.ulong; break; 1709 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong | b->m_data.slonglong; break; 1710 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong | b->m_data.ulonglong; break; 1711 1712 default: 1713 case Scalar::e_void: 1714 case Scalar::e_float: 1715 case Scalar::e_double: 1716 case Scalar::e_long_double: 1717 // No bitwise AND on floats, doubles of long doubles 1718 result.m_type = Scalar::e_void; 1719 break; 1720 } 1721 } 1722 return result; 1723} 1724 1725const Scalar 1726lldb_private::operator% (const Scalar& lhs, const Scalar& rhs) 1727{ 1728 Scalar result; 1729 Scalar temp_value; 1730 const Scalar* a; 1731 const Scalar* b; 1732 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1733 { 1734 switch (result.m_type) 1735 { 1736 case Scalar::e_sint: result.m_data.sint = a->m_data.sint % b->m_data.sint; break; 1737 case Scalar::e_uint: result.m_data.uint = a->m_data.uint % b->m_data.uint; break; 1738 case Scalar::e_slong: result.m_data.slong = a->m_data.slong % b->m_data.slong; break; 1739 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong % b->m_data.ulong; break; 1740 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong % b->m_data.slonglong; break; 1741 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong % b->m_data.ulonglong; break; 1742 1743 default: 1744 case Scalar::e_void: 1745 case Scalar::e_float: 1746 case Scalar::e_double: 1747 case Scalar::e_long_double: 1748 // No bitwise AND on floats, doubles of long doubles 1749 result.m_type = Scalar::e_void; 1750 break; 1751 } 1752 } 1753 return result; 1754} 1755 1756const Scalar 1757lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs) 1758{ 1759 Scalar result; 1760 Scalar temp_value; 1761 const Scalar* a; 1762 const Scalar* b; 1763 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1764 { 1765 switch (result.m_type) 1766 { 1767 case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break; 1768 case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break; 1769 case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break; 1770 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break; 1771 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break; 1772 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break; 1773 1774 default: 1775 case Scalar::e_void: 1776 case Scalar::e_float: 1777 case Scalar::e_double: 1778 case Scalar::e_long_double: 1779 // No bitwise AND on floats, doubles of long doubles 1780 result.m_type = Scalar::e_void; 1781 break; 1782 } 1783 } 1784 return result; 1785} 1786 1787// Return the raw unsigned integer without any casting or conversion 1788unsigned int 1789Scalar::RawUInt () const 1790{ 1791 return m_data.uint; 1792} 1793 1794// Return the raw unsigned long without any casting or conversion 1795unsigned long 1796Scalar::RawULong () const 1797{ 1798 return m_data.ulong; 1799} 1800 1801// Return the raw unsigned long long without any casting or conversion 1802unsigned long long 1803Scalar::RawULongLong () const 1804{ 1805 return m_data.ulonglong; 1806} 1807 1808 1809Error 1810Scalar::SetValueFromCString (const char *value_str, Encoding encoding, uint32_t byte_size) 1811{ 1812 Error error; 1813 if (value_str == NULL && value_str[0] == '\0') 1814 { 1815 error.SetErrorString ("Invalid c-string value string."); 1816 return error; 1817 } 1818 bool success = false; 1819 switch (encoding) 1820 { 1821 default: 1822 case eEncodingInvalid: 1823 error.SetErrorString ("Invalid encoding."); 1824 break; 1825 1826 case eEncodingUint: 1827 if (byte_size <= sizeof (unsigned long long)) 1828 { 1829 uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success); 1830 if (!success) 1831 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value.\n", value_str); 1832 else if (!UIntValueIsValidForSize (uval64, byte_size)) 1833 error.SetErrorStringWithFormat ("Value 0x%llx is too large to fit in a %u byte unsigned integer value.\n", uval64, byte_size); 1834 else 1835 { 1836 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size); 1837 switch (m_type) 1838 { 1839 case e_uint: m_data.uint = uval64; break; 1840 case e_ulong: m_data.ulong = uval64; break; 1841 case e_ulonglong: m_data.ulonglong = uval64; break; 1842 default: 1843 error.SetErrorStringWithFormat ("Unsupported unsigned integer byte size: %u.\n", byte_size); 1844 break; 1845 } 1846 } 1847 } 1848 else 1849 { 1850 error.SetErrorStringWithFormat ("Unsupported unsigned integer byte size: %u.\n", byte_size); 1851 return error; 1852 } 1853 break; 1854 1855 case eEncodingSint: 1856 if (byte_size <= sizeof (long long)) 1857 { 1858 uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success); 1859 if (!success) 1860 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value.\n", value_str); 1861 else if (!SIntValueIsValidForSize (sval64, byte_size)) 1862 error.SetErrorStringWithFormat ("Value 0x%llx is too large to fit in a %u byte signed integer value.\n", sval64, byte_size); 1863 else 1864 { 1865 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size); 1866 switch (m_type) 1867 { 1868 case e_sint: m_data.sint = sval64; break; 1869 case e_slong: m_data.slong = sval64; break; 1870 case e_slonglong: m_data.slonglong = sval64; break; 1871 default: 1872 error.SetErrorStringWithFormat ("Unsupported signed integer byte size: %u.\n", byte_size); 1873 break; 1874 } 1875 } 1876 } 1877 else 1878 { 1879 error.SetErrorStringWithFormat ("Unsupported signed integer byte size: %u.\n", byte_size); 1880 return error; 1881 } 1882 break; 1883 1884 case eEncodingIEEE754: 1885 if (byte_size == sizeof (float)) 1886 { 1887 if (::sscanf (value_str, "%f", &m_data.flt) == 1) 1888 m_type = e_float; 1889 else 1890 error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str); 1891 } 1892 else if (byte_size == sizeof (double)) 1893 { 1894 if (::sscanf (value_str, "%lf", &m_data.dbl) == 1) 1895 m_type = e_double; 1896 else 1897 error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str); 1898 } 1899 else if (byte_size == sizeof (long double)) 1900 { 1901 if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1) 1902 m_type = e_long_double; 1903 else 1904 error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str); 1905 } 1906 else 1907 { 1908 error.SetErrorStringWithFormat ("Unsupported float byte size: %u.\n", byte_size); 1909 return error; 1910 } 1911 break; 1912 1913 case eEncodingVector: 1914 error.SetErrorString ("Vector encoding unsupported."); 1915 break; 1916 } 1917 if (error.Fail()) 1918 m_type = e_void; 1919 1920 return error; 1921} 1922 1923bool 1924lldb_private::operator== (const Scalar& lhs, const Scalar& rhs) 1925{ 1926 // If either entry is void then we can just compare the types 1927 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 1928 return lhs.m_type == rhs.m_type; 1929 1930 Scalar temp_value; 1931 const Scalar* a; 1932 const Scalar* b; 1933 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 1934 { 1935 default: 1936 case Scalar::e_void: break; 1937 case Scalar::e_sint: return a->m_data.sint == b->m_data.sint; 1938 case Scalar::e_uint: return a->m_data.uint == b->m_data.uint; 1939 case Scalar::e_slong: return a->m_data.slong == b->m_data.slong; 1940 case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong; 1941 case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong; 1942 case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong; 1943 case Scalar::e_float: return a->m_data.flt == b->m_data.flt; 1944 case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl; 1945 case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl; 1946 } 1947 return false; 1948} 1949 1950bool 1951lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs) 1952{ 1953 // If either entry is void then we can just compare the types 1954 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 1955 return lhs.m_type != rhs.m_type; 1956 1957 Scalar temp_value; // A temp value that might get a copy of either promoted value 1958 const Scalar* a; 1959 const Scalar* b; 1960 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 1961 { 1962 default: 1963 case Scalar::e_void: break; 1964 case Scalar::e_sint: return a->m_data.sint != b->m_data.sint; 1965 case Scalar::e_uint: return a->m_data.uint != b->m_data.uint; 1966 case Scalar::e_slong: return a->m_data.slong != b->m_data.slong; 1967 case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong; 1968 case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong; 1969 case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong; 1970 case Scalar::e_float: return a->m_data.flt != b->m_data.flt; 1971 case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl; 1972 case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl; 1973 } 1974 return true; 1975} 1976 1977bool 1978lldb_private::operator< (const Scalar& lhs, const Scalar& rhs) 1979{ 1980 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 1981 return false; 1982 1983 Scalar temp_value; 1984 const Scalar* a; 1985 const Scalar* b; 1986 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 1987 { 1988 default: 1989 case Scalar::e_void: break; 1990 case Scalar::e_sint: return a->m_data.sint < b->m_data.sint; 1991 case Scalar::e_uint: return a->m_data.uint < b->m_data.uint; 1992 case Scalar::e_slong: return a->m_data.slong < b->m_data.slong; 1993 case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong; 1994 case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong; 1995 case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong; 1996 case Scalar::e_float: return a->m_data.flt < b->m_data.flt; 1997 case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl; 1998 case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl; 1999 } 2000 return false; 2001} 2002 2003bool 2004lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs) 2005{ 2006 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2007 return false; 2008 2009 Scalar temp_value; 2010 const Scalar* a; 2011 const Scalar* b; 2012 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2013 { 2014 default: 2015 case Scalar::e_void: break; 2016 case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint; 2017 case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint; 2018 case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong; 2019 case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong; 2020 case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong; 2021 case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong; 2022 case Scalar::e_float: return a->m_data.flt <= b->m_data.flt; 2023 case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl; 2024 case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl; 2025 } 2026 return false; 2027} 2028 2029 2030bool 2031lldb_private::operator> (const Scalar& lhs, const Scalar& rhs) 2032{ 2033 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2034 return false; 2035 2036 Scalar temp_value; 2037 const Scalar* a; 2038 const Scalar* b; 2039 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2040 { 2041 default: 2042 case Scalar::e_void: break; 2043 case Scalar::e_sint: return a->m_data.sint > b->m_data.sint; 2044 case Scalar::e_uint: return a->m_data.uint > b->m_data.uint; 2045 case Scalar::e_slong: return a->m_data.slong > b->m_data.slong; 2046 case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong; 2047 case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong; 2048 case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong; 2049 case Scalar::e_float: return a->m_data.flt > b->m_data.flt; 2050 case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl; 2051 case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl; 2052 } 2053 return false; 2054} 2055 2056bool 2057lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs) 2058{ 2059 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2060 return false; 2061 2062 Scalar temp_value; 2063 const Scalar* a; 2064 const Scalar* b; 2065 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2066 { 2067 default: 2068 case Scalar::e_void: break; 2069 case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint; 2070 case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint; 2071 case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong; 2072 case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong; 2073 case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong; 2074 case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong; 2075 case Scalar::e_float: return a->m_data.flt >= b->m_data.flt; 2076 case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl; 2077 case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl; 2078 } 2079 return false; 2080} 2081 2082 2083 2084 2085