xref: /external/lldb/source/Core/Scalar.cpp

//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "lldb/Core/Scalar.h"

#include <math.h>
#include <inttypes.h>

#include "lldb/Interpreter/Args.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Host/Endian.h"

#include "Plugins/Process/Utility/InstructionUtils.h"

using namespace lldb;
using namespace lldb_private;

//----------------------------------------------------------------------
// Promote to max type currently follows the ANSI C rule for type
// promotion in expressions.
//----------------------------------------------------------------------
static Scalar::Type
PromoteToMaxType
(
    const Scalar& lhs,                  // The const left hand side object
    const Scalar& rhs,                  // The const right hand side object
    Scalar& temp_value,             // A modifiable temp value than can be used to hold either the promoted lhs or rhs object
    const Scalar* &promoted_lhs_ptr,    // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted)
    const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted)
)
{
    Scalar result;
    // Initialize the promoted values for both the right and left hand side values
    // to be the objects themselves. If no promotion is needed (both right and left
    // have the same type), then the temp_value will not get used.
    promoted_lhs_ptr = &lhs;
    promoted_rhs_ptr = &rhs;
    // Extract the types of both the right and left hand side values
    Scalar::Type lhs_type = lhs.GetType();
    Scalar::Type rhs_type = rhs.GetType();

    if (lhs_type > rhs_type)
    {
        // Right hand side need to be promoted
        temp_value = rhs;                   // Copy right hand side into the temp value
        if (temp_value.Promote(lhs_type))   // Promote it
            promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side
    }
    else if (lhs_type < rhs_type)
    {
        // Left hand side need to be promoted
        temp_value = lhs;                   // Copy left hand side value into the temp value
        if (temp_value.Promote(rhs_type))   // Promote it
            promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
    }

    // Make sure our type promotion worked as exptected
    if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
        return promoted_lhs_ptr->GetType(); // Return the resulting max type

    // Return the void type (zero) if we fail to promote either of the values.
    return Scalar::e_void;
}


//----------------------------------------------------------------------
// Scalar constructor
//----------------------------------------------------------------------
Scalar::Scalar() :
    m_type(e_void),
    m_data()
{
}

//----------------------------------------------------------------------
// Scalar copy constructor
//----------------------------------------------------------------------
Scalar::Scalar(const Scalar& rhs) :
    m_type(rhs.m_type),
    m_data(rhs.m_data)  // TODO: verify that for C++ this will correctly copy the union??
{
}

//Scalar::Scalar(const RegisterValue& reg) :
//  m_type(e_void),
//  m_data()
//{
//  switch (reg.info.encoding)
//  {
//  case eEncodingUint:     // unsigned integer
//      switch (reg.info.byte_size)
//      {
//      case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
//      case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
//      case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
//      case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break;
//      break;
//      }
//      break;
//
//  case eEncodingSint:     // signed integer
//      switch (reg.info.byte_size)
//      {
//      case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
//      case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
//      case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
//      case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break;
//      break;
//      }
//      break;
//
//  case eEncodingIEEE754:  // float
//      switch (reg.info.byte_size)
//      {
//      case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
//      case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
//      break;
//      }
//      break;
//    case eEncodingVector: // vector registers
//      break;
//  }
//}

bool
Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
{
    size_t byte_size = GetByteSize();
    if (byte_size > 0)
    {
        if (limit_byte_size < byte_size)
        {
            if (lldb::endian::InlHostByteOrder() == eByteOrderLittle)
            {
                // On little endian systems if we want fewer bytes from the
                // current type we just specify fewer bytes since the LSByte
                // is first...
                data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder());
            }
            else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
            {
                // On big endian systems if we want fewer bytes from the
                // current type have to advance our initial byte pointer and
                // trim down the number of bytes since the MSByte is first
                data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
            }
        }
        else
        {
            // We want all of the data
            data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder());
        }
        return true;
    }
    data.Clear();
    return false;
}

size_t
Scalar::GetByteSize() const
{
    switch (m_type)
    {
    case e_void:
        break;
    case e_sint:        return sizeof(m_data.sint);
    case e_uint:        return sizeof(m_data.uint);
    case e_slong:       return sizeof(m_data.slong);
    case e_ulong:       return sizeof(m_data.ulong);
    case e_slonglong:   return sizeof(m_data.slonglong);
    case e_ulonglong:   return sizeof(m_data.ulonglong);
    case e_float:       return sizeof(m_data.flt);
    case e_double:      return sizeof(m_data.dbl);
    case e_long_double: return sizeof(m_data.ldbl);
    }
    return 0;
}

bool
Scalar::IsZero() const
{
    switch (m_type)
    {
    case e_void:
        break;
    case e_sint:        return m_data.sint == 0;
    case e_uint:        return m_data.uint == 0;
    case e_slong:       return m_data.slong == 0;
    case e_ulong:       return m_data.ulong == 0;
    case e_slonglong:   return m_data.slonglong == 0;
    case e_ulonglong:   return m_data.ulonglong == 0;
    case e_float:       return m_data.flt == 0.0f;
    case e_double:      return m_data.dbl == 0.0;
    case e_long_double: return m_data.ldbl == 0.0;
    }
    return false;
}

void
Scalar::GetValue (Stream *s, bool show_type) const
{
    if (show_type)
        s->Printf("(%s) ", GetTypeAsCString());

    switch (m_type)
    {
    case e_void:
        break;
    case e_sint:        s->Printf("%i", m_data.sint);               break;
    case e_uint:        s->Printf("0x%8.8x", m_data.uint);          break;
    case e_slong:       s->Printf("%li", m_data.slong);             break;
    case e_ulong:       s->Printf("0x%8.8lx", m_data.ulong);        break;
    case e_slonglong:   s->Printf("%lli", m_data.slonglong);        break;
    case e_ulonglong:   s->Printf("0x%16.16llx", m_data.ulonglong); break;
    case e_float:       s->Printf("%f", m_data.flt);                break;
    case e_double:      s->Printf("%g", m_data.dbl);                break;
    case e_long_double: s->Printf("%Lg", m_data.ldbl);              break;
    }
}

const char *
Scalar::GetTypeAsCString() const
{
    switch (m_type)
    {
    case e_void:        return "void";
    case e_sint:        return "int";
    case e_uint:        return "unsigned int";
    case e_slong:       return "long";
    case e_ulong:       return "unsigned long";
    case e_slonglong:   return "long long";
    case e_ulonglong:   return "unsigned long long";
    case e_float:       return "float";
    case e_double:      return "double";
    case e_long_double: return "long double";
    }
    return "<invalid Scalar type>";
}



//----------------------------------------------------------------------
// Scalar copy constructor
//----------------------------------------------------------------------
Scalar&
Scalar::operator=(const Scalar& rhs)
{
    if (this != &rhs)
    {
        m_type = rhs.m_type;
        ::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
    }
    return *this;
}

Scalar&
Scalar::operator= (const int v)
{
    m_type = e_sint;
    m_data.sint = v;
    return *this;
}


Scalar&
Scalar::operator= (unsigned int v)
{
    m_type = e_uint;
    m_data.uint = v;
    return *this;
}

Scalar&
Scalar::operator= (long v)
{
    m_type = e_slong;
    m_data.slong = v;
    return *this;
}

