X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9c2882d9e1b17c600a196e1b69fbe66b98204151..7a5e62674f8c9e923956d67d95f5d0c97763ca1f:/include/wx/longlong.h

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index 4fd611a710..31baf4810e 100644
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -3,8 +3,6 @@
 // Purpose:     declaration of wxLongLong class - best implementation of a 64
 //              bit integer for the current platform.
 // Author:      Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
-// Remarks:     this class is not public in wxWindows 2.0! It is intentionally
-//              not documented and is for private use only.
 // Modified by:
 // Created:     10.02.99
 // RCS-ID:      $Id$
@@ -21,11 +19,20 @@
 
 #include "wx/defs.h"
 #include "wx/wxchar.h"
-#include "wx/debug.h"
 
 #include <limits.h>     // for LONG_MAX
 
-//#define wxUSE_LONGLONG_WX 1 // for testing (VZ)
+// define this to compile wxLongLongWx in "test" mode: the results of all
+// calculations will be compared with the real results taken from
+// wxLongLongNative -- this is extremely useful to find the bugs in
+// wxLongLongWx class!
+
+// #define wxLONGLONG_TEST_MODE
+
+#ifdef wxLONGLONG_TEST_MODE
+    #define wxUSE_LONGLONG_WX 1
+    #define wxUSE_LONGLONG_NATIVE 1
+#endif // wxLONGLONG_TEST_MODE
 
 // ----------------------------------------------------------------------------
 // decide upon which class we will use
@@ -43,7 +50,7 @@
     #define wxLongLongIsLong
 #elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
     #define wxLongLong_t __int64
-#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x530)
+#elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
     #define wxLongLong_t __int64
 #elif defined(__GNUG__)
     #define wxLongLong_t long long
@@ -54,12 +61,16 @@
         #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
     // both warning and pragma warning are not portable, but at least an
-    // unknown pragma should never be an error
+    // unknown pragma should never be an error - unless the compiler is
+    // seriously broken as Watcom C++ seems to be...
+#if (!(defined(__WATCOMC__) || defined(__VISAGECPP__)))
     #pragma warning "Your compiler does not appear to support 64 bit "\
                     "integers, using emulation class instead."
-
+#endif
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
@@ -67,8 +78,12 @@
 // to disable automatic testing (useful for the test program which defines
 // both classes) but by default we only use one class
 #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
-    #undef wxUSE_LONGLONG_NATIVE
-    #define wxUSE_LONGLONG_NATIVE 0
+    // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set:
+    // this is useful in test programs and only there
+    #ifndef wxUSE_LONGLONG_NATIVE
+        #define wxUSE_LONGLONG_NATIVE 0
+    #endif
+
     class WXDLLEXPORT wxLongLongWx;
     typedef wxLongLongWx wxLongLong;
 #else
@@ -301,13 +316,32 @@ class WXDLLEXPORT wxLongLongWx
 public:
     // ctors
         // default ctor initializes to 0
-    wxLongLongWx() { m_lo = m_hi = 0; }
+    wxLongLongWx()
+    {
+        m_lo = m_hi = 0;
+
+#ifdef wxLONGLONG_TEST_MODE
+        m_ll = 0;
+
+        Check();
+#endif // wxLONGLONG_TEST_MODE
+    }
         // from long
-    wxLongLongWx(long l)
-        { m_lo = l; m_hi = (l < 0 ? -1l : 0l); }
+    wxLongLongWx(long l) { *this = l; }
         // from 2 longs
     wxLongLongWx(long hi, unsigned long lo)
-        { m_hi = hi; m_lo = lo; }
+    {
+        m_hi = hi;
+        m_lo = lo;
+
+#ifdef wxLONGLONG_TEST_MODE
+        m_ll = hi;
+        m_ll <<= 32;
+        m_ll |= lo;
+
+        Check();
+#endif // wxLONGLONG_TEST_MODE
+    }
 
     // default copy ctor is ok in both cases
 
@@ -316,7 +350,18 @@ public:
     // assignment operators
         // from long
     wxLongLongWx& operator=(long l)
-        { m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
+    {
+        m_lo = l;
+        m_hi = (l < 0 ? -1l : 0l);
+
+#ifdef wxLONGLONG_TEST_MODE
+        m_ll = l;
+
+        Check();
+#endif // wxLONGLONG_TEST_MODE
+
+        return *this;
+    }
         // from double
     wxLongLongWx& Assign(double d);
         // can't have assignment operator from 2 longs
@@ -329,12 +374,25 @@ public:
 
         // get absolute value
     wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
-    wxLongLongWx& Abs() { if ( m_hi < 0 ) m_hi = -m_hi; return *this; }
+    wxLongLongWx& Abs()
+    {
+        if ( m_hi < 0 )
+            m_hi = -m_hi;
+
+#ifdef wxLONGLONG_TEST_MODE
+        if ( m_ll < 0 )
+            m_ll = -m_ll;
+
+        Check();
+#endif // wxLONGLONG_TEST_MODE
+
+        return *this;
+    }
 
         // convert to long with range checking in the debug mode (only!)
     long ToLong() const
     {
-        wxASSERT_MSG( m_hi == 0l,
+        wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l),
                       _T("wxLongLong to long conversion loss of precision") );
 
         return (long)m_lo;
@@ -351,10 +409,11 @@ public:
     wxLongLongWx& operator++();
 
         // post increment operator
-    wxLongLongWx& operator++(int);
+    wxLongLongWx& operator++(int) { return ++(*this); }
 
         // negation operator
     wxLongLongWx operator-() const;
+    wxLongLongWx& Negate();
 
         // subraction
     wxLongLongWx operator-(const wxLongLongWx& ll) const;
@@ -364,7 +423,7 @@ public:
     wxLongLongWx& operator--();
 
         // post decrement operator
-    wxLongLongWx& operator--(int);
+    wxLongLongWx& operator--(int) { return --(*this); }
 
     // shifts
         // left shift
@@ -396,6 +455,17 @@ public:
     bool operator>=(const wxLongLongWx& ll) const
         { return *this > ll || *this == ll; }
 
+    bool operator<(long l) const { return *this < wxLongLongWx(l); }
+    bool operator>(long l) const { return *this > wxLongLongWx(l); }
+    bool operator==(long l) const
+    {
+        return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l)
+                      : (m_hi == -1 && m_lo == (unsigned long)l);
+    }
+
+    bool operator<=(long l) const { return *this < l || *this == l; }
+    bool operator>=(long l) const { return *this > l || *this == l; }
+
     // multiplication
     wxLongLongWx operator*(const wxLongLongWx& ll) const;
     wxLongLongWx& operator*=(const wxLongLongWx& ll);
@@ -415,13 +485,22 @@ public:
     friend ostream& operator<<(ostream&, const wxLongLongWx&);
 #endif // wxUSE_STD_IOSTREAM
 
-    void *asArray(void) const;
+    void *asArray() const;
 
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 
     long m_hi;                // signed bit is in the high part
     unsigned long m_lo;
+
+#ifdef wxLONGLONG_TEST_MODE
+    void Check()
+    {
+        wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
+    }
+
+    wxLongLong_t m_ll;
+#endif // wxLONGLONG_TEST_MODE
 };
 
 #endif // wxUSE_LONGLONG_WX