include/wx/longlong.h

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