Function ieee754_format_decimal

src/fl/stl/ieee754_string.cpp.hpp:439–553

}

fl::string ieee754_format_decimal(u32 bits, int precision) FL_NOEXCEPT {
    if (precision < 0) precision = 0;
    if (precision > 9) precision = 9;

    const bool neg = (bits >> 31) & 1u;
    const int  biased_exp = static_cast<int>((bits >> 23) & 0xFFu);
    const u32  mant_bits = bits & 0x7FFFFFu;

    // Inf / NaN.
    if (biased_exp == 0xFF) {
        if (mant_bits != 0) return fl::string("nan");
        return neg ? fl::string("-inf") : fl::string("inf");
    }

    fl::string s;

    auto append_zero_with_precision = [&]() {
        s += "0";
        if (precision > 0) {
            s += ".";
            for (int i = 0; i < precision; ++i) s += "0";
        }
    };

    // +/- 0 (and any subnormal -- those collapse to zero per the parser's
    // contract, so the serializer matches).
    if (biased_exp == 0) {
        if (neg) s += "-";
        append_zero_with_precision();
        return s;
    }

    // Normal number: value = mantissa_full * 2**bin_exp.
    // mantissa_full carries the implicit leading 1.
    const u32 mantissa_full = mant_bits | 0x800000u;       // 24 bits
    const int bin_exp_raw = biased_exp - 127 - 23;  // signed

    // Lift to a 64-bit normalized representation so we can multiply against
    // the shared pow10 table.  mantissa_full's bit 23 is set, so shifting left by 40
    // puts that set bit in position 63.
    const u64 mant64 = static_cast<u64>(mantissa_full) << 40;
    const int bin_exp = bin_exp_raw - 40;

    // Look up the normalized representation of 10**precision.
    const fl::size idx = static_cast<fl::size>(precision - kPow10KMin);
    const u64 pow_mant = kPow10Mant[idx];
    const int pow_exp = kPow10BExp[idx];

    // Multiply via the same widening helper the parser uses.
    u64 scaled_hi = mul_hi_u64(mant64, pow_mant);
    int scaled_bin_exp = bin_exp + pow_exp + 64;
    if ((scaled_hi & 0x8000000000000000ull) == 0) {
        scaled_hi <<= 1;
        --scaled_bin_exp;
    }

    // Convert (scaled_hi, scaled_bin_exp) to a u64 integer count of
    // `precision` decimal places. Overflow on the way up clamps to +/- inf;