Fixed old FIXME about unsigned result of sunstraction + a few changes to be able to compile at the same time wxLongLongNative and wxLongLongWx for unit tests about the same functionality (define wxLONGLONG_TEST_MODE for the build if you want to test it.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@30822 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/longlong.h

@@ -115,6 +115,9 @@ public:
         m_ll = ((wxLongLong_t) hi) << 32;
         m_ll |= (wxLongLong_t) lo;
     }
+#if wxUSE_LONGLONG_WX
+    wxLongLongNative(wxLongLongWx ll);
+#endif
 
     // default copy ctor is ok
 
@@ -124,6 +127,10 @@ public:
         // from native 64 bit integer
     wxLongLongNative& operator=(wxLongLong_t ll)
         { m_ll = ll; return *this; }
+#if wxUSE_LONGLONG_WX
+    wxLongLongNative& operator=(wxLongLongWx ll);
+#endif
+
 
         // from double: this one has an explicit name because otherwise we
         // would have ambiguity with "ll = int" and also because we don't want
@@ -623,6 +630,10 @@ public:
     // comparison
     bool operator==(const wxLongLongWx& ll) const
         { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
+#if wxUSE_LONGLONG_NATIVE
+    bool operator==(const wxLongLongNative& ll) const
+        { return m_lo == ll.GetLo() && m_hi == ll.GetHi(); }
+#endif
     bool operator!=(const wxLongLongWx& ll) const
         { return !(*this == ll); }
     bool operator<(const wxLongLongWx& ll) const;
@@ -717,6 +728,14 @@ public:
 #endif // wxLONGLONG_TEST_MODE
     }
 
+    // from signed to unsigned
+    wxULongLongWx(wxLongLongWx ll)
+    {
+        wxASSERT(ll.GetHi() >= 0);
+        m_hi = (unsigned long)ll.GetHi();
+        m_lo = ll.GetLo();
+    }
+
     // default copy ctor is ok in both cases
 
     // no dtor
@@ -767,8 +786,8 @@ public:
         // post increment operator
     wxULongLongWx& operator++(int) { return ++(*this); }
 
-        // subraction (FIXME: should return wxLongLong)
+        // substraction
-    wxULongLongWx operator-(const wxULongLongWx& ll) const;
+    wxLongLongWx operator-(const wxULongLongWx& ll) const;
     wxULongLongWx& operator-=(const wxULongLongWx& ll);
 
         // pre decrement operator
@@ -886,10 +905,10 @@ inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull !=
 
 inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
 
-// FIXME: this should return wxLongLong
+inline wxLongLong operator-(unsigned long l, const wxULongLong& ull)
-inline wxULongLong operator-(unsigned long l, const wxULongLong& ull)
 {
-    return wxULongLong(l) - ull;
+    wxULongLong ret = wxULongLong(l) - ull;
+    return wxLongLong((long)ret.GetHi(),ret.GetLo());
 }
 
 #endif // _WX_LONGLONG_H

src/common/longlong.cpp

@@ -78,6 +78,25 @@ void *wxULongLongNative::asArray() const
     return temp;
 }
 
+#if wxUSE_LONGLONG_WX
+wxLongLongNative::wxLongLongNative(wxLongLongWx ll)
+{
+    // assign first to avoid precision loss!
+    m_ll = ll.GetHi();
+    m_ll <<= 32;
+    m_ll |= ll.GetLo();
+}
+
+wxLongLongNative& wxLongLongNative::operator=(wxLongLongWx ll)
+{
+    // assign first to avoid precision loss!
+    m_ll = ll.GetHi();
+    m_ll <<= 32;
+    m_ll |= ll.GetLo();
+    return *this;
+}
+#endif
+
 #endif // wxUSE_LONGLONG_NATIVE
 
 // ============================================================================
@@ -426,10 +445,14 @@ wxLongLongWx wxLongLongWx::operator-(const wxLongLongWx& ll) const
     return res;
 }
 
