]> git.saurik.com Git - wxWidgets.git/blob - src/common/longlong.cpp
*** empty log message ***
[wxWidgets.git] / src / common / longlong.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/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 wxWindows 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 license
12 /////////////////////////////////////////////////////////////////////////////
13
14 // ============================================================================
15 // headers
16 // ============================================================================
17
18 #ifdef __GNUG__
19 #pragma implementation "longlong.h"
20 #endif
21
22 #include "wx/wxprec.h"
23
24 #ifdef __BORLANDC__
25 #pragma hdrstop
26 #endif
27
28 #if wxUSE_LONGLONG
29
30 #include "wx/longlong.h"
31
32 #include <memory.h> // for memset()
33
34 // ============================================================================
35 // implementation
36 // ============================================================================
37
38 #if wxUSE_LONGLONG_NATIVE
39
40 // ----------------------------------------------------------------------------
41 // misc
42 // ----------------------------------------------------------------------------
43
44 void *wxLongLongNative::asArray(void) const
45 {
46 static unsigned char temp[8];
47
48 temp[0] = (m_ll >> 56) & 0xFF;
49 temp[1] = (m_ll >> 48) & 0xFF;
50 temp[2] = (m_ll >> 40) & 0xFF;
51 temp[3] = (m_ll >> 32) & 0xFF;
52 temp[4] = (m_ll >> 24) & 0xFF;
53 temp[5] = (m_ll >> 16) & 0xFF;
54 temp[6] = (m_ll >> 8) & 0xFF;
55 temp[7] = (m_ll >> 0) & 0xFF;
56
57 return temp;
58 }
59
60 // input/output
61 ostream& operator<< (ostream& o, const wxLongLongNative& ll)
62 {
63 char result[65];
64
65 memset(result, 'A', 64);
66
67 result[64] = '\0';
68
69 for (int i = 0; i < 64; i++)
70 {
71 result[63 - i] = '0' + (char) ((ll.m_ll >> i) & 1);
72 }
73
74 return o << result;
75 }
76
77 #endif // wxUSE_LONGLONG_NATIVE
78
79 #if wxUSE_LONGLONG_WX
80
81 wxLongLongWx wxLongLongWx::operator<<(int shift) const
82 {
83 if (shift == 0)
84 return *this;
85
86 if (shift < 32)
87 return wxLongLongWx((m_hi << shift) | (m_lo >> (32 - shift)),
88 m_lo << shift);
89 else
90 return wxLongLongWx(m_lo << (shift - 32),
91 0);
92 }
93
94 wxLongLongWx& wxLongLongWx::operator<<=(int shift)
95 {
96 if (shift == 0)
97 return *this;
98
99 if (shift < 32)
100 {
101 m_hi <<= shift;
102 m_hi |= m_lo >> (32 - shift);
103 m_lo <<= shift;
104 }
105 else
106 {
107 m_hi = m_lo << (shift - 32);
108 m_lo = 0;
109 }
110
111 return *this;
112 }
113
114 wxLongLongWx wxLongLongWx::operator>>(int shift) const
115 {
116 if (shift == 0)
117 return *this;
118
119 if (shift < 32)
120 return wxLongLongWx(m_hi >> shift,
121 (m_lo >> shift) | (m_hi << (32 - shift)));
122 else
123 return wxLongLongWx((m_hi < 0 ? -1l : 0),
124 m_hi >> (shift - 32));
125 }
126
127 wxLongLongWx& wxLongLongWx::operator>>=(int shift)
128 {
129 if (shift == 0)
130 return *this;
131
132 if (shift < 32)
133 {
134 m_lo >>= shift;
135 m_lo |= m_hi << (32 - shift);
136 m_hi >>= shift;
137 }
138 else
139 {
140 m_lo = m_hi >> (shift - 32);
141 m_hi = (m_hi < 0 ? -1L : 0);
142 }
143
144 return *this;
145 }
146
147 wxLongLongWx wxLongLongWx::operator+(const wxLongLongWx& ll) const
148 {
149 wxLongLongWx temp;
150
151 temp.m_lo = m_lo + ll.m_lo;
152 temp.m_hi = m_hi + ll.m_hi;
153 if ((temp.m_lo < m_lo) || (temp.m_lo < ll.m_lo))
154 temp.m_hi++;
155
156 return temp;
157 }
158
159 wxLongLongWx wxLongLongWx::operator+(long l) const
160 {
161 wxLongLongWx temp;
162
163 temp.m_lo = m_lo + l;
164
165 if (l < 0)
166 temp.m_hi += -1l;
167
168 if ((temp.m_lo < m_lo) || (temp.m_lo < (unsigned long)l))
169 temp.m_hi++;
170
171 return temp;
172 }
173
174 wxLongLongWx& wxLongLongWx::operator+=(const wxLongLongWx& ll)
175 {
176 unsigned long previous = m_lo;
177
178 m_lo += ll.m_lo;
179 m_hi += ll.m_hi;
180
181 if ((m_lo < previous) || (m_lo < ll.m_lo))
182 m_hi++;
183
184 return *this;
185 }
186
187 wxLongLongWx& wxLongLongWx::operator+=(long l)
188 {
189 unsigned long previous = m_lo;
190
191 m_lo += l;
192 if (l < 0)
193 m_hi += -1l;
194
195 if ((m_lo < previous) || (m_lo < (unsigned long)l))
196 m_hi++;
197
198 return *this;
199 }
200
201 // pre increment
202 wxLongLongWx& wxLongLongWx::operator++()
203 {
204 m_lo++;
205 if (m_lo == 0)
206 m_hi++;
207
208 return *this;
209 }
210
211 // post increment
212 wxLongLongWx& wxLongLongWx::operator++(int)
213 {
214 m_lo++;
215 if (m_lo == 0)
216 m_hi++;
217
218 return *this;
219 }
220
221 // negation
222 wxLongLongWx wxLongLongWx::operator-() const
223 {
224 wxLongLongWx temp(~m_hi, ~m_lo);
225
226 temp.m_lo++;
227 if (temp.m_lo == 0)
228 temp.m_hi++;
229
230 return temp;
231 }
232
233 // subtraction
234
235 wxLongLongWx wxLongLongWx::operator-(const wxLongLongWx& ll) const
236 {
237 wxLongLongWx temp;
238
239 temp.m_lo = m_lo - ll.m_lo;
240 temp.m_hi = m_hi - ll.m_hi;
241
242 if (m_lo < ll.m_lo)
243 temp.m_hi--;
244
245 return temp;
246 }
247
248 wxLongLongWx& wxLongLongWx::operator-=(const wxLongLongWx& ll)
249 {
250 unsigned long previous = m_lo;
251
252 m_lo -= ll.m_lo;
253 m_hi -= ll.m_hi;
254
255 if (previous < ll.m_lo)
256 m_hi--;
257
258 return *this;;
259 }
260
261 // pre decrement
262 wxLongLongWx& wxLongLongWx::operator--()
263 {
264 m_lo--;
265 if (m_lo == 0xFFFFFFFF)
266 m_hi--;
267
268 return *this;
269 }
270
271 // post decrement
272 wxLongLongWx& wxLongLongWx::operator--(int)
273 {
274 m_lo--;
275 if (m_lo == 0xFFFFFFFF)
276 m_hi--;
277
278 return *this;
279 }
280
281 // comparison operators
282
283 bool wxLongLongWx::operator<(const wxLongLongWx& ll) const
284 {
285 if (m_lo < ll.m_lo)
286 return 1;
287 if (m_lo > ll.m_lo)
288 return 0;
289 if (m_hi < ll.m_hi)
290 return 1;
291 if (m_hi > ll.m_hi)
292 return 0;
293 return 0;
294 }
295
296 bool wxLongLongWx::operator>(const wxLongLongWx& ll) const
297 {
298 if (m_lo < ll.m_lo)
299 return 0;
300 if (m_lo > ll.m_lo)
301 return 1;
302 if (m_hi < ll.m_hi)
303 return 0;
304 if (m_hi > ll.m_hi)
305 return 1;
306 return 0;
307 }
308
309 bool wxLongLongWx::operator<=(const wxLongLongWx& ll) const
310 {
311 if (m_lo < ll.m_lo)
312 return 1;
313 if (m_lo > ll.m_lo)
314 return 0;
315 if (m_hi < ll.m_hi)
316 return 1;
317 if (m_hi > ll.m_hi)
318 return 0;
319 return 1;
320 }
321
322 bool wxLongLongWx::operator>=(const wxLongLongWx& ll) const
323 {
324 if (m_lo < ll.m_lo)
325 return 0;
326 if (m_lo > ll.m_lo)
327 return 1;
328 if (m_hi < ll.m_hi)
329 return 0;
330 if (m_hi > ll.m_hi)
331 return 1;
332 return 1;
333 }
334
335 // bitwise operators
336
337 wxLongLongWx wxLongLongWx::operator&(const wxLongLongWx& ll) const
338 {
339 return wxLongLongWx(m_hi & ll.m_hi, m_lo & ll.m_lo);
340 }
341
342 wxLongLongWx wxLongLongWx::operator|(const wxLongLongWx& ll) const
343 {
344 return wxLongLongWx(m_hi | ll.m_hi, m_lo | ll.m_lo);
345 }
346
347 wxLongLongWx wxLongLongWx::operator^(const wxLongLongWx& ll) const
348 {
349 return wxLongLongWx(m_hi ^ ll.m_hi, m_lo ^ ll.m_lo);
350 }
351
352 wxLongLongWx& wxLongLongWx::operator&=(const wxLongLongWx& ll)
353 {
354 m_lo &= ll.m_lo;
355 m_hi &= ll.m_hi;
356
357 return *this;
358 }
359
360 wxLongLongWx& wxLongLongWx::operator|=(const wxLongLongWx& ll)
361 {
362 m_lo |= ll.m_lo;
363 m_hi |= ll.m_hi;
364
365 return *this;
366 }
367
368 wxLongLongWx& wxLongLongWx::operator^=(const wxLongLongWx& ll)
369 {
370 m_lo ^= ll.m_lo;
371 m_hi ^= ll.m_hi;
372
373 return *this;
374 }
375
376 wxLongLongWx wxLongLongWx::operator~() const
377 {
378 return wxLongLongWx(~m_hi, ~m_lo);
379 }
380
381 // multiplication
382
383 wxLongLongWx wxLongLongWx::operator*(const wxLongLongWx& ll) const
384 {
385 wxLongLongWx t(m_hi, m_lo);
386 wxLongLongWx q(ll.m_hi, ll.m_lo);
387 wxLongLongWx p;
388 int counter = 0;
389
390 do
391 {
392 if ((q.m_lo & 1) != 0)
393 p += t;
394 q >>= 1;
395 t <<= 1;
396 counter++;
397 }
398 while ((counter < 64) && ((q.m_hi != 0) || (q.m_lo != 0)));
399 return p;
400 }
401
402 wxLongLongWx& wxLongLongWx::operator*=(const wxLongLongWx& ll)
403 {
404 wxLongLongWx t(m_hi, m_lo);
405 wxLongLongWx q(ll.m_hi, ll.m_lo);
406 int counter = 0;
407
408 do
409 {
410 if ((q.m_lo & 1) != 0)
411 *this += t;
412 q >>= 1;
413 t <<= 1;
414 counter++;
415 }
416 while ((counter < 64) && ((q.m_hi != 0) || (q.m_lo != 0)));
417 return *this;
418 }
419
420 // division
421
422 void wxLongLongWx::Divide(const wxLongLongWx& divisor, wxLongLongWx& quotient, wxLongLongWx& remainder) const
423 {
424 if ((divisor.m_lo == 0) && (divisor.m_hi == 0))
425 {
426 // provoke division by zero error and silence the compilers warnings
427 // about an expression without effect and unused variable
428 long dummy = divisor.m_lo/divisor.m_hi;
429 dummy += 0;
430 }
431
432 wxFAIL_MSG("not implemented");
433 }
434
435 // temporary - just for testing
436 void *wxLongLongWx::asArray(void) const
437 {
438 static unsigned char temp[8];
439
440 temp[0] = (m_hi >> 24) & 0xFF;
441 temp[1] = (m_hi >> 16) & 0xFF;
442 temp[2] = (m_hi >> 8) & 0xFF;
443 temp[3] = (m_hi >> 0) & 0xFF;
444 temp[4] = (m_lo >> 24) & 0xFF;
445 temp[5] = (m_lo >> 16) & 0xFF;
446 temp[6] = (m_lo >> 8) & 0xFF;
447 temp[7] = (m_lo >> 0) & 0xFF;
448
449 return temp;
450 }
451
452 // input/output
453
454 ostream& operator<< (ostream& o, const wxLongLongWx& ll)
455 {
456 char result[65];
457
458 memset(result, 'A', 64);
459
460 result[64] = '\0';
461
462 for (int i = 0; i < 32; i++)
463 {
464 result[31 - i] = (char) ('0' + (int) ((ll.m_hi >> i) & 1));
465 result[63 - i] = (char) ('0' + (int) ((ll.m_lo >> i) & 1));
466 }
467
468 return o << result;
469 }
470 #endif
471 // wxUSE_LONGLONG_NATIVE
472
473 #endif // wxUSE_LONGLONG