1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
/*
* Handling of the int64 and uint64 types. Done in 32-bit integers,
* for (pre-C99) portability. Hopefully once C99 becomes widespread
* we can kiss this lot goodbye...
*/
#include <assert.h>
typedef struct {
unsigned long hi, lo;
} uint64, int64;
uint64 uint64_div10(uint64 x, int *remainder) {
uint64 y;
int rem, r2;
y.hi = x.hi / 10;
y.lo = x.lo / 10;
rem = x.lo % 10;
/*
* Now we have to add in the remainder left over from x.hi.
*/
r2 = x.hi % 10;
y.lo += r2 * 2 * (0x80000000 / 10);
rem += r2 * 2 * (0x80000000 % 10);
y.lo += rem / 10;
rem %= 10;
if (remainder)
*remainder = rem;
return y;
}
void uint64_decimal(uint64 x, char *buffer) {
char buf[20];
int start = 20;
int d;
while (x.hi || x.lo) {
x = uint64_div10(x, &d);
assert(start > 0);
buf[--start] = d + '0';
}
memcpy(buffer, buf+start, sizeof(buf)-start);
buffer[sizeof(buf)-start] = '\0';
}
uint64 uint64_make(unsigned long hi, unsigned long lo) {
uint64 y;
y.hi = hi;
y.lo = lo;
return y;
}
uint64 uint64_add(uint64 x, uint64 y) {
x.lo += y.lo;
x.hi += y.hi + (x.lo < y.lo ? 1 : 0);
return x;
}
uint64 uint64_add32(uint64 x, unsigned long y) {
uint64 yy;
yy.hi = 0;
yy.lo = y;
return uint64_add(x, yy);
}
|
