Method do_write_float

include/fmt/format.h:2382–2476

template <typename OutputIt, typename DecimalFP, typename Char, typename Grouping = digit_grouping<Char>>
FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, const format_specs<Char>& specs,
                                    float_specs fspecs, locale_ref loc) -> OutputIt {
    auto significand = f.significand;
    int significand_size = get_significand_size(f);
    const Char zero = static_cast<Char>('0');
    auto sign = fspecs.sign;
    size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
    using iterator = reserve_iterator<OutputIt>;

    Char decimal_point = fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');

    int output_exp = f.exponent + significand_size - 1;
    auto use_exp_format = [=]() {
        if (fspecs.format == float_format::exp) return true;
        if (fspecs.format != float_format::general) return false;
        // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
        // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
        const int exp_lower = -4, exp_upper = 16;
        return output_exp < exp_lower || output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
    };
    if (use_exp_format()) {
        int num_zeros = 0;
        if (fspecs.showpoint) {
            num_zeros = fspecs.precision - significand_size;
            if (num_zeros < 0) num_zeros = 0;
            size += to_unsigned(num_zeros);
        } else if (significand_size == 1) {
            decimal_point = Char();
        }
        auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
        int exp_digits = 2;
        if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;

        size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
        char exp_char = fspecs.upper ? 'E' : 'e';
        auto write = [=](iterator it) {
            if (sign) *it++ = detail::sign<Char>(sign);
            // Insert a decimal point after the first digit and add an exponent.
            it = write_significand(it, significand, significand_size, 1, decimal_point);
            if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
            *it++ = static_cast<Char>(exp_char);
            return write_exponent<Char>(output_exp, it);
        };
        return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
                               : base_iterator(out, write(reserve(out, size)));
    }

    int exp = f.exponent + significand_size;
    if (f.exponent >= 0) {
        // 1234e5 -> 123400000[.0+]
        size += to_unsigned(f.exponent);
        int num_zeros = fspecs.precision - exp;
        abort_fuzzing_if(num_zeros > 5000);
        if (fspecs.showpoint) {
            ++size;
            if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0;
            if (num_zeros > 0) size += to_unsigned(num_zeros);
        }