home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / longlong.h < prev    next >
C/C++ Source or Header  |  2002-10-21  |  32KB  |  943 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        wx/longlong.h
  3. // Purpose:     declaration of wxLongLong class - best implementation of a 64
  4. //              bit integer for the current platform.
  5. // Author:      Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
  6. // Modified by:
  7. // Created:     10.02.99
  8. // RCS-ID:      $Id: longlong.h,v 1.43.4.4 2002/10/17 16:30:36 VZ Exp $
  9. // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  10. // Licence:     wxWindows license
  11. /////////////////////////////////////////////////////////////////////////////
  12.  
  13. #ifndef _WX_LONGLONG_H
  14. #define _WX_LONGLONG_H
  15.  
  16. #if defined(__GNUG__) && !defined(__APPLE__)
  17.     #pragma interface "longlong.h"
  18. #endif
  19.  
  20. #include "wx/defs.h"
  21. #include "wx/string.h"
  22.  
  23. #include <limits.h>     // for LONG_MAX
  24.  
  25. // define this to compile wxLongLongWx in "test" mode: the results of all
  26. // calculations will be compared with the real results taken from
  27. // wxLongLongNative -- this is extremely useful to find the bugs in
  28. // wxLongLongWx class!
  29.  
  30. // #define wxLONGLONG_TEST_MODE
  31.  
  32. #ifdef wxLONGLONG_TEST_MODE
  33.     #define wxUSE_LONGLONG_WX 1
  34.     #define wxUSE_LONGLONG_NATIVE 1
  35. #endif // wxLONGLONG_TEST_MODE
  36.  
  37. // ----------------------------------------------------------------------------
  38. // decide upon which class we will use
  39. // ----------------------------------------------------------------------------
  40.  
  41. // to avoid compilation problems on 64bit machines with ambiguous method calls
  42. // we will need to define this
  43. #undef wxLongLongIsLong
  44.  
  45. // NB: we #define and not typedef wxLongLong_t because we want to be able to
  46. //     use 'unsigned wxLongLong_t' as well and because we use "#ifdef
  47. //     wxLongLong_t" below
  48.  
  49. // first check for generic cases which are long on 64bit machine and "long
  50. // long", then check for specific compilers
  51. #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
  52.     #define wxLongLong_t long
  53.     #define wxLongLongSuffix l
  54.     #define wxLongLongFmtSpec _T("l")
  55.     #define wxLongLongIsLong
  56. #elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
  57.     #define wxLongLong_t __int64
  58.     #define wxLongLongSuffix i64
  59.     #define wxLongLongFmtSpec _T("I64")
  60. #elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
  61.     #define wxLongLong_t __int64
  62.     #define wxLongLongSuffix i64
  63.     #define wxLongLongFmtSpec _T("I64")
  64. #elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \
  65.         defined(__MINGW32__) || \
  66.         defined(__CYGWIN__) || \
  67.         defined(__WXMICROWIN__) || \
  68.         (defined(__DJGPP__) && __DJGPP__ >= 2)
  69.     #define wxLongLong_t long long
  70.     #define wxLongLongSuffix ll
  71.     #define wxLongLongFmtSpec _T("ll")
  72. #elif defined(__MWERKS__)
  73.     #if __option(longlong)
  74.         #define wxLongLong_t long long
  75.         #define wxLongLongSuffix ll
  76.         #define wxLongLongFmtSpec _T("ll")
  77.     #else
  78.         #error "The 64 bit integer support in CodeWarrior has been disabled."
  79.         #error "See the documentation on the 'longlong' pragma."
  80.     #endif
  81. #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
  82.     #define wxLongLong_t long long
  83. #else // no native long long type
  84.     // both warning and pragma warning are not portable, but at least an
  85.     // unknown pragma should never be an error -- except that, actually, some
  86.     // broken compilers don't like it, so we have to disable it in this case
  87.     // <sigh>
  88. #if !(defined(__WATCOMC__) || defined(__VISAGECPP__))
  89.     #pragma warning "Your compiler does not appear to support 64 bit "\
  90.                     "integers, using emulation class instead.\n" \
  91.                     "Please report your compiler version to " \
  92.                     "wx-dev@lists.wxwindows.org!"
  93. #endif
  94.  
  95.     #define wxUSE_LONGLONG_WX 1
  96. #endif // compiler
  97.  
  98. // this macro allows to definea 64 bit constant in a portable way
  99. #define wxMakeLongLong(x, s) x ## s
  100. #define wxMakeLongLong2(x, s) wxMakeLongLong(x, s)
  101. #define wxLL(x) wxMakeLongLong2(x, wxLongLongSuffix)
  102.  
  103. // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
  104. // to disable automatic testing (useful for the test program which defines
  105. // both classes) but by default we only use one class
  106. #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
  107.     // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set:
  108.     // this is useful in test programs and only there
  109.     #ifndef wxUSE_LONGLONG_NATIVE
  110.         #define wxUSE_LONGLONG_NATIVE 0
  111.     #endif
  112.  
  113.     class WXDLLEXPORT wxLongLongWx;
  114.     class WXDLLEXPORT wxULongLongWx;
  115. #if defined(__VISUALC__) && !defined(__WIN32__)
  116.     #define wxLongLong wxLongLongWx
  117.     #define wxULongLong wxULongLongWx
  118. #else
  119.     typedef wxLongLongWx wxLongLong;
  120.     typedef wxULongLongWx wxULongLong;
  121. #endif
  122.  
  123. #else
  124.     // if nothing is defined, use native implementation by default, of course
  125.     #ifndef wxUSE_LONGLONG_NATIVE
  126.         #define wxUSE_LONGLONG_NATIVE 1
  127.     #endif
  128. #endif
  129.  
  130. #ifndef wxUSE_LONGLONG_WX
  131.     #define wxUSE_LONGLONG_WX 0
  132.     class WXDLLEXPORT wxLongLongNative;
  133.     class WXDLLEXPORT wxULongLongNative;
  134.     typedef wxLongLongNative wxLongLong;
  135.     typedef wxULongLongNative wxULongLong;
  136. #endif
  137.  
  138. // NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should
  139. //     typedef wxLongLong as it wants, we don't do it
  140.  
  141. // ----------------------------------------------------------------------------
  142. // choose the appropriate class
  143. // ----------------------------------------------------------------------------
  144.  
  145. // we use iostream for wxLongLong output
  146. #include "wx/ioswrap.h"
  147.  
  148. #if wxUSE_LONGLONG_NATIVE
  149.  
  150. class WXDLLEXPORT wxLongLongNative
  151. {
  152. public:
  153.     // ctors
  154.         // default ctor initializes to 0
  155.     wxLongLongNative() : m_ll(0) { }
  156.         // from long long
  157.     wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { }
  158.         // from 2 longs
  159.     wxLongLongNative(long hi, unsigned long lo) : m_ll(0)
  160.     {
  161.         // assign first to avoid precision loss!
  162.         m_ll = ((wxLongLong_t) hi) << 32;
  163.         m_ll |= (wxLongLong_t) lo;
  164.     }
  165.  
  166.     // default copy ctor is ok
  167.  
  168.     // no dtor
  169.  
  170.     // assignment operators
  171.         // from native 64 bit integer
  172.     wxLongLongNative& operator=(wxLongLong_t ll)
  173.         { m_ll = ll; return *this; }
  174.  
  175.         // from double: this one has an explicit name because otherwise we
  176.         // would have ambiguity with "ll = int" and also because we don't want
  177.         // to have implicit conversions between doubles and wxLongLongs
  178.     wxLongLongNative& Assign(double d)
  179.         { m_ll = (wxLongLong_t)d; return *this; }
  180.  
  181.     // assignment operators from wxLongLongNative is ok
  182.  
  183.     // accessors
  184.         // get high part
  185.     long GetHi() const
  186.         { return (long)(m_ll >> 32); }
  187.         // get low part
  188.     unsigned long GetLo() const
  189.         { return (unsigned long)m_ll; }
  190.  
  191.         // get absolute value
  192.     wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }
  193.     wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
  194.  
  195.         // convert to native long long
  196.     wxLongLong_t GetValue() const { return m_ll; }
  197.  
  198.         // convert to long with range checking in the debug mode (only!)
  199.     long ToLong() const
  200.     {
  201.         wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
  202.                       _T("wxLongLong to long conversion loss of precision") );
  203.  
  204.         return (long)m_ll;
  205.     }
  206.  
  207.     // don't provide implicit conversion to wxLongLong_t or we will have an
  208.     // ambiguity for all arithmetic operations
  209.     //operator wxLongLong_t() const { return m_ll; }
  210.  
  211.     // operations
  212.         // addition
  213.     wxLongLongNative operator+(const wxLongLongNative& ll) const
  214.         { return wxLongLongNative(m_ll + ll.m_ll); }
  215.     wxLongLongNative& operator+=(const wxLongLongNative& ll)
  216.         { m_ll += ll.m_ll; return *this; }
  217.  
  218.     wxLongLongNative operator+(const wxLongLong_t ll) const
  219.         { return wxLongLongNative(m_ll + ll); }
  220.     wxLongLongNative& operator+=(const wxLongLong_t ll)
  221.         { m_ll += ll; return *this; }
  222.  
  223.         // pre increment
  224.     wxLongLongNative& operator++()
  225.         { m_ll++; return *this; }
  226.  
  227.         // post increment
  228.     wxLongLongNative operator++(int)
  229.         { wxLongLongNative value(*this); m_ll++; return value; }
  230.  
  231.         // negation operator
  232.     wxLongLongNative operator-() const
  233.         { return wxLongLongNative(-m_ll); }
  234.     wxLongLongNative& Negate() { m_ll = -m_ll; return *this; }
  235.  
  236.         // subtraction
  237.     wxLongLongNative operator-(const wxLongLongNative& ll) const
  238.         { return wxLongLongNative(m_ll - ll.m_ll); }
  239.     wxLongLongNative& operator-=(const wxLongLongNative& ll)
  240.         { m_ll -= ll.m_ll; return *this; }
  241.  
  242.     wxLongLongNative operator-(const wxLongLong_t ll) const
  243.         { return wxLongLongNative(m_ll - ll); }
  244.     wxLongLongNative& operator-=(const wxLongLong_t ll)
  245.         { m_ll -= ll; return *this; }
  246.  
  247.         // pre decrement
  248.     wxLongLongNative& operator--()
  249.         { m_ll--; return *this; }
  250.  
  251.         // post decrement
  252.     wxLongLongNative operator--(int)
  253.         { wxLongLongNative value(*this); m_ll--; return value; }
  254.  
  255.     // shifts
  256.         // left shift
  257.     wxLongLongNative operator<<(int shift) const
  258.         { return wxLongLongNative(m_ll << shift);; }
  259.     wxLongLongNative& operator<<=(int shift)
  260.         { m_ll <<= shift; return *this; }
  261.  
  262.         // right shift
  263.     wxLongLongNative operator>>(int shift) const
  264.         { return wxLongLongNative(m_ll >> shift);; }
  265.     wxLongLongNative& operator>>=(int shift)
  266.         { m_ll >>= shift; return *this; }
  267.  
  268.     // bitwise operators
  269.     wxLongLongNative operator&(const wxLongLongNative& ll) const
  270.         { return wxLongLongNative(m_ll & ll.m_ll); }
  271.     wxLongLongNative& operator&=(const wxLongLongNative& ll)
  272.         { m_ll &= ll.m_ll; return *this; }
  273.  
  274.     wxLongLongNative operator|(const wxLongLongNative& ll) const
  275.         { return wxLongLongNative(m_ll | ll.m_ll); }
  276.     wxLongLongNative& operator|=(const wxLongLongNative& ll)
  277.         { m_ll |= ll.m_ll; return *this; }
  278.  
  279.     wxLongLongNative operator^(const wxLongLongNative& ll) const
  280.         { return wxLongLongNative(m_ll ^ ll.m_ll); }
  281.     wxLongLongNative& operator^=(const wxLongLongNative& ll)
  282.         { m_ll ^= ll.m_ll; return *this; }
  283.  
  284.     // multiplication/division
  285.     wxLongLongNative operator*(const wxLongLongNative& ll) const
  286.         { return wxLongLongNative(m_ll * ll.m_ll); }
  287.     wxLongLongNative operator*(long l) const
  288.         { return wxLongLongNative(m_ll * l); }
  289.     wxLongLongNative& operator*=(const wxLongLongNative& ll)
  290.         { m_ll *= ll.m_ll; return *this; }
  291.     wxLongLongNative& operator*=(long l)
  292.         { m_ll *= l; return *this; }
  293.  
  294.     wxLongLongNative operator/(const wxLongLongNative& ll) const
  295.         { return wxLongLongNative(m_ll / ll.m_ll); }
  296.     wxLongLongNative operator/(long l) const
  297.         { return wxLongLongNative(m_ll / l); }
  298.     wxLongLongNative& operator/=(const wxLongLongNative& ll)
  299.         { m_ll /= ll.m_ll; return *this; }
  300.     wxLongLongNative& operator/=(long l)
  301.         { m_ll /= l; return *this; }
  302.  
  303.     wxLongLongNative operator%(const wxLongLongNative& ll) const
  304.         { return wxLongLongNative(m_ll % ll.m_ll); }
  305.     wxLongLongNative operator%(long l) const
  306.         { return wxLongLongNative(m_ll % l); }
  307.  
  308.     // comparison
  309.     bool operator==(const wxLongLongNative& ll) const
  310.         { return m_ll == ll.m_ll; }
  311.     bool operator==(long l) const
  312.         { return m_ll == l; }
  313.     bool operator!=(const wxLongLongNative& ll) const
  314.         { return m_ll != ll.m_ll; }
  315.     bool operator!=(long l) const
  316.         { return m_ll != l; }
  317.     bool operator<(const wxLongLongNative& ll) const
  318.         { return m_ll < ll.m_ll; }
  319.     bool operator<(long l) const
  320.         { return m_ll < l; }
  321.     bool operator>(const wxLongLongNative& ll) const
  322.         { return m_ll > ll.m_ll; }
  323.     bool operator>(long l) const
  324.         { return m_ll > l; }
  325.     bool operator<=(const wxLongLongNative& ll) const
  326.         { return m_ll <= ll.m_ll; }
  327.     bool operator<=(long l) const
  328.         { return m_ll <= l; }
  329.     bool operator>=(const wxLongLongNative& ll) const
  330.         { return m_ll >= ll.m_ll; }
  331.     bool operator>=(long l) const
  332.         { return m_ll >= l; }
  333.  
  334.     // miscellaneous
  335.  
  336.         // return the string representation of this number
  337.     wxString ToString() const;
  338.  
  339.         // conversion to byte array: returns a pointer to static buffer!
  340.     void *asArray() const;
  341.  
  342. #if wxUSE_STD_IOSTREAM
  343.         // input/output
  344.     friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);
  345. #endif
  346.  
  347. private:
  348.     wxLongLong_t  m_ll;
  349. };
  350.  
  351.  
  352. class WXDLLEXPORT wxULongLongNative
  353. {
  354. public:
  355.     // ctors
  356.         // default ctor initializes to 0
  357.     wxULongLongNative() : m_ll(0) { }
  358.         // from long long
  359.     wxULongLongNative(unsigned wxLongLong_t ll) : m_ll(ll) { }
  360.         // from 2 longs
  361.     wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)
  362.     {
  363.         // assign first to avoid precision loss!
  364.         m_ll = ((unsigned wxLongLong_t) hi) << 32;
  365.         m_ll |= (unsigned wxLongLong_t) lo;
  366.     }
  367.  
  368.     // default copy ctor is ok
  369.  
  370.     // no dtor
  371.  
  372.     // assignment operators
  373.         // from native 64 bit integer
  374.     wxULongLongNative& operator=(unsigned wxLongLong_t ll)
  375.         { m_ll = ll; return *this; }
  376.  
  377.     // assignment operators from wxULongLongNative is ok
  378.  
  379.     // accessors
  380.         // get high part
  381.     unsigned long GetHi() const
  382.         { return (unsigned long)(m_ll >> 32); }
  383.         // get low part
  384.     unsigned long GetLo() const
  385.         { return (unsigned long)m_ll; }
  386.  
  387.         // convert to native ulong long
  388.     unsigned wxLongLong_t GetValue() const { return m_ll; }
  389.  
  390.         // convert to ulong with range checking in the debug mode (only!)
  391.     unsigned long ToULong() const
  392.     {
  393.         wxASSERT_MSG( m_ll <= LONG_MAX,
  394.                       _T("wxULongLong to long conversion loss of precision") );
  395.  
  396.         return (unsigned long)m_ll;
  397.     }
  398.  
  399.     // operations
  400.         // addition
  401.     wxULongLongNative operator+(const wxULongLongNative& ll) const
  402.         { return wxULongLongNative(m_ll + ll.m_ll); }
  403.     wxULongLongNative& operator+=(const wxULongLongNative& ll)
  404.         { m_ll += ll.m_ll; return *this; }
  405.  
  406.     wxULongLongNative operator+(const unsigned wxLongLong_t ll) const
  407.         { return wxULongLongNative(m_ll + ll); }
  408.     wxULongLongNative& operator+=(const unsigned wxLongLong_t ll)
  409.         { m_ll += ll; return *this; }
  410.  
  411.         // pre increment
  412.     wxULongLongNative& operator++()
  413.         { m_ll++; return *this; }
  414.  
  415.         // post increment
  416.     wxULongLongNative operator++(int)
  417.         { wxULongLongNative value(*this); m_ll++; return value; }
  418.  
  419.         // subtraction
  420.     wxULongLongNative operator-(const wxULongLongNative& ll) const
  421.         { return wxULongLongNative(m_ll - ll.m_ll); }
  422.     wxULongLongNative& operator-=(const wxULongLongNative& ll)
  423.         { m_ll -= ll.m_ll; return *this; }
  424.  
  425.     wxULongLongNative operator-(const unsigned wxLongLong_t ll) const
  426.         { return wxULongLongNative(m_ll - ll); }
  427.     wxULongLongNative& operator-=(const unsigned wxLongLong_t ll)
  428.         { m_ll -= ll; return *this; }
  429.  
  430.         // pre decrement
  431.     wxULongLongNative& operator--()
  432.         { m_ll--; return *this; }
  433.  
  434.         // post decrement
  435.     wxULongLongNative operator--(int)
  436.         { wxULongLongNative value(*this); m_ll--; return value; }
  437.  
  438.     // shifts
  439.         // left shift
  440.     wxULongLongNative operator<<(int shift) const
  441.         { return wxULongLongNative(m_ll << shift);; }
  442.     wxULongLongNative& operator<<=(int shift)
  443.         { m_ll <<= shift; return *this; }
  444.  
  445.         // right shift
  446.     wxULongLongNative operator>>(int shift) const
  447.         { return wxULongLongNative(m_ll >> shift);; }
  448.     wxULongLongNative& operator>>=(int shift)
  449.         { m_ll >>= shift; return *this; }
  450.  
  451.     // bitwise operators
  452.     wxULongLongNative operator&(const wxULongLongNative& ll) const
  453.         { return wxULongLongNative(m_ll & ll.m_ll); }
  454.     wxULongLongNative& operator&=(const wxULongLongNative& ll)
  455.         { m_ll &= ll.m_ll; return *this; }
  456.  
  457.     wxULongLongNative operator|(const wxULongLongNative& ll) const
  458.         { return wxULongLongNative(m_ll | ll.m_ll); }
  459.     wxULongLongNative& operator|=(const wxULongLongNative& ll)
  460.         { m_ll |= ll.m_ll; return *this; }
  461.  
  462.     wxULongLongNative operator^(const wxULongLongNative& ll) const
  463.         { return wxULongLongNative(m_ll ^ ll.m_ll); }
  464.     wxULongLongNative& operator^=(const wxULongLongNative& ll)
  465.         { m_ll ^= ll.m_ll; return *this; }
  466.  
  467.     // multiplication/division
  468.     wxULongLongNative operator*(const wxULongLongNative& ll) const
  469.         { return wxULongLongNative(m_ll * ll.m_ll); }
  470.     wxULongLongNative operator*(unsigned long l) const
  471.         { return wxULongLongNative(m_ll * l); }
  472.     wxULongLongNative& operator*=(const wxULongLongNative& ll)
  473.         { m_ll *= ll.m_ll; return *this; }
  474.     wxULongLongNative& operator*=(unsigned long l)
  475.         { m_ll *= l; return *this; }
  476.  
  477.     wxULongLongNative operator/(const wxULongLongNative& ll) const
  478.         { return wxULongLongNative(m_ll / ll.m_ll); }
  479.     wxULongLongNative operator/(unsigned long l) const
  480.         { return wxULongLongNative(m_ll / l); }
  481.     wxULongLongNative& operator/=(const wxULongLongNative& ll)
  482.         { m_ll /= ll.m_ll; return *this; }
  483.     wxULongLongNative& operator/=(unsigned long l)
  484.         { m_ll /= l; return *this; }
  485.  
  486.     wxULongLongNative operator%(const wxULongLongNative& ll) const
  487.         { return wxULongLongNative(m_ll % ll.m_ll); }
  488.     wxULongLongNative operator%(unsigned long l) const
  489.         { return wxULongLongNative(m_ll % l); }
  490.  
  491.     // comparison
  492.     bool operator==(const wxULongLongNative& ll) const
  493.         { return m_ll == ll.m_ll; }
  494.     bool operator==(unsigned long l) const
  495.         { return m_ll == l; }
  496.     bool operator!=(const wxULongLongNative& ll) const
  497.         { return m_ll != ll.m_ll; }
  498.     bool operator!=(unsigned long l) const
  499.         { return m_ll != l; }
  500.     bool operator<(const wxULongLongNative& ll) const
  501.         { return m_ll < ll.m_ll; }
  502.     bool operator<(unsigned long l) const
  503.         { return m_ll < l; }
  504.     bool operator>(const wxULongLongNative& ll) const
  505.         { return m_ll > ll.m_ll; }
  506.     bool operator>(unsigned long l) const
  507.         { return m_ll > l; }
  508.     bool operator<=(const wxULongLongNative& ll) const
  509.         { return m_ll <= ll.m_ll; }
  510.     bool operator<=(unsigned long l) const
  511.         { return m_ll <= l; }
  512.     bool operator>=(const wxULongLongNative& ll) const
  513.         { return m_ll >= ll.m_ll; }
  514.     bool operator>=(unsigned long l) const
  515.         { return m_ll >= l; }
  516.  
  517.     // miscellaneous
  518.  
  519.         // return the string representation of this number
  520.     wxString ToString() const;
  521.  
  522.         // conversion to byte array: returns a pointer to static buffer!
  523.     void *asArray() const;
  524.  
  525. #if wxUSE_STD_IOSTREAM
  526.         // input/output
  527.     friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);
  528. #endif
  529.  
  530. private:
  531.     unsigned wxLongLong_t  m_ll;
  532. };
  533.  
  534. #endif // wxUSE_LONGLONG_NATIVE
  535.  
  536. #if wxUSE_LONGLONG_WX
  537.  
  538. class WXDLLEXPORT wxLongLongWx
  539. {
  540. public:
  541.     // ctors
  542.         // default ctor initializes to 0
  543.     wxLongLongWx()
  544.     {
  545.         m_lo = m_hi = 0;
  546.  
  547. #ifdef wxLONGLONG_TEST_MODE
  548.         m_ll = 0;
  549.  
  550.         Check();
  551. #endif // wxLONGLONG_TEST_MODE
  552.     }
  553.         // from long
  554.     wxLongLongWx(long l) { *this = l; }
  555.         // from 2 longs
  556.     wxLongLongWx(long hi, unsigned long lo)
  557.     {
  558.         m_hi = hi;
  559.         m_lo = lo;
  560.  
  561. #ifdef wxLONGLONG_TEST_MODE
  562.         m_ll = hi;
  563.         m_ll <<= 32;
  564.         m_ll |= lo;
  565.  
  566.         Check();
  567. #endif // wxLONGLONG_TEST_MODE
  568.     }
  569.  
  570.     // default copy ctor is ok in both cases
  571.  
  572.     // no dtor
  573.  
  574.     // assignment operators
  575.         // from long
  576.     wxLongLongWx& operator=(long l)
  577.     {
  578.         m_lo = l;
  579.         m_hi = (l < 0 ? -1l : 0l);
  580.  
  581. #ifdef wxLONGLONG_TEST_MODE
  582.         m_ll = l;
  583.  
  584.         Check();
  585. #endif // wxLONGLONG_TEST_MODE
  586.  
  587.         return *this;
  588.     }
  589.         // from double
  590.     wxLongLongWx& Assign(double d);
  591.         // can't have assignment operator from 2 longs
  592.  
  593.     // accessors
  594.         // get high part
  595.     long GetHi() const { return m_hi; }
  596.         // get low part
  597.     unsigned long GetLo() const { return m_lo; }
  598.  
  599.         // get absolute value
  600.     wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
  601.     wxLongLongWx& Abs()
  602.     {
  603.         if ( m_hi < 0 )
  604.             m_hi = -m_hi;
  605.  
  606. #ifdef wxLONGLONG_TEST_MODE
  607.         if ( m_ll < 0 )
  608.             m_ll = -m_ll;
  609.  
  610.         Check();
  611. #endif // wxLONGLONG_TEST_MODE
  612.  
  613.         return *this;
  614.     }
  615.  
  616.         // convert to long with range checking in the debug mode (only!)
  617.     long ToLong() const
  618.     {
  619.         wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l),
  620.                       _T("wxLongLong to long conversion loss of precision") );
  621.  
  622.         return (long)m_lo;
  623.     }
  624.  
  625.     // operations
  626.         // addition
  627.     wxLongLongWx operator+(const wxLongLongWx& ll) const;
  628.     wxLongLongWx& operator+=(const wxLongLongWx& ll);
  629.     wxLongLongWx operator+(long l) const;
  630.     wxLongLongWx& operator+=(long l);
  631.  
  632.         // pre increment operator
  633.     wxLongLongWx& operator++();
  634.  
  635.         // post increment operator
  636.     wxLongLongWx& operator++(int) { return ++(*this); }
  637.  
  638.         // negation operator
  639.     wxLongLongWx operator-() const;
  640.     wxLongLongWx& Negate();
  641.  
  642.         // subraction
  643.     wxLongLongWx operator-(const wxLongLongWx& ll) const;
  644.     wxLongLongWx& operator-=(const wxLongLongWx& ll);
  645.  
  646.         // pre decrement operator
  647.     wxLongLongWx& operator--();
  648.  
  649.         // post decrement operator
  650.     wxLongLongWx& operator--(int) { return --(*this); }
  651.  
  652.     // shifts
  653.         // left shift
  654.     wxLongLongWx operator<<(int shift) const;
  655.     wxLongLongWx& operator<<=(int shift);
  656.  
  657.         // right shift
  658.     wxLongLongWx operator>>(int shift) const;
  659.     wxLongLongWx& operator>>=(int shift);
  660.  
  661.     // bitwise operators
  662.     wxLongLongWx operator&(const wxLongLongWx& ll) const;
  663.     wxLongLongWx& operator&=(const wxLongLongWx& ll);
  664.     wxLongLongWx operator|(const wxLongLongWx& ll) const;
  665.     wxLongLongWx& operator|=(const wxLongLongWx& ll);
  666.     wxLongLongWx operator^(const wxLongLongWx& ll) const;
  667.     wxLongLongWx& operator^=(const wxLongLongWx& ll);
  668.     wxLongLongWx operator~() const;
  669.  
  670.     // comparison
  671.     bool operator==(const wxLongLongWx& ll) const
  672.         { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
  673.     bool operator!=(const wxLongLongWx& ll) const
  674.         { return !(*this == ll); }
  675.     bool operator<(const wxLongLongWx& ll) const;
  676.     bool operator>(const wxLongLongWx& ll) const;
  677.     bool operator<=(const wxLongLongWx& ll) const
  678.         { return *this < ll || *this == ll; }
  679.     bool operator>=(const wxLongLongWx& ll) const
  680.         { return *this > ll || *this == ll; }
  681.  
  682.     bool operator<(long l) const { return *this < wxLongLongWx(l); }
  683.     bool operator>(long l) const { return *this > wxLongLongWx(l); }
  684.     bool operator==(long l) const
  685.     {
  686.         return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l)
  687.                       : (m_hi == -1 && m_lo == (unsigned long)l);
  688.     }
  689.  
  690.     bool operator<=(long l) const { return *this < l || *this == l; }
  691.     bool operator>=(long l) const { return *this > l || *this == l; }
  692.  
  693.     // multiplication
  694.     wxLongLongWx operator*(const wxLongLongWx& ll) const;
  695.     wxLongLongWx& operator*=(const wxLongLongWx& ll);
  696.  
  697.     // division
  698.     wxLongLongWx operator/(const wxLongLongWx& ll) const;
  699.     wxLongLongWx& operator/=(const wxLongLongWx& ll);
  700.  
  701.     wxLongLongWx operator%(const wxLongLongWx& ll) const;
  702.  
  703.     void Divide(const wxLongLongWx& divisor,
  704.                 wxLongLongWx& quotient,
  705.                 wxLongLongWx& remainder) const;
  706.  
  707.     // input/output
  708.  
  709.     // return the string representation of this number
  710.     wxString ToString() const;
  711.  
  712.     void *asArray() const;
  713.  
  714. #if wxUSE_STD_IOSTREAM
  715.     friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);
  716. #endif // wxUSE_STD_IOSTREAM
  717.  
  718. private:
  719.     // long is at least 32 bits, so represent our 64bit number as 2 longs
  720.  
  721.     long m_hi;                // signed bit is in the high part
  722.     unsigned long m_lo;
  723.  
  724. #ifdef wxLONGLONG_TEST_MODE
  725.     void Check()
  726.     {
  727.         wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
  728.     }
  729.  
  730.     wxLongLong_t m_ll;
  731. #endif // wxLONGLONG_TEST_MODE
  732. };
  733.  
  734.  
  735. class WXDLLEXPORT wxULongLongWx
  736. {
  737. public:
  738.     // ctors
  739.         // default ctor initializes to 0
  740.     wxULongLongWx()
  741.     {
  742.         m_lo = m_hi = 0;
  743.  
  744. #ifdef wxLONGLONG_TEST_MODE
  745.         m_ll = 0;
  746.  
  747.         Check();
  748. #endif // wxLONGLONG_TEST_MODE
  749.     }
  750.         // from ulong
  751.     wxULongLongWx(unsigned long l) { *this = l; }
  752.         // from 2 ulongs
  753.     wxULongLongWx(unsigned long hi, unsigned long lo)
  754.     {
  755.         m_hi = hi;
  756.         m_lo = lo;
  757.  
  758. #ifdef wxLONGLONG_TEST_MODE
  759.         m_ll = hi;
  760.         m_ll <<= 32;
  761.         m_ll |= lo;
  762.  
  763.         Check();
  764. #endif // wxLONGLONG_TEST_MODE
  765.     }
  766.  
  767.     // default copy ctor is ok in both cases
  768.  
  769.     // no dtor
  770.  
  771.     // assignment operators
  772.         // from long
  773.     wxULongLongWx& operator=(unsigned long l)
  774.     {
  775.         m_lo = l;
  776.         m_hi = 0;
  777.  
  778. #ifdef wxLONGLONG_TEST_MODE
  779.         m_ll = l;
  780.  
  781.         Check();
  782. #endif // wxLONGLONG_TEST_MODE
  783.  
  784.         return *this;
  785.     }
  786.  
  787.     // can't have assignment operator from 2 longs
  788.  
  789.     // accessors
  790.         // get high part
  791.     unsigned long GetHi() const { return m_hi; }
  792.         // get low part
  793.     unsigned long GetLo() const { return m_lo; }
  794.  
  795.         // convert to long with range checking in the debug mode (only!)
  796.     unsigned long ToULong() const
  797.     {
  798.         wxASSERT_MSG( m_hi == 0ul,
  799.                       _T("wxULongLong to long conversion loss of precision") );
  800.  
  801.         return (unsigned long)m_lo;
  802.     }
  803.  
  804.     // operations
  805.         // addition
  806.     wxULongLongWx operator+(const wxULongLongWx& ll) const;
  807.     wxULongLongWx& operator+=(const wxULongLongWx& ll);
  808.     wxULongLongWx operator+(unsigned long l) const;
  809.     wxULongLongWx& operator+=(unsigned long l);
  810.  
  811.         // pre increment operator
  812.     wxULongLongWx& operator++();
  813.  
  814.         // post increment operator
  815.     wxULongLongWx& operator++(int) { return ++(*this); }
  816.  
  817.         // subraction (FIXME: should return wxLongLong)
  818.     wxULongLongWx operator-(const wxULongLongWx& ll) const;
  819.     wxULongLongWx& operator-=(const wxULongLongWx& ll);
  820.  
  821.         // pre decrement operator
  822.     wxULongLongWx& operator--();
  823.  
  824.         // post decrement operator
  825.     wxULongLongWx& operator--(int) { return --(*this); }
  826.  
  827.     // shifts
  828.         // left shift
  829.     wxULongLongWx operator<<(int shift) const;
  830.     wxULongLongWx& operator<<=(int shift);
  831.  
  832.         // right shift
  833.     wxULongLongWx operator>>(int shift) const;
  834.     wxULongLongWx& operator>>=(int shift);
  835.  
  836.     // bitwise operators
  837.     wxULongLongWx operator&(const wxULongLongWx& ll) const;
  838.     wxULongLongWx& operator&=(const wxULongLongWx& ll);
  839.     wxULongLongWx operator|(const wxULongLongWx& ll) const;
  840.     wxULongLongWx& operator|=(const wxULongLongWx& ll);
  841.     wxULongLongWx operator^(const wxULongLongWx& ll) const;
  842.     wxULongLongWx& operator^=(const wxULongLongWx& ll);
  843.     wxULongLongWx operator~() const;
  844.  
  845.     // comparison
  846.     bool operator==(const wxULongLongWx& ll) const
  847.         { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
  848.     bool operator!=(const wxULongLongWx& ll) const
  849.         { return !(*this == ll); }
  850.     bool operator<(const wxULongLongWx& ll) const;
  851.     bool operator>(const wxULongLongWx& ll) const;
  852.     bool operator<=(const wxULongLongWx& ll) const
  853.         { return *this < ll || *this == ll; }
  854.     bool operator>=(const wxULongLongWx& ll) const
  855.         { return *this > ll || *this == ll; }
  856.  
  857.     bool operator<(unsigned long l) const { return *this < wxULongLongWx(l); }
  858.     bool operator>(unsigned long l) const { return *this > wxULongLongWx(l); }
  859.     bool operator==(unsigned long l) const
  860.     {
  861.         return (m_hi == 0 && m_lo == (unsigned long)l);
  862.     }
  863.  
  864.     bool operator<=(unsigned long l) const { return *this < l || *this == l; }
  865.     bool operator>=(unsigned long l) const { return *this > l || *this == l; }
  866.  
  867.     // multiplication
  868.     wxULongLongWx operator*(const wxULongLongWx& ll) const;
  869.     wxULongLongWx& operator*=(const wxULongLongWx& ll);
  870.  
  871.     // division
  872.     wxULongLongWx operator/(const wxULongLongWx& ll) const;
  873.     wxULongLongWx& operator/=(const wxULongLongWx& ll);
  874.  
  875.     wxULongLongWx operator%(const wxULongLongWx& ll) const;
  876.  
  877.     void Divide(const wxULongLongWx& divisor,
  878.                 wxULongLongWx& quotient,
  879.                 wxULongLongWx& remainder) const;
  880.  
  881.     // input/output
  882.  
  883.     // return the string representation of this number
  884.     wxString ToString() const;
  885.  
  886.     void *asArray() const;
  887.  
  888. #if wxUSE_STD_IOSTREAM
  889.     friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);
  890. #endif // wxUSE_STD_IOSTREAM
  891.  
  892. private:
  893.     // long is at least 32 bits, so represent our 64bit number as 2 longs
  894.  
  895.     unsigned long m_hi;
  896.     unsigned long m_lo;
  897.  
  898. #ifdef wxLONGLONG_TEST_MODE
  899.     void Check()
  900.     {
  901.         wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
  902.     }
  903.  
  904.     unsigned wxLongLong_t m_ll;
  905. #endif // wxLONGLONG_TEST_MODE
  906. };
  907.  
  908. #endif // wxUSE_LONGLONG_WX
  909.  
  910. // ----------------------------------------------------------------------------
  911. // binary operators
  912. // ----------------------------------------------------------------------------
  913.  
  914. inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }
  915. inline bool operator>(long l, const wxLongLong& ll) { return ll < l; }
  916. inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
  917. inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
  918. inline bool operator==(long l, const wxLongLong& ll) { return ll == l; }
  919. inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; }
  920.  
  921. inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; }
  922. inline wxLongLong operator-(long l, const wxLongLong& ll)
  923. {
  924.     return wxLongLong(l) - ll;
  925. }
  926.  
  927. inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
  928. inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
  929. inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
  930. inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
  931. inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
  932. inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }
  933.  
  934. inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
  935.  
  936. // FIXME: this should return wxLongLong
  937. inline wxULongLong operator-(unsigned long l, const wxULongLong& ull)
  938. {
  939.     return wxULongLong(l) - ull;
  940. }
  941.  
  942. #endif // _WX_LONGLONG_H
  943.