1254721Semaste//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste#include "lldb/Core/Scalar.h" 11254721Semaste 12254721Semaste#include <math.h> 13254721Semaste#include <inttypes.h> 14254721Semaste 15254721Semaste#include "lldb/Interpreter/Args.h" 16254721Semaste#include "lldb/Core/Error.h" 17254721Semaste#include "lldb/Core/Stream.h" 18254721Semaste#include "lldb/Core/DataExtractor.h" 19254721Semaste#include "lldb/Host/Endian.h" 20254721Semaste 21254721Semaste#include "Plugins/Process/Utility/InstructionUtils.h" 22254721Semaste 23254721Semasteusing namespace lldb; 24254721Semasteusing namespace lldb_private; 25254721Semaste 26254721Semaste//---------------------------------------------------------------------- 27254721Semaste// Promote to max type currently follows the ANSI C rule for type 28254721Semaste// promotion in expressions. 29254721Semaste//---------------------------------------------------------------------- 30254721Semastestatic Scalar::Type 31254721SemastePromoteToMaxType 32254721Semaste( 33254721Semaste const Scalar& lhs, // The const left hand side object 34254721Semaste const Scalar& rhs, // The const right hand side object 35254721Semaste Scalar& temp_value, // A modifiable temp value than can be used to hold either the promoted lhs or rhs object 36254721Semaste const Scalar* &promoted_lhs_ptr, // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted) 37254721Semaste const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted) 38254721Semaste) 39254721Semaste{ 40254721Semaste Scalar result; 41254721Semaste // Initialize the promoted values for both the right and left hand side values 42254721Semaste // to be the objects themselves. If no promotion is needed (both right and left 43254721Semaste // have the same type), then the temp_value will not get used. 44254721Semaste promoted_lhs_ptr = &lhs; 45254721Semaste promoted_rhs_ptr = &rhs; 46254721Semaste // Extract the types of both the right and left hand side values 47254721Semaste Scalar::Type lhs_type = lhs.GetType(); 48254721Semaste Scalar::Type rhs_type = rhs.GetType(); 49254721Semaste 50254721Semaste if (lhs_type > rhs_type) 51254721Semaste { 52254721Semaste // Right hand side need to be promoted 53254721Semaste temp_value = rhs; // Copy right hand side into the temp value 54254721Semaste if (temp_value.Promote(lhs_type)) // Promote it 55254721Semaste promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side 56254721Semaste } 57254721Semaste else if (lhs_type < rhs_type) 58254721Semaste { 59254721Semaste // Left hand side need to be promoted 60254721Semaste temp_value = lhs; // Copy left hand side value into the temp value 61254721Semaste if (temp_value.Promote(rhs_type)) // Promote it 62254721Semaste promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side 63254721Semaste } 64254721Semaste 65254721Semaste // Make sure our type promotion worked as exptected 66254721Semaste if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType()) 67254721Semaste return promoted_lhs_ptr->GetType(); // Return the resulting max type 68254721Semaste 69254721Semaste // Return the void type (zero) if we fail to promote either of the values. 70254721Semaste return Scalar::e_void; 71254721Semaste} 72254721Semaste 73254721Semaste 74254721Semaste//---------------------------------------------------------------------- 75254721Semaste// Scalar constructor 76254721Semaste//---------------------------------------------------------------------- 77254721SemasteScalar::Scalar() : 78254721Semaste m_type(e_void), 79254721Semaste m_data() 80254721Semaste{ 81254721Semaste} 82254721Semaste 83254721Semaste//---------------------------------------------------------------------- 84254721Semaste// Scalar copy constructor 85254721Semaste//---------------------------------------------------------------------- 86254721SemasteScalar::Scalar(const Scalar& rhs) : 87254721Semaste m_type(rhs.m_type), 88254721Semaste m_data(rhs.m_data) // TODO: verify that for C++ this will correctly copy the union?? 89254721Semaste{ 90254721Semaste} 91254721Semaste 92254721Semaste//Scalar::Scalar(const RegisterValue& reg) : 93254721Semaste// m_type(e_void), 94254721Semaste// m_data() 95254721Semaste//{ 96254721Semaste// switch (reg.info.encoding) 97254721Semaste// { 98254721Semaste// case eEncodingUint: // unsigned integer 99254721Semaste// switch (reg.info.byte_size) 100254721Semaste// { 101254721Semaste// case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break; 102254721Semaste// case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break; 103254721Semaste// case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break; 104254721Semaste// case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break; 105254721Semaste// break; 106254721Semaste// } 107254721Semaste// break; 108254721Semaste// 109254721Semaste// case eEncodingSint: // signed integer 110254721Semaste// switch (reg.info.byte_size) 111254721Semaste// { 112254721Semaste// case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break; 113254721Semaste// case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break; 114254721Semaste// case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break; 115254721Semaste// case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break; 116254721Semaste// break; 117254721Semaste// } 118254721Semaste// break; 119254721Semaste// 120254721Semaste// case eEncodingIEEE754: // float 121254721Semaste// switch (reg.info.byte_size) 122254721Semaste// { 123254721Semaste// case 4: m_type = e_float; m_data.flt = reg.value.float32; break; 124254721Semaste// case 8: m_type = e_double; m_data.dbl = reg.value.float64; break; 125254721Semaste// break; 126254721Semaste// } 127254721Semaste// break; 128254721Semaste// case eEncodingVector: // vector registers 129254721Semaste// break; 130254721Semaste// } 131254721Semaste//} 132254721Semaste 133254721Semastebool 134254721SemasteScalar::GetData (DataExtractor &data, size_t limit_byte_size) const 135254721Semaste{ 136254721Semaste size_t byte_size = GetByteSize(); 137254721Semaste if (byte_size > 0) 138254721Semaste { 139254721Semaste if (limit_byte_size < byte_size) 140254721Semaste { 141254721Semaste if (lldb::endian::InlHostByteOrder() == eByteOrderLittle) 142254721Semaste { 143254721Semaste // On little endian systems if we want fewer bytes from the 144254721Semaste // current type we just specify fewer bytes since the LSByte 145254721Semaste // is first... 146254721Semaste data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder()); 147254721Semaste } 148254721Semaste else if (lldb::endian::InlHostByteOrder() == eByteOrderBig) 149254721Semaste { 150254721Semaste // On big endian systems if we want fewer bytes from the 151254721Semaste // current type have to advance our initial byte pointer and 152254721Semaste // trim down the number of bytes since the MSByte is first 153254721Semaste data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder()); 154254721Semaste } 155254721Semaste } 156254721Semaste else 157254721Semaste { 158254721Semaste // We want all of the data 159254721Semaste data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder()); 160254721Semaste } 161254721Semaste return true; 162254721Semaste } 163254721Semaste data.Clear(); 164254721Semaste return false; 165254721Semaste} 166254721Semaste 167254721Semastesize_t 168254721SemasteScalar::GetByteSize() const 169254721Semaste{ 170254721Semaste switch (m_type) 171254721Semaste { 172254721Semaste case e_void: 173254721Semaste break; 174254721Semaste case e_sint: return sizeof(m_data.sint); 175254721Semaste case e_uint: return sizeof(m_data.uint); 176254721Semaste case e_slong: return sizeof(m_data.slong); 177254721Semaste case e_ulong: return sizeof(m_data.ulong); 178254721Semaste case e_slonglong: return sizeof(m_data.slonglong); 179254721Semaste case e_ulonglong: return sizeof(m_data.ulonglong); 180254721Semaste case e_float: return sizeof(m_data.flt); 181254721Semaste case e_double: return sizeof(m_data.dbl); 182254721Semaste case e_long_double: return sizeof(m_data.ldbl); 183254721Semaste } 184254721Semaste return 0; 185254721Semaste} 186254721Semaste 187254721Semastebool 188254721SemasteScalar::IsZero() const 189254721Semaste{ 190254721Semaste switch (m_type) 191254721Semaste { 192254721Semaste case e_void: 193254721Semaste break; 194254721Semaste case e_sint: return m_data.sint == 0; 195254721Semaste case e_uint: return m_data.uint == 0; 196254721Semaste case e_slong: return m_data.slong == 0; 197254721Semaste case e_ulong: return m_data.ulong == 0; 198254721Semaste case e_slonglong: return m_data.slonglong == 0; 199254721Semaste case e_ulonglong: return m_data.ulonglong == 0; 200254721Semaste case e_float: return m_data.flt == 0.0f; 201254721Semaste case e_double: return m_data.dbl == 0.0; 202254721Semaste case e_long_double: return m_data.ldbl == 0.0; 203254721Semaste } 204254721Semaste return false; 205254721Semaste} 206254721Semaste 207254721Semastevoid 208254721SemasteScalar::GetValue (Stream *s, bool show_type) const 209254721Semaste{ 210254721Semaste if (show_type) 211254721Semaste s->Printf("(%s) ", GetTypeAsCString()); 212254721Semaste 213254721Semaste switch (m_type) 214254721Semaste { 215254721Semaste case e_void: 216254721Semaste break; 217254721Semaste case e_sint: s->Printf("%i", m_data.sint); break; 218254721Semaste case e_uint: s->Printf("0x%8.8x", m_data.uint); break; 219254721Semaste case e_slong: s->Printf("%li", m_data.slong); break; 220254721Semaste case e_ulong: s->Printf("0x%8.8lx", m_data.ulong); break; 221254721Semaste case e_slonglong: s->Printf("%lli", m_data.slonglong); break; 222254721Semaste case e_ulonglong: s->Printf("0x%16.16llx", m_data.ulonglong); break; 223254721Semaste case e_float: s->Printf("%f", m_data.flt); break; 224254721Semaste case e_double: s->Printf("%g", m_data.dbl); break; 225254721Semaste case e_long_double: s->Printf("%Lg", m_data.ldbl); break; 226254721Semaste } 227254721Semaste} 228254721Semaste 229254721Semasteconst char * 230254721SemasteScalar::GetTypeAsCString() const 231254721Semaste{ 232254721Semaste switch (m_type) 233254721Semaste { 234254721Semaste case e_void: return "void"; 235254721Semaste case e_sint: return "int"; 236254721Semaste case e_uint: return "unsigned int"; 237254721Semaste case e_slong: return "long"; 238254721Semaste case e_ulong: return "unsigned long"; 239254721Semaste case e_slonglong: return "long long"; 240254721Semaste case e_ulonglong: return "unsigned long long"; 241254721Semaste case e_float: return "float"; 242254721Semaste case e_double: return "double"; 243254721Semaste case e_long_double: return "long double"; 244254721Semaste } 245254721Semaste return "<invalid Scalar type>"; 246254721Semaste} 247254721Semaste 248254721Semaste 249254721Semaste 250254721Semaste//---------------------------------------------------------------------- 251254721Semaste// Scalar copy constructor 252254721Semaste//---------------------------------------------------------------------- 253254721SemasteScalar& 254254721SemasteScalar::operator=(const Scalar& rhs) 255254721Semaste{ 256254721Semaste if (this != &rhs) 257254721Semaste { 258254721Semaste m_type = rhs.m_type; 259254721Semaste ::memcpy (&m_data, &rhs.m_data, sizeof(m_data)); 260254721Semaste } 261254721Semaste return *this; 262254721Semaste} 263254721Semaste 264254721SemasteScalar& 265254721SemasteScalar::operator= (const int v) 266254721Semaste{ 267254721Semaste m_type = e_sint; 268254721Semaste m_data.sint = v; 269254721Semaste return *this; 270254721Semaste} 271254721Semaste 272254721Semaste 273254721SemasteScalar& 274254721SemasteScalar::operator= (unsigned int v) 275254721Semaste{ 276254721Semaste m_type = e_uint; 277254721Semaste m_data.uint = v; 278254721Semaste return *this; 279254721Semaste} 280254721Semaste 281254721SemasteScalar& 282254721SemasteScalar::operator= (long v) 283254721Semaste{ 284254721Semaste m_type = e_slong; 285254721Semaste m_data.slong = v; 286254721Semaste return *this; 287254721Semaste} 288254721Semaste 289254721SemasteScalar& 290254721SemasteScalar::operator= (unsigned long v) 291254721Semaste{ 292254721Semaste m_type = e_ulong; 293254721Semaste m_data.ulong = v; 294254721Semaste return *this; 295254721Semaste} 296254721Semaste 297254721SemasteScalar& 298254721SemasteScalar::operator= (long long v) 299254721Semaste{ 300254721Semaste m_type = e_slonglong; 301254721Semaste m_data.slonglong = v; 302254721Semaste return *this; 303254721Semaste} 304254721Semaste 305254721SemasteScalar& 306254721SemasteScalar::operator= (unsigned long long v) 307254721Semaste{ 308254721Semaste m_type = e_ulonglong; 309254721Semaste m_data.ulonglong = v; 310254721Semaste return *this; 311254721Semaste} 312254721Semaste 313254721SemasteScalar& 314254721SemasteScalar::operator= (float v) 315254721Semaste{ 316254721Semaste m_type = e_float; 317254721Semaste m_data.flt = v; 318254721Semaste return *this; 319254721Semaste} 320254721Semaste 321254721SemasteScalar& 322254721SemasteScalar::operator= (double v) 323254721Semaste{ 324254721Semaste m_type = e_double; 325254721Semaste m_data.dbl = v; 326254721Semaste return *this; 327254721Semaste} 328254721Semaste 329254721SemasteScalar& 330254721SemasteScalar::operator= (long double v) 331254721Semaste{ 332254721Semaste m_type = e_long_double; 333254721Semaste m_data.ldbl = v; 334254721Semaste return *this; 335254721Semaste} 336254721Semaste 337254721Semaste//---------------------------------------------------------------------- 338254721Semaste// Destructor 339254721Semaste//---------------------------------------------------------------------- 340254721SemasteScalar::~Scalar() 341254721Semaste{ 342254721Semaste} 343254721Semaste 344254721Semastebool 345254721SemasteScalar::Promote(Scalar::Type type) 346254721Semaste{ 347254721Semaste bool success = false; 348254721Semaste switch (m_type) 349254721Semaste { 350254721Semaste case e_void: 351254721Semaste break; 352254721Semaste 353254721Semaste case e_sint: 354254721Semaste switch (type) 355254721Semaste { 356254721Semaste case e_void: break; 357254721Semaste case e_sint: success = true; break; 358254721Semaste case e_uint: m_data.uint = m_data.sint; success = true; break; 359254721Semaste case e_slong: m_data.slong = m_data.sint; success = true; break; 360254721Semaste case e_ulong: m_data.ulong = m_data.sint; success = true; break; 361254721Semaste case e_slonglong: m_data.slonglong = m_data.sint; success = true; break; 362254721Semaste case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break; 363254721Semaste case e_float: m_data.flt = m_data.sint; success = true; break; 364254721Semaste case e_double: m_data.dbl = m_data.sint; success = true; break; 365254721Semaste case e_long_double: m_data.ldbl = m_data.sint; success = true; break; 366254721Semaste } 367254721Semaste break; 368254721Semaste 369254721Semaste case e_uint: 370254721Semaste switch (type) 371254721Semaste { 372254721Semaste case e_void: 373254721Semaste case e_sint: break; 374254721Semaste case e_uint: success = true; break; 375254721Semaste case e_slong: m_data.slong = m_data.uint; success = true; break; 376254721Semaste case e_ulong: m_data.ulong = m_data.uint; success = true; break; 377254721Semaste case e_slonglong: m_data.slonglong = m_data.uint; success = true; break; 378254721Semaste case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break; 379254721Semaste case e_float: m_data.flt = m_data.uint; success = true; break; 380254721Semaste case e_double: m_data.dbl = m_data.uint; success = true; break; 381254721Semaste case e_long_double: m_data.ldbl = m_data.uint; success = true; break; 382254721Semaste } 383254721Semaste break; 384254721Semaste 385254721Semaste case e_slong: 386254721Semaste switch (type) 387254721Semaste { 388254721Semaste case e_void: 389254721Semaste case e_sint: 390254721Semaste case e_uint: break; 391254721Semaste case e_slong: success = true; break; 392254721Semaste case e_ulong: m_data.ulong = m_data.slong; success = true; break; 393254721Semaste case e_slonglong: m_data.slonglong = m_data.slong; success = true; break; 394254721Semaste case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break; 395254721Semaste case e_float: m_data.flt = m_data.slong; success = true; break; 396254721Semaste case e_double: m_data.dbl = m_data.slong; success = true; break; 397254721Semaste case e_long_double: m_data.ldbl = m_data.slong; success = true; break; 398254721Semaste } 399254721Semaste break; 400254721Semaste 401254721Semaste case e_ulong: 402254721Semaste switch (type) 403254721Semaste { 404254721Semaste case e_void: 405254721Semaste case e_sint: 406254721Semaste case e_uint: 407254721Semaste case e_slong: break; 408254721Semaste case e_ulong: success = true; break; 409254721Semaste case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break; 410254721Semaste case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break; 411254721Semaste case e_float: m_data.flt = m_data.ulong; success = true; break; 412254721Semaste case e_double: m_data.dbl = m_data.ulong; success = true; break; 413254721Semaste case e_long_double: m_data.ldbl = m_data.ulong; success = true; break; 414254721Semaste } 415254721Semaste break; 416254721Semaste 417254721Semaste case e_slonglong: 418254721Semaste switch (type) 419254721Semaste { 420254721Semaste case e_void: 421254721Semaste case e_sint: 422254721Semaste case e_uint: 423254721Semaste case e_slong: 424254721Semaste case e_ulong: break; 425254721Semaste case e_slonglong: success = true; break; 426254721Semaste case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break; 427254721Semaste case e_float: m_data.flt = m_data.slonglong; success = true; break; 428254721Semaste case e_double: m_data.dbl = m_data.slonglong; success = true; break; 429254721Semaste case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break; 430254721Semaste } 431254721Semaste break; 432254721Semaste 433254721Semaste case e_ulonglong: 434254721Semaste switch (type) 435254721Semaste { 436254721Semaste case e_void: 437254721Semaste case e_sint: 438254721Semaste case e_uint: 439254721Semaste case e_slong: 440254721Semaste case e_ulong: 441254721Semaste case e_slonglong: break; 442254721Semaste case e_ulonglong: success = true; break; 443254721Semaste case e_float: m_data.flt = m_data.ulonglong; success = true; break; 444254721Semaste case e_double: m_data.dbl = m_data.ulonglong; success = true; break; 445254721Semaste case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; 446254721Semaste } 447254721Semaste break; 448254721Semaste 449254721Semaste case e_float: 450254721Semaste switch (type) 451254721Semaste { 452254721Semaste case e_void: 453254721Semaste case e_sint: 454254721Semaste case e_uint: 455254721Semaste case e_slong: 456254721Semaste case e_ulong: 457254721Semaste case e_slonglong: 458254721Semaste case e_ulonglong: break; 459254721Semaste case e_float: success = true; break; 460254721Semaste case e_double: m_data.dbl = m_data.flt; success = true; break; 461254721Semaste case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; 462254721Semaste } 463254721Semaste break; 464254721Semaste 465254721Semaste case e_double: 466254721Semaste switch (type) 467254721Semaste { 468254721Semaste case e_void: 469254721Semaste case e_sint: 470254721Semaste case e_uint: 471254721Semaste case e_slong: 472254721Semaste case e_ulong: 473254721Semaste case e_slonglong: 474254721Semaste case e_ulonglong: 475254721Semaste case e_float: break; 476254721Semaste case e_double: success = true; break; 477254721Semaste case e_long_double: m_data.ldbl = m_data.dbl; success = true; break; 478254721Semaste } 479254721Semaste break; 480254721Semaste 481254721Semaste case e_long_double: 482254721Semaste switch (type) 483254721Semaste { 484254721Semaste case e_void: 485254721Semaste case e_sint: 486254721Semaste case e_uint: 487254721Semaste case e_slong: 488254721Semaste case e_ulong: 489254721Semaste case e_slonglong: 490254721Semaste case e_ulonglong: 491254721Semaste case e_float: 492254721Semaste case e_double: break; 493254721Semaste case e_long_double: success = true; break; 494254721Semaste } 495254721Semaste break; 496254721Semaste } 497254721Semaste 498254721Semaste if (success) 499254721Semaste m_type = type; 500254721Semaste return success; 501254721Semaste} 502254721Semaste 503254721Semasteconst char * 504254721SemasteScalar::GetValueTypeAsCString (Scalar::Type type) 505254721Semaste{ 506254721Semaste switch (type) 507254721Semaste { 508254721Semaste case e_void: return "void"; 509254721Semaste case e_sint: return "int"; 510254721Semaste case e_uint: return "unsigned int"; 511254721Semaste case e_slong: return "long"; 512254721Semaste case e_ulong: return "unsigned long"; 513254721Semaste case e_slonglong: return "long long"; 514254721Semaste case e_ulonglong: return "unsigned long long"; 515254721Semaste case e_float: return "float"; 516254721Semaste case e_double: return "double"; 517254721Semaste case e_long_double: return "long double"; 518254721Semaste } 519254721Semaste return "???"; 520254721Semaste} 521254721Semaste 522254721Semaste 523254721SemasteScalar::Type 524254721SemasteScalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size) 525254721Semaste{ 526254721Semaste if (byte_size <= sizeof(sint_t)) 527254721Semaste return e_sint; 528254721Semaste if (byte_size <= sizeof(slong_t)) 529254721Semaste return e_slong; 530254721Semaste if (byte_size <= sizeof(slonglong_t)) 531254721Semaste return e_slonglong; 532254721Semaste return e_void; 533254721Semaste} 534254721Semaste 535254721SemasteScalar::Type 536254721SemasteScalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size) 537254721Semaste{ 538254721Semaste if (byte_size <= sizeof(uint_t)) 539254721Semaste return e_uint; 540254721Semaste if (byte_size <= sizeof(ulong_t)) 541254721Semaste return e_ulong; 542254721Semaste if (byte_size <= sizeof(ulonglong_t)) 543254721Semaste return e_ulonglong; 544254721Semaste return e_void; 545254721Semaste} 546254721Semaste 547254721SemasteScalar::Type 548254721SemasteScalar::GetValueTypeForFloatWithByteSize (size_t byte_size) 549254721Semaste{ 550254721Semaste if (byte_size == sizeof(float_t)) 551254721Semaste return e_float; 552254721Semaste if (byte_size == sizeof(double_t)) 553254721Semaste return e_double; 554254721Semaste if (byte_size == sizeof(long_double_t)) 555254721Semaste return e_long_double; 556254721Semaste return e_void; 557254721Semaste} 558254721Semaste 559254721Semastebool 560254721SemasteScalar::Cast(Scalar::Type type) 561254721Semaste{ 562254721Semaste bool success = false; 563254721Semaste switch (m_type) 564254721Semaste { 565254721Semaste case e_void: 566254721Semaste break; 567254721Semaste 568254721Semaste case e_sint: 569254721Semaste switch (type) 570254721Semaste { 571254721Semaste case e_void: break; 572254721Semaste case e_sint: success = true; break; 573254721Semaste case e_uint: m_data.uint = m_data.sint; success = true; break; 574254721Semaste case e_slong: m_data.slong = m_data.sint; success = true; break; 575254721Semaste case e_ulong: m_data.ulong = m_data.sint; success = true; break; 576254721Semaste case e_slonglong: m_data.slonglong = m_data.sint; success = true; break; 577254721Semaste case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break; 578254721Semaste case e_float: m_data.flt = m_data.sint; success = true; break; 579254721Semaste case e_double: m_data.dbl = m_data.sint; success = true; break; 580254721Semaste case e_long_double: m_data.ldbl = m_data.sint; success = true; break; 581254721Semaste } 582254721Semaste break; 583254721Semaste 584254721Semaste case e_uint: 585254721Semaste switch (type) 586254721Semaste { 587254721Semaste case e_void: 588254721Semaste case e_sint: m_data.sint = m_data.uint; success = true; break; 589254721Semaste case e_uint: success = true; break; 590254721Semaste case e_slong: m_data.slong = m_data.uint; success = true; break; 591254721Semaste case e_ulong: m_data.ulong = m_data.uint; success = true; break; 592254721Semaste case e_slonglong: m_data.slonglong = m_data.uint; success = true; break; 593254721Semaste case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break; 594254721Semaste case e_float: m_data.flt = m_data.uint; success = true; break; 595254721Semaste case e_double: m_data.dbl = m_data.uint; success = true; break; 596254721Semaste case e_long_double: m_data.ldbl = m_data.uint; success = true; break; 597254721Semaste } 598254721Semaste break; 599254721Semaste 600254721Semaste case e_slong: 601254721Semaste switch (type) 602254721Semaste { 603254721Semaste case e_void: 604254721Semaste case e_sint: m_data.sint = (sint_t)m_data.slong; success = true; break; 605254721Semaste case e_uint: m_data.uint = (uint_t)m_data.slong; success = true; break; 606254721Semaste case e_slong: success = true; break; 607254721Semaste case e_ulong: m_data.ulong = m_data.slong; success = true; break; 608254721Semaste case e_slonglong: m_data.slonglong = m_data.slong; success = true; break; 609254721Semaste case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break; 610254721Semaste case e_float: m_data.flt = m_data.slong; success = true; break; 611254721Semaste case e_double: m_data.dbl = m_data.slong; success = true; break; 612254721Semaste case e_long_double: m_data.ldbl = m_data.slong; success = true; break; 613254721Semaste } 614254721Semaste break; 615254721Semaste 616254721Semaste case e_ulong: 617254721Semaste switch (type) 618254721Semaste { 619254721Semaste case e_void: 620254721Semaste case e_sint: m_data.sint = (sint_t)m_data.ulong; success = true; break; 621254721Semaste case e_uint: m_data.uint = (uint_t)m_data.ulong; success = true; break; 622254721Semaste case e_slong: m_data.slong = m_data.ulong; success = true; break; 623254721Semaste case e_ulong: success = true; break; 624254721Semaste case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break; 625254721Semaste case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break; 626254721Semaste case e_float: m_data.flt = m_data.ulong; success = true; break; 627254721Semaste case e_double: m_data.dbl = m_data.ulong; success = true; break; 628254721Semaste case e_long_double: m_data.ldbl = m_data.ulong; success = true; break; 629254721Semaste } 630254721Semaste break; 631254721Semaste 632254721Semaste case e_slonglong: 633254721Semaste switch (type) 634254721Semaste { 635254721Semaste case e_void: 636254721Semaste case e_sint: m_data.sint = (sint_t)m_data.slonglong; success = true; break; 637254721Semaste case e_uint: m_data.uint = (uint_t)m_data.slonglong; success = true; break; 638254721Semaste case e_slong: m_data.slong = m_data.slonglong; success = true; break; 639254721Semaste case e_ulong: m_data.ulong = m_data.slonglong; success = true; break; 640254721Semaste case e_slonglong: success = true; break; 641254721Semaste case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break; 642254721Semaste case e_float: m_data.flt = m_data.slonglong; success = true; break; 643254721Semaste case e_double: m_data.dbl = m_data.slonglong; success = true; break; 644254721Semaste case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break; 645254721Semaste } 646254721Semaste break; 647254721Semaste 648254721Semaste case e_ulonglong: 649254721Semaste switch (type) 650254721Semaste { 651254721Semaste case e_void: 652254721Semaste case e_sint: m_data.sint = (sint_t)m_data.ulonglong; success = true; break; 653254721Semaste case e_uint: m_data.uint = (uint_t)m_data.ulonglong; success = true; break; 654254721Semaste case e_slong: m_data.slong = m_data.ulonglong; success = true; break; 655254721Semaste case e_ulong: m_data.ulong = m_data.ulonglong; success = true; break; 656254721Semaste case e_slonglong: m_data.slonglong = m_data.ulonglong; success = true; break; 657254721Semaste case e_ulonglong: success = true; break; 658254721Semaste case e_float: m_data.flt = m_data.ulonglong; success = true; break; 659254721Semaste case e_double: m_data.dbl = m_data.ulonglong; success = true; break; 660254721Semaste case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; 661254721Semaste } 662254721Semaste break; 663254721Semaste 664254721Semaste case e_float: 665254721Semaste switch (type) 666254721Semaste { 667254721Semaste case e_void: 668254721Semaste case e_sint: m_data.sint = (sint_t)m_data.flt; success = true; break; 669254721Semaste case e_uint: m_data.uint = (uint_t)m_data.flt; success = true; break; 670254721Semaste case e_slong: m_data.slong = (slong_t)m_data.flt; success = true; break; 671254721Semaste case e_ulong: m_data.ulong = (ulong_t)m_data.flt; success = true; break; 672254721Semaste case e_slonglong: m_data.slonglong = (slonglong_t)m_data.flt; success = true; break; 673254721Semaste case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.flt; success = true; break; 674254721Semaste case e_float: success = true; break; 675254721Semaste case e_double: m_data.dbl = m_data.flt; success = true; break; 676254721Semaste case e_long_double: m_data.ldbl = m_data.flt; success = true; break; 677254721Semaste } 678254721Semaste break; 679254721Semaste 680254721Semaste case e_double: 681254721Semaste switch (type) 682254721Semaste { 683254721Semaste case e_void: 684254721Semaste case e_sint: m_data.sint = (sint_t)m_data.dbl; success = true; break; 685254721Semaste case e_uint: m_data.uint = (uint_t)m_data.dbl; success = true; break; 686254721Semaste case e_slong: m_data.slong = (slong_t)m_data.dbl; success = true; break; 687254721Semaste case e_ulong: m_data.ulong = (ulong_t)m_data.dbl; success = true; break; 688254721Semaste case e_slonglong: m_data.slonglong = (slonglong_t)m_data.dbl; success = true; break; 689254721Semaste case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.dbl; success = true; break; 690254721Semaste case e_float: m_data.flt = (float_t)m_data.dbl; success = true; break; 691254721Semaste case e_double: success = true; break; 692254721Semaste case e_long_double: m_data.ldbl = m_data.dbl; success = true; break; 693254721Semaste } 694254721Semaste break; 695254721Semaste 696254721Semaste case e_long_double: 697254721Semaste switch (type) 698254721Semaste { 699254721Semaste case e_void: 700254721Semaste case e_sint: m_data.sint = (sint_t)m_data.ldbl; success = true; break; 701254721Semaste case e_uint: m_data.uint = (uint_t)m_data.ldbl; success = true; break; 702254721Semaste case e_slong: m_data.slong = (slong_t)m_data.ldbl; success = true; break; 703254721Semaste case e_ulong: m_data.ulong = (ulong_t)m_data.ldbl; success = true; break; 704254721Semaste case e_slonglong: m_data.slonglong = (slonglong_t)m_data.ldbl; success = true; break; 705254721Semaste case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.ldbl; success = true; break; 706254721Semaste case e_float: m_data.flt = (float_t)m_data.ldbl; success = true; break; 707254721Semaste case e_double: m_data.dbl = (double_t)m_data.ldbl; success = true; break; 708254721Semaste case e_long_double: success = true; break; 709254721Semaste } 710254721Semaste break; 711254721Semaste } 712254721Semaste 713254721Semaste if (success) 714254721Semaste m_type = type; 715254721Semaste return success; 716254721Semaste} 717254721Semaste 718254721Semastebool 719254721SemasteScalar::MakeSigned () 720254721Semaste{ 721254721Semaste bool success = false; 722254721Semaste 723254721Semaste switch (m_type) 724254721Semaste { 725254721Semaste case e_void: break; 726254721Semaste case e_sint: success = true; break; 727254721Semaste case e_uint: m_type = e_sint; success = true; break; 728254721Semaste case e_slong: success = true; break; 729254721Semaste case e_ulong: m_type = e_slong; success = true; break; 730254721Semaste case e_slonglong: success = true; break; 731254721Semaste case e_ulonglong: m_type = e_slonglong; success = true; break; 732254721Semaste case e_float: success = true; break; 733254721Semaste case e_double: success = true; break; 734254721Semaste case e_long_double: success = true; break; 735254721Semaste } 736254721Semaste 737254721Semaste return success; 738254721Semaste} 739254721Semaste 740254721Semasteint 741254721SemasteScalar::SInt(int fail_value) const 742254721Semaste{ 743254721Semaste switch (m_type) 744254721Semaste { 745254721Semaste case e_void: break; 746254721Semaste case e_sint: return m_data.sint; 747254721Semaste case e_uint: return (int)m_data.uint; 748254721Semaste case e_slong: return (int)m_data.slong; 749254721Semaste case e_ulong: return (int)m_data.ulong; 750254721Semaste case e_slonglong: return (int)m_data.slonglong; 751254721Semaste case e_ulonglong: return (int)m_data.ulonglong; 752254721Semaste case e_float: return (int)m_data.flt; 753254721Semaste case e_double: return (int)m_data.dbl; 754254721Semaste case e_long_double: return (int)m_data.ldbl; 755254721Semaste } 756254721Semaste return fail_value; 757254721Semaste} 758254721Semaste 759254721Semasteunsigned int 760254721SemasteScalar::UInt(unsigned int fail_value) const 761254721Semaste{ 762254721Semaste switch (m_type) 763254721Semaste { 764254721Semaste case e_void: break; 765254721Semaste case e_sint: return (unsigned int)m_data.sint; 766254721Semaste case e_uint: return (unsigned int)m_data.uint; 767254721Semaste case e_slong: return (unsigned int)m_data.slong; 768254721Semaste case e_ulong: return (unsigned int)m_data.ulong; 769254721Semaste case e_slonglong: return (unsigned int)m_data.slonglong; 770254721Semaste case e_ulonglong: return (unsigned int)m_data.ulonglong; 771254721Semaste case e_float: return (unsigned int)m_data.flt; 772254721Semaste case e_double: return (unsigned int)m_data.dbl; 773254721Semaste case e_long_double: return (unsigned int)m_data.ldbl; 774254721Semaste } 775254721Semaste return fail_value; 776254721Semaste} 777254721Semaste 778254721Semaste 779254721Semastelong 780254721SemasteScalar::SLong(long fail_value) const 781254721Semaste{ 782254721Semaste switch (m_type) 783254721Semaste { 784254721Semaste case e_void: break; 785254721Semaste case e_sint: return (long)m_data.sint; 786254721Semaste case e_uint: return (long)m_data.uint; 787254721Semaste case e_slong: return (long)m_data.slong; 788254721Semaste case e_ulong: return (long)m_data.ulong; 789254721Semaste case e_slonglong: return (long)m_data.slonglong; 790254721Semaste case e_ulonglong: return (long)m_data.ulonglong; 791254721Semaste case e_float: return (long)m_data.flt; 792254721Semaste case e_double: return (long)m_data.dbl; 793254721Semaste case e_long_double: return (long)m_data.ldbl; 794254721Semaste } 795254721Semaste return fail_value; 796254721Semaste} 797254721Semaste 798254721Semaste 799254721Semaste 800254721Semasteunsigned long 801254721SemasteScalar::ULong(unsigned long fail_value) const 802254721Semaste{ 803254721Semaste switch (m_type) 804254721Semaste { 805254721Semaste case e_void: break; 806254721Semaste case e_sint: return (unsigned long)m_data.sint; 807254721Semaste case e_uint: return (unsigned long)m_data.uint; 808254721Semaste case e_slong: return (unsigned long)m_data.slong; 809254721Semaste case e_ulong: return (unsigned long)m_data.ulong; 810254721Semaste case e_slonglong: return (unsigned long)m_data.slonglong; 811254721Semaste case e_ulonglong: return (unsigned long)m_data.ulonglong; 812254721Semaste case e_float: return (unsigned long)m_data.flt; 813254721Semaste case e_double: return (unsigned long)m_data.dbl; 814254721Semaste case e_long_double: return (unsigned long)m_data.ldbl; 815254721Semaste } 816254721Semaste return fail_value; 817254721Semaste} 818254721Semaste 819254721Semasteuint64_t 820254721SemasteScalar::GetRawBits64(uint64_t fail_value) const 821254721Semaste{ 822254721Semaste switch (m_type) 823254721Semaste { 824254721Semaste case e_void: 825254721Semaste break; 826254721Semaste 827254721Semaste case e_sint: 828254721Semaste case e_uint: 829254721Semaste return m_data.uint; 830254721Semaste 831254721Semaste case e_slong: 832254721Semaste case e_ulong: 833254721Semaste return m_data.ulong; 834254721Semaste 835254721Semaste case e_slonglong: 836254721Semaste case e_ulonglong: 837254721Semaste return m_data.ulonglong; 838254721Semaste 839254721Semaste case e_float: 840254721Semaste if (sizeof(m_data.flt) == sizeof(m_data.uint)) 841254721Semaste return m_data.uint; 842254721Semaste else if (sizeof(m_data.flt) == sizeof(m_data.ulong)) 843254721Semaste return m_data.ulong; 844254721Semaste else if (sizeof(m_data.flt) == sizeof(m_data.ulonglong)) 845254721Semaste return m_data.ulonglong; 846254721Semaste break; 847254721Semaste 848254721Semaste case e_double: 849254721Semaste if (sizeof(m_data.dbl) == sizeof(m_data.uint)) 850254721Semaste return m_data.uint; 851254721Semaste else if (sizeof(m_data.dbl) == sizeof(m_data.ulong)) 852254721Semaste return m_data.ulong; 853254721Semaste else if (sizeof(m_data.dbl) == sizeof(m_data.ulonglong)) 854254721Semaste return m_data.ulonglong; 855254721Semaste break; 856254721Semaste 857254721Semaste case e_long_double: 858254721Semaste if (sizeof(m_data.ldbl) == sizeof(m_data.uint)) 859254721Semaste return m_data.uint; 860254721Semaste else if (sizeof(m_data.ldbl) == sizeof(m_data.ulong)) 861254721Semaste return m_data.ulong; 862254721Semaste else if (sizeof(m_data.ldbl) == sizeof(m_data.ulonglong)) 863254721Semaste return m_data.ulonglong; 864254721Semaste break; 865254721Semaste } 866254721Semaste return fail_value; 867254721Semaste} 868254721Semaste 869254721Semaste 870254721Semaste 871254721Semastelong long 872254721SemasteScalar::SLongLong(long long fail_value) const 873254721Semaste{ 874254721Semaste switch (m_type) 875254721Semaste { 876254721Semaste case e_void: break; 877254721Semaste case e_sint: return (long long)m_data.sint; 878254721Semaste case e_uint: return (long long)m_data.uint; 879254721Semaste case e_slong: return (long long)m_data.slong; 880254721Semaste case e_ulong: return (long long)m_data.ulong; 881254721Semaste case e_slonglong: return (long long)m_data.slonglong; 882254721Semaste case e_ulonglong: return (long long)m_data.ulonglong; 883254721Semaste case e_float: return (long long)m_data.flt; 884254721Semaste case e_double: return (long long)m_data.dbl; 885254721Semaste case e_long_double: return (long long)m_data.ldbl; 886254721Semaste } 887254721Semaste return fail_value; 888254721Semaste} 889254721Semaste 890254721Semaste 891254721Semasteunsigned long long 892254721SemasteScalar::ULongLong(unsigned long long fail_value) const 893254721Semaste{ 894254721Semaste switch (m_type) 895254721Semaste { 896254721Semaste case e_void: break; 897254721Semaste case e_sint: return (unsigned long long)m_data.sint; 898254721Semaste case e_uint: return (unsigned long long)m_data.uint; 899254721Semaste case e_slong: return (unsigned long long)m_data.slong; 900254721Semaste case e_ulong: return (unsigned long long)m_data.ulong; 901254721Semaste case e_slonglong: return (unsigned long long)m_data.slonglong; 902254721Semaste case e_ulonglong: return (unsigned long long)m_data.ulonglong; 903254721Semaste case e_float: return (unsigned long long)m_data.flt; 904254721Semaste case e_double: return (unsigned long long)m_data.dbl; 905254721Semaste case e_long_double: return (unsigned long long)m_data.ldbl; 906254721Semaste } 907254721Semaste return fail_value; 908254721Semaste} 909254721Semaste 910254721Semaste 911254721Semastefloat 912254721SemasteScalar::Float(float fail_value) const 913254721Semaste{ 914254721Semaste switch (m_type) 915254721Semaste { 916254721Semaste case e_void: break; 917254721Semaste case e_sint: return (float)m_data.sint; 918254721Semaste case e_uint: return (float)m_data.uint; 919254721Semaste case e_slong: return (float)m_data.slong; 920254721Semaste case e_ulong: return (float)m_data.ulong; 921254721Semaste case e_slonglong: return (float)m_data.slonglong; 922254721Semaste case e_ulonglong: return (float)m_data.ulonglong; 923254721Semaste case e_float: return (float)m_data.flt; 924254721Semaste case e_double: return (float)m_data.dbl; 925254721Semaste case e_long_double: return (float)m_data.ldbl; 926254721Semaste } 927254721Semaste return fail_value; 928254721Semaste} 929254721Semaste 930254721Semaste 931254721Semastedouble 932254721SemasteScalar::Double(double fail_value) const 933254721Semaste{ 934254721Semaste switch (m_type) 935254721Semaste { 936254721Semaste case e_void: break; 937254721Semaste case e_sint: return (double)m_data.sint; 938254721Semaste case e_uint: return (double)m_data.uint; 939254721Semaste case e_slong: return (double)m_data.slong; 940254721Semaste case e_ulong: return (double)m_data.ulong; 941254721Semaste case e_slonglong: return (double)m_data.slonglong; 942254721Semaste case e_ulonglong: return (double)m_data.ulonglong; 943254721Semaste case e_float: return (double)m_data.flt; 944254721Semaste case e_double: return (double)m_data.dbl; 945254721Semaste case e_long_double: return (double)m_data.ldbl; 946254721Semaste } 947254721Semaste return fail_value; 948254721Semaste} 949254721Semaste 950254721Semaste 951254721Semastelong double 952254721SemasteScalar::LongDouble(long double fail_value) const 953254721Semaste{ 954254721Semaste switch (m_type) 955254721Semaste { 956254721Semaste case e_void: break; 957254721Semaste case e_sint: return (long double)m_data.sint; 958254721Semaste case e_uint: return (long double)m_data.uint; 959254721Semaste case e_slong: return (long double)m_data.slong; 960254721Semaste case e_ulong: return (long double)m_data.ulong; 961254721Semaste case e_slonglong: return (long double)m_data.slonglong; 962254721Semaste case e_ulonglong: return (long double)m_data.ulonglong; 963254721Semaste case e_float: return (long double)m_data.flt; 964254721Semaste case e_double: return (long double)m_data.dbl; 965254721Semaste case e_long_double: return (long double)m_data.ldbl; 966254721Semaste } 967254721Semaste return fail_value; 968254721Semaste} 969254721Semaste 970254721Semaste 971254721SemasteScalar& 972254721SemasteScalar::operator+= (const Scalar& rhs) 973254721Semaste{ 974254721Semaste Scalar temp_value; 975254721Semaste const Scalar* a; 976254721Semaste const Scalar* b; 977254721Semaste if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void) 978254721Semaste { 979254721Semaste switch (m_type) 980254721Semaste { 981254721Semaste case e_void: break; 982254721Semaste case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break; 983254721Semaste case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break; 984254721Semaste case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break; 985254721Semaste case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; 986254721Semaste case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; 987254721Semaste case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; 988254721Semaste case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break; 989254721Semaste case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; 990254721Semaste case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; 991254721Semaste } 992254721Semaste } 993254721Semaste return *this; 994254721Semaste} 995254721Semaste 996254721SemasteScalar& 997254721SemasteScalar::operator<<= (const Scalar& rhs) 998254721Semaste{ 999254721Semaste switch (m_type) 1000254721Semaste { 1001254721Semaste case e_void: 1002254721Semaste case e_float: 1003254721Semaste case e_double: 1004254721Semaste case e_long_double: 1005254721Semaste m_type = e_void; 1006254721Semaste break; 1007254721Semaste 1008254721Semaste case e_sint: 1009254721Semaste switch (rhs.m_type) 1010254721Semaste { 1011254721Semaste case e_void: 1012254721Semaste case e_float: 1013254721Semaste case e_double: 1014254721Semaste case e_long_double: 1015254721Semaste m_type = e_void; 1016254721Semaste break; 1017254721Semaste case e_sint: m_data.sint <<= rhs.m_data.sint; break; 1018254721Semaste case e_uint: m_data.sint <<= rhs.m_data.uint; break; 1019254721Semaste case e_slong: m_data.sint <<= rhs.m_data.slong; break; 1020254721Semaste case e_ulong: m_data.sint <<= rhs.m_data.ulong; break; 1021254721Semaste case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break; 1022254721Semaste case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break; 1023254721Semaste } 1024254721Semaste break; 1025254721Semaste 1026254721Semaste case e_uint: 1027254721Semaste switch (rhs.m_type) 1028254721Semaste { 1029254721Semaste case e_void: 1030254721Semaste case e_float: 1031254721Semaste case e_double: 1032254721Semaste case e_long_double: 1033254721Semaste m_type = e_void; 1034254721Semaste break; 1035254721Semaste case e_sint: m_data.uint <<= rhs.m_data.sint; break; 1036254721Semaste case e_uint: m_data.uint <<= rhs.m_data.uint; break; 1037254721Semaste case e_slong: m_data.uint <<= rhs.m_data.slong; break; 1038254721Semaste case e_ulong: m_data.uint <<= rhs.m_data.ulong; break; 1039254721Semaste case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break; 1040254721Semaste case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break; 1041254721Semaste } 1042254721Semaste break; 1043254721Semaste 1044254721Semaste case e_slong: 1045254721Semaste switch (rhs.m_type) 1046254721Semaste { 1047254721Semaste case e_void: 1048254721Semaste case e_float: 1049254721Semaste case e_double: 1050254721Semaste case e_long_double: 1051254721Semaste m_type = e_void; 1052254721Semaste break; 1053254721Semaste case e_sint: m_data.slong <<= rhs.m_data.sint; break; 1054254721Semaste case e_uint: m_data.slong <<= rhs.m_data.uint; break; 1055254721Semaste case e_slong: m_data.slong <<= rhs.m_data.slong; break; 1056254721Semaste case e_ulong: m_data.slong <<= rhs.m_data.ulong; break; 1057254721Semaste case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break; 1058254721Semaste case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break; 1059254721Semaste } 1060254721Semaste break; 1061254721Semaste 1062254721Semaste case e_ulong: 1063254721Semaste switch (rhs.m_type) 1064254721Semaste { 1065254721Semaste case e_void: 1066254721Semaste case e_float: 1067254721Semaste case e_double: 1068254721Semaste case e_long_double: 1069254721Semaste m_type = e_void; 1070254721Semaste break; 1071254721Semaste case e_sint: m_data.ulong <<= rhs.m_data.sint; break; 1072254721Semaste case e_uint: m_data.ulong <<= rhs.m_data.uint; break; 1073254721Semaste case e_slong: m_data.ulong <<= rhs.m_data.slong; break; 1074254721Semaste case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break; 1075254721Semaste case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break; 1076254721Semaste case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break; 1077254721Semaste } 1078254721Semaste break; 1079254721Semaste case e_slonglong: 1080254721Semaste switch (rhs.m_type) 1081254721Semaste { 1082254721Semaste case e_void: 1083254721Semaste case e_float: 1084254721Semaste case e_double: 1085254721Semaste case e_long_double: 1086254721Semaste m_type = e_void; 1087254721Semaste break; 1088254721Semaste case e_sint: m_data.slonglong <<= rhs.m_data.sint; break; 1089254721Semaste case e_uint: m_data.slonglong <<= rhs.m_data.uint; break; 1090254721Semaste case e_slong: m_data.slonglong <<= rhs.m_data.slong; break; 1091254721Semaste case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break; 1092254721Semaste case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break; 1093254721Semaste case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break; 1094254721Semaste } 1095254721Semaste break; 1096254721Semaste 1097254721Semaste case e_ulonglong: 1098254721Semaste switch (rhs.m_type) 1099254721Semaste { 1100254721Semaste case e_void: 1101254721Semaste case e_float: 1102254721Semaste case e_double: 1103254721Semaste case e_long_double: 1104254721Semaste m_type = e_void; 1105254721Semaste break; 1106254721Semaste case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break; 1107254721Semaste case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break; 1108254721Semaste case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break; 1109254721Semaste case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break; 1110254721Semaste case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break; 1111254721Semaste case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break; 1112254721Semaste } 1113254721Semaste break; 1114254721Semaste } 1115254721Semaste return *this; 1116254721Semaste} 1117254721Semaste 1118254721Semastebool 1119254721SemasteScalar::ShiftRightLogical(const Scalar& rhs) 1120254721Semaste{ 1121254721Semaste switch (m_type) 1122254721Semaste { 1123254721Semaste case e_void: 1124254721Semaste case e_float: 1125254721Semaste case e_double: 1126254721Semaste case e_long_double: 1127254721Semaste m_type = e_void; 1128254721Semaste break; 1129254721Semaste 1130254721Semaste case e_sint: 1131254721Semaste case e_uint: 1132254721Semaste switch (rhs.m_type) 1133254721Semaste { 1134254721Semaste case e_void: 1135254721Semaste case e_float: 1136254721Semaste case e_double: 1137254721Semaste case e_long_double: 1138254721Semaste m_type = e_void; 1139254721Semaste break; 1140254721Semaste case e_sint: m_data.uint >>= rhs.m_data.sint; break; 1141254721Semaste case e_uint: m_data.uint >>= rhs.m_data.uint; break; 1142254721Semaste case e_slong: m_data.uint >>= rhs.m_data.slong; break; 1143254721Semaste case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; 1144254721Semaste case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; 1145254721Semaste case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; 1146254721Semaste } 1147254721Semaste break; 1148254721Semaste 1149254721Semaste case e_slong: 1150254721Semaste case e_ulong: 1151254721Semaste switch (rhs.m_type) 1152254721Semaste { 1153254721Semaste case e_void: 1154254721Semaste case e_float: 1155254721Semaste case e_double: 1156254721Semaste case e_long_double: 1157254721Semaste m_type = e_void; 1158254721Semaste break; 1159254721Semaste case e_sint: m_data.ulong >>= rhs.m_data.sint; break; 1160254721Semaste case e_uint: m_data.ulong >>= rhs.m_data.uint; break; 1161254721Semaste case e_slong: m_data.ulong >>= rhs.m_data.slong; break; 1162254721Semaste case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; 1163254721Semaste case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; 1164254721Semaste case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; 1165254721Semaste } 1166254721Semaste break; 1167254721Semaste 1168254721Semaste case e_slonglong: 1169254721Semaste case e_ulonglong: 1170254721Semaste switch (rhs.m_type) 1171254721Semaste { 1172254721Semaste case e_void: 1173254721Semaste case e_float: 1174254721Semaste case e_double: 1175254721Semaste case e_long_double: 1176254721Semaste m_type = e_void; 1177254721Semaste break; 1178254721Semaste case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; 1179254721Semaste case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; 1180254721Semaste case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; 1181254721Semaste case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; 1182254721Semaste case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; 1183254721Semaste case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; 1184254721Semaste } 1185254721Semaste break; 1186254721Semaste } 1187254721Semaste return m_type != e_void; 1188254721Semaste} 1189254721Semaste 1190254721Semaste 1191254721SemasteScalar& 1192254721SemasteScalar::operator>>= (const Scalar& rhs) 1193254721Semaste{ 1194254721Semaste switch (m_type) 1195254721Semaste { 1196254721Semaste case e_void: 1197254721Semaste case e_float: 1198254721Semaste case e_double: 1199254721Semaste case e_long_double: 1200254721Semaste m_type = e_void; 1201254721Semaste break; 1202254721Semaste 1203254721Semaste case e_sint: 1204254721Semaste switch (rhs.m_type) 1205254721Semaste { 1206254721Semaste case e_void: 1207254721Semaste case e_float: 1208254721Semaste case e_double: 1209254721Semaste case e_long_double: 1210254721Semaste m_type = e_void; 1211254721Semaste break; 1212254721Semaste case e_sint: m_data.sint >>= rhs.m_data.sint; break; 1213254721Semaste case e_uint: m_data.sint >>= rhs.m_data.uint; break; 1214254721Semaste case e_slong: m_data.sint >>= rhs.m_data.slong; break; 1215254721Semaste case e_ulong: m_data.sint >>= rhs.m_data.ulong; break; 1216254721Semaste case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break; 1217254721Semaste case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break; 1218254721Semaste } 1219254721Semaste break; 1220254721Semaste 1221254721Semaste case e_uint: 1222254721Semaste switch (rhs.m_type) 1223254721Semaste { 1224254721Semaste case e_void: 1225254721Semaste case e_float: 1226254721Semaste case e_double: 1227254721Semaste case e_long_double: 1228254721Semaste m_type = e_void; 1229254721Semaste break; 1230254721Semaste case e_sint: m_data.uint >>= rhs.m_data.sint; break; 1231254721Semaste case e_uint: m_data.uint >>= rhs.m_data.uint; break; 1232254721Semaste case e_slong: m_data.uint >>= rhs.m_data.slong; break; 1233254721Semaste case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; 1234254721Semaste case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; 1235254721Semaste case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; 1236254721Semaste } 1237254721Semaste break; 1238254721Semaste 1239254721Semaste case e_slong: 1240254721Semaste switch (rhs.m_type) 1241254721Semaste { 1242254721Semaste case e_void: 1243254721Semaste case e_float: 1244254721Semaste case e_double: 1245254721Semaste case e_long_double: 1246254721Semaste m_type = e_void; 1247254721Semaste break; 1248254721Semaste case e_sint: m_data.slong >>= rhs.m_data.sint; break; 1249254721Semaste case e_uint: m_data.slong >>= rhs.m_data.uint; break; 1250254721Semaste case e_slong: m_data.slong >>= rhs.m_data.slong; break; 1251254721Semaste case e_ulong: m_data.slong >>= rhs.m_data.ulong; break; 1252254721Semaste case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break; 1253254721Semaste case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break; 1254254721Semaste } 1255254721Semaste break; 1256254721Semaste 1257254721Semaste case e_ulong: 1258254721Semaste switch (rhs.m_type) 1259254721Semaste { 1260254721Semaste case e_void: 1261254721Semaste case e_float: 1262254721Semaste case e_double: 1263254721Semaste case e_long_double: 1264254721Semaste m_type = e_void; 1265254721Semaste break; 1266254721Semaste case e_sint: m_data.ulong >>= rhs.m_data.sint; break; 1267254721Semaste case e_uint: m_data.ulong >>= rhs.m_data.uint; break; 1268254721Semaste case e_slong: m_data.ulong >>= rhs.m_data.slong; break; 1269254721Semaste case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; 1270254721Semaste case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; 1271254721Semaste case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; 1272254721Semaste } 1273254721Semaste break; 1274254721Semaste case e_slonglong: 1275254721Semaste switch (rhs.m_type) 1276254721Semaste { 1277254721Semaste case e_void: 1278254721Semaste case e_float: 1279254721Semaste case e_double: 1280254721Semaste case e_long_double: 1281254721Semaste m_type = e_void; 1282254721Semaste break; 1283254721Semaste case e_sint: m_data.slonglong >>= rhs.m_data.sint; break; 1284254721Semaste case e_uint: m_data.slonglong >>= rhs.m_data.uint; break; 1285254721Semaste case e_slong: m_data.slonglong >>= rhs.m_data.slong; break; 1286254721Semaste case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break; 1287254721Semaste case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break; 1288254721Semaste case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break; 1289254721Semaste } 1290254721Semaste break; 1291254721Semaste 1292254721Semaste case e_ulonglong: 1293254721Semaste switch (rhs.m_type) 1294254721Semaste { 1295254721Semaste case e_void: 1296254721Semaste case e_float: 1297254721Semaste case e_double: 1298254721Semaste case e_long_double: 1299254721Semaste m_type = e_void; 1300254721Semaste break; 1301254721Semaste case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; 1302254721Semaste case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; 1303254721Semaste case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; 1304254721Semaste case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; 1305254721Semaste case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; 1306254721Semaste case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; 1307254721Semaste } 1308254721Semaste break; 1309254721Semaste } 1310254721Semaste return *this; 1311254721Semaste} 1312254721Semaste 1313254721Semaste 1314254721SemasteScalar& 1315254721SemasteScalar::operator&= (const Scalar& rhs) 1316254721Semaste{ 1317254721Semaste switch (m_type) 1318254721Semaste { 1319254721Semaste case e_void: 1320254721Semaste case e_float: 1321254721Semaste case e_double: 1322254721Semaste case e_long_double: 1323254721Semaste m_type = e_void; 1324254721Semaste break; 1325254721Semaste 1326254721Semaste case e_sint: 1327254721Semaste switch (rhs.m_type) 1328254721Semaste { 1329254721Semaste case e_void: 1330254721Semaste case e_float: 1331254721Semaste case e_double: 1332254721Semaste case e_long_double: 1333254721Semaste m_type = e_void; 1334254721Semaste break; 1335254721Semaste case e_sint: m_data.sint &= rhs.m_data.sint; break; 1336254721Semaste case e_uint: m_data.sint &= rhs.m_data.uint; break; 1337254721Semaste case e_slong: m_data.sint &= rhs.m_data.slong; break; 1338254721Semaste case e_ulong: m_data.sint &= rhs.m_data.ulong; break; 1339254721Semaste case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break; 1340254721Semaste case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break; 1341254721Semaste } 1342254721Semaste break; 1343254721Semaste 1344254721Semaste case e_uint: 1345254721Semaste switch (rhs.m_type) 1346254721Semaste { 1347254721Semaste case e_void: 1348254721Semaste case e_float: 1349254721Semaste case e_double: 1350254721Semaste case e_long_double: 1351254721Semaste m_type = e_void; 1352254721Semaste break; 1353254721Semaste case e_sint: m_data.uint &= rhs.m_data.sint; break; 1354254721Semaste case e_uint: m_data.uint &= rhs.m_data.uint; break; 1355254721Semaste case e_slong: m_data.uint &= rhs.m_data.slong; break; 1356254721Semaste case e_ulong: m_data.uint &= rhs.m_data.ulong; break; 1357254721Semaste case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break; 1358254721Semaste case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break; 1359254721Semaste } 1360254721Semaste break; 1361254721Semaste 1362254721Semaste case e_slong: 1363254721Semaste switch (rhs.m_type) 1364254721Semaste { 1365254721Semaste case e_void: 1366254721Semaste case e_float: 1367254721Semaste case e_double: 1368254721Semaste case e_long_double: 1369254721Semaste m_type = e_void; 1370254721Semaste break; 1371254721Semaste case e_sint: m_data.slong &= rhs.m_data.sint; break; 1372254721Semaste case e_uint: m_data.slong &= rhs.m_data.uint; break; 1373254721Semaste case e_slong: m_data.slong &= rhs.m_data.slong; break; 1374254721Semaste case e_ulong: m_data.slong &= rhs.m_data.ulong; break; 1375254721Semaste case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break; 1376254721Semaste case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break; 1377254721Semaste } 1378254721Semaste break; 1379254721Semaste 1380254721Semaste case e_ulong: 1381254721Semaste switch (rhs.m_type) 1382254721Semaste { 1383254721Semaste case e_void: 1384254721Semaste case e_float: 1385254721Semaste case e_double: 1386254721Semaste case e_long_double: 1387254721Semaste m_type = e_void; 1388254721Semaste break; 1389254721Semaste case e_sint: m_data.ulong &= rhs.m_data.sint; break; 1390254721Semaste case e_uint: m_data.ulong &= rhs.m_data.uint; break; 1391254721Semaste case e_slong: m_data.ulong &= rhs.m_data.slong; break; 1392254721Semaste case e_ulong: m_data.ulong &= rhs.m_data.ulong; break; 1393254721Semaste case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break; 1394254721Semaste case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break; 1395254721Semaste } 1396254721Semaste break; 1397254721Semaste case e_slonglong: 1398254721Semaste switch (rhs.m_type) 1399254721Semaste { 1400254721Semaste case e_void: 1401254721Semaste case e_float: 1402254721Semaste case e_double: 1403254721Semaste case e_long_double: 1404254721Semaste m_type = e_void; 1405254721Semaste break; 1406254721Semaste case e_sint: m_data.slonglong &= rhs.m_data.sint; break; 1407254721Semaste case e_uint: m_data.slonglong &= rhs.m_data.uint; break; 1408254721Semaste case e_slong: m_data.slonglong &= rhs.m_data.slong; break; 1409254721Semaste case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break; 1410254721Semaste case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break; 1411254721Semaste case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break; 1412254721Semaste } 1413254721Semaste break; 1414254721Semaste 1415254721Semaste case e_ulonglong: 1416254721Semaste switch (rhs.m_type) 1417254721Semaste { 1418254721Semaste case e_void: 1419254721Semaste case e_float: 1420254721Semaste case e_double: 1421254721Semaste case e_long_double: 1422254721Semaste m_type = e_void; 1423254721Semaste break; 1424254721Semaste case e_sint: m_data.ulonglong &= rhs.m_data.sint; break; 1425254721Semaste case e_uint: m_data.ulonglong &= rhs.m_data.uint; break; 1426254721Semaste case e_slong: m_data.ulonglong &= rhs.m_data.slong; break; 1427254721Semaste case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break; 1428254721Semaste case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break; 1429254721Semaste case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break; 1430254721Semaste } 1431254721Semaste break; 1432254721Semaste } 1433254721Semaste return *this; 1434254721Semaste} 1435254721Semaste 1436254721Semaste 1437254721Semaste 1438254721Semastebool 1439254721SemasteScalar::AbsoluteValue() 1440254721Semaste{ 1441254721Semaste switch (m_type) 1442254721Semaste { 1443254721Semaste case e_void: 1444254721Semaste break; 1445254721Semaste 1446254721Semaste case e_sint: 1447254721Semaste if (m_data.sint < 0) 1448254721Semaste m_data.sint = -m_data.sint; 1449254721Semaste return true; 1450254721Semaste 1451254721Semaste case e_slong: 1452254721Semaste if (m_data.slong < 0) 1453254721Semaste m_data.slong = -m_data.slong; 1454254721Semaste return true; 1455254721Semaste 1456254721Semaste case e_slonglong: 1457254721Semaste if (m_data.slonglong < 0) 1458254721Semaste m_data.slonglong = -m_data.slonglong; 1459254721Semaste return true; 1460254721Semaste 1461254721Semaste case e_uint: 1462254721Semaste case e_ulong: 1463254721Semaste case e_ulonglong: return true; 1464254721Semaste case e_float: m_data.flt = fabsf(m_data.flt); return true; 1465254721Semaste case e_double: m_data.dbl = fabs(m_data.dbl); return true; 1466254721Semaste case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true; 1467254721Semaste } 1468254721Semaste return false; 1469254721Semaste} 1470254721Semaste 1471254721Semaste 1472254721Semastebool 1473254721SemasteScalar::UnaryNegate() 1474254721Semaste{ 1475254721Semaste switch (m_type) 1476254721Semaste { 1477254721Semaste case e_void: break; 1478254721Semaste case e_sint: m_data.sint = -m_data.sint; return true; 1479254721Semaste case e_uint: m_data.uint = -m_data.uint; return true; 1480254721Semaste case e_slong: m_data.slong = -m_data.slong; return true; 1481254721Semaste case e_ulong: m_data.ulong = -m_data.ulong; return true; 1482254721Semaste case e_slonglong: m_data.slonglong = -m_data.slonglong; return true; 1483254721Semaste case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true; 1484254721Semaste case e_float: m_data.flt = -m_data.flt; return true; 1485254721Semaste case e_double: m_data.dbl = -m_data.dbl; return true; 1486254721Semaste case e_long_double: m_data.ldbl = -m_data.ldbl; return true; 1487254721Semaste } 1488254721Semaste return false; 1489254721Semaste} 1490254721Semaste 1491254721Semastebool 1492254721SemasteScalar::OnesComplement() 1493254721Semaste{ 1494254721Semaste switch (m_type) 1495254721Semaste { 1496254721Semaste case e_sint: m_data.sint = ~m_data.sint; return true; 1497254721Semaste case e_uint: m_data.uint = ~m_data.uint; return true; 1498254721Semaste case e_slong: m_data.slong = ~m_data.slong; return true; 1499254721Semaste case e_ulong: m_data.ulong = ~m_data.ulong; return true; 1500254721Semaste case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true; 1501254721Semaste case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true; 1502254721Semaste 1503254721Semaste case e_void: 1504254721Semaste case e_float: 1505254721Semaste case e_double: 1506254721Semaste case e_long_double: 1507254721Semaste break; 1508254721Semaste } 1509254721Semaste return false; 1510254721Semaste} 1511254721Semaste 1512254721Semaste 1513254721Semasteconst Scalar 1514254721Semastelldb_private::operator+ (const Scalar& lhs, const Scalar& rhs) 1515254721Semaste{ 1516254721Semaste Scalar result; 1517254721Semaste Scalar temp_value; 1518254721Semaste const Scalar* a; 1519254721Semaste const Scalar* b; 1520254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1521254721Semaste { 1522254721Semaste switch (result.m_type) 1523254721Semaste { 1524254721Semaste case Scalar::e_void: break; 1525254721Semaste case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break; 1526254721Semaste case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break; 1527254721Semaste case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break; 1528254721Semaste case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; 1529254721Semaste case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; 1530254721Semaste case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; 1531254721Semaste case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break; 1532254721Semaste case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; 1533254721Semaste case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; 1534254721Semaste } 1535254721Semaste } 1536254721Semaste return result; 1537254721Semaste} 1538254721Semaste 1539254721Semaste 1540254721Semasteconst Scalar 1541254721Semastelldb_private::operator- (const Scalar& lhs, const Scalar& rhs) 1542254721Semaste{ 1543254721Semaste Scalar result; 1544254721Semaste Scalar temp_value; 1545254721Semaste const Scalar* a; 1546254721Semaste const Scalar* b; 1547254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1548254721Semaste { 1549254721Semaste switch (result.m_type) 1550254721Semaste { 1551254721Semaste case Scalar::e_void: break; 1552254721Semaste case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break; 1553254721Semaste case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break; 1554254721Semaste case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break; 1555254721Semaste case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break; 1556254721Semaste case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break; 1557254721Semaste case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break; 1558254721Semaste case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break; 1559254721Semaste case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break; 1560254721Semaste case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break; 1561254721Semaste } 1562254721Semaste } 1563254721Semaste return result; 1564254721Semaste} 1565254721Semaste 1566254721Semasteconst Scalar 1567254721Semastelldb_private::operator/ (const Scalar& lhs, const Scalar& rhs) 1568254721Semaste{ 1569254721Semaste Scalar result; 1570254721Semaste Scalar temp_value; 1571254721Semaste const Scalar* a; 1572254721Semaste const Scalar* b; 1573254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1574254721Semaste { 1575254721Semaste switch (result.m_type) 1576254721Semaste { 1577254721Semaste case Scalar::e_void: break; 1578254721Semaste 1579254721Semaste 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; 1580254721Semaste 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; 1581254721Semaste 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; 1582254721Semaste 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; 1583254721Semaste 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; 1584254721Semaste 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; 1585254721Semaste 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; 1586254721Semaste 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; 1587254721Semaste 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; 1588254721Semaste } 1589254721Semaste } 1590254721Semaste // For division only, the only way it should make it here is if a promotion failed, 1591254721Semaste // or if we are trying to do a divide by zero. 1592254721Semaste result.m_type = Scalar::e_void; 1593254721Semaste return result; 1594254721Semaste} 1595254721Semaste 1596254721Semasteconst Scalar 1597254721Semastelldb_private::operator* (const Scalar& lhs, const Scalar& rhs) 1598254721Semaste{ 1599254721Semaste Scalar result; 1600254721Semaste Scalar temp_value; 1601254721Semaste const Scalar* a; 1602254721Semaste const Scalar* b; 1603254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1604254721Semaste { 1605254721Semaste switch (result.m_type) 1606254721Semaste { 1607254721Semaste case Scalar::e_void: break; 1608254721Semaste case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break; 1609254721Semaste case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break; 1610254721Semaste case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break; 1611254721Semaste case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break; 1612254721Semaste case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break; 1613254721Semaste case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break; 1614254721Semaste case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break; 1615254721Semaste case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break; 1616254721Semaste case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break; 1617254721Semaste } 1618254721Semaste } 1619254721Semaste return result; 1620254721Semaste} 1621254721Semaste 1622254721Semasteconst Scalar 1623254721Semastelldb_private::operator& (const Scalar& lhs, const Scalar& rhs) 1624254721Semaste{ 1625254721Semaste Scalar result; 1626254721Semaste Scalar temp_value; 1627254721Semaste const Scalar* a; 1628254721Semaste const Scalar* b; 1629254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1630254721Semaste { 1631254721Semaste switch (result.m_type) 1632254721Semaste { 1633254721Semaste case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break; 1634254721Semaste case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break; 1635254721Semaste case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break; 1636254721Semaste case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break; 1637254721Semaste case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break; 1638254721Semaste case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break; 1639254721Semaste 1640254721Semaste case Scalar::e_void: 1641254721Semaste case Scalar::e_float: 1642254721Semaste case Scalar::e_double: 1643254721Semaste case Scalar::e_long_double: 1644254721Semaste // No bitwise AND on floats, doubles of long doubles 1645254721Semaste result.m_type = Scalar::e_void; 1646254721Semaste break; 1647254721Semaste } 1648254721Semaste } 1649254721Semaste return result; 1650254721Semaste} 1651254721Semaste 1652254721Semasteconst Scalar 1653254721Semastelldb_private::operator| (const Scalar& lhs, const Scalar& rhs) 1654254721Semaste{ 1655254721Semaste Scalar result; 1656254721Semaste Scalar temp_value; 1657254721Semaste const Scalar* a; 1658254721Semaste const Scalar* b; 1659254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1660254721Semaste { 1661254721Semaste switch (result.m_type) 1662254721Semaste { 1663254721Semaste case Scalar::e_sint: result.m_data.sint = a->m_data.sint | b->m_data.sint; break; 1664254721Semaste case Scalar::e_uint: result.m_data.uint = a->m_data.uint | b->m_data.uint; break; 1665254721Semaste case Scalar::e_slong: result.m_data.slong = a->m_data.slong | b->m_data.slong; break; 1666254721Semaste case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong | b->m_data.ulong; break; 1667254721Semaste case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong | b->m_data.slonglong; break; 1668254721Semaste case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong | b->m_data.ulonglong; break; 1669254721Semaste 1670254721Semaste case Scalar::e_void: 1671254721Semaste case Scalar::e_float: 1672254721Semaste case Scalar::e_double: 1673254721Semaste case Scalar::e_long_double: 1674254721Semaste // No bitwise AND on floats, doubles of long doubles 1675254721Semaste result.m_type = Scalar::e_void; 1676254721Semaste break; 1677254721Semaste } 1678254721Semaste } 1679254721Semaste return result; 1680254721Semaste} 1681254721Semaste 1682254721Semasteconst Scalar 1683254721Semastelldb_private::operator% (const Scalar& lhs, const Scalar& rhs) 1684254721Semaste{ 1685254721Semaste Scalar result; 1686254721Semaste Scalar temp_value; 1687254721Semaste const Scalar* a; 1688254721Semaste const Scalar* b; 1689254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1690254721Semaste { 1691254721Semaste switch (result.m_type) 1692254721Semaste { 1693254721Semaste default: break; 1694254721Semaste 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; 1695254721Semaste 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; 1696254721Semaste 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; 1697254721Semaste 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; 1698254721Semaste 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; 1699254721Semaste 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; 1700254721Semaste } 1701254721Semaste } 1702254721Semaste result.m_type = Scalar::e_void; 1703254721Semaste return result; 1704254721Semaste} 1705254721Semaste 1706254721Semasteconst Scalar 1707254721Semastelldb_private::operator^ (const Scalar& lhs, const Scalar& rhs) 1708254721Semaste{ 1709254721Semaste Scalar result; 1710254721Semaste Scalar temp_value; 1711254721Semaste const Scalar* a; 1712254721Semaste const Scalar* b; 1713254721Semaste if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1714254721Semaste { 1715254721Semaste switch (result.m_type) 1716254721Semaste { 1717254721Semaste case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break; 1718254721Semaste case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break; 1719254721Semaste case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break; 1720254721Semaste case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break; 1721254721Semaste case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break; 1722254721Semaste case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break; 1723254721Semaste 1724254721Semaste case Scalar::e_void: 1725254721Semaste case Scalar::e_float: 1726254721Semaste case Scalar::e_double: 1727254721Semaste case Scalar::e_long_double: 1728254721Semaste // No bitwise AND on floats, doubles of long doubles 1729254721Semaste result.m_type = Scalar::e_void; 1730254721Semaste break; 1731254721Semaste } 1732254721Semaste } 1733254721Semaste return result; 1734254721Semaste} 1735254721Semaste 1736254721Semasteconst Scalar 1737254721Semastelldb_private::operator<< (const Scalar& lhs, const Scalar &rhs) 1738254721Semaste{ 1739254721Semaste Scalar result = lhs; 1740254721Semaste result <<= rhs; 1741254721Semaste return result; 1742254721Semaste} 1743254721Semaste 1744254721Semasteconst Scalar 1745254721Semastelldb_private::operator>> (const Scalar& lhs, const Scalar &rhs) 1746254721Semaste{ 1747254721Semaste Scalar result = lhs; 1748254721Semaste result >>= rhs; 1749254721Semaste return result; 1750254721Semaste} 1751254721Semaste 1752254721Semaste// Return the raw unsigned integer without any casting or conversion 1753254721Semasteunsigned int 1754254721SemasteScalar::RawUInt () const 1755254721Semaste{ 1756254721Semaste return m_data.uint; 1757254721Semaste} 1758254721Semaste 1759254721Semaste// Return the raw unsigned long without any casting or conversion 1760254721Semasteunsigned long 1761254721SemasteScalar::RawULong () const 1762254721Semaste{ 1763254721Semaste return m_data.ulong; 1764254721Semaste} 1765254721Semaste 1766254721Semaste// Return the raw unsigned long long without any casting or conversion 1767254721Semasteunsigned long long 1768254721SemasteScalar::RawULongLong () const 1769254721Semaste{ 1770254721Semaste return m_data.ulonglong; 1771254721Semaste} 1772254721Semaste 1773254721Semaste 1774254721SemasteError 1775254721SemasteScalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size) 1776254721Semaste{ 1777254721Semaste Error error; 1778254721Semaste if (value_str == NULL || value_str[0] == '\0') 1779254721Semaste { 1780254721Semaste error.SetErrorString ("Invalid c-string value string."); 1781254721Semaste return error; 1782254721Semaste } 1783254721Semaste bool success = false; 1784254721Semaste switch (encoding) 1785254721Semaste { 1786254721Semaste case eEncodingInvalid: 1787254721Semaste error.SetErrorString ("Invalid encoding."); 1788254721Semaste break; 1789254721Semaste 1790254721Semaste case eEncodingUint: 1791254721Semaste if (byte_size <= sizeof (unsigned long long)) 1792254721Semaste { 1793254721Semaste uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success); 1794254721Semaste if (!success) 1795254721Semaste error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str); 1796254721Semaste else if (!UIntValueIsValidForSize (uval64, byte_size)) 1797254721Semaste error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte unsigned integer value", uval64, byte_size); 1798254721Semaste else 1799254721Semaste { 1800254721Semaste m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size); 1801254721Semaste switch (m_type) 1802254721Semaste { 1803254721Semaste case e_uint: m_data.uint = (uint_t)uval64; break; 1804254721Semaste case e_ulong: m_data.ulong = (ulong_t)uval64; break; 1805254721Semaste case e_ulonglong: m_data.ulonglong = (ulonglong_t)uval64; break; 1806254721Semaste default: 1807254721Semaste error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size); 1808254721Semaste break; 1809254721Semaste } 1810254721Semaste } 1811254721Semaste } 1812254721Semaste else 1813254721Semaste { 1814254721Semaste error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size); 1815254721Semaste return error; 1816254721Semaste } 1817254721Semaste break; 1818254721Semaste 1819254721Semaste case eEncodingSint: 1820254721Semaste if (byte_size <= sizeof (long long)) 1821254721Semaste { 1822254721Semaste uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success); 1823254721Semaste if (!success) 1824254721Semaste error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str); 1825254721Semaste else if (!SIntValueIsValidForSize (sval64, byte_size)) 1826254721Semaste error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte signed integer value", sval64, byte_size); 1827254721Semaste else 1828254721Semaste { 1829254721Semaste m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size); 1830254721Semaste switch (m_type) 1831254721Semaste { 1832254721Semaste case e_sint: m_data.sint = (sint_t)sval64; break; 1833254721Semaste case e_slong: m_data.slong = (slong_t)sval64; break; 1834254721Semaste case e_slonglong: m_data.slonglong = (slonglong_t)sval64; break; 1835254721Semaste default: 1836254721Semaste error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size); 1837254721Semaste break; 1838254721Semaste } 1839254721Semaste } 1840254721Semaste } 1841254721Semaste else 1842254721Semaste { 1843254721Semaste error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size); 1844254721Semaste return error; 1845254721Semaste } 1846254721Semaste break; 1847254721Semaste 1848254721Semaste case eEncodingIEEE754: 1849254721Semaste if (byte_size == sizeof (float)) 1850254721Semaste { 1851254721Semaste if (::sscanf (value_str, "%f", &m_data.flt) == 1) 1852254721Semaste m_type = e_float; 1853254721Semaste else 1854254721Semaste error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 1855254721Semaste } 1856254721Semaste else if (byte_size == sizeof (double)) 1857254721Semaste { 1858254721Semaste if (::sscanf (value_str, "%lf", &m_data.dbl) == 1) 1859254721Semaste m_type = e_double; 1860254721Semaste else 1861254721Semaste error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 1862254721Semaste } 1863254721Semaste else if (byte_size == sizeof (long double)) 1864254721Semaste { 1865254721Semaste if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1) 1866254721Semaste m_type = e_long_double; 1867254721Semaste else 1868254721Semaste error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 1869254721Semaste } 1870254721Semaste else 1871254721Semaste { 1872254721Semaste error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size); 1873254721Semaste return error; 1874254721Semaste } 1875254721Semaste break; 1876254721Semaste 1877254721Semaste case eEncodingVector: 1878254721Semaste error.SetErrorString ("vector encoding unsupported."); 1879254721Semaste break; 1880254721Semaste } 1881254721Semaste if (error.Fail()) 1882254721Semaste m_type = e_void; 1883254721Semaste 1884254721Semaste return error; 1885254721Semaste} 1886254721Semaste 1887254721SemasteError 1888254721SemasteScalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size) 1889254721Semaste{ 1890254721Semaste Error error; 1891254721Semaste 1892254721Semaste switch (encoding) 1893254721Semaste { 1894254721Semaste case lldb::eEncodingInvalid: 1895254721Semaste error.SetErrorString ("invalid encoding"); 1896254721Semaste break; 1897254721Semaste case lldb::eEncodingVector: 1898254721Semaste error.SetErrorString ("vector encoding unsupported"); 1899254721Semaste break; 1900254721Semaste case lldb::eEncodingUint: 1901254721Semaste { 1902254721Semaste lldb::offset_t offset; 1903254721Semaste 1904254721Semaste switch (byte_size) 1905254721Semaste { 1906254721Semaste case 1: operator=((uint8_t)data.GetU8(&offset)); break; 1907254721Semaste case 2: operator=((uint16_t)data.GetU16(&offset)); break; 1908254721Semaste case 4: operator=((uint32_t)data.GetU32(&offset)); break; 1909254721Semaste case 8: operator=((uint64_t)data.GetU64(&offset)); break; 1910254721Semaste default: 1911254721Semaste error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size); 1912254721Semaste break; 1913254721Semaste } 1914254721Semaste } 1915254721Semaste break; 1916254721Semaste case lldb::eEncodingSint: 1917254721Semaste { 1918254721Semaste lldb::offset_t offset; 1919254721Semaste 1920254721Semaste switch (byte_size) 1921254721Semaste { 1922254721Semaste case 1: operator=((int8_t)data.GetU8(&offset)); break; 1923254721Semaste case 2: operator=((int16_t)data.GetU16(&offset)); break; 1924254721Semaste case 4: operator=((int32_t)data.GetU32(&offset)); break; 1925254721Semaste case 8: operator=((int64_t)data.GetU64(&offset)); break; 1926254721Semaste default: 1927254721Semaste error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size); 1928254721Semaste break; 1929254721Semaste } 1930254721Semaste } 1931254721Semaste break; 1932254721Semaste case lldb::eEncodingIEEE754: 1933254721Semaste { 1934254721Semaste lldb::offset_t offset; 1935254721Semaste 1936254721Semaste if (byte_size == sizeof (float)) 1937254721Semaste operator=((float)data.GetFloat(&offset)); 1938254721Semaste else if (byte_size == sizeof (double)) 1939254721Semaste operator=((double)data.GetDouble(&offset)); 1940254721Semaste else if (byte_size == sizeof (long double)) 1941254721Semaste operator=((long double)data.GetLongDouble(&offset)); 1942254721Semaste else 1943254721Semaste error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size); 1944254721Semaste } 1945254721Semaste break; 1946254721Semaste } 1947254721Semaste 1948254721Semaste return error; 1949254721Semaste} 1950254721Semaste 1951254721Semastebool 1952254721SemasteScalar::SignExtend (uint32_t sign_bit_pos) 1953254721Semaste{ 1954254721Semaste const uint32_t max_bit_pos = GetByteSize() * 8; 1955254721Semaste 1956254721Semaste if (sign_bit_pos < max_bit_pos) 1957254721Semaste { 1958254721Semaste switch (m_type) 1959254721Semaste { 1960254721Semaste case Scalar::e_void: 1961254721Semaste case Scalar::e_float: 1962254721Semaste case Scalar::e_double: 1963254721Semaste case Scalar::e_long_double: 1964254721Semaste return false; 1965254721Semaste 1966254721Semaste case Scalar::e_sint: 1967254721Semaste case Scalar::e_uint: 1968254721Semaste if (max_bit_pos == sign_bit_pos) 1969254721Semaste return true; 1970254721Semaste else if (sign_bit_pos < (max_bit_pos-1)) 1971254721Semaste { 1972254721Semaste unsigned int sign_bit = 1u << sign_bit_pos; 1973254721Semaste if (m_data.uint & sign_bit) 1974254721Semaste { 1975254721Semaste const unsigned int mask = ~(sign_bit) + 1u; 1976254721Semaste m_data.uint |= mask; 1977254721Semaste } 1978254721Semaste return true; 1979254721Semaste } 1980254721Semaste break; 1981254721Semaste 1982254721Semaste case Scalar::e_slong: 1983254721Semaste case Scalar::e_ulong: 1984254721Semaste if (max_bit_pos == sign_bit_pos) 1985254721Semaste return true; 1986254721Semaste else if (sign_bit_pos < (max_bit_pos-1)) 1987254721Semaste { 1988254721Semaste unsigned long sign_bit = 1ul << sign_bit_pos; 1989254721Semaste if (m_data.ulong & sign_bit) 1990254721Semaste { 1991254721Semaste const unsigned long mask = ~(sign_bit) + 1ul; 1992254721Semaste m_data.ulong |= mask; 1993254721Semaste } 1994254721Semaste return true; 1995254721Semaste } 1996254721Semaste break; 1997254721Semaste 1998254721Semaste case Scalar::e_slonglong: 1999254721Semaste case Scalar::e_ulonglong: 2000254721Semaste if (max_bit_pos == sign_bit_pos) 2001254721Semaste return true; 2002254721Semaste else if (sign_bit_pos < (max_bit_pos-1)) 2003254721Semaste { 2004254721Semaste unsigned long long sign_bit = 1ull << sign_bit_pos; 2005254721Semaste if (m_data.ulonglong & sign_bit) 2006254721Semaste { 2007254721Semaste const unsigned long long mask = ~(sign_bit) + 1ull; 2008254721Semaste m_data.ulonglong |= mask; 2009254721Semaste } 2010254721Semaste return true; 2011254721Semaste } 2012254721Semaste break; 2013254721Semaste } 2014254721Semaste } 2015254721Semaste return false; 2016254721Semaste} 2017254721Semaste 2018254721Semastesize_t 2019254721SemasteScalar::GetAsMemoryData (void *dst, 2020254721Semaste size_t dst_len, 2021254721Semaste lldb::ByteOrder dst_byte_order, 2022254721Semaste Error &error) const 2023254721Semaste{ 2024254721Semaste // Get a data extractor that points to the native scalar data 2025254721Semaste DataExtractor data; 2026254721Semaste if (!GetData(data)) 2027254721Semaste { 2028254721Semaste error.SetErrorString ("invalid scalar value"); 2029254721Semaste return 0; 2030254721Semaste } 2031254721Semaste 2032254721Semaste const size_t src_len = data.GetByteSize(); 2033254721Semaste 2034254721Semaste // Prepare a memory buffer that contains some or all of the register value 2035254721Semaste const size_t bytes_copied = data.CopyByteOrderedData (0, // src offset 2036254721Semaste src_len, // src length 2037254721Semaste dst, // dst buffer 2038254721Semaste dst_len, // dst length 2039254721Semaste dst_byte_order); // dst byte order 2040254721Semaste if (bytes_copied == 0) 2041254721Semaste error.SetErrorString ("failed to copy data"); 2042254721Semaste 2043254721Semaste return bytes_copied; 2044254721Semaste} 2045254721Semaste 2046254721Semastebool 2047254721SemasteScalar::ExtractBitfield (uint32_t bit_size, 2048254721Semaste uint32_t bit_offset) 2049254721Semaste{ 2050254721Semaste if (bit_size == 0) 2051254721Semaste return true; 2052254721Semaste 2053254721Semaste uint32_t msbit = bit_offset + bit_size - 1; 2054254721Semaste uint32_t lsbit = bit_offset; 2055254721Semaste switch (m_type) 2056254721Semaste { 2057254721Semaste case Scalar::e_void: 2058254721Semaste break; 2059254721Semaste 2060254721Semaste case e_float: 2061254721Semaste if (sizeof(m_data.flt) == sizeof(sint_t)) 2062254721Semaste m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit); 2063254721Semaste else if (sizeof(m_data.flt) == sizeof(ulong_t)) 2064254721Semaste m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit); 2065254721Semaste else if (sizeof(m_data.flt) == sizeof(ulonglong_t)) 2066254721Semaste m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit); 2067254721Semaste else 2068254721Semaste return false; 2069254721Semaste return true; 2070254721Semaste 2071254721Semaste case e_double: 2072254721Semaste if (sizeof(m_data.dbl) == sizeof(sint_t)) 2073254721Semaste m_data.sint = SignedBits (m_data.sint, msbit, lsbit); 2074254721Semaste else if (sizeof(m_data.dbl) == sizeof(ulong_t)) 2075254721Semaste m_data.slong = SignedBits (m_data.slong, msbit, lsbit); 2076254721Semaste else if (sizeof(m_data.dbl) == sizeof(ulonglong_t)) 2077254721Semaste m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit); 2078254721Semaste else 2079254721Semaste return false; 2080254721Semaste return true; 2081254721Semaste 2082254721Semaste case e_long_double: 2083254721Semaste if (sizeof(m_data.ldbl) == sizeof(sint_t)) 2084254721Semaste m_data.sint = SignedBits (m_data.sint, msbit, lsbit); 2085254721Semaste else if (sizeof(m_data.ldbl) == sizeof(ulong_t)) 2086254721Semaste m_data.slong = SignedBits (m_data.slong, msbit, lsbit); 2087254721Semaste else if (sizeof(m_data.ldbl) == sizeof(ulonglong_t)) 2088254721Semaste m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit); 2089254721Semaste else 2090254721Semaste return false; 2091254721Semaste return true; 2092254721Semaste 2093254721Semaste case Scalar::e_sint: 2094254721Semaste m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit); 2095254721Semaste return true; 2096254721Semaste 2097254721Semaste case Scalar::e_uint: 2098254721Semaste m_data.uint = (uint_t)UnsignedBits (m_data.uint, msbit, lsbit); 2099254721Semaste return true; 2100254721Semaste 2101254721Semaste case Scalar::e_slong: 2102254721Semaste m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit); 2103254721Semaste return true; 2104254721Semaste 2105254721Semaste case Scalar::e_ulong: 2106254721Semaste m_data.ulong = (ulong_t)UnsignedBits (m_data.ulong, msbit, lsbit); 2107254721Semaste return true; 2108254721Semaste 2109254721Semaste case Scalar::e_slonglong: 2110254721Semaste m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit); 2111254721Semaste return true; 2112254721Semaste 2113254721Semaste case Scalar::e_ulonglong: 2114254721Semaste m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit); 2115254721Semaste return true; 2116254721Semaste } 2117254721Semaste return false; 2118254721Semaste} 2119254721Semaste 2120254721Semaste 2121254721Semaste 2122254721Semaste 2123254721Semaste 2124254721Semastebool 2125254721Semastelldb_private::operator== (const Scalar& lhs, const Scalar& rhs) 2126254721Semaste{ 2127254721Semaste // If either entry is void then we can just compare the types 2128254721Semaste if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2129254721Semaste return lhs.m_type == rhs.m_type; 2130254721Semaste 2131254721Semaste Scalar temp_value; 2132254721Semaste const Scalar* a; 2133254721Semaste const Scalar* b; 2134254721Semaste switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2135254721Semaste { 2136254721Semaste case Scalar::e_void: break; 2137254721Semaste case Scalar::e_sint: return a->m_data.sint == b->m_data.sint; 2138254721Semaste case Scalar::e_uint: return a->m_data.uint == b->m_data.uint; 2139254721Semaste case Scalar::e_slong: return a->m_data.slong == b->m_data.slong; 2140254721Semaste case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong; 2141254721Semaste case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong; 2142254721Semaste case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong; 2143254721Semaste case Scalar::e_float: return a->m_data.flt == b->m_data.flt; 2144254721Semaste case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl; 2145254721Semaste case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl; 2146254721Semaste } 2147254721Semaste return false; 2148254721Semaste} 2149254721Semaste 2150254721Semastebool 2151254721Semastelldb_private::operator!= (const Scalar& lhs, const Scalar& rhs) 2152254721Semaste{ 2153254721Semaste // If either entry is void then we can just compare the types 2154254721Semaste if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2155254721Semaste return lhs.m_type != rhs.m_type; 2156254721Semaste 2157254721Semaste Scalar temp_value; // A temp value that might get a copy of either promoted value 2158254721Semaste const Scalar* a; 2159254721Semaste const Scalar* b; 2160254721Semaste switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2161254721Semaste { 2162254721Semaste case Scalar::e_void: break; 2163254721Semaste case Scalar::e_sint: return a->m_data.sint != b->m_data.sint; 2164254721Semaste case Scalar::e_uint: return a->m_data.uint != b->m_data.uint; 2165254721Semaste case Scalar::e_slong: return a->m_data.slong != b->m_data.slong; 2166254721Semaste case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong; 2167254721Semaste case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong; 2168254721Semaste case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong; 2169254721Semaste case Scalar::e_float: return a->m_data.flt != b->m_data.flt; 2170254721Semaste case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl; 2171254721Semaste case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl; 2172254721Semaste } 2173254721Semaste return true; 2174254721Semaste} 2175254721Semaste 2176254721Semastebool 2177254721Semastelldb_private::operator< (const Scalar& lhs, const Scalar& rhs) 2178254721Semaste{ 2179254721Semaste if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2180254721Semaste return false; 2181254721Semaste 2182254721Semaste Scalar temp_value; 2183254721Semaste const Scalar* a; 2184254721Semaste const Scalar* b; 2185254721Semaste switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2186254721Semaste { 2187254721Semaste case Scalar::e_void: break; 2188254721Semaste case Scalar::e_sint: return a->m_data.sint < b->m_data.sint; 2189254721Semaste case Scalar::e_uint: return a->m_data.uint < b->m_data.uint; 2190254721Semaste case Scalar::e_slong: return a->m_data.slong < b->m_data.slong; 2191254721Semaste case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong; 2192254721Semaste case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong; 2193254721Semaste case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong; 2194254721Semaste case Scalar::e_float: return a->m_data.flt < b->m_data.flt; 2195254721Semaste case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl; 2196254721Semaste case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl; 2197254721Semaste } 2198254721Semaste return false; 2199254721Semaste} 2200254721Semaste 2201254721Semastebool 2202254721Semastelldb_private::operator<= (const Scalar& lhs, const Scalar& rhs) 2203254721Semaste{ 2204254721Semaste if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2205254721Semaste return false; 2206254721Semaste 2207254721Semaste Scalar temp_value; 2208254721Semaste const Scalar* a; 2209254721Semaste const Scalar* b; 2210254721Semaste switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2211254721Semaste { 2212254721Semaste case Scalar::e_void: break; 2213254721Semaste case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint; 2214254721Semaste case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint; 2215254721Semaste case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong; 2216254721Semaste case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong; 2217254721Semaste case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong; 2218254721Semaste case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong; 2219254721Semaste case Scalar::e_float: return a->m_data.flt <= b->m_data.flt; 2220254721Semaste case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl; 2221254721Semaste case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl; 2222254721Semaste } 2223254721Semaste return false; 2224254721Semaste} 2225254721Semaste 2226254721Semaste 2227254721Semastebool 2228254721Semastelldb_private::operator> (const Scalar& lhs, const Scalar& rhs) 2229254721Semaste{ 2230254721Semaste if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2231254721Semaste return false; 2232254721Semaste 2233254721Semaste Scalar temp_value; 2234254721Semaste const Scalar* a; 2235254721Semaste const Scalar* b; 2236254721Semaste switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2237254721Semaste { 2238254721Semaste case Scalar::e_void: break; 2239254721Semaste case Scalar::e_sint: return a->m_data.sint > b->m_data.sint; 2240254721Semaste case Scalar::e_uint: return a->m_data.uint > b->m_data.uint; 2241254721Semaste case Scalar::e_slong: return a->m_data.slong > b->m_data.slong; 2242254721Semaste case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong; 2243254721Semaste case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong; 2244254721Semaste case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong; 2245254721Semaste case Scalar::e_float: return a->m_data.flt > b->m_data.flt; 2246254721Semaste case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl; 2247254721Semaste case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl; 2248254721Semaste } 2249254721Semaste return false; 2250254721Semaste} 2251254721Semaste 2252254721Semastebool 2253254721Semastelldb_private::operator>= (const Scalar& lhs, const Scalar& rhs) 2254254721Semaste{ 2255254721Semaste if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2256254721Semaste return false; 2257254721Semaste 2258254721Semaste Scalar temp_value; 2259254721Semaste const Scalar* a; 2260254721Semaste const Scalar* b; 2261254721Semaste switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2262254721Semaste { 2263254721Semaste case Scalar::e_void: break; 2264254721Semaste case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint; 2265254721Semaste case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint; 2266254721Semaste case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong; 2267254721Semaste case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong; 2268254721Semaste case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong; 2269254721Semaste case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong; 2270254721Semaste case Scalar::e_float: return a->m_data.flt >= b->m_data.flt; 2271254721Semaste case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl; 2272254721Semaste case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl; 2273254721Semaste } 2274254721Semaste return false; 2275254721Semaste} 2276254721Semaste 2277254721Semaste 2278254721Semaste 2279254721Semaste 2280