Scalar&
Scalar::operator= (unsigned long v)
{
    m_type = e_ulong;
    m_data.ulong = v;
    return *this;
}

Scalar&
Scalar::operator= (long long v)
{
    m_type = e_slonglong;
    m_data.slonglong = v;
    return *this;
}

Scalar&
Scalar::operator= (unsigned long long v)
{
    m_type = e_ulonglong;
    m_data.ulonglong = v;
    return *this;
}

Scalar&
Scalar::operator= (float v)
{
    m_type = e_float;
    m_data.flt = v;
    return *this;
}

Scalar&
Scalar::operator= (double v)
{
    m_type = e_double;
    m_data.dbl = v;
    return *this;
}

Scalar&
Scalar::operator= (long double v)
{
    m_type = e_long_double;
    m_data.ldbl = v;
    return *this;
}

//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
Scalar::~Scalar()
{
}

bool
Scalar::Promote(Scalar::Type type)
{
    bool success = false;
    switch (m_type)
    {
    case e_void:
        break;

    case e_sint:
        switch (type)
        {
        case e_void:        break;
        case e_sint:        success = true; break;
        case e_uint:        m_data.uint         = m_data.sint;      success = true; break;
        case e_slong:       m_data.slong        = m_data.sint;      success = true; break;
        case e_ulong:       m_data.ulong        = m_data.sint;      success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.sint;      success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.sint;      success = true; break;
        case e_float:       m_data.flt          = m_data.sint;      success = true; break;
        case e_double:      m_data.dbl          = m_data.sint;      success = true; break;
        case e_long_double: m_data.ldbl         = m_data.sint;      success = true; break;
        }
        break;

    case e_uint:
        switch (type)
        {
        case e_void:
        case e_sint:        break;
        case e_uint:        success = true; break;
        case e_slong:       m_data.slong        = m_data.uint;      success = true; break;
        case e_ulong:       m_data.ulong        = m_data.uint;      success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.uint;      success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.uint;      success = true; break;
        case e_float:       m_data.flt          = m_data.uint;      success = true; break;
        case e_double:      m_data.dbl          = m_data.uint;      success = true; break;
        case e_long_double: m_data.ldbl         = m_data.uint;      success = true; break;
        }
        break;

    case e_slong:
        switch (type)
        {
        case e_void:
        case e_sint:
        case e_uint:        break;
        case e_slong:       success = true; break;
        case e_ulong:       m_data.ulong        = m_data.slong;     success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.slong;     success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.slong;     success = true; break;
        case e_float:       m_data.flt          = m_data.slong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.slong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.slong;     success = true; break;
        }
        break;

    case e_ulong:
        switch (type)
        {
        case e_void:
        case e_sint:
        case e_uint:
        case e_slong:       break;
        case e_ulong:       success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.ulong;     success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.ulong;     success = true; break;
        case e_float:       m_data.flt          = m_data.ulong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.ulong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.ulong;     success = true; break;
        }
        break;

    case e_slonglong:
        switch (type)
        {
        case e_void:
        case e_sint:
        case e_uint:
        case e_slong:
        case e_ulong:       break;
        case e_slonglong:   success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.slonglong;     success = true; break;
        case e_float:       m_data.flt          = m_data.slonglong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.slonglong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.slonglong;     success = true; break;
        }
        break;

    case e_ulonglong:
        switch (type)
        {
        case e_void:
        case e_sint:
        case e_uint:
        case e_slong:
        case e_ulong:
        case e_slonglong:   break;
        case e_ulonglong:   success = true; break;
        case e_float:       m_data.flt          = m_data.ulonglong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.ulonglong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
        }
        break;

    case e_float:
        switch (type)
        {
        case e_void:
        case e_sint:
        case e_uint:
        case e_slong:
        case e_ulong:
        case e_slonglong:
        case e_ulonglong:   break;
        case e_float:       success = true; break;
        case e_double:      m_data.dbl          = m_data.flt;           success = true; break;
        case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
        }
        break;

    case e_double:
        switch (type)
        {
        case e_void:
        case e_sint:
        case e_uint:
        case e_slong:
        case e_ulong:
        case e_slonglong:
        case e_ulonglong:
        case e_float:       break;
        case e_double:      success = true; break;
        case e_long_double: m_data.ldbl         = m_data.dbl;       success = true; break;
        }
        break;

    case e_long_double:
        switch (type)
        {
        case e_void:
        case e_sint:
        case e_uint:
        case e_slong:
        case e_ulong:
        case e_slonglong:
        case e_ulonglong:
        case e_float:
        case e_double:      break;
        case e_long_double: success = true; break;
        }
        break;
    }

    if (success)
        m_type = type;
    return success;
}

const char *
Scalar::GetValueTypeAsCString (Scalar::Type type)
{
    switch (type)
    {
    case e_void:        return "void";
    case e_sint:        return "int";
    case e_uint:        return "unsigned int";
    case e_slong:       return "long";
    case e_ulong:       return "unsigned long";
    case e_slonglong:   return "long long";
    case e_ulonglong:   return "unsigned long long";
    case e_float:       return "float";
    case e_double:      return "double";
    case e_long_double: return "long double";
    }
    return "???";
}


Scalar::Type
Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
{
    if (byte_size <= sizeof(sint_t))
        return e_sint;
    if (byte_size <= sizeof(slong_t))
        return e_slong;
    if (byte_size <= sizeof(slonglong_t))
        return e_slonglong;
    return e_void;
}

Scalar::Type
Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size)
{
    if (byte_size <= sizeof(uint_t))
        return e_uint;
    if (byte_size <= sizeof(ulong_t))
        return e_ulong;
    if (byte_size <= sizeof(ulonglong_t))
        return e_ulonglong;
    return e_void;
}

Scalar::Type
Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size)
{
    if (byte_size == sizeof(float_t))
        return e_float;
    if (byte_size == sizeof(double_t))
        return e_double;
    if (byte_size == sizeof(long_double_t))
        return e_long_double;
    return e_void;
}

