Method format_hexfloat

include/fmt/format.h:2920–2993

// Formats a floating-point number using the hexfloat format.
template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)>
FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, float_specs specs, buffer<char>& buf) {
    // float is passed as double to reduce the number of instantiations and to
    // simplify implementation.
    static_assert(!std::is_same<Float, float>::value, "");

    using info = dragonbox::float_info<Float>;

    // Assume Float is in the format [sign][exponent][significand].
    using carrier_uint = typename info::carrier_uint;

    constexpr auto num_float_significand_bits = detail::num_significand_bits<Float>();

    basic_fp<carrier_uint> f(value);
    f.e += num_float_significand_bits;
    if (!has_implicit_bit<Float>()) --f.e;

    constexpr auto num_fraction_bits = num_float_significand_bits + (has_implicit_bit<Float>() ? 1 : 0);
    constexpr auto num_xdigits = (num_fraction_bits + 3) / 4;

    constexpr auto leading_shift = ((num_xdigits - 1) * 4);
    const auto leading_mask = carrier_uint(0xF) << leading_shift;
    const auto leading_xdigit = static_cast<uint32_t>((f.f & leading_mask) >> leading_shift);
    if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);

    int print_xdigits = num_xdigits - 1;
    if (precision >= 0 && print_xdigits > precision) {
        const int shift = ((print_xdigits - precision - 1) * 4);
        const auto mask = carrier_uint(0xF) << shift;
        const auto v = static_cast<uint32_t>((f.f & mask) >> shift);

        if (v >= 8) {
            const auto inc = carrier_uint(1) << (shift + 4);
            f.f += inc;
            f.f &= ~(inc - 1);
        }

        // Check long double overflow
        if (!has_implicit_bit<Float>()) {
            const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
            if ((f.f & implicit_bit) == implicit_bit) {
                f.f >>= 4;
                f.e += 4;
            }
        }

        print_xdigits = precision;
    }

    char xdigits[num_bits<carrier_uint>() / 4];
    detail::fill_n(xdigits, sizeof(xdigits), '0');
    format_uint<4>(xdigits, f.f, num_xdigits, specs.upper);

    // Remove zero tail
    while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits;

    buf.push_back('0');
    buf.push_back(specs.upper ? 'X' : 'x');
    buf.push_back(xdigits[0]);