-wxULongLongWx wxULongLongWx::operator-(const wxULongLongWx& ll) const
+wxLongLongWx wxULongLongWx::operator-(const wxULongLongWx& ll) const
 {
-    wxULongLongWx res(*this);
+    wxASSERT(m_hi <= LONG_MAX );
-    res -= ll;
+    wxASSERT(ll.m_hi <= LONG_MAX );
+
+    wxLongLongWx res( (long)m_hi , m_lo );
+    wxLongLongWx op( (long)ll.m_hi , ll.m_lo );
+    res -= op;
 
     return res;
 }
@@ -819,7 +842,7 @@ void wxLongLongWx::Divide(const wxLongLongWx& divisorIn,
     }
     else
     {
-        // here: dividend > divisor and both are positibe: do unsigned division
+        // here: dividend > divisor and both are positive: do unsigned division
         size_t nBits = 64u;
         wxLongLongWx d;
 
@@ -1062,66 +1085,68 @@ void *wxULongLongWx::asArray(void) const
 
 #endif // wxUSE_LONGLONG_WX
 
-wxString
+#define LL_TO_STRING(name)                                           \
+    wxString name::ToString() const                                  \
+    {                                                                \
+        /* TODO: this is awfully inefficient, anything better? */    \
+        wxString result;                                             \
+                                                                     \
+        name ll = *this;                                             \
+                                                                     \
+        bool neg;                                                    \
+        if ( ll < 0 )                                                \
+        {                                                            \
+            ll.Negate();                                             \
+            neg = true;                                              \
+        }                                                            \
+        else                                                         \
+        {                                                            \
+            neg = false;                                             \
+        }                                                            \
+                                                                     \
+        while ( ll != 0 )                                            \
+        {                                                            \
+            result.Prepend((wxChar)(_T('0') + (ll % 10).ToLong()));  \
+            ll /= 10;                                                \
+        }                                                            \
+                                                                     \
+        if ( result.empty() )                                        \
+            result = _T('0');                                        \
+        else if ( neg )                                              \
+            result.Prepend(_T('-'));                                 \
+                                                                     \
+        return result;                                               \
+    }
+
+#define ULL_TO_STRING(name)                                          \
+    wxString name::ToString() const                                  \
+    {                                                                \
+        /* TODO: this is awfully inefficient, anything better? */    \
+        wxString result;                                             \
+                                                                     \
+        name ll = *this;                                             \
+                                                                     \
+        while ( ll != 0 )                                            \
+        {                                                            \
+            result.Prepend((wxChar)(_T('0') + (ll % 10).ToULong())); \
+            ll /= 10;                                                \
+        }                                                            \
+                                                                     \
+        if ( result.empty() )                                        \
+            result = _T('0');                                        \
+                                                                     \
+        return result;                                               \
+    }
+
 #if wxUSE_LONGLONG_NATIVE
-wxLongLongNative::ToString() const
+    LL_TO_STRING(wxLongLongNative)
-#else
+    ULL_TO_STRING(wxULongLongNative)
-wxLongLongWx::ToString() const
 #endif
-{
-    // TODO: this is awfully inefficient, anything better?
-    wxString result;
 
-    wxLongLong ll = *this;
+#if wxUSE_LONGLONG_WX
-
+    LL_TO_STRING(wxLongLongWx)
-    bool neg;
+    ULL_TO_STRING(wxULongLongWx)
-    if ( ll < 0 )
-    {
-        ll.Negate();
-        neg = true;
-    }
-    else
-    {
-        neg = false;
-    }
-
-    while ( ll != 0 )
-    {
-        result.Prepend((wxChar)(_T('0') + (ll % 10).ToLong()));
-        ll /= 10;
-    }
-
-    if ( result.empty() )
-        result = _T('0');
-    else if ( neg )
-        result.Prepend(_T('-'));
-
-    return result;
-}
-
-wxString
-#if wxUSE_LONGLONG_NATIVE
-wxULongLongNative::ToString() const
-#else
-wxULongLongWx::ToString() const
 #endif
-{
-    // TODO: this is awfully inefficient, anything better?
-    wxString result;
-
-    wxULongLong ll = *this;
-
-    while ( ll != 0 )
-    {
-        result.Prepend((wxChar)(_T('0') + (ll % 10).ToULong()));
-        ll /= 10;
-    }
-
-    if ( result.empty() )
-        result = _T('0');
-
-    return result;
-}
 
 #if wxUSE_STD_IOSTREAM