bool
Scalar::Cast(Scalar::Type type)
{
    bool success = false;
    switch (m_type)
    {
    case e_void:
        break;

    case e_sint:
        switch (type)
        {
        case e_void:        break;
        case e_sint:        success = true; break;
        case e_uint:        m_data.uint         = m_data.sint;      success = true; break;
        case e_slong:       m_data.slong        = m_data.sint;      success = true; break;
        case e_ulong:       m_data.ulong        = m_data.sint;      success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.sint;      success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.sint;      success = true; break;
        case e_float:       m_data.flt          = m_data.sint;      success = true; break;
        case e_double:      m_data.dbl          = m_data.sint;      success = true; break;
        case e_long_double: m_data.ldbl         = m_data.sint;      success = true; break;
        }
        break;

    case e_uint:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = m_data.uint;      success = true; break;
        case e_uint:        success = true; break;
        case e_slong:       m_data.slong        = m_data.uint;      success = true; break;
        case e_ulong:       m_data.ulong        = m_data.uint;      success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.uint;      success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.uint;      success = true; break;
        case e_float:       m_data.flt          = m_data.uint;      success = true; break;
        case e_double:      m_data.dbl          = m_data.uint;      success = true; break;
        case e_long_double: m_data.ldbl         = m_data.uint;      success = true; break;
        }
        break;

    case e_slong:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = (sint_t)m_data.slong;     success = true; break;
        case e_uint:        m_data.uint         = (uint_t)m_data.slong;     success = true; break;
        case e_slong:       success = true; break;
        case e_ulong:       m_data.ulong        = m_data.slong;     success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.slong;     success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.slong;     success = true; break;
        case e_float:       m_data.flt          = m_data.slong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.slong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.slong;     success = true; break;
        }
        break;

    case e_ulong:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = (sint_t)m_data.ulong;     success = true; break;
        case e_uint:        m_data.uint         = (uint_t)m_data.ulong;     success = true; break;
        case e_slong:       m_data.slong        = m_data.ulong;     success = true; break;
        case e_ulong:       success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.ulong;     success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.ulong;     success = true; break;
        case e_float:       m_data.flt          = m_data.ulong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.ulong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.ulong;     success = true; break;
        }
        break;

    case e_slonglong:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = (sint_t)m_data.slonglong;     success = true; break;
        case e_uint:        m_data.uint         = (uint_t)m_data.slonglong;     success = true; break;
        case e_slong:       m_data.slong        = m_data.slonglong;     success = true; break;
        case e_ulong:       m_data.ulong        = m_data.slonglong;     success = true; break;
        case e_slonglong:   success = true; break;
        case e_ulonglong:   m_data.ulonglong    = m_data.slonglong;     success = true; break;
        case e_float:       m_data.flt          = m_data.slonglong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.slonglong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.slonglong;     success = true; break;
        }
        break;

    case e_ulonglong:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = (sint_t)m_data.ulonglong;     success = true; break;
        case e_uint:        m_data.uint         = (uint_t)m_data.ulonglong;     success = true; break;
        case e_slong:       m_data.slong        = m_data.ulonglong;     success = true; break;
        case e_ulong:       m_data.ulong        = m_data.ulonglong;     success = true; break;
        case e_slonglong:   m_data.slonglong    = m_data.ulonglong;     success = true; break;
        case e_ulonglong:   success = true; break;
        case e_float:       m_data.flt          = m_data.ulonglong;     success = true; break;
        case e_double:      m_data.dbl          = m_data.ulonglong;     success = true; break;
        case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
        }
        break;

    case e_float:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = (sint_t)m_data.flt;       success = true; break;
        case e_uint:        m_data.uint         = (uint_t)m_data.flt;       success = true; break;
        case e_slong:       m_data.slong        = (slong_t)m_data.flt;      success = true; break;
        case e_ulong:       m_data.ulong        = (ulong_t)m_data.flt;      success = true; break;
        case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.flt;  success = true; break;
        case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.flt;  success = true; break;
        case e_float:       success = true; break;
        case e_double:      m_data.dbl          = m_data.flt;               success = true; break;
        case e_long_double: m_data.ldbl         = m_data.flt;               success = true; break;
        }
        break;

    case e_double:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = (sint_t)m_data.dbl;       success = true; break;
        case e_uint:        m_data.uint         = (uint_t)m_data.dbl;       success = true; break;
        case e_slong:       m_data.slong        = (slong_t)m_data.dbl;      success = true; break;
        case e_ulong:       m_data.ulong        = (ulong_t)m_data.dbl;      success = true; break;
        case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.dbl;  success = true; break;
        case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.dbl;  success = true; break;
        case e_float:       m_data.flt          = (float_t)m_data.dbl;      success = true; break;
        case e_double:      success = true; break;
        case e_long_double: m_data.ldbl         = m_data.dbl;               success = true; break;
        }
        break;

    case e_long_double:
        switch (type)
        {
        case e_void:
        case e_sint:        m_data.sint         = (sint_t)m_data.ldbl;      success = true; break;
        case e_uint:        m_data.uint         = (uint_t)m_data.ldbl;      success = true; break;
        case e_slong:       m_data.slong        = (slong_t)m_data.ldbl;     success = true; break;
        case e_ulong:       m_data.ulong        = (ulong_t)m_data.ldbl;     success = true; break;
        case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.ldbl; success = true; break;
        case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.ldbl; success = true; break;
        case e_float:       m_data.flt          = (float_t)m_data.ldbl;     success = true; break;
        case e_double:      m_data.dbl          = (double_t)m_data.ldbl;    success = true; break;
        case e_long_double: success = true; break;
        }
        break;
    }

    if (success)
        m_type = type;
    return success;
}

bool
Scalar::MakeSigned ()
{
    bool success = false;

    switch (m_type)
    {
    case e_void:                                break;
    case e_sint:                                success = true; break;
    case e_uint:        m_type = e_sint;        success = true; break;
    case e_slong:                               success = true; break;
    case e_ulong:       m_type = e_slong;       success = true; break;
    case e_slonglong:                           success = true; break;
    case e_ulonglong:   m_type = e_slonglong;   success = true; break;
    case e_float:                               success = true; break;
    case e_double:                              success = true; break;
    case e_long_double:                         success = true; break;
    }

    return success;
}

int
Scalar::SInt(int fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return m_data.sint;
    case e_uint:        return (int)m_data.uint;
    case e_slong:       return (int)m_data.slong;
    case e_ulong:       return (int)m_data.ulong;
    case e_slonglong:   return (int)m_data.slonglong;
    case e_ulonglong:   return (int)m_data.ulonglong;
    case e_float:       return (int)m_data.flt;
    case e_double:      return (int)m_data.dbl;
    case e_long_double: return (int)m_data.ldbl;
    }
    return fail_value;
}

unsigned int
Scalar::UInt(unsigned int fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (unsigned int)m_data.sint;
    case e_uint:        return (unsigned int)m_data.uint;
    case e_slong:       return (unsigned int)m_data.slong;
    case e_ulong:       return (unsigned int)m_data.ulong;
    case e_slonglong:   return (unsigned int)m_data.slonglong;
    case e_ulonglong:   return (unsigned int)m_data.ulonglong;
    case e_float:       return (unsigned int)m_data.flt;
    case e_double:      return (unsigned int)m_data.dbl;
    case e_long_double: return (unsigned int)m_data.ldbl;
    }
    return fail_value;
}


long
Scalar::SLong(long fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (long)m_data.sint;
    case e_uint:        return (long)m_data.uint;
    case e_slong:       return (long)m_data.slong;
    case e_ulong:       return (long)m_data.ulong;
    case e_slonglong:   return (long)m_data.slonglong;
    case e_ulonglong:   return (long)m_data.ulonglong;
    case e_float:       return (long)m_data.flt;
    case e_double:      return (long)m_data.dbl;
    case e_long_double: return (long)m_data.ldbl;
    }
    return fail_value;
}



unsigned long
Scalar::ULong(unsigned long fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (unsigned long)m_data.sint;
    case e_uint:        return (unsigned long)m_data.uint;
    case e_slong:       return (unsigned long)m_data.slong;
    case e_ulong:       return (unsigned long)m_data.ulong;
    case e_slonglong:   return (unsigned long)m_data.slonglong;
    case e_ulonglong:   return (unsigned long)m_data.ulonglong;
    case e_float:       return (unsigned long)m_data.flt;
    case e_double:      return (unsigned long)m_data.dbl;
    case e_long_double: return (unsigned long)m_data.ldbl;
    }
    return fail_value;
}

