cfout.cpp File Reference

#include <corecrt_internal_fltintrn.h>
#include <corecrt_internal_big_integer.h>
#include <fenv.h>
#include <string.h>

Include dependency graph for cfout.cpp:

Go to the source code of this file.

Classes
class	anonymous_namespace{cfout.cpp}::fp_control_word_guard
class	anonymous_namespace{cfout.cpp}::scoped_fp_state_reset

Namespaces
namespace	anonymous_namespace{cfout.cpp}

Functions
template<typename FloatingType >
static __forceinline __acrt_has_trailing_digits __cdecl	convert_to_fos_high_precision (FloatingType const value, uint32_t const precision, __acrt_precision_style const precision_style, int *const exponent, char *const mantissa_buffer, size_t const mantissa_buffer_count) throw ()
__acrt_has_trailing_digits __cdecl	__acrt_fltout (_CRT_DOUBLE value, unsigned const precision, __acrt_precision_style const precision_style, STRFLT const flt, char *const result, size_t const result_count)

Function Documentation

__acrt_fltout()

__acrt_has_trailing_digits __cdecl __acrt_fltout	(	_CRT_DOUBLE	value,
		unsigned const	precision,
		__acrt_precision_style const	precision_style,
		STRFLT const	flt,
		char *const	result,
		size_t const	result_count
	)

Definition at line 315 of file cfout.cpp.

{
    using floating_traits = __acrt_floating_type_traits<double>;
    using components_type = floating_traits::components_type;
 
    scoped_fp_state_reset const reset_fp_state;
 
    components_type& components = reinterpret_cast<components_type&>(value);
 
    flt->sign     = components._sign == 1 ? '-' : ' ';
    flt->mantissa = result;
 
    unsigned int float_control;
    _controlfp_s(&float_control, 0, 0);
    bool const value_is_zero = components._exponent == 0 && (components._mantissa == 0 || float_control & _DN_FLUSH);
    if (value_is_zero)
    {
        flt->decpt = 0;
        _ERRCHECK(strcpy_s(result, result_count, "0"));
        return __acrt_has_trailing_digits::no_trailing;
    }
 
    // Handle special cases:
    __acrt_fp_class const classification = __acrt_fp_classify(value.x);
    if (classification != __acrt_fp_class::finite)
    {
        flt->decpt = 1;
    }
 
    switch (classification)
    {
    case __acrt_fp_class::infinity:      _ERRCHECK(strcpy_s(result, result_count, "1#INF" )); return __acrt_has_trailing_digits::trailing;
    case __acrt_fp_class::quiet_nan:     _ERRCHECK(strcpy_s(result, result_count, "1#QNAN")); return __acrt_has_trailing_digits::no_trailing;
    case __acrt_fp_class::signaling_nan: _ERRCHECK(strcpy_s(result, result_count, "1#SNAN")); return __acrt_has_trailing_digits::no_trailing;
    case __acrt_fp_class::indeterminate: _ERRCHECK(strcpy_s(result, result_count, "1#IND" )); return __acrt_has_trailing_digits::no_trailing;
    }
 
    // Make the number positive before we pass it to the digit generator:
    components._sign = 0;
 
    // The digit generator produces a truncated sequence of digits.  To allow
    // our caller to correctly round the mantissa, we need to generate an extra
    // digit.
    fp_control_word_guard const fpc(_MCW_EM, _MCW_EM);
    return convert_to_fos_high_precision(value.x, precision + 1, precision_style, &flt->decpt, result, result_count);
}

Referenced by _ecvt_s_internal(), _fcvt_internal(), _fcvt_s_internal(), and _gcvt_s_internal().

convert_to_fos_high_precision()

template<typename FloatingType >

static __forceinline __acrt_has_trailing_digits __cdecl convert_to_fos_high_precision ( FloatingType const  value, uint32_t const  precision, __acrt_precision_style const  precision_style, int *const  exponent, char *const  mantissa_buffer, size_t const  mantissa_buffer_count  ) throw ( )

static

Definition at line 106 of file cfout.cpp.

