X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/90e572f1e5af1e51fd14e2e1e6f64fa3e258e590..616c0d1f3ac084bb92f0a75dc48812e8647f1b22:/include/wx/longlong.h?ds=sidebyside diff --git a/include/wx/longlong.h b/include/wx/longlong.h index 0fdf22973a..19c580110e 100644 --- a/include/wx/longlong.h +++ b/include/wx/longlong.h @@ -14,6 +14,9 @@ #define _WX_LONGLONG_H #include "wx/defs.h" + +#if wxUSE_LONGLONG + #include "wx/string.h" #include // for LONG_MAX @@ -39,7 +42,12 @@ // unknown pragma should never be an error -- except that, actually, some // broken compilers don't like it, so we have to disable it in this case // - #if !(defined(__WATCOMC__) || defined(__VISAGECPP__)) + #ifdef __GNUC__ + #warning "Your compiler does not appear to support 64 bit "\ + "integers, using emulation class instead.\n" \ + "Please report your compiler version to " \ + "wx-dev@lists.wxwidgets.org!" + #elif !(defined(__WATCOMC__) || defined(__VISAGECPP__)) #pragma warning "Your compiler does not appear to support 64 bit "\ "integers, using emulation class instead.\n" \ "Please report your compiler version to " \ @@ -59,8 +67,8 @@ #define wxUSE_LONGLONG_NATIVE 0 #endif - class WXDLLIMPEXP_BASE wxLongLongWx; - class WXDLLIMPEXP_BASE wxULongLongWx; + class WXDLLIMPEXP_FWD_BASE wxLongLongWx; + class WXDLLIMPEXP_FWD_BASE wxULongLongWx; #if defined(__VISUALC__) && !defined(__WIN32__) #define wxLongLong wxLongLongWx #define wxULongLong wxULongLongWx @@ -78,8 +86,8 @@ #ifndef wxUSE_LONGLONG_WX #define wxUSE_LONGLONG_WX 0 - class WXDLLIMPEXP_BASE wxLongLongNative; - class WXDLLIMPEXP_BASE wxULongLongNative; + class WXDLLIMPEXP_FWD_BASE wxLongLongNative; + class WXDLLIMPEXP_FWD_BASE wxULongLongNative; typedef wxLongLongNative wxLongLong; typedef wxULongLongNative wxULongLong; #endif @@ -105,9 +113,9 @@ public: // from long long wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { } // from 2 longs - wxLongLongNative(long hi, unsigned long lo) : m_ll(0) + wxLongLongNative(wxInt32 hi, wxUint32 lo) { - // assign first to avoid precision loss! + // cast to wxLongLong_t first to avoid precision loss! m_ll = ((wxLongLong_t) hi) << 32; m_ll |= (wxLongLong_t) lo; } @@ -121,10 +129,24 @@ public: // assignment operators // from native 64 bit integer +#ifndef wxLongLongIsLong wxLongLongNative& operator=(wxLongLong_t ll) { m_ll = ll; return *this; } + wxLongLongNative& operator=(wxULongLong_t ll) + { m_ll = ll; return *this; } +#endif // !wxLongLongNative + wxLongLongNative& operator=(const wxULongLongNative &ll); + wxLongLongNative& operator=(int l) + { m_ll = l; return *this; } + wxLongLongNative& operator=(long l) + { m_ll = l; return *this; } + wxLongLongNative& operator=(unsigned int l) + { m_ll = l; return *this; } + wxLongLongNative& operator=(unsigned long l) + { m_ll = l; return *this; } #if wxUSE_LONGLONG_WX wxLongLongNative& operator=(wxLongLongWx ll); + wxLongLongNative& operator=(const class wxULongLongWx &ll); #endif @@ -138,11 +160,11 @@ public: // accessors // get high part - long GetHi() const - { return wx_truncate_cast(long, m_ll >> 32); } + wxInt32 GetHi() const + { return wx_truncate_cast(wxInt32, m_ll >> 32); } // get low part - unsigned long GetLo() const - { return wx_truncate_cast(unsigned long, m_ll); } + wxUint32 GetLo() const + { return wx_truncate_cast(wxUint32, m_ll); } // get absolute value wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); } @@ -155,7 +177,7 @@ public: long ToLong() const { wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX), - _T("wxLongLong to long conversion loss of precision") ); + wxT("wxLongLong to long conversion loss of precision") ); return wx_truncate_cast(long, m_ll); } @@ -307,6 +329,13 @@ public: friend WXDLLIMPEXP_BASE wxString& operator<<(wxString&, const wxLongLongNative&); +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongNative&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongNative&); +#endif + private: wxLongLong_t m_ll; }; @@ -321,31 +350,53 @@ public: // from long long wxULongLongNative(wxULongLong_t ll) : m_ll(ll) { } // from 2 longs - wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0) + wxULongLongNative(wxUint32 hi, wxUint32 lo) : m_ll(0) { - // assign first to avoid precision loss! + // cast to wxLongLong_t first to avoid precision loss! m_ll = ((wxULongLong_t) hi) << 32; m_ll |= (wxULongLong_t) lo; } +#if wxUSE_LONGLONG_WX + wxULongLongNative(const class wxULongLongWx &ll); +#endif + // default copy ctor is ok // no dtor // assignment operators // from native 64 bit integer +#ifndef wxLongLongIsLong wxULongLongNative& operator=(wxULongLong_t ll) { m_ll = ll; return *this; } + wxULongLongNative& operator=(wxLongLong_t ll) + { m_ll = ll; return *this; } +#endif // !wxLongLongNative + wxULongLongNative& operator=(int l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(long l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(unsigned int l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(unsigned long l) + { m_ll = l; return *this; } + wxULongLongNative& operator=(const wxLongLongNative &ll) + { m_ll = ll.GetValue(); return *this; } +#if wxUSE_LONGLONG_WX + wxULongLongNative& operator=(wxLongLongWx ll); + wxULongLongNative& operator=(const class wxULongLongWx &ll); +#endif // assignment operators from wxULongLongNative is ok // accessors // get high part - unsigned long GetHi() const - { return wx_truncate_cast(unsigned long, m_ll >> 32); } + wxUint32 GetHi() const + { return wx_truncate_cast(wxUint32, m_ll >> 32); } // get low part - unsigned long GetLo() const - { return wx_truncate_cast(unsigned long, m_ll); } + wxUint32 GetLo() const + { return wx_truncate_cast(wxUint32, m_ll); } // convert to native ulong long wxULongLong_t GetValue() const { return m_ll; } @@ -353,12 +404,24 @@ public: // convert to ulong with range checking in debug mode (only!) unsigned long ToULong() const { - wxASSERT_MSG( m_ll <= LONG_MAX, - _T("wxULongLong to long conversion loss of precision") ); + wxASSERT_MSG( m_ll <= ULONG_MAX, + wxT("wxULongLong to long conversion loss of precision") ); return wx_truncate_cast(unsigned long, m_ll); } + // convert to double + // + // For some completely obscure reasons compiling the cast below with + // VC6 in DLL builds only (!) results in "error C2520: conversion from + // unsigned __int64 to double not implemented, use signed __int64" so + // we must use a different version for that compiler. +#ifdef __VISUALC6__ + double ToDouble() const; +#else + double ToDouble() const { return wx_truncate_cast(double, m_ll); } +#endif + // operations // addition wxULongLongNative operator+(const wxULongLongNative& ll) const @@ -494,10 +557,24 @@ public: friend WXDLLIMPEXP_BASE wxString& operator<<(wxString&, const wxULongLongNative&); +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongNative&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongNative&); +#endif + private: wxULongLong_t m_ll; }; +inline +wxLongLongNative& wxLongLongNative::operator=(const wxULongLongNative &ll) +{ + m_ll = ll.GetValue(); + return *this; +} + #endif // wxUSE_LONGLONG_NATIVE #if wxUSE_LONGLONG_WX @@ -553,7 +630,34 @@ public: return *this; } - // from double + // from int + wxLongLongWx& operator=(int l) + { + return operator=((long)l); + } + + wxLongLongWx& operator=(unsigned long l) + { + m_lo = l; + m_hi = 0; + +#ifdef wxLONGLONG_TEST_MODE + m_ll = l; + + Check(); +#endif // wxLONGLONG_TEST_MODE + + return *this; + } + + wxLongLongWx& operator=(unsigned int l) + { + return operator=((unsigned long)l); + } + + wxLongLongWx& operator=(const class wxULongLongWx &ll); + + // from double wxLongLongWx& Assign(double d); // can't have assignment operator from 2 longs @@ -584,7 +688,7 @@ public: long ToLong() const { wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l), - _T("wxLongLong to long conversion loss of precision") ); + wxT("wxLongLong to long conversion loss of precision") ); return (long)m_lo; } @@ -693,6 +797,13 @@ public: friend WXDLLIMPEXP_BASE wxString& operator<<(wxString&, const wxLongLongWx&); +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongWx&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongWx&); +#endif + private: // long is at least 32 bits, so represent our 64bit number as 2 longs @@ -769,6 +880,26 @@ public: return *this; } + wxULongLongWx& operator=(long l) + { + m_lo = l; + m_hi = (unsigned long) ((l<0) ? -1l : 0); + +#ifdef wxLONGLONG_TEST_MODE + m_ll = (wxULongLong_t) (wxLongLong_t) l; + + Check(); +#endif // wxLONGLONG_TEST_MODE + + return *this; + } + wxULongLongWx& operator=(const class wxLongLongWx &ll) { + // Should we use an assert like it was before in the constructor? + // wxASSERT(ll.GetHi() >= 0); + m_hi = (unsigned long)ll.GetHi(); + m_lo = ll.GetLo(); + return *this; + } // can't have assignment operator from 2 longs @@ -782,11 +913,14 @@ public: unsigned long ToULong() const { wxASSERT_MSG( m_hi == 0ul, - _T("wxULongLong to long conversion loss of precision") ); + wxT("wxULongLong to long conversion loss of precision") ); return (unsigned long)m_lo; } + // convert to double + double ToDouble() const; + // operations // addition wxULongLongWx operator+(const wxULongLongWx& ll) const; @@ -879,6 +1013,13 @@ public: friend WXDLLIMPEXP_BASE wxString& operator<<(wxString&, const wxULongLongWx&); +#if wxUSE_STREAMS + friend WXDLLIMPEXP_BASE + class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongWx&); + friend WXDLLIMPEXP_BASE + class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongWx&); +#endif + private: // long is at least 32 bits, so represent our 64bit number as 2 longs @@ -929,4 +1070,76 @@ inline wxLongLong operator-(unsigned long l, const wxULongLong& ull) return wxLongLong((long)ret.GetHi(),ret.GetLo()); } +#if wxUSE_LONGLONG_NATIVE && wxUSE_STREAMS + +WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxULongLong_t value); +WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxLongLong_t value); + +WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxULongLong_t &value); +WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxLongLong_t &value); + +#endif + +// ---------------------------------------------------------------------------- +// Specialize numeric_limits<> for our long long wrapper classes. +// ---------------------------------------------------------------------------- + +#if wxUSE_LONGLONG_NATIVE + +// VC6 is known to not have __int64 specializations of numeric_limits<> in its +// anyhow so don't bother including it, especially as it results in +// tons of warnings because the standard header itself uses obsolete template +// specialization syntax. +#ifndef __VISUALC6__ + +#include + +namespace std +{ + +#ifdef __clang__ + // libstdc++ (used by Clang) uses struct for numeric_limits; unlike gcc, clang + // warns about this + template<> struct numeric_limits : public numeric_limits {}; + template<> struct numeric_limits : public numeric_limits {}; +#else + template<> class numeric_limits : public numeric_limits {}; + template<> class numeric_limits : public numeric_limits {}; +#endif + +} // namespace std + +#endif // !VC6 + +#endif // wxUSE_LONGLONG_NATIVE + +// ---------------------------------------------------------------------------- +// Specialize wxArgNormalizer to allow using wxLongLong directly with wx pseudo +// vararg functions. +// ---------------------------------------------------------------------------- + +// Notice that this must be done here and not in wx/strvararg.h itself because +// we can't include wx/longlong.h from there as this header itself includes +// wx/string.h which includes wx/strvararg.h too, so to avoid the circular +// dependencies we can only do it here (or add another header just for this but +// it doesn't seem necessary). +#include "wx/strvararg.h" + +template<> +struct WXDLLIMPEXP_BASE wxArgNormalizer +{ + wxArgNormalizer(wxLongLong value, + const wxFormatString *fmt, unsigned index) + : m_value(value) + { + wxASSERT_ARG_TYPE( fmt, index, wxFormatString::Arg_LongLongInt ); + } + + wxLongLong_t get() const { return m_value.GetValue(); } + + wxLongLong m_value; +}; + +#endif // wxUSE_LONGLONG + #endif // _WX_LONGLONG_H