Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368//// cfout.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// Floating point binary to decimal conversion routines//#include <corecrt_internal_fltintrn.h>#include <corecrt_internal_big_integer.h>#include <fenv.h>#include <string.h>
using namespace __crt_strtox;
namespace{ // Guard class for floating point control word modifications in the interrupt exception mask. class fp_control_word_guard { public: explicit fp_control_word_guard(unsigned int const mask = ~0u) : _mask(mask) { _controlfp_s(&_original_control_word, 0, 0); }
fp_control_word_guard(unsigned int const new_control, unsigned int const mask) : _mask(mask) { unsigned int float_control; _controlfp_s(&_original_control_word, 0, 0); _controlfp_s(&float_control, new_control, _mask); }
~fp_control_word_guard() { unsigned int reset_cw; _controlfp_s(&reset_cw, _original_control_word, _mask); }
private: unsigned int _original_control_word; unsigned int _mask; };
class scoped_fp_state_reset { public:
scoped_fp_state_reset() throw() { // The calls to feholdexcept and fesetenv are relatively expensive, // so we only call them if there are any unmasked exceptions. fegetenv(&_environment); if ((_environment._Fe_ctl & FE_ALL_EXCEPT) == FE_ALL_EXCEPT) { _requires_reset = false; } else { feholdexcept(&_environment); _requires_reset = true; } }
~scoped_fp_state_reset() throw() { if (_requires_reset) { fesetenv(&_environment); } }
private:
scoped_fp_state_reset(scoped_fp_state_reset const&); scoped_fp_state_reset& operator=(scoped_fp_state_reset const&);
fenv_t _environment; bool _requires_reset; };}
// This function converts a finite, positive floating point value into its// decimal representation. The decimal mantissa and exponent are returned// via the out parameters and the return value affirms if there were trailing// digits. If the value is zero, negative, infinity, or nan, the behavior is// undefined.//// This function is based on the digit generation algorithm described in the// paper "Printing floating point numbers quickly and accurately," by Robert G.// Burger and R. Kent Dybvig, from ACM SIGPLAN 1996 Conference on Programming// Language Design and Implementation, June 1996. This function deviates from// that algorithm in its termination conditions: the Burger-Dybvig algorithm// terminates when it runs out of significant digits; this function continues// generating digits, even if they are insignificant (this allows us to print// large, exactly representable values exactly, e.g. large powers of two).//// This function stops generating digits when the first of the following// conditions is true: [1] the mantissa buffer is exhausted, [2] sufficient// digits have been generated for a %f specifier with the requested precision,// or [3] all remaining digits are known to be zero.template <typename FloatingType>__forceinline static __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(){ 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;}
extern "C" __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 ){ 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);}