test for wxLog interaction with wxYield better

[wxWidgets.git] / include / wx / longlong.h

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index c8778899ab94f48a363c3aa52a1a8135ed0e3797..621abc3e3dd2f1c8799c7637732abe2fe903a0fe 100644 (file)
--- 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
 // 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$
 // Modified by:
 // Created:     10.02.99
 // RCS-ID:      $Id$


@@ -21,11 +19,20 @@
 
 #include "wx/defs.h"
 #include "wx/wxchar.h"
 
 #include "wx/defs.h"
 #include "wx/wxchar.h"

-#include "wx/debug.h"

 
 #include <limits.h>     // for LONG_MAX
 
 
 #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
 
 // ----------------------------------------------------------------------------
 // decide upon which class we will use


@@ -43,9 +50,9 @@
     #define wxLongLongIsLong
 #elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
     #define wxLongLong_t __int64
     #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
     #define wxLongLong_t __int64

-#elif defined(__GNUG__)
+#elif defined(__GNUG__) || defined(__sgi)

     #define wxLongLong_t long long
 #elif defined(__MWERKS__)
     #if __option(longlong)
     #define wxLongLong_t long long
 #elif defined(__MWERKS__)
     #if __option(longlong)


@@ -54,16 +61,19 @@
         #error "The 64 bit integer support in CodeWarrior has been disabled."
         #error "See the documentation on the 'longlong' pragma."
     #endif
         #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
 #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
-
+    // both warning and pragma warning are not portable, but at least an
+    // 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

     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 


@@ -71,10 +81,19 @@
 // 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)
 // 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;
     class WXDLLEXPORT wxLongLongWx;

+#if defined(__VISUALC__) && !defined(__WIN32__)
+    #define wxLongLong wxLongLongWx
+#else

     typedef wxLongLongWx wxLongLong;
     typedef wxLongLongWx wxLongLong;

+#endif
+

 #else
     // if nothing is defined, use native implementation by default, of course
     #ifndef wxUSE_LONGLONG_NATIVE
 #else
     // if nothing is defined, use native implementation by default, of course
     #ifndef wxUSE_LONGLONG_NATIVE


@@ -289,7 +308,7 @@ public:
 
 #if wxUSE_STD_IOSTREAM
         // input/output
 
 #if wxUSE_STD_IOSTREAM
         // input/output

-    friend ostream& operator<<(ostream&, const wxLongLongNative&);
+    friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);

 #endif
 
 private:
 #endif
 
 private:


@@ -305,13 +324,32 @@ class WXDLLEXPORT wxLongLongWx
 public:
     // ctors
         // default ctor initializes to 0
 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
         // 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)
         // 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
 
 
     // default copy ctor is ok in both cases
 


@@ -320,7 +358,18 @@ public:
     // assignment operators
         // from long
     wxLongLongWx& operator=(long l)
     // 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
         // from double
     wxLongLongWx& Assign(double d);
         // can't have assignment operator from 2 longs


@@ -333,12 +382,25 @@ public:
 
         // get absolute value
     wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
 
         // 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
     {
 
         // 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;
                       _T("wxLongLong to long conversion loss of precision") );
 
         return (long)m_lo;


@@ -355,10 +417,11 @@ public:
     wxLongLongWx& operator++();
 
         // post increment operator
     wxLongLongWx& operator++();
 
         // post increment operator

-    wxLongLongWx& operator++(int);
+    wxLongLongWx& operator++(int) { return ++(*this); }

 
         // negation operator
     wxLongLongWx operator-() const;
 
         // negation operator
     wxLongLongWx operator-() const;

+    wxLongLongWx& Negate();

 
         // subraction
     wxLongLongWx operator-(const wxLongLongWx& ll) const;
 
         // subraction
     wxLongLongWx operator-(const wxLongLongWx& ll) const;


@@ -368,7 +431,7 @@ public:
     wxLongLongWx& operator--();
 
         // post decrement operator
     wxLongLongWx& operator--();
 
         // post decrement operator

-    wxLongLongWx& operator--(int);
+    wxLongLongWx& operator--(int) { return --(*this); }

 
     // shifts
         // left shift
 
     // shifts
         // left shift


@@ -400,6 +463,17 @@ public:
     bool operator>=(const wxLongLongWx& ll) const
         { return *this > ll || *this == ll; }
 
     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);
     // multiplication
     wxLongLongWx operator*(const wxLongLongWx& ll) const;
     wxLongLongWx& operator*=(const wxLongLongWx& ll);


@@ -416,16 +490,25 @@ public:
 
     // input/output
 #if wxUSE_STD_IOSTREAM
 
     // input/output
 #if wxUSE_STD_IOSTREAM

-    friend ostream& operator<<(ostream&, const wxLongLongWx&);
+    friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);

 #endif // wxUSE_STD_IOSTREAM
 
 #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;
 
 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
 };
 
 #endif // wxUSE_LONGLONG_WX


@@ -434,14 +517,14 @@ private:
 // binary operators
 // ----------------------------------------------------------------------------
 
 // 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 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 WXDLLEXPORT operator+(long l, const wxLongLong& ll) { return ll + l; }
-inline wxLongLong WXDLLEXPORT 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; }

 
 #endif // _WX_LONGLONG_H
 
 #endif // _WX_LONGLONG_H