uint64_t
Scalar::GetRawBits64(uint64_t fail_value) const
{
    switch (m_type)
    {
    case e_void:
        break;

    case e_sint:
    case e_uint:
        return m_data.uint;

    case e_slong:
    case e_ulong:
        return m_data.ulong;

    case e_slonglong:
    case e_ulonglong:
        return m_data.ulonglong;

    case e_float:
        if (sizeof(m_data.flt) == sizeof(m_data.uint))
            return m_data.uint;
        else if (sizeof(m_data.flt) == sizeof(m_data.ulong))
            return m_data.ulong;
        else if (sizeof(m_data.flt) == sizeof(m_data.ulonglong))
            return m_data.ulonglong;
        break;

    case e_double:
        if (sizeof(m_data.dbl) == sizeof(m_data.uint))
            return m_data.uint;
        else if (sizeof(m_data.dbl) == sizeof(m_data.ulong))
            return m_data.ulong;
        else if (sizeof(m_data.dbl) == sizeof(m_data.ulonglong))
            return m_data.ulonglong;
        break;

    case e_long_double:
        if (sizeof(m_data.ldbl) == sizeof(m_data.uint))
            return m_data.uint;
        else if (sizeof(m_data.ldbl) == sizeof(m_data.ulong))
            return m_data.ulong;
        else if (sizeof(m_data.ldbl) == sizeof(m_data.ulonglong))
            return m_data.ulonglong;
        break;
    }
    return fail_value;
}



long long
Scalar::SLongLong(long long fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (long long)m_data.sint;
    case e_uint:        return (long long)m_data.uint;
    case e_slong:       return (long long)m_data.slong;
    case e_ulong:       return (long long)m_data.ulong;
    case e_slonglong:   return (long long)m_data.slonglong;
    case e_ulonglong:   return (long long)m_data.ulonglong;
    case e_float:       return (long long)m_data.flt;
    case e_double:      return (long long)m_data.dbl;
    case e_long_double: return (long long)m_data.ldbl;
    }
    return fail_value;
}


unsigned long long
Scalar::ULongLong(unsigned long long fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (unsigned long long)m_data.sint;
    case e_uint:        return (unsigned long long)m_data.uint;
    case e_slong:       return (unsigned long long)m_data.slong;
    case e_ulong:       return (unsigned long long)m_data.ulong;
    case e_slonglong:   return (unsigned long long)m_data.slonglong;
    case e_ulonglong:   return (unsigned long long)m_data.ulonglong;
    case e_float:       return (unsigned long long)m_data.flt;
    case e_double:      return (unsigned long long)m_data.dbl;
    case e_long_double: return (unsigned long long)m_data.ldbl;
    }
    return fail_value;
}


float
Scalar::Float(float fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (float)m_data.sint;
    case e_uint:        return (float)m_data.uint;
    case e_slong:       return (float)m_data.slong;
    case e_ulong:       return (float)m_data.ulong;
    case e_slonglong:   return (float)m_data.slonglong;
    case e_ulonglong:   return (float)m_data.ulonglong;
    case e_float:       return (float)m_data.flt;
    case e_double:      return (float)m_data.dbl;
    case e_long_double: return (float)m_data.ldbl;
    }
    return fail_value;
}


double
Scalar::Double(double fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (double)m_data.sint;
    case e_uint:        return (double)m_data.uint;
    case e_slong:       return (double)m_data.slong;
    case e_ulong:       return (double)m_data.ulong;
    case e_slonglong:   return (double)m_data.slonglong;
    case e_ulonglong:   return (double)m_data.ulonglong;
    case e_float:       return (double)m_data.flt;
    case e_double:      return (double)m_data.dbl;
    case e_long_double: return (double)m_data.ldbl;
    }
    return fail_value;
}


long double
Scalar::LongDouble(long double fail_value) const
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        return (long double)m_data.sint;
    case e_uint:        return (long double)m_data.uint;
    case e_slong:       return (long double)m_data.slong;
    case e_ulong:       return (long double)m_data.ulong;
    case e_slonglong:   return (long double)m_data.slonglong;
    case e_ulonglong:   return (long double)m_data.ulonglong;
    case e_float:       return (long double)m_data.flt;
    case e_double:      return (long double)m_data.dbl;
    case e_long_double: return (long double)m_data.ldbl;
    }
    return fail_value;
}


Scalar&
Scalar::operator+= (const Scalar& rhs)
{
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (m_type)
        {
        case e_void:        break;
        case e_sint:        m_data.sint         = a->m_data.sint        + b->m_data.sint;       break;
        case e_uint:        m_data.uint         = a->m_data.uint        + b->m_data.uint;       break;
        case e_slong:       m_data.slong        = a->m_data.slong       + b->m_data.slong;      break;
        case e_ulong:       m_data.ulong        = a->m_data.ulong       + b->m_data.ulong;      break;
        case e_slonglong:   m_data.slonglong    = a->m_data.slonglong   + b->m_data.slonglong;  break;
        case e_ulonglong:   m_data.ulonglong    = a->m_data.ulonglong   + b->m_data.ulonglong;  break;
        case e_float:       m_data.flt          = a->m_data.flt         + b->m_data.flt;        break;
        case e_double:      m_data.dbl          = a->m_data.dbl         + b->m_data.dbl;        break;
        case e_long_double: m_data.ldbl         = a->m_data.ldbl        + b->m_data.ldbl;       break;
        }
    }
    return *this;
}

Scalar&
Scalar::operator<<= (const Scalar& rhs)
{
    switch (m_type)
    {
    case e_void:
    case e_float:
    case e_double:
    case e_long_double:
        m_type = e_void;
        break;

    case e_sint:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.sint <<= rhs.m_data.sint;        break;
        case e_uint:            m_data.sint <<= rhs.m_data.uint;        break;
        case e_slong:           m_data.sint <<= rhs.m_data.slong;       break;
        case e_ulong:           m_data.sint <<= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.sint <<= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.sint <<= rhs.m_data.ulonglong;   break;
        }
        break;

    case e_uint:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.uint <<= rhs.m_data.sint;        break;
        case e_uint:            m_data.uint <<= rhs.m_data.uint;        break;
        case e_slong:           m_data.uint <<= rhs.m_data.slong;       break;
        case e_ulong:           m_data.uint <<= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.uint <<= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.uint <<= rhs.m_data.ulonglong;   break;
        }
        break;

    case e_slong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.slong <<= rhs.m_data.sint;       break;
        case e_uint:            m_data.slong <<= rhs.m_data.uint;       break;
        case e_slong:           m_data.slong <<= rhs.m_data.slong;      break;
        case e_ulong:           m_data.slong <<= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.slong <<= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.slong <<= rhs.m_data.ulonglong;  break;
        }
        break;

    case e_ulong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulong <<= rhs.m_data.sint;       break;
        case e_uint:            m_data.ulong <<= rhs.m_data.uint;       break;
        case e_slong:           m_data.ulong <<= rhs.m_data.slong;      break;
        case e_ulong:           m_data.ulong <<= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.ulong <<= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.ulong <<= rhs.m_data.ulonglong;  break;
        }
        break;
    case e_slonglong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.slonglong <<= rhs.m_data.sint;       break;
        case e_uint:            m_data.slonglong <<= rhs.m_data.uint;       break;
        case e_slong:           m_data.slonglong <<= rhs.m_data.slong;      break;
        case e_ulong:           m_data.slonglong <<= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.slonglong <<= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.slonglong <<= rhs.m_data.ulonglong;  break;
        }
        break;

    case e_ulonglong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulonglong <<= rhs.m_data.sint;       break;
        case e_uint:            m_data.ulonglong <<= rhs.m_data.uint;       break;
        case e_slong:           m_data.ulonglong <<= rhs.m_data.slong;      break;
        case e_ulong:           m_data.ulonglong <<= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.ulonglong <<= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.ulonglong <<= rhs.m_data.ulonglong;  break;
        }
        break;
    }
    return *this;
}

