#pragma interface "longlong.h"
#endif
+#include "wx/defs.h"
+#include "wx/wxchar.h"
+#include "wx/debug.h"
+
+#include <limits.h> // for LONG_MAX
+
+#define wxUSE_LONGLONG_WX 1
+
// ----------------------------------------------------------------------------
// decide upon which class we will use
// ----------------------------------------------------------------------------
// to avoid compilation problems on 64bit machines with ambiguous method calls
-// we will need this
+// 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
+// use 'unsigned wxLongLong_t' as well and because we use "#ifdef
+// wxLongLong_t" below
#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
#define wxLongLong_t long
#define wxLongLongIsLong
-#elif defined(__VISUALC__)
+#elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
+ #define wxLongLong_t __int64
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x530)
#define wxLongLong_t __int64
#elif defined(__GNUG__)
#define wxLongLong_t long long
#error "The 64 bit integer support in CodeWarrior has been disabled."
#error "See the documentation on the 'longlong' pragma."
#endif
-#else
- #warning "Your compiler does not appear to support 64 bit integers, "\
- "using emulation class instead."
+#else // no native long long type
+ // we don't give warnings for the compilers we know about that they don't
+ // have any 64 bit integer type
+ #if !defined(__VISAGECPP__) && \
+ !defined(__VISUALC__) && \
+ !defined(__BORLANDC__
+ #warning "Your compiler does not appear to support 64 bit integers, "\
+ "using emulation class instead."
+ #endif // known compilers without long long
+
#define wxUSE_LONGLONG_WX 1
#endif // compiler
// 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
-#ifndef wxLongLong_t
+#if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
#undef wxUSE_LONGLONG_NATIVE
#define wxUSE_LONGLONG_NATIVE 0
class WXDLLEXPORT wxLongLongWx;
m_ll |= (wxLongLong_t) lo;
}
- // default copy ctor is ok in both cases
+ // default copy ctor is ok
// no dtor
wxLongLongNative& operator=(wxLongLong_t ll)
{ m_ll = ll; return *this; }
+ // from double: this one has an explicit name because otherwise we
+ // would have ambiguity with "ll = int" and also because we don't want
+ // to have implicit conversions between doubles and wxLongLongs
+ wxLongLongNative& Assign(double d)
+ { m_ll = (wxLongLong_t)d; return *this; }
+
// assignment operators from wxLongLongNative is ok
// accessors
// get high part
long GetHi() const
- { return (long)((m_ll & 0xFFFFFFFF00000000l) >> 32); }
+ { return (long)(m_ll >> 32); }
// get low part
unsigned long GetLo() const
- { return (unsigned long) (m_ll & 0x00000000FFFFFFFFl); }
+ { return (unsigned long)m_ll; }
// get absolute value
+ wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }
wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
// convert to native long long
wxLongLong_t GetValue() const { return m_ll; }
+ // convert to long with range checking in the debug mode (only!)
+ long ToLong() const
+ {
+ wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
+ _T("wxLongLong to long conversion loss of precision") );
+
+ return (long)m_ll;
+ }
+
+ // 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; }
// operations
// multiplication/division
wxLongLongNative operator*(const wxLongLongNative& ll) const
{ return wxLongLongNative(m_ll * ll.m_ll); }
+ wxLongLongNative operator*(long l) const
+ { return wxLongLongNative(m_ll * l); }
wxLongLongNative& operator*=(const wxLongLongNative& ll)
{ m_ll *= ll.m_ll; return *this; }
+ wxLongLongNative& operator*=(long l)
+ { m_ll *= l; return *this; }
wxLongLongNative operator/(const wxLongLongNative& ll) const
{ return wxLongLongNative(m_ll / ll.m_ll); }
{ return wxLongLongNative(m_ll / l); }
wxLongLongNative& operator/=(const wxLongLongNative& ll)
{ m_ll /= ll.m_ll; return *this; }
+ wxLongLongNative& operator/=(long l)
+ { m_ll /= l; return *this; }
wxLongLongNative operator%(const wxLongLongNative& ll) const
{ return wxLongLongNative(m_ll % ll.m_ll); }
// conversion to byte array: returns a pointer to static buffer!
void *asArray() const;
+#if wxUSE_STD_IOSTREAM
// input/output
friend ostream& operator<<(ostream&, const wxLongLongNative&);
+#endif
private:
wxLongLong_t m_ll;
// from long
wxLongLongWx& operator=(long l)
{ m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
+ // from double
+ wxLongLongWx& Assign(double d);
// can't have assignment operator from 2 longs
// accessors
// get low part
unsigned long GetLo() const { return m_lo; }
+ // get absolute value
+ wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
+ wxLongLongWx& Abs() { if ( m_hi < 0 ) m_hi = -m_hi; return *this; }
+
+ // convert to long with range checking in the debug mode (only!)
+ long ToLong() const
+ {
+ wxASSERT_MSG( m_hi == 0l,
+ _T("wxLongLong to long conversion loss of precision") );
+
+ return (long)m_lo;
+ }
+
// operations
// addition
wxLongLongWx operator+(const wxLongLongWx& ll) const;
wxLongLongWx operator~() const;
// comparison
- bool operator==(const wxLongLongWx& ll) const;
- bool operator!=(const wxLongLongWx& ll) const;
+ bool operator==(const wxLongLongWx& ll) const
+ { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
+ bool operator!=(const wxLongLongWx& ll) const
+ { return !(*this == ll); }
bool operator<(const wxLongLongWx& ll) const;
bool operator>(const wxLongLongWx& ll) const;
- bool operator<=(const wxLongLongWx& ll) const;
- bool operator>=(const wxLongLongWx& ll) const;
+ bool operator<=(const wxLongLongWx& ll) const
+ { return *this < ll || *this == ll; }
+ bool operator>=(const wxLongLongWx& ll) const
+ { return *this > ll || *this == ll; }
// multiplication
wxLongLongWx operator*(const wxLongLongWx& ll) const;
wxLongLongWx& operator*=(const wxLongLongWx& ll);
- void *asArray(void) const;
// division
+ wxLongLongWx operator/(const wxLongLongWx& ll) const;
+ wxLongLongWx& operator/=(const wxLongLongWx& ll);
+
+ wxLongLongWx operator%(const wxLongLongWx& ll) const;
+
void Divide(const wxLongLongWx& divisor,
wxLongLongWx& quotient,
wxLongLongWx& remainder) const;
// input/output
+#if wxUSE_STD_IOSTREAM
friend ostream& operator<<(ostream&, const wxLongLongWx&);
+#endif // wxUSE_STD_IOSTREAM
+
+ void *asArray(void) const;
private:
// long is at least 32 bits, so represent our 64bit number as 2 longs
#endif // wxUSE_LONGLONG_WX
+// ----------------------------------------------------------------------------
+// binary operators
+// ----------------------------------------------------------------------------
+
+inline bool WXDLLEXPORT operator<(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator>(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator<=(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator>=(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator==(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator!=(long l, const wxLongLong& ll) { return ll > l; }
+
+inline wxLongLong WXDLLEXPORT operator+(long l, const wxLongLong& ll) { return ll + l; }
+inline wxLongLong WXDLLEXPORT operator-(long l, const wxLongLong& ll) { return ll - l; }
+
#endif // _WX_LONGLONG_H
projects / wxWidgets.git / blobdiff