// Created: 10.02.99
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LONGLONG_H
#define _WX_LONGLONG_H
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma interface "longlong.h"
#endif
// decide upon which class we will use
// ----------------------------------------------------------------------------
-// to avoid compilation problems on 64bit machines with ambiguous method calls
-// we will need to define this
-#undef wxLongLongIsLong
-
-// NB: we #define and not typedef wxLongLong_t because we want to be able to
-// use 'unsigned wxLongLong_t' as well and because we use "#ifdef
-// wxLongLong_t" below
-
-// first check for generic cases which are long on 64bit machine and "long
-// long", then check for specific compilers
-#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
- #define wxLongLong_t long
- #define wxLongLongIsLong
-#elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
- #define wxLongLong_t __int64
-#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 wxLongLong_t long long
-#elif defined(__MWERKS__)
- #if __option(longlong)
- #define wxLongLong_t long long
- #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
-#else // no native long long type
+#ifndef wxLongLong_t
// 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__))
- #pragma 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.wxwindows.org!"
-#endif
+ #if !(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 " \
+ "wx-dev@lists.wxwidgets.org!"
+ #endif
#define wxUSE_LONGLONG_WX 1
#endif // compiler
#define wxUSE_LONGLONG_NATIVE 0
#endif
- class WXDLLEXPORT wxLongLongWx;
+ class WXDLLIMPEXP_BASE wxLongLongWx;
+ class WXDLLIMPEXP_BASE wxULongLongWx;
#if defined(__VISUALC__) && !defined(__WIN32__)
#define wxLongLong wxLongLongWx
#define wxULongLong wxULongLongWx
#ifndef wxUSE_LONGLONG_WX
#define wxUSE_LONGLONG_WX 0
- class WXDLLEXPORT wxLongLongNative;
- class WXDLLEXPORT wxULongLongNative;
+ class WXDLLIMPEXP_BASE wxLongLongNative;
+ class WXDLLIMPEXP_BASE wxULongLongNative;
typedef wxLongLongNative wxLongLong;
typedef wxULongLongNative wxULongLong;
#endif
// ----------------------------------------------------------------------------
// we use iostream for wxLongLong output
-#include "wx/ioswrap.h"
+#include "wx/iosfwrap.h"
#if wxUSE_LONGLONG_NATIVE
-class WXDLLEXPORT wxLongLongNative
+class WXDLLIMPEXP_BASE wxLongLongNative
{
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;
m_ll |= (wxLongLong_t) lo;
}
+#if wxUSE_LONGLONG_WX
+ wxLongLongNative(wxLongLongWx ll);
+#endif
// default copy ctor is ok
// from native 64 bit integer
wxLongLongNative& operator=(wxLongLong_t ll)
{ m_ll = ll; return *this; }
+#if wxUSE_LONGLONG_WX
+ wxLongLongNative& operator=(wxLongLongWx ll);
+#endif
+
// from double: this one has an explicit name because otherwise we
// would have ambiguity with "ll = int" and also because we don't want
// 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
{
return (long)m_ll;
}
+#if wxABI_VERSION >= 20602
+ // convert to double
+ double ToDouble() const { return m_ll; }
+#endif // ABI >= 2.6.2
+
// don't provide implicit conversion to wxLongLong_t or we will have an
// ambiguity for all arithmetic operations
//operator wxLongLong_t() const { return m_ll; }
{ 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
wxLongLongNative operator<<(int shift) const
- { return wxLongLongNative(m_ll << shift);; }
+ { return wxLongLongNative(m_ll << shift); }
wxLongLongNative& operator<<=(int shift)
{ m_ll <<= shift; return *this; }
// right shift
wxLongLongNative operator>>(int shift) const
- { return wxLongLongNative(m_ll >> shift);; }
+ { return wxLongLongNative(m_ll >> shift); }
wxLongLongNative& operator>>=(int shift)
{ m_ll >>= shift; return *this; }
#if wxUSE_STD_IOSTREAM
// input/output
- friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);
+ friend WXDLLIMPEXP_BASE
+ wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);
#endif
+ friend WXDLLIMPEXP_BASE
+ wxString& operator<<(wxString&, const wxLongLongNative&);
+
private:
wxLongLong_t m_ll;
};
-class WXDLLEXPORT wxULongLongNative
+class WXDLLIMPEXP_BASE wxULongLongNative
{
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(wxULongLong_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;
- m_ll |= (unsigned wxLongLong_t) lo;
+ m_ll = ((wxULongLong_t) hi) << 32;
+ m_ll |= (wxULongLong_t) lo;
}
// default copy ctor is ok
// assignment operators
// from native 64 bit integer
- wxULongLongNative& operator=(unsigned wxLongLong_t ll)
+ wxULongLongNative& operator=(wxULongLong_t ll)
{ m_ll = ll; return *this; }
// assignment operators from wxULongLongNative is ok
{ return (unsigned long)m_ll; }
// convert to native ulong long
- unsigned wxLongLong_t GetValue() const { return m_ll; }
+ wxULongLong_t GetValue() const { return m_ll; }
// convert to ulong with range checking in the debug mode (only!)
unsigned long ToULong() const
{
- wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
+ wxASSERT_MSG( m_ll <= LONG_MAX,
_T("wxULongLong to long conversion loss of precision") );
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
wxULongLongNative& operator+=(const wxULongLongNative& ll)
{ m_ll += ll.m_ll; return *this; }
- wxULongLongNative operator+(const unsigned wxLongLong_t ll) const
+ wxULongLongNative operator+(const wxULongLong_t ll) const
{ return wxULongLongNative(m_ll + ll); }
- wxULongLongNative& operator+=(const unsigned wxLongLong_t ll)
+ wxULongLongNative& operator+=(const wxULongLong_t ll)
{ m_ll += ll; return *this; }
// pre increment
{ 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
wxULongLongNative& operator-=(const wxULongLongNative& ll)
{ m_ll -= ll.m_ll; return *this; }
- wxULongLongNative operator-(const unsigned wxLongLong_t ll) const
+ wxULongLongNative operator-(const wxULongLong_t ll) const
{ return wxULongLongNative(m_ll - ll); }
- wxULongLongNative& operator-=(const unsigned wxLongLong_t ll)
+ wxULongLongNative& operator-=(const wxULongLong_t ll)
{ m_ll -= ll; return *this; }
// pre decrement
{ 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
wxULongLongNative operator<<(int shift) const
- { return wxULongLongNative(m_ll << shift);; }
+ { return wxULongLongNative(m_ll << shift); }
wxULongLongNative& operator<<=(int shift)
{ m_ll <<= shift; return *this; }
// right shift
wxULongLongNative operator>>(int shift) const
- { return wxULongLongNative(m_ll >> shift);; }
+ { return wxULongLongNative(m_ll >> shift); }
wxULongLongNative& operator>>=(int shift)
{ m_ll >>= shift; return *this; }
#if wxUSE_STD_IOSTREAM
// input/output
- friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);
+ friend WXDLLIMPEXP_BASE
+ wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);
#endif
+ friend WXDLLIMPEXP_BASE
+ wxString& operator<<(wxString&, const wxULongLongNative&);
+
private:
- unsigned wxLongLong_t m_ll;
+ wxULongLong_t m_ll;
};
#endif // wxUSE_LONGLONG_NATIVE
#if wxUSE_LONGLONG_WX
-class WXDLLEXPORT wxLongLongWx
+class WXDLLIMPEXP_BASE wxLongLongWx
{
public:
// ctors
return (long)m_lo;
}
+#if wxABI_VERSION >= 20602
+ // convert to double
+ double ToDouble() const;
+#endif // ABI >= 2.6.2
+
// operations
// addition
wxLongLongWx operator+(const wxLongLongWx& ll) const;
// comparison
bool operator==(const wxLongLongWx& ll) const
{ return m_lo == ll.m_lo && m_hi == ll.m_hi; }
+#if wxUSE_LONGLONG_NATIVE
+ bool operator==(const wxLongLongNative& ll) const
+ { return m_lo == ll.GetLo() && m_hi == ll.GetHi(); }
+#endif
bool operator!=(const wxLongLongWx& ll) const
{ return !(*this == ll); }
bool operator<(const wxLongLongWx& ll) const;
void *asArray() const;
#if wxUSE_STD_IOSTREAM
- friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);
+ friend WXDLLIMPEXP_BASE
+ wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);
#endif // wxUSE_STD_IOSTREAM
+ friend WXDLLIMPEXP_BASE
+ wxString& operator<<(wxString&, const wxLongLongWx&);
+
private:
// long is at least 32 bits, so represent our 64bit number as 2 longs
};
-class WXDLLEXPORT wxULongLongWx
+class WXDLLIMPEXP_BASE wxULongLongWx
{
public:
// ctors
#endif // wxLONGLONG_TEST_MODE
}
+ // from signed to unsigned
+ wxULongLongWx(wxLongLongWx ll)
+ {
+ wxASSERT(ll.GetHi() >= 0);
+ m_hi = (unsigned long)ll.GetHi();
+ m_lo = ll.GetLo();
+ }
+
// default copy ctor is ok in both cases
// no dtor
// 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
- wxULongLongWx operator-(const wxULongLongWx& ll) const;
+ // subtraction
+ wxLongLongWx operator-(const wxULongLongWx& ll) const;
wxULongLongWx& operator-=(const wxULongLongWx& ll);
// pre decrement operator
void *asArray() const;
#if wxUSE_STD_IOSTREAM
- friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);
+ friend WXDLLIMPEXP_BASE
+ wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);
#endif // wxUSE_STD_IOSTREAM
+ friend WXDLLIMPEXP_BASE
+ wxString& operator<<(wxString&, const wxULongLongWx&);
+
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
wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
}
- unsigned wxLongLong_t m_ll;
+ wxULongLong_t m_ll;
#endif // 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 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 - l; }
+inline wxLongLong operator-(long l, const wxLongLong& ll)
+{
+ 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& ll) { return ll + l; }
-inline wxULongLong operator-(unsigned long l, const wxULongLong& ll) { return ll - l; }
+inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
+
+inline wxLongLong operator-(unsigned long l, const wxULongLong& ull)
+{
+ wxULongLong ret = wxULongLong(l) - ull;
+ return wxLongLong((long)ret.GetHi(),ret.GetLo());
+}
#endif // _WX_LONGLONG_H
projects / wxWidgets.git / blobdiff