bool
Scalar::ShiftRightLogical(const Scalar& rhs)
{
    switch (m_type)
    {
    case e_void:
    case e_float:
    case e_double:
    case e_long_double:
        m_type = e_void;
        break;

    case e_sint:
    case e_uint:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.uint >>= rhs.m_data.sint;        break;
        case e_uint:            m_data.uint >>= rhs.m_data.uint;        break;
        case e_slong:           m_data.uint >>= rhs.m_data.slong;       break;
        case e_ulong:           m_data.uint >>= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.uint >>= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.uint >>= rhs.m_data.ulonglong;   break;
        }
        break;

    case e_slong:
    case e_ulong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulong >>= rhs.m_data.sint;       break;
        case e_uint:            m_data.ulong >>= rhs.m_data.uint;       break;
        case e_slong:           m_data.ulong >>= rhs.m_data.slong;      break;
        case e_ulong:           m_data.ulong >>= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.ulong >>= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.ulong >>= rhs.m_data.ulonglong;  break;
        }
        break;

    case e_slonglong:
    case e_ulonglong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulonglong >>= rhs.m_data.sint;       break;
        case e_uint:            m_data.ulonglong >>= rhs.m_data.uint;       break;
        case e_slong:           m_data.ulonglong >>= rhs.m_data.slong;      break;
        case e_ulong:           m_data.ulonglong >>= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.ulonglong >>= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.ulonglong >>= rhs.m_data.ulonglong;  break;
        }
        break;
    }
    return m_type != e_void;
}


Scalar&
Scalar::operator>>= (const Scalar& rhs)
{
    switch (m_type)
    {
    case e_void:
    case e_float:
    case e_double:
    case e_long_double:
        m_type = e_void;
        break;

    case e_sint:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.sint >>= rhs.m_data.sint;        break;
        case e_uint:            m_data.sint >>= rhs.m_data.uint;        break;
        case e_slong:           m_data.sint >>= rhs.m_data.slong;       break;
        case e_ulong:           m_data.sint >>= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.sint >>= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.sint >>= rhs.m_data.ulonglong;   break;
        }
        break;

    case e_uint:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.uint >>= rhs.m_data.sint;        break;
        case e_uint:            m_data.uint >>= rhs.m_data.uint;        break;
        case e_slong:           m_data.uint >>= rhs.m_data.slong;       break;
        case e_ulong:           m_data.uint >>= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.uint >>= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.uint >>= rhs.m_data.ulonglong;   break;
        }
        break;

    case e_slong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.slong >>= rhs.m_data.sint;       break;
        case e_uint:            m_data.slong >>= rhs.m_data.uint;       break;
        case e_slong:           m_data.slong >>= rhs.m_data.slong;      break;
        case e_ulong:           m_data.slong >>= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.slong >>= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.slong >>= rhs.m_data.ulonglong;  break;
        }
        break;

    case e_ulong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulong >>= rhs.m_data.sint;       break;
        case e_uint:            m_data.ulong >>= rhs.m_data.uint;       break;
        case e_slong:           m_data.ulong >>= rhs.m_data.slong;      break;
        case e_ulong:           m_data.ulong >>= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.ulong >>= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.ulong >>= rhs.m_data.ulonglong;  break;
        }
        break;
    case e_slonglong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.slonglong >>= rhs.m_data.sint;       break;
        case e_uint:            m_data.slonglong >>= rhs.m_data.uint;       break;
        case e_slong:           m_data.slonglong >>= rhs.m_data.slong;      break;
        case e_ulong:           m_data.slonglong >>= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.slonglong >>= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.slonglong >>= rhs.m_data.ulonglong;  break;
        }
        break;

    case e_ulonglong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulonglong >>= rhs.m_data.sint;       break;
        case e_uint:            m_data.ulonglong >>= rhs.m_data.uint;       break;
        case e_slong:           m_data.ulonglong >>= rhs.m_data.slong;      break;
        case e_ulong:           m_data.ulonglong >>= rhs.m_data.ulong;      break;
        case e_slonglong:       m_data.ulonglong >>= rhs.m_data.slonglong;  break;
        case e_ulonglong:       m_data.ulonglong >>= rhs.m_data.ulonglong;  break;
        }
        break;
    }
    return *this;
}


Scalar&
Scalar::operator&= (const Scalar& rhs)
{
    switch (m_type)
    {
    case e_void:
    case e_float:
    case e_double:
    case e_long_double:
        m_type = e_void;
        break;

    case e_sint:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.sint &= rhs.m_data.sint;         break;
        case e_uint:            m_data.sint &= rhs.m_data.uint;         break;
        case e_slong:           m_data.sint &= rhs.m_data.slong;        break;
        case e_ulong:           m_data.sint &= rhs.m_data.ulong;        break;
        case e_slonglong:       m_data.sint &= rhs.m_data.slonglong;    break;
        case e_ulonglong:       m_data.sint &= rhs.m_data.ulonglong;    break;
        }
        break;

    case e_uint:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.uint &= rhs.m_data.sint;         break;
        case e_uint:            m_data.uint &= rhs.m_data.uint;         break;
        case e_slong:           m_data.uint &= rhs.m_data.slong;        break;
        case e_ulong:           m_data.uint &= rhs.m_data.ulong;        break;
        case e_slonglong:       m_data.uint &= rhs.m_data.slonglong;    break;
        case e_ulonglong:       m_data.uint &= rhs.m_data.ulonglong;    break;
        }
        break;

    case e_slong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.slong &= rhs.m_data.sint;        break;
        case e_uint:            m_data.slong &= rhs.m_data.uint;        break;
        case e_slong:           m_data.slong &= rhs.m_data.slong;       break;
        case e_ulong:           m_data.slong &= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.slong &= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.slong &= rhs.m_data.ulonglong;   break;
        }
        break;

    case e_ulong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulong &= rhs.m_data.sint;        break;
        case e_uint:            m_data.ulong &= rhs.m_data.uint;        break;
        case e_slong:           m_data.ulong &= rhs.m_data.slong;       break;
        case e_ulong:           m_data.ulong &= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.ulong &= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.ulong &= rhs.m_data.ulonglong;   break;
        }
        break;
    case e_slonglong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.slonglong &= rhs.m_data.sint;        break;
        case e_uint:            m_data.slonglong &= rhs.m_data.uint;        break;
        case e_slong:           m_data.slonglong &= rhs.m_data.slong;       break;
        case e_ulong:           m_data.slonglong &= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.slonglong &= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.slonglong &= rhs.m_data.ulonglong;   break;
        }
        break;

    case e_ulonglong:
        switch (rhs.m_type)
        {
        case e_void:
        case e_float:
        case e_double:
        case e_long_double:
            m_type = e_void;
            break;
        case e_sint:            m_data.ulonglong &= rhs.m_data.sint;        break;
        case e_uint:            m_data.ulonglong &= rhs.m_data.uint;        break;
        case e_slong:           m_data.ulonglong &= rhs.m_data.slong;       break;
        case e_ulong:           m_data.ulonglong &= rhs.m_data.ulong;       break;
        case e_slonglong:       m_data.ulonglong &= rhs.m_data.slonglong;   break;
        case e_ulonglong:       m_data.ulonglong &= rhs.m_data.ulonglong;   break;
        }
        break;
    }
    return *this;
}



