src/common/longlong.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/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 wxWindows 2.0! It is intentionally
   6 //              not documented and is for private use only.
   7 // Modified by:
   8 // Created:     10.02.99
   9 // RCS-ID:      $Id$
  10 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  11 // Licence:     wxWindows license
  12 /////////////////////////////////////////////////////////////////////////////
  13
  14 // ============================================================================
  15 // headers
  16 // ============================================================================
  17
  18 #ifdef __GNUG__
  19     #pragma implementation "longlong.h"
  20 #endif
  21
  22 #include "wx/wxprec.h"
  23
  24 #ifdef __BORLANDC__
  25     #pragma hdrstop
  26 #endif
  27
  28 #if wxUSE_LONGLONG
  29 #include "wx/longlong.h"
  30
  31 #include <memory.h>     // for memset()
  32 #include <math.h>       // for fabs()
  33
  34 // ============================================================================
  35 // implementation
  36 // ============================================================================
  37
  38 #if wxUSE_LONGLONG_NATIVE
  39
  40 // ----------------------------------------------------------------------------
  41 // misc
  42 // ----------------------------------------------------------------------------
  43
  44 void *wxLongLongNative::asArray() const
  45 {
  46     static unsigned char temp[8];
  47
  48     temp[0] = (m_ll >> 56) & 0xFF;
  49     temp[1] = (m_ll >> 48) & 0xFF;
  50     temp[2] = (m_ll >> 40) & 0xFF;
  51     temp[3] = (m_ll >> 32) & 0xFF;
  52     temp[4] = (m_ll >> 24) & 0xFF;
  53     temp[5] = (m_ll >> 16) & 0xFF;
  54     temp[6] = (m_ll >> 8)  & 0xFF;
  55     temp[7] = (m_ll >> 0)  & 0xFF;
  56
  57     return temp;
  58 }
  59
  60 #if wxUSE_STD_IOSTREAM
  61
  62 // input/output
  63 ostream& operator<< (ostream& o, const wxLongLongNative& ll)
  64 {
  65     char result[65];
  66
  67     memset(result, 'A', 64);
  68
  69     result[64] = '\0';
  70
  71     for (int i = 0; i < 64; i++)
  72     {
  73         result[63 - i] = '0' + (char) ((ll.GetValue() >> i) & 1);
  74     }
  75
  76     return o << result;
  77 }
  78
  79 #endif // wxUSE_STD_IOSTREAM
  80
  81 #endif // wxUSE_LONGLONG_NATIVE
  82
  83 // ============================================================================
  84 // wxLongLongWx: emulation of 'long long' using 2 longs
  85 // ============================================================================
  86
  87 #if wxUSE_LONGLONG_WX
  88
  89 // assignment
  90 wxLongLongWx& wxLongLongWx::Assign(double d)
  91 {
  92     bool positive = d >= 0;
  93     d = fabs(d);
  94     if ( d <= ULONG_MAX )
  95     {
  96         m_hi = 0;
  97         m_lo = (long)d;
  98     }
  99     else
 100     {
 101         m_hi = (unsigned long)(d / (1.0 + (double)ULONG_MAX));
 102         m_lo = (unsigned long)(d - ((double)m_hi * (1.0 + (double)ULONG_MAX)));
 103     }
 104
 105 #ifdef wxLONGLONG_TEST_MODE
 106     m_ll = (wxLongLong_t)d;
 107
 108     Check();
 109 #endif // wxLONGLONG_TEST_MODE
 110
 111     if ( !positive )
 112         Negate();
 113
 114     return *this;
 115 }
 116
 117 wxLongLongWx wxLongLongWx::operator<<(int shift) const
 118 {
 119     wxLongLongWx ll(*this);
 120     ll <<= shift;
 121
 122     return ll;
 123 }
 124
 125 wxLongLongWx& wxLongLongWx::operator<<=(int shift)
 126 {
 127     if (shift != 0)
 128     {
 129         if (shift < 32)
 130         {
 131             m_hi <<= shift;
 132             m_hi |= m_lo >> (32 - shift);
 133             m_lo <<= shift;
 134         }
 135         else
 136         {
 137             m_hi = m_lo << (shift - 32);
 138             m_lo = 0;
 139         }
 140     }
 141
 142 #ifdef wxLONGLONG_TEST_MODE
 143     m_ll <<= shift;
 144
 145     Check();
 146 #endif // wxLONGLONG_TEST_MODE
 147
 148     return *this;
 149 }
 150
 151 wxLongLongWx wxLongLongWx::operator>>(int shift) const
 152 {
 153     wxLongLongWx ll(*this);
 154     ll >>= shift;
 155
 156     return ll;
 157 }
 158
 159 wxLongLongWx& wxLongLongWx::operator>>=(int shift)
 160 {
 161     if (shift != 0)
 162     {
 163         if (shift < 32)
 164         {
 165             m_lo >>= shift;
 166             m_lo |= m_hi << (32 - shift);
 167             m_hi >>= shift;
 168         }
 169         else
 170         {
 171             m_lo = m_hi >> (shift - 32);
 172             m_hi = (m_hi < 0 ? -1L : 0);
 173         }
 174     }
 175
 176 #ifdef wxLONGLONG_TEST_MODE
 177     m_ll >>= shift;
 178
 179     Check();
 180 #endif // wxLONGLONG_TEST_MODE
 181
 182     return *this;
 183 }
 184
 185 wxLongLongWx wxLongLongWx::operator+(const wxLongLongWx& ll) const
 186 {
 187     wxLongLongWx res(*this);
 188     res += ll;
 189
 190     return res;
 191 }
 192
 193 wxLongLongWx wxLongLongWx::operator+(long l) const
 194 {
 195     wxLongLongWx res(*this);
 196     res += l;
 197
 198     return res;
 199 }
 200
 201 wxLongLongWx& wxLongLongWx::operator+=(const wxLongLongWx& ll)
 202 {
 203     unsigned long previous = m_lo;
 204
 205     m_lo += ll.m_lo;
 206     m_hi += ll.m_hi;
 207
 208     if ((m_lo < previous) || (m_lo < ll.m_lo))
 209         m_hi++;
 210
 211 #ifdef wxLONGLONG_TEST_MODE
 212     m_ll += ll.m_ll;
 213
 214     Check();
 215 #endif // wxLONGLONG_TEST_MODE
 216
 217     return *this;
 218 }
 219
 220 wxLongLongWx& wxLongLongWx::operator+=(long l)
 221 {
 222     unsigned long previous = m_lo;
 223
 224     m_lo += l;
 225     if (l < 0)
 226         m_hi += -1l;
 227
 228     if ((m_lo < previous) || (m_lo < (unsigned long)l))
 229         m_hi++;
 230
 231 #ifdef wxLONGLONG_TEST_MODE
 232     m_ll += l;
 233
 234     Check();
 235 #endif // wxLONGLONG_TEST_MODE
 236
 237     return *this;
 238 }
 239
 240 // pre increment
 241 wxLongLongWx& wxLongLongWx::operator++()
 242 {
 243     m_lo++;
 244     if (m_lo == 0)
 245         m_hi++;
 246
 247 #ifdef wxLONGLONG_TEST_MODE
 248     m_ll++;
 249
 250     Check();
 251 #endif // wxLONGLONG_TEST_MODE
 252
 253     return *this;
 254 }
 255
 256 // negation
 257 wxLongLongWx wxLongLongWx::operator-() const
 258 {
 259     wxLongLongWx res(*this);
 260     res.Negate();
 261
 262     return res;
 263 }
 264
 265 wxLongLongWx& wxLongLongWx::Negate()
 266 {
 267     m_hi = ~m_hi;
 268     m_lo = ~m_lo;
 269
 270     m_lo++;
 271     if ( m_lo == 0 )
 272         m_hi++;
 273
 274 #ifdef wxLONGLONG_TEST_MODE
 275     m_ll = -m_ll;
 276
 277     Check();
 278 #endif // wxLONGLONG_TEST_MODE
 279
 280     return *this;
 281 }
 282
 283 // subtraction
 284
 285 wxLongLongWx wxLongLongWx::operator-(const wxLongLongWx& ll) const
 286 {
 287     wxLongLongWx res(*this);
 288     res -= ll;
 289
 290     return res;
 291 }
 292
 293 wxLongLongWx& wxLongLongWx::operator-=(const wxLongLongWx& ll)
 294 {
 295     unsigned long previous = m_lo;
 296
 297     m_lo -= ll.m_lo;
 298     m_hi -= ll.m_hi;
 299
 300     if (previous < ll.m_lo)
 301         m_hi--;
 302
 303 #ifdef wxLONGLONG_TEST_MODE
 304     m_ll -= ll.m_ll;
 305
 306     Check();
 307 #endif // wxLONGLONG_TEST_MODE
 308
 309     return *this;
 310 }
 311
 312 // pre decrement
 313 wxLongLongWx& wxLongLongWx::operator--()
 314 {
 315     m_lo--;
 316     if (m_lo == 0xFFFFFFFF)
 317         m_hi--;
 318
 319 #ifdef wxLONGLONG_TEST_MODE
 320     m_ll--;
 321
 322     Check();
 323 #endif // wxLONGLONG_TEST_MODE
 324
 325     return *this;
 326 }
 327
 328 // comparison operators
 329
 330 bool wxLongLongWx::operator<(const wxLongLongWx& ll) const
 331 {
 332     if ( m_hi < ll.m_hi )
 333         return TRUE;
 334     else if ( m_hi == ll.m_hi )
 335         return m_lo < ll.m_lo;
 336     else
 337         return FALSE;
 338 }
 339
 340 bool wxLongLongWx::operator>(const wxLongLongWx& ll) const
 341 {
 342     if ( m_hi > ll.m_hi )
 343         return TRUE;
 344     else if ( m_hi == ll.m_hi )
 345         return m_lo > ll.m_lo;
 346     else
 347         return FALSE;
 348 }
 349
 350 // bitwise operators
 351
 352 wxLongLongWx wxLongLongWx::operator&(const wxLongLongWx& ll) const
 353 {
 354     return wxLongLongWx(m_hi & ll.m_hi, m_lo & ll.m_lo);
 355 }
 356
 357 wxLongLongWx wxLongLongWx::operator|(const wxLongLongWx& ll) const
 358 {
 359     return wxLongLongWx(m_hi | ll.m_hi, m_lo | ll.m_lo);
 360 }
 361
 362 wxLongLongWx wxLongLongWx::operator^(const wxLongLongWx& ll) const
 363 {
 364     return wxLongLongWx(m_hi ^ ll.m_hi, m_lo ^ ll.m_lo);
 365 }
 366
 367 wxLongLongWx& wxLongLongWx::operator&=(const wxLongLongWx& ll)
 368 {
 369     m_lo &= ll.m_lo;
 370     m_hi &= ll.m_hi;
 371
 372 #ifdef wxLONGLONG_TEST_MODE
 373     m_ll &= ll.m_ll;
 374
 375     Check();
 376 #endif // wxLONGLONG_TEST_MODE
 377
 378     return *this;
 379 }
 380
 381 wxLongLongWx& wxLongLongWx::operator|=(const wxLongLongWx& ll)
 382 {
 383     m_lo |= ll.m_lo;
 384     m_hi |= ll.m_hi;
 385
 386 #ifdef wxLONGLONG_TEST_MODE
 387     m_ll |= ll.m_ll;
 388
 389     Check();
 390 #endif // wxLONGLONG_TEST_MODE
 391
 392     return *this;
 393 }
 394
 395 wxLongLongWx& wxLongLongWx::operator^=(const wxLongLongWx& ll)
 396 {
 397     m_lo ^= ll.m_lo;
 398     m_hi ^= ll.m_hi;
 399
 400 #ifdef wxLONGLONG_TEST_MODE
 401     m_ll ^= ll.m_ll;
 402
 403     Check();
 404 #endif // wxLONGLONG_TEST_MODE
 405
 406     return *this;
 407 }
 408
 409 wxLongLongWx wxLongLongWx::operator~() const
 410 {
 411     return wxLongLongWx(~m_hi, ~m_lo);
 412 }
 413
 414 // multiplication
 415
 416 wxLongLongWx wxLongLongWx::operator*(const wxLongLongWx& ll) const
 417 {
 418     wxLongLongWx res(*this);
 419     res *= ll;
 420
 421     return res;
 422 }
 423
 424 wxLongLongWx& wxLongLongWx::operator*=(const wxLongLongWx& ll)
 425 {
 426     wxLongLongWx t(m_hi, m_lo);
 427     wxLongLongWx q(ll.m_hi, ll.m_lo);
 428
 429     m_hi = m_lo = 0;
 430
 431 #ifdef wxLONGLONG_TEST_MODE
 432     wxLongLong_t llOld = m_ll;
 433     m_ll = 0;
 434 #endif // wxLONGLONG_TEST_MODE
 435
 436     int counter = 0;
 437     do
 438     {
 439         if ((q.m_lo & 1) != 0)
 440             *this += t;
 441         q >>= 1;
 442         t <<= 1;
 443         counter++;
 444     }
 445     while ((counter < 64) && ((q.m_hi != 0) || (q.m_lo != 0)));
 446
 447 #ifdef wxLONGLONG_TEST_MODE
 448     m_ll = llOld * ll.m_ll;
 449
 450     Check();
 451 #endif // wxLONGLONG_TEST_MODE
 452
 453     return *this;
 454 }
 455
 456 // division
 457
 458 void wxLongLongWx::Divide(const wxLongLongWx& divisorIn,
 459                           wxLongLongWx& quotient,
 460                           wxLongLongWx& remainder) const
 461 {
 462     if ((divisorIn.m_lo == 0) && (divisorIn.m_hi == 0))
 463     {
 464         // provoke division by zero error and silence the compilers warnings
 465         // about an expression without effect and unused variable
 466         long dummy = divisorIn.m_lo/divisorIn.m_hi;
 467         dummy += 0;
 468     }
 469
 470     // VZ: I'm writing this in a hurry and it's surely not the fastest way to
 471     //     do this - any improvements are more than welcome
 472     //
 473     //     code inspired by the snippet at
 474     //          http://www.bearcave.com/software/divide.htm
 475     //
 476     //     Copyright notice:
 477     //
 478     //     Use of this program, for any purpose, is granted the author, Ian
 479     //     Kaplan, as long as this copyright notice is included in the source
 480     //     code or any source code derived from this program. The user assumes
 481     //     all responsibility for using this code.
 482
 483     // init everything
 484     wxLongLongWx dividend = *this,
 485                  divisor = divisorIn;
 486
 487     quotient = 0l;
 488     remainder = 0l;
 489
 490     // always do unsigned division and adjust the signs later: in C integer
 491     // division, the sign of the remainder is the same as the sign of the
 492     // dividend, while the sign of the quotient is the product of the signs of
 493     // the dividend and divisor. Of course, we also always have
 494     //
 495     //      dividend = quotient*divisor + remainder
 496     //
 497     // with 0 <= abs(remainder) < abs(divisor)
 498     bool negRemainder = dividend.m_hi < 0;
 499     bool negQuotient = FALSE;   // assume positive
 500     if ( dividend.m_hi < 0 )
 501     {
 502         negQuotient = !negQuotient;
 503         dividend = -dividend;
 504     }
 505     if ( divisor.m_hi < 0 )
 506     {
 507         negQuotient = !negQuotient;
 508         divisor = -divisor;
 509     }
 510
 511     // check for some particular cases
 512     if ( divisor > dividend )
 513     {
 514         remainder = dividend;
 515     }
 516     else if ( divisor == dividend )
 517     {
 518         quotient = 1l;
 519     }
 520     else
 521     {
 522         // here: dividend > divisor and both are positibe: do unsigned division
 523         size_t nBits = 64u;
 524         wxLongLongWx d;
 525
 526         #define IS_MSB_SET(ll)  ((ll.m_hi) & (1 << (8*sizeof(long) - 1)))
 527
 528         while ( remainder < divisor )
 529         {
 530             remainder <<= 1;
 531             if ( IS_MSB_SET(dividend) )
 532             {
 533                 remainder |= 1;
 534             }
 535
 536             d = dividend;
 537             dividend <<= 1;
 538
 539             nBits--;
 540         }
 541
 542         // undo the last loop iteration
 543         dividend = d;
 544         remainder >>= 1;
 545         nBits++;
 546
 547         for ( size_t i = 0; i < nBits; i++ )
 548         {
 549             remainder <<= 1;
 550             if ( IS_MSB_SET(dividend) )
 551             {
 552                 remainder |= 1;
 553             }
 554
 555             wxLongLongWx t = remainder - divisor;
 556             dividend <<= 1;
 557             quotient <<= 1;
 558             if ( !IS_MSB_SET(t) )
 559             {
 560                 quotient |= 1;
 561
 562                 remainder = t;
 563             }
 564         }
 565     }
 566
 567     // adjust signs
 568     if ( negRemainder )
 569     {
 570         remainder = -remainder;
 571     }
 572
 573     if ( negQuotient )
 574     {
 575         quotient = -quotient;
 576     }
 577 }
 578
 579 wxLongLongWx wxLongLongWx::operator/(const wxLongLongWx& ll) const
 580 {
 581     wxLongLongWx quotient, remainder;
 582
 583     Divide(ll, quotient, remainder);
 584
 585     return quotient;
 586 }
 587
 588 wxLongLongWx& wxLongLongWx::operator/=(const wxLongLongWx& ll)
 589 {
 590     wxLongLongWx quotient, remainder;
 591
 592     Divide(ll, quotient, remainder);
 593
 594     *this = quotient;
 595
 596     return *this;
 597 }
 598
 599 wxLongLongWx wxLongLongWx::operator%(const wxLongLongWx& ll) const
 600 {
 601     wxLongLongWx quotient, remainder;
 602
 603     Divide(ll, quotient, remainder);
 604
 605     return remainder;
 606 }
 607
 608 // ----------------------------------------------------------------------------
 609 // misc
 610 // ----------------------------------------------------------------------------
 611
 612 // temporary - just for testing
 613 void *wxLongLongWx::asArray(void) const
 614 {
 615     static unsigned char temp[8];
 616
 617     temp[0] = (char)((m_hi >> 24) & 0xFF);
 618     temp[1] = (char)((m_hi >> 16) & 0xFF);
 619     temp[2] = (char)((m_hi >> 8)  & 0xFF);
 620     temp[3] = (char)((m_hi >> 0)  & 0xFF);
 621     temp[4] = (char)((m_lo >> 24) & 0xFF);
 622     temp[5] = (char)((m_lo >> 16) & 0xFF);
 623     temp[6] = (char)((m_lo >> 8)  & 0xFF);
 624     temp[7] = (char)((m_lo >> 0)  & 0xFF);
 625
 626     return temp;
 627 }
 628
 629 #if wxUSE_STD_IOSTREAM
 630
 631 // input/output
 632 ostream& operator<< (ostream& o, const wxLongLongWx& ll)
 633 {
 634     char result[65];
 635
 636     memset(result, 'A', 64);
 637
 638     result[64] = '\0';
 639
 640     for (int i = 0; i < 32; i++)
 641     {
 642         result[31 - i] = (char) ('0' + (int) ((ll.m_hi >> i) & 1));
 643         result[63 - i] = (char) ('0' + (int) ((ll.m_lo >> i) & 1));
 644     }
 645
 646     return o << result;
 647 }
 648 #endif // wxUSE_STD_IOSTREAM
 649
 650 #endif // wxUSE_LONGLONG_NATIVE
 651
 652 #endif // wxUSE_LONGLONG