#ifndef _WX_LONGLONG_H
#define _WX_LONGLONG_H
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "longlong.h"
#endif
// long", then check for specific compilers
#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
#define wxLongLong_t long
+ #define wxLongLongSuffix l
+ #define wxLongLongFmtSpec _T("l")
#define wxLongLongIsLong
#elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
#define wxLongLong_t __int64
+ #define wxLongLongSuffix i64
+ #define wxLongLongFmtSpec _T("I64")
#elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
#define wxLongLong_t __int64
-#elif defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8
- #define wxLongLong_t long long
-#elif defined(__MINGW32__) || defined(__CYGWIN__) || defined(__WXMICROWIN__)
+ #define wxLongLongSuffix i64
+ #define wxLongLongFmtSpec _T("I64")
+#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8) || \
+ defined(__MINGW32__) || \
+ defined(__CYGWIN__) || \
+ defined(__WXMICROWIN__) || \
+ (defined(__DJGPP__) && __DJGPP__ >= 2)
#define wxLongLong_t long long
+ #define wxLongLongSuffix ll
+ #define wxLongLongFmtSpec _T("ll")
#elif defined(__MWERKS__)
#if __option(longlong)
#define wxLongLong_t long long
+ #define wxLongLongSuffix ll
+ #define wxLongLongFmtSpec _T("ll")
#else
#error "The 64 bit integer support in CodeWarrior has been disabled."
#error "See the documentation on the 'longlong' pragma."
#endif
#elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
- #define wxLongLong_t long long
+ #define wxLongLong_t long long
#else // no native long long type
// both warning and pragma warning are not portable, but at least an
- // unknown pragma should never be an error - except that, actually, some
+ // 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
// <sigh>
#if !(defined(__WATCOMC__) || defined(__VISAGECPP__))
#define wxUSE_LONGLONG_WX 1
#endif // compiler
+// this macro allows to definea 64 bit constant in a portable way
+#define wxMakeLongLong(x, s) x ## s
+#define wxMakeLongLong2(x, s) wxMakeLongLong(x, s)
+#define wxLL(x) wxMakeLongLong2(x, wxLongLongSuffix)
+
// the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
// to disable automatic testing (useful for the test program which defines
// both classes) but by default we only use one class
#endif
class WXDLLEXPORT wxLongLongWx;
+ class WXDLLEXPORT wxULongLongWx;
#if defined(__VISUALC__) && !defined(__WIN32__)
#define wxLongLong wxLongLongWx
#define wxULongLong wxULongLongWx
public:
// ctors
// default ctor initializes to 0
- wxLongLongNative() { m_ll = 0; }
+ wxLongLongNative() : m_ll(0) { }
// from long long
- wxLongLongNative(wxLongLong_t ll) { m_ll = ll; }
+ wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { }
// from 2 longs
- wxLongLongNative(long hi, unsigned long lo)
+ wxLongLongNative(long hi, unsigned long lo) : m_ll(0)
{
// assign first to avoid precision loss!
m_ll = ((wxLongLong_t) hi) << 32;
// convert to native long long
wxLongLong_t GetValue() const { return m_ll; }
- // implicit conversion for times when we want a native type
- // or wxLongLong, NOT wxLongLongNative and without having
- // to ifdef user code for each use.
- operator wxLongLong_t() const { return m_ll; }
-
// convert to long with range checking in the debug mode (only!)
long ToLong() const
{
{ m_ll++; return *this; }
// post increment
- wxLongLongNative& operator++(int)
- { m_ll++; return *this; }
+ wxLongLongNative operator++(int)
+ { wxLongLongNative value(*this); m_ll++; return value; }
// negation operator
wxLongLongNative operator-() const
{ m_ll--; return *this; }
// post decrement
- wxLongLongNative& operator--(int)
- { m_ll--; return *this; }
+ wxLongLongNative operator--(int)
+ { wxLongLongNative value(*this); m_ll--; return value; }
// shifts
// left shift
public:
// ctors
// default ctor initializes to 0
- wxULongLongNative() { m_ll = 0; }
+ wxULongLongNative() : m_ll(0) { }
// from long long
- wxULongLongNative(unsigned wxLongLong_t ll) { m_ll = ll; }
+ wxULongLongNative(unsigned wxLongLong_t ll) : m_ll(ll) { }
// from 2 longs
- wxULongLongNative(unsigned long hi, unsigned long lo)
+ wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)
{
// assign first to avoid precision loss!
m_ll = ((unsigned wxLongLong_t) hi) << 32;
return (unsigned long)m_ll;
}
- // don't provide implicit conversion to unsigned wxLongLong_t or we
- // will have an ambiguity for all arithmetic operations
- //operator wxULongLong_t() const { return m_ll; }
-
// operations
// addition
wxULongLongNative operator+(const wxULongLongNative& ll) const
{ m_ll++; return *this; }
// post increment
- wxULongLongNative& operator++(int)
- { m_ll++; return *this; }
+ wxULongLongNative operator++(int)
+ { wxULongLongNative value(*this); m_ll++; return value; }
// subtraction
wxULongLongNative operator-(const wxULongLongNative& ll) const
{ m_ll--; return *this; }
// post decrement
- wxULongLongNative& operator--(int)
- { m_ll--; return *this; }
+ wxULongLongNative operator--(int)
+ { wxULongLongNative value(*this); m_ll--; return value; }
// shifts
// left shift
// convert to long with range checking in the debug mode (only!)
unsigned long ToULong() const
{
- wxASSERT_MSG( (m_hi == 0l),
+ wxASSERT_MSG( m_hi == 0ul,
_T("wxULongLong to long conversion loss of precision") );
return (unsigned long)m_lo;
// post increment operator
wxULongLongWx& operator++(int) { return ++(*this); }
- // subraction
+ // subraction (FIXME: should return wxLongLong)
wxULongLongWx operator-(const wxULongLongWx& ll) const;
wxULongLongWx& operator-=(const wxULongLongWx& ll);
private:
// long is at least 32 bits, so represent our 64bit number as 2 longs
- unsigned long m_hi
+ unsigned long m_hi;
unsigned long m_lo;
#ifdef wxLONGLONG_TEST_MODE
// ----------------------------------------------------------------------------
inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator>(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator<=(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator>=(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator==(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator!=(long l, const wxLongLong& ll) { return ll > l; }
-
-inline wxLongLong operator+(long l, const wxLongLong& ll)
-{
- return ll + wxLongLong(l);
-}
+inline bool operator>(long l, const wxLongLong& ll) { return ll < l; }
+inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
+inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
+inline bool operator==(long l, const wxLongLong& ll) { return ll == l; }
+inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; }
+inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; }
inline wxLongLong operator-(long l, const wxLongLong& ll)
{
- return ll - wxLongLong(l);
+ return wxLongLong(l) - ll;
}
-inline bool operator<(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator>(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator<=(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator>=(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator==(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator!=(unsigned long l, const wxULongLong& ll) { return ll > l; }
+inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
+inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
+inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
+inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
+inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
+inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }
+
+inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
-inline wxULongLong operator+(unsigned long l, const wxULongLong& ll) { return ll + l; }
-inline wxULongLong operator-(unsigned long l, const wxULongLong& ll) { return ll - l; }
+// FIXME: this should return wxLongLong
+inline wxULongLong operator-(unsigned long l, const wxULongLong& ull)
+{
+ return wxULongLong(l) - ull;
+}
#endif // _WX_LONGLONG_H
projects / wxWidgets.git / blobdiff