bool
Scalar::AbsoluteValue()
{
    switch (m_type)
    {
    case e_void:
        break;

    case e_sint:
        if (m_data.sint < 0)
            m_data.sint = -m_data.sint;
        return true;

    case e_slong:
        if (m_data.slong < 0)
            m_data.slong = -m_data.slong;
        return true;

    case e_slonglong:
        if (m_data.slonglong < 0)
            m_data.slonglong = -m_data.slonglong;
        return true;

    case e_uint:
    case e_ulong:
    case e_ulonglong:   return true;
    case e_float:       m_data.flt = fabsf(m_data.flt);     return true;
    case e_double:      m_data.dbl = fabs(m_data.dbl);      return true;
    case e_long_double: m_data.ldbl = fabsl(m_data.ldbl);   return true;
    }
    return false;
}


bool
Scalar::UnaryNegate()
{
    switch (m_type)
    {
    case e_void:        break;
    case e_sint:        m_data.sint = -m_data.sint;             return true;
    case e_uint:        m_data.uint = -m_data.uint;             return true;
    case e_slong:       m_data.slong = -m_data.slong;           return true;
    case e_ulong:       m_data.ulong = -m_data.ulong;           return true;
    case e_slonglong:   m_data.slonglong = -m_data.slonglong;   return true;
    case e_ulonglong:   m_data.ulonglong = -m_data.ulonglong;   return true;
    case e_float:       m_data.flt = -m_data.flt;               return true;
    case e_double:      m_data.dbl = -m_data.dbl;               return true;
    case e_long_double: m_data.ldbl = -m_data.ldbl;             return true;
    }
    return false;
}

bool
Scalar::OnesComplement()
{
    switch (m_type)
    {
    case e_sint:        m_data.sint = ~m_data.sint; return true;
    case e_uint:        m_data.uint = ~m_data.uint; return true;
    case e_slong:       m_data.slong = ~m_data.slong; return true;
    case e_ulong:       m_data.ulong = ~m_data.ulong; return true;
    case e_slonglong:   m_data.slonglong = ~m_data.slonglong; return true;
    case e_ulonglong:   m_data.ulonglong = ~m_data.ulonglong; return true;

    case e_void:
    case e_float:
    case e_double:
    case e_long_double:
        break;
    }
    return false;
}


const Scalar
lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_void:            break;
        case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        + b->m_data.sint;       break;
        case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        + b->m_data.uint;       break;
        case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       + b->m_data.slong;      break;
        case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       + b->m_data.ulong;      break;
        case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   + b->m_data.slonglong;  break;
        case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   + b->m_data.ulonglong;  break;
        case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         + b->m_data.flt;        break;
        case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         + b->m_data.dbl;        break;
        case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        + b->m_data.ldbl;       break;
        }
    }
    return result;
}


const Scalar
lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_void:            break;
        case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        - b->m_data.sint;       break;
        case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        - b->m_data.uint;       break;
        case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       - b->m_data.slong;      break;
        case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       - b->m_data.ulong;      break;
        case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   - b->m_data.slonglong;  break;
        case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   - b->m_data.ulonglong;  break;
        case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         - b->m_data.flt;        break;
        case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         - b->m_data.dbl;        break;
        case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        - b->m_data.ldbl;       break;
        }
    }
    return result;
}

const Scalar
lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_void:            break;

        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;
        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;
        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;
        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;
        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;
        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;
        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;
        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;
        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;
        }
    }
    // For division only, the only way it should make it here is if a promotion failed,
    // or if we are trying to do a divide by zero.
    result.m_type = Scalar::e_void;
    return result;
}

const Scalar
lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_void:            break;
        case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        * b->m_data.sint;       break;
        case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        * b->m_data.uint;       break;
        case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       * b->m_data.slong;      break;
        case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       * b->m_data.ulong;      break;
        case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   * b->m_data.slonglong;  break;
        case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   * b->m_data.ulonglong;  break;
        case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         * b->m_data.flt;        break;
        case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         * b->m_data.dbl;        break;
        case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        * b->m_data.ldbl;       break;
        }
    }
    return result;
}

const Scalar
lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        & b->m_data.sint;       break;
        case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        & b->m_data.uint;       break;
        case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       & b->m_data.slong;      break;
        case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       & b->m_data.ulong;      break;
        case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   & b->m_data.slonglong;  break;
        case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   & b->m_data.ulonglong;  break;

        case Scalar::e_void:
        case Scalar::e_float:
        case Scalar::e_double:
        case Scalar::e_long_double:
            // No bitwise AND on floats, doubles of long doubles
            result.m_type = Scalar::e_void;
            break;
        }
    }
    return result;
}

const Scalar
lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        | b->m_data.sint;       break;
        case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        | b->m_data.uint;       break;
        case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       | b->m_data.slong;      break;
        case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       | b->m_data.ulong;      break;
        case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   | b->m_data.slonglong;  break;
        case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   | b->m_data.ulonglong;  break;

        case Scalar::e_void:
        case Scalar::e_float:
        case Scalar::e_double:
        case Scalar::e_long_double:
            // No bitwise AND on floats, doubles of long doubles
            result.m_type = Scalar::e_void;
            break;
        }
    }
    return result;
}

const Scalar
lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        % b->m_data.sint;       break;
        case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        % b->m_data.uint;       break;
        case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       % b->m_data.slong;      break;
        case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       % b->m_data.ulong;      break;
        case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   % b->m_data.slonglong;  break;
        case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   % b->m_data.ulonglong;  break;

        case Scalar::e_void:
        case Scalar::e_float:
        case Scalar::e_double:
        case Scalar::e_long_double:
            // No bitwise AND on floats, doubles of long doubles
            result.m_type = Scalar::e_void;
            break;
        }
    }
    return result;
}

const Scalar
lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
{
    Scalar result;
    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
    {
        switch (result.m_type)
        {
        case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        ^ b->m_data.sint;       break;
        case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        ^ b->m_data.uint;       break;
        case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       ^ b->m_data.slong;      break;
        case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       ^ b->m_data.ulong;      break;
        case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   ^ b->m_data.slonglong;  break;
        case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   ^ b->m_data.ulonglong;  break;

        case Scalar::e_void:
        case Scalar::e_float:
        case Scalar::e_double:
        case Scalar::e_long_double:
            // No bitwise AND on floats, doubles of long doubles
            result.m_type = Scalar::e_void;
            break;
        }
    }
    return result;
}

const Scalar
lldb_private::operator<< (const Scalar& lhs, const Scalar &rhs)
{
    Scalar result = lhs;
    result <<= rhs;
    return result;
}

const Scalar
lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
{
    Scalar result = lhs;
    result >>= rhs;
    return result;
}

// Return the raw unsigned integer without any casting or conversion
unsigned int
Scalar::RawUInt () const
{
    return m_data.uint;
}

