/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/longlong.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/longlong.cpp

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.22