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