// Return the raw unsigned long without any casting or conversion
unsigned long
Scalar::RawULong () const
{
    return m_data.ulong;
}

// Return the raw unsigned long long without any casting or conversion
unsigned long long
Scalar::RawULongLong () const
{
    return m_data.ulonglong;
}


Error
Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
{
    Error error;
    if (value_str == NULL || value_str[0] == '\0')
    {
        error.SetErrorString ("Invalid c-string value string.");
        return error;
    }
    bool success = false;
    switch (encoding)
    {
    case eEncodingInvalid:
        error.SetErrorString ("Invalid encoding.");
        break;

    case eEncodingUint:
        if (byte_size <= sizeof (unsigned long long))
        {
            uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
            if (!success)
                error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
            else if (!UIntValueIsValidForSize (uval64, byte_size))
                error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte unsigned integer value", uval64, byte_size);
            else
            {
                m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
                switch (m_type)
                {
                case e_uint:        m_data.uint = (uint_t)uval64;           break;
                case e_ulong:       m_data.ulong = (ulong_t)uval64;         break;
                case e_ulonglong:   m_data.ulonglong = (ulonglong_t)uval64; break;
                default:
                    error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
                    break;
                }
            }
        }
        else
        {
            error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
            return error;
        }
        break;

    case eEncodingSint:
        if (byte_size <= sizeof (long long))
        {
            uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
            if (!success)
                error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
            else if (!SIntValueIsValidForSize (sval64, byte_size))
                error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte signed integer value", sval64, byte_size);
            else
            {
                m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
                switch (m_type)
                {
                case e_sint:        m_data.sint = (sint_t)sval64;           break;
                case e_slong:       m_data.slong = (slong_t)sval64;         break;
                case e_slonglong:   m_data.slonglong = (slonglong_t)sval64; break;
                default:
                    error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
                    break;
                }
            }
        }
        else
        {
            error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
            return error;
        }
        break;

    case eEncodingIEEE754:
        if (byte_size == sizeof (float))
        {
            if (::sscanf (value_str, "%f", &m_data.flt) == 1)
                m_type = e_float;
            else
                error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
        }
        else if (byte_size == sizeof (double))
        {
            if (::sscanf (value_str, "%lf", &m_data.dbl) == 1)
                m_type = e_double;
            else
                error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
        }
        else if (byte_size == sizeof (long double))
        {
            if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1)
                m_type = e_long_double;
            else
                error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
        }
        else
        {
            error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size);
            return error;
        }
        break;

    case eEncodingVector:
        error.SetErrorString ("vector encoding unsupported.");
        break;
    }
    if (error.Fail())
        m_type = e_void;

    return error;
}

Error
Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size)
{
    Error error;

    switch (encoding)
    {
    case lldb::eEncodingInvalid:
        error.SetErrorString ("invalid encoding");
        break;
    case lldb::eEncodingVector:
        error.SetErrorString ("vector encoding unsupported");
        break;
    case lldb::eEncodingUint:
        {
            lldb::offset_t offset;

            switch (byte_size)
            {
            case 1: operator=((uint8_t)data.GetU8(&offset)); break;
            case 2: operator=((uint16_t)data.GetU16(&offset)); break;
            case 4: operator=((uint32_t)data.GetU32(&offset)); break;
            case 8: operator=((uint64_t)data.GetU64(&offset)); break;
            default:
                error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
                break;
            }
        }
        break;
    case lldb::eEncodingSint:
        {
            lldb::offset_t offset;

            switch (byte_size)
            {
            case 1: operator=((int8_t)data.GetU8(&offset)); break;
            case 2: operator=((int16_t)data.GetU16(&offset)); break;
            case 4: operator=((int32_t)data.GetU32(&offset)); break;
            case 8: operator=((int64_t)data.GetU64(&offset)); break;
            default:
                error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
                break;
            }
        }
        break;
    case lldb::eEncodingIEEE754:
        {
            lldb::offset_t offset;

            if (byte_size == sizeof (float))
                operator=((float)data.GetFloat(&offset));
            else if (byte_size == sizeof (double))
                operator=((double)data.GetDouble(&offset));
            else if (byte_size == sizeof (long double))
                operator=((long double)data.GetLongDouble(&offset));
            else
                error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size);
        }
        break;
    }

    return error;
}

bool
Scalar::SignExtend (uint32_t sign_bit_pos)
{
    const uint32_t max_bit_pos = GetByteSize() * 8;

    if (sign_bit_pos < max_bit_pos)
    {
        switch (m_type)
        {
        case Scalar::e_void:
        case Scalar::e_float:
        case Scalar::e_double:
        case Scalar::e_long_double:
            return false;

        case Scalar::e_sint:
        case Scalar::e_uint:
            if (max_bit_pos == sign_bit_pos)
                return true;
            else if (sign_bit_pos < (max_bit_pos-1))
            {
                unsigned int sign_bit = 1u << sign_bit_pos;
                if (m_data.uint & sign_bit)
                {
                    const unsigned int mask = ~(sign_bit) + 1u;
                    m_data.uint |= mask;
                }
                return true;
            }
            break;

        case Scalar::e_slong:
        case Scalar::e_ulong:
            if (max_bit_pos == sign_bit_pos)
                return true;
            else if (sign_bit_pos < (max_bit_pos-1))
            {
                unsigned long sign_bit = 1ul << sign_bit_pos;
                if (m_data.ulong & sign_bit)
                {
                    const unsigned long mask = ~(sign_bit) + 1ul;
                    m_data.ulong |= mask;
                }
                return true;
            }
            break;

        case Scalar::e_slonglong:
        case Scalar::e_ulonglong:
            if (max_bit_pos == sign_bit_pos)
                return true;
            else if (sign_bit_pos < (max_bit_pos-1))
            {
                unsigned long long sign_bit = 1ull << sign_bit_pos;
                if (m_data.ulonglong & sign_bit)
                {
                    const unsigned long long mask = ~(sign_bit) + 1ull;
                    m_data.ulonglong |= mask;
                }
                return true;
            }
            break;
        }
    }
    return false;
}

size_t
Scalar::GetAsMemoryData (void *dst,
                         size_t dst_len,
                         lldb::ByteOrder dst_byte_order,
                         Error &error) const
{
    // Get a data extractor that points to the native scalar data
    DataExtractor data;
    if (!GetData(data))
    {
        error.SetErrorString ("invalid scalar value");
        return 0;
    }

    const size_t src_len = data.GetByteSize();

    // Prepare a memory buffer that contains some or all of the register value
    const size_t bytes_copied = data.CopyByteOrderedData (0,                  // src offset
                                                            src_len,            // src length
                                                            dst,                // dst buffer
                                                            dst_len,            // dst length
                                                            dst_byte_order);    // dst byte order
    if (bytes_copied == 0)
        error.SetErrorString ("failed to copy data");

    return bytes_copied;
}

