Fix wx[Sorted]ArrayString::Index when wxUSE_STL=1, because

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

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index 3a6f3f6f90d5143984018112127470bcef05b142..725ff72c66fc12c1d1d66f0464aa54e06c8889d9 100644 (file)
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -7,13 +7,13 @@
 // Created:     10.02.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     10.02.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_LONGLONG_H
 #define _WX_LONGLONG_H
 
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_LONGLONG_H
 #define _WX_LONGLONG_H
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)

     #pragma interface "longlong.h"
 #endif
 
     #pragma interface "longlong.h"
 #endif
 


@@ -50,27 +50,40 @@
 // long", then check for specific compilers
 #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
     #define wxLongLong_t long
 // long", then check for specific compilers
 #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
     #define wxLongLong_t long

+    #define wxLongLongSuffix l
+    #define wxLongLongFmtSpec _T("l")

     #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

+    #define wxLongLongSuffix i64
+    #define wxLongLongFmtSpec _T("I64")

 #elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
     #define wxLongLong_t __int64
 #elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
     #define wxLongLong_t __int64

-#elif defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8
-    #define wxLongLong_t long long
-#elif defined(__MINGW32__) || defined(__CYGWIN__) || defined(__WXMICROWIN__)
+    #define wxLongLongSuffix i64
+    #define wxLongLongFmtSpec _T("Ld")
+#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \
+        defined(__MINGW32__) || \
+        defined(__GNUC__) || \
+        defined(__CYGWIN__) || \
+        defined(__WXMICROWIN__) || \
+        (defined(__DJGPP__) && __DJGPP__ >= 2)

     #define wxLongLong_t long long
     #define wxLongLong_t long long

+    #define wxLongLongSuffix ll
+    #define wxLongLongFmtSpec _T("ll")

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

+        #define wxLongLongSuffix ll
+        #define wxLongLongFmtSpec _T("ll")

     #else
         #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
     #else
         #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
+    #define wxLongLong_t long long

 #else // no native long long type
     // both warning and pragma warning are not portable, but at least an
 #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 - except that, actually, some
+    // 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__))
     // broken compilers don't like it, so we have to disable it in this case
     // <sigh>
 #if !(defined(__WATCOMC__) || defined(__VISAGECPP__))


@@ -83,6 +96,11 @@
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 

+// this macro allows to definea 64 bit constant in a portable way
+#define wxMakeLongLong(x, s) x ## s
+#define wxMakeLongLong2(x, s) wxMakeLongLong(x, s)
+#define wxLL(x) wxMakeLongLong2(x, wxLongLongSuffix)
+

 // 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
 // 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


@@ -93,7 +111,8 @@
         #define wxUSE_LONGLONG_NATIVE 0
     #endif
 
         #define wxUSE_LONGLONG_NATIVE 0
     #endif
 

-    class WXDLLEXPORT wxLongLongWx;
+    class WXDLLIMPEXP_BASE wxLongLongWx;
+    class WXDLLIMPEXP_BASE wxULongLongWx;

 #if defined(__VISUALC__) && !defined(__WIN32__)
     #define wxLongLong wxLongLongWx
     #define wxULongLong wxULongLongWx
 #if defined(__VISUALC__) && !defined(__WIN32__)
     #define wxLongLong wxLongLongWx
     #define wxULongLong wxULongLongWx


@@ -111,8 +130,8 @@
 
 #ifndef wxUSE_LONGLONG_WX
     #define wxUSE_LONGLONG_WX 0
 
 #ifndef wxUSE_LONGLONG_WX
     #define wxUSE_LONGLONG_WX 0

-    class WXDLLEXPORT wxLongLongNative;
-    class WXDLLEXPORT wxULongLongNative;
+    class WXDLLIMPEXP_BASE wxLongLongNative;
+    class WXDLLIMPEXP_BASE wxULongLongNative;

     typedef wxLongLongNative wxLongLong;
     typedef wxULongLongNative wxULongLong;
 #endif
     typedef wxLongLongNative wxLongLong;
     typedef wxULongLongNative wxULongLong;
 #endif


@@ -125,20 +144,20 @@
 // ----------------------------------------------------------------------------
 
 // we use iostream for wxLongLong output
 // ----------------------------------------------------------------------------
 
 // we use iostream for wxLongLong output

-#include "wx/ioswrap.h"
+#include "wx/iosfwrap.h"

 
 #if wxUSE_LONGLONG_NATIVE
 
 
 #if wxUSE_LONGLONG_NATIVE
 

-class WXDLLEXPORT wxLongLongNative
+class WXDLLIMPEXP_BASE wxLongLongNative

 {
 public:
     // ctors
         // default ctor initializes to 0
 {
 public:
     // ctors
         // default ctor initializes to 0

-    wxLongLongNative() { m_ll = 0; }
+    wxLongLongNative() : m_ll(0) { }

         // from long long
         // from long long

-    wxLongLongNative(wxLongLong_t ll) { m_ll = ll; }
+    wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { }

         // from 2 longs
         // from 2 longs

-    wxLongLongNative(long hi, unsigned long lo)
+    wxLongLongNative(long hi, unsigned long lo) : m_ll(0)

     {
         // assign first to avoid precision loss!
         m_ll = ((wxLongLong_t) hi) << 32;
     {
         // assign first to avoid precision loss!
         m_ll = ((wxLongLong_t) hi) << 32;


@@ -177,11 +196,6 @@ public:
         // convert to native long long
     wxLongLong_t GetValue() const { return m_ll; }
 
         // convert to native long long
     wxLongLong_t GetValue() const { return m_ll; }
 

-        // implicit conversion for times when we want a native type
-        // or wxLongLong, NOT wxLongLongNative and without having
-        // to ifdef user code for each use.
-    operator wxLongLong_t() const { return m_ll; }
-

         // 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
     {


@@ -212,8 +226,8 @@ public:
         { m_ll++; return *this; }
 
         // post increment
         { m_ll++; return *this; }
 
         // post increment

-    wxLongLongNative& operator++(int)
-        { m_ll++; return *this; }
+    wxLongLongNative operator++(int)
+        { wxLongLongNative value(*this); m_ll++; return value; }

 
         // negation operator
     wxLongLongNative operator-() const
 
         // negation operator
     wxLongLongNative operator-() const


@@ -236,8 +250,8 @@ public:
         { m_ll--; return *this; }
 
         // post decrement
         { m_ll--; return *this; }
 
         // post decrement

-    wxLongLongNative& operator--(int)
-        { m_ll--; return *this; }
+    wxLongLongNative operator--(int)
+        { wxLongLongNative value(*this); m_ll--; return value; }

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


@@ -336,16 +350,16 @@ private:
 };
 
 
 };
 
 

-class WXDLLEXPORT wxULongLongNative
+class WXDLLIMPEXP_BASE wxULongLongNative

 {
 public:
     // ctors
         // default ctor initializes to 0
 {
 public:
     // ctors
         // default ctor initializes to 0

-    wxULongLongNative() { m_ll = 0; }
+    wxULongLongNative() : m_ll(0) { }

         // from long long
         // from long long

-    wxULongLongNative(unsigned wxLongLong_t ll) { m_ll = ll; }
+    wxULongLongNative(unsigned wxLongLong_t ll) : m_ll(ll) { }

         // from 2 longs
         // from 2 longs

-    wxULongLongNative(unsigned long hi, unsigned long lo)
+    wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)

     {
         // assign first to avoid precision loss!
         m_ll = ((unsigned wxLongLong_t) hi) << 32;
     {
         // assign first to avoid precision loss!
         m_ll = ((unsigned wxLongLong_t) hi) << 32;


@@ -383,10 +397,6 @@ public:
         return (unsigned long)m_ll;
     }
 
         return (unsigned long)m_ll;
     }
 

-    // don't provide implicit conversion to unsigned wxLongLong_t or we
-    // will have an ambiguity for all arithmetic operations
-    //operator wxULongLong_t() const { return m_ll; }
-

     // operations
         // addition
     wxULongLongNative operator+(const wxULongLongNative& ll) const
     // operations
         // addition
     wxULongLongNative operator+(const wxULongLongNative& ll) const


@@ -404,8 +414,8 @@ public:
         { m_ll++; return *this; }
 
         // post increment
         { m_ll++; return *this; }
 
         // post increment

-    wxULongLongNative& operator++(int)
-        { m_ll++; return *this; }
+    wxULongLongNative operator++(int)
+        { wxULongLongNative value(*this); m_ll++; return value; }

 
         // subtraction
     wxULongLongNative operator-(const wxULongLongNative& ll) const
 
         // subtraction
     wxULongLongNative operator-(const wxULongLongNative& ll) const


@@ -423,8 +433,8 @@ public:
         { m_ll--; return *this; }
 
         // post decrement
         { m_ll--; return *this; }
 
         // post decrement

-    wxULongLongNative& operator--(int)
-        { m_ll--; return *this; }
+    wxULongLongNative operator--(int)
+        { wxULongLongNative value(*this); m_ll--; return value; }

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


@@ -526,7 +536,7 @@ private:
 
 #if wxUSE_LONGLONG_WX
 
 
 #if wxUSE_LONGLONG_WX
 

-class WXDLLEXPORT wxLongLongWx
+class WXDLLIMPEXP_BASE wxLongLongWx

 {
 public:
     // ctors
 {
 public:
     // ctors


@@ -723,7 +733,7 @@ private:
 };
 
 
 };
 
 

-class WXDLLEXPORT wxULongLongWx
+class WXDLLIMPEXP_BASE wxULongLongWx

 {
 public:
     // ctors
 {
 public:
     // ctors


@@ -786,7 +796,7 @@ public:
         // convert to long with range checking in the debug mode (only!)
     unsigned long ToULong() const
     {
         // convert to long with range checking in the debug mode (only!)
     unsigned long ToULong() const
     {

-        wxASSERT_MSG( (m_hi == 0l),
+        wxASSERT_MSG( m_hi == 0ul,

                       _T("wxULongLong to long conversion loss of precision") );
 
         return (unsigned long)m_lo;
                       _T("wxULongLong to long conversion loss of precision") );
 
         return (unsigned long)m_lo;


@@ -805,7 +815,7 @@ public:
         // post increment operator
     wxULongLongWx& operator++(int) { return ++(*this); }
 
         // post increment operator
     wxULongLongWx& operator++(int) { return ++(*this); }
 

-        // subraction
+        // subraction (FIXME: should return wxLongLong)

     wxULongLongWx operator-(const wxULongLongWx& ll) const;
     wxULongLongWx& operator-=(const wxULongLongWx& ll);
 
     wxULongLongWx operator-(const wxULongLongWx& ll) const;
     wxULongLongWx& operator-=(const wxULongLongWx& ll);
 


@@ -883,7 +893,7 @@ public:
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 

-    unsigned long m_hi
+    unsigned long m_hi;

     unsigned long m_lo;
 
 #ifdef wxLONGLONG_TEST_MODE
     unsigned long m_lo;
 
 #ifdef wxLONGLONG_TEST_MODE


@@ -903,23 +913,31 @@ private:
 // ----------------------------------------------------------------------------
 
 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 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 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; }
+inline wxLongLong operator-(long l, const wxLongLong& ll)
+{
+    return wxLongLong(l) - ll;
+}
+
+inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
+inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
+inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
+inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
+inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
+inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }

 
 

-inline bool operator<(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator>(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator<=(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator>=(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator==(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator!=(unsigned long l, const wxULongLong& ll) { return ll > l; }
+inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }

 
 

-inline wxULongLong operator+(unsigned long l, const wxULongLong& ll) { return ll + l; }
-inline wxULongLong operator-(unsigned long l, const wxULongLong& ll) { return ll - l; }
+// FIXME: this should return wxLongLong
+inline wxULongLong operator-(unsigned long l, const wxULongLong& ull)
+{
+    return wxULongLong(l) - ull;
+}

 
 #endif // _WX_LONGLONG_H
 
 #endif // _WX_LONGLONG_H