dte test coverage

Directory: ./
File: src/util/numtostr.c
Date: 2025-07-13 15:27:15
Exec Total Coverage
Lines: 109 109 100.0%
Functions: 12 12 100.0%
Branches: 40 40 100.0%
Line Branch Exec Source
1 // Locale-independent integer to string conversion.
2 // Copyright © Craig Barnes.
3 // SPDX-License-Identifier: GPL-2.0-only
4
5 #include <string.h>
6 #include <sys/stat.h>
7 #include "numtostr.h"
8 #include "bit.h"
9 #include "debug.h"
10
11 const char hextable[32] =
12 "0123456789ABCDEF"
13 "0123456789abcdef";
14
15 static const char filesize_unit_prefixes[8] = "KMGTPEZY";
16
17 1084 static size_t umax_count_base10_digits(uintmax_t x)
18 {
19 1084 size_t digits = 0;
20 2801 do {
21 2801 x /= 10;
22 2801 digits++;
23
2/2
✓ Branch 0 (3→4) taken 1717 times.
✓ Branch 1 (3→5) taken 1084 times.
 2801 } while (x);
24 1084 return digits;
25 }
26
27 // Writes the decimal string representation of `x` into `buf`,
28 // which must have enough space available for a known/constant
29 // value of `x` or `DECIMAL_STR_MAX(x)` bytes for arbitrary values.
30 // Returns the number of bytes (digits) written.
31 1084 size_t buf_umax_to_str(uintmax_t x, char *buf)
32 {
33 1084 const size_t ndigits = umax_count_base10_digits(x);
34 1084 size_t i = ndigits;
35 1084 buf[i--] = '\0';
36 2801 do {
37 2801 buf[i--] = (x % 10) + '0';
38
2/2
✓ Branch 0 (4→4) taken 1717 times.
✓ Branch 1 (4→5) taken 1084 times.
 2801 } while (x /= 10);
39 1084 return ndigits;
40 }
41
42 // Like buf_umax_to_str(), but writing a hexadecimal string and
43 // needing `HEX_STR_MAX(x)` bytes of buffer space for arbitrary
44 // values. A minimum number of digits can also be specified, e.g.
45 // for use cases like "U+000A".
46 16 size_t buf_umax_to_hex_str(uintmax_t x, char *buf, size_t min_digits)
47 {
48
2/2
✓ Branch 0 (3→4) taken 10 times.
✓ Branch 1 (3→6) taken 6 times.
 16 const size_t ndigits = MAX(min_digits, umax_count_base16_digits(x));
49 10 BUG_ON(ndigits < 1);
50 16 size_t i = ndigits;
51 16 buf[i--] = '\0';
52 118 do {
53 118 unsigned int nibble = x & 0xF;
54 118 buf[i] = hextable[nibble];
55 118 x >>= 4;
56
2/2
✓ Branch 0 (7→7) taken 102 times.
✓ Branch 1 (7→8) taken 16 times.
 118 } while (i--);
57 16 return ndigits;
58 }
59
60 // Writes the decimal string representation of `x` into a static
61 // buffer and returns a pointer to it. Unlike buf_umax_to_str(),
62 // this can be done without counting the number of digits first,
63 // by beginning at the end of the buffer and returning a pointer
64 // to the "first" (last written) byte offset.
65 12050 const char *umax_to_str(uintmax_t x)
66 {
67 12050 static char buf[DECIMAL_STR_MAX(x)];
68 12050 size_t i = sizeof(buf) - 2;
69 49050 do {
70 49050 buf[i--] = (x % 10) + '0';
71
2/2
✓ Branch 0 (3→4) taken 37000 times.
✓ Branch 1 (3→5) taken 12050 times.
 49050 } while (x /= 10);
72 12050 return &buf[i + 1];
73 }
74
75 // Like buf_umax_to_str() but for uint8_t values (1-3 digits)
76 28 size_t buf_u8_to_str(uint8_t x, char *buf)
77 {
78 28 size_t ndigits = 1;
79
2/2
✓ Branch 0 (2→3) taken 15 times.
✓ Branch 1 (2→4) taken 13 times.
 28 if (x >= 100) {
80 15 buf[2] = (x % 10) + '0';
81 15 x /= 10;
82 15 ndigits++;
83 }
84
85
2/2
✓ Branch 0 (4→5) taken 24 times.
✓ Branch 1 (4→6) taken 4 times.
 28 if (x >= 10) {
86 24 buf[1] = (x % 10) + '0';
87 24 x /= 10;
88 24 ndigits++;
89 }
90
91 28 buf[0] = (x % 10) + '0';
92 28 return ndigits;
93 }
94
95 12035 const char *uint_to_str(unsigned int x)
96 {
97 12035 return umax_to_str(x);
98 }
99
100 2 const char *ulong_to_str(unsigned long x)
101 {
102 2 return umax_to_str(x);
103 }
104
105 983 size_t buf_uint_to_str(unsigned int x, char *buf)
106 {
107 983 return buf_umax_to_str(x, buf);
108 }
109
110 #ifdef S_ISVTX
111 # define VTXBIT (S_ISVTX)
112 #else
113 # define VTXBIT ((mode_t)0)
114 #endif
115
116 /*
117 * Write the string representation of permission bits from `mode` into `buf`.
118 * This follows the POSIX ls(1) format, but excludes the "is a directory"
119 * clause for the T/t field (as permitted by the spec).
120 *
121 * See also:
122 *
123 * • https://pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html#tag_20_73_10:~:text=three%20character%20positions
124 * • https://gnu.org/software/coreutils/manual/html_node/What-information-is-listed.html#index-long-ls-format
125 */
126 20 char *file_permissions_to_str(mode_t mode, char buf[10])
127 {
128 20 static const char xmap[8] = "-xSs-xTt";
129
130 // Owner
131
2/2
✓ Branch 0 (2→3) taken 14 times.
✓ Branch 1 (2→4) taken 6 times.
 20 buf[0] = (mode & S_IRUSR) ? 'r' : '-';
132
2/2
✓ Branch 0 (4→5) taken 15 times.
✓ Branch 1 (4→6) taken 5 times.
 20 buf[1] = (mode & S_IWUSR) ? 'w' : '-';
133 20 buf[2] = xmap[((mode & S_IXUSR) >> 6) | ((mode & S_ISUID) >> 10)];
134
135 // Group
136
2/2
✓ Branch 0 (6→7) taken 15 times.
✓ Branch 1 (6→8) taken 5 times.
 20 buf[3] = (mode & S_IRGRP) ? 'r' : '-';
137
2/2
✓ Branch 0 (8→9) taken 16 times.
✓ Branch 1 (8→10) taken 4 times.
 20 buf[4] = (mode & S_IWGRP) ? 'w' : '-';
138 20 buf[5] = xmap[((mode & S_IXGRP) >> 3) | ((mode & S_ISGID) >> 9)];
139
140 // Others
141
2/2
✓ Branch 0 (10→11) taken 14 times.
✓ Branch 1 (10→12) taken 6 times.
 20 buf[6] = (mode & S_IROTH) ? 'r' : '-';
142
2/2
✓ Branch 0 (12→13) taken 15 times.
✓ Branch 1 (12→14) taken 5 times.
 20 buf[7] = (mode & S_IWOTH) ? 'w' : '-';
143 20 buf[8] = xmap[4 + ((mode & S_IXOTH) | ((mode & VTXBIT) >> 8))];
144
145 20 buf[9] = '\0';
146 20 return buf;
147 }
148
149 // Write an approximate, human-readable representation of `bytes` into
150 // `buf`, using IEC 80000-13 units (e.g. KiB, MiB, etc.) and (optionally)
151 // a 2 digit decimal fraction
152 65 char *human_readable_size(uintmax_t bytes, char buf[HRSIZE_MAX])
153 {
154 65 unsigned int sigbits = umax_bitwidth(bytes);
155 65 unsigned int nr_unit_shifts = (sigbits - !!sigbits) / 10;
156 65 uintmax_t ipart = bytes >> (nr_unit_shifts * 10);
157 65 uintmax_t unit = ((uintmax_t)1) << (nr_unit_shifts * 10);
158 65 uintmax_t hundredth = unit / 100;
159 65 unsigned int fpart = 0;
160
161
2/2
✓ Branch 0 (2→3) taken 57 times.
✓ Branch 1 (2→5) taken 8 times.
 65 if (hundredth) {
162 57 uintmax_t remainder = bytes & (unit - 1);
163 57 unsigned int f = remainder / hundredth;
164 57 ipart += (f > 99);
165
2/2
✓ Branch 0 (3→4) taken 6 times.
✓ Branch 1 (3→5) taken 51 times.
 57 fpart = (f > 99) ? 0 : f;
166 }
167
168 65 size_t i = buf_umax_to_str(ipart, buf);
169
170
2/2
✓ Branch 0 (6→7) taken 24 times.
✓ Branch 1 (6→8) taken 41 times.
 65 if (fpart > 0) {
171 24 buf[i++] = '.';
172 24 buf[i++] = '0' + ((fpart / 10) % 10);
173 24 buf[i++] = '0' + (fpart % 10);
174 }
175
176
2/2
✓ Branch 0 (8→9) taken 57 times.
✓ Branch 1 (8→10) taken 8 times.
 65 if (nr_unit_shifts > 0) {
177 57 buf[i++] = ' ';
178 57 buf[i++] = filesize_unit_prefixes[nr_unit_shifts - 1];
179 57 buf[i++] = 'i';
180 57 buf[i++] = 'B';
181 }
182
183 65 buf[i] = '\0';
184 65 return buf;
185 }
186
187 // Like human_readable_size(), but also printing the exact number
188 // of bytes in parentheses, e.g. 1024 → "1 KiB (1024)"
189 6 char *filesize_to_str(uintmax_t bytes, char buf[FILESIZE_STR_MAX])
190 {
191 6 human_readable_size(bytes, buf);
192
2/2
✓ Branch 0 (3→4) taken 3 times.
✓ Branch 1 (3→6) taken 3 times.
 6 if (bytes < 1024) {
193 return buf;
194 }
195 3 size_t i = strlen(buf);
196 3 buf[i++] = ' ';
197 3 buf[i++] = '(';
198 3 i += buf_umax_to_str(bytes, buf + i);
199 3 buf[i++] = ')';
200 3 buf[i] = '\0';
201 3 return buf;
202 }
203
204 // Like human_readable_size(), but done in a way that's always round-trippable
205 // (without loss in precision) and thus only made as "human readable" as is
206 // possible under that constraint. While filesize_to_str() takes the approach
207 // of also including the exact number of bytes in parentheses, this function is
208 // for uses cases that call for a single, trivially parseable integer and unit.
209 // In practical terms this means that 1.5GiB (3 << 29) is printed as "1536MiB"
210 // and `(3 << 29) + 1` is printed as "1610612737".
211 18 char *filesize_to_str_precise(uintmax_t bytes, char buf[PRECISE_FILESIZE_STR_MAX])
212 {
213
2/2
✓ Branch 0 (2→3) taken 17 times.
✓ Branch 1 (2→4) taken 1 times.
 18 unsigned int tzcount = bytes ? umax_ctz(bytes) : 0; // Special case zero
214 18 unsigned int nr_unit_shifts = tzcount / 10;
215 18 unsigned int shift = nr_unit_shifts * 10;
216 18 size_t i = buf_umax_to_str(bytes >> shift, buf);
217
2/2
✓ Branch 0 (5→6) taken 9 times.
✓ Branch 1 (5→7) taken 9 times.
 18 if (nr_unit_shifts) {
218 9 buf[i++] = filesize_unit_prefixes[nr_unit_shifts - 1];
219 9 buf[i++] = 'i';
220 9 buf[i++] = 'B';
221 }
222 18 buf[i] = '\0';
223 18 return buf;
224 }
225