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