VA 4.0 fixes

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

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index 562c1e1de4d1412951bc15e9de650272357d7a11..5ff8a9b01c63fe5cd15e30b7c03cea688e0e6b15 100644 (file)
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -25,7 +25,17 @@
 
 #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


@@ -54,15 +64,17 @@
         #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.
+    // Err, actually, Watcom C++ doesn't like it.
+    // (well, if the compilers are _that_ broken, I'm removing it (VZ))
+#if 0 //ndef __WATCOMC__
+    #pragma warning "Your compiler does not appear to support 64 bit "\
+                    "integers, using emulation class instead."
+#endif

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


@@ -71,8 +83,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)
 // 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 nad only there
+    #ifndef wxUSE_LONGLONG_NATIVE
+        #define wxUSE_LONGLONG_NATIVE 0
+    #endif
+

     class WXDLLEXPORT wxLongLongWx;
     typedef wxLongLongWx wxLongLong;
 #else
     class WXDLLEXPORT wxLongLongWx;
     typedef wxLongLongWx wxLongLong;
 #else


@@ -305,13 +321,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 +355,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 +379,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 +414,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 +428,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


@@ -419,13 +479,22 @@ public:
     friend ostream& operator<<(ostream&, const wxLongLongWx&);
 #endif // wxUSE_STD_IOSTREAM
 
     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;
 
 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