bool
Scalar::ExtractBitfield (uint32_t bit_size,
                         uint32_t bit_offset)
{
    if (bit_size == 0)
        return true;

    uint32_t msbit = bit_offset + bit_size - 1;
    uint32_t lsbit = bit_offset;
    switch (m_type)
    {
        case Scalar::e_void:
            break;

        case e_float:
            if (sizeof(m_data.flt) == sizeof(sint_t))
                m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
            else if (sizeof(m_data.flt) == sizeof(ulong_t))
                m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
            else if (sizeof(m_data.flt) == sizeof(ulonglong_t))
                m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
            else
                return false;
            return true;

        case e_double:
            if (sizeof(m_data.dbl) == sizeof(sint_t))
                m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
            else if (sizeof(m_data.dbl) == sizeof(ulong_t))
                m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
            else if (sizeof(m_data.dbl) == sizeof(ulonglong_t))
                m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
            else
                return false;
            return true;

        case e_long_double:
            if (sizeof(m_data.ldbl) == sizeof(sint_t))
                m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
            else if (sizeof(m_data.ldbl) == sizeof(ulong_t))
                m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
            else if (sizeof(m_data.ldbl) == sizeof(ulonglong_t))
                m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
            else
                return false;
            return true;

        case Scalar::e_sint:
            m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
            return true;

        case Scalar::e_uint:
            m_data.uint = (uint_t)UnsignedBits (m_data.uint, msbit, lsbit);
            return true;

        case Scalar::e_slong:
            m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
            return true;

        case Scalar::e_ulong:
            m_data.ulong = (ulong_t)UnsignedBits (m_data.ulong, msbit, lsbit);
            return true;

        case Scalar::e_slonglong:
            m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
            return true;

        case Scalar::e_ulonglong:
            m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit);
            return true;
    }
    return false;
}





bool
lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
{
    // If either entry is void then we can just compare the types
    if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
        return lhs.m_type == rhs.m_type;

    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
    {
    case Scalar::e_void:            break;
    case Scalar::e_sint:            return a->m_data.sint       == b->m_data.sint;
    case Scalar::e_uint:            return a->m_data.uint       == b->m_data.uint;
    case Scalar::e_slong:           return a->m_data.slong      == b->m_data.slong;
    case Scalar::e_ulong:           return a->m_data.ulong      == b->m_data.ulong;
    case Scalar::e_slonglong:       return a->m_data.slonglong  == b->m_data.slonglong;
    case Scalar::e_ulonglong:       return a->m_data.ulonglong  == b->m_data.ulonglong;
    case Scalar::e_float:           return a->m_data.flt        == b->m_data.flt;
    case Scalar::e_double:      return a->m_data.dbl        == b->m_data.dbl;
    case Scalar::e_long_double: return a->m_data.ldbl       == b->m_data.ldbl;
    }
    return false;
}

bool
lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
{
    // If either entry is void then we can just compare the types
    if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
        return lhs.m_type != rhs.m_type;

    Scalar temp_value;  // A temp value that might get a copy of either promoted value
    const Scalar* a;
    const Scalar* b;
    switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
    {
    case Scalar::e_void:            break;
    case Scalar::e_sint:            return a->m_data.sint       != b->m_data.sint;
    case Scalar::e_uint:            return a->m_data.uint       != b->m_data.uint;
    case Scalar::e_slong:           return a->m_data.slong      != b->m_data.slong;
    case Scalar::e_ulong:           return a->m_data.ulong      != b->m_data.ulong;
    case Scalar::e_slonglong:       return a->m_data.slonglong  != b->m_data.slonglong;
    case Scalar::e_ulonglong:       return a->m_data.ulonglong  != b->m_data.ulonglong;
    case Scalar::e_float:           return a->m_data.flt        != b->m_data.flt;
    case Scalar::e_double:      return a->m_data.dbl        != b->m_data.dbl;
    case Scalar::e_long_double: return a->m_data.ldbl       != b->m_data.ldbl;
    }
    return true;
}

bool
lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
{
    if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
        return false;

    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
    {
    case Scalar::e_void:            break;
    case Scalar::e_sint:            return a->m_data.sint       < b->m_data.sint;
    case Scalar::e_uint:            return a->m_data.uint       < b->m_data.uint;
    case Scalar::e_slong:           return a->m_data.slong      < b->m_data.slong;
    case Scalar::e_ulong:           return a->m_data.ulong      < b->m_data.ulong;
    case Scalar::e_slonglong:       return a->m_data.slonglong  < b->m_data.slonglong;
    case Scalar::e_ulonglong:       return a->m_data.ulonglong  < b->m_data.ulonglong;
    case Scalar::e_float:           return a->m_data.flt        < b->m_data.flt;
    case Scalar::e_double:      return a->m_data.dbl        < b->m_data.dbl;
    case Scalar::e_long_double: return a->m_data.ldbl       < b->m_data.ldbl;
    }
    return false;
}

bool
lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
{
    if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
        return false;

    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
    {
    case Scalar::e_void:            break;
    case Scalar::e_sint:            return a->m_data.sint       <= b->m_data.sint;
    case Scalar::e_uint:            return a->m_data.uint       <= b->m_data.uint;
    case Scalar::e_slong:           return a->m_data.slong      <= b->m_data.slong;
    case Scalar::e_ulong:           return a->m_data.ulong      <= b->m_data.ulong;
    case Scalar::e_slonglong:       return a->m_data.slonglong  <= b->m_data.slonglong;
    case Scalar::e_ulonglong:       return a->m_data.ulonglong  <= b->m_data.ulonglong;
    case Scalar::e_float:           return a->m_data.flt        <= b->m_data.flt;
    case Scalar::e_double:      return a->m_data.dbl        <= b->m_data.dbl;
    case Scalar::e_long_double: return a->m_data.ldbl       <= b->m_data.ldbl;
    }
    return false;
}


bool
lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
{
    if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
        return false;

    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
    {
    case Scalar::e_void:            break;
    case Scalar::e_sint:            return a->m_data.sint       > b->m_data.sint;
    case Scalar::e_uint:            return a->m_data.uint       > b->m_data.uint;
    case Scalar::e_slong:           return a->m_data.slong      > b->m_data.slong;
    case Scalar::e_ulong:           return a->m_data.ulong      > b->m_data.ulong;
    case Scalar::e_slonglong:       return a->m_data.slonglong  > b->m_data.slonglong;
    case Scalar::e_ulonglong:       return a->m_data.ulonglong  > b->m_data.ulonglong;
    case Scalar::e_float:           return a->m_data.flt        > b->m_data.flt;
    case Scalar::e_double:      return a->m_data.dbl        > b->m_data.dbl;
    case Scalar::e_long_double: return a->m_data.ldbl       > b->m_data.ldbl;
    }
    return false;
}

bool
lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
{
    if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
        return false;

    Scalar temp_value;
    const Scalar* a;
    const Scalar* b;
    switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
    {
    case Scalar::e_void:            break;
    case Scalar::e_sint:            return a->m_data.sint       >= b->m_data.sint;
    case Scalar::e_uint:            return a->m_data.uint       >= b->m_data.uint;
    case Scalar::e_slong:           return a->m_data.slong      >= b->m_data.slong;
    case Scalar::e_ulong:           return a->m_data.ulong      >= b->m_data.ulong;
    case Scalar::e_slonglong:       return a->m_data.slonglong  >= b->m_data.slonglong;
    case Scalar::e_ulonglong:       return a->m_data.ulonglong  >= b->m_data.ulonglong;
    case Scalar::e_float:           return a->m_data.flt        >= b->m_data.flt;
    case Scalar::e_double:      return a->m_data.dbl        >= b->m_data.dbl;
    case Scalar::e_long_double: return a->m_data.ldbl       >= b->m_data.ldbl;
    }
    return false;
}