]>
Commit | Line | Data |
---|---|---|
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 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
10 | // Licence: wxWindows licence | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | #ifndef _WX_LONGLONG_H | |
14 | #define _WX_LONGLONG_H | |
15 | ||
16 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) | |
17 | #pragma interface "longlong.h" | |
18 | #endif | |
19 | ||
20 | #include "wx/defs.h" | |
21 | #include "wx/string.h" | |
22 | ||
23 | #include <limits.h> // for LONG_MAX | |
24 | ||
25 | // define this to compile wxLongLongWx in "test" mode: the results of all | |
26 | // calculations will be compared with the real results taken from | |
27 | // wxLongLongNative -- this is extremely useful to find the bugs in | |
28 | // wxLongLongWx class! | |
29 | ||
30 | // #define wxLONGLONG_TEST_MODE | |
31 | ||
32 | #ifdef wxLONGLONG_TEST_MODE | |
33 | #define wxUSE_LONGLONG_WX 1 | |
34 | #define wxUSE_LONGLONG_NATIVE 1 | |
35 | #endif // wxLONGLONG_TEST_MODE | |
36 | ||
37 | // ---------------------------------------------------------------------------- | |
38 | // decide upon which class we will use | |
39 | // ---------------------------------------------------------------------------- | |
40 | ||
41 | #ifndef wxLongLong_t | |
42 | // both warning and pragma warning are not portable, but at least an | |
43 | // unknown pragma should never be an error -- except that, actually, some | |
44 | // broken compilers don't like it, so we have to disable it in this case | |
45 | // <sigh> | |
46 | #if !(defined(__WATCOMC__) || defined(__VISAGECPP__)) | |
47 | #pragma warning "Your compiler does not appear to support 64 bit "\ | |
48 | "integers, using emulation class instead.\n" \ | |
49 | "Please report your compiler version to " \ | |
50 | "wx-dev@lists.wxwidgets.org!" | |
51 | #endif | |
52 | ||
53 | #define wxUSE_LONGLONG_WX 1 | |
54 | #endif // compiler | |
55 | ||
56 | // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE | |
57 | // to disable automatic testing (useful for the test program which defines | |
58 | // both classes) but by default we only use one class | |
59 | #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t) | |
60 | // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set: | |
61 | // this is useful in test programs and only there | |
62 | #ifndef wxUSE_LONGLONG_NATIVE | |
63 | #define wxUSE_LONGLONG_NATIVE 0 | |
64 | #endif | |
65 | ||
66 | class WXDLLIMPEXP_BASE wxLongLongWx; | |
67 | class WXDLLIMPEXP_BASE wxULongLongWx; | |
68 | #if defined(__VISUALC__) && !defined(__WIN32__) | |
69 | #define wxLongLong wxLongLongWx | |
70 | #define wxULongLong wxULongLongWx | |
71 | #else | |
72 | typedef wxLongLongWx wxLongLong; | |
73 | typedef wxULongLongWx wxULongLong; | |
74 | #endif | |
75 | ||
76 | #else | |
77 | // if nothing is defined, use native implementation by default, of course | |
78 | #ifndef wxUSE_LONGLONG_NATIVE | |
79 | #define wxUSE_LONGLONG_NATIVE 1 | |
80 | #endif | |
81 | #endif | |
82 | ||
83 | #ifndef wxUSE_LONGLONG_WX | |
84 | #define wxUSE_LONGLONG_WX 0 | |
85 | class WXDLLIMPEXP_BASE wxLongLongNative; | |
86 | class WXDLLIMPEXP_BASE wxULongLongNative; | |
87 | typedef wxLongLongNative wxLongLong; | |
88 | typedef wxULongLongNative wxULongLong; | |
89 | #endif | |
90 | ||
91 | // NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should | |
92 | // typedef wxLongLong as it wants, we don't do it | |
93 | ||
94 | // ---------------------------------------------------------------------------- | |
95 | // choose the appropriate class | |
96 | // ---------------------------------------------------------------------------- | |
97 | ||
98 | // we use iostream for wxLongLong output | |
99 | #include "wx/iosfwrap.h" | |
100 | ||
101 | #if wxUSE_LONGLONG_NATIVE | |
102 | ||
103 | class WXDLLIMPEXP_BASE wxLongLongNative | |
104 | { | |
105 | public: | |
106 | // ctors | |
107 | // default ctor initializes to 0 | |
108 | wxLongLongNative() : m_ll(0) { } | |
109 | // from long long | |
110 | wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { } | |
111 | // from 2 longs | |
112 | wxLongLongNative(long hi, unsigned long lo) : m_ll(0) | |
113 | { | |
114 | // assign first to avoid precision loss! | |
115 | m_ll = ((wxLongLong_t) hi) << 32; | |
116 | m_ll |= (wxLongLong_t) lo; | |
117 | } | |
118 | ||
119 | // default copy ctor is ok | |
120 | ||
121 | // no dtor | |
122 | ||
123 | // assignment operators | |
124 | // from native 64 bit integer | |
125 | wxLongLongNative& operator=(wxLongLong_t ll) | |
126 | { m_ll = ll; return *this; } | |
127 | ||
128 | // from double: this one has an explicit name because otherwise we | |
129 | // would have ambiguity with "ll = int" and also because we don't want | |
130 | // to have implicit conversions between doubles and wxLongLongs | |
131 | wxLongLongNative& Assign(double d) | |
132 | { m_ll = (wxLongLong_t)d; return *this; } | |
133 | ||
134 | // assignment operators from wxLongLongNative is ok | |
135 | ||
136 | // accessors | |
137 | // get high part | |
138 | long GetHi() const | |
139 | { return (long)(m_ll >> 32); } | |
140 | // get low part | |
141 | unsigned long GetLo() const | |
142 | { return (unsigned long)m_ll; } | |
143 | ||
144 | // get absolute value | |
145 | wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); } | |
146 | wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; } | |
147 | ||
148 | // convert to native long long | |
149 | wxLongLong_t GetValue() const { return m_ll; } | |
150 | ||
151 | // convert to long with range checking in the debug mode (only!) | |
152 | long ToLong() const | |
153 | { | |
154 | wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX), | |
155 | _T("wxLongLong to long conversion loss of precision") ); | |
156 | ||
157 | return (long)m_ll; | |
158 | } | |
159 | ||
160 | // don't provide implicit conversion to wxLongLong_t or we will have an | |
161 | // ambiguity for all arithmetic operations | |
162 | //operator wxLongLong_t() const { return m_ll; } | |
163 | ||
164 | // operations | |
165 | // addition | |
166 | wxLongLongNative operator+(const wxLongLongNative& ll) const | |
167 | { return wxLongLongNative(m_ll + ll.m_ll); } | |
168 | wxLongLongNative& operator+=(const wxLongLongNative& ll) | |
169 | { m_ll += ll.m_ll; return *this; } | |
170 | ||
171 | wxLongLongNative operator+(const wxLongLong_t ll) const | |
172 | { return wxLongLongNative(m_ll + ll); } | |
173 | wxLongLongNative& operator+=(const wxLongLong_t ll) | |
174 | { m_ll += ll; return *this; } | |
175 | ||
176 | // pre increment | |
177 | wxLongLongNative& operator++() | |
178 | { m_ll++; return *this; } | |
179 | ||
180 | // post increment | |
181 | wxLongLongNative operator++(int) | |
182 | { wxLongLongNative value(*this); m_ll++; return value; } | |
183 | ||
184 | // negation operator | |
185 | wxLongLongNative operator-() const | |
186 | { return wxLongLongNative(-m_ll); } | |
187 | wxLongLongNative& Negate() { m_ll = -m_ll; return *this; } | |
188 | ||
189 | // subtraction | |
190 | wxLongLongNative operator-(const wxLongLongNative& ll) const | |
191 | { return wxLongLongNative(m_ll - ll.m_ll); } | |
192 | wxLongLongNative& operator-=(const wxLongLongNative& ll) | |
193 | { m_ll -= ll.m_ll; return *this; } | |
194 | ||
195 | wxLongLongNative operator-(const wxLongLong_t ll) const | |
196 | { return wxLongLongNative(m_ll - ll); } | |
197 | wxLongLongNative& operator-=(const wxLongLong_t ll) | |
198 | { m_ll -= ll; return *this; } | |
199 | ||
200 | // pre decrement | |
201 | wxLongLongNative& operator--() | |
202 | { m_ll--; return *this; } | |
203 | ||
204 | // post decrement | |
205 | wxLongLongNative operator--(int) | |
206 | { wxLongLongNative value(*this); m_ll--; return value; } | |
207 | ||
208 | // shifts | |
209 | // left shift | |
210 | wxLongLongNative operator<<(int shift) const | |
211 | { return wxLongLongNative(m_ll << shift);; } | |
212 | wxLongLongNative& operator<<=(int shift) | |
213 | { m_ll <<= shift; return *this; } | |
214 | ||
215 | // right shift | |
216 | wxLongLongNative operator>>(int shift) const | |
217 | { return wxLongLongNative(m_ll >> shift);; } | |
218 | wxLongLongNative& operator>>=(int shift) | |
219 | { m_ll >>= shift; return *this; } | |
220 | ||
221 | // bitwise operators | |
222 | wxLongLongNative operator&(const wxLongLongNative& ll) const | |
223 | { return wxLongLongNative(m_ll & ll.m_ll); } | |
224 | wxLongLongNative& operator&=(const wxLongLongNative& ll) | |
225 | { m_ll &= ll.m_ll; return *this; } | |
226 | ||
227 | wxLongLongNative operator|(const wxLongLongNative& ll) const | |
228 | { return wxLongLongNative(m_ll | ll.m_ll); } | |
229 | wxLongLongNative& operator|=(const wxLongLongNative& ll) | |
230 | { m_ll |= ll.m_ll; return *this; } | |
231 | ||
232 | wxLongLongNative operator^(const wxLongLongNative& ll) const | |
233 | { return wxLongLongNative(m_ll ^ ll.m_ll); } | |
234 | wxLongLongNative& operator^=(const wxLongLongNative& ll) | |
235 | { m_ll ^= ll.m_ll; return *this; } | |
236 | ||
237 | // multiplication/division | |
238 | wxLongLongNative operator*(const wxLongLongNative& ll) const | |
239 | { return wxLongLongNative(m_ll * ll.m_ll); } | |
240 | wxLongLongNative operator*(long l) const | |
241 | { return wxLongLongNative(m_ll * l); } | |
242 | wxLongLongNative& operator*=(const wxLongLongNative& ll) | |
243 | { m_ll *= ll.m_ll; return *this; } | |
244 | wxLongLongNative& operator*=(long l) | |
245 | { m_ll *= l; return *this; } | |
246 | ||
247 | wxLongLongNative operator/(const wxLongLongNative& ll) const | |
248 | { return wxLongLongNative(m_ll / ll.m_ll); } | |
249 | wxLongLongNative operator/(long l) const | |
250 | { return wxLongLongNative(m_ll / l); } | |
251 | wxLongLongNative& operator/=(const wxLongLongNative& ll) | |
252 | { m_ll /= ll.m_ll; return *this; } | |
253 | wxLongLongNative& operator/=(long l) | |
254 | { m_ll /= l; return *this; } | |
255 | ||
256 | wxLongLongNative operator%(const wxLongLongNative& ll) const | |
257 | { return wxLongLongNative(m_ll % ll.m_ll); } | |
258 | wxLongLongNative operator%(long l) const | |
259 | { return wxLongLongNative(m_ll % l); } | |
260 | ||
261 | // comparison | |
262 | bool operator==(const wxLongLongNative& ll) const | |
263 | { return m_ll == ll.m_ll; } | |
264 | bool operator==(long l) const | |
265 | { return m_ll == l; } | |
266 | bool operator!=(const wxLongLongNative& ll) const | |
267 | { return m_ll != ll.m_ll; } | |
268 | bool operator!=(long l) const | |
269 | { return m_ll != l; } | |
270 | bool operator<(const wxLongLongNative& ll) const | |
271 | { return m_ll < ll.m_ll; } | |
272 | bool operator<(long l) const | |
273 | { return m_ll < l; } | |
274 | bool operator>(const wxLongLongNative& ll) const | |
275 | { return m_ll > ll.m_ll; } | |
276 | bool operator>(long l) const | |
277 | { return m_ll > l; } | |
278 | bool operator<=(const wxLongLongNative& ll) const | |
279 | { return m_ll <= ll.m_ll; } | |
280 | bool operator<=(long l) const | |
281 | { return m_ll <= l; } | |
282 | bool operator>=(const wxLongLongNative& ll) const | |
283 | { return m_ll >= ll.m_ll; } | |
284 | bool operator>=(long l) const | |
285 | { return m_ll >= l; } | |
286 | ||
287 | // miscellaneous | |
288 | ||
289 | // return the string representation of this number | |
290 | wxString ToString() const; | |
291 | ||
292 | // conversion to byte array: returns a pointer to static buffer! | |
293 | void *asArray() const; | |
294 | ||
295 | #if wxUSE_STD_IOSTREAM | |
296 | // input/output | |
297 | friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&); | |
298 | #endif | |
299 | ||
300 | private: | |
301 | wxLongLong_t m_ll; | |
302 | }; | |
303 | ||
304 | ||
305 | class WXDLLIMPEXP_BASE wxULongLongNative | |
306 | { | |
307 | public: | |
308 | // ctors | |
309 | // default ctor initializes to 0 | |
310 | wxULongLongNative() : m_ll(0) { } | |
311 | // from long long | |
312 | wxULongLongNative(unsigned wxLongLong_t ll) : m_ll(ll) { } | |
313 | // from 2 longs | |
314 | wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0) | |
315 | { | |
316 | // assign first to avoid precision loss! | |
317 | m_ll = ((unsigned wxLongLong_t) hi) << 32; | |
318 | m_ll |= (unsigned wxLongLong_t) lo; | |
319 | } | |
320 | ||
321 | // default copy ctor is ok | |
322 | ||
323 | // no dtor | |
324 | ||
325 | // assignment operators | |
326 | // from native 64 bit integer | |
327 | wxULongLongNative& operator=(unsigned wxLongLong_t ll) | |
328 | { m_ll = ll; return *this; } | |
329 | ||
330 | // assignment operators from wxULongLongNative is ok | |
331 | ||
332 | // accessors | |
333 | // get high part | |
334 | unsigned long GetHi() const | |
335 | { return (unsigned long)(m_ll >> 32); } | |
336 | // get low part | |
337 | unsigned long GetLo() const | |
338 | { return (unsigned long)m_ll; } | |
339 | ||
340 | // convert to native ulong long | |
341 | unsigned wxLongLong_t GetValue() const { return m_ll; } | |
342 | ||
343 | // convert to ulong with range checking in the debug mode (only!) | |
344 | unsigned long ToULong() const | |
345 | { | |
346 | wxASSERT_MSG( m_ll <= LONG_MAX, | |
347 | _T("wxULongLong to long conversion loss of precision") ); | |
348 | ||
349 | return (unsigned long)m_ll; | |
350 | } | |
351 | ||
352 | // operations | |
353 | // addition | |
354 | wxULongLongNative operator+(const wxULongLongNative& ll) const | |
355 | { return wxULongLongNative(m_ll + ll.m_ll); } | |
356 | wxULongLongNative& operator+=(const wxULongLongNative& ll) | |
357 | { m_ll += ll.m_ll; return *this; } | |
358 | ||
359 | wxULongLongNative operator+(const unsigned wxLongLong_t ll) const | |
360 | { return wxULongLongNative(m_ll + ll); } | |
361 | wxULongLongNative& operator+=(const unsigned wxLongLong_t ll) | |
362 | { m_ll += ll; return *this; } | |
363 | ||
364 | // pre increment | |
365 | wxULongLongNative& operator++() | |
366 | { m_ll++; return *this; } | |
367 | ||
368 | // post increment | |
369 | wxULongLongNative operator++(int) | |
370 | { wxULongLongNative value(*this); m_ll++; return value; } | |
371 | ||
372 | // subtraction | |
373 | wxULongLongNative operator-(const wxULongLongNative& ll) const | |
374 | { return wxULongLongNative(m_ll - ll.m_ll); } | |
375 | wxULongLongNative& operator-=(const wxULongLongNative& ll) | |
376 | { m_ll -= ll.m_ll; return *this; } | |
377 | ||
378 | wxULongLongNative operator-(const unsigned wxLongLong_t ll) const | |
379 | { return wxULongLongNative(m_ll - ll); } | |
380 | wxULongLongNative& operator-=(const unsigned wxLongLong_t ll) | |
381 | { m_ll -= ll; return *this; } | |
382 | ||
383 | // pre decrement | |
384 | wxULongLongNative& operator--() | |
385 | { m_ll--; return *this; } | |
386 | ||
387 | // post decrement | |
388 | wxULongLongNative operator--(int) | |
389 | { wxULongLongNative value(*this); m_ll--; return value; } | |
390 | ||
391 | // shifts | |
392 | // left shift | |
393 | wxULongLongNative operator<<(int shift) const | |
394 | { return wxULongLongNative(m_ll << shift);; } | |
395 | wxULongLongNative& operator<<=(int shift) | |
396 | { m_ll <<= shift; return *this; } | |
397 | ||
398 | // right shift | |
399 | wxULongLongNative operator>>(int shift) const | |
400 | { return wxULongLongNative(m_ll >> shift);; } | |
401 | wxULongLongNative& operator>>=(int shift) | |
402 | { m_ll >>= shift; return *this; } | |
403 | ||
404 | // bitwise operators | |
405 | wxULongLongNative operator&(const wxULongLongNative& ll) const | |
406 | { return wxULongLongNative(m_ll & ll.m_ll); } | |
407 | wxULongLongNative& operator&=(const wxULongLongNative& ll) | |
408 | { m_ll &= ll.m_ll; return *this; } | |
409 | ||
410 | wxULongLongNative operator|(const wxULongLongNative& ll) const | |
411 | { return wxULongLongNative(m_ll | ll.m_ll); } | |
412 | wxULongLongNative& operator|=(const wxULongLongNative& ll) | |
413 | { m_ll |= ll.m_ll; return *this; } | |
414 | ||
415 | wxULongLongNative operator^(const wxULongLongNative& ll) const | |
416 | { return wxULongLongNative(m_ll ^ ll.m_ll); } | |
417 | wxULongLongNative& operator^=(const wxULongLongNative& ll) | |
418 | { m_ll ^= ll.m_ll; return *this; } | |
419 | ||
420 | // multiplication/division | |
421 | wxULongLongNative operator*(const wxULongLongNative& ll) const | |
422 | { return wxULongLongNative(m_ll * ll.m_ll); } | |
423 | wxULongLongNative operator*(unsigned long l) const | |
424 | { return wxULongLongNative(m_ll * l); } | |
425 | wxULongLongNative& operator*=(const wxULongLongNative& ll) | |
426 | { m_ll *= ll.m_ll; return *this; } | |
427 | wxULongLongNative& operator*=(unsigned long l) | |
428 | { m_ll *= l; return *this; } | |
429 | ||
430 | wxULongLongNative operator/(const wxULongLongNative& ll) const | |
431 | { return wxULongLongNative(m_ll / ll.m_ll); } | |
432 | wxULongLongNative operator/(unsigned long l) const | |
433 | { return wxULongLongNative(m_ll / l); } | |
434 | wxULongLongNative& operator/=(const wxULongLongNative& ll) | |
435 | { m_ll /= ll.m_ll; return *this; } | |
436 | wxULongLongNative& operator/=(unsigned long l) | |
437 | { m_ll /= l; return *this; } | |
438 | ||
439 | wxULongLongNative operator%(const wxULongLongNative& ll) const | |
440 | { return wxULongLongNative(m_ll % ll.m_ll); } | |
441 | wxULongLongNative operator%(unsigned long l) const | |
442 | { return wxULongLongNative(m_ll % l); } | |
443 | ||
444 | // comparison | |
445 | bool operator==(const wxULongLongNative& ll) const | |
446 | { return m_ll == ll.m_ll; } | |
447 | bool operator==(unsigned long l) const | |
448 | { return m_ll == l; } | |
449 | bool operator!=(const wxULongLongNative& ll) const | |
450 | { return m_ll != ll.m_ll; } | |
451 | bool operator!=(unsigned long l) const | |
452 | { return m_ll != l; } | |
453 | bool operator<(const wxULongLongNative& ll) const | |
454 | { return m_ll < ll.m_ll; } | |
455 | bool operator<(unsigned long l) const | |
456 | { return m_ll < l; } | |
457 | bool operator>(const wxULongLongNative& ll) const | |
458 | { return m_ll > ll.m_ll; } | |
459 | bool operator>(unsigned long l) const | |
460 | { return m_ll > l; } | |
461 | bool operator<=(const wxULongLongNative& ll) const | |
462 | { return m_ll <= ll.m_ll; } | |
463 | bool operator<=(unsigned long l) const | |
464 | { return m_ll <= l; } | |
465 | bool operator>=(const wxULongLongNative& ll) const | |
466 | { return m_ll >= ll.m_ll; } | |
467 | bool operator>=(unsigned long l) const | |
468 | { return m_ll >= l; } | |
469 | ||
470 | // miscellaneous | |
471 | ||
472 | // return the string representation of this number | |
473 | wxString ToString() const; | |
474 | ||
475 | // conversion to byte array: returns a pointer to static buffer! | |
476 | void *asArray() const; | |
477 | ||
478 | #if wxUSE_STD_IOSTREAM | |
479 | // input/output | |
480 | friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&); | |
481 | #endif | |
482 | ||
483 | private: | |
484 | unsigned wxLongLong_t m_ll; | |
485 | }; | |
486 | ||
487 | #endif // wxUSE_LONGLONG_NATIVE | |
488 | ||
489 | #if wxUSE_LONGLONG_WX | |
490 | ||
491 | class WXDLLIMPEXP_BASE wxLongLongWx | |
492 | { | |
493 | public: | |
494 | // ctors | |
495 | // default ctor initializes to 0 | |
496 | wxLongLongWx() | |
497 | { | |
498 | m_lo = m_hi = 0; | |
499 | ||
500 | #ifdef wxLONGLONG_TEST_MODE | |
501 | m_ll = 0; | |
502 | ||
503 | Check(); | |
504 | #endif // wxLONGLONG_TEST_MODE | |
505 | } | |
506 | // from long | |
507 | wxLongLongWx(long l) { *this = l; } | |
508 | // from 2 longs | |
509 | wxLongLongWx(long hi, unsigned long lo) | |
510 | { | |
511 | m_hi = hi; | |
512 | m_lo = lo; | |
513 | ||
514 | #ifdef wxLONGLONG_TEST_MODE | |
515 | m_ll = hi; | |
516 | m_ll <<= 32; | |
517 | m_ll |= lo; | |
518 | ||
519 | Check(); | |
520 | #endif // wxLONGLONG_TEST_MODE | |
521 | } | |
522 | ||
523 | // default copy ctor is ok in both cases | |
524 | ||
525 | // no dtor | |
526 | ||
527 | // assignment operators | |
528 | // from long | |
529 | wxLongLongWx& operator=(long l) | |
530 | { | |
531 | m_lo = l; | |
532 | m_hi = (l < 0 ? -1l : 0l); | |
533 | ||
534 | #ifdef wxLONGLONG_TEST_MODE | |
535 | m_ll = l; | |
536 | ||
537 | Check(); | |
538 | #endif // wxLONGLONG_TEST_MODE | |
539 | ||
540 | return *this; | |
541 | } | |
542 | // from double | |
543 | wxLongLongWx& Assign(double d); | |
544 | // can't have assignment operator from 2 longs | |
545 | ||
546 | // accessors | |
547 | // get high part | |
548 | long GetHi() const { return m_hi; } | |
549 | // get low part | |
550 | unsigned long GetLo() const { return m_lo; } | |
551 | ||
552 | // get absolute value | |
553 | wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); } | |
554 | wxLongLongWx& Abs() | |
555 | { | |
556 | if ( m_hi < 0 ) | |
557 | m_hi = -m_hi; | |
558 | ||
559 | #ifdef wxLONGLONG_TEST_MODE | |
560 | if ( m_ll < 0 ) | |
561 | m_ll = -m_ll; | |
562 | ||
563 | Check(); | |
564 | #endif // wxLONGLONG_TEST_MODE | |
565 | ||
566 | return *this; | |
567 | } | |
568 | ||
569 | // convert to long with range checking in the debug mode (only!) | |
570 | long ToLong() const | |
571 | { | |
572 | wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l), | |
573 | _T("wxLongLong to long conversion loss of precision") ); | |
574 | ||
575 | return (long)m_lo; | |
576 | } | |
577 | ||
578 | // operations | |
579 | // addition | |
580 | wxLongLongWx operator+(const wxLongLongWx& ll) const; | |
581 | wxLongLongWx& operator+=(const wxLongLongWx& ll); | |
582 | wxLongLongWx operator+(long l) const; | |
583 | wxLongLongWx& operator+=(long l); | |
584 | ||
585 | // pre increment operator | |
586 | wxLongLongWx& operator++(); | |
587 | ||
588 | // post increment operator | |
589 | wxLongLongWx& operator++(int) { return ++(*this); } | |
590 | ||
591 | // negation operator | |
592 | wxLongLongWx operator-() const; | |
593 | wxLongLongWx& Negate(); | |
594 | ||
595 | // subraction | |
596 | wxLongLongWx operator-(const wxLongLongWx& ll) const; | |
597 | wxLongLongWx& operator-=(const wxLongLongWx& ll); | |
598 | ||
599 | // pre decrement operator | |
600 | wxLongLongWx& operator--(); | |
601 | ||
602 | // post decrement operator | |
603 | wxLongLongWx& operator--(int) { return --(*this); } | |
604 | ||
605 | // shifts | |
606 | // left shift | |
607 | wxLongLongWx operator<<(int shift) const; | |
608 | wxLongLongWx& operator<<=(int shift); | |
609 | ||
610 | // right shift | |
611 | wxLongLongWx operator>>(int shift) const; | |
612 | wxLongLongWx& operator>>=(int shift); | |
613 | ||
614 | // bitwise operators | |
615 | wxLongLongWx operator&(const wxLongLongWx& ll) const; | |
616 | wxLongLongWx& operator&=(const wxLongLongWx& ll); | |
617 | wxLongLongWx operator|(const wxLongLongWx& ll) const; | |
618 | wxLongLongWx& operator|=(const wxLongLongWx& ll); | |
619 | wxLongLongWx operator^(const wxLongLongWx& ll) const; | |
620 | wxLongLongWx& operator^=(const wxLongLongWx& ll); | |
621 | wxLongLongWx operator~() const; | |
622 | ||
623 | // comparison | |
624 | bool operator==(const wxLongLongWx& ll) const | |
625 | { return m_lo == ll.m_lo && m_hi == ll.m_hi; } | |
626 | bool operator!=(const wxLongLongWx& ll) const | |
627 | { return !(*this == ll); } | |
628 | bool operator<(const wxLongLongWx& ll) const; | |
629 | bool operator>(const wxLongLongWx& ll) const; | |
630 | bool operator<=(const wxLongLongWx& ll) const | |
631 | { return *this < ll || *this == ll; } | |
632 | bool operator>=(const wxLongLongWx& ll) const | |
633 | { return *this > ll || *this == ll; } | |
634 | ||
635 | bool operator<(long l) const { return *this < wxLongLongWx(l); } | |
636 | bool operator>(long l) const { return *this > wxLongLongWx(l); } | |
637 | bool operator==(long l) const | |
638 | { | |
639 | return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l) | |
640 | : (m_hi == -1 && m_lo == (unsigned long)l); | |
641 | } | |
642 | ||
643 | bool operator<=(long l) const { return *this < l || *this == l; } | |
644 | bool operator>=(long l) const { return *this > l || *this == l; } | |
645 | ||
646 | // multiplication | |
647 | wxLongLongWx operator*(const wxLongLongWx& ll) const; | |
648 | wxLongLongWx& operator*=(const wxLongLongWx& ll); | |
649 | ||
650 | // division | |
651 | wxLongLongWx operator/(const wxLongLongWx& ll) const; | |
652 | wxLongLongWx& operator/=(const wxLongLongWx& ll); | |
653 | ||
654 | wxLongLongWx operator%(const wxLongLongWx& ll) const; | |
655 | ||
656 | void Divide(const wxLongLongWx& divisor, | |
657 | wxLongLongWx& quotient, | |
658 | wxLongLongWx& remainder) const; | |
659 | ||
660 | // input/output | |
661 | ||
662 | // return the string representation of this number | |
663 | wxString ToString() const; | |
664 | ||
665 | void *asArray() const; | |
666 | ||
667 | #if wxUSE_STD_IOSTREAM | |
668 | friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&); | |
669 | #endif // wxUSE_STD_IOSTREAM | |
670 | ||
671 | private: | |
672 | // long is at least 32 bits, so represent our 64bit number as 2 longs | |
673 | ||
674 | long m_hi; // signed bit is in the high part | |
675 | unsigned long m_lo; | |
676 | ||
677 | #ifdef wxLONGLONG_TEST_MODE | |
678 | void Check() | |
679 | { | |
680 | wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo ); | |
681 | } | |
682 | ||
683 | wxLongLong_t m_ll; | |
684 | #endif // wxLONGLONG_TEST_MODE | |
685 | }; | |
686 | ||
687 | ||
688 | class WXDLLIMPEXP_BASE wxULongLongWx | |
689 | { | |
690 | public: | |
691 | // ctors | |
692 | // default ctor initializes to 0 | |
693 | wxULongLongWx() | |
694 | { | |
695 | m_lo = m_hi = 0; | |
696 | ||
697 | #ifdef wxLONGLONG_TEST_MODE | |
698 | m_ll = 0; | |
699 | ||
700 | Check(); | |
701 | #endif // wxLONGLONG_TEST_MODE | |
702 | } | |
703 | // from ulong | |
704 | wxULongLongWx(unsigned long l) { *this = l; } | |
705 | // from 2 ulongs | |
706 | wxULongLongWx(unsigned long hi, unsigned long lo) | |
707 | { | |
708 | m_hi = hi; | |
709 | m_lo = lo; | |
710 | ||
711 | #ifdef wxLONGLONG_TEST_MODE | |
712 | m_ll = hi; | |
713 | m_ll <<= 32; | |
714 | m_ll |= lo; | |
715 | ||
716 | Check(); | |
717 | #endif // wxLONGLONG_TEST_MODE | |
718 | } | |
719 | ||
720 | // default copy ctor is ok in both cases | |
721 | ||
722 | // no dtor | |
723 | ||
724 | // assignment operators | |
725 | // from long | |
726 | wxULongLongWx& operator=(unsigned long l) | |
727 | { | |
728 | m_lo = l; | |
729 | m_hi = 0; | |
730 | ||
731 | #ifdef wxLONGLONG_TEST_MODE | |
732 | m_ll = l; | |
733 | ||
734 | Check(); | |
735 | #endif // wxLONGLONG_TEST_MODE | |
736 | ||
737 | return *this; | |
738 | } | |
739 | ||
740 | // can't have assignment operator from 2 longs | |
741 | ||
742 | // accessors | |
743 | // get high part | |
744 | unsigned long GetHi() const { return m_hi; } | |
745 | // get low part | |
746 | unsigned long GetLo() const { return m_lo; } | |
747 | ||
748 | // convert to long with range checking in the debug mode (only!) | |
749 | unsigned long ToULong() const | |
750 | { | |
751 | wxASSERT_MSG( m_hi == 0ul, | |
752 | _T("wxULongLong to long conversion loss of precision") ); | |
753 | ||
754 | return (unsigned long)m_lo; | |
755 | } | |
756 | ||
757 | // operations | |
758 | // addition | |
759 | wxULongLongWx operator+(const wxULongLongWx& ll) const; | |
760 | wxULongLongWx& operator+=(const wxULongLongWx& ll); | |
761 | wxULongLongWx operator+(unsigned long l) const; | |
762 | wxULongLongWx& operator+=(unsigned long l); | |
763 | ||
764 | // pre increment operator | |
765 | wxULongLongWx& operator++(); | |
766 | ||
767 | // post increment operator | |
768 | wxULongLongWx& operator++(int) { return ++(*this); } | |
769 | ||
770 | // subraction (FIXME: should return wxLongLong) | |
771 | wxULongLongWx operator-(const wxULongLongWx& ll) const; | |
772 | wxULongLongWx& operator-=(const wxULongLongWx& ll); | |
773 | ||
774 | // pre decrement operator | |
775 | wxULongLongWx& operator--(); | |
776 | ||
777 | // post decrement operator | |
778 | wxULongLongWx& operator--(int) { return --(*this); } | |
779 | ||
780 | // shifts | |
781 | // left shift | |
782 | wxULongLongWx operator<<(int shift) const; | |
783 | wxULongLongWx& operator<<=(int shift); | |
784 | ||
785 | // right shift | |
786 | wxULongLongWx operator>>(int shift) const; | |
787 | wxULongLongWx& operator>>=(int shift); | |
788 | ||
789 | // bitwise operators | |
790 | wxULongLongWx operator&(const wxULongLongWx& ll) const; | |
791 | wxULongLongWx& operator&=(const wxULongLongWx& ll); | |
792 | wxULongLongWx operator|(const wxULongLongWx& ll) const; | |
793 | wxULongLongWx& operator|=(const wxULongLongWx& ll); | |
794 | wxULongLongWx operator^(const wxULongLongWx& ll) const; | |
795 | wxULongLongWx& operator^=(const wxULongLongWx& ll); | |
796 | wxULongLongWx operator~() const; | |
797 | ||
798 | // comparison | |
799 | bool operator==(const wxULongLongWx& ll) const | |
800 | { return m_lo == ll.m_lo && m_hi == ll.m_hi; } | |
801 | bool operator!=(const wxULongLongWx& ll) const | |
802 | { return !(*this == ll); } | |
803 | bool operator<(const wxULongLongWx& ll) const; | |
804 | bool operator>(const wxULongLongWx& ll) const; | |
805 | bool operator<=(const wxULongLongWx& ll) const | |
806 | { return *this < ll || *this == ll; } | |
807 | bool operator>=(const wxULongLongWx& ll) const | |
808 | { return *this > ll || *this == ll; } | |
809 | ||
810 | bool operator<(unsigned long l) const { return *this < wxULongLongWx(l); } | |
811 | bool operator>(unsigned long l) const { return *this > wxULongLongWx(l); } | |
812 | bool operator==(unsigned long l) const | |
813 | { | |
814 | return (m_hi == 0 && m_lo == (unsigned long)l); | |
815 | } | |
816 | ||
817 | bool operator<=(unsigned long l) const { return *this < l || *this == l; } | |
818 | bool operator>=(unsigned long l) const { return *this > l || *this == l; } | |
819 | ||
820 | // multiplication | |
821 | wxULongLongWx operator*(const wxULongLongWx& ll) const; | |
822 | wxULongLongWx& operator*=(const wxULongLongWx& ll); | |
823 | ||
824 | // division | |
825 | wxULongLongWx operator/(const wxULongLongWx& ll) const; | |
826 | wxULongLongWx& operator/=(const wxULongLongWx& ll); | |
827 | ||
828 | wxULongLongWx operator%(const wxULongLongWx& ll) const; | |
829 | ||
830 | void Divide(const wxULongLongWx& divisor, | |
831 | wxULongLongWx& quotient, | |
832 | wxULongLongWx& remainder) const; | |
833 | ||
834 | // input/output | |
835 | ||
836 | // return the string representation of this number | |
837 | wxString ToString() const; | |
838 | ||
839 | void *asArray() const; | |
840 | ||
841 | #if wxUSE_STD_IOSTREAM | |
842 | friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&); | |
843 | #endif // wxUSE_STD_IOSTREAM | |
844 | ||
845 | private: | |
846 | // long is at least 32 bits, so represent our 64bit number as 2 longs | |
847 | ||
848 | unsigned long m_hi; | |
849 | unsigned long m_lo; | |
850 | ||
851 | #ifdef wxLONGLONG_TEST_MODE | |
852 | void Check() | |
853 | { | |
854 | wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo ); | |
855 | } | |
856 | ||
857 | unsigned wxLongLong_t m_ll; | |
858 | #endif // wxLONGLONG_TEST_MODE | |
859 | }; | |
860 | ||
861 | #endif // wxUSE_LONGLONG_WX | |
862 | ||
863 | // ---------------------------------------------------------------------------- | |
864 | // binary operators | |
865 | // ---------------------------------------------------------------------------- | |
866 | ||
867 | inline bool operator<(long l, const wxLongLong& ll) { return ll > l; } | |
868 | inline bool operator>(long l, const wxLongLong& ll) { return ll < l; } | |
869 | inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; } | |
870 | inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; } | |
871 | inline bool operator==(long l, const wxLongLong& ll) { return ll == l; } | |
872 | inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; } | |
873 | ||
874 | inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; } | |
875 | inline wxLongLong operator-(long l, const wxLongLong& ll) | |
876 | { | |
877 | return wxLongLong(l) - ll; | |
878 | } | |
879 | ||
880 | inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; } | |
881 | inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; } | |
882 | inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; } | |
883 | inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; } | |
884 | inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; } | |
885 | inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; } | |
886 | ||
887 | inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; } | |
888 | ||
889 | // FIXME: this should return wxLongLong | |
890 | inline wxULongLong operator-(unsigned long l, const wxULongLong& ull) | |
891 | { | |
892 | return wxULongLong(l) - ull; | |
893 | } | |
894 | ||
895 | #endif // _WX_LONGLONG_H |