Inside Bitcoin

251static const int64_t UPPER_BOUND = 1000000000000000000LL - 1LL;
252
253/** Helper function for ParseFixedPoint */
254static inline bool ProcessMantissaDigit(char ch, int64_t &mantissa, int &mantissa_tzeros)
255{
256    if(ch == '0')
257        ++mantissa_tzeros;
258    else {
259        for (int i=0; i<=mantissa_tzeros; ++i) {
260            if (mantissa > (UPPER_BOUND / 10LL))
261                return false; /* overflow */
262            mantissa *= 10;
263        }
264        mantissa += ch - '0';
265        mantissa_tzeros = 0;
266    }
267    return true;
268}
269
270bool ParseFixedPoint(std::string_view val, int decimals, int64_t *amount_out)
271{
272    int64_t mantissa = 0;
273    int64_t exponent = 0;
274    int mantissa_tzeros = 0;
275    bool mantissa_sign = false;
276    bool exponent_sign = false;
277    int ptr = 0;
278    int end = val.size();
279    int point_ofs = 0;
280
281    if (ptr < end && val[ptr] == '-') {
282        mantissa_sign = true;
283        ++ptr;
284    }
285    if (ptr < end)
286    {
287        if (val[ptr] == '0') {
288            /* pass single 0 */
289            ++ptr;
290        } else if (val[ptr] >= '1' && val[ptr] <= '9') {
291            while (ptr < end && IsDigit(val[ptr])) {
292                if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
293                    return false; /* overflow */
294                ++ptr;
295            }
296        } else return false; /* missing expected digit */
297    } else return false; /* empty string or loose '-' */
298    if (ptr < end && val[ptr] == '.')
299    {
300        ++ptr;
301        if (ptr < end && IsDigit(val[ptr]))
302        {
303            while (ptr < end && IsDigit(val[ptr])) {
304                if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
305                    return false; /* overflow */
306                ++ptr;
307                ++point_ofs;
308            }
309        } else return false; /* missing expected digit */
310    }
311    if (ptr < end && (val[ptr] == 'e' || val[ptr] == 'E'))
312    {
313        ++ptr;
314        if (ptr < end && val[ptr] == '+')
315            ++ptr;
316        else if (ptr < end && val[ptr] == '-') {
317            exponent_sign = true;
318            ++ptr;
319        }
320        if (ptr < end && IsDigit(val[ptr])) {
321            while (ptr < end && IsDigit(val[ptr])) {
322                if (exponent > (UPPER_BOUND / 10LL))
323                    return false; /* overflow */
324                exponent = exponent * 10 + val[ptr] - '0';
325                ++ptr;
326            }
327        } else return false; /* missing expected digit */
328    }
329    if (ptr != end)
330        return false; /* trailing garbage */
331
332    /* finalize exponent */
333    if (exponent_sign)
334        exponent = -exponent;
335    exponent = exponent - point_ofs + mantissa_tzeros;
336
337    /* finalize mantissa */
338    if (mantissa_sign)
339        mantissa = -mantissa;
340
341    /* convert to one 64-bit fixed-point value */
342    exponent += decimals;
343    if (exponent < 0)
344        return false; /* cannot represent values smaller than 10^-decimals */
345    if (exponent >= 18)
346        return false; /* cannot represent values larger than or equal to 10^(18-decimals) */
347
348    for (int i=0; i < exponent; ++i) {
349        if (mantissa > (UPPER_BOUND / 10LL) || mantissa < -(UPPER_BOUND / 10LL))
350            return false; /* overflow */
351        mantissa *= 10;
352    }
353    if (mantissa > UPPER_BOUND || mantissa < -UPPER_BOUND)
354        return false; /* overflow */
355
356    if (amount_out)
357        *amount_out = mantissa;
358
359    return true;
360}
361
362std::string ToLower(std::string_view str)
363{
364    std::string r;
365    r.reserve(str.size());
366    for (auto ch : str) r += ToLower(ch);
367    return r;
368}
369
370std::string ToUpper(std::string_view str)
371{
372    std::string r;
373    r.reserve(str.size());
374    for (auto ch : str) r += ToUpper(ch);
375    return r;
376}
377
378std::string Capitalize(std::string str)
379{
380    if (str.empty()) return str;
381    str[0] = ToUpper(str.front());
382    return str;
383}
384
385std::optional<uint64_t> ParseByteUnits(std::string_view str, ByteUnit default_multiplier)
386{
387    if (str.empty()) {
388        return std::nullopt;
389    }
390    auto multiplier = default_multiplier;
391    char unit = str.back();
392    switch (unit) {
393    case 'k':
394        multiplier = ByteUnit::k;
395        break;
396    case 'K':
397        multiplier = ByteUnit::K;
398        break;
399    case 'm':
400        multiplier = ByteUnit::m;
401        break;
402    case 'M':
403        multiplier = ByteUnit::M;
404        break;
405    case 'g':
406        multiplier = ByteUnit::g;
407        break;
408    case 'G':
409        multiplier = ByteUnit::G;
410        break;
411    case 't':
412        multiplier = ByteUnit::t;
413        break;
414    case 'T':
415        multiplier = ByteUnit::T;
416        break;
417    default:
418        unit = 0;
419        break;
420    }
421
422    uint64_t unit_amount = static_cast<uint64_t>(multiplier);
423    auto parsed_num = ToIntegral<uint64_t>(unit ? str.substr(0, str.size() - 1) : str);
424    if (!parsed_num || parsed_num > std::numeric_limits<uint64_t>::max() / unit_amount) { // check overflow
425        return std::nullopt;
426    }
427    return *parsed_num * unit_amount;
428}
429
430bool CaseInsensitiveEqual(std::string_view s1, std::string_view s2)
431{
432    if (s1.size() != s2.size()) return false;
433    for (size_t i = 0; i < s1.size(); ++i) {
434        char c1 = s1[i];
435        if (c1 >= 'A' && c1 <= 'Z') c1 -= ('A' - 'a');
436        char c2 = s2[i];
437        if (c2 >= 'A' && c2 <= 'Z') c2 -= ('A' - 'a');
438        if (c1 != c2) return false;
439    }
440    return true;
441}
442