src/common/longlong.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/longlong.cpp
   3 // Purpose:     implementation of wxLongLongNative
   4 // Author:      Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
   5 // Remarks:     this class is not public in wxWidgets 2.0! It is intentionally
   6 //              not documented and is for private use only.
   7 // Modified by:
   8 // Created:     10.02.99
   9 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ============================================================================
  14 // headers
  15 // ============================================================================
  16
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20     #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_LONGLONG
  24
  25 #include "wx/longlong.h"
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/math.h"       // for fabs()
  29 #endif
  30
  31 #if wxUSE_STREAMS
  32     #include "wx/txtstrm.h"
  33 #endif
  34
  35 #include <string.h>            // for memset()
  36
  37 #include "wx/ioswrap.h"
  38
  39 // ============================================================================
  40 // implementation
  41 // ============================================================================
  42
  43 #if wxUSE_LONGLONG_NATIVE
  44
  45 // ----------------------------------------------------------------------------
  46 // misc
  47 // ----------------------------------------------------------------------------
  48
  49 void *wxLongLongNative::asArray() const
  50 {
  51     static unsigned char temp[8];
  52
  53     temp[0] = wx_truncate_cast(unsigned char, ((m_ll >> 56) & 0xFF));
  54     temp[1] = wx_truncate_cast(unsigned char, ((m_ll >> 48) & 0xFF));
  55     temp[2] = wx_truncate_cast(unsigned char, ((m_ll >> 40) & 0xFF));
  56     temp[3] = wx_truncate_cast(unsigned char, ((m_ll >> 32) & 0xFF));
  57     temp[4] = wx_truncate_cast(unsigned char, ((m_ll >> 24) & 0xFF));
  58     temp[5] = wx_truncate_cast(unsigned char, ((m_ll >> 16) & 0xFF));
  59     temp[6] = wx_truncate_cast(unsigned char, ((m_ll >> 8)  & 0xFF));
  60     temp[7] = wx_truncate_cast(unsigned char, ((m_ll >> 0)  & 0xFF));
  61
  62     return temp;
  63 }
  64
  65 void *wxULongLongNative::asArray() const
  66 {
  67     static unsigned char temp[8];
  68
  69     temp[0] = wx_truncate_cast(unsigned char, ((m_ll >> 56) & 0xFF));
  70     temp[1] = wx_truncate_cast(unsigned char, ((m_ll >> 48) & 0xFF));
  71     temp[2] = wx_truncate_cast(unsigned char, ((m_ll >> 40) & 0xFF));
  72     temp[3] = wx_truncate_cast(unsigned char, ((m_ll >> 32) & 0xFF));
  73     temp[4] = wx_truncate_cast(unsigned char, ((m_ll >> 24) & 0xFF));
  74     temp[5] = wx_truncate_cast(unsigned char, ((m_ll >> 16) & 0xFF));
  75     temp[6] = wx_truncate_cast(unsigned char, ((m_ll >> 8)  & 0xFF));
  76     temp[7] = wx_truncate_cast(unsigned char, ((m_ll >> 0)  & 0xFF));
  77
  78     return temp;
  79 }
  80
  81 #if wxUSE_LONGLONG_WX
  82 wxLongLongNative::wxLongLongNative(wxLongLongWx ll)
  83 {
  84     // assign first to avoid precision loss!
  85     m_ll = ll.GetHi();
  86     m_ll <<= 32;
  87     m_ll |= ll.GetLo();
  88 }
  89
  90 wxLongLongNative& wxLongLongNative::operator=(wxLongLongWx ll)
  91 {
  92     // assign first to avoid precision loss!
  93     m_ll = ll.GetHi();
  94     m_ll <<= 32;
  95     m_ll |= ll.GetLo();
  96     return *this;
  97 }
  98
  99 wxLongLongNative& wxLongLongNative::operator=(const class wxULongLongWx &ll)
 100 {
 101     // assign first to avoid precision loss!
 102     m_ll = ll.GetHi();
 103     m_ll <<= 32;
 104     m_ll |= ll.GetLo();
 105     return *this;
 106 }
 107
 108 wxULongLongNative::wxULongLongNative(const class wxULongLongWx &ll)
 109 {
 110     // assign first to avoid precision loss!
 111     m_ll = ll.GetHi();
 112     m_ll <<= 32;
 113     m_ll |= ((unsigned long) ll.GetLo());
 114 }
 115
 116 wxULongLongNative& wxULongLongNative::operator=(wxLongLongWx ll)
 117 {
 118     // assign first to avoid precision loss!
 119     m_ll = ll.GetHi();
 120     m_ll <<= 32;
 121     m_ll |= ((unsigned long) ll.GetLo());
 122     return *this;
 123 }
 124
 125 wxULongLongNative& wxULongLongNative::operator=(const class wxULongLongWx &ll)
 126 {
 127     // assign first to avoid precision loss!
 128     m_ll = ll.GetHi();
 129     m_ll <<= 32;
 130     m_ll |= ((unsigned long) ll.GetLo());
 131     return *this;
 132 }
 133 #endif
 134
 135 #ifdef __VISUALC6__
 136 double wxULongLongNative::ToDouble() const
 137 {
 138     // Work around the problem of casting unsigned __int64 to double in VC6
 139     // (which for unknown reasons only manifests itself in DLL builds, i.e.
 140     // when using /MD).
 141     static const __int64 int64_t_max = 9223372036854775807i64;
 142     if ( m_ll <= int64_t_max )
 143         return wx_truncate_cast(double, (wxLongLong_t)m_ll);
 144
 145     double d = wx_truncate_cast(double, int64_t_max);
 146     d += (__int64)(m_ll - int64_t_max - 1); // The cast is safe because of -1
 147     return d + 1;
 148 }
 149 #endif // __VISUALC6__
 150
 151 #endif // wxUSE_LONGLONG_NATIVE
 152
 153 // ============================================================================
 154 // wxLongLongWx: emulation of 'long long' using 2 longs
 155 // ============================================================================
 156
 157 #if wxUSE_LONGLONG_WX
 158
 159 // Set value from unsigned wxULongLongWx
 160 wxLongLongWx &wxLongLongWx::operator=(const class wxULongLongWx &ll)
 161 {
 162     m_hi = (unsigned long) ll.GetHi();
 163     m_lo = ll.GetLo();
 164     return *this;
 165 }
 166
 167 // assignment
 168 wxLongLongWx& wxLongLongWx::Assign(double d)
 169 {
 170     bool positive = d >= 0;
 171     d = fabs(d);
 172     if ( d <= ULONG_MAX )
 173     {
 174         m_hi = 0;
 175         m_lo = (long)d;
 176     }
 177     else
 178     {
 179         m_hi = (unsigned long)(d / (1.0 + (double)ULONG_MAX));
 180         m_lo = (unsigned long)(d - ((double)m_hi * (1.0 + (double)ULONG_MAX)));
 181     }
 182
 183 #ifdef wxLONGLONG_TEST_MODE
 184     m_ll = (wxLongLong_t)d;
 185
 186     Check();
 187 #endif // wxLONGLONG_TEST_MODE
 188
 189     if ( !positive )
 190         Negate();
 191
 192     return *this;
 193 }
 194
 195 double wxLongLongWx::ToDouble() const
 196 {
 197     double d = m_hi;
 198     d *= 1.0 + (double)ULONG_MAX;
 199     d += m_lo;
 200
 201 #ifdef wxLONGLONG_TEST_MODE
 202     wxASSERT( d == m_ll );
 203 #endif // wxLONGLONG_TEST_MODE
 204
 205     return d;
 206 }
 207
 208 double wxULongLongWx::ToDouble() const
 209 {
 210     unsigned double d = m_hi;
 211     d *= 1.0 + (double)ULONG_MAX;
 212     d += m_lo;
 213
 214 #ifdef wxLONGLONG_TEST_MODE
 215     wxASSERT( d == m_ll );
 216 #endif // wxLONGLONG_TEST_MODE
 217
 218     return d;
 219 }
 220
 221 wxLongLongWx wxLongLongWx::operator<<(int shift) const
 222 {
 223     wxLongLongWx ll(*this);
 224     ll <<= shift;
 225
 226     return ll;
 227 }
 228
 229 wxULongLongWx wxULongLongWx::operator<<(int shift) const
 230 {
 231     wxULongLongWx ll(*this);
 232     ll <<= shift;
 233
 234     return ll;
 235 }
 236
 237 wxLongLongWx& wxLongLongWx::operator<<=(int shift)
 238 {
 239     if (shift != 0)
 240     {
 241         if (shift < 32)
 242         {
 243             m_hi <<= shift;
 244             m_hi |= m_lo >> (32 - shift);
 245             m_lo <<= shift;
 246         }
 247         else
 248         {
 249             m_hi = m_lo << (shift - 32);
 250             m_lo = 0;
 251         }
 252     }
 253
 254 #ifdef wxLONGLONG_TEST_MODE
 255     m_ll <<= shift;
 256
 257     Check();
 258 #endif // wxLONGLONG_TEST_MODE
 259
 260     return *this;
 261 }
 262
 263 wxULongLongWx& wxULongLongWx::operator<<=(int shift)
 264 {
 265     if (shift != 0)
 266     {
 267         if (shift < 32)
 268         {
 269             m_hi <<= shift;
 270             m_hi |= m_lo >> (32 - shift);
 271             m_lo <<= shift;
 272         }
 273         else
 274         {
 275             m_hi = m_lo << (shift - 32);
 276             m_lo = 0;
 277         }
 278     }
 279
 280 #ifdef wxLONGLONG_TEST_MODE
 281     m_ll <<= shift;
 282
 283     Check();
 284 #endif // wxLONGLONG_TEST_MODE
 285
 286     return *this;
 287 }
 288
 289 wxLongLongWx wxLongLongWx::operator>>(int shift) const
 290 {
 291     wxLongLongWx ll(*this);
 292     ll >>= shift;
 293
 294     return ll;
 295 }
 296
 297 wxULongLongWx wxULongLongWx::operator>>(int shift) const
 298 {
 299     wxULongLongWx ll(*this);
 300     ll >>= shift;
 301
 302     return ll;
 303 }
 304
 305 wxLongLongWx& wxLongLongWx::operator>>=(int shift)
 306 {
 307     if (shift != 0)
 308     {
 309         if (shift < 32)
 310         {
 311             m_lo >>= shift;
 312             m_lo |= m_hi << (32 - shift);
 313             m_hi >>= shift;
 314         }
 315         else
 316         {
 317             m_lo = m_hi >> (shift - 32);
 318             m_hi = (m_hi < 0 ? -1L : 0);
 319         }
 320     }
 321
 322 #ifdef wxLONGLONG_TEST_MODE
 323     m_ll >>= shift;
 324
 325     Check();
 326 #endif // wxLONGLONG_TEST_MODE
 327
 328     return *this;
 329 }
 330
 331 wxULongLongWx& wxULongLongWx::operator>>=(int shift)
 332 {
 333     if (shift != 0)
 334     {
 335         if (shift < 32)
 336         {
 337             m_lo >>= shift;
 338             m_lo |= m_hi << (32 - shift);
 339             m_hi >>= shift;
 340         }
 341         else
 342         {
 343             m_lo = m_hi >> (shift - 32);
 344             m_hi = 0;
 345         }
 346     }
 347
 348 #ifdef wxLONGLONG_TEST_MODE
 349     m_ll >>= shift;
 350
 351     Check();
 352 #endif // wxLONGLONG_TEST_MODE
 353
 354     return *this;
 355 }
 356
 357 wxLongLongWx wxLongLongWx::operator+(const wxLongLongWx& ll) const
 358 {
 359     wxLongLongWx res(*this);
 360     res += ll;
 361
 362     return res;
 363 }
 364
 365 wxULongLongWx wxULongLongWx::operator+(const wxULongLongWx& ll) const
 366 {
 367     wxULongLongWx res(*this);
 368     res += ll;
 369
 370     return res;
 371 }
 372
 373 wxLongLongWx wxLongLongWx::operator+(long l) const
 374 {
 375     wxLongLongWx res(*this);
 376     res += l;
 377
 378     return res;
 379 }
 380
 381 wxULongLongWx wxULongLongWx::operator+(unsigned long l) const
 382 {
 383     wxULongLongWx res(*this);
 384     res += l;
 385
 386     return res;
 387 }
 388
 389 wxLongLongWx& wxLongLongWx::operator+=(const wxLongLongWx& ll)
 390 {
 391     unsigned long previous = m_lo;
 392
 393     m_lo += ll.m_lo;
 394     m_hi += ll.m_hi;
 395
 396     if ((m_lo < previous) || (m_lo < ll.m_lo))
 397         m_hi++;
 398
 399 #ifdef wxLONGLONG_TEST_MODE
 400     m_ll += ll.m_ll;
 401
 402     Check();
 403 #endif // wxLONGLONG_TEST_MODE
 404
 405     return *this;
 406 }
 407
 408 wxULongLongWx& wxULongLongWx::operator+=(const wxULongLongWx& ll)
 409 {
 410     unsigned long previous = m_lo;
 411
 412     m_lo += ll.m_lo;
 413     m_hi += ll.m_hi;
 414
 415     if ((m_lo < previous) || (m_lo < ll.m_lo))
 416         m_hi++;
 417
 418 #ifdef wxLONGLONG_TEST_MODE
 419     m_ll += ll.m_ll;
 420
 421     Check();
 422 #endif // wxLONGLONG_TEST_MODE
 423
 424     return *this;
 425 }
 426
 427 wxLongLongWx& wxLongLongWx::operator+=(long l)
 428 {
 429     unsigned long previous = m_lo;
 430
 431     m_lo += l;
 432     if (l < 0)
 433         m_hi += -1l;
 434
 435     if ((m_lo < previous) || (m_lo < (unsigned long)l))
 436         m_hi++;
 437
 438 #ifdef wxLONGLONG_TEST_MODE
 439     m_ll += l;
 440
 441     Check();
 442 #endif // wxLONGLONG_TEST_MODE
 443
 444     return *this;
 445 }
 446
 447 wxULongLongWx& wxULongLongWx::operator+=(unsigned long l)
 448 {
 449     unsigned long previous = m_lo;
 450
 451     m_lo += l;
 452
 453     if ((m_lo < previous) || (m_lo < l))
 454         m_hi++;
 455
 456 #ifdef wxLONGLONG_TEST_MODE
 457     m_ll += l;
 458
 459     Check();
 460 #endif // wxLONGLONG_TEST_MODE
 461
 462     return *this;
 463 }
 464
 465 // pre increment
 466 wxLongLongWx& wxLongLongWx::operator++()
 467 {
 468     m_lo++;
 469     if (m_lo == 0)
 470         m_hi++;
 471
 472 #ifdef wxLONGLONG_TEST_MODE
 473     m_ll++;
 474
 475     Check();
 476 #endif // wxLONGLONG_TEST_MODE
 477
 478     return *this;
 479 }
 480
 481 wxULongLongWx& wxULongLongWx::operator++()
 482 {
 483     m_lo++;
 484     if (m_lo == 0)
 485         m_hi++;
 486
 487 #ifdef wxLONGLONG_TEST_MODE
 488     m_ll++;
 489
 490     Check();
 491 #endif // wxLONGLONG_TEST_MODE
 492
 493     return *this;
 494 }
 495
 496 // negation
 497 wxLongLongWx wxLongLongWx::operator-() const
 498 {
 499     wxLongLongWx res(*this);
 500     res.Negate();
 501
 502     return res;
 503 }
 504
 505 wxLongLongWx& wxLongLongWx::Negate()
 506 {
 507     m_hi = ~m_hi;
 508     m_lo = ~m_lo;
 509
 510     m_lo++;
 511     if ( m_lo == 0 )
 512         m_hi++;
 513
 514 #ifdef wxLONGLONG_TEST_MODE
 515     m_ll = -m_ll;
 516
 517     Check();
 518 #endif // wxLONGLONG_TEST_MODE
 519
 520     return *this;
 521 }
 522
 523 // subtraction
 524
 525 wxLongLongWx wxLongLongWx::operator-(const wxLongLongWx& ll) const
 526 {
 527     wxLongLongWx res(*this);
 528     res -= ll;
 529
 530     return res;
 531 }
 532
 533 wxLongLongWx wxULongLongWx::operator-(const wxULongLongWx& ll) const
 534 {
 535     wxASSERT(m_hi <= LONG_MAX );
 536     wxASSERT(ll.m_hi <= LONG_MAX );
 537
 538     wxLongLongWx res( (long)m_hi , m_lo );
 539     wxLongLongWx op( (long)ll.m_hi , ll.m_lo );
 540     res -= op;
 541
 542     return res;
 543 }
 544
 545 wxLongLongWx& wxLongLongWx::operator-=(const wxLongLongWx& ll)
 546 {
 547     unsigned long previous = m_lo;
 548
 549     m_lo -= ll.m_lo;
 550     m_hi -= ll.m_hi;
 551
 552     if (previous < ll.m_lo)
 553         m_hi--;
 554
 555 #ifdef wxLONGLONG_TEST_MODE
 556     m_ll -= ll.m_ll;
 557
 558     Check();
 559 #endif // wxLONGLONG_TEST_MODE
 560
 561     return *this;
 562 }
 563
 564 wxULongLongWx& wxULongLongWx::operator-=(const wxULongLongWx& ll)
 565 {
 566     unsigned long previous = m_lo;
 567
 568     m_lo -= ll.m_lo;
 569     m_hi -= ll.m_hi;
 570
 571     if (previous < ll.m_lo)
 572         m_hi--;
 573
 574 #ifdef wxLONGLONG_TEST_MODE
 575     m_ll -= ll.m_ll;
 576
 577     Check();
 578 #endif // wxLONGLONG_TEST_MODE
 579
 580     return *this;
 581 }
 582
 583 // pre decrement
 584 wxLongLongWx& wxLongLongWx::operator--()
 585 {
 586     m_lo--;
 587     if (m_lo == 0xFFFFFFFF)
 588         m_hi--;
 589
 590 #ifdef wxLONGLONG_TEST_MODE
 591     m_ll--;
 592
 593     Check();
 594 #endif // wxLONGLONG_TEST_MODE
 595
 596     return *this;
 597 }
 598
 599 wxULongLongWx& wxULongLongWx::operator--()
 600 {
 601     m_lo--;
 602     if (m_lo == 0xFFFFFFFF)
 603         m_hi--;
 604
 605 #ifdef wxLONGLONG_TEST_MODE
 606     m_ll--;
 607
 608     Check();
 609 #endif // wxLONGLONG_TEST_MODE
 610
 611     return *this;
 612 }
 613
 614 // comparison operators
 615
 616 bool wxLongLongWx::operator<(const wxLongLongWx& ll) const
 617 {
 618     if ( m_hi < ll.m_hi )
 619         return true;
 620     else if ( m_hi == ll.m_hi )
 621         return m_lo < ll.m_lo;
 622     else
 623         return false;
 624 }
 625
 626 bool wxULongLongWx::operator<(const wxULongLongWx& ll) const
 627 {
 628     if ( m_hi < ll.m_hi )
 629         return true;
 630     else if ( m_hi == ll.m_hi )
 631         return m_lo < ll.m_lo;
 632     else
 633         return false;
 634 }
 635
 636 bool wxLongLongWx::operator>(const wxLongLongWx& ll) const
 637 {
 638     if ( m_hi > ll.m_hi )
 639         return true;
 640     else if ( m_hi == ll.m_hi )
 641         return m_lo > ll.m_lo;
 642     else
 643         return false;
 644 }
 645
 646 bool wxULongLongWx::operator>(const wxULongLongWx& ll) const
 647 {
 648     if ( m_hi > ll.m_hi )
 649         return true;
 650     else if ( m_hi == ll.m_hi )
 651         return m_lo > ll.m_lo;
 652     else
 653         return false;
 654 }
 655
 656 // bitwise operators
 657
 658 wxLongLongWx wxLongLongWx::operator&(const wxLongLongWx& ll) const
 659 {
 660     return wxLongLongWx(m_hi & ll.m_hi, m_lo & ll.m_lo);
 661 }
 662
 663 wxULongLongWx wxULongLongWx::operator&(const wxULongLongWx& ll) const
 664 {
 665     return wxULongLongWx(m_hi & ll.m_hi, m_lo & ll.m_lo);
 666 }
 667
 668 wxLongLongWx wxLongLongWx::operator|(const wxLongLongWx& ll) const
 669 {
 670     return wxLongLongWx(m_hi | ll.m_hi, m_lo | ll.m_lo);
 671 }
 672
 673 wxULongLongWx wxULongLongWx::operator|(const wxULongLongWx& ll) const
 674 {
 675     return wxULongLongWx(m_hi | ll.m_hi, m_lo | ll.m_lo);
 676 }
 677
 678 wxLongLongWx wxLongLongWx::operator^(const wxLongLongWx& ll) const
 679 {
 680     return wxLongLongWx(m_hi ^ ll.m_hi, m_lo ^ ll.m_lo);
 681 }
 682
 683 wxULongLongWx wxULongLongWx::operator^(const wxULongLongWx& ll) const
 684 {
 685     return wxULongLongWx(m_hi ^ ll.m_hi, m_lo ^ ll.m_lo);
 686 }
 687
 688 wxLongLongWx& wxLongLongWx::operator&=(const wxLongLongWx& ll)
 689 {
 690     m_lo &= ll.m_lo;
 691     m_hi &= ll.m_hi;
 692
 693 #ifdef wxLONGLONG_TEST_MODE
 694     m_ll &= ll.m_ll;
 695
 696     Check();
 697 #endif // wxLONGLONG_TEST_MODE
 698
 699     return *this;
 700 }
 701
 702 wxULongLongWx& wxULongLongWx::operator&=(const wxULongLongWx& ll)
 703 {
 704     m_lo &= ll.m_lo;
 705     m_hi &= ll.m_hi;
 706
 707 #ifdef wxLONGLONG_TEST_MODE
 708     m_ll &= ll.m_ll;
 709
 710     Check();
 711 #endif // wxLONGLONG_TEST_MODE
 712
 713     return *this;
 714 }
 715
 716 wxLongLongWx& wxLongLongWx::operator|=(const wxLongLongWx& ll)
 717 {
 718     m_lo |= ll.m_lo;
 719     m_hi |= ll.m_hi;
 720
 721 #ifdef wxLONGLONG_TEST_MODE
 722     m_ll |= ll.m_ll;
 723
 724     Check();
 725 #endif // wxLONGLONG_TEST_MODE
 726
 727     return *this;
 728 }
 729
 730 wxULongLongWx& wxULongLongWx::operator|=(const wxULongLongWx& ll)
 731 {
 732     m_lo |= ll.m_lo;
 733     m_hi |= ll.m_hi;
 734
 735 #ifdef wxLONGLONG_TEST_MODE
 736     m_ll |= ll.m_ll;
 737
 738     Check();
 739 #endif // wxLONGLONG_TEST_MODE
 740
 741     return *this;
 742 }
 743
 744 wxLongLongWx& wxLongLongWx::operator^=(const wxLongLongWx& ll)
 745 {
 746     m_lo ^= ll.m_lo;
 747     m_hi ^= ll.m_hi;
 748
 749 #ifdef wxLONGLONG_TEST_MODE
 750     m_ll ^= ll.m_ll;
 751
 752     Check();
 753 #endif // wxLONGLONG_TEST_MODE
 754
 755     return *this;
 756 }
 757
 758 wxULongLongWx& wxULongLongWx::operator^=(const wxULongLongWx& ll)
 759 {
 760     m_lo ^= ll.m_lo;
 761     m_hi ^= ll.m_hi;
 762
 763 #ifdef wxLONGLONG_TEST_MODE
 764     m_ll ^= ll.m_ll;
 765
 766     Check();
 767 #endif // wxLONGLONG_TEST_MODE
 768
 769     return *this;
 770 }
 771
 772 wxLongLongWx wxLongLongWx::operator~() const
 773 {
 774     return wxLongLongWx(~m_hi, ~m_lo);
 775 }
 776
 777 wxULongLongWx wxULongLongWx::operator~() const
 778 {
 779     return wxULongLongWx(~m_hi, ~m_lo);
 780 }
 781
 782 // multiplication
 783
 784 wxLongLongWx wxLongLongWx::operator*(const wxLongLongWx& ll) const
 785 {
 786     wxLongLongWx res(*this);
 787     res *= ll;
 788
 789     return res;
 790 }
 791
 792 wxULongLongWx wxULongLongWx::operator*(const wxULongLongWx& ll) const
 793 {
 794     wxULongLongWx res(*this);
 795     res *= ll;
 796
 797     return res;
 798 }
 799
 800 wxLongLongWx& wxLongLongWx::operator*=(const wxLongLongWx& ll)
 801 {
 802     wxLongLongWx t(m_hi, m_lo);
 803     wxLongLongWx q(ll.m_hi, ll.m_lo);
 804
 805     m_hi = m_lo = 0;
 806
 807 #ifdef wxLONGLONG_TEST_MODE
 808     wxLongLong_t llOld = m_ll;
 809     m_ll = 0;
 810 #endif // wxLONGLONG_TEST_MODE
 811
 812     int counter = 0;
 813     do
 814     {
 815         if ((q.m_lo & 1) != 0)
 816             *this += t;
 817         q >>= 1;
 818         t <<= 1;
 819         counter++;
 820     }
 821     while ((counter < 64) && ((q.m_hi != 0) || (q.m_lo != 0)));
 822
 823 #ifdef wxLONGLONG_TEST_MODE
 824     m_ll = llOld * ll.m_ll;
 825
 826     Check();
 827 #endif // wxLONGLONG_TEST_MODE
 828
 829     return *this;
 830 }
 831
 832 wxULongLongWx& wxULongLongWx::operator*=(const wxULongLongWx& ll)
 833 {
 834     wxULongLongWx t(m_hi, m_lo);
 835     wxULongLongWx q(ll.m_hi, ll.m_lo);
 836
 837     m_hi = m_lo = 0;
 838
 839 #ifdef wxLONGLONG_TEST_MODE
 840     wxULongLong_t llOld = m_ll;
 841     m_ll = 0;
 842 #endif // wxLONGLONG_TEST_MODE
 843
 844     int counter = 0;
 845     do
 846     {
 847         if ((q.m_lo & 1) != 0)
 848             *this += t;
 849         q >>= 1;
 850         t <<= 1;
 851         counter++;
 852     }
 853     while ((counter < 64) && ((q.m_hi != 0) || (q.m_lo != 0)));
 854
 855 #ifdef wxLONGLONG_TEST_MODE
 856     m_ll = llOld * ll.m_ll;
 857
 858     Check();
 859 #endif // wxLONGLONG_TEST_MODE
 860
 861     return *this;
 862 }
 863
 864 // division
 865
 866 #define IS_MSB_SET(ll)  ((ll.GetHi()) & (1 << (8*sizeof(long) - 1)))
 867
 868 void wxLongLongWx::Divide(const wxLongLongWx& divisorIn,
 869                           wxLongLongWx& quotient,
 870                           wxLongLongWx& remainderIO) const
 871 {
 872     if ((divisorIn.m_lo == 0) && (divisorIn.m_hi == 0))
 873     {
 874         // provoke division by zero error and silence the compilers warnings
 875         // about an expression without effect and unused variable
 876         long dummy = divisorIn.m_lo/divisorIn.m_hi;
 877         dummy += 0;
 878     }
 879
 880     // VZ: I'm writing this in a hurry and it's surely not the fastest way to
 881     //     do this - any improvements are more than welcome
 882     //
 883     //     code inspired by the snippet at
 884     //          http://www.bearcave.com/software/divide.htm
 885     //
 886     //     Copyright notice:
 887     //
 888     //     Use of this program, for any purpose, is granted the author, Ian
 889     //     Kaplan, as long as this copyright notice is included in the source
 890     //     code or any source code derived from this program. The user assumes
 891     //     all responsibility for using this code.
 892
 893     // init everything
 894     wxULongLongWx dividend, divisor, remainder;
 895
 896     quotient = 0l;
 897     remainder = 0l;
 898
 899     // always do unsigned division and adjust the signs later: in C integer
 900     // division, the sign of the remainder is the same as the sign of the
 901     // dividend, while the sign of the quotient is the product of the signs of
 902     // the dividend and divisor. Of course, we also always have
 903     //
 904     //      dividend = quotient*divisor + remainder
 905     //
 906     // with 0 <= abs(remainder) < abs(divisor)
 907     bool negRemainder = GetHi() < 0;
 908     bool negQuotient = false;   // assume positive
 909     if ( GetHi() < 0 )
 910     {
 911         negQuotient = !negQuotient;
 912         dividend = -*this;
 913     } else {
 914         dividend = *this;
 915     }
 916     if ( divisorIn.GetHi() < 0 )
 917     {
 918         negQuotient = !negQuotient;
 919         divisor = -divisorIn;
 920     } else {
 921         divisor = divisorIn;
 922     }
 923
 924     // check for some particular cases
 925     if ( divisor > dividend )
 926     {
 927         remainder = dividend;
 928     }
 929     else if ( divisor == dividend )
 930     {
 931         quotient = 1l;
 932     }
 933     else
 934     {
 935         // here: dividend > divisor and both are positive: do unsigned division
 936         size_t nBits = 64u;
 937         wxLongLongWx d;
 938
 939         while ( remainder < divisor )
 940         {
 941             remainder <<= 1;
 942             if ( IS_MSB_SET(dividend) )
 943             {
 944                 remainder |= 1;
 945             }
 946
 947             d = dividend;
 948             dividend <<= 1;
 949
 950             nBits--;
 951         }
 952
 953         // undo the last loop iteration
 954         dividend = d;
 955         remainder >>= 1;
 956         nBits++;
 957
 958         for ( size_t i = 0; i < nBits; i++ )
 959         {
 960             remainder <<= 1;
 961             if ( IS_MSB_SET(dividend) )
 962             {
 963                 remainder |= 1;
 964             }
 965
 966             wxLongLongWx t = remainder - divisor;
 967             dividend <<= 1;
 968             quotient <<= 1;
 969             if ( !IS_MSB_SET(t) )
 970             {
 971                 quotient |= 1;
 972
 973                 remainder = t;
 974             }
 975         }
 976     }
 977
 978     remainderIO = remainder;
 979
 980     // adjust signs
 981     if ( negRemainder )
 982     {
 983         remainderIO = -remainderIO;
 984     }
 985
 986     if ( negQuotient )
 987     {
 988         quotient = -quotient;
 989     }
 990 }
 991
 992 void wxULongLongWx::Divide(const wxULongLongWx& divisorIn,
 993                            wxULongLongWx& quotient,
 994                            wxULongLongWx& remainder) const
 995 {
 996     if ((divisorIn.m_lo == 0) && (divisorIn.m_hi == 0))
 997     {
 998         // provoke division by zero error and silence the compilers warnings
 999         // about an expression without effect and unused variable
1000         unsigned long dummy = divisorIn.m_lo/divisorIn.m_hi;
1001         dummy += 0;
1002     }
1003
1004     // VZ: I'm writing this in a hurry and it's surely not the fastest way to
1005     //     do this - any improvements are more than welcome
1006     //
1007     //     code inspired by the snippet at
1008     //          http://www.bearcave.com/software/divide.htm
1009     //
1010     //     Copyright notice:
1011     //
1012     //     Use of this program, for any purpose, is granted the author, Ian
1013     //     Kaplan, as long as this copyright notice is included in the source
1014     //     code or any source code derived from this program. The user assumes
1015     //     all responsibility for using this code.
1016
1017     // init everything
1018     wxULongLongWx dividend = *this,
1019                   divisor = divisorIn;
1020
1021     quotient = 0l;
1022     remainder = 0l;
1023
1024     // check for some particular cases
1025     if ( divisor > dividend )
1026     {
1027         remainder = dividend;
1028     }
1029     else if ( divisor == dividend )
1030     {
1031         quotient = 1l;
1032     }
1033     else
1034     {
1035         // here: dividend > divisor
1036         size_t nBits = 64u;
1037         wxULongLongWx d;
1038
1039         while ( remainder < divisor )
1040         {
1041             remainder <<= 1;
1042             if ( IS_MSB_SET(dividend) )
1043             {
1044                 remainder |= 1;
1045             }
1046
1047             d = dividend;
1048             dividend <<= 1;
1049
1050             nBits--;
1051         }
1052
1053         // undo the last loop iteration
1054         dividend = d;
1055         remainder >>= 1;
1056         nBits++;
1057
1058         for ( size_t i = 0; i < nBits; i++ )
1059         {
1060             remainder <<= 1;
1061             if ( IS_MSB_SET(dividend) )
1062             {
1063                 remainder |= 1;
1064             }
1065
1066             wxULongLongWx t = remainder - divisor;
1067             dividend <<= 1;
1068             quotient <<= 1;
1069             if ( !IS_MSB_SET(t) )
1070             {
1071                 quotient |= 1;
1072
1073                 remainder = t;
1074             }
1075         }
1076     }
1077 }
1078
1079 wxLongLongWx wxLongLongWx::operator/(const wxLongLongWx& ll) const
1080 {
1081     wxLongLongWx quotient, remainder;
1082
1083     Divide(ll, quotient, remainder);
1084
1085     return quotient;
1086 }
1087
1088 wxULongLongWx wxULongLongWx::operator/(const wxULongLongWx& ll) const
1089 {
1090     wxULongLongWx quotient, remainder;
1091
1092     Divide(ll, quotient, remainder);
1093
1094     return quotient;
1095 }
1096
1097 wxLongLongWx& wxLongLongWx::operator/=(const wxLongLongWx& ll)
1098 {
1099     wxLongLongWx quotient, remainder;
1100
1101     Divide(ll, quotient, remainder);
1102
1103     *this = quotient;
1104
1105     return *this;
1106 }
1107
1108 wxULongLongWx& wxULongLongWx::operator/=(const wxULongLongWx& ll)
1109 {
1110     wxULongLongWx quotient, remainder;
1111
1112     Divide(ll, quotient, remainder);
1113
1114     *this = quotient;
1115
1116     return *this;
1117 }
1118
1119 wxLongLongWx wxLongLongWx::operator%(const wxLongLongWx& ll) const
1120 {
1121     wxLongLongWx quotient, remainder;
1122
1123     Divide(ll, quotient, remainder);
1124
1125     return remainder;
1126 }
1127
1128 wxULongLongWx wxULongLongWx::operator%(const wxULongLongWx& ll) const
1129 {
1130     wxULongLongWx quotient, remainder;
1131
1132     Divide(ll, quotient, remainder);
1133
1134     return remainder;
1135 }
1136
1137 // ----------------------------------------------------------------------------
1138 // misc
1139 // ----------------------------------------------------------------------------
1140
1141 // temporary - just for testing
1142 void *wxLongLongWx::asArray(void) const
1143 {
1144     static unsigned char temp[8];
1145
1146     temp[0] = (char)((m_hi >> 24) & 0xFF);
1147     temp[1] = (char)((m_hi >> 16) & 0xFF);
1148     temp[2] = (char)((m_hi >> 8)  & 0xFF);
1149     temp[3] = (char)((m_hi >> 0)  & 0xFF);
1150     temp[4] = (char)((m_lo >> 24) & 0xFF);
1151     temp[5] = (char)((m_lo >> 16) & 0xFF);
1152     temp[6] = (char)((m_lo >> 8)  & 0xFF);
1153     temp[7] = (char)((m_lo >> 0)  & 0xFF);
1154
1155     return temp;
1156 }
1157
1158 void *wxULongLongWx::asArray(void) const
1159 {
1160     static unsigned char temp[8];
1161
1162     temp[0] = (char)((m_hi >> 24) & 0xFF);
1163     temp[1] = (char)((m_hi >> 16) & 0xFF);
1164     temp[2] = (char)((m_hi >> 8)  & 0xFF);
1165     temp[3] = (char)((m_hi >> 0)  & 0xFF);
1166     temp[4] = (char)((m_lo >> 24) & 0xFF);
1167     temp[5] = (char)((m_lo >> 16) & 0xFF);
1168     temp[6] = (char)((m_lo >> 8)  & 0xFF);
1169     temp[7] = (char)((m_lo >> 0)  & 0xFF);
1170
1171     return temp;
1172 }
1173
1174 #endif // wxUSE_LONGLONG_WX
1175
1176 #define LL_TO_STRING(name)                                           \
1177     wxString name::ToString() const                                  \
1178     {                                                                \
1179         /* TODO: this is awfully inefficient, anything better? */    \
1180         wxString result;                                             \
1181                                                                      \
1182         name ll = *this;                                             \
1183                                                                      \
1184         bool neg = ll < 0;                                           \
1185         if ( neg )                                                   \
1186         {                                                            \
1187             while ( ll != 0 )                                        \
1188             {                                                        \
1189                 long digit = (ll % 10).ToLong();                     \
1190                 result.Prepend((wxChar)(wxT('0') - digit));          \
1191                 ll /= 10;                                            \
1192             }                                                        \
1193         }                                                            \
1194         else                                                         \
1195         {                                                            \
1196             while ( ll != 0 )                                        \
1197             {                                                        \
1198                 long digit = (ll % 10).ToLong();                     \
1199                 result.Prepend((wxChar)(wxT('0') + digit));          \
1200                 ll /= 10;                                            \
1201             }                                                        \
1202         }                                                            \
1203                                                                      \
1204         if ( result.empty() )                                        \
1205             result = wxT('0');                                       \
1206         else if ( neg )                                              \
1207             result.Prepend(wxT('-'));                                \
1208                                                                      \
1209         return result;                                               \
1210     }
1211
1212 #define ULL_TO_STRING(name)                                          \
1213     wxString name::ToString() const                                  \
1214     {                                                                \
1215         /* TODO: this is awfully inefficient, anything better? */    \
1216         wxString result;                                             \
1217                                                                      \
1218         name ll = *this;                                             \
1219                                                                      \
1220         while ( ll != 0 )                                            \
1221         {                                                            \
1222             result.Prepend((wxChar)(wxT('0') + (ll % 10).ToULong())); \
1223             ll /= 10;                                                \
1224         }                                                            \
1225                                                                      \
1226         if ( result.empty() )                                        \
1227             result = wxT('0');                                       \
1228                                                                      \
1229         return result;                                               \
1230     }
1231
1232 #if wxUSE_LONGLONG_NATIVE
1233     LL_TO_STRING(wxLongLongNative)
1234     ULL_TO_STRING(wxULongLongNative)
1235 #endif
1236
1237 #if wxUSE_LONGLONG_WX
1238     LL_TO_STRING(wxLongLongWx)
1239     ULL_TO_STRING(wxULongLongWx)
1240 #endif
1241
1242 #if wxUSE_STD_IOSTREAM
1243
1244 // input/output
1245 WXDLLIMPEXP_BASE
1246 wxSTD ostream& operator<< (wxSTD ostream& o, const wxLongLong& ll)
1247 {
1248     return o << ll.ToString();
1249 }
1250
1251 WXDLLIMPEXP_BASE
1252 wxSTD ostream& operator<< (wxSTD ostream& o, const wxULongLong& ll)
1253 {
1254     return o << ll.ToString();
1255 }
1256
1257 #endif // wxUSE_STD_IOSTREAM
1258
1259 WXDLLIMPEXP_BASE wxString& operator<< (wxString& s, const wxLongLong& ll)
1260 {
1261     return s << ll.ToString();
1262 }
1263
1264 WXDLLIMPEXP_BASE wxString& operator<< (wxString& s, const wxULongLong& ll)
1265 {
1266     return s << ll.ToString();
1267 }
1268
1269 #if wxUSE_STREAMS
1270
1271 WXDLLIMPEXP_BASE wxTextOutputStream& operator<< (wxTextOutputStream& o, const wxULongLong& ll)
1272 {
1273     return o << ll.ToString();
1274 }
1275
1276 WXDLLIMPEXP_BASE wxTextOutputStream& operator<< (wxTextOutputStream& o, const wxLongLong& ll)
1277 {
1278     return o << ll.ToString();
1279 }
1280
1281 #define READ_STRING_CHAR(s, idx, len) ((idx!=len) ? (wxChar)s[idx++] : wxT('\0'))
1282
1283 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &o, wxULongLong &ll)
1284 {
1285     wxString s = o.ReadWord();
1286
1287     ll = wxULongLong(0l, 0l);
1288     size_t length = s.length();
1289     size_t idx = 0;
1290
1291     wxChar ch = READ_STRING_CHAR(s, idx, length);
1292
1293     // Skip WS
1294     while (ch==wxT(' ') || ch==wxT('\t'))
1295         ch = READ_STRING_CHAR(s, idx, length);
1296
1297     // Read number
1298     wxULongLong multiplier(0l, 10l);
1299     while (ch>=wxT('0') && ch<=wxT('9')) {
1300         long lValue = (unsigned) (ch - wxT('0'));
1301         ll = ll * multiplier + wxULongLong(0l, lValue);
1302         ch = READ_STRING_CHAR(s, idx, length);
1303     }
1304
1305     return o;
1306 }
1307
1308 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &o, wxLongLong &ll)
1309 {
1310     wxString s = o.ReadWord();
1311
1312     ll = wxLongLong(0l, 0l);
1313     size_t length = s.length();
1314     size_t idx = 0;
1315
1316     wxChar ch = READ_STRING_CHAR(s, idx, length);
1317
1318     // Skip WS
1319     while (ch==wxT(' ') || ch==wxT('\t'))
1320         ch = READ_STRING_CHAR(s, idx, length);
1321
1322     // Ask for sign
1323     int iSign = 1;
1324     if (ch==wxT('-') || ch==wxT('+')) {
1325         iSign = ((ch==wxT('-')) ? -1 : 1);
1326         ch = READ_STRING_CHAR(s, idx, length);
1327     }
1328
1329     // Read number
1330     wxLongLong multiplier(0l, 10l);
1331     while (ch>=wxT('0') && ch<=wxT('9')) {
1332         long lValue = (unsigned) (ch - wxT('0'));
1333         ll = ll * multiplier + wxLongLong(0l, lValue);
1334         ch = READ_STRING_CHAR(s, idx, length);
1335     }
1336
1337 #if wxUSE_LONGLONG_NATIVE
1338     ll = ll * wxLongLong((wxLongLong_t) iSign);
1339 #else
1340     ll = ll * wxLongLong((long) iSign);
1341 #endif
1342
1343     return o;
1344 }
1345
1346 #if wxUSE_LONGLONG_NATIVE
1347
1348 WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &o, wxULongLong_t value)
1349 {
1350     return o << wxULongLong(value).ToString();
1351 }
1352
1353 WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &o, wxLongLong_t value)
1354 {
1355     return o << wxLongLong(value).ToString();
1356 }
1357
1358 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &o, wxULongLong_t &value)
1359 {
1360     wxULongLong ll;
1361     o >> ll;
1362     value = ll.GetValue();
1363     return o;
1364 }
1365
1366 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &o, wxLongLong_t &value)
1367 {
1368     wxLongLong ll;
1369     o >> ll;
1370     value = ll.GetValue();
1371     return o;
1372 }
1373
1374 #endif // wxUSE_LONGLONG_NATIVE
1375
1376 #endif // wxUSE_STREAMS
1377
1378 #endif // wxUSE_LONGLONG