 |
zstr.c - libzahl - big integer library |
 |
git clone git://git.suckless.org/libzahl |
 |
Log |
|
Files |
|
Refs |
|
README |
|
LICENSE |
|
--- |
|
zstr.c (2963B) |
|
--- |
|
1 /* See LICENSE file for copyright and license details. */ |
|
2 #include "internals.h" |
|
3 |
|
4 #include <stdio.h> |
|
5 |
|
6 #define num libzahl_tmp_str_num |
|
7 #define rem libzahl_tmp_str_rem |
|
8 |
|
9 /* All 19 you see here is derived from that 10¹⁹ is the largest |
|
10 * power of than < 2⁶⁴, and 64 is the number of bits in |
|
11 * zahl_char_t. If zahl_char_t is chanced, the value 19, and |
|
12 * the cast to unsigned long long must be changed accordingly. */ |
|
13 |
|
14 |
|
15 #define S1(P) P"0" P"1" P"2" P"3" P"4" P"5" P"6" … |
|
16 #define S2(P) S1(P"0")S1(P"1")S1(P"2")S1(P"3")S1(P"4")S1(P"5")S1(P"6")S… |
|
17 |
|
18 |
|
19 static inline O2 void |
|
20 sprintint_fix(char *buf, zahl_char_t v) |
|
21 { |
|
22 const char *partials = S2(""); |
|
23 uint16_t *buffer = (uint16_t *)(buf + 1); |
|
24 |
|
25 buffer[8] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
26 buffer[7] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
27 buffer[6] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
28 buffer[5] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
29 buffer[4] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
30 buffer[3] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
31 buffer[2] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
32 buffer[1] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
33 buffer[0] = *(const uint16_t *)(partials + 2 * (v % 100)), v /= … |
|
34 *buf = (char)('0' + v); |
|
35 buf[19] = 0; |
|
36 } |
|
37 |
|
38 static inline void |
|
39 cmemmove(char *d, const char *s, long n) |
|
40 { |
|
41 while (n--) |
|
42 *d++ = *s++; |
|
43 } |
|
44 |
|
45 static inline size_t |
|
46 sprintint_min(char *buf, zahl_char_t v) |
|
47 { |
|
48 long i = 0, j; |
|
49 sprintint_fix(buf, v); |
|
50 for (; buf[i] == '0'; i++); |
|
51 cmemmove(buf, buf + i, j = 19 - i); |
|
52 buf[j] = 0; |
|
53 return (size_t)j; |
|
54 } |
|
55 |
|
56 |
|
57 char * |
|
58 zstr(z_t a, char *b, size_t n) |
|
59 { |
|
60 char buf[19 + 1]; |
|
61 size_t len, neg, last, tot = 0; |
|
62 char overridden = 0; |
|
63 |
|
64 if (unlikely(zzero(a))) { |
|
65 if (unlikely(!b) && unlikely(!(b = malloc(2)))) |
|
66 libzahl_memfailure(); |
|
67 b[0] = '0'; |
|
68 b[1] = 0; |
|
69 return b; |
|
70 } |
|
71 |
|
72 if (!n) { |
|
73 /* Calculate a value that is at least the number of |
|
74 * digits required to store the string. The overshoot |
|
75 * is not too signicant. */ |
|
76 n = (20 * BITS_PER_CHAR / 64 + (BITS_PER_CHAR == 8)) * a… |
|
77 /* Note, depends on a ≠ as ensure above. */ |
|
78 } |
|
79 |
|
80 if (unlikely(!b) && unlikely(!(b = libzahl_temp_allocation = mal… |
|
81 libzahl_memfailure(); |
|
82 |
|
83 neg = znegative(a); |
|
84 zabs(num, a); |
|
85 b[0] = '-'; |
|
86 b += neg; |
|
87 n -= neg; |
|
88 n = (last = n) > 19 ? (n - 19) : 0; |
|
89 |
|
90 for (;;) { |
|
91 zdivmod(num, rem, num, libzahl_const_1e19); |
|
92 if (likely(!zzero(num))) { |
|
93 sprintint_fix(b + n, zzero(rem) ? 0 : rem->chars… |
|
94 b[n + 19] = overridden; |
|
95 overridden = b[n]; |
|
96 n = (last = n) > 19 ? (n - 19) : 0; |
|
97 tot += 19; |
|
98 } else { |
|
99 len = sprintint_min(buf, rem->chars[0]); |
|
100 if (tot) { |
|
101 memcpy(b, buf, len); |
|
102 memmove(b + len, b + last, tot + 1); |
|
103 } else { |
|
104 memcpy(b, buf, len + 1); |
|
105 } |
|
106 break; |
|
107 } |
|
108 } |
|
109 |
|
110 libzahl_temp_allocation = 0; |
|
111 return b - neg; |
|
112 } |