{
    using floating_traits = __acrt_floating_type_traits<FloatingType>;
    using components_type = typename floating_traits::components_type;
 
    _ASSERTE(mantissa_buffer_count > 0);
 
    components_type const& value_components = reinterpret_cast<components_type const&>(value);
 
    // Special handling is required for denormal values:  because the implicit
    // high order bit is a zero, not a one, we need to [1] not set that bit when
    // we expand the mantissa, and [2] increment the exponent to account for the
    // extra shift.
    bool const is_denormal = value_components._exponent == 0;
 
    uint64_t const mantissa_adjustment = is_denormal
        ? 0
        : static_cast<uint64_t>(1) << (floating_traits::mantissa_bits - 1);
 
    int32_t const exponent_adjustment = is_denormal
        ? 2
        : 1;
 
    // f and e are the unbiased mantissa and exponent, respectively.  (Where one-
    // -letter variable names are used, they match the same variables from the
    // Burger-Dybvig paper.)
    uint64_t const f = value_components._mantissa + mantissa_adjustment;
    int32_t  const e =
        static_cast<int32_t>(value_components._exponent) -
        floating_traits::exponent_bias -
        floating_traits::mantissa_bits +
        exponent_adjustment;
 
    // k is the decimal exponent, such that the resulting decimal number is of
    // the form 0.mmmmm * 10^k, where mmmm are the mantissa digits we generate.
    // Note that the use of log10 here may not give the correct result:  it may
    // be off by one, e.g. as is the case for powers of ten (log10(100) is two,
    // but the correct value of k for 100 is 3).  We detect off-by-one errors
    // later and correct for them.
    int32_t k = static_cast<int32_t>(ceil(log10(value)));
    if (k == INT32_MAX || k == INT32_MIN)
    {
        _ASSERTE(("unexpected input value; log10 failed", 0));
        k = 0;
    }
 
    // The floating point number is represented as a fraction, r / s.  The
    // initialization of these two values is as described in the Burger-Dybvig
    // paper.
    big_integer r = make_big_integer(f);
    big_integer s{};
 
    if (e >= 0)
    {
        if (r != make_big_integer_power_of_two(floating_traits::mantissa_bits - 1))
        {
            shift_left(r, e + 1);   // f * b^e * 2
            s = make_big_integer(2); // 2
        }
        else
        {
            shift_left(r, e + 2);   // f * b^(e+1) * 2
            s = make_big_integer(4); // b * 2
        }
    }
    else
    {
        if (e == floating_traits::minimum_binary_exponent ||
            r != make_big_integer_power_of_two(floating_traits::mantissa_bits - 1))
        {
            shift_left(r, 1);                          // f * 2
            s = make_big_integer_power_of_two(-e + 1); // b^-e * 2
        }
        else
        {
            shift_left(r, 2);                          // f * b * 2
            s = make_big_integer_power_of_two(-e + 2); // b^(-e+1) * 2
        }
    }
 
    if (k >= 0)
    {
        multiply_by_power_of_ten(s, k);
    }
    else
    {
        multiply_by_power_of_ten(r, -k);
    }
 
    char* mantissa_it = mantissa_buffer;
 
    // Perform a trial digit generation to handle off-by-one errors in the
    // computation of 'k':  There are three possible cases, which we handle
    // in turn:
    multiply(r, 10);
    uint32_t const initial_digit = static_cast<uint32_t>(divide(r, s));
 
    // If the initial digit was computed as 10, k is too small.  We increment k
    // and adjust s as if it had been computed with the correct k above.  We
    // then treat the digit as a one, which is what it would have been extracted
    // as had k, r, and s been correct to begin with.
    if (initial_digit == 10)
    {
        ++k;
        *mantissa_it++ = '1';
        multiply(s, 10);
    }
    // If the initial digit is zero, k is too large.  We decrement k and ignore
    // the zero that we read (the next digit that we read will be the "real"
    // initial digit.
    else if (initial_digit == 0)
    {
        --k;
    }
    // Otherwise, k was correct and the digit we read was the actual initial
    // digit of the number; just store it.
    else
    {
        *mantissa_it++ = static_cast<char>('0' + initial_digit);
    }
 
    *exponent = k; // k is now correct; store it for our caller
 
    // convert_to_fos_high_precision() generates digits assuming we're formatting with %f
    // When %e is the format specifier, adding the exponent to the number of required digits
    // is not needed.
    uint32_t const required_digits = k >= 0 && precision <= INT_MAX && precision_style == __acrt_precision_style::fixed
        ? k + precision
        : precision;
 
    char* const mantissa_last = mantissa_buffer + __min(mantissa_buffer_count - 1, required_digits);
 
    // We must track whether there are any non-zero digits that were not written to the mantissa,
    // since just checking whether 'r' is zero is insufficient for knowing whether there are any
    // remaining zeros after the generated digits.
    bool unwritten_nonzero_digits_in_chunk = false;
    for (;;)
    {
        if (mantissa_it == mantissa_last)
        {
            break;
        }
 
        if (is_zero(r))
        {
            break;
        }
 
        // To reduce the number of expensive high precision division operations,
        // we generate multiple digits per iteration.  Our quotient type is a
        // uint32_t, and the largest power of ten representable by a uint32_t is
        // 10^9, so we generate nine digits per iteration.
        uint32_t const digits_per_iteration            = 9;
        uint32_t const digits_per_iteration_multiplier = 1000 * 1000 * 1000;
 
        multiply(r, digits_per_iteration_multiplier);
        uint32_t quotient = static_cast<uint32_t>(divide(r, s));
 
        _ASSERTE(quotient < digits_per_iteration_multiplier);
 
        // Decompose the quotient into its nine component digits by repeatedly
        // dividing by ten.  This generates digits in reverse order.
        #pragma warning(suppress: 6293) // For-loop counts down from minimum
        for (uint32_t i = digits_per_iteration - 1; i != static_cast<uint32_t>(-1); --i)
        {
            char const d = static_cast<char>('0' + quotient % 10);
            quotient /= 10;
 
            // We may not have room in the mantissa buffer for all of the digits.
            // Ignore the ones for which we do not have room.
            // Last value in mantissa must be null terminator, account for one place after digit generation.
            if (static_cast<uint32_t>(mantissa_last - mantissa_it) <= i)
            {
                if (d != '0')
                {
                    unwritten_nonzero_digits_in_chunk = true;
                }
 
                continue;
            }
 
            mantissa_it[i] = d;
        }
 
        mantissa_it += __min(digits_per_iteration, mantissa_last - mantissa_it);
    }
 
    *mantissa_it = '\0';
 
    // To detect whether there are zeros after the generated digits for the purposes of rounding,
    // we must check whether 'r' is zero, but also whether there were any non-zero numbers that were
    // not written to the mantissa in the last evaluated chunk.
    bool const all_zeros_after_chunk = is_zero(r);
 
    if (all_zeros_after_chunk && !unwritten_nonzero_digits_in_chunk)
    {
        return __acrt_has_trailing_digits::no_trailing;
    }
 
    return __acrt_has_trailing_digits::trailing;
}

Referenced by __acrt_fltout().