Linking with the TIFF library

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

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index c9b582b7a3d1c44256c82de5a6a4d46c51c8a45c..a3e8281d27a547c96c29b83c457f51ceea8b46a0 100644 (file)
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -19,6 +19,12 @@
     #pragma interface "longlong.h"
 #endif
 
+#include "wx/defs.h"
+#include "wx/wxchar.h"
+#include "wx/debug.h"
+
+#include <limits.h>     // for LONG_MAX
+
 // ----------------------------------------------------------------------------
 // decide upon which class we will use
 // ----------------------------------------------------------------------------
@@ -33,7 +39,9 @@
 #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
     #define wxLongLong_t long
     #define wxLongLongIsLong
-#elif defined(__VISUALC__)
+#elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
+    #define wxLongLong_t __int64
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x530)
     #define wxLongLong_t __int64
 #elif defined(__GNUG__)
     #define wxLongLong_t long long
@@ -44,9 +52,16 @@
         #error "The 64 bit integer support in CodeWarrior has been disabled."
         #error "See the documentation on the 'longlong' pragma."
     #endif
-#else
-    #warning "Your compiler does not appear to support 64 bit integers, "\
-             "using emulation class instead."
+#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
+
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
@@ -108,6 +123,12 @@ public:
     wxLongLongNative& operator=(wxLongLong_t ll)
         { m_ll = ll; return *this; }
 
+        // from double: this one has an explicit name because otherwise we
+        // would have ambiguity with "ll = int" and also because we don't want
+        // to have implicit conversions between doubles and wxLongLongs
+    wxLongLongNative& Assign(double d)
+        { m_ll = (wxLongLong_t)d; return *this; }
+
     // assignment operators from wxLongLongNative is ok
 
     // accessors
@@ -124,6 +145,15 @@ public:
         // convert to native long long
     wxLongLong_t GetValue() const { return m_ll; }
 
+        // convert to long with range checking in the debug mode (only!)
+    long ToLong() const
+    {
+        wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
+                      _T("wxLongLong to long conversion loss of precision") );
+
+        return (long)m_ll;
+    }
+
     // don't provide implicit conversion to wxLongLong_t or we will have an
     // ambiguity for all arithmetic operations
     //operator wxLongLong_t() const { return m_ll; }
@@ -254,8 +284,10 @@ public:
         // conversion to byte array: returns a pointer to static buffer!
     void *asArray() const;
 
+#if wxUSE_STD_IOSTREAM
         // input/output
     friend ostream& operator<<(ostream&, const wxLongLongNative&);
+#endif
 
 private:
     wxLongLong_t  m_ll;
@@ -286,6 +318,8 @@ public:
         // from long
     wxLongLongWx& operator=(long l)
         { m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
+        // from double
+    wxLongLongWx& Assign(double d);
         // can't have assignment operator from 2 longs
 
     // accessors
@@ -294,6 +328,18 @@ public:
         // get low part
     unsigned long GetLo() const { return m_lo; }
 
+        // get absolute value
+    wxLongLongWx& Abs() { if ( m_hi < 0 ) m_hi = -m_hi; return *this; }
+
+        // convert to long with range checking in the debug mode (only!)
+    long ToLong() const
+    {
+        wxASSERT_MSG( m_hi == 0l,
+                      _T("wxLongLong to long conversion loss of precision") );
+
+        return (long)m_lo;
+    }
+
     // operations
         // addition
     wxLongLongWx operator+(const wxLongLongWx& ll) const;
@@ -349,15 +395,23 @@ public:
     // multiplication
     wxLongLongWx operator*(const wxLongLongWx& ll) const;
     wxLongLongWx& operator*=(const wxLongLongWx& ll);
-    void *asArray(void) const;
 
     // division
+    wxLongLongWx operator/(const wxLongLongWx& ll) const;
+    wxLongLongWx& operator/=(const wxLongLongWx& ll);
+
+    wxLongLongWx operator%(const wxLongLongWx& ll) const;
+
     void Divide(const wxLongLongWx& divisor,
                 wxLongLongWx& quotient,
                 wxLongLongWx& remainder) const;
 
     // input/output
+#if wxUSE_STD_IOSTREAM
     friend ostream& operator<<(ostream&, const wxLongLongWx&);
+#endif // wxUSE_STD_IOSTREAM
+
+    void *asArray(void) const;
 
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs