]>
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 license | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | #ifndef _WX_LONGLONG_H | |
14 | #define _WX_LONGLONG_H | |
15 | ||
16 | #ifdef __GNUG__ | |
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 | // to avoid compilation problems on 64bit machines with ambiguous method calls | |
42 | // we will need to define this | |
43 | #undef wxLongLongIsLong | |
44 | ||
45 | // NB: we #define and not typedef wxLongLong_t because we want to be able to | |
46 | // use 'unsigned wxLongLong_t' as well and because we use "#ifdef | |
47 | // wxLongLong_t" below | |
48 | #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) | |
49 | #define wxLongLong_t long | |
50 | #define wxLongLongIsLong | |
51 | #elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ ) | |
52 | #define wxLongLong_t __int64 | |
53 | #elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520) | |
54 | #define wxLongLong_t __int64 | |
55 | #elif defined(__GNUG__) || defined(__sgi) | |
56 | #define wxLongLong_t long long | |
57 | #elif defined(__MWERKS__) | |
58 | #if __option(longlong) | |
59 | #define wxLongLong_t long long | |
60 | #else | |
61 | #error "The 64 bit integer support in CodeWarrior has been disabled." | |
62 | #error "See the documentation on the 'longlong' pragma." | |
63 | #endif | |
64 | #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400 | |
65 | #define wxLongLong_t long long | |
66 | #else // no native long long type | |
67 | // both warning and pragma warning are not portable, but at least an | |
68 | // unknown pragma should never be an error - except that, actually, some | |
69 | // broken compilers don't like it, so we have to disable it in this case | |
70 | // <sigh> | |
71 | #if !(defined(__WATCOMC__) || defined(__VISAGECPP__)) | |
72 | #pragma warning "Your compiler does not appear to support 64 bit "\ | |
73 | "integers, using emulation class instead.\n" \ | |
74 | "Please report your compiler version to " \ | |
75 | "wx-dev@lists.wxwindows.org!" | |
76 | #endif | |
77 | #define wxUSE_LONGLONG_WX 1 | |
78 | #endif // compiler | |
79 | ||
80 | // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE | |
81 | // to disable automatic testing (useful for the test program which defines | |
82 | // both classes) but by default we only use one class | |
83 | #if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t) | |
84 | // don't use both classes unless wxUSE_LONGLONG_NATIVE was explicitly set: | |
85 | // this is useful in test programs and only there | |
86 | #ifndef wxUSE_LONGLONG_NATIVE | |
87 | #define wxUSE_LONGLONG_NATIVE 0 | |
88 | #endif | |
89 | ||
90 | class WXDLLEXPORT wxLongLongWx; | |
91 | #if defined(__VISUALC__) && !defined(__WIN32__) | |
92 | #define wxLongLong wxLongLongWx | |
93 | #else | |
94 | typedef wxLongLongWx wxLongLong; | |
95 | #endif | |
96 | ||
97 | #else | |
98 | // if nothing is defined, use native implementation by default, of course | |
99 | #ifndef wxUSE_LONGLONG_NATIVE | |
100 | #define wxUSE_LONGLONG_NATIVE 1 | |
101 | #endif | |
102 | #endif | |
103 | ||
104 | #ifndef wxUSE_LONGLONG_WX | |
105 | #define wxUSE_LONGLONG_WX 0 | |
106 | class WXDLLEXPORT wxLongLongNative; | |
107 | typedef wxLongLongNative wxLongLong; | |
108 | #endif | |
109 | ||
110 | // NB: if both wxUSE_LONGLONG_WX and NATIVE are defined, the user code should | |
111 | // typedef wxLongLong as it wants, we don't do it | |
112 | ||
113 | // ---------------------------------------------------------------------------- | |
114 | // choose the appropriate class | |
115 | // ---------------------------------------------------------------------------- | |
116 | ||
117 | // we use iostream for wxLongLong output | |
118 | #include "wx/ioswrap.h" | |
119 | ||
120 | #if wxUSE_LONGLONG_NATIVE | |
121 | ||
122 | class WXDLLEXPORT wxLongLongNative | |
123 | { | |
124 | public: | |
125 | // ctors | |
126 | // default ctor initializes to 0 | |
127 | wxLongLongNative() { m_ll = 0; } | |
128 | // from long long | |
129 | wxLongLongNative(wxLongLong_t ll) { m_ll = ll; } | |
130 | // from 2 longs | |
131 | wxLongLongNative(long hi, unsigned long lo) | |
132 | { | |
133 | // assign first to avoid precision loss! | |
134 | m_ll = ((wxLongLong_t) hi) << 32; | |
135 | m_ll |= (wxLongLong_t) lo; | |
136 | } | |
137 | ||
138 | // default copy ctor is ok | |
139 | ||
140 | // no dtor | |
141 | ||
142 | // assignment operators | |
143 | // from native 64 bit integer | |
144 | wxLongLongNative& operator=(wxLongLong_t ll) | |
145 | { m_ll = ll; return *this; } | |
146 | ||
147 | // from double: this one has an explicit name because otherwise we | |
148 | // would have ambiguity with "ll = int" and also because we don't want | |
149 | // to have implicit conversions between doubles and wxLongLongs | |
150 | wxLongLongNative& Assign(double d) | |
151 | { m_ll = (wxLongLong_t)d; return *this; } | |
152 | ||
153 | // assignment operators from wxLongLongNative is ok | |
154 | ||
155 | // accessors | |
156 | // get high part | |
157 | long GetHi() const | |
158 | { return (long)(m_ll >> 32); } | |
159 | // get low part | |
160 | unsigned long GetLo() const | |
161 | { return (unsigned long)m_ll; } | |
162 | ||
163 | // get absolute value | |
164 | wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); } | |
165 | wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; } | |
166 | ||
167 | // convert to native long long | |
168 | wxLongLong_t GetValue() const { return m_ll; } | |
169 | ||
170 | // convert to long with range checking in the debug mode (only!) | |
171 | long ToLong() const | |
172 | { | |
173 | wxASSERT_MSG( (m_ll >= LONG_MIN) && (m_ll <= LONG_MAX), | |
174 | _T("wxLongLong to long conversion loss of precision") ); | |
175 | ||
176 | return (long)m_ll; | |
177 | } | |
178 | ||
179 | // don't provide implicit conversion to wxLongLong_t or we will have an | |
180 | // ambiguity for all arithmetic operations | |
181 | //operator wxLongLong_t() const { return m_ll; } | |
182 | ||
183 | // operations | |
184 | // addition | |
185 | wxLongLongNative operator+(const wxLongLongNative& ll) const | |
186 | { return wxLongLongNative(m_ll + ll.m_ll); } | |
187 | wxLongLongNative& operator+=(const wxLongLongNative& ll) | |
188 | { m_ll += ll.m_ll; return *this; } | |
189 | ||
190 | wxLongLongNative operator+(const wxLongLong_t ll) const | |
191 | { return wxLongLongNative(m_ll + ll); } | |
192 | wxLongLongNative& operator+=(const wxLongLong_t ll) | |
193 | { m_ll += ll; return *this; } | |
194 | ||
195 | // pre increment | |
196 | wxLongLongNative& operator++() | |
197 | { m_ll++; return *this; } | |
198 | ||
199 | // post increment | |
200 | wxLongLongNative& operator++(int) | |
201 | { m_ll++; return *this; } | |
202 | ||
203 | // negation operator | |
204 | wxLongLongNative operator-() const | |
205 | { return wxLongLongNative(-m_ll); } | |
206 | wxLongLongNative& Negate() { m_ll = -m_ll; return *this; } | |
207 | ||
208 | // subtraction | |
209 | wxLongLongNative operator-(const wxLongLongNative& ll) const | |
210 | { return wxLongLongNative(m_ll - ll.m_ll); } | |
211 | wxLongLongNative& operator-=(const wxLongLongNative& ll) | |
212 | { m_ll -= ll.m_ll; return *this; } | |
213 | ||
214 | wxLongLongNative operator-(const wxLongLong_t ll) const | |
215 | { return wxLongLongNative(m_ll - ll); } | |
216 | wxLongLongNative& operator-=(const wxLongLong_t ll) | |
217 | { m_ll -= ll; return *this; } | |
218 | ||
219 | // pre decrement | |
220 | wxLongLongNative& operator--() | |
221 | { m_ll--; return *this; } | |
222 | ||
223 | // post decrement | |
224 | wxLongLongNative& operator--(int) | |
225 | { m_ll--; return *this; } | |
226 | ||
227 | // shifts | |
228 | // left shift | |
229 | wxLongLongNative operator<<(int shift) const | |
230 | { return wxLongLongNative(m_ll << shift);; } | |
231 | wxLongLongNative& operator<<=(int shift) | |
232 | { m_ll <<= shift; return *this; } | |
233 | ||
234 | // right shift | |
235 | wxLongLongNative operator>>(int shift) const | |
236 | { return wxLongLongNative(m_ll >> shift);; } | |
237 | wxLongLongNative& operator>>=(int shift) | |
238 | { m_ll >>= shift; return *this; } | |
239 | ||
240 | // bitwise operators | |
241 | wxLongLongNative operator&(const wxLongLongNative& ll) const | |
242 | { return wxLongLongNative(m_ll & ll.m_ll); } | |
243 | wxLongLongNative& operator&=(const wxLongLongNative& ll) | |
244 | { m_ll &= ll.m_ll; return *this; } | |
245 | ||
246 | wxLongLongNative operator|(const wxLongLongNative& ll) const | |
247 | { return wxLongLongNative(m_ll | ll.m_ll); } | |
248 | wxLongLongNative& operator|=(const wxLongLongNative& ll) | |
249 | { m_ll |= ll.m_ll; return *this; } | |
250 | ||
251 | wxLongLongNative operator^(const wxLongLongNative& ll) const | |
252 | { return wxLongLongNative(m_ll ^ ll.m_ll); } | |
253 | wxLongLongNative& operator^=(const wxLongLongNative& ll) | |
254 | { m_ll ^= ll.m_ll; return *this; } | |
255 | ||
256 | // multiplication/division | |
257 | wxLongLongNative operator*(const wxLongLongNative& ll) const | |
258 | { return wxLongLongNative(m_ll * ll.m_ll); } | |
259 | wxLongLongNative operator*(long l) const | |
260 | { return wxLongLongNative(m_ll * l); } | |
261 | wxLongLongNative& operator*=(const wxLongLongNative& ll) | |
262 | { m_ll *= ll.m_ll; return *this; } | |
263 | wxLongLongNative& operator*=(long l) | |
264 | { m_ll *= l; return *this; } | |
265 | ||
266 | wxLongLongNative operator/(const wxLongLongNative& ll) const | |
267 | { return wxLongLongNative(m_ll / ll.m_ll); } | |
268 | wxLongLongNative operator/(long l) const | |
269 | { return wxLongLongNative(m_ll / l); } | |
270 | wxLongLongNative& operator/=(const wxLongLongNative& ll) | |
271 | { m_ll /= ll.m_ll; return *this; } | |
272 | wxLongLongNative& operator/=(long l) | |
273 | { m_ll /= l; return *this; } | |
274 | ||
275 | wxLongLongNative operator%(const wxLongLongNative& ll) const | |
276 | { return wxLongLongNative(m_ll % ll.m_ll); } | |
277 | wxLongLongNative operator%(long l) const | |
278 | { return wxLongLongNative(m_ll % l); } | |
279 | ||
280 | // comparison | |
281 | bool operator==(const wxLongLongNative& ll) const | |
282 | { return m_ll == ll.m_ll; } | |
283 | bool operator==(long l) const | |
284 | { return m_ll == l; } | |
285 | bool operator!=(const wxLongLongNative& ll) const | |
286 | { return m_ll != ll.m_ll; } | |
287 | bool operator!=(long l) const | |
288 | { return m_ll != l; } | |
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 | ||
306 | // miscellaneous | |
307 | ||
308 | // return the string representation of this number | |
309 | wxString ToString() const; | |
310 | ||
311 | // conversion to byte array: returns a pointer to static buffer! | |
312 | void *asArray() const; | |
313 | ||
314 | #if wxUSE_STD_IOSTREAM | |
315 | // input/output | |
316 | friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&); | |
317 | #endif | |
318 | ||
319 | private: | |
320 | wxLongLong_t m_ll; | |
321 | }; | |
322 | ||
323 | #endif // wxUSE_LONGLONG_NATIVE | |
324 | ||
325 | #if wxUSE_LONGLONG_WX | |
326 | ||
327 | class WXDLLEXPORT wxLongLongWx | |
328 | { | |
329 | public: | |
330 | // ctors | |
331 | // default ctor initializes to 0 | |
332 | wxLongLongWx() | |
333 | { | |
334 | m_lo = m_hi = 0; | |
335 | ||
336 | #ifdef wxLONGLONG_TEST_MODE | |
337 | m_ll = 0; | |
338 | ||
339 | Check(); | |
340 | #endif // wxLONGLONG_TEST_MODE | |
341 | } | |
342 | // from long | |
343 | wxLongLongWx(long l) { *this = l; } | |
344 | // from 2 longs | |
345 | wxLongLongWx(long hi, unsigned long lo) | |
346 | { | |
347 | m_hi = hi; | |
348 | m_lo = lo; | |
349 | ||
350 | #ifdef wxLONGLONG_TEST_MODE | |
351 | m_ll = hi; | |
352 | m_ll <<= 32; | |
353 | m_ll |= lo; | |
354 | ||
355 | Check(); | |
356 | #endif // wxLONGLONG_TEST_MODE | |
357 | } | |
358 | ||
359 | // default copy ctor is ok in both cases | |
360 | ||
361 | // no dtor | |
362 | ||
363 | // assignment operators | |
364 | // from long | |
365 | wxLongLongWx& operator=(long l) | |
366 | { | |
367 | m_lo = l; | |
368 | m_hi = (l < 0 ? -1l : 0l); | |
369 | ||
370 | #ifdef wxLONGLONG_TEST_MODE | |
371 | m_ll = l; | |
372 | ||
373 | Check(); | |
374 | #endif // wxLONGLONG_TEST_MODE | |
375 | ||
376 | return *this; | |
377 | } | |
378 | // from double | |
379 | wxLongLongWx& Assign(double d); | |
380 | // can't have assignment operator from 2 longs | |
381 | ||
382 | // accessors | |
383 | // get high part | |
384 | long GetHi() const { return m_hi; } | |
385 | // get low part | |
386 | unsigned long GetLo() const { return m_lo; } | |
387 | ||
388 | // get absolute value | |
389 | wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); } | |
390 | wxLongLongWx& Abs() | |
391 | { | |
392 | if ( m_hi < 0 ) | |
393 | m_hi = -m_hi; | |
394 | ||
395 | #ifdef wxLONGLONG_TEST_MODE | |
396 | if ( m_ll < 0 ) | |
397 | m_ll = -m_ll; | |
398 | ||
399 | Check(); | |
400 | #endif // wxLONGLONG_TEST_MODE | |
401 | ||
402 | return *this; | |
403 | } | |
404 | ||
405 | // convert to long with range checking in the debug mode (only!) | |
406 | long ToLong() const | |
407 | { | |
408 | wxASSERT_MSG( (m_hi == 0l) || (m_hi == -1l), | |
409 | _T("wxLongLong to long conversion loss of precision") ); | |
410 | ||
411 | return (long)m_lo; | |
412 | } | |
413 | ||
414 | // operations | |
415 | // addition | |
416 | wxLongLongWx operator+(const wxLongLongWx& ll) const; | |
417 | wxLongLongWx& operator+=(const wxLongLongWx& ll); | |
418 | wxLongLongWx operator+(long l) const; | |
419 | wxLongLongWx& operator+=(long l); | |
420 | ||
421 | // pre increment operator | |
422 | wxLongLongWx& operator++(); | |
423 | ||
424 | // post increment operator | |
425 | wxLongLongWx& operator++(int) { return ++(*this); } | |
426 | ||
427 | // negation operator | |
428 | wxLongLongWx operator-() const; | |
429 | wxLongLongWx& Negate(); | |
430 | ||
431 | // subraction | |
432 | wxLongLongWx operator-(const wxLongLongWx& ll) const; | |
433 | wxLongLongWx& operator-=(const wxLongLongWx& ll); | |
434 | ||
435 | // pre decrement operator | |
436 | wxLongLongWx& operator--(); | |
437 | ||
438 | // post decrement operator | |
439 | wxLongLongWx& operator--(int) { return --(*this); } | |
440 | ||
441 | // shifts | |
442 | // left shift | |
443 | wxLongLongWx operator<<(int shift) const; | |
444 | wxLongLongWx& operator<<=(int shift); | |
445 | ||
446 | // right shift | |
447 | wxLongLongWx operator>>(int shift) const; | |
448 | wxLongLongWx& operator>>=(int shift); | |
449 | ||
450 | // bitwise operators | |
451 | wxLongLongWx operator&(const wxLongLongWx& ll) const; | |
452 | wxLongLongWx& operator&=(const wxLongLongWx& ll); | |
453 | wxLongLongWx operator|(const wxLongLongWx& ll) const; | |
454 | wxLongLongWx& operator|=(const wxLongLongWx& ll); | |
455 | wxLongLongWx operator^(const wxLongLongWx& ll) const; | |
456 | wxLongLongWx& operator^=(const wxLongLongWx& ll); | |
457 | wxLongLongWx operator~() const; | |
458 | ||
459 | // comparison | |
460 | bool operator==(const wxLongLongWx& ll) const | |
461 | { return m_lo == ll.m_lo && m_hi == ll.m_hi; } | |
462 | bool operator!=(const wxLongLongWx& ll) const | |
463 | { return !(*this == ll); } | |
464 | bool operator<(const wxLongLongWx& ll) const; | |
465 | bool operator>(const wxLongLongWx& ll) const; | |
466 | bool operator<=(const wxLongLongWx& ll) const | |
467 | { return *this < ll || *this == ll; } | |
468 | bool operator>=(const wxLongLongWx& ll) const | |
469 | { return *this > ll || *this == ll; } | |
470 | ||
471 | bool operator<(long l) const { return *this < wxLongLongWx(l); } | |
472 | bool operator>(long l) const { return *this > wxLongLongWx(l); } | |
473 | bool operator==(long l) const | |
474 | { | |
475 | return l >= 0 ? (m_hi == 0 && m_lo == (unsigned long)l) | |
476 | : (m_hi == -1 && m_lo == (unsigned long)l); | |
477 | } | |
478 | ||
479 | bool operator<=(long l) const { return *this < l || *this == l; } | |
480 | bool operator>=(long l) const { return *this > l || *this == l; } | |
481 | ||
482 | // multiplication | |
483 | wxLongLongWx operator*(const wxLongLongWx& ll) const; | |
484 | wxLongLongWx& operator*=(const wxLongLongWx& ll); | |
485 | ||
486 | // division | |
487 | wxLongLongWx operator/(const wxLongLongWx& ll) const; | |
488 | wxLongLongWx& operator/=(const wxLongLongWx& ll); | |
489 | ||
490 | wxLongLongWx operator%(const wxLongLongWx& ll) const; | |
491 | ||
492 | void Divide(const wxLongLongWx& divisor, | |
493 | wxLongLongWx& quotient, | |
494 | wxLongLongWx& remainder) const; | |
495 | ||
496 | // input/output | |
497 | ||
498 | // return the string representation of this number | |
499 | wxString ToString() const; | |
500 | ||
501 | void *asArray() const; | |
502 | ||
503 | #if wxUSE_STD_IOSTREAM | |
504 | friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&); | |
505 | #endif // wxUSE_STD_IOSTREAM | |
506 | ||
507 | private: | |
508 | // long is at least 32 bits, so represent our 64bit number as 2 longs | |
509 | ||
510 | long m_hi; // signed bit is in the high part | |
511 | unsigned long m_lo; | |
512 | ||
513 | #ifdef wxLONGLONG_TEST_MODE | |
514 | void Check() | |
515 | { | |
516 | wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo ); | |
517 | } | |
518 | ||
519 | wxLongLong_t m_ll; | |
520 | #endif // wxLONGLONG_TEST_MODE | |
521 | }; | |
522 | ||
523 | #endif // wxUSE_LONGLONG_WX | |
524 | ||
525 | // ---------------------------------------------------------------------------- | |
526 | // binary operators | |
527 | // ---------------------------------------------------------------------------- | |
528 | ||
529 | inline bool operator<(long l, const wxLongLong& ll) { return ll > l; } | |
530 | inline bool operator>(long l, const wxLongLong& ll) { return ll > l; } | |
531 | inline bool operator<=(long l, const wxLongLong& ll) { return ll > l; } | |
532 | inline bool operator>=(long l, const wxLongLong& ll) { return ll > l; } | |
533 | inline bool operator==(long l, const wxLongLong& ll) { return ll > l; } | |
534 | inline bool operator!=(long l, const wxLongLong& ll) { return ll > l; } | |
535 | ||
536 | inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; } | |
537 | inline wxLongLong operator-(long l, const wxLongLong& ll) { return ll - l; } | |
538 | ||
539 | #endif // _WX_LONGLONG_H |