ieee754_parse_decimal()

u32 fl::ieee754_parse_decimal	(	const char *	s,
		fl::size	len,
		fl::size *	consumed = nullptr )

Parse a decimal floating-point number into IEEE 754 single-precision bits.

Accepts the usual decimal syntax: optional sign, integer digits, optional fractional part, optional e/E exponent. Returns the IEEE 754 single-precision bit pattern of the parsed value. Caller bit-casts to float via fl::bit_cast<float>(bits) if needed.

No FP arithmetic is performed. The implementation uses only integer shifts, masks, and 32x32->64 widening multiplies – libgcc soft-FP helpers (__aeabi_d*, __aeabi_f*) are never reached.

Failure mode: malformed inputs return 0x00000000 (positive zero) and set *consumed to 0. Inputs that overflow IEEE 754 single-precision range (>~3.4e38) clamp to +inf / -inf bit patterns. Inputs that underflow (>~1.4e-45) clamp to +/-0.

Parameters

s	Pointer to the decimal text.
len	Length of the text in bytes (no NUL terminator assumed).
consumed	If non-null, receives the number of bytes consumed. Useful for caller-side bookkeeping (e.g. JSON tokenizer).

Returns

IEEE 754 single-precision bit pattern.

Definition at line 261 of file ieee754_string.cpp.hpp.

                                                                                   {
    fl::size i = 0;
 
    auto fail = [&]() -> u32 {
        if (consumed) *consumed = 0;
        return 0;
    };
 
    // Skip leading whitespace.
    while (i < len && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' ||
                       s[i] == '\r' || s[i] == '\f' || s[i] == '\v')) {
        ++i;
    }
 
    // Sign.
    u32 sign_bit = 0;
    if (i < len && s[i] == '-') { sign_bit = kSignBitMask; ++i; }
    else if (i < len && s[i] == '+') { ++i; }
 
    // Mantissa: integer + optional fractional. Cap at 19 significant decimal
    // digits -- that is the max u64 can hold (10**19 < 2**64). Beyond that we
    // drop digits but keep tracking the decimal exponent so values like
    // "100000000000000000000" (1e20) still round to the right magnitude.
    fl::u64 mantissa = 0;
    int decimal_exp = 0;
    int significant_digits = 0;
    bool seen_decimal = false;
    bool seen_digit = false;
    constexpr int kMaxSignificantDigits = 19;
 
    while (i < len) {
        const char c = s[i];
        if (c >= '0' && c <= '9') {
            seen_digit = true;
            if (significant_digits < kMaxSignificantDigits) {
                // u64 max is ~1.8e19, mantissa * 10 + 9 stays below for 18 digits.
                mantissa = mantissa * 10u + static_cast<fl::u64>(c - '0');
                if (significant_digits != 0 || c != '0') {
                    ++significant_digits;
                }
                if (seen_decimal) {
                    --decimal_exp;
                }
            } else {
                // Out of mantissa precision -- track magnitude via decimal_exp only.
                if (!seen_decimal) {
                    ++decimal_exp;
                }
            }
            ++i;
        } else if (c == '.' && !seen_decimal) {
            seen_decimal = true;
            ++i;
        } else {
            break;
        }
    }
 
    // Reject inputs that contained no digit (e.g. "", ".", "-.", "+.", "e5").
    // `i == mantissa_start` only catches "" and "-"/"+" -- a lone "." passes
    // the start-position guard because the loop consumed it.
    if (!seen_digit) {
        return fail();
    }
 
    // Optional exponent.
    if (i < len && (s[i] == 'e' || s[i] == 'E')) {
        const fl::size exp_start = i + 1;
        fl::size j = exp_start;
        int exp_sign = 1;
        if (j < len && s[j] == '-') { exp_sign = -1; ++j; }
        else if (j < len && s[j] == '+') { ++j; }
        int exp_val = 0;
        const fl::size digits_begin = j;
        while (j < len && s[j] >= '0' && s[j] <= '9') {
            if (exp_val < 10000) {
                exp_val = exp_val * 10 + (s[j] - '0');
            }
            ++j;
        }
        if (j != digits_begin) {
            decimal_exp += exp_sign * exp_val;
            i = j;
        }
        // else: lone 'e' with no digits -- treat as end-of-number, leave i at 'e'.
    }
 
    if (consumed) *consumed = i;
 
    if (mantissa == 0) {
        return sign_bit;
    }
 
    // Normalize mantissa into [2**63, 2**64) so the top bit is set. The
    // shift count becomes part of the binary exponent.
    int mantissa_shift = 0;
    while ((mantissa & 0x8000000000000000ull) == 0) {
        mantissa <<= 1;
        ++mantissa_shift;
    }
    // After normalization: original_mantissa = mantissa * 2**(-mantissa_shift).
 
    // Out-of-table decimal exponent: under/overflow before we even multiply.
    // The table floor (kPow10KMin) is chosen so the parser's raw 19-digit
    // mantissa still covers IEEE 754 single-precision range -- see
    // ci/tools/gen_pow10_table.py.
    if (decimal_exp < kPow10KMin) {
        return sign_bit;  // +/- 0
    }
    if (decimal_exp > kPow10KMax) {
        return sign_bit | kInfBitsPos;  // +/- inf
    }
 
    const fl::size idx = static_cast<fl::size>(decimal_exp - kPow10KMin);
    const fl::u64 pow_mant = kPow10Mant[idx];
    const int    pow_exp  = kPow10BExp[idx];
 
    fl::u64 product_hi = mul_hi_u64(mantissa, pow_mant);
    // The full product (mantissa * pow_mant) is in [2**126, 2**128). Its top
    // 64 bits (product_hi) are in [2**62, 2**64). If bit 63 isn't set,
    // shift left by 1 to renormalize and consume one binary-exponent unit.
    int extra_shift = 0;
    if ((product_hi & 0x8000000000000000ull) == 0) {
        product_hi <<= 1;
        extra_shift = 1;
    }
 
    // Binary exponent of the renormalized mantissa: combines the input
    // mantissa shift, the pow10 binary exponent, the +64 for taking the
    // top half of the 128-bit product, and the renormalization shift.
    int bin_exp = -mantissa_shift + pow_exp + 64 - extra_shift;
 
    // IEEE 754 single-precision biased exponent: the implicit-1 form is
    // product_hi / 2**63, so the unbiased binary exponent is (bin_exp + 63).
    int biased_exp = bin_exp + 63 + 127;
 
    if (biased_exp >= 0xFF) {
        return sign_bit | kInfBitsPos;  // +/- inf
    }
    if (biased_exp <= 0) {
        // Subnormal / underflow. For embedded-grade precision we collapse
        // to +/- 0 -- the JSON-RPC use case never needs denormals, and
        // avoiding the subnormal path keeps the bit-twiddling logic compact.
        return sign_bit;
    }
 
    // Extract the 23-bit mantissa from the top 64 bits with round-half-to-even.
    //   product_hi bits [62:40] -> ieee_mant bits [22:0]
    //   product_hi bit  [39]    -> rounding bit
    //   product_hi bits [38:0]  -> sticky bits
    fl::u32 ieee_mant = static_cast<fl::u32>((product_hi >> 40) & 0x7FFFFFu);
    const fl::u64 round_bit = (product_hi >> 39) & 1u;
    const fl::u64 sticky = (product_hi & 0x7FFFFFFFFFull);  // bits [38:0]
    if (round_bit && (sticky != 0 || (ieee_mant & 1u))) {
        ++ieee_mant;
        if (ieee_mant == (1u << 23)) {
            // Mantissa overflow on rounding -- re-renormalize.
            ieee_mant = 0;
            ++biased_exp;
            if (biased_exp >= 0xFF) {
                return sign_bit | kInfBitsPos;
            }
        }
    }
 
    return sign_bit | (static_cast<fl::u32>(biased_exp) << 23) | ieee_mant;
}

References FL_NOEXCEPT.

Referenced by fl::anonymous_namespace{json.cpp.hpp}::JsonBuilder::on_token(), fl::anonymous_namespace{json.cpp.hpp}::JsonBuilder::parse_float_array(), and fl::anonymous_namespace{json.cpp.hpp}::JsonTokenizer::scan_array_lookahead().

Here is the caller graph for this function: