ReactOS 0.4.16-dev-753-g705a985
cvt.cpp File Reference
#include <corecrt_internal.h>
#include <corecrt_internal_ptd_propagation.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <locale.h>
#include <corecrt_internal_fltintrn.h>
#include <fenv.h>
#include <float.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
Include dependency graph for cvt.cpp:

Go to the source code of this file.

Typedefs

using components_type = floating_traits::components_type
 

Functions

static void __cdecl shift_bytes (_Maybe_unsafe_(_Inout_updates_z_, buffer_count) char *const buffer_base, _In_ size_t const buffer_count, _In_range_(buffer_base, buffer_base+buffer_count) char *const string, _In_ int const distance) throw ()
 
 _Success_ (return==0) static errno_t __cdecl fp_format_nan_or_infinity(_In_ __acrt_fp_class const classification
 
 _In_range_ (0, 1) bool const is_negative
 
 _Maybe_unsafe_ (_Out_writes_z_, result_buffer_count) char *result_buffer
 
 _In_range_ (1, SIZE_MAX) size_t result_buffer_count
 
result_buffer_count char *const _In_fits_precision_ (precision) size_t const result_buffer_count
 
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const _In_ STRFLT const _In_ bool const _Inout_ __crt_cached_ptd_host &ptd throw ()
 
 _Maybe_unsafe_ (_Inout_updates_z_, result_buffer_count) char *const result_buffer
 
 _Out_writes_ (scratch_buffer_count) char *const scratch_buffer
 
static bool fe_to_nearest (double const *const argument, unsigned __int64 const mask, short const maskpos)
 
static bool should_round_up (double const *const argument, unsigned __int64 const mask, short const maskpos, __acrt_rounding_mode const rounding_mode)
 
 if (precision< 0)
 
 _UCRT_VALIDATE_RETURN_ERRCODE (ptd, result_buffer_count > static_cast< size_t >(1+4+precision+6), ERANGE)
 
 if (components->_exponent==floating_traits::exponent_mask)
 
 if (precision==0)
 
 if (components->_mantissa > 0)
 
 for (;precision > 0;--precision)
 
 if (exponent >=0)
 
 if (result_buffer !=pos||exponent >=100)
 
errno_t __cdecl __acrt_fp_format (double const *const value, char *const result_buffer, size_t const result_buffer_count, char *const scratch_buffer, size_t const scratch_buffer_count, int const format, int const precision, uint64_t const options, __acrt_rounding_mode rounding_mode, __crt_cached_ptd_host &ptd)
 

Variables

result_buffer_count char *const result_buffer = '\0'
 
result_buffer_count char *const _In_ int const precision
 
result_buffer_count char *const _In_ int const _In_ bool const capitals
 
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const min_exponent_digits
 
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const _In_ STRFLT const pflt
 
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const _In_ STRFLT const _In_ bool const g_fmt
 
_In_ size_t const scratch_buffer_count
 
_In_ size_t const _In_ int const _In_ bool const _In_ unsigned const _In_ __acrt_rounding_mode const rounding_mode
 
_In_ size_t const _In_ int _In_ bool const _In_ unsigned const _In_ __acrt_rounding_mode const _Inout_ __crt_cached_ptd_host & ptd
 
components_type const *const components = reinterpret_cast<components_type const*>(argument)
 
int const hexadd = (capitals ? 'A' : 'a') - '9' - 1
 
unsigned __int64 debias = floating_traits::exponent_bias
 
 else
 
charpos = result_buffer++
 
__int64 exponent = components->_exponent - debias
 
 return
 
buffer_count char *const buffer
 

Typedef Documentation

◆ components_type

using components_type = floating_traits::components_type

Definition at line 357 of file cvt.cpp.

Function Documentation

◆ __acrt_fp_format()

errno_t __cdecl __acrt_fp_format ( double const *const  value,
char *const  result_buffer,
size_t const  result_buffer_count,
char *const  scratch_buffer,
size_t const  scratch_buffer_count,
int const  format,
int const  precision,
uint64_t const  options,
__acrt_rounding_mode  rounding_mode,
__crt_cached_ptd_host &  ptd 
)

Definition at line 786 of file cvt.cpp.

798{
801 _UCRT_VALIDATE_RETURN_ERRCODE(ptd, scratch_buffer != nullptr, EINVAL);
803
804 bool const use_capitals = format == 'A' || format == 'E' || format == 'F' || format == 'G';
805
806 // Detect special cases (NaNs and infinities) and handle them specially.
807 // Note that the underlying __acrt_fltout function will also handle these
808 // special cases, but it does so using the legacy strings (e.g. 1.#INF).
809 // Our special handling here uses the C99 strings (e.g. INF).
811 {
812 __acrt_fp_class const classification = __acrt_fp_classify(*value);
813 if (classification != __acrt_fp_class::finite)
814 {
815 return fp_format_nan_or_infinity(
816 classification,
820 use_capitals);
821 }
822 }
823
827 }
828
829 switch (format)
830 {
831 case 'a':
832 case 'A':
833 return fp_format_a(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
834
835 case 'e':
836 case 'E':
837 return fp_format_e(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
838
839 case 'f':
840 case 'F':
842
843 default:
844 _ASSERTE(("Unsupported format specifier", 0));
845 case 'g':
846 case 'G':
847 return fp_format_g(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
848 }
849}
#define EINVAL
Definition: acclib.h:90
bool __cdecl __acrt_fp_is_negative(double const &value)
__acrt_fp_class __cdecl __acrt_fp_classify(double const &value)
#define _UCRT_VALIDATE_RETURN_ERRCODE(ptd, expr, errorcode)
#define _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING
#define _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS
#define _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY
#define _ASSERTE(expr)
Definition: crtdbg.h:114
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const min_exponent_digits
Definition: cvt.cpp:115
_In_ size_t const _In_ int _In_ bool const _In_ unsigned const _In_ __acrt_rounding_mode const _Inout_ __crt_cached_ptd_host & ptd
Definition: cvt.cpp:355
result_buffer_count char *const result_buffer
Definition: cvt.cpp:111
_In_ size_t const scratch_buffer_count
Definition: cvt.cpp:219
_In_ size_t const _In_ int const _In_ bool const _In_ unsigned const _In_ __acrt_rounding_mode const rounding_mode
Definition: cvt.cpp:223
GLenum GLint GLint * precision
Definition: glext.h:7539
Definition: format.c:58
size_t const result_buffer_count
Definition: tmpfile.cpp:196
Definition: pdh_main.c:94

Referenced by _gcvt_s_internal(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_a().

◆ _In_fits_precision_()

_In_fits_precision_ ( precision  ) const

◆ _In_range_() [1/2]

_In_range_ ( ,
 
) const

Definition at line 54 of file cvt.cpp.

56{
57 using floating_traits = __acrt_floating_type_traits<double>;
58 using components_type = floating_traits::components_type;
59
60 // Ensure that we have sufficient space to store at least the basic three-
61 // character INF or NAN string, plus the minus sign if required:
62 if (result_buffer_count < _countof("INF") + is_negative)
63 {
64 *result_buffer = '\0';
65 return ENOMEM;
66 }
67
68 if (is_negative)
69 {
70 *result_buffer++ = '-';
71 *result_buffer = '\0';
73 {
75 }
76 }
77
78 static char const* const strings[][4] =
79 {
80 { "INF", "INF", "inf", "inf" }, // Infinity
81 { "NAN", "NAN", "nan", "nan" }, // Quiet NAN
82 { "NAN(SNAN)", "NAN", "nan(snan)", "nan" }, // Signaling NAN
83 { "NAN(IND)", "NAN", "nan(ind)", "nan" }, // Indeterminate
84 };
85
86 uint32_t const row = static_cast<uint32_t>(classification) - 1;
87 uint32_t const column = use_capitals ? 0 : 2;
88
89 bool const long_string_will_fit = result_buffer_count > strlen(strings[row][column]);
93 strings[row][column + !long_string_will_fit]));
94 return 0;
95}
#define ENOMEM
Definition: acclib.h:84
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define _CRT_UNBOUNDED_BUFFER_SIZE
#define _ERRCHECK(e)
floating_traits::components_type components_type
Definition: cvt.cpp:357
UINT32 uint32_t
Definition: types.h:75
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
GLsizei const GLchar *const * strings
Definition: glext.h:7622
#define strcpy_s(d, l, s)
Definition: utility.h:200
#define _countof(array)
Definition: sndvol32.h:70

◆ _In_range_() [2/2]

_In_range_ ( ,
SIZE_MAX   
)

◆ _Maybe_unsafe_() [1/2]

_Maybe_unsafe_ ( _Inout_updates_z_  ,
result_buffer_count   
) const

◆ _Maybe_unsafe_() [2/2]

_Maybe_unsafe_ ( _Out_writes_z_  ,
result_buffer_count   
)

◆ _Out_writes_()

_Out_writes_ ( scratch_buffer_count  ) const

◆ _Success_()

_Success_ ( return  = = 0) const

◆ _UCRT_VALIDATE_RETURN_ERRCODE()

_UCRT_VALIDATE_RETURN_ERRCODE ( ptd  ,
result_buffer_count  ,
static_cast< size_t 1+4+precision+6,
ERANGE   
)

◆ fe_to_nearest()

static bool fe_to_nearest ( double const *const  argument,
unsigned __int64 const  mask,
short const  maskpos 
)
static

Definition at line 261 of file cvt.cpp.

262{
263 using floating_traits = __acrt_floating_type_traits<double>;
264 using components_type = floating_traits::components_type;
265 components_type const* const components = reinterpret_cast<components_type const*>(argument);
266
267 unsigned short digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
268
269 if (digit > 8)
270 {
271 return true;
272 }
273
274 if (digit < 8)
275 {
276 return false;
277 }
278
279 unsigned __int64 const roundBitsMask = (static_cast<unsigned __int64>(1) << maskpos) - 1;
280 if (components->_mantissa & roundBitsMask)
281 {
282 return true;
283 }
284
285 //if we still have digits to the left to compare
286 if (maskpos != DBL_MANT_DIG - 5)
287 {
288 // We divide the mantisa by 16 to move the digits to the right, after that we apply the mask
289 // to get the digit at the left.
290 digit = static_cast<unsigned short>(((components->_mantissa / 16) & mask) >> maskpos);
291 }
292 else
293 {
294 digit = components->_exponent == 0 ? 0 : 1;
295 }
296
297 return digit % 2 == 1;
298}
#define __int64
Definition: basetyps.h:16
GLenum GLenum GLuint components
Definition: glext.h:9620
GLenum GLint GLuint mask
Definition: glext.h:6028
#define DBL_MANT_DIG
Definition: float.h:75
#define const
Definition: zconf.h:233

Referenced by should_round_up().

◆ for()

for ( precision,
0;--  precision 
)

Definition at line 516 of file cvt.cpp.

517 {
518 *result_buffer++ = '0';
519 }

◆ if() [1/6]

if ( components->  _exponent = floating_traits::exponent_mask)

Definition at line 375 of file cvt.cpp.

376 {
377 errno_t const e = fp_format_e(
378 argument,
381 scratch_buffer,
383 precision,
384 false,
387 ptd);
388
389 if (e != 0)
390 {
391 // An error occurred
392 result_buffer[0] = '\0';
393 return e;
394 }
395
396 // Substitute the e with p:
397 char* p = strrchr(result_buffer, 'e');
398 if (p)
399 {
400 *p = capitals ? 'P' : 'p';
401
402 // Trim the exponent (which is 0) to only one digit; skip the
403 // exponent sign and the first digit and put the terminating 0:
404 p += 3;
405 *p = 0;
406 }
407 return e;
408 }
result_buffer_count char *const _In_ int const _In_ bool const capitals
Definition: cvt.cpp:114
GLfloat GLfloat p
Definition: glext.h:8902
#define e
Definition: ke_i.h:82
_CRT_RESTORE_GCC_WARNINGS _CRT_DISABLE_GCC_WARNINGS _Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
int errno_t
Definition: corecrt.h:615

◆ if() [2/6]

if ( components->  _mantissa,
 
)

Definition at line 453 of file cvt.cpp.

454 {
455 // Print 4 bits at a time, and skip the initial zeroes
456 // Prepare the mask to read the first 4 bits
457 short maskpos = (floating_traits::mantissa_bits - 1) - 4;
458
459 unsigned __int64 mask = 0xf;
460 mask <<= maskpos;
461
462 while (maskpos >= 0 && precision > 0)
463 {
464 unsigned short digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
465 digit += '0';
466 if (digit > '9')
467 {
468 digit += static_cast<unsigned short>(hexadd);
469 }
470 *result_buffer++ = static_cast<char>(digit);
471 mask >>= 4;
472 maskpos -= 4;
473 --precision;
474 }
475
476 // Round the mantissa:
477 if (maskpos >= 0)
478 {
479 if (should_round_up(argument, mask, maskpos, rounding_mode))
480 {
481 char* p = result_buffer;
482 --p;
483 // If the last digit is 'f', we need to add one to the previous
484 // digit, too; pos is the position of the decimal point
485 while (*p == 'f' || *p == 'F')
486 {
487 *p-- = '0';
488 }
489 // If we reached the decimal point, it means we are rounding
490 // something like 0x0.fffff so this will become 0x1.00000 :
491 if (p != pos)
492 {
493 if (*p == '9')
494 {
495 *p += static_cast<char>(1 + hexadd);
496 }
497 else
498 {
499 *p += 1;
500 }
501 }
502 else // p == pos
503 {
504 // Skip the decimal point:
505 --p;
506
507 // The first digit is always 0 or 1, so we don't need to
508 // add hexadd:
509 *p += 1;
510 }
511 }
512 }
513 }
char * pos
Definition: cvt.cpp:440
int const hexadd
Definition: cvt.cpp:416
result_buffer_count char *const _In_ int const precision
Definition: cvt.cpp:113
static bool should_round_up(double const *const argument, unsigned __int64 const mask, short const maskpos, __acrt_rounding_mode const rounding_mode)
Definition: cvt.cpp:300

◆ if() [3/6]

if ( exponent >=  0)

Definition at line 530 of file cvt.cpp.

531 {
532 *result_buffer++ = '+';
533 }

◆ if() [4/6]

if ( )

Definition at line 359 of file cvt.cpp.

360 {
361 precision = 0;
362 }

◆ if() [5/6]

if ( precision  = = 0)

Definition at line 441 of file cvt.cpp.

442 {
443 // If precision is 0, then we don't have to print the decimal point:
444 // we mark this putting 0 instead of the decimal point itself
445 *pos = 0;
446 }

◆ if() [6/6]

if ( result_buffer = pos || exponent >= 100)

Definition at line 548 of file cvt.cpp.

549 {
550 *result_buffer++ = '0' + static_cast<char>(exponent / 100);
551 exponent %= 100;
552 }
__int64 exponent
Definition: cvt.cpp:529

◆ shift_bytes()

static void __cdecl shift_bytes ( _Maybe_unsafe_(_Inout_updates_z_, buffer_count) char *const  buffer_base,
_In_ size_t const  buffer_count,
_In_range_(buffer_base, buffer_base+buffer_count) char *const  string,
_In_ int const  distance 
)
throw (
)
static

Definition at line 26 of file cvt.cpp.

32{
33 UNREFERENCED_PARAMETER(buffer_base);
35
36 if (distance != 0)
37 {
38 memmove(string + distance, string, strlen(string) + 1);
39 }
40}
GLsizei GLsizei GLfloat distance
Definition: glext.h:11755
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:325
size_t const buffer_count
Definition: xtoa.cpp:36

Referenced by throw().

◆ should_round_up()

static bool should_round_up ( double const *const  argument,
unsigned __int64 const  mask,
short const  maskpos,
__acrt_rounding_mode const  rounding_mode 
)
static

Definition at line 300 of file cvt.cpp.

301{
302 using floating_traits = __acrt_floating_type_traits<double>;
303 using components_type = floating_traits::components_type;
304 components_type const* const components = reinterpret_cast<components_type const*>(argument);
305
306 unsigned short const digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
307
309 {
310 return digit >= 8;
311 }
312 int const round_mode = fegetround();
313
314 if (round_mode == FE_TONEAREST)
315 {
316 return fe_to_nearest(argument, mask, maskpos);
317 }
318
319 if (round_mode == FE_UPWARD)
320 {
321 return digit != 0 && !components->_sign;
322 }
323
324 if (round_mode == FE_DOWNWARD)
325 {
326 return digit != 0 && components->_sign;
327 }
328
329 return false;
330}
#define FE_UPWARD
Definition: fenv.h:22
#define FE_TONEAREST
Definition: fenv.h:20
#define FE_DOWNWARD
Definition: fenv.h:21
int __cdecl fegetround(void)
static bool fe_to_nearest(double const *const argument, unsigned __int64 const mask, short const maskpos)
Definition: cvt.cpp:261

Referenced by if().

◆ throw()

Definition at line 119 of file cvt.cpp.

120{
121 // The max length if calculated like this:
122 // 3 = sign + first digit + decimal point
123 // precision = decimal digits
124 // 5 = exponent letter (e or E), exponent sign, three digits exponent
125 // 1 = extra space for rounding
126 _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer_count > static_cast<size_t>(3 + (precision > 0 ? precision : 0) + 5 + 1), ERANGE);
127
128 // Place the output in the buffer and round. Leave space in the buffer
129 // for the '-' sign (if any) and the decimal point (if any):
130 if (g_fmt)
131 {
132 // Shift it right one place if nec. for decimal point:
133 char* const p = result_buffer + (pflt->sign == '-');
135 }
136
137 // Now fix the number up to be in e format:
138 char* p = result_buffer;
139
140 // Put in negative sign if needed:
141 if (pflt->sign == '-')
142 *p++ = '-';
143
144 // Put in decimal point if needed. Copy the first digit to the place left
145 // for it and put the decimal point in its place:
146 if (precision > 0)
147 {
148 *p = *(p + 1);
149 *++p = *ptd.get_locale()->locinfo->lconv->decimal_point;
150 }
151
152 // Find the end of the string, attach the exponent field and save the
153 // exponent position:
154 p = p + precision + (g_fmt ? 0 : 1);
156 p,
159 : result_buffer_count - (p - result_buffer), "e+000"));
160 char* exponentpos = p + 2;
161
162 // Adjust exponent indicator according to capitals flag and increment
163 // pointer to point to exponent sign:
164 if (capitals)
165 *p = 'E';
166
167 ++p;
168
169 // If mantissa is zero, then the number is 0 and we are done; otherwise
170 // adjust the exponent sign (if necessary) and value:
171 if (*pflt->mantissa != '0')
172 {
173 // Check to see if exponent is negative; if so adjust exponent sign and
174 // exponent value:
175 int exp = pflt->decpt - 1;
176 if (exp < 0)
177 {
178 exp = -exp;
179 *p = '-';
180 }
181
182 ++p;
183
184 if (exp >= 100)
185 {
186 *p += static_cast<char>(exp / 100);
187 exp %= 100;
188 }
189
190 ++p;
191
192 if (exp >= 10)
193 {
194 *p += static_cast<char>(exp / 10);
195 exp %= 10;
196 }
197
198 *++p += static_cast<char>(exp);
199 }
200
201 if (min_exponent_digits == 2)
202 {
203 // If possible, reduce the exponent to two digits:
204 if (*exponentpos == '0')
205 {
206 memmove(exponentpos, exponentpos + 1, 3);
207 }
208 }
209
210 return 0;
211}
#define ERANGE
Definition: acclib.h:92
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const _In_ STRFLT const _In_ bool const g_fmt
Definition: cvt.cpp:117
static void __cdecl shift_bytes(_Maybe_unsafe_(_Inout_updates_z_, buffer_count) char *const buffer_base, _In_ size_t const buffer_count, _In_range_(buffer_base, buffer_base+buffer_count) char *const string, _In_ int const distance)
Definition: cvt.cpp:26
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const _In_ STRFLT const pflt
Definition: cvt.cpp:116
DWORD exp
Definition: msg.c:16058

Variable Documentation

◆ buffer

Definition at line 580 of file cvt.cpp.

◆ capitals

Definition at line 114 of file cvt.cpp.

Referenced by if(), and throw().

◆ components

components_type const* const components = reinterpret_cast<components_type const*>(argument)

Definition at line 374 of file cvt.cpp.

◆ debias

unsigned __int64 debias = floating_traits::exponent_bias

Definition at line 419 of file cvt.cpp.

◆ else

else
Initial value:
{
*result_buffer++ = '1'

Definition at line 434 of file cvt.cpp.

◆ exponent

◆ g_fmt

Definition at line 117 of file cvt.cpp.

Referenced by throw().

◆ hexadd

int const hexadd = (capitals ? 'A' : 'a') - '9' - 1

Definition at line 416 of file cvt.cpp.

Referenced by if().

◆ min_exponent_digits

Definition at line 115 of file cvt.cpp.

Referenced by __acrt_fp_format(), if(), and throw().

◆ pflt

Definition at line 116 of file cvt.cpp.

Referenced by __acrt_fp_strflt_to_string(), and throw().

◆ pos

* pos = result_buffer++

Definition at line 440 of file cvt.cpp.

Referenced by if().

◆ precision

Definition at line 113 of file cvt.cpp.

Referenced by if().

◆ ptd

size_t const size_t const Character const *const __crt_cached_ptd_host & ptd
Initial value:
{
using floating_traits = __acrt_floating_type_traits<double>

Definition at line 353 of file cvt.cpp.

Referenced by ___lc_codepage_func(), ___lc_collate_cp_func(), ___lc_locale_name_func(), ___mb_cur_max_func(), __acrt_errno_map_os_error_ptd(), __acrt_fp_format(), __acrt_fp_strflt_to_string(), __acrt_getptd(), __acrt_stdio_end_temporary_buffering_nolock(), __acrt_stdio_flush_and_write_narrow_nolock(), __acrt_stdio_flush_and_write_wide_nolock(), __acrt_stdio_flush_nolock(), __acrt_update_locale_info(), __acrt_update_locale_info_explicit(), __acrt_update_multibyte_info(), __acrt_update_multibyte_info_explicit(), __acrt_update_thread_locale_data(), __crt_mbstring::__c16rtomb_utf8(), __crt_mbstring::__c32rtomb_utf8(), __conio_common_vcprintf(), __conio_common_vcprintf_p(), __conio_common_vcprintf_s(), __conio_common_vcwprintf(), __conio_common_vcwprintf_p(), __conio_common_vcwprintf_s(), __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(), __doserrno(), __getgmtimebuf(), __crt_mbstring::__mbrtoc16_utf8(), __crt_mbstring::__mbrtoc32_utf8(), __p___mb_cur_max(), __pctype_func(), __pragma(), _chsize_nolock(), _chsize_nolock_internal(), _chsize_s(), _chsize_s_internal(), _close(), _close_internal(), _close_nolock(), _close_nolock_internal(), _configthreadlocale(), _dup(), _dup2(), _dup2_internal(), _dup2_nolock_internal(), _dup_internal(), _dup_nolock_internal(), _ecvt(), _ecvt_internal(), _ecvt_s(), _ecvt_s_internal(), _errno(), _fclose_internal(), _fclose_nolock(), _fclose_nolock_internal(), _fcvt(), _fcvt_internal(), _fcvt_s(), _fcvt_s_internal(), _fflush_nolock(), _fflush_nolock_internal(), _fputc_internal(), _fputc_nolock(), _fputc_nolock_internal(), _fputs_internal(), _fputwc_internal(), _fputwc_nolock(), _fputwc_nolock_internal(), _fputws_internal(), _fseek_nolock(), _fseeki64(), _fseeki64_nolock(), _ftell_nolock(), _ftelli64(), _ftelli64_nolock(), _ftelli64_nolock_internal(), _fwrite_internal(), _fwrite_nolock(), _fwrite_nolock_internal(), _gcvt_s(), _gcvt_s_internal(), _get_current_locale(), _get_thread_local_invalid_parameter_handler(), _invalid_parameter(), _invalid_parameter_internal(), _lseek(), _lseek_internal(), _lseek_nolock(), _lseek_nolock_internal(), _lseeki64(), _lseeki64_internal(), _lseeki64_nolock(), _lseeki64_nolock_internal(), _mblen_internal(), _mblen_l(), _mbstowcs_internal(), _mbstowcs_l(), _mbstowcs_l_helper(), _mbstowcs_s_l(), _mbtowc_internal(), _mbtowc_l(), _perror_internal(), _putch_nolock(), _putch_nolock_internal(), _puts_internal(), _putws(), _putws_internal(), _rewind_internal(), _seh_filter_exe(), _set_doserrno(), _set_errno(), _set_thread_local_invalid_parameter_handler(), _setvbuf_internal(), _Success_(), _tcstol_internal(), _wctomb_internal(), _wctomb_l(), _wctomb_s_l(), _write(), _write_internal(), _write_nolock(), _wsetlocale(), _wsetlocale_set_cat(), c16rtomb(), c32rtomb(), common_asctime_get_ptd_buffer(), common_end_thread(), common_flush_and_write_nolock(), common_fseek(), common_fseek_nolock(), common_ftell(), common_ftell_nolock(), common_ftell_read_mode_nolock(), common_ftell_translated_utf8_nolock(), common_lseek(), common_lseek_do_seek_nolock(), common_lseek_nolock(), common_strerror(), common_vcprintf(), construct_ptd(), construct_ptd_array(), DataCache_GetExtent(), DECLARE_INTERFACE_(), destroy_ptd(), destroy_ptd_array(), duplicate_osfhnd(), __crt_stdio_output::formatting_buffer::ensure_buffer_is_big_enough(), fast_check_current_locale(), fclose(), fputc(), fputs(), fputwc(), fputwc_binary_nolock(), fputws(), fseek(), ftell(), fwrite(), get_ptd_buffer(), get_strerror_buffer(), get_terminate_or_default(), get_tmpnam_ptd_buffer(), if(), internal_to_string(), anonymous_namespace{mstscax.cpp}::CoClass::IViewObject2::GetExtent(), anonymous_namespace{mstscax.cpp}::CoClass::IViewObject::Draw(), anonymous_namespace{mstscax.cpp}::CoClass::IViewObject::GetColorSet(), localeconv(), mblen(), mbrtoc16(), mbrtoc32(), mbstowcs(), mbstowcs_s(), mbtowc(), OleConvertOLESTREAMToIStorage(), __crt_stdio_output::output_adapter_data< Character, OutputAdapter >::output_adapter_data(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::output_processor(), __crt_strtox::parse_integer(), __crt_strtox::parse_integer_from_string(), perror(), puts(), raise(), rand(), replace_current_thread_locale_nolock(), __crt_mbstring::return_illegal_sequence(), rewind(), set_terminate(), setlocale(), setmbcp_internal(), setvbuf(), signal(), stabs_get_basic(), stabs_parse_typedef(), stabs_pts_push(), stabs_pts_read_aggregate(), stabs_pts_read_array(), stabs_pts_read_enum(), stabs_pts_read_id(), stabs_pts_read_method_info(), stabs_pts_read_number(), stabs_pts_read_range(), stabs_pts_read_range_value(), stabs_pts_read_type_def(), stabs_pts_read_type_reference(), test_CreateFormatEnum(), test_pack_RemFORMATETC(), throw(), try_get_ptd_buffer(), update_thread_multibyte_data_internal(), __crt_stdio_output::stream_output_adapter< Character >::validate(), __crt_stdio_output::string_output_adapter< Character >::validate(), ViewObject_Draw(), ViewObject_GetColorSet(), ViewObject_GetExtent(), ViewObject_GetNaturalExtent(), wctomb_s(), write_buffer_nolock(), __crt_stdio_output::output_adapter_common< Character, Derived >::write_character(), __crt_stdio_output::console_output_adapter< Character >::write_character_without_count_update(), __crt_stdio_output::stream_output_adapter< Character >::write_character_without_count_update(), write_double_translated_ansi_nolock(), __crt_stdio_output::write_multiple_characters(), write_requires_double_translation_nolock(), __crt_stdio_output::console_output_adapter< Character >::write_string(), __crt_stdio_output::stream_output_adapter< Character >::write_string(), __crt_stdio_output::string_output_adapter< Character >::write_string(), and __crt_stdio_output::output_adapter_common< Character, Derived >::write_string_impl().

◆ result_buffer

◆ return

return

Definition at line 564 of file cvt.cpp.

◆ rounding_mode

◆ scratch_buffer_count

_In_ size_t const scratch_buffer_count

Definition at line 219 of file cvt.cpp.

Referenced by __acrt_fp_format(), and if().