Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2022 The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <span.h>
7 : : #include <util/strencodings.h>
8 : :
9 : : #include <array>
10 : : #include <cassert>
11 : : #include <cstring>
12 : : #include <limits>
13 : : #include <optional>
14 : : #include <ostream>
15 : : #include <string>
16 : : #include <vector>
17 : :
18 [ + - ]: 173 : static const std::string CHARS_ALPHA_NUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
19 : :
20 : 0 : static const std::string SAFE_CHARS[] =
21 : 173 : {
22 [ + - ]: 173 : CHARS_ALPHA_NUM + " .,;-_/:?@()", // SAFE_CHARS_DEFAULT
23 [ + - ]: 173 : CHARS_ALPHA_NUM + " .,;-_?@", // SAFE_CHARS_UA_COMMENT
24 [ + - ]: 173 : CHARS_ALPHA_NUM + ".-_", // SAFE_CHARS_FILENAME
25 [ + - ]: 173 : CHARS_ALPHA_NUM + "!*'();:@&=+$,/?#[]-_.~%", // SAFE_CHARS_URI
26 : : };
27 : :
28 : 12845 : std::string SanitizeString(std::string_view str, int rule)
29 : : {
30 : 12845 : std::string result;
31 [ + + ]: 98241 : for (char c : str) {
32 [ + + ]: 85396 : if (SAFE_CHARS[rule].find(c) != std::string::npos) {
33 [ + - ]: 35737 : result.push_back(c);
34 : 35737 : }
35 : : }
36 : 12845 : return result;
37 [ + - ]: 12845 : }
38 : :
39 : : const signed char p_util_hexdigit[256] =
40 : : { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
41 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
42 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
43 : : 0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,
44 : : -1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
45 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
46 : : -1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
47 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
48 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
49 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
50 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
51 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
52 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
53 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
54 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
55 : : -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, };
56 : :
57 : 225280929 : signed char HexDigit(char c)
58 : : {
59 : 225280929 : return p_util_hexdigit[(unsigned char)c];
60 : : }
61 : :
62 : 33717 : bool IsHex(std::string_view str)
63 : : {
64 [ + + ]: 94240297 : for (char c : str) {
65 [ + + ]: 94213579 : if (HexDigit(c) < 0) return false;
66 : : }
67 [ + + ]: 26718 : return (str.size() > 0) && (str.size()%2 == 0);
68 : 33717 : }
69 : :
70 : 214 : bool IsHexNumber(std::string_view str)
71 : : {
72 [ + + ]: 214 : if (str.substr(0, 2) == "0x") str.remove_prefix(2);
73 [ + + ]: 9891324 : for (char c : str) {
74 [ + + ]: 9891154 : if (HexDigit(c) < 0) return false;
75 : : }
76 : : // Return false for empty string or "0x".
77 : 170 : return str.size() > 0;
78 : 214 : }
79 : :
80 : : template <typename Byte>
81 : 69682 : std::optional<std::vector<Byte>> TryParseHex(std::string_view str)
82 : : {
83 : 69682 : std::vector<Byte> vch;
84 : 69682 : auto it = str.begin();
85 [ + + + + ]: 52583397 : while (it != str.end()) {
86 [ + + + + ]: 52513743 : if (IsSpace(*it)) {
87 : 1882 : ++it;
88 : 1882 : continue;
89 : : }
90 : 52511861 : auto c1 = HexDigit(*(it++));
91 [ + + + + ]: 52511861 : if (it == str.end()) return std::nullopt;
92 : 52511839 : auto c2 = HexDigit(*(it++));
93 [ + + + + : 52511839 : if (c1 < 0 || c2 < 0) return std::nullopt;
+ + + + ]
94 [ + - + - ]: 52511833 : vch.push_back(Byte(c1 << 4) | Byte(c2));
95 : : }
96 [ + - + - ]: 69654 : return vch;
97 : 69682 : }
98 : : template std::optional<std::vector<std::byte>> TryParseHex(std::string_view);
99 : : template std::optional<std::vector<uint8_t>> TryParseHex(std::string_view);
100 : :
101 : 3716 : bool SplitHostPort(std::string_view in, uint16_t& portOut, std::string& hostOut)
102 : : {
103 : 3716 : bool valid = false;
104 : 3716 : size_t colon = in.find_last_of(':');
105 : : // if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
106 : 3716 : bool fHaveColon = colon != in.npos;
107 [ + + + + ]: 4331 : bool fBracketed = fHaveColon && (in[0] == '[' && in[colon - 1] == ']'); // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is safe
108 [ + + + + ]: 3716 : bool fMultiColon{fHaveColon && colon != 0 && (in.find_last_of(':', colon - 1) != in.npos)};
109 [ + + + + : 3716 : if (fHaveColon && (colon == 0 || fBracketed || !fMultiColon)) {
+ + + + ]
110 : : uint16_t n;
111 [ + + ]: 513 : if (ParseUInt16(in.substr(colon + 1), &n)) {
112 : 45 : in = in.substr(0, colon);
113 : 45 : portOut = n;
114 : 45 : valid = (portOut != 0);
115 : 45 : }
116 : 513 : } else {
117 : 3203 : valid = true;
118 : : }
119 [ + + + + : 3716 : if (in.size() > 0 && in[0] == '[' && in[in.size() - 1] == ']') {
+ + ]
120 : 7 : hostOut = in.substr(1, in.size() - 2);
121 : 7 : } else {
122 : 3709 : hostOut = in;
123 : : }
124 : :
125 : 3716 : return valid;
126 : : }
127 : :
128 : 35841 : std::string EncodeBase64(Span<const unsigned char> input)
129 : : {
130 : : static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
131 : :
132 : 35841 : std::string str;
133 [ + - ]: 35841 : str.reserve(((input.size() + 2) / 3) * 4);
134 [ + - ]: 46887386 : ConvertBits<8, 6, true>([&](int v) { str += pbase64[v]; }, input.begin(), input.end());
135 [ + + + - ]: 70964 : while (str.size() % 4) str += '=';
136 : 35841 : return str;
137 [ + - ]: 35841 : }
138 : :
139 : 6911 : std::optional<std::vector<unsigned char>> DecodeBase64(std::string_view str)
140 : : {
141 : : static const int8_t decode64_table[256]{
142 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
143 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
144 : : -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
145 : : -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
146 : : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
147 : : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
148 : : 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
149 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
150 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
151 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
152 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
153 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
154 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
155 : : };
156 : :
157 [ + + ]: 6911 : if (str.size() % 4 != 0) return {};
158 : : /* One or two = characters at the end are permitted. */
159 [ + + + + ]: 6761 : if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
160 [ + + + + ]: 6761 : if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
161 : :
162 : 6761 : std::vector<unsigned char> ret;
163 [ + - ]: 6761 : ret.reserve((str.size() * 3) / 4);
164 [ + - ]: 6761 : bool valid = ConvertBits<6, 8, false>(
165 : 22063080 : [&](unsigned char c) { ret.push_back(c); },
166 : 6761 : str.begin(), str.end(),
167 : 29410302 : [](char c) { return decode64_table[uint8_t(c)]; }
168 : : );
169 [ + + ]: 6761 : if (!valid) return {};
170 : :
171 [ + - ]: 6701 : return ret;
172 : 6911 : }
173 : :
174 : 743345 : std::string EncodeBase32(Span<const unsigned char> input, bool pad)
175 : : {
176 : : static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
177 : :
178 : 743345 : std::string str;
179 [ + - ]: 743345 : str.reserve(((input.size() + 4) / 5) * 8);
180 [ + - ]: 46267239 : ConvertBits<8, 5, true>([&](int v) { str += pbase32[v]; }, input.begin(), input.end());
181 [ - + ]: 743345 : if (pad) {
182 [ + + ]: 759555 : while (str.size() % 8) {
183 [ + - ]: 16210 : str += '=';
184 : : }
185 : 743345 : }
186 : 743345 : return str;
187 [ + - ]: 743345 : }
188 : :
189 : 5431 : std::string EncodeBase32(std::string_view str, bool pad)
190 : : {
191 : 5431 : return EncodeBase32(MakeUCharSpan(str), pad);
192 : : }
193 : :
194 : 635861 : std::optional<std::vector<unsigned char>> DecodeBase32(std::string_view str)
195 : : {
196 : : static const int8_t decode32_table[256]{
197 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
198 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
199 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,
200 : : -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
201 : : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 0, 1, 2,
202 : : 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
203 : : 23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
204 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
205 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
206 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
207 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
208 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
209 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
210 : : };
211 : :
212 [ + + ]: 635861 : if (str.size() % 8 != 0) return {};
213 : : /* 1, 3, 4, or 6 padding '=' suffix characters are permitted. */
214 [ + - + + ]: 632445 : if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
215 [ + - + + ]: 632445 : if (str.size() >= 2 && str.substr(str.size() - 2) == "==") str.remove_suffix(2);
216 [ + - + + ]: 632445 : if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
217 [ + - + + ]: 632445 : if (str.size() >= 2 && str.substr(str.size() - 2) == "==") str.remove_suffix(2);
218 : :
219 : 632445 : std::vector<unsigned char> ret;
220 [ + - ]: 632445 : ret.reserve((str.size() * 5) / 8);
221 [ + - ]: 632445 : bool valid = ConvertBits<5, 8, false>(
222 : 22753166 : [&](unsigned char c) { ret.push_back(c); },
223 : 632445 : str.begin(), str.end(),
224 : 35394355 : [](char c) { return decode32_table[uint8_t(c)]; }
225 : : );
226 : :
227 [ + + ]: 632445 : if (!valid) return {};
228 : :
229 [ + - ]: 631886 : return ret;
230 : 635861 : }
231 : :
232 : : namespace {
233 : : template <typename T>
234 : 1375787 : bool ParseIntegral(std::string_view str, T* out)
235 : : {
236 : : static_assert(std::is_integral<T>::value);
237 : : // Replicate the exact behavior of strtol/strtoll/strtoul/strtoull when
238 : : // handling leading +/- for backwards compatibility.
239 [ + + + + : 1375787 : if (str.length() >= 2 && str[0] == '+' && str[1] == '-') {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + ]
240 : 32 : return false;
241 : : }
242 [ + + + + : 1375755 : const std::optional<T> opt_int = ToIntegral<T>((!str.empty() && str[0] == '+') ? str.substr(1) : str);
+ + + + +
+ + + + +
+ + + + +
+ + - +
+ ]
243 [ + + + + : 1375755 : if (!opt_int) {
+ + + + +
+ + + ]
244 : 1371 : return false;
245 : : }
246 [ + - + - : 1374384 : if (out != nullptr) {
+ - + - +
- + - ]
247 : 1374384 : *out = *opt_int;
248 : 1374384 : }
249 : 1374384 : return true;
250 : 1375787 : }
251 : : }; // namespace
252 : :
253 : 1379 : bool ParseInt32(std::string_view str, int32_t* out)
254 : : {
255 : 1379 : return ParseIntegral<int32_t>(str, out);
256 : : }
257 : :
258 : 45600 : bool ParseInt64(std::string_view str, int64_t* out)
259 : : {
260 : 45600 : return ParseIntegral<int64_t>(str, out);
261 : : }
262 : :
263 : 7323 : bool ParseUInt8(std::string_view str, uint8_t* out)
264 : : {
265 : 7323 : return ParseIntegral<uint8_t>(str, out);
266 : : }
267 : :
268 : 605 : bool ParseUInt16(std::string_view str, uint16_t* out)
269 : : {
270 : 605 : return ParseIntegral<uint16_t>(str, out);
271 : : }
272 : :
273 : 1320788 : bool ParseUInt32(std::string_view str, uint32_t* out)
274 : : {
275 : 1320788 : return ParseIntegral<uint32_t>(str, out);
276 : : }
277 : :
278 : 92 : bool ParseUInt64(std::string_view str, uint64_t* out)
279 : : {
280 : 92 : return ParseIntegral<uint64_t>(str, out);
281 : : }
282 : :
283 : 2725 : std::string FormatParagraph(std::string_view in, size_t width, size_t indent)
284 : : {
285 [ + - ]: 2725 : assert(width >= indent);
286 : 2725 : std::stringstream out;
287 : 2725 : size_t ptr = 0;
288 : 2725 : size_t indented = 0;
289 [ + + ]: 5376 : while (ptr < in.size())
290 : : {
291 : 2936 : size_t lineend = in.find_first_of('\n', ptr);
292 [ + + ]: 2936 : if (lineend == std::string::npos) {
293 : 2325 : lineend = in.size();
294 : 2325 : }
295 : 2936 : const size_t linelen = lineend - ptr;
296 : 2936 : const size_t rem_width = width - indented;
297 [ + + ]: 2936 : if (linelen <= rem_width) {
298 [ + - + - ]: 2487 : out << in.substr(ptr, linelen + 1);
299 : 2487 : ptr = lineend + 1;
300 : 2487 : indented = 0;
301 : 2487 : } else {
302 : 449 : size_t finalspace = in.find_last_of(" \n", ptr + rem_width);
303 [ + + + + ]: 449 : if (finalspace == std::string::npos || finalspace < ptr) {
304 : : // No place to break; just include the entire word and move on
305 : 346 : finalspace = in.find_first_of("\n ", ptr);
306 [ + + ]: 346 : if (finalspace == std::string::npos) {
307 : : // End of the string, just add it and break
308 [ + - + - ]: 285 : out << in.substr(ptr);
309 : 285 : break;
310 : : }
311 : 61 : }
312 [ + - + - : 164 : out << in.substr(ptr, finalspace - ptr) << "\n";
+ - ]
313 [ + + ]: 164 : if (in[finalspace] == '\n') {
314 : 27 : indented = 0;
315 [ + + ]: 164 : } else if (indent) {
316 [ + - + - ]: 90 : out << std::string(indent, ' ');
317 : 90 : indented = indent;
318 : 90 : }
319 : 164 : ptr = finalspace + 1;
320 : : }
321 : : }
322 [ + - ]: 2725 : return out.str();
323 : 2725 : }
324 : :
325 : : /** Upper bound for mantissa.
326 : : * 10^18-1 is the largest arbitrary decimal that will fit in a signed 64-bit integer.
327 : : * Larger integers cannot consist of arbitrary combinations of 0-9:
328 : : *
329 : : * 999999999999999999 1^18-1
330 : : * 9223372036854775807 (1<<63)-1 (max int64_t)
331 : : * 9999999999999999999 1^19-1 (would overflow)
332 : : */
333 : : static const int64_t UPPER_BOUND = 1000000000000000000LL - 1LL;
334 : :
335 : : /** Helper function for ParseFixedPoint */
336 : 592914 : static inline bool ProcessMantissaDigit(char ch, int64_t &mantissa, int &mantissa_tzeros)
337 : : {
338 [ + + ]: 592914 : if(ch == '0')
339 : 592011 : ++mantissa_tzeros;
340 : : else {
341 [ + + ]: 2525 : for (int i=0; i<=mantissa_tzeros; ++i) {
342 [ + + ]: 1641 : if (mantissa > (UPPER_BOUND / 10LL))
343 : 19 : return false; /* overflow */
344 : 1622 : mantissa *= 10;
345 : 1622 : }
346 : 884 : mantissa += ch - '0';
347 : 884 : mantissa_tzeros = 0;
348 : : }
349 : 592895 : return true;
350 : 592914 : }
351 : :
352 : 1381 : bool ParseFixedPoint(std::string_view val, int decimals, int64_t *amount_out)
353 : : {
354 : 1381 : int64_t mantissa = 0;
355 : 1381 : int64_t exponent = 0;
356 : 1381 : int mantissa_tzeros = 0;
357 : 1381 : bool mantissa_sign = false;
358 : 1381 : bool exponent_sign = false;
359 : 1381 : int ptr = 0;
360 : 1381 : int end = val.size();
361 : 1381 : int point_ofs = 0;
362 : :
363 [ + + + + ]: 1381 : if (ptr < end && val[ptr] == '-') {
364 : 19 : mantissa_sign = true;
365 : 19 : ++ptr;
366 : 19 : }
367 [ + + ]: 1381 : if (ptr < end)
368 : : {
369 [ + + ]: 1368 : if (val[ptr] == '0') {
370 : : /* pass single 0 */
371 : 40 : ++ptr;
372 [ + + + + ]: 1368 : } else if (val[ptr] >= '1' && val[ptr] <= '9') {
373 [ + + + + ]: 592386 : while (ptr < end && IsDigit(val[ptr])) {
374 [ + + ]: 592235 : if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
375 : 16 : return false; /* overflow */
376 : 592219 : ++ptr;
377 : : }
378 : 1312 : } else return false; /* missing expected digit */
379 : 204 : } else return false; /* empty string or loose '-' */
380 [ + + + + ]: 191 : if (ptr < end && val[ptr] == '.')
381 : : {
382 : 58 : ++ptr;
383 [ + + + + ]: 58 : if (ptr < end && IsDigit(val[ptr]))
384 : : {
385 [ + + + + ]: 728 : while (ptr < end && IsDigit(val[ptr])) {
386 [ + + ]: 679 : if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
387 : 3 : return false; /* overflow */
388 : 676 : ++ptr;
389 : 676 : ++point_ofs;
390 : : }
391 : 55 : } else return false; /* missing expected digit */
392 : 49 : }
393 [ + + + + : 182 : if (ptr < end && (val[ptr] == 'e' || val[ptr] == 'E'))
+ + ]
394 : : {
395 : 50 : ++ptr;
396 [ + + + + ]: 50 : if (ptr < end && val[ptr] == '+')
397 : 3 : ++ptr;
398 [ + + + + ]: 47 : else if (ptr < end && val[ptr] == '-') {
399 : 3 : exponent_sign = true;
400 : 3 : ++ptr;
401 : 3 : }
402 [ + + + + ]: 50 : if (ptr < end && IsDigit(val[ptr])) {
403 [ + + + + ]: 577 : while (ptr < end && IsDigit(val[ptr])) {
404 [ + + ]: 539 : if (exponent > (UPPER_BOUND / 10LL))
405 : 4 : return false; /* overflow */
406 : 535 : exponent = exponent * 10 + val[ptr] - '0';
407 : 535 : ++ptr;
408 : : }
409 : 46 : } else return false; /* missing expected digit */
410 : 38 : }
411 [ + + ]: 170 : if (ptr != end)
412 : 21 : return false; /* trailing garbage */
413 : :
414 : : /* finalize exponent */
415 [ + + ]: 149 : if (exponent_sign)
416 : 3 : exponent = -exponent;
417 : 149 : exponent = exponent - point_ofs + mantissa_tzeros;
418 : :
419 : : /* finalize mantissa */
420 [ + + ]: 149 : if (mantissa_sign)
421 : 15 : mantissa = -mantissa;
422 : :
423 : : /* convert to one 64-bit fixed-point value */
424 : 149 : exponent += decimals;
425 [ + + ]: 149 : if (exponent < 0)
426 : 26 : return false; /* cannot represent values smaller than 10^-decimals */
427 [ + + ]: 123 : if (exponent >= 18)
428 : 22 : return false; /* cannot represent values larger than or equal to 10^(18-decimals) */
429 : :
430 [ + + ]: 583 : for (int i=0; i < exponent; ++i) {
431 [ + + + + ]: 499 : if (mantissa > (UPPER_BOUND / 10LL) || mantissa < -(UPPER_BOUND / 10LL))
432 : 17 : return false; /* overflow */
433 : 482 : mantissa *= 10;
434 : 482 : }
435 [ + - - + ]: 84 : if (mantissa > UPPER_BOUND || mantissa < -UPPER_BOUND)
436 : 0 : return false; /* overflow */
437 : :
438 [ + - ]: 84 : if (amount_out)
439 : 84 : *amount_out = mantissa;
440 : :
441 : 84 : return true;
442 : 1381 : }
443 : :
444 : 4719 : std::string ToLower(std::string_view str)
445 : : {
446 : 4719 : std::string r;
447 [ + + + - : 34122516 : for (auto ch : str) r += ToLower(ch);
+ - ]
448 : 4719 : return r;
449 [ + - ]: 4719 : }
450 : :
451 : 1749 : std::string ToUpper(std::string_view str)
452 : : {
453 : 1749 : std::string r;
454 [ + + + - : 525015 : for (auto ch : str) r += ToUpper(ch);
+ - ]
455 : 1749 : return r;
456 [ + - ]: 1749 : }
457 : :
458 : 342 : std::string Capitalize(std::string str)
459 : : {
460 [ + + ]: 342 : if (str.empty()) return str;
461 : 332 : str[0] = ToUpper(str.front());
462 : 332 : return str;
463 : 342 : }
464 : :
465 : : namespace {
466 : :
467 : : using ByteAsHex = std::array<char, 2>;
468 : :
469 : : constexpr std::array<ByteAsHex, 256> CreateByteToHexMap()
470 : : {
471 : : constexpr char hexmap[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
472 : :
473 : : std::array<ByteAsHex, 256> byte_to_hex{};
474 : : for (size_t i = 0; i < byte_to_hex.size(); ++i) {
475 : : byte_to_hex[i][0] = hexmap[i >> 4];
476 : : byte_to_hex[i][1] = hexmap[i & 15];
477 : : }
478 : : return byte_to_hex;
479 : : }
480 : :
481 : : } // namespace
482 : :
483 : 9442047 : std::string HexStr(const Span<const uint8_t> s)
484 : : {
485 [ + - ]: 9442047 : std::string rv(s.size() * 2, '\0');
486 : : static constexpr auto byte_to_hex = CreateByteToHexMap();
487 : : static_assert(sizeof(byte_to_hex) == 512);
488 : :
489 : 9442047 : char* it = rv.data();
490 [ + + ]: 271979083 : for (uint8_t v : s) {
491 : 262537036 : std::memcpy(it, byte_to_hex[v].data(), 2);
492 : 262537036 : it += 2;
493 : : }
494 : :
495 [ - + ]: 9442047 : assert(it == rv.data() + rv.size());
496 : 9442047 : return rv;
497 [ + - ]: 9442047 : }
498 : :
499 : 0 : std::optional<uint64_t> ParseByteUnits(std::string_view str, ByteUnit default_multiplier)
500 : : {
501 [ # # ]: 0 : if (str.empty()) {
502 : 0 : return std::nullopt;
503 : : }
504 : 0 : auto multiplier = default_multiplier;
505 : 0 : char unit = str.back();
506 [ # # # # : 0 : switch (unit) {
# # # #
# ]
507 : : case 'k':
508 : 0 : multiplier = ByteUnit::k;
509 : 0 : break;
510 : : case 'K':
511 : 0 : multiplier = ByteUnit::K;
512 : 0 : break;
513 : : case 'm':
514 : 0 : multiplier = ByteUnit::m;
515 : 0 : break;
516 : : case 'M':
517 : 0 : multiplier = ByteUnit::M;
518 : 0 : break;
519 : : case 'g':
520 : 0 : multiplier = ByteUnit::g;
521 : 0 : break;
522 : : case 'G':
523 : 0 : multiplier = ByteUnit::G;
524 : 0 : break;
525 : : case 't':
526 : 0 : multiplier = ByteUnit::t;
527 : 0 : break;
528 : : case 'T':
529 : 0 : multiplier = ByteUnit::T;
530 : 0 : break;
531 : : default:
532 : 0 : unit = 0;
533 : 0 : break;
534 : : }
535 : :
536 : 0 : uint64_t unit_amount = static_cast<uint64_t>(multiplier);
537 [ # # ]: 0 : auto parsed_num = ToIntegral<uint64_t>(unit ? str.substr(0, str.size() - 1) : str);
538 [ # # # # ]: 0 : if (!parsed_num || parsed_num > std::numeric_limits<uint64_t>::max() / unit_amount) { // check overflow
539 : 0 : return std::nullopt;
540 : : }
541 : 0 : return *parsed_num * unit_amount;
542 : 0 : }
|
