projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add more checks for Intel compiler.
[wxWidgets.git] / include / wx / longlong.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/longlong.h
3 // Purpose: declaration of wxLongLong class - best implementation of a 64
4 // bit integer for the current platform.
5 // Author: Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
6 // Modified by:
7 // Created: 10.02.99
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_LONGLONG_H
13 #define _WX_LONGLONG_H
14
15 #include "wx/defs.h"
16
17 #if wxUSE_LONGLONG
18
19 #include "wx/string.h"
20
21 #include <limits.h> // for LONG_MAX
22
23 // define this to compile wxLongLongWx in "test" mode: the results of all
24 // calculations will be compared with the real results taken from
25 // wxLongLongNative -- this is extremely useful to find the bugs in
26 // wxLongLongWx class!
27
28 // #define wxLONGLONG_TEST_MODE
29
30 #ifdef wxLONGLONG_TEST_MODE
31 #define wxUSE_LONGLONG_WX 1
32 #define wxUSE_LONGLONG_NATIVE 1
33 #endif // wxLONGLONG_TEST_MODE
34
35 // ----------------------------------------------------------------------------
36 // decide upon which class we will use
37 // ----------------------------------------------------------------------------
38
39 #ifndef wxLongLong_t
40 // both warning and pragma warning are not portable, but at least an
41 // unknown pragma should never be an error -- except that, actually, some
42 // broken compilers don't like it, so we have to disable it in this case
43 // <sigh>
44 #ifdef __GNUC__
45 #warning "Your compiler does not appear to support 64 bit "\
46 "integers, using emulation class instead.\n" \
47 "Please report your compiler version to " \
48 "wx-dev@lists.wxwidgets.org!"
49 #elif !(defined(__WATCOMC__) || defined(__VISAGECPP__))
50 #pragma warning "Your compiler does not appear to support 64 bit "\
51 "integers, using emulation class instead.\n" \
52 "Please report your compiler version to " \
53 "wx-dev@lists.wxwidgets.org!"
54 #endif
55
56 #define wxUSE_LONGLONG_WX 1
57 #endif // compiler
58
59 // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
60 // to disable automatic testing (useful for the test program which defines
61 // both classes) but by default we only use one class
62 #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
63 // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set:
64 // this is useful in test programs and only there
65 #ifndef wxUSE_LONGLONG_NATIVE
66 #define wxUSE_LONGLONG_NATIVE 0
67 #endif
68
69 class WXDLLIMPEXP_FWD_BASE wxLongLongWx;
70 class WXDLLIMPEXP_FWD_BASE wxULongLongWx;
71 #if defined(__VISUALC__) && !defined(__WIN32__)
72 #define wxLongLong wxLongLongWx
73 #define wxULongLong wxULongLongWx
74 #else
75 typedef wxLongLongWx wxLongLong;
76 typedef wxULongLongWx wxULongLong;
77 #endif
78
79 #else
80 // if nothing is defined, use native implementation by default, of course
81 #ifndef wxUSE_LONGLONG_NATIVE
82 #define wxUSE_LONGLONG_NATIVE 1
83 #endif
84 #endif
85
86 #ifndef wxUSE_LONGLONG_WX
87 #define wxUSE_LONGLONG_WX 0
88 class WXDLLIMPEXP_FWD_BASE wxLongLongNative;
89 class WXDLLIMPEXP_FWD_BASE wxULongLongNative;
90 typedef wxLongLongNative wxLongLong;
91 typedef wxULongLongNative wxULongLong;
92 #endif
93
94 // NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should
95 // typedef wxLongLong as it wants, we don't do it
96
97 // ----------------------------------------------------------------------------
98 // choose the appropriate class
99 // ----------------------------------------------------------------------------
100
101 // we use iostream for wxLongLong output
102 #include "wx/iosfwrap.h"
103
104 #if wxUSE_LONGLONG_NATIVE
105
106 class WXDLLIMPEXP_BASE wxLongLongNative
107 {
108 public:
109 // ctors
110 // default ctor initializes to 0
111 wxLongLongNative() : m_ll(0) { }
112 // from long long
113 wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { }
114 // from 2 longs
115 wxLongLongNative(wxInt32 hi, wxUint32 lo)
116 {
117 // cast to wxLongLong_t first to avoid precision loss!
118 m_ll = ((wxLongLong_t) hi) << 32;
119 m_ll |= (wxLongLong_t) lo;
120 }
121 #if wxUSE_LONGLONG_WX
122 wxLongLongNative(wxLongLongWx ll);
123 #endif
124
125 // default copy ctor is ok
126
127 // no dtor
128
129 // assignment operators
130 // from native 64 bit integer
131 #ifndef wxLongLongIsLong
132 wxLongLongNative& operator=(wxLongLong_t ll)
133 { m_ll = ll; return *this; }
134 wxLongLongNative& operator=(wxULongLong_t ll)
135 { m_ll = ll; return *this; }
136 #endif // !wxLongLongNative
137 wxLongLongNative& operator=(const wxULongLongNative &ll);
138 wxLongLongNative& operator=(int l)
139 { m_ll = l; return *this; }
140 wxLongLongNative& operator=(long l)
141 { m_ll = l; return *this; }
142 wxLongLongNative& operator=(unsigned int l)
143 { m_ll = l; return *this; }
144 wxLongLongNative& operator=(unsigned long l)
145 { m_ll = l; return *this; }
146 #if wxUSE_LONGLONG_WX
147 wxLongLongNative& operator=(wxLongLongWx ll);
148 wxLongLongNative& operator=(const class wxULongLongWx &ll);
149 #endif
150
151
152 // from double: this one has an explicit name because otherwise we
153 // would have ambiguity with "ll = int" and also because we don't want
154 // to have implicit conversions between doubles and wxLongLongs
155 wxLongLongNative& Assign(double d)
156 { m_ll = (wxLongLong_t)d; return *this; }
157
158 // assignment operators from wxLongLongNative is ok
159
160 // accessors
161 // get high part
162 wxInt32 GetHi() const
163 { return wx_truncate_cast(wxInt32, m_ll >> 32); }
164 // get low part
165 wxUint32 GetLo() const
166 { return wx_truncate_cast(wxUint32, m_ll); }
167
168 // get absolute value
169 wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }
170 wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
171
172 // convert to native long long
173 wxLongLong_t GetValue() const { return m_ll; }
174
175 // convert to long with range checking in debug mode (only!)
176 long ToLong() const
177 {
178 wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX),
179 wxT("wxLongLong to long conversion loss of precision") );
180
181 return wx_truncate_cast(long, m_ll);
182 }
183
184 // convert to double
185 double ToDouble() const { return wx_truncate_cast(double, m_ll); }
186
187 // don't provide implicit conversion to wxLongLong_t or we will have an
188 // ambiguity for all arithmetic operations
189 //operator wxLongLong_t() const { return m_ll; }
190
191 // operations
192 // addition
193 wxLongLongNative operator+(const wxLongLongNative& ll) const
194 { return wxLongLongNative(m_ll + ll.m_ll); }
195 wxLongLongNative& operator+=(const wxLongLongNative& ll)
196 { m_ll += ll.m_ll; return *this; }
197
198 wxLongLongNative operator+(const wxLongLong_t ll) const
199 { return wxLongLongNative(m_ll + ll); }
200 wxLongLongNative& operator+=(const wxLongLong_t ll)
201 { m_ll += ll; return *this; }
202
203 // pre increment
204 wxLongLongNative& operator++()
205 { m_ll++; return *this; }
206
207 // post increment
208 wxLongLongNative operator++(int)
209 { wxLongLongNative value(*this); m_ll++; return value; }
210
211 // negation operator
212 wxLongLongNative operator-() const
213 { return wxLongLongNative(-m_ll); }
214 wxLongLongNative& Negate() { m_ll = -m_ll; return *this; }
215
216 // subtraction
217 wxLongLongNative operator-(const wxLongLongNative& ll) const
218 { return wxLongLongNative(m_ll - ll.m_ll); }
219 wxLongLongNative& operator-=(const wxLongLongNative& ll)
220 { m_ll -= ll.m_ll; return *this; }
221
222 wxLongLongNative operator-(const wxLongLong_t ll) const
223 { return wxLongLongNative(m_ll - ll); }
224 wxLongLongNative& operator-=(const wxLongLong_t ll)
225 { m_ll -= ll; return *this; }
226
227 // pre decrement
228 wxLongLongNative& operator--()
229 { m_ll--; return *this; }
230
231 // post decrement
232 wxLongLongNative operator--(int)
233 { wxLongLongNative value(*this); m_ll--; return value; }
234
235 // shifts
236 // left shift
237 wxLongLongNative operator<<(int shift) const
238 { return wxLongLongNative(m_ll << shift); }
239 wxLongLongNative& operator<<=(int shift)
240 { m_ll <<= shift; return *this; }
241
242 // right shift
243 wxLongLongNative operator>>(int shift) const
244 { return wxLongLongNative(m_ll >> shift); }
245 wxLongLongNative& operator>>=(int shift)
246 { m_ll >>= shift; return *this; }
247
248 // bitwise operators
249 wxLongLongNative operator&(const wxLongLongNative& ll) const
250 { return wxLongLongNative(m_ll & ll.m_ll); }
251 wxLongLongNative& operator&=(const wxLongLongNative& ll)
252 { m_ll &= ll.m_ll; return *this; }
253
254 wxLongLongNative operator|(const wxLongLongNative& ll) const
255 { return wxLongLongNative(m_ll | ll.m_ll); }
256 wxLongLongNative& operator|=(const wxLongLongNative& ll)
257 { m_ll |= ll.m_ll; return *this; }
258
259 wxLongLongNative operator^(const wxLongLongNative& ll) const
260 { return wxLongLongNative(m_ll ^ ll.m_ll); }
261 wxLongLongNative& operator^=(const wxLongLongNative& ll)
262 { m_ll ^= ll.m_ll; return *this; }
263
264 // multiplication/division
265 wxLongLongNative operator*(const wxLongLongNative& ll) const
266 { return wxLongLongNative(m_ll * ll.m_ll); }
267 wxLongLongNative operator*(long l) const
268 { return wxLongLongNative(m_ll * l); }
269 wxLongLongNative& operator*=(const wxLongLongNative& ll)
270 { m_ll *= ll.m_ll; return *this; }
271 wxLongLongNative& operator*=(long l)
272 { m_ll *= l; return *this; }
273
274 wxLongLongNative operator/(const wxLongLongNative& ll) const
275 { return wxLongLongNative(m_ll / ll.m_ll); }
276 wxLongLongNative operator/(long l) const
277 { return wxLongLongNative(m_ll / l); }
278 wxLongLongNative& operator/=(const wxLongLongNative& ll)
279 { m_ll /= ll.m_ll; return *this; }
280 wxLongLongNative& operator/=(long l)
281 { m_ll /= l; return *this; }
282
283 wxLongLongNative operator%(const wxLongLongNative& ll) const
284 { return wxLongLongNative(m_ll % ll.m_ll); }
285 wxLongLongNative operator%(long l) const
286 { return wxLongLongNative(m_ll % l); }
287
288 // comparison
289 bool operator==(const wxLongLongNative& ll) const
290 { return m_ll == ll.m_ll; }
291 bool operator==(long l) const
292 { return m_ll == l; }
293 bool operator!=(const wxLongLongNative& ll) const
294 { return m_ll != ll.m_ll; }
295 bool operator!=(long l) const
296 { return m_ll != l; }
297 bool operator<(const wxLongLongNative& ll) const
298 { return m_ll < ll.m_ll; }
299 bool operator<(long l) const
300 { return m_ll < l; }
301 bool operator>(const wxLongLongNative& ll) const
302 { return m_ll > ll.m_ll; }
303 bool operator>(long l) const
304 { return m_ll > l; }
305 bool operator<=(const wxLongLongNative& ll) const
306 { return m_ll <= ll.m_ll; }
307 bool operator<=(long l) const
308 { return m_ll <= l; }
309 bool operator>=(const wxLongLongNative& ll) const
310 { return m_ll >= ll.m_ll; }
311 bool operator>=(long l) const
312 { return m_ll >= l; }
313
314 // miscellaneous
315
316 // return the string representation of this number
317 wxString ToString() const;
318
319 // conversion to byte array: returns a pointer to static buffer!
320 void *asArray() const;
321
322 #if wxUSE_STD_IOSTREAM
323 // input/output
324 friend WXDLLIMPEXP_BASE
325 wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);
326 #endif
327
328 friend WXDLLIMPEXP_BASE
329 wxString& operator<<(wxString&, const wxLongLongNative&);
330
331 #if wxUSE_STREAMS
332 friend WXDLLIMPEXP_BASE
333 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongNative&);
334 friend WXDLLIMPEXP_BASE
335 class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongNative&);
336 #endif
337
338 private:
339 wxLongLong_t m_ll;
340 };
341
342
343 class WXDLLIMPEXP_BASE wxULongLongNative
344 {
345 public:
346 // ctors
347 // default ctor initializes to 0
348 wxULongLongNative() : m_ll(0) { }
349 // from long long
350 wxULongLongNative(wxULongLong_t ll) : m_ll(ll) { }
351 // from 2 longs
352 wxULongLongNative(wxUint32 hi, wxUint32 lo) : m_ll(0)
353 {
354 // cast to wxLongLong_t first to avoid precision loss!
355 m_ll = ((wxULongLong_t) hi) << 32;
356 m_ll |= (wxULongLong_t) lo;
357 }
358
359 #if wxUSE_LONGLONG_WX
360 wxULongLongNative(const class wxULongLongWx &ll);
361 #endif
362
363 // default copy ctor is ok
364
365 // no dtor
366
367 // assignment operators
368 // from native 64 bit integer
369 #ifndef wxLongLongIsLong
370 wxULongLongNative& operator=(wxULongLong_t ll)
371 { m_ll = ll; return *this; }
372 wxULongLongNative& operator=(wxLongLong_t ll)
373 { m_ll = ll; return *this; }
374 #endif // !wxLongLongNative
375 wxULongLongNative& operator=(int l)
376 { m_ll = l; return *this; }
377 wxULongLongNative& operator=(long l)
378 { m_ll = l; return *this; }
379 wxULongLongNative& operator=(unsigned int l)
380 { m_ll = l; return *this; }
381 wxULongLongNative& operator=(unsigned long l)
382 { m_ll = l; return *this; }
383 wxULongLongNative& operator=(const wxLongLongNative &ll)
384 { m_ll = ll.GetValue(); return *this; }
385 #if wxUSE_LONGLONG_WX
386 wxULongLongNative& operator=(wxLongLongWx ll);
387 wxULongLongNative& operator=(const class wxULongLongWx &ll);
388 #endif
389
390 // assignment operators from wxULongLongNative is ok
391
392 // accessors
393 // get high part
394 wxUint32 GetHi() const
395 { return wx_truncate_cast(wxUint32, m_ll >> 32); }
396 // get low part
397 wxUint32 GetLo() const
398 { return wx_truncate_cast(wxUint32, m_ll); }
399
400 // convert to native ulong long
401 wxULongLong_t GetValue() const { return m_ll; }
402
403 // convert to ulong with range checking in debug mode (only!)
404 unsigned long ToULong() const
405 {
406 wxASSERT_MSG( m_ll <= ULONG_MAX,
407 wxT("wxULongLong to long conversion loss of precision") );
408
409 return wx_truncate_cast(unsigned long, m_ll);
410 }
411
412 // convert to double
413 //
414 // For some completely obscure reasons compiling the cast below with
415 // VC6 in DLL builds only (!) results in "error C2520: conversion from
416 // unsigned __int64 to double not implemented, use signed __int64" so
417 // we must use a different version for that compiler.
418 #ifdef __VISUALC6__
419 double ToDouble() const;
420 #else
421 double ToDouble() const { return wx_truncate_cast(double, m_ll); }
422 #endif
423
424 // operations
425 // addition
426 wxULongLongNative operator+(const wxULongLongNative& ll) const
427 { return wxULongLongNative(m_ll + ll.m_ll); }
428 wxULongLongNative& operator+=(const wxULongLongNative& ll)
429 { m_ll += ll.m_ll; return *this; }
430
431 wxULongLongNative operator+(const wxULongLong_t ll) const
432 { return wxULongLongNative(m_ll + ll); }
433 wxULongLongNative& operator+=(const wxULongLong_t ll)
434 { m_ll += ll; return *this; }
435
436 // pre increment
437 wxULongLongNative& operator++()
438 { m_ll++; return *this; }
439
440 // post increment
441 wxULongLongNative operator++(int)
442 { wxULongLongNative value(*this); m_ll++; return value; }
443
444 // subtraction
445 wxULongLongNative operator-(const wxULongLongNative& ll) const
446 { return wxULongLongNative(m_ll - ll.m_ll); }
447 wxULongLongNative& operator-=(const wxULongLongNative& ll)
448 { m_ll -= ll.m_ll; return *this; }
449
450 wxULongLongNative operator-(const wxULongLong_t ll) const
451 { return wxULongLongNative(m_ll - ll); }
452 wxULongLongNative& operator-=(const wxULongLong_t ll)
453 { m_ll -= ll; return *this; }
454
455 // pre decrement
456 wxULongLongNative& operator--()
457 { m_ll--; return *this; }
458
459 // post decrement
460 wxULongLongNative operator--(int)
461 { wxULongLongNative value(*this); m_ll--; return value; }
462
463 // shifts
464 // left shift
465 wxULongLongNative operator<<(int shift) const
466 { return wxULongLongNative(m_ll << shift); }
467 wxULongLongNative& operator<<=(int shift)
468 { m_ll <<= shift; return *this; }
469
470 // right shift
471 wxULongLongNative operator>>(int shift) const
472 { return wxULongLongNative(m_ll >> shift); }
473 wxULongLongNative& operator>>=(int shift)
474 { m_ll >>= shift; return *this; }
475
476 // bitwise operators
477 wxULongLongNative operator&(const wxULongLongNative& ll) const
478 { return wxULongLongNative(m_ll & ll.m_ll); }
479 wxULongLongNative& operator&=(const wxULongLongNative& ll)
480 { m_ll &= ll.m_ll; return *this; }
481
482 wxULongLongNative operator|(const wxULongLongNative& ll) const
483 { return wxULongLongNative(m_ll | ll.m_ll); }
484 wxULongLongNative& operator|=(const wxULongLongNative& ll)
485 { m_ll |= ll.m_ll; return *this; }
486
487 wxULongLongNative operator^(const wxULongLongNative& ll) const
488 { return wxULongLongNative(m_ll ^ ll.m_ll); }
489 wxULongLongNative& operator^=(const wxULongLongNative& ll)
490 { m_ll ^= ll.m_ll; return *this; }
491
492 // multiplication/division
493 wxULongLongNative operator*(const wxULongLongNative& ll) const
494 { return wxULongLongNative(m_ll * ll.m_ll); }
495 wxULongLongNative operator*(unsigned long l) const
496 { return wxULongLongNative(m_ll * l); }
497 wxULongLongNative& operator*=(const wxULongLongNative& ll)
498 { m_ll *= ll.m_ll; return *this; }
499 wxULongLongNative& operator*=(unsigned long l)
500 { m_ll *= l; return *this; }
501
502 wxULongLongNative operator/(const wxULongLongNative& ll) const
503 { return wxULongLongNative(m_ll / ll.m_ll); }
504 wxULongLongNative operator/(unsigned long l) const
505 { return wxULongLongNative(m_ll / l); }
506 wxULongLongNative& operator/=(const wxULongLongNative& ll)
507 { m_ll /= ll.m_ll; return *this; }
508 wxULongLongNative& operator/=(unsigned long l)
509 { m_ll /= l; return *this; }
510
511 wxULongLongNative operator%(const wxULongLongNative& ll) const
512 { return wxULongLongNative(m_ll % ll.m_ll); }
513 wxULongLongNative operator%(unsigned long l) const
514 { return wxULongLongNative(m_ll % l); }
515
516 // comparison
517 bool operator==(const wxULongLongNative& ll) const
518 { return m_ll == ll.m_ll; }
519 bool operator==(unsigned long l) const
520 { return m_ll == l; }
521 bool operator!=(const wxULongLongNative& ll) const
522 { return m_ll != ll.m_ll; }
523 bool operator!=(unsigned long l) const
524 { return m_ll != l; }
525 bool operator<(const wxULongLongNative& ll) const
526 { return m_ll < ll.m_ll; }
527 bool operator<(unsigned long l) const
528 { return m_ll < l; }
529 bool operator>(const wxULongLongNative& ll) const
530 { return m_ll > ll.m_ll; }
531 bool operator>(unsigned long l) const
532 { return m_ll > l; }
533 bool operator<=(const wxULongLongNative& ll) const
534 { return m_ll <= ll.m_ll; }
535 bool operator<=(unsigned long l) const
536 { return m_ll <= l; }
537 bool operator>=(const wxULongLongNative& ll) const
538 { return m_ll >= ll.m_ll; }
539 bool operator>=(unsigned long l) const
540 { return m_ll >= l; }
541
542 // miscellaneous
543
544 // return the string representation of this number
545 wxString ToString() const;
546
547 // conversion to byte array: returns a pointer to static buffer!
548 void *asArray() const;
549
550 #if wxUSE_STD_IOSTREAM
551 // input/output
552 friend WXDLLIMPEXP_BASE
553 wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);
554 #endif
555
556 friend WXDLLIMPEXP_BASE
557 wxString& operator<<(wxString&, const wxULongLongNative&);
558
559 #if wxUSE_STREAMS
560 friend WXDLLIMPEXP_BASE
561 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongNative&);
562 friend WXDLLIMPEXP_BASE
563 class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongNative&);
564 #endif
565
566 private:
567 wxULongLong_t m_ll;
568 };
569
570 inline
571 wxLongLongNative& wxLongLongNative::operator=(const wxULongLongNative &ll)
572 {
573 m_ll = ll.GetValue();
574 return *this;
575 }
576
577 #endif // wxUSE_LONGLONG_NATIVE
578
579 #if wxUSE_LONGLONG_WX
580
581 class WXDLLIMPEXP_BASE wxLongLongWx
582 {
583 public:
584 // ctors
585 // default ctor initializes to 0
586 wxLongLongWx()
587 {
588 m_lo = m_hi = 0;
589
590 #ifdef wxLONGLONG_TEST_MODE
591 m_ll = 0;
592
593 Check();
594 #endif // wxLONGLONG_TEST_MODE
595 }
596 // from long
597 wxLongLongWx(long l) { *this = l; }
598 // from 2 longs
599 wxLongLongWx(long hi, unsigned long lo)
600 {
601 m_hi = hi;
602 m_lo = lo;
603
604 #ifdef wxLONGLONG_TEST_MODE
605 m_ll = hi;
606 m_ll <<= 32;
607 m_ll |= lo;
608
609 Check();
610 #endif // wxLONGLONG_TEST_MODE
611 }
612
613 // default copy ctor is ok in both cases
614
615 // no dtor
616
617 // assignment operators
618 // from long
619 wxLongLongWx& operator=(long l)
620 {
621 m_lo = l;
622 m_hi = (l < 0 ? -1l : 0l);
623
624 #ifdef wxLONGLONG_TEST_MODE
625 m_ll = l;
626
627 Check();
628 #endif // wxLONGLONG_TEST_MODE
629
630 return *this;
631 }
632 // from int
633 wxLongLongWx& operator=(int l)
634 {
635 return operator=((long)l);
636 }
637
638 wxLongLongWx& operator=(unsigned long l)
639 {
640 m_lo = l;
641 m_hi = 0;
642
643 #ifdef wxLONGLONG_TEST_MODE
644 m_ll = l;
645
646 Check();
647 #endif // wxLONGLONG_TEST_MODE
648
649 return *this;
650 }
651
652 wxLongLongWx& operator=(unsigned int l)
653 {
654 return operator=((unsigned long)l);
655 }
656
657 wxLongLongWx& operator=(const class wxULongLongWx &ll);
658
659 // from double
660 wxLongLongWx& Assign(double d);
661 // can't have assignment operator from 2 longs
662
663 // accessors
664 // get high part
665 long GetHi() const { return m_hi; }
666 // get low part
667 unsigned long GetLo() const { return m_lo; }
668
669 // get absolute value
670 wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
671 wxLongLongWx& Abs()
672 {
673 if ( m_hi < 0 )
674 m_hi = -m_hi;
675
676 #ifdef wxLONGLONG_TEST_MODE
677 if ( m_ll < 0 )
678 m_ll = -m_ll;
679
680 Check();
681 #endif // wxLONGLONG_TEST_MODE
682
683 return *this;
684 }
685
686 // convert to long with range checking in debug mode (only!)
687 long ToLong() const
688 {
689 wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l),
690 wxT("wxLongLong to long conversion loss of precision") );
691
692 return (long)m_lo;
693 }
694
695 // convert to double
696 double ToDouble() const;
697
698 // operations
699 // addition
700 wxLongLongWx operator+(const wxLongLongWx& ll) const;
701 wxLongLongWx& operator+=(const wxLongLongWx& ll);
702 wxLongLongWx operator+(long l) const;
703 wxLongLongWx& operator+=(long l);
704
705 // pre increment operator
706 wxLongLongWx& operator++();
707
708 // post increment operator
709 wxLongLongWx& operator++(int) { return ++(*this); }
710
711 // negation operator
712 wxLongLongWx operator-() const;
713 wxLongLongWx& Negate();
714
715 // subraction
716 wxLongLongWx operator-(const wxLongLongWx& ll) const;
717 wxLongLongWx& operator-=(const wxLongLongWx& ll);
718
719 // pre decrement operator
720 wxLongLongWx& operator--();
721
722 // post decrement operator
723 wxLongLongWx& operator--(int) { return --(*this); }
724
725 // shifts
726 // left shift
727 wxLongLongWx operator<<(int shift) const;
728 wxLongLongWx& operator<<=(int shift);
729
730 // right shift
731 wxLongLongWx operator>>(int shift) const;
732 wxLongLongWx& operator>>=(int shift);
733
734 // bitwise operators
735 wxLongLongWx operator&(const wxLongLongWx& ll) const;
736 wxLongLongWx& operator&=(const wxLongLongWx& ll);
737 wxLongLongWx operator|(const wxLongLongWx& ll) const;
738 wxLongLongWx& operator|=(const wxLongLongWx& ll);
739 wxLongLongWx operator^(const wxLongLongWx& ll) const;
740 wxLongLongWx& operator^=(const wxLongLongWx& ll);
741 wxLongLongWx operator~() const;
742
743 // comparison
744 bool operator==(const wxLongLongWx& ll) const
745 { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
746 #if wxUSE_LONGLONG_NATIVE
747 bool operator==(const wxLongLongNative& ll) const
748 { return m_lo == ll.GetLo() && m_hi == ll.GetHi(); }
749 #endif
750 bool operator!=(const wxLongLongWx& ll) const
751 { return !(*this == ll); }
752 bool operator<(const wxLongLongWx& ll) const;
753 bool operator>(const wxLongLongWx& ll) const;
754 bool operator<=(const wxLongLongWx& ll) const
755 { return *this < ll || *this == ll; }
756 bool operator>=(const wxLongLongWx& ll) const
757 { return *this > ll || *this == ll; }
758
759 bool operator<(long l) const { return *this < wxLongLongWx(l); }
760 bool operator>(long l) const { return *this > wxLongLongWx(l); }
761 bool operator==(long l) const
762 {
763 return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l)
764 : (m_hi == -1 && m_lo == (unsigned long)l);
765 }
766
767 bool operator<=(long l) const { return *this < l || *this == l; }
768 bool operator>=(long l) const { return *this > l || *this == l; }
769
770 // multiplication
771 wxLongLongWx operator*(const wxLongLongWx& ll) const;
772 wxLongLongWx& operator*=(const wxLongLongWx& ll);
773
774 // division
775 wxLongLongWx operator/(const wxLongLongWx& ll) const;
776 wxLongLongWx& operator/=(const wxLongLongWx& ll);
777
778 wxLongLongWx operator%(const wxLongLongWx& ll) const;
779
780 void Divide(const wxLongLongWx& divisor,
781 wxLongLongWx& quotient,
782 wxLongLongWx& remainder) const;
783
784 // input/output
785
786 // return the string representation of this number
787 wxString ToString() const;
788
789 void *asArray() const;
790
791 #if wxUSE_STD_IOSTREAM
792 friend WXDLLIMPEXP_BASE
793 wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);
794 #endif // wxUSE_STD_IOSTREAM
795
796 friend WXDLLIMPEXP_BASE
797 wxString& operator<<(wxString&, const wxLongLongWx&);
798
799 #if wxUSE_STREAMS
800 friend WXDLLIMPEXP_BASE
801 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxLongLongWx&);
802 friend WXDLLIMPEXP_BASE
803 class wxTextInputStream& operator>>(class wxTextInputStream&, wxLongLongWx&);
804 #endif
805
806 private:
807 // long is at least 32 bits, so represent our 64bit number as 2 longs
808
809 long m_hi; // signed bit is in the high part
810 unsigned long m_lo;
811
812 #ifdef wxLONGLONG_TEST_MODE
813 void Check()
814 {
815 wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
816 }
817
818 wxLongLong_t m_ll;
819 #endif // wxLONGLONG_TEST_MODE
820 };
821
822
823 class WXDLLIMPEXP_BASE wxULongLongWx
824 {
825 public:
826 // ctors
827 // default ctor initializes to 0
828 wxULongLongWx()
829 {
830 m_lo = m_hi = 0;
831
832 #ifdef wxLONGLONG_TEST_MODE
833 m_ll = 0;
834
835 Check();
836 #endif // wxLONGLONG_TEST_MODE
837 }
838 // from ulong
839 wxULongLongWx(unsigned long l) { *this = l; }
840 // from 2 ulongs
841 wxULongLongWx(unsigned long hi, unsigned long lo)
842 {
843 m_hi = hi;
844 m_lo = lo;
845
846 #ifdef wxLONGLONG_TEST_MODE
847 m_ll = hi;
848 m_ll <<= 32;
849 m_ll |= lo;
850
851 Check();
852 #endif // wxLONGLONG_TEST_MODE
853 }
854
855 // from signed to unsigned
856 wxULongLongWx(wxLongLongWx ll)
857 {
858 wxASSERT(ll.GetHi() >= 0);
859 m_hi = (unsigned long)ll.GetHi();
860 m_lo = ll.GetLo();
861 }
862
863 // default copy ctor is ok in both cases
864
865 // no dtor
866
867 // assignment operators
868 // from long
869 wxULongLongWx& operator=(unsigned long l)
870 {
871 m_lo = l;
872 m_hi = 0;
873
874 #ifdef wxLONGLONG_TEST_MODE
875 m_ll = l;
876
877 Check();
878 #endif // wxLONGLONG_TEST_MODE
879
880 return *this;
881 }
882 wxULongLongWx& operator=(long l)
883 {
884 m_lo = l;
885 m_hi = (unsigned long) ((l<0) ? -1l : 0);
886
887 #ifdef wxLONGLONG_TEST_MODE
888 m_ll = (wxULongLong_t) (wxLongLong_t) l;
889
890 Check();
891 #endif // wxLONGLONG_TEST_MODE
892
893 return *this;
894 }
895 wxULongLongWx& operator=(const class wxLongLongWx &ll) {
896 // Should we use an assert like it was before in the constructor?
897 // wxASSERT(ll.GetHi() >= 0);
898 m_hi = (unsigned long)ll.GetHi();
899 m_lo = ll.GetLo();
900 return *this;
901 }
902
903 // can't have assignment operator from 2 longs
904
905 // accessors
906 // get high part
907 unsigned long GetHi() const { return m_hi; }
908 // get low part
909 unsigned long GetLo() const { return m_lo; }
910
911 // convert to long with range checking in debug mode (only!)
912 unsigned long ToULong() const
913 {
914 wxASSERT_MSG( m_hi == 0ul,
915 wxT("wxULongLong to long conversion loss of precision") );
916
917 return (unsigned long)m_lo;
918 }
919
920 // convert to double
921 double ToDouble() const;
922
923 // operations
924 // addition
925 wxULongLongWx operator+(const wxULongLongWx& ll) const;
926 wxULongLongWx& operator+=(const wxULongLongWx& ll);
927 wxULongLongWx operator+(unsigned long l) const;
928 wxULongLongWx& operator+=(unsigned long l);
929
930 // pre increment operator
931 wxULongLongWx& operator++();
932
933 // post increment operator
934 wxULongLongWx& operator++(int) { return ++(*this); }
935
936 // subtraction
937 wxLongLongWx operator-(const wxULongLongWx& ll) const;
938 wxULongLongWx& operator-=(const wxULongLongWx& ll);
939
940 // pre decrement operator
941 wxULongLongWx& operator--();
942
943 // post decrement operator
944 wxULongLongWx& operator--(int) { return --(*this); }
945
946 // shifts
947 // left shift
948 wxULongLongWx operator<<(int shift) const;
949 wxULongLongWx& operator<<=(int shift);
950
951 // right shift
952 wxULongLongWx operator>>(int shift) const;
953 wxULongLongWx& operator>>=(int shift);
954
955 // bitwise operators
956 wxULongLongWx operator&(const wxULongLongWx& ll) const;
957 wxULongLongWx& operator&=(const wxULongLongWx& ll);
958 wxULongLongWx operator|(const wxULongLongWx& ll) const;
959 wxULongLongWx& operator|=(const wxULongLongWx& ll);
960 wxULongLongWx operator^(const wxULongLongWx& ll) const;
961 wxULongLongWx& operator^=(const wxULongLongWx& ll);
962 wxULongLongWx operator~() const;
963
964 // comparison
965 bool operator==(const wxULongLongWx& ll) const
966 { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
967 bool operator!=(const wxULongLongWx& ll) const
968 { return !(*this == ll); }
969 bool operator<(const wxULongLongWx& ll) const;
970 bool operator>(const wxULongLongWx& ll) const;
971 bool operator<=(const wxULongLongWx& ll) const
972 { return *this < ll || *this == ll; }
973 bool operator>=(const wxULongLongWx& ll) const
974 { return *this > ll || *this == ll; }
975
976 bool operator<(unsigned long l) const { return *this < wxULongLongWx(l); }
977 bool operator>(unsigned long l) const { return *this > wxULongLongWx(l); }
978 bool operator==(unsigned long l) const
979 {
980 return (m_hi == 0 && m_lo == (unsigned long)l);
981 }
982
983 bool operator<=(unsigned long l) const { return *this < l || *this == l; }
984 bool operator>=(unsigned long l) const { return *this > l || *this == l; }
985
986 // multiplication
987 wxULongLongWx operator*(const wxULongLongWx& ll) const;
988 wxULongLongWx& operator*=(const wxULongLongWx& ll);
989
990 // division
991 wxULongLongWx operator/(const wxULongLongWx& ll) const;
992 wxULongLongWx& operator/=(const wxULongLongWx& ll);
993
994 wxULongLongWx operator%(const wxULongLongWx& ll) const;
995
996 void Divide(const wxULongLongWx& divisor,
997 wxULongLongWx& quotient,
998 wxULongLongWx& remainder) const;
999
1000 // input/output
1001
1002 // return the string representation of this number
1003 wxString ToString() const;
1004
1005 void *asArray() const;
1006
1007 #if wxUSE_STD_IOSTREAM
1008 friend WXDLLIMPEXP_BASE
1009 wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);
1010 #endif // wxUSE_STD_IOSTREAM
1011
1012 friend WXDLLIMPEXP_BASE
1013 wxString& operator<<(wxString&, const wxULongLongWx&);
1014
1015 #if wxUSE_STREAMS
1016 friend WXDLLIMPEXP_BASE
1017 class wxTextOutputStream& operator<<(class wxTextOutputStream&, const wxULongLongWx&);
1018 friend WXDLLIMPEXP_BASE
1019 class wxTextInputStream& operator>>(class wxTextInputStream&, wxULongLongWx&);
1020 #endif
1021
1022 private:
1023 // long is at least 32 bits, so represent our 64bit number as 2 longs
1024
1025 unsigned long m_hi;
1026 unsigned long m_lo;
1027
1028 #ifdef wxLONGLONG_TEST_MODE
1029 void Check()
1030 {
1031 wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
1032 }
1033
1034 wxULongLong_t m_ll;
1035 #endif // wxLONGLONG_TEST_MODE
1036 };
1037
1038 #endif // wxUSE_LONGLONG_WX
1039
1040 // ----------------------------------------------------------------------------
1041 // binary operators
1042 // ----------------------------------------------------------------------------
1043
1044 inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }
1045 inline bool operator>(long l, const wxLongLong& ll) { return ll < l; }
1046 inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
1047 inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
1048 inline bool operator==(long l, const wxLongLong& ll) { return ll == l; }
1049 inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; }
1050
1051 inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; }
1052 inline wxLongLong operator-(long l, const wxLongLong& ll)
1053 {
1054 return wxLongLong(l) - ll;
1055 }
1056
1057 inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
1058 inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
1059 inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
1060 inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
1061 inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
1062 inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }
1063
1064 inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
1065
1066 inline wxLongLong operator-(unsigned long l, const wxULongLong& ull)
1067 {
1068 wxULongLong ret = wxULongLong(l) - ull;
1069 return wxLongLong((wxInt32)ret.GetHi(),ret.GetLo());
1070 }
1071
1072 #if wxUSE_LONGLONG_NATIVE && wxUSE_STREAMS
1073
1074 WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxULongLong_t value);
1075 WXDLLIMPEXP_BASE class wxTextOutputStream &operator<<(class wxTextOutputStream &stream, wxLongLong_t value);
1076
1077 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxULongLong_t &value);
1078 WXDLLIMPEXP_BASE class wxTextInputStream &operator>>(class wxTextInputStream &stream, wxLongLong_t &value);
1079
1080 #endif
1081
1082 // ----------------------------------------------------------------------------
1083 // Specialize numeric_limits<> for our long long wrapper classes.
1084 // ----------------------------------------------------------------------------
1085
1086 #if wxUSE_LONGLONG_NATIVE
1087
1088 // VC6 is known to not have __int64 specializations of numeric_limits<> in its
1089 // <limits> anyhow so don't bother including it, especially as it results in
1090 // tons of warnings because the standard header itself uses obsolete template
1091 // specialization syntax.
1092 #ifndef __VISUALC6__
1093
1094 #include <limits>
1095
1096 namespace std
1097 {
1098
1099 #ifdef __clang__
1100 // libstdc++ (used by Clang) uses struct for numeric_limits; unlike gcc, clang
1101 // warns about this
1102 template<> struct numeric_limits<wxLongLong> : public numeric_limits<wxLongLong_t> {};
1103 template<> struct numeric_limits<wxULongLong> : public numeric_limits<wxULongLong_t> {};
1104 #else
1105 template<> class numeric_limits<wxLongLong> : public numeric_limits<wxLongLong_t> {};
1106 template<> class numeric_limits<wxULongLong> : public numeric_limits<wxULongLong_t> {};
1107 #endif
1108
1109 } // namespace std
1110
1111 #endif // !VC6
1112
1113 #endif // wxUSE_LONGLONG_NATIVE
1114
1115 // ----------------------------------------------------------------------------
1116 // Specialize wxArgNormalizer to allow using wxLongLong directly with wx pseudo
1117 // vararg functions.
1118 // ----------------------------------------------------------------------------
1119
1120 // Notice that this must be done here and not in wx/strvararg.h itself because
1121 // we can't include wx/longlong.h from there as this header itself includes
1122 // wx/string.h which includes wx/strvararg.h too, so to avoid the circular
1123 // dependencies we can only do it here (or add another header just for this but
1124 // it doesn't seem necessary).
1125 #include "wx/strvararg.h"
1126
1127 template<>
1128 struct WXDLLIMPEXP_BASE wxArgNormalizer<wxLongLong>
1129 {
1130 wxArgNormalizer(wxLongLong value,
1131 const wxFormatString *fmt, unsigned index)
1132 : m_value(value)
1133 {
1134 wxASSERT_ARG_TYPE( fmt, index, wxFormatString::Arg_LongLongInt );
1135 }
1136
1137 wxLongLong_t get() const { return m_value.GetValue(); }
1138
1139 wxLongLong m_value;
1140 };
1141
1142 #endif // wxUSE_LONGLONG
1143
1144 #endif // _WX_LONGLONG_H
wxWidgets (Impactor)