// 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.wxwindows.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;
// 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
};
-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(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
#if wxUSE_LONGLONG_WX
-class WXDLLEXPORT wxLongLongWx
+class WXDLLIMPEXP_BASE wxLongLongWx
{
public:
// ctors
};
-class WXDLLEXPORT wxULongLongWx
+class WXDLLIMPEXP_BASE wxULongLongWx
{
public:
// ctors
// 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