Add files using upload-large-folder tool

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgets.cpp

@@ -0,0 +1,128 @@
+//
+// cgets.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cgets() and _cgets_s(), which read a string from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_securecrt.h>
+#include <stdlib.h>
+
+
+
+extern "C" extern intptr_t __dcrt_lowio_console_input_handle;
+
+
+
+// Use of the following buffer variables is primarily for syncronizing with
+// _cgets_s. _cget_s fills the MBCS buffer and if the user passes in single
+// character buffer and the unicode character is not converted to single byte
+// MBC, then _cget_s should buffer that character so that next call to
+// _cgetws_s can return the same character.
+extern "C" extern wchar_t __console_wchar_buffer;
+extern "C" extern int     __console_wchar_buffer_used;
+
+
+
+// Reads a string from the console; always null-terminates the buffer.  Returns
+// 0 on success; returns an errno error code on failure.
+extern "C" errno_t __cdecl _cgets_s(char* const source_string, size_t const size_in_bytes, size_t* const size_read)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(source_string != nullptr, EINVAL);
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_in_bytes > 0,        EINVAL);
+    _RESET_STRING(source_string, size_in_bytes);
+
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_read != nullptr, EINVAL);
+
+    errno_t error  = 0;
+    char*   string = source_string;
+
+    __acrt_lock(__acrt_conio_lock);
+    __try
+    {
+        // The implementation of cgets is slightly tricky. The reason being,
+        // the code page for console is different from the CRT code page.
+        // What this means is the program may interpret character
+        // differently from it's acctual value. To fix this, what we really
+        // want to do is read the input as unicode string and then convert
+        // it to proper MBCS representation.
+        //
+        // This fix this we are really converting from Unicode to MBCS.
+        // This adds performance problem as we may endup doing this
+        // character by character. The basic problem here is that we have
+        // no way to know how many UNICODE characters will be needed to fit
+        // them in given size of MBCS buffer. To fix this issue we will be
+        // converting one Unicode character at a time to MBCS. This makes
+        // this slow, but then this is already console input,
+        *size_read = 0;
+
+        size_t available = size_in_bytes - 1;
+        do
+        {
+            wchar_t wchar_buff[2];
+            size_t sizeRead = 0;
+
+            error = _cgetws_s(wchar_buff, _countof(wchar_buff), &sizeRead);
+            if (error != 0)
+                break;
+
+            if (wchar_buff[0] == '\0')
+                break;
+
+            int size_converted = 0;
+            errno_t const wctomb_result = wctomb_s(&size_converted, string, available, wchar_buff[0]);
+            if (wctomb_result != 0)
+            {
+                // Put the wide character back in the buffer so that the
+                // unutilized wide character is still in the stream:
+                __console_wchar_buffer = wchar_buff[0];
+                __console_wchar_buffer_used = 1;
+                break;
+            }
+
+            string     += size_converted;
+            *size_read += size_converted;
+            available  -= size_converted;
+        }
+        while (available > 0);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+
+    *string++ = '\0';
+
+    if (error != 0)
+        errno = error;
+
+    return error;
+}
+
+
+
+// Reads a string from the console via ReadConsole on a cooked console handle.
+// string[0] must contain the maximum length of the string.  The number of
+// characters written is stored in string[1].  The return value is a pointer to
+// string[2] on success; nullptr on failure.
+extern "C" char* __cdecl _cgets(_Inout_z_ char* const string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(string != nullptr, EINVAL, nullptr);
+    _VALIDATE_CLEAR_OSSERR_RETURN(string[0] > 0,     EINVAL, nullptr);
+
+    size_t const size_in_bytes = static_cast<size_t>(string[0]);
+
+    size_t size_read = 0;
+    // warning 26018: Potential overflow of null terminated buffer using expression string+2
+    // Suppressing warning since _cgets is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    errno_t const result = _cgets_s(string + 2, size_in_bytes, &size_read);
+
+    // warning 26018: Potential overflow of null terminated buffer using expression string[1]
+    // Suppressing warning since _cgets is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    string[1] = static_cast<char>(size_read);
+
+    return result == 0 ? string + 2 : nullptr;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgetws.cpp

@@ -0,0 +1,156 @@
+//
+// cgetws.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cgetws() and _cgetws_s(), which read a wide string from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_securecrt.h>
+#include <stdlib.h>
+
+// Use of the following buffer variables is primarily for syncronizing with
+// _cgets_s. _cget_s fills the MBCS buffer and if the user passes in single
+// character buffer and the unicode character is not converted to single byte
+// MBC, then _cget_s should buffer that character so that next call to
+// _cgetws_s can return the same character.
+extern "C" wchar_t __console_wchar_buffer      = 0;
+extern "C" int     __console_wchar_buffer_used = 0;
+
+
+
+// Reads a string from the console; always null-terminates the buffer.  Returns
+// 0 on success; returns an errno error code on failure.
+extern "C" errno_t __cdecl _cgetws_s(wchar_t* const string_buffer, size_t const size_in_words, size_t* const size_read)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(string_buffer != nullptr, EINVAL);
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_in_words > 0, EINVAL);
+    _RESET_STRING(string_buffer, size_in_words);
+
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_read != nullptr, EINVAL);
+
+    __acrt_lock(__acrt_conio_lock);
+    errno_t retval = 0;
+    __try
+    {
+        wchar_t* string = string_buffer;
+
+        // We need to decrement size_in_words because ReadConsole reads as many
+        // characters as the parameter passed.  It doesn't null-terminate:
+        size_t size_remaining = size_in_words - 1;
+        *size_read = 0;
+
+        // If size_in_words was 1, then there's only room for the null terminator:
+        if (size_remaining == 0)
+            __leave;
+
+        // If there is a buffered character, first fill with the buffered
+        // character then proceed with reading from the console:
+        if (__console_wchar_buffer_used != 0)
+        {
+            *string++ = __console_wchar_buffer;
+            --size_remaining;
+            (*size_read)++;
+
+            if (__console_wchar_buffer == L'\0')
+                size_remaining = 0;
+
+            __console_wchar_buffer = 0;
+        }
+
+        if (size_remaining == 0)
+            __leave;
+
+        /*
+        * __dcrt_lowio_console_input_handle, the handle to the console input, is created the first
+        * time that either _getch() or _cgets() or _kbhit() is called.
+        */
+
+        if (__dcrt_lowio_ensure_console_input_initialized() == FALSE)
+        {
+            __acrt_errno_map_os_error(GetLastError());
+            retval = errno;
+            __leave;
+        }
+
+        ULONG old_state;
+        __dcrt_get_input_console_mode(&old_state);
+        __dcrt_set_input_console_mode(ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT | ENABLE_ECHO_INPUT);
+
+        ULONG wchars_read;
+        BOOL read_console_result = __dcrt_read_console(
+            string,
+            static_cast<DWORD>(size_remaining),
+            &wchars_read);
+
+        if (!read_console_result)
+        {
+            __acrt_errno_map_os_error(GetLastError());
+            retval = errno;
+            __leave;
+        }
+
+        // Set the length of the string and null terminate it:
+        if (wchars_read >= 2 && string[wchars_read - 2] == L'\r')
+        {
+            *size_read += wchars_read - 2;
+            string[wchars_read - 2] = L'\0';
+        }
+        else if (wchars_read == size_remaining && string[wchars_read - 1] == L'\r')
+        {
+            // Special case 1:  \r\n straddles the boundary:
+            string[wchars_read - 1] = L'\0';
+            *size_read += wchars_read - 1;
+        }
+        else if (wchars_read == 1 && string[0] == L'\n')
+        {
+            // Special case 2:  Read a single \n:
+            string[0] = L'\0';
+            *size_read += 0;
+        }
+        else
+        {
+            *size_read += wchars_read;
+            string[wchars_read] = L'\0';
+        }
+
+        __dcrt_set_input_console_mode(old_state);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+
+    return retval;
+}
+
+
+
+// Reads a string from the console via ReadConsole on a cooked console handle.
+// string[0] must contain the maximum length of the string.  The number of
+// characters written is stored in string[1].  The return value is a pointer to
+// string[2] on success; nullptr on failure.
+//
+// Note that _cgetws() does NOT check the pushback character buffer, so it will
+// not return any character that is pushed back by a call to _ungetwch().
+extern "C" wchar_t* __cdecl _cgetws(_Inout_z_ wchar_t* const string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(string != nullptr, EINVAL, nullptr);
+    _VALIDATE_CLEAR_OSSERR_RETURN(string[0] > 0,     EINVAL, nullptr);
+
+    size_t const size_in_words = static_cast<size_t>(string[0]);
+
+    size_t size_read = 0;
+    // warning 26018: Potential overflow of null terminated buffer using expression string+2
+    // Suppressing warning since _cgetws is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    errno_t const result = _cgetws_s(string + 2, size_in_words, &size_read);
+
+    // warning 26018: Potential overflow of null terminated buffer using expression string[1]
+    // Suppressing warning since _cgetws is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    string[1] = static_cast<wchar_t>(size_read);
+
+    return result == 0 ? string + 2 : nullptr;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cprintf.cpp

@@ -0,0 +1,104 @@
+//
+// cprintf.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The standard output functions, which perform formatted output to the
+// console.
+//
+#include <corecrt_internal_stdio_output.h>
+
+
+using namespace __crt_stdio_output;
+
+
+
+template <template <typename, typename> class Base, typename Character>
+static int __cdecl common_vcprintf(
+    unsigned __int64   const options,
+    Character const*   const format,
+    __crt_cached_ptd_host&   ptd,
+    va_list            const arglist
+    )
+{
+    typedef output_processor<
+        Character,
+        console_output_adapter<Character>,
+        Base<Character, console_output_adapter<Character>>
+    > processor_type;
+
+    processor_type processor(
+        console_output_adapter<Character>(),
+        options,
+        format,
+        ptd,
+        arglist);
+
+    return processor.process();
+}
+
+extern "C" int __cdecl __conio_common_vcprintf(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<standard_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcprintf_s(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<format_validation_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcprintf_p(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<positional_parameter_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwprintf(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<standard_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwprintf_s(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<format_validation_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwprintf_p(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<positional_parameter_base>(options, format, ptd, arglist);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputs.cpp

@@ -0,0 +1,38 @@
+//
+// cputs.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cputs(), which writes a string directly to the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+
+// Writes the given string directly to the console.  No newline is appended.
+// Returns 0 on success; nonzero on failure.
+extern "C" int __cdecl _cputs(char const* const string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(string != nullptr, EINVAL, -1);
+
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        // Write the string directly to the console.  Each character is written
+        // individually, as performance of this function is not considered
+        // critical.
+        for (char const* p = string; *p; ++p)
+        {
+            if (_putch_nolock(*p) == EOF)
+            {
+                result = -1;
+                __leave;
+            }
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputws.cpp

@@ -0,0 +1,63 @@
+//
+// cputws.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cputws(), which writes a wide string directly to the console.
+//
+#include <conio.h>
+#include <errno.h>
+#include <corecrt_internal_lowio.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Writes the given string directly to the console.  No newline is appended.
+//
+// Returns 0 on success; nonzero on failure.
+extern "C" int __cdecl _cputws(wchar_t const* string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN((string != nullptr), EINVAL, -1);
+
+    if (__dcrt_lowio_ensure_console_output_initialized() == FALSE)
+        return -1;
+
+    // Write string to console file handle:
+    ptrdiff_t length = wcslen(string);
+
+    __acrt_lock(__acrt_conio_lock);
+
+    int result = 0;
+
+    __try
+    {
+        while (length > 0)
+        {
+            static size_t const max_write_bytes = 65535;
+            static size_t const max_write_wchars = max_write_bytes / sizeof(wchar_t);
+
+            DWORD const wchars_to_write = length > max_write_wchars
+                ? max_write_wchars
+                : static_cast<DWORD>(length);
+
+            DWORD wchars_written;
+            if (__dcrt_write_console(
+                string,
+                wchars_to_write,
+                &wchars_written) == FALSE)
+            {
+                result = -1;
+                __leave;
+            }
+
+            string += wchars_to_write;
+            length -= wchars_to_write;
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+
+    return result;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cscanf.cpp

@@ -0,0 +1,56 @@
+//
+// cscanf.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The core formatted input functions for direct console I/O.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_stdio_input.h>
+
+using namespace __crt_stdio_input;
+
+template <typename Character>
+static int __cdecl common_cscanf(
+    unsigned __int64 const options,
+    Character const* const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    ) throw()
+{
+    typedef input_processor<
+        Character,
+        console_input_adapter<Character>
+    > processor_type;
+
+    _LocaleUpdate locale_update(locale);
+
+    processor_type processor(
+        console_input_adapter<Character>(),
+        options,
+        format,
+        locale_update.GetLocaleT(),
+        arglist);
+
+    return processor.process();
+}
+
+extern "C" int __cdecl __conio_common_vcscanf(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_cscanf(options, format, locale, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwscanf(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_cscanf(options, format, locale, arglist);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getch.cpp

@@ -0,0 +1,569 @@
+//
+// getch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _getch(), _getche(), and _ungetch(), which get and unget
+// characters directly from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+namespace
+{
+    struct CharPair
+    {
+        unsigned char LeadChar;
+        unsigned char SecondChar;
+    };
+
+    struct EnhKeyVals
+    {
+        unsigned short ScanCode;
+        CharPair RegChars;
+        CharPair ShiftChars;
+        CharPair CtrlChars;
+        CharPair AltChars;
+    };
+
+    struct NormKeyVals
+    {
+        CharPair RegChars;
+        CharPair ShiftChars;
+        CharPair CtrlChars;
+        CharPair AltChars;
+    };
+}
+
+
+
+// Table of enhanced key values:
+static EnhKeyVals const EnhancedKeys[] =
+{
+    { 28, {  13,   0 }, {  13,   0 }, {  10,   0 }, {   0, 166 } },
+    { 53, {  47,   0 }, {  63,   0 }, {   0, 149 }, {   0, 164 } },
+    { 71, { 224,  71 }, { 224,  71 }, { 224, 119 }, {   0, 151 } },
+    { 72, { 224,  72 }, { 224,  72 }, { 224, 141 }, {   0, 152 } },
+    { 73, { 224,  73 }, { 224,  73 }, { 224, 134 }, {   0, 153 } },
+    { 75, { 224,  75 }, { 224,  75 }, { 224, 115 }, {   0, 155 } },
+    { 77, { 224,  77 }, { 224,  77 }, { 224, 116 }, {   0, 157 } },
+    { 79, { 224,  79 }, { 224,  79 }, { 224, 117 }, {   0, 159 } },
+    { 80, { 224,  80 }, { 224,  80 }, { 224, 145 }, {   0, 160 } },
+    { 81, { 224,  81 }, { 224,  81 }, { 224, 118 }, {   0, 161 } },
+    { 82, { 224,  82 }, { 224,  82 }, { 224, 146 }, {   0, 162 } },
+    { 83, { 224,  83 }, { 224,  83 }, { 224, 147 }, {   0, 163 } }
+};
+
+// The number of elements in EnhancedKeys:
+#define NUM_EKA_ELTS (sizeof(EnhancedKeys) / sizeof(EnhKeyVals))
+
+
+
+// Table of key values for normal keys.  Note that the table is padded so that
+// the key scan code serves as an index into the table.
+static NormKeyVals const NormalKeys[] =
+{
+    /* padding */
+    { /*  0 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /*  1 */ {  27,   0 }, {  27,   0 }, {  27,   0 }, {   0,   1 } },
+    { /*  2 */ {  49,   0 }, {  33,   0 }, {   0,   0 }, {   0, 120 } },
+    { /*  3 */ {  50,   0 }, {  64,   0 }, {   0,   3 }, {   0, 121 } },
+    { /*  4 */ {  51,   0 }, {  35,   0 }, {   0,   0 }, {   0, 122 } },
+    { /*  5 */ {  52,   0 }, {  36,   0 }, {   0,   0 }, {   0, 123 } },
+    { /*  6 */ {  53,   0 }, {  37,   0 }, {   0,   0 }, {   0, 124 } },
+    { /*  7 */ {  54,   0 }, {  94,   0 }, {  30,   0 }, {   0, 125 } },
+    { /*  8 */ {  55,   0 }, {  38,   0 }, {   0,   0 }, {   0, 126 } },
+    { /*  9 */ {  56,   0 }, {  42,   0 }, {   0,   0 }, {   0, 127 } },
+    { /* 10 */ {  57,   0 }, {  40,   0 }, {   0,   0 }, {   0, 128 } },
+    { /* 11 */ {  48,   0 }, {  41,   0 }, {   0,   0 }, {   0, 129 } },
+    { /* 12 */ {  45,   0 }, {  95,   0 }, {  31,   0 }, {   0, 130 } },
+    { /* 13 */ {  61,   0 }, {  43,   0 }, {   0,   0 }, {   0, 131 } },
+    { /* 14 */ {   8,   0 }, {   8,   0 }, { 127,   0 }, {   0,  14 } },
+    { /* 15 */ {   9,   0 }, {   0,  15 }, {   0, 148 }, {   0,  15 } },
+    { /* 16 */ { 113,   0 }, {  81,   0 }, {  17,   0 }, {   0,  16 } },
+    { /* 17 */ { 119,   0 }, {  87,   0 }, {  23,   0 }, {   0,  17 } },
+    { /* 18 */ { 101,   0 }, {  69,   0 }, {   5,   0 }, {   0,  18 } },
+    { /* 19 */ { 114,   0 }, {  82,   0 }, {  18,   0 }, {   0,  19 } },
+    { /* 20 */ { 116,   0 }, {  84,   0 }, {  20,   0 }, {   0,  20 } },
+    { /* 21 */ { 121,   0 }, {  89,   0 }, {  25,   0 }, {   0,  21 } },
+    { /* 22 */ { 117,   0 }, {  85,   0 }, {  21,   0 }, {   0,  22 } },
+    { /* 23 */ { 105,   0 }, {  73,   0 }, {   9,   0 }, {   0,  23 } },
+    { /* 24 */ { 111,   0 }, {  79,   0 }, {  15,   0 }, {   0,  24 } },
+    { /* 25 */ { 112,   0 }, {  80,   0 }, {  16,   0 }, {   0,  25 } },
+    { /* 26 */ {  91,   0 }, { 123,   0 }, {  27,   0 }, {   0,  26 } },
+    { /* 27 */ {  93,   0 }, { 125,   0 }, {  29,   0 }, {   0,  27 } },
+    { /* 28 */ {  13,   0 }, {  13,   0 }, {  10,   0 }, {   0,  28 } },
+
+    /* padding */
+    { /* 29 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 30 */ {  97,   0 }, {  65,   0 }, {   1,   0 }, {   0,  30 } },
+    { /* 31 */ { 115,   0 }, {  83,   0 }, {  19,   0 }, {   0,  31 } },
+    { /* 32 */ { 100,   0 }, {  68,   0 }, {   4,   0 }, {   0,  32 } },
+    { /* 33 */ { 102,   0 }, {  70,   0 }, {   6,   0 }, {   0,  33 } },
+    { /* 34 */ { 103,   0 }, {  71,   0 }, {   7,   0 }, {   0,  34 } },
+    { /* 35 */ { 104,   0 }, {  72,   0 }, {   8,   0 }, {   0,  35 } },
+    { /* 36 */ { 106,   0 }, {  74,   0 }, {  10,   0 }, {   0,  36 } },
+    { /* 37 */ { 107,   0 }, {  75,   0 }, {  11,   0 }, {   0,  37 } },
+    { /* 38 */ { 108,   0 }, {  76,   0 }, {  12,   0 }, {   0,  38 } },
+    { /* 39 */ {  59,   0 }, {  58,   0 }, {   0,   0 }, {   0,  39 } },
+    { /* 40 */ {  39,   0 }, {  34,   0 }, {   0,   0 }, {   0,  40 } },
+    { /* 41 */ {  96,   0 }, { 126,   0 }, {   0,   0 }, {   0,  41 } },
+
+    /* padding */
+    { /* 42 */ {    0,  0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 43 */ {  92,   0 }, { 124,   0 }, {  28,   0 }, {   0,   0 } },
+    { /* 44 */ { 122,   0 }, {  90,   0 }, {  26,   0 }, {   0,  44 } },
+    { /* 45 */ { 120,   0 }, {  88,   0 }, {  24,   0 }, {   0,  45 } },
+    { /* 46 */ {  99,   0 }, {  67,   0 }, {   3,   0 }, {   0,  46 } },
+    { /* 47 */ { 118,   0 }, {  86,   0 }, {  22,   0 }, {   0,  47 } },
+    { /* 48 */ {  98,   0 }, {  66,   0 }, {   2,   0 }, {   0,  48 } },
+    { /* 49 */ { 110,   0 }, {  78,   0 }, {  14,   0 }, {   0,  49 } },
+    { /* 50 */ { 109,   0 }, {  77,   0 }, {  13,   0 }, {   0,  50 } },
+    { /* 51 */ {  44,   0 }, {  60,   0 }, {   0,   0 }, {   0,  51 } },
+    { /* 52 */ {  46,   0 }, {  62,   0 }, {   0,   0 }, {   0,  52 } },
+    { /* 53 */ {  47,   0 }, {  63,   0 }, {   0,   0 }, {   0,  53 } },
+
+    /* padding */
+    { /* 54 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 55 */ {  42,   0 }, {   0,   0 }, { 114,   0 }, {   0,   0 } },
+
+    /* padding */
+    { /* 56 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 57 */ {  32,   0 }, {  32,   0 }, {  32,   0 }, {  32,   0 } },
+
+    /* padding */
+    { /* 58 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 59 */ {   0,  59 }, {   0,  84 }, {   0,  94 }, {   0, 104 } },
+    { /* 60 */ {   0,  60 }, {   0,  85 }, {   0,  95 }, {   0, 105 } },
+    { /* 61 */ {   0,  61 }, {   0,  86 }, {   0,  96 }, {   0, 106 } },
+    { /* 62 */ {   0,  62 }, {   0,  87 }, {   0,  97 }, {   0, 107 } },
+    { /* 63 */ {   0,  63 }, {   0,  88 }, {   0,  98 }, {   0, 108 } },
+    { /* 64 */ {   0,  64 }, {   0,  89 }, {   0,  99 }, {   0, 109 } },
+    { /* 65 */ {   0,  65 }, {   0,  90 }, {   0, 100 }, {   0, 110 } },
+    { /* 66 */ {   0,  66 }, {   0,  91 }, {   0, 101 }, {   0, 111 } },
+    { /* 67 */ {   0,  67 }, {   0,  92 }, {   0, 102 }, {   0, 112 } },
+    { /* 68 */ {   0,  68 }, {   0,  93 }, {   0, 103 }, {   0, 113 } },
+
+    /* padding */
+    { /* 69 */ {    0,  0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 70 */ {    0,  0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 71 */ {   0,  71 }, {  55,   0 }, {   0, 119 }, {   0,   0 } },
+    { /* 72 */ {   0,  72 }, {  56,   0 }, {   0, 141 }, {   0,   0 } },
+    { /* 73 */ {   0,  73 }, {  57,   0 }, {   0, 132 }, {   0,   0 } },
+    { /* 74 */ {   0,   0 }, {  45,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 75 */ {   0,  75 }, {  52,   0 }, {   0, 115 }, {   0,   0 } },
+    { /* 76 */ {   0,   0 }, {  53,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 77 */ {   0,  77 }, {  54,   0 }, {   0, 116 }, {   0,   0 } },
+    { /* 78 */ {   0,   0 }, {  43,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 79 */ {   0,  79 }, {  49,   0 }, {   0, 117 }, {   0,   0 } },
+    { /* 80 */ {   0,  80 }, {  50,   0 }, {   0, 145 }, {   0,   0 } },
+    { /* 81 */ {   0,  81 }, {  51,   0 }, {   0, 118 }, {   0,   0 } },
+    { /* 82 */ {   0,  82 }, {  48,   0 }, {   0, 146 }, {   0,   0 } },
+    { /* 83 */ {   0,  83 }, {  46,   0 }, {   0, 147 }, {   0,   0 } },
+
+    /* padding */
+    { /* 84 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 85 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 86 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 87 */ { 224, 133 }, { 224, 135 }, { 224, 137 }, { 224, 139 } },
+    { /* 88 */ { 224, 134 }, { 224, 136 }, { 224, 138 }, { 224, 140 } }
+};
+
+// The primary purpose of the pushback buffer is so that if a
+// multi-byte character or extended key code is read, we can return
+// the first byte and store the rest of the data in the buffer for
+// subsequent calls. UTF-8 characters can be up to 4 bytes long, so
+// the pushback buffer must be able to store the 3 remaining bytes.
+size_t const getch_pushback_buffer_capacity = 3;
+
+static int getch_pushback_buffer[getch_pushback_buffer_capacity];
+static int getch_pushback_buffer_index = 0;
+static int getch_pushback_buffer_current_size = 0;
+
+static bool is_getch_pushback_buffer_full()
+{
+    return getch_pushback_buffer_current_size >= getch_pushback_buffer_capacity;
+}
+
+static void add_to_getch_pushback_buffer(int const c)
+{
+    _ASSERTE(!is_getch_pushback_buffer_full());
+    getch_pushback_buffer[getch_pushback_buffer_current_size++] = c;
+}
+
+static int peek_next_getch_pushback_buffer()
+{
+    if (getch_pushback_buffer_current_size == 0) {
+        return EOF;
+    }
+
+    return getch_pushback_buffer[getch_pushback_buffer_index];
+}
+
+static int get_next_getch_pushback_buffer()
+{
+    if (getch_pushback_buffer_current_size == 0) {
+        return EOF;
+    }
+
+    int const ret_val = getch_pushback_buffer[getch_pushback_buffer_index++];
+
+    if (getch_pushback_buffer_index == getch_pushback_buffer_current_size) {
+        getch_pushback_buffer_index = 0;
+        getch_pushback_buffer_current_size = 0;
+    }
+
+    return ret_val;
+}
+
+extern "C" extern intptr_t __dcrt_lowio_console_input_handle;
+
+extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD*);
+extern "C" int __cdecl _kbhit_nolock();
+
+
+
+// These functions read a single character from the console.  _getch() does not
+// echo the character; _getche() does echo the character.  If the push-back
+// buffer is nonempty, the buffered character is returned immediately, without
+// being echoed.
+//
+// On success, the read character is returned; on failure, EOF is returned.
+extern "C" int __cdecl _getch()
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _getch_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+extern "C" int __cdecl _getche()
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _getche_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+extern "C" int __cdecl _getch_nolock()
+{
+    // Check the pushback buffer for a character.  If one is present, return it:
+    int const pushback = get_next_getch_pushback_buffer();
+    if (pushback != EOF)
+    {
+        return pushback;
+    }
+
+    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) {
+        return EOF;
+    }
+
+    // Switch console to raw mode:
+    DWORD old_console_mode;
+    __dcrt_get_input_console_mode(&old_console_mode);
+    __dcrt_set_input_console_mode(0);
+
+    int result = 0;
+
+    __try
+    {
+        for ( ; ; )
+        {
+            // Get a console input event:
+            INPUT_RECORD input_record;
+            DWORD num_read;
+
+            if (__dcrt_read_console_input(&input_record, 1, &num_read) == FALSE || num_read == 0)
+            {
+                result = EOF;
+                __leave;
+            }
+
+            // Look for, and decipher, key events.
+            if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown)
+            {
+                // Simple case:  if UnicodeChar is non-zero, we can convert it to char and return it.
+                wchar_t const c = input_record.Event.KeyEvent.uChar.UnicodeChar;
+                if (c != 0)
+                {
+                    wchar_t const c_buffer[2] = {c, L'\0'};
+                    char mb_chars[4];
+
+                    size_t const amount_written = __acrt_wcs_to_mbs_cp_array(
+                        c_buffer,
+                        mb_chars,
+                        GetConsoleCP()
+                        );
+
+                    // Mask with 0xFF to just get lowest byte
+                    if (amount_written >= 1) {
+                        result = mb_chars[0] & 0xFF;
+                    }
+
+                    if (amount_written >= 2) {
+                        for (size_t i = 1; i < amount_written; ++i) {
+                            add_to_getch_pushback_buffer(mb_chars[i] & 0xFF);
+                        }
+                    }
+                    __leave;
+                }
+
+                // Hard case:  either it is an extended code or an event which
+                // should not be recognized.  Let _getextendedkeycode do the work:
+                CharPair const* const cp = _getextendedkeycode(&input_record.Event.KeyEvent);
+                if (cp != nullptr)
+                {
+                    // Mask with 0xFF to just get lowest byte
+                    add_to_getch_pushback_buffer(cp->SecondChar & 0xFF);
+                    result = cp->LeadChar & 0xFF;
+                    __leave;
+                }
+            }
+        }
+    }
+    __finally
+    {
+        // Restore the previous console mode:
+        __dcrt_set_input_console_mode(old_console_mode);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _getche_nolock()
+{
+    // Check the pushback buffer for a character.  If one is present, return
+    // it without echoing:
+    int const pushback = get_next_getch_pushback_buffer();
+    if (pushback != EOF)
+    {
+        return pushback;
+    }
+
+    // Otherwise, read the next character from the console and echo it:
+    int const c = _getch_nolock();
+    if (c == EOF)
+        return EOF;
+
+    if (_putch_nolock(c) == EOF)
+        return EOF;
+
+    return c;
+}
+
+
+
+// Returns nonzero if a keystroke is waiting to be read; otherwise returns zero.
+extern "C" int __cdecl _kbhit()
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _kbhit_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _kbhit_nolock()
+{
+    // If a character has been pushed back, return TRUE:
+    if (peek_next_getch_pushback_buffer() != EOF) {
+        return TRUE;
+    }
+
+    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) {
+        return FALSE;
+    }
+
+    // Peek at all pending console events:
+    DWORD num_pending;
+    if (__dcrt_get_number_of_console_input_events(&num_pending) == FALSE) {
+        return FALSE;
+    }
+
+    if (num_pending == 0) {
+        return FALSE;
+    }
+
+    __crt_scoped_stack_ptr<INPUT_RECORD> const input_buffer(_malloca_crt_t(INPUT_RECORD, num_pending));
+    if (input_buffer.get() == nullptr) {
+        return FALSE;
+    }
+
+    DWORD num_peeked;
+    // AsciiChar is not read, so using the narrow Win32 API is permitted.
+    if (__dcrt_peek_console_input_a(input_buffer.get(), num_pending, &num_peeked) == FALSE) {
+        return FALSE;
+    }
+
+    if (num_peeked == 0 || num_peeked > num_pending) {
+        return FALSE;
+    }
+
+    // Scan all of the peeked events to determine if any is a key event
+    // that should be recognized:
+    for (INPUT_RECORD* p = input_buffer.get(); num_peeked > 0; --num_peeked, ++p)
+    {
+        if (p->EventType != KEY_EVENT)
+            continue;
+
+        if (!p->Event.KeyEvent.bKeyDown)
+            continue;
+
+        if (p->Event.KeyEvent.uChar.AsciiChar == 0 &&
+            _getextendedkeycode(&p->Event.KeyEvent) == nullptr)
+            continue;
+
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+
+
+// Pushes back ("ungets") one character to be read next by _getwch() or
+// _getwche().  On success, returns the character that was pushed back; on
+// failure, returns EOF.
+extern "C" int __cdecl _ungetch(int const c)
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _ungetch_nolock(c);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _ungetch_nolock(int const c)
+{
+    // Fail if the character is EOF or the pusback buffer is nonempty:
+    if (c == EOF || is_getch_pushback_buffer_full()) {
+        return EOF;
+    }
+
+    add_to_getch_pushback_buffer(c);
+    return c;
+}
+
+
+
+// Returns the extended code (if there is one) for a key event.  This is the
+// core function for the _getch() and _getche() functions and their wide
+// character equivalents, and is essential to _kbhit().  This is the function
+// that determines whether or not a key event NOT accompanied by an ASCII
+// character has an extended code and returns that code.
+//
+// On success, a pointer to a CharPair value holding the lead and second
+// characters of the extended code is returned.  On failure, nullptr is returned.
+extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD* const pKE)
+{
+    DWORD const CKS = pKE->dwControlKeyState;
+
+    if (CKS & ENHANCED_KEY)
+    {
+        // Find the appropriate entry in EnhancedKeys[]:
+        for (int i = 0 ; i < NUM_EKA_ELTS; ++i)
+        {
+            if (EnhancedKeys[i].ScanCode != pKE->wVirtualScanCode)
+            {
+                continue;
+            }
+
+            // We found a match!  Determine which pair to return:
+            if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
+            {
+                return &EnhancedKeys[i].AltChars;
+            }
+            else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
+            {
+                return &EnhancedKeys[i].CtrlChars;
+            }
+            else if (CKS & SHIFT_PRESSED)
+            {
+                return &EnhancedKeys[i].ShiftChars;
+            }
+            else
+            {
+                return &EnhancedKeys[i].RegChars;
+            }
+        }
+
+        return nullptr;
+    }
+    else
+    {
+        // Regular key or keyboard event which shouldn't be recognized.
+        // Determine which by getting the proper field of the proper entry in
+        // NormalKeys[] and examining the extended code.
+        CharPair const* pCP;
+
+        if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].AltChars;
+        }
+        else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].CtrlChars;
+        }
+        else if (CKS & SHIFT_PRESSED)
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].ShiftChars;
+        }
+        else
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].RegChars;
+        }
+
+        // Make sure it wasn't a keyboard event which should not be recognized
+        // (e.g. the shift key was pressed):
+        if ((pCP->LeadChar != 0 && pCP->LeadChar != 224) || pCP->SecondChar == 0)
+        {
+            return nullptr;
+        }
+
+        return pCP;
+    }
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getwch.cpp

@@ -0,0 +1,201 @@
+//
+// getwch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _getwch(), _getwche(), and _ungetwch(), which get and unget
+// characters directly from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+
+
+namespace
+{
+    struct CharPair
+    {
+        unsigned char LeadChar;
+        unsigned char SecondChar;
+    };
+}
+
+
+static wint_t wchbuf = WEOF; // The push-back buffer
+
+extern "C" extern intptr_t __dcrt_lowio_console_input_handle;
+
+extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD*);
+
+
+
+// Reads one character directly from the console.  The _getwche() form also
+// echoes the character back to the console.  If the push-back buffer is
+// nonempty, then its value is returned and the push-back buffer is marked as
+// empty.
+//
+// Returns the character that is read on success; returns WEOF on failure.
+extern "C" wint_t __cdecl _getwch()
+{
+    __acrt_lock(__acrt_conio_lock);
+    wint_t result = 0;
+    __try
+    {
+        result = _getwch_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+extern "C" wint_t __cdecl _getwche()
+{
+    __acrt_lock(__acrt_conio_lock);
+    wint_t result = 0;
+    __try
+    {
+        result = _getwche_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" wint_t __cdecl _getwch_nolock()
+{
+    // First check the pushback buffer for a character.  If it has one, return
+    // it without echoing and reset the buffer:
+    if (wchbuf != WEOF)
+    {
+        wchar_t const buffered_wchar = static_cast<wchar_t>(wchbuf & 0xFFFF);
+        wchbuf = WEOF;
+        return buffered_wchar;
+    }
+
+    // The console input handle is created the first time that _getwch(),
+    // _cgetws(), or _kbhit() is called:
+    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE)
+        return WEOF;
+
+    // Switch to raw mode (no line input, no echo input):
+    DWORD old_console_mode;
+    __dcrt_get_input_console_mode(&old_console_mode);
+    __dcrt_set_input_console_mode(0);
+    wint_t result = 0;
+    __try
+    {
+        for ( ; ; )
+        {
+            // Get a console input event:
+            INPUT_RECORD input_record;
+            DWORD num_read;
+            if (__dcrt_read_console_input(&input_record, 1, &num_read) == FALSE)
+            {
+                result = WEOF;
+                __leave;
+            }
+
+            if (num_read == 0)
+            {
+                result = WEOF;
+                __leave;
+            }
+
+            // Look for, and decipher, key events.
+            if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown)
+            {
+                // Easy case:  if UnicodeChar is non-zero, we can just return it:
+                wchar_t const c = static_cast<wchar_t>(input_record.Event.KeyEvent.uChar.UnicodeChar);
+                if (c != 0)
+                {
+                    result = c;
+                    __leave;
+                }
+
+                // Hard case:  either it is an extended code or an event which
+                // should not be recognized.  Let _getextendedkeycode do the work:
+                CharPair const* const cp = _getextendedkeycode(&input_record.Event.KeyEvent);
+                if (cp != nullptr)
+                {
+                    wchbuf = cp->SecondChar;
+                    result = cp->LeadChar;
+                    __leave;
+                }
+            }
+        }
+    }
+    __finally
+    {
+        // Restore the previous console mode:
+        __dcrt_set_input_console_mode(old_console_mode);
+    }
+    return result;
+}
+
+
+
+extern "C" wint_t __cdecl _getwche_nolock()
+{
+    // First check the pushback buffer for a character.  If it has one, return
+    // it without echoing and reset the buffer:
+    if (wchbuf != WEOF)
+    {
+        wchar_t const buffered_wchar = static_cast<wchar_t>(wchbuf & 0xFFFF);
+        wchbuf = WEOF;
+        return buffered_wchar;
+    }
+
+    // Othwrwise, read the character, echo it, and return it.  If anything fails,
+    // we immediately return WEOF.
+    wchar_t const gotten_wchar = _getwch_nolock();
+    if (gotten_wchar == WEOF)
+        return WEOF;
+
+    if (_putwch_nolock(gotten_wchar) == WEOF)
+        return WEOF;
+
+    return gotten_wchar;
+}
+
+
+
+// Pushes back ("ungets") one character to be read next by _getwch() or
+// _getwche().  On success, returns the character that was pushed back; on
+// failure, returns EOF.
+extern "C" wint_t __cdecl _ungetwch(wint_t const c)
+{
+    __acrt_lock(__acrt_conio_lock);
+    wint_t result = 0;
+    __try
+    {
+        result = _ungetwch_nolock(c);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" wint_t __cdecl _ungetwch_nolock(wint_t const c)
+{
+    // Fail if the char is EOF or the pushback buffer is non-empty:
+    if (c == WEOF || wchbuf != WEOF)
+        return static_cast<wint_t>(EOF);
+
+    wchbuf = (c & 0xFF);
+    return wchbuf;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initcon.cpp

@@ -0,0 +1,83 @@
+//
+// initcon.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the global console output handle and the __dcrt_lowio_initialize_console_output() and
+// __dcrt_terminate_console_output() functions, which initialize and close that handle.
+// Also defines functions that can be used instead of the Console API to enable retry behavior
+// in case the cached console handle is freed.
+
+#include <corecrt_internal_lowio.h>
+
+_CRT_LINKER_FORCE_INCLUDE(__dcrt_console_output_terminator);
+
+// The global console output handle.
+static HANDLE __dcrt_lowio_console_output_handle = _console_uninitialized_handle;
+
+// Initializes the global console output handle
+static void __dcrt_lowio_initialize_console_output()
+{
+    __dcrt_lowio_console_output_handle = CreateFileW(
+        L"CONOUT$",
+        GENERIC_WRITE,
+        FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nullptr,
+        OPEN_EXISTING,
+        0,
+        nullptr);
+}
+
+extern "C" BOOL __cdecl __dcrt_lowio_ensure_console_output_initialized()
+{
+    if (__dcrt_lowio_console_output_handle == _console_uninitialized_handle)
+    {
+        __dcrt_lowio_initialize_console_output();
+    }
+
+    if (__dcrt_lowio_console_output_handle == _console_invalid_handle)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+// Closes the global console output handle
+extern "C" void __cdecl __dcrt_terminate_console_output()
+{
+    if (   __dcrt_lowio_console_output_handle != _console_invalid_handle
+        && __dcrt_lowio_console_output_handle != _console_uninitialized_handle)
+    {
+        CloseHandle(__dcrt_lowio_console_output_handle);
+    }
+}
+
+template <typename Func>
+static BOOL console_output_reopen_and_retry(Func const& fp) throw()
+{
+    BOOL result = fp();
+    if (!result && GetLastError() == ERROR_INVALID_HANDLE) {
+        __dcrt_terminate_console_output();
+        __dcrt_lowio_initialize_console_output();
+        result = fp();
+    }
+    return result;
+}
+
+extern "C" BOOL __cdecl __dcrt_write_console(
+    _In_  void const * lpBuffer,
+    _In_  DWORD        nNumberOfCharsToWrite,
+    _Out_ LPDWORD      lpNumberOfCharsWritten
+    )
+{
+    return console_output_reopen_and_retry(
+        [lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten]()
+        {
+            return ::WriteConsoleW(
+                __dcrt_lowio_console_output_handle,
+                lpBuffer,
+                nNumberOfCharsToWrite,
+                lpNumberOfCharsWritten,
+                nullptr);
+        });
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initconin.cpp

@@ -0,0 +1,162 @@
+//
+// initconin.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the global console input handle and the __dcrt_lowio_initialize_console_input() and
+// __dcrt_terminate_console_input() functions, which initialize and close that handle.
+// Also defines functions that can be used instead of the Console API to enable retry behavior
+// in case the cached console handle is freed.
+
+#include <corecrt_internal_lowio.h>
+
+_CRT_LINKER_FORCE_INCLUDE(__dcrt_console_input_terminator);
+
+// The global console input handle.
+static HANDLE __dcrt_lowio_console_input_handle = _console_uninitialized_handle;
+
+// Initializes the global console input handle
+static void __dcrt_lowio_initialize_console_input()
+{
+    __dcrt_lowio_console_input_handle = CreateFileW(
+        L"CONIN$",
+        GENERIC_READ | GENERIC_WRITE,
+        FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nullptr,
+        OPEN_EXISTING,
+        0,
+        nullptr);
+}
+
+extern "C" BOOL __cdecl __dcrt_lowio_ensure_console_input_initialized()
+{
+    if (__dcrt_lowio_console_input_handle == _console_uninitialized_handle)
+    {
+        __dcrt_lowio_initialize_console_input();
+    }
+
+    if (__dcrt_lowio_console_input_handle == _console_invalid_handle)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+// Closes the global console input handle
+extern "C" void __cdecl __dcrt_terminate_console_input()
+{
+    if (   __dcrt_lowio_console_input_handle != _console_invalid_handle
+        && __dcrt_lowio_console_input_handle != _console_uninitialized_handle)
+    {
+        CloseHandle(__dcrt_lowio_console_input_handle);
+    }
+}
+
+template <typename Func>
+static BOOL console_input_reopen_and_retry(Func const& fp) throw()
+{
+    BOOL result = fp();
+    if (!result && GetLastError() == ERROR_INVALID_HANDLE) {
+        __dcrt_terminate_console_input();
+        __dcrt_lowio_initialize_console_input();
+        result = fp();
+    }
+    return result;
+}
+
+extern "C" BOOL __cdecl __dcrt_read_console_input(
+    _Out_ PINPUT_RECORD lpBuffer,
+    _In_  DWORD         nLength,
+    _Out_ LPDWORD       lpNumberOfEventsRead
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpBuffer, nLength, lpNumberOfEventsRead]()
+        {
+            return ::ReadConsoleInputW(
+                __dcrt_lowio_console_input_handle,
+                lpBuffer,
+                nLength,
+                lpNumberOfEventsRead
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_read_console(
+    _Out_ LPVOID  lpBuffer,
+    _In_  DWORD   nNumberOfCharsToRead,
+    _Out_ LPDWORD lpNumberOfCharsRead
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead]()
+        {
+            return ::ReadConsoleW(
+                __dcrt_lowio_console_input_handle,
+                lpBuffer,
+                nNumberOfCharsToRead,
+                lpNumberOfCharsRead,
+                nullptr
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_get_number_of_console_input_events(
+    _Out_ LPDWORD lpcNumberOfEvents
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpcNumberOfEvents]()
+        {
+            return ::GetNumberOfConsoleInputEvents(
+                __dcrt_lowio_console_input_handle,
+                lpcNumberOfEvents
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_peek_console_input_a(
+    _Out_ PINPUT_RECORD lpBuffer,
+    _In_  DWORD         nLength,
+    _Out_ LPDWORD       lpNumberOfEventsRead
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpBuffer, nLength, lpNumberOfEventsRead]()
+        {
+            return ::PeekConsoleInputA(
+                __dcrt_lowio_console_input_handle,
+                lpBuffer,
+                nLength,
+                lpNumberOfEventsRead
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_get_input_console_mode(
+    _Out_ LPDWORD lpMode
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpMode]()
+        {
+            return ::GetConsoleMode(
+                __dcrt_lowio_console_input_handle,
+                lpMode
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_set_input_console_mode(
+    _In_ DWORD dwMode
+    )
+{
+    return console_input_reopen_and_retry(
+        [dwMode]()
+        {
+            return ::SetConsoleMode(
+                __dcrt_lowio_console_input_handle,
+                dwMode
+                );
+        });
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/pipe.cpp

@@ -0,0 +1,113 @@
+//
+// pipe.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _pipe(), which creates a pipe.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdlib.h>
+
+
+
+// Creates a pipe.  The phandles pointer must be a pointer to an array of two
+// int objects.  Upon successful return, phandles[0] is the read handle, and
+// phandles[1] is the write handle for the pipe.  On success, 0 is returned; on
+// failure, -1 is returned and errno is set.
+//
+// The psize is the amount of memory, in bytes, to ask the OS to reserve for the
+// pipe.  The textmode is the text mode that will be given to the pipe.
+extern "C" int __cdecl _pipe(int* const phandles, unsigned const psize, int const textmode)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(phandles != nullptr, EINVAL, -1);
+    phandles[0] = phandles[1] = -1;
+
+    _VALIDATE_CLEAR_OSSERR_RETURN((textmode & ~(_O_NOINHERIT | _O_BINARY | _O_TEXT)) == 0, EINVAL, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN((textmode & (_O_BINARY | _O_TEXT)) != (_O_BINARY | _O_TEXT), EINVAL, -1);
+
+
+    SECURITY_ATTRIBUTES security_attributes;
+    security_attributes.nLength = sizeof(security_attributes);
+    security_attributes.lpSecurityDescriptor = nullptr;
+    security_attributes.bInheritHandle = (textmode & _O_NOINHERIT) == 0;
+
+
+    // Create the pipe:
+    HANDLE read_handle, write_handle;
+    if (!CreatePipe(&read_handle, &write_handle, &security_attributes, psize))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    // Create the CRT read handle for the pipe:
+    int const crt_read_handle = _alloc_osfhnd();
+    if (crt_read_handle == -1)
+    {
+        errno = EMFILE;
+        _doserrno = 0;
+        CloseHandle(read_handle);
+        CloseHandle(write_handle);
+        return -1;
+    }
+
+    __try
+    {
+        _osfile(crt_read_handle)     = FOPEN | FPIPE | FTEXT;
+        _textmode(crt_read_handle)   = __crt_lowio_text_mode::ansi;
+        _tm_unicode(crt_read_handle) = false;
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(crt_read_handle);
+    }
+
+    // Create the CRT write handle for the pipe:
+    int const crt_write_handle = _alloc_osfhnd();
+    if (crt_write_handle == -1)
+    {
+        _osfile(crt_read_handle) = 0;
+        errno = EMFILE;
+        _doserrno = 0;
+        CloseHandle(read_handle);
+        CloseHandle(write_handle);
+        return -1;
+    }
+
+    __try
+    {
+        _osfile(crt_write_handle)     = FOPEN | FPIPE | FTEXT;
+        _textmode(crt_write_handle)   = __crt_lowio_text_mode::ansi;
+        _tm_unicode(crt_write_handle) = false;
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(crt_write_handle);
+    }
+
+    // Figure out which textmode the file gets:
+    int fmode = 0;
+    _ERRCHECK(_get_fmode(&fmode));
+
+    // The pipe gets binary mode if (a) binary was requested or (b) the
+    // global default fmode was changed to binary.
+    if ((textmode & _O_BINARY) || ((textmode & _O_TEXT) == 0 && fmode == _O_BINARY))
+    {
+        _osfile(crt_read_handle)  &= ~FTEXT;
+        _osfile(crt_write_handle) &= ~FTEXT;
+    }
+
+    if (textmode & _O_NOINHERIT)
+    {
+        _osfile(crt_read_handle)  |= FNOINHERIT;
+        _osfile(crt_write_handle) |= FNOINHERIT;
+    }
+
+    __acrt_lowio_set_os_handle(crt_read_handle,  reinterpret_cast<intptr_t>(read_handle));
+    __acrt_lowio_set_os_handle(crt_write_handle, reinterpret_cast<intptr_t>(write_handle));
+
+    phandles[0] = crt_read_handle;
+    phandles[1] = crt_write_handle;
+
+    return 0;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/popen.cpp

@@ -0,0 +1,488 @@
+//
+// popen.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// The _popen() and _pclose() functions, which open a pipe to a child process.
+//
+#include <corecrt_internal_stdio.h>
+#include <process.h>
+
+
+
+#define STDIN     0
+#define STDOUT    1
+
+
+
+namespace {
+
+    template <typename Character>
+    struct fdopen_mode
+    {
+        Character mode[3];
+    };
+
+    // This is the entry type for the stream pointer / process handle pairs that
+    // are stored for each outstanding popen.
+    struct process_handle_pair
+    {
+        FILE*    stream;
+        intptr_t process_handle;
+    };
+
+    struct stream_traits
+    {
+        typedef FILE* type;
+
+        static bool close(_In_ type h) throw()
+        {
+            fclose(h);
+            return true;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return nullptr;
+        }
+    };
+
+    struct process_handle_pair_traits
+    {
+        typedef process_handle_pair* type;
+
+        static bool close(_In_ type h) throw()
+        {
+            h->process_handle = 0;
+            h->stream         = nullptr;
+            return true;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return nullptr;
+        }
+    };
+
+    typedef __crt_unique_handle_t<stream_traits>              unique_stream;
+    typedef __crt_unique_handle_t<process_handle_pair_traits> unique_process_handle_pair;
+}
+
+
+
+// The global table of stream pointer / process handle pairs.  Access to this
+// global tbale is only done via the idtab function.  The table is expanded as
+// necessary (by idtab), and free table entries are reused.  (An entry is free
+// if its stream is null.)  The table is never contracted.
+static unsigned             __idtabsiz;
+static process_handle_pair* __idpairs;
+
+
+
+// Finds the entry for the given stream in the global table.  If the stream is
+// found, a pointer to it is returned; if the stream is not found, null is
+// returned.
+//
+// If the stream is null, a new entry is allocated and a pointer to it is
+// returned.  If no entries are available and expansion of the table fails,
+// null is returned.
+//
+// This function assumes the caller has acquired the lock on the table already.
+static process_handle_pair* __cdecl idtab(FILE* const stream) throw()
+{
+    // Search the table, and return the matching entry if one is found:
+    process_handle_pair* const first = __idpairs;
+    process_handle_pair* const last  = first + __idtabsiz;
+    for (process_handle_pair* it = first; it != last; ++it)
+    {
+        if (it->stream == stream)
+            return it;
+    }
+
+    // We did not find an entry in the table.  If the stream is null, then we
+    // try creating or expanding the table.  Otherwise, we return null.  Note
+    // that when the table is created or expanded, exactly one new entry is
+    // produced.  This must not be changed unless code is added to mark the
+    // extra entries as being free (e.g., by setting their stream fields to null.
+    if (stream != nullptr)
+        return nullptr;
+
+    if (__idtabsiz + 1 < __idtabsiz)
+        return nullptr;
+
+    if (__idtabsiz + 1 >= SIZE_MAX / sizeof(process_handle_pair))
+        return nullptr;
+
+    process_handle_pair* const newptr = _recalloc_crt_t(process_handle_pair, __idpairs, __idtabsiz + 1).detach();
+    if (newptr == nullptr)
+        return nullptr;
+
+    __idpairs = newptr;
+    process_handle_pair* const pairptr = newptr + __idtabsiz;
+    ++__idtabsiz;
+
+    return pairptr;
+}
+
+
+
+template <typename Character>
+static fdopen_mode<Character> __cdecl convert_popen_type_to_fdopen_mode(
+    Character const* const type
+    ) throw()
+{
+    fdopen_mode<Character> result = fdopen_mode<Character>();
+
+    Character const* type_it = type;
+
+    while (*type_it == ' ')
+        ++type_it;
+
+    _VALIDATE_RETURN(*type_it == 'w' || *type_it == 'r', EINVAL, result);
+    result.mode[0] = *type_it++;
+
+    while (*type_it == ' ')
+        ++type_it;
+
+    _VALIDATE_RETURN(*type_it == '\0' || *type_it == 't' || *type_it == 'b', EINVAL, result);
+    result.mode[1] = *type_it;
+
+    return result;
+}
+
+
+
+template <typename Character>
+static Character const* __cdecl get_comspec() throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    static Character const comspec_name[] = { 'C', 'O', 'M', 'S', 'P', 'E', 'C', '\0' };
+
+    Character* comspec_value = nullptr;
+    if (_ERRCHECK_EINVAL(stdio_traits::tdupenv_s_crt(&comspec_value, nullptr, comspec_name)) != 0)
+        return nullptr;
+
+    return comspec_value;
+}
+
+
+
+template <typename Character>
+static Character const* __cdecl get_path() throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    static Character const path_name[] = { 'P', 'A', 'T', 'H', '\0' };
+
+    Character* path_value = nullptr;
+    if (_ERRCHECK_EINVAL(stdio_traits::tdupenv_s_crt(&path_value, nullptr, path_name)) != 0)
+        return nullptr;
+
+    return path_value;
+}
+
+
+
+template <typename Character>
+static Character const* __cdecl get_executable_path(
+    Character const* const executable
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    // If we can access the given path, just use it:
+    if (stdio_traits::taccess_s(executable, 0) == 0)
+        return executable;
+
+    // Otherwise, we need to search the PATH:
+    __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, MAX_PATH));
+    if (buffer.get() == nullptr)
+        return nullptr;
+
+    __crt_unique_heap_ptr<Character const> path(get_path<Character>());
+
+    Character const* current = path.get();
+    while ((current = stdio_traits::tgetpath(current, buffer.get(), MAX_PATH - 1)) != 0)
+    {
+        if (__crt_stdio_path_requires_backslash(buffer.get()))
+        {
+            static Character const backslash[] = { '\\', '\0' };
+            _ERRCHECK(stdio_traits::tcscat_s(buffer.get(), MAX_PATH, backslash));
+        }
+
+        if (stdio_traits::tcslen(buffer.get()) + stdio_traits::tcslen(executable) >= MAX_PATH)
+            return nullptr;
+
+        _ERRCHECK(stdio_traits::tcscat_s(buffer.get(), MAX_PATH, executable));
+
+        if (stdio_traits::taccess_s(buffer.get(), 0) == 0)
+            return buffer.detach();
+    }
+
+    return nullptr;
+}
+
+
+
+template <typename Character>
+static FILE* __cdecl common_popen_nolock(
+    Character const* const command,
+    Character const* const fdopen_mode,
+    int              const std_fh,
+    int (&pipe_handles)[2]
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    HANDLE const process_handle = GetCurrentProcess();
+
+    // We only return the second pipe handle to the caller; for the first pipe,
+    // we just need to use the HANDLE:
+    __crt_unique_handle new_pipe_handle;
+    if (!DuplicateHandle(
+            process_handle,
+            reinterpret_cast<HANDLE>(_osfhnd(pipe_handles[0])),
+            process_handle,
+            new_pipe_handle.get_address_of(),
+            0,
+            TRUE,
+            DUPLICATE_SAME_ACCESS))
+    {
+        return nullptr;
+    }
+
+    _close(pipe_handles[0]);
+    pipe_handles[0] = -1;
+
+    // Associate a stream with the pipe handle to be returned to the caller:
+    unique_stream pipe_stream(stdio_traits::tfdopen(pipe_handles[1], fdopen_mode));
+    if (!pipe_stream)
+        return nullptr;
+
+    // Obtain a proces handle pair in which to store the process handle:
+    unique_process_handle_pair id_pair(idtab(nullptr));
+    if (!id_pair)
+        return nullptr;
+
+    // Determine which command processor to use:  command.com or cmd.exe:
+    static Character const default_cmd_exe[] = { 'c', 'm', 'd', '.', 'e', 'x', 'e', '\0' };
+
+    __crt_unique_heap_ptr<Character const> const comspec_variable(get_comspec<Character>());
+    Character const* const cmd_exe = comspec_variable.get() != nullptr
+        ? comspec_variable.get()
+        : default_cmd_exe;
+
+    STARTUPINFOW startup_info = { 0 };
+    startup_info.cb = sizeof(startup_info);
+
+    // The following arguments are used by the OS for duplicating the handles:
+    startup_info.dwFlags = STARTF_USESTDHANDLES;
+    startup_info.hStdInput  = std_fh == STDIN  ? new_pipe_handle.get() : reinterpret_cast<HANDLE>(_osfhnd(0));
+    startup_info.hStdOutput = std_fh == STDOUT ? new_pipe_handle.get() : reinterpret_cast<HANDLE>(_osfhnd(1));
+    startup_info.hStdError  = reinterpret_cast<HANDLE>(_osfhnd(2));
+
+    static Character const slash_c[] = { ' ', '/', 'c', ' ', '\0' };
+
+    size_t const command_line_count =
+        stdio_traits::tcslen(cmd_exe) +
+        stdio_traits::tcslen(slash_c) +
+        stdio_traits::tcslen(command) +
+        1;
+
+    __crt_unique_heap_ptr<Character> const command_line(_calloc_crt_t(Character, command_line_count));
+    if (command_line.get() == nullptr)
+        return nullptr;
+
+    _ERRCHECK(stdio_traits::tcscpy_s(command_line.get(), command_line_count, cmd_exe));
+    _ERRCHECK(stdio_traits::tcscat_s(command_line.get(), command_line_count, slash_c));
+    _ERRCHECK(stdio_traits::tcscat_s(command_line.get(), command_line_count, command));
+
+    // Find the path at which the executable is accessible:
+    Character const* const selected_cmd_exe(get_executable_path(cmd_exe));
+    if (selected_cmd_exe == nullptr)
+        return nullptr;
+
+    // If get_executable_path() returned a path other than the one we gave it,
+    // we must be sure to free the string when we return:
+    __crt_unique_heap_ptr<Character const> const owned_final_exe_path(selected_cmd_exe != cmd_exe
+        ? selected_cmd_exe
+        : nullptr);
+
+    PROCESS_INFORMATION process_info = PROCESS_INFORMATION();
+    BOOL const child_status = stdio_traits::create_process(
+        selected_cmd_exe,
+        command_line.get(),
+        nullptr,
+        nullptr,
+        TRUE,
+        0,
+        nullptr,
+        nullptr,
+        &startup_info,
+        &process_info);
+
+    if (!child_status)
+        return nullptr;
+
+    FILE* const result_stream = pipe_stream.detach();
+
+    CloseHandle(process_info.hThread);
+    id_pair.get()->process_handle = reinterpret_cast<intptr_t>(process_info.hProcess);
+    id_pair.get()->stream         = result_stream;
+    id_pair.detach();
+    return result_stream;
+}
+
+
+
+template <typename Character>
+static FILE* __cdecl common_popen(
+    Character const* const command,
+    Character const* const type
+    ) throw()
+{
+    _VALIDATE_RETURN(command != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(type    != nullptr, EINVAL, nullptr);
+
+    fdopen_mode<Character> const fdopen_mode = convert_popen_type_to_fdopen_mode(type);
+    if (fdopen_mode.mode[0] == '\0')
+        return nullptr;
+
+    // Do the _pipe().  Note that neither of the resulting handles is inheritable.
+    int pipe_mode = _O_NOINHERIT;
+    if (fdopen_mode.mode[1] == 't') { pipe_mode |= _O_TEXT;   }
+    if (fdopen_mode.mode[1] == 'b') { pipe_mode |= _O_BINARY; }
+
+    int pipe_handles[2];
+    if (_pipe(pipe_handles, 1024, pipe_mode) == -1)
+        return nullptr;
+
+    int const std_fh = fdopen_mode.mode[0] == 'w'
+        ? STDIN
+        : STDOUT;
+
+    int ordered_pipe_handles[] =
+    {
+        std_fh == STDIN ? pipe_handles[0] : pipe_handles[1],
+        std_fh == STDIN ? pipe_handles[1] : pipe_handles[0]
+    };
+
+    FILE* return_value = nullptr;
+
+    __acrt_lock(__acrt_popen_lock);
+    __try
+    {
+        errno_t const saved_errno = errno;
+
+        return_value = common_popen_nolock(
+            command,
+            fdopen_mode.mode,
+            std_fh,
+            ordered_pipe_handles);
+
+        errno = saved_errno;
+
+        if (return_value != nullptr)
+            __leave;
+
+        // If the implementation function returned successfully, everything was
+        // cleaned up except the lock.
+        int* const first = ordered_pipe_handles;
+        int* const last  = first + _countof(ordered_pipe_handles);
+        for (int* it = first; it != last; ++it)
+        {
+            if (*it != -1)
+                _close(*it);
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_popen_lock);
+    }
+
+    return return_value;
+}
+
+
+
+// Starts a child process using the given 'command' and opens a pipe to it, as
+// requested via the 'type'.  If the 'type' string contains an 'r', the calling
+// process can read the child command's standard output via the returned stream.
+// If the 'type' string contains a 'w', the calling process can write to the
+// child command's standard input via the returned stream.
+//
+// Returns a usable stream on success; returns null on failure.
+extern "C" FILE* __cdecl _popen(
+    char const* const command,
+    char const* const type
+    )
+{
+    return common_popen(command, type);
+}
+
+
+
+extern "C" FILE* __cdecl _wpopen(
+    wchar_t const* const command,
+    wchar_t const* const type
+    )
+{
+    return common_popen(command, type);
+}
+
+
+
+// Waits on the child command with which the 'stream' is associated, then closes
+// the stream and its associated pipe.  The 'stream' must have been returned from
+// a previous call to _popen().  This function looks up the process handle in the
+// global table, waits on it, then closes the stream.
+//
+// On success, the exit status of the child command is returned.  The format of
+// the return value is the same as for cwait(), except that the low order and
+// high order bytes are swapped.  If an error occurs, -1 is returned.
+extern "C" int __cdecl _pclose(FILE* const stream)
+{
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, -1);
+
+    int return_value = -1;
+
+    __acrt_lock(__acrt_popen_lock);
+    __try
+    {
+        process_handle_pair* const id_pair = idtab(stream);
+        if (id_pair == nullptr)
+        {
+            errno = EBADF;
+            __leave;
+        }
+
+        fclose(stream);
+
+        intptr_t const process_handle = id_pair->process_handle;
+
+        // Mark the id pair as free (we will close the handle in the call to _cwait):
+        id_pair->stream         = nullptr;
+        id_pair->process_handle = 0;
+
+        // Wait on the child copy of the command processor and its children:
+        errno_t const saved_errno = errno;
+        errno = 0;
+
+        int status = 0;
+        if (_cwait(&status, process_handle, _WAIT_GRANDCHILD) != -1 || errno == EINTR)
+        {
+            errno = saved_errno;
+            return_value = status;
+            __leave;
+        }
+
+        errno = saved_errno;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_popen_lock);
+    }
+
+    return return_value;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putch.cpp

@@ -0,0 +1,82 @@
+//
+// putch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _putch(), which writes a character to the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <stdlib.h>
+
+// Writes a wide character to the console.  Returns the character on success,
+// EOF on failure.
+extern "C" int __cdecl _putch(int const c)
+{
+    return __acrt_lock_and_call(__acrt_conio_lock, [&]
+    {
+        return _putch_nolock(c);
+    });
+}
+
+extern "C" int __cdecl _putch_nolock_internal(int const c, __crt_cached_ptd_host& ptd)
+{
+    __acrt_ptd*     const raw_ptd      = ptd.get_raw_ptd();
+    unsigned char*  const ch_buf       = raw_ptd->_putch_buffer;
+    unsigned short* const pch_buf_used = &raw_ptd->_putch_buffer_used;
+
+    // We can only use the character directly if we are sure that the machine
+    // is big-endian.
+    int result = c;
+
+    // Why are we using putwch to write to Console when we could have
+    // written straight away to Console? The problem we have in writing to
+    // Console is that CRT codepage is different from Console codepage and
+    // thus to write to console, we will need to convert the codepage. Here
+    // we can use unicode version of these routines and this way we will
+    // only have to do one conversion and rest will be handled by putwch.
+
+    // The usual way people call putch is character by character. Also
+    // there is no way we can convert partial MBCS to unicode character. To
+    // address this issue, we buffer all the lead bytes and combine them
+    // with trail bytes and then do the conversion.
+    if (*pch_buf_used == 1)
+    {
+        _ASSERTE(isleadbyte(ch_buf[0]) != 0);
+
+        ch_buf[1] = static_cast<unsigned char>(c);
+    }
+    else
+    {
+        ch_buf[0] = static_cast<unsigned char>(c);
+    }
+
+    if (*pch_buf_used == 0 && isleadbyte(ch_buf[0]))
+    {
+        // We still need trail byte, wait for it.
+        *pch_buf_used = 1;
+    }
+    else
+    {
+        wchar_t wchar;
+        if (_mbtowc_internal(&wchar, reinterpret_cast<char const*>(ch_buf), *pch_buf_used + 1, ptd) == -1 ||
+            _putwch_nolock(wchar) == WEOF)
+        {
+            result = EOF;
+        }
+
+        // Since we have processed full MBCS character, we should reset ch_buf_used.
+        *pch_buf_used = 0;
+    }
+
+    return result;
+}
+
+extern "C" int __cdecl _putch_nolock(int const c)
+{
+     __crt_cached_ptd_host ptd;
+     return _putch_nolock_internal(c, ptd);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putwch.cpp

@@ -0,0 +1,39 @@
+//
+// putwch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _putwch(), which writes a wide character to the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+// Writes a wide character to the console.  Returns the character on success,
+// WEOF on failure.
+extern "C" wint_t __cdecl _putwch(wchar_t const c)
+{
+    return __acrt_lock_and_call(__acrt_conio_lock, [&]
+    {
+        return _putwch_nolock(c);
+    });
+}
+
+extern "C" wint_t __cdecl _putwch_nolock(wchar_t const c)
+{
+    if (__dcrt_lowio_ensure_console_output_initialized() == FALSE)
+        return WEOF;
+
+    // Write character to console:
+    DWORD charsWritten;
+    if (__dcrt_write_console(&c, 1, &charsWritten) == FALSE)
+        return WEOF;
+
+    return c;
+}
+
+extern "C" wint_t __cdecl _putwch_nolock_internal(wchar_t const c, __crt_cached_ptd_host&)
+{
+    // Currently _putwch_nolock does not require any PTD access. Do not need to propagate __crt_cached_ptd_host&.
+    return _putwch_nolock(c);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_ctype.cpp

@@ -0,0 +1,254 @@
+//
+// _ctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the function equivalents of the character classification macros in
+// <ctype.h>.  These function definitions make use of the macros.  The functions
+// return zero if the character does not meet the requirements, and nonzero if
+// the character does meet the requirements.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+// The ctype functions (isalnum(), isupper(), etc) are very small and quick.
+// Optimizing for size has a measurable negative impact, so we optimize for speed here.
+#pragma optimize("t", on)
+
+static __forceinline int fast_check_initial_locale(int const c, int const mask) throw()
+{
+    #ifdef _DEBUG
+    return _chvalidator(c, mask);
+    #else
+    return __acrt_locale_get_ctype_array_value(__acrt_initial_locale_data._public._locale_pctype, c, mask);
+    #endif
+}
+
+static __forceinline int fast_check_current_locale(int const c, int const mask) throw()
+{
+    // Avoid PTD lookup when locale is unchanged.
+    if (!__acrt_locale_changed())
+    {
+        return fast_check_initial_locale(c, mask);
+    }
+
+    // Avoid _LocaleUpdate overhead:
+    // * Extra un-inlined function calls
+    // * Multibyte locale synchronization
+    // * Marking/unmarking current thread as using per-thread-locales.
+
+    __acrt_ptd * const ptd{__acrt_getptd()};
+    __crt_locale_data * locale_info{ptd->_locale_info};
+    __acrt_update_locale_info(ptd, &locale_info);
+
+    // Common case
+    if (c >= -1 && c <= 255)
+    {
+        return locale_info->_public._locale_pctype[c] & mask;
+    }
+
+    // Microsoft Extension: Translate int values outside of unsigned char range for DBCS locales
+    // Note that our documentation also clearly states this is undefined.
+    if (locale_info->_public._locale_mb_cur_max > 1)
+    {
+        return _isctype_l(c, mask, nullptr);
+    }
+
+    return 0;
+}
+
+static __forceinline int fast_check_given_locale(int const c, int const mask, _locale_t const locale) throw()
+{
+    // Avoid _LocaleUpdate overhead - just check whether it's nullptr.
+    if (locale == nullptr) {
+        return fast_check_current_locale(c, mask);
+    }
+
+    // Common case
+    if (c >= -1 && c <= 255)
+    {
+        return locale->locinfo->_public._locale_pctype[c] & mask;
+    }
+
+    // Microsoft Extension: Translate int values outside of unsigned char range for DBCS locales
+    // Note that our documentation also clearly states this is undefined.
+    if (locale->locinfo->_public._locale_mb_cur_max > 1)
+    {
+        return _isctype_l(c, mask, locale);
+    }
+
+    return 0;
+}
+
+
+extern "C" int (__cdecl _isalpha_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _ALPHA, locale);
+}
+
+extern "C" int (__cdecl isalpha)(int const c)
+{
+    return fast_check_current_locale(c, _ALPHA);
+}
+
+
+extern "C" int (__cdecl _isupper_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _UPPER, locale);
+}
+
+extern "C" int (__cdecl isupper)(int const c)
+{
+    return fast_check_current_locale(c, _UPPER);
+}
+
+
+extern "C" int (__cdecl _islower_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _LOWER, locale);
+}
+
+extern "C" int (__cdecl islower)(int const c)
+{
+    return fast_check_current_locale(c, _LOWER);
+}
+
+
+extern "C" int (__cdecl _isdigit_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isdigit)(int const c)
+{
+    return fast_check_current_locale(c, _DIGIT);
+}
+
+
+extern "C" int (__cdecl _isxdigit_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _HEX, locale);
+}
+
+extern "C" int (__cdecl isxdigit)(int const c)
+{
+    return fast_check_current_locale(c, _HEX);
+}
+
+
+extern "C" int (__cdecl _isspace_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _SPACE, locale);
+}
+
+extern "C" int (__cdecl isspace)(int const c)
+{
+    return fast_check_current_locale(c, _SPACE);
+}
+
+
+extern "C" int (__cdecl _ispunct_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _PUNCT, locale);
+}
+
+extern "C" int (__cdecl ispunct)(int const c)
+{
+    return fast_check_current_locale(c, _PUNCT);
+}
+
+
+extern "C" int (__cdecl _isblank_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _BLANK, locale);
+}
+
+extern "C" int (__cdecl isblank)(int const c)
+{
+    // \t is a blank character, but is not registered as _Blank on the table, because that will make it
+    //printable. Also Windows (via GetStringType()) considered all _BLANK characters to also be _PRINT characters,
+    //so does not have a way to specify blank, non-printable.
+    if (c == '\t') {
+        return _BLANK;
+    }
+
+    return fast_check_current_locale(c, _BLANK);
+}
+
+
+extern "C" int (__cdecl _isalnum_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _ALPHA | _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isalnum)(int const c)
+{
+    return fast_check_current_locale(c, _ALPHA | _DIGIT);
+}
+
+
+extern "C" int (__cdecl _isprint_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _BLANK | _PUNCT | _ALPHA | _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isprint)(int const c)
+{
+    return fast_check_current_locale(c, _BLANK | _PUNCT | _ALPHA | _DIGIT);
+}
+
+
+extern "C" int (__cdecl _isgraph_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _PUNCT | _ALPHA | _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isgraph)(int const c)
+{
+    return fast_check_current_locale(c, _PUNCT | _ALPHA | _DIGIT);
+}
+
+
+extern "C" int (__cdecl _iscntrl_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _CONTROL, locale);
+}
+
+extern "C" int (__cdecl iscntrl)(int const c)
+{
+    return fast_check_current_locale(c, _CONTROL);
+}
+
+
+extern "C" int (__cdecl __isascii)(int const c)
+{
+    return __isascii(c);
+}
+
+extern "C" int (__cdecl __toascii)(int const c)
+{
+    return __toascii(c);
+}
+
+
+extern "C" int (__cdecl _iscsymf_l)(int const c, _locale_t const locale)
+{
+    return (_isalpha_l)(c, locale) || c == '_';
+}
+
+extern "C" int (__cdecl __iscsymf)(int const c)
+{
+    return __iscsymf(c);
+}
+
+
+extern "C" int (__cdecl _iscsym_l)(int const c, _locale_t const locale)
+{
+    return (_isalnum_l)(c, locale) || c == '_';
+}
+
+extern "C" int (__cdecl __iscsym)(int const c)
+{
+    return __iscsym(static_cast<unsigned char>(c));
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_fptostr.cpp

@@ -0,0 +1,173 @@
+//
+// _fptostr.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the internal function that writes a mantissa (in a STRFLT) into a
+// buffer.  This function puts all of the digits into the buffer, handles
+// rounding based on the requested precision (digits), and updates the decimal
+// point position in the STRFLT object.  Note that this function does not change
+// the mantissa field of the STRFLT, so callers of this function may rely on it
+// being unmodified.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <fenv.h>
+#include <string.h>
+#include <stddef.h>
+
+// __acrt_has_trailing_digits::no_trailing isn't indicative of how to round if we're rounding to a point before the end of the generated digits.
+// __acrt_has_trailing_digits::no_trailing only says if there are any digits after the mantisa we got.
+// We need to ensure the remaining generated digits are all zero before choosing rounds-to-even behavior intended for exactly representable floating point numbers.
+static bool check_trailing(char const * mantissa_it, __acrt_has_trailing_digits const trailing_digits)
+{
+    if (trailing_digits == __acrt_has_trailing_digits::trailing)
+    {
+        return true;
+    }
+
+    while (*mantissa_it == '0')
+    {
+        mantissa_it++;
+    }
+
+    if (*mantissa_it != '\0')
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static bool should_round_up(
+    char const *               const mantissa_base,
+    char const *               const mantissa_it,
+    int                        const sign,
+    __acrt_has_trailing_digits const trailing_digits,
+    __acrt_rounding_mode       const rounding_mode
+)
+{
+    if (rounding_mode == __acrt_rounding_mode::legacy)
+    {
+        return *mantissa_it >= '5';
+    }
+
+    int const round_mode = fegetround();
+
+    if (round_mode == FE_TONEAREST)
+    {
+        if (*mantissa_it > '5')
+        {
+            return true;
+        }
+
+        if (*mantissa_it < '5')
+        {
+            return false;
+        }
+
+        // If there are trailing digits we are in a scenario like this .5000000001 and should round up
+        if (check_trailing(mantissa_it + 1, trailing_digits))
+        {
+            return true;
+        }
+
+        // At this point, the number is exactly representable and we are rounding 5.
+        // In this case, IEEE 754 states to round towards the nearest even number.
+        // Therefore: if the previous digit is odd, we round up (1.5 -> 2).
+        //            if the previous digit is even, we round down (2.5 -> 2).
+
+        // If there is no preceding digit, it is considered zero, so round down.
+        if (mantissa_it == mantissa_base)
+        {
+            return false;
+        }
+
+        // If the previous digit is odd, we should round up to the closest even.
+        return *(mantissa_it - 1) % 2;
+    }
+
+    if (round_mode == FE_UPWARD)
+    {
+        return check_trailing(mantissa_it, trailing_digits) && sign != '-';
+    }
+
+    if (round_mode == FE_DOWNWARD)
+    {
+        return check_trailing(mantissa_it, trailing_digits) && sign == '-';
+    }
+
+    return false;
+}
+
+extern "C" errno_t __cdecl __acrt_fp_strflt_to_string(
+    char*                        const buffer,
+    size_t                       const buffer_count,
+    int                                digits,
+    STRFLT                       const pflt,
+    __acrt_has_trailing_digits   const trailing_digits,
+    __acrt_rounding_mode         const rounding_mode,
+    __crt_cached_ptd_host&             ptd
+)
+{
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count > 0,  EINVAL);
+    buffer[0] = '\0';
+
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count > static_cast<size_t>((digits > 0 ? digits : 0) + 1), ERANGE);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, pflt != nullptr, EINVAL);
+
+    char* buffer_it           = buffer;
+    char* const mantissa_base = pflt->mantissa;
+    char* mantissa_it         = pflt->mantissa;
+
+    // The buffer will contain 'digits' decimal digits plus an optional overflow
+    // digit for the rounding.
+
+    // Initialize the first digit in the buffer to '0' (Note: not '\0') and set
+    // the pointer to the second digit of the buffer.  The first digit is used
+    // to handle overflow on rounding (e.g. 9.999... becomes 10.000...), which
+    // requires a carry into the first digit.
+    *buffer_it++ = '0';
+
+    // Copy the digits of the value into the buffer (with '0' padding) and
+    // insert the null terminator:
+    while (digits > 0)
+    {
+        *buffer_it++ = *mantissa_it ? *mantissa_it++ : '0';
+        --digits;
+    }
+
+    *buffer_it = '\0';
+
+    // Do any rounding which may be needed.  Note:  if digits < 0, we don't do
+    // any rounding because in this case, the rounding occurs in a digit which
+    // will not be output because of the precision requested.
+    if (digits >= 0 && should_round_up(mantissa_base, mantissa_it, pflt->sign, trailing_digits, rounding_mode))
+    {
+        buffer_it--;
+
+        while (*buffer_it == '9')
+        {
+            *buffer_it-- = '0';
+        }
+
+        *buffer_it += 1;
+    }
+
+    if (*buffer == '1')
+    {
+        // The rounding caused overflow into the leading digit (e.g. 9.999...
+        // became 10.000...), so increment the decimal point position by 1:
+        pflt->decpt++;
+    }
+    else
+    {
+        // Move the entire string to the left one digit to remove the unused
+        // overflow digit:
+        memmove(buffer, buffer + 1, strlen(buffer + 1) + 1);
+    }
+
+    return 0;
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_mbslen.cpp

@@ -0,0 +1,119 @@
+//
+// _mbslen.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the mbstrlen functions, which return the number of multibyte
+// characters in a multibyte string, excluding the null terminator.  This
+// function is locale-dependent.  If the string contains invalid multibyte
+// characters, -1 is returned and errno is set to EILSEQ.
+//
+// There are two variations of these functions:  mbstrnlen (note the 'n'),
+// which takes a max_size, which is the maximum number of bytes to scan
+// in the string.  These variations also validate their arguments.  The
+// variations without the 'n' (mbstrlen) stop only when the null terminator
+// is reached and do not validate their arguments.
+//
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+
+
+_Check_return_
+_Post_satisfies_((return <= _String_length_(string) && return <= max_size) || return == (size_t)-1)
+static size_t __cdecl common_mbstrlen_l(
+    char const* const string,
+    size_t      const max_size,
+    _locale_t   const locale
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    _ASSERTE(
+        locale_update.GetLocaleT()->locinfo->_public._locale_mb_cur_max == 1 ||
+        locale_update.GetLocaleT()->locinfo->_public._locale_mb_cur_max == 2);
+
+    // Handle single byte character sets:
+    if (locale_update.GetLocaleT()->locinfo->_public._locale_mb_cur_max == 1)
+    {
+        return strnlen(string, max_size);
+    }
+
+    // Verify that all of the multibyte characters are valid:
+    if (__acrt_MultiByteToWideChar(
+            locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            string,
+            static_cast<int>(max_size),
+            nullptr,
+            0
+        ) == 0)
+    {
+        // There was a bad multibyte character:
+        errno = EILSEQ;
+        return static_cast<size_t>(-1);
+    }
+
+    // Count multibyte characters:
+    size_t n    = 0; // Number of multibyte characters read
+    size_t size = 0; // Number of bytes read
+    for (char const* it = string; size < max_size && *it; ++n, ++it, ++size)
+    {
+        if (_isleadbyte_fast_internal(static_cast<unsigned char>(*it), locale_update.GetLocaleT()))
+        {
+            ++size;
+            if (size >= max_size)
+                break;
+
+            ++it;
+            if (*it == '\0')
+                break;
+        }
+    }
+
+    return size >= max_size ? max_size : n;
+}
+
+
+
+extern "C" size_t __cdecl _mbstrlen_l(
+    char const* const string,
+    _locale_t   const locale
+    )
+{
+    return common_mbstrlen_l(string, _CRT_UNBOUNDED_BUFFER_SIZE, locale);
+}
+
+extern "C" size_t __cdecl _mbstrlen(char const* const string)
+{
+    if (!__acrt_locale_changed())
+    {
+        return strlen(string);
+    }
+    else
+    {
+        return _mbstrlen_l(string, nullptr);
+    }
+}
+
+
+
+extern "C" size_t __cdecl _mbstrnlen_l(
+    char const* const string,
+    size_t      const max_size,
+    _locale_t   const locale
+    )
+{
+    _VALIDATE_RETURN(string != nullptr,   EINVAL, static_cast<size_t>(-1));
+    _VALIDATE_RETURN(max_size <= INT_MAX, EINVAL, static_cast<size_t>(-1));
+
+    return common_mbstrlen_l(string, max_size, locale);
+}
+
+extern "C" size_t __cdecl _mbstrnlen(
+    char const* const string,
+    size_t      const max_size
+    )
+{
+    return _mbstrnlen_l(string, max_size, nullptr);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_wctype.cpp

@@ -0,0 +1,171 @@
+//
+// _wctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the function equivalents of the wide character classification macros
+// in <ctype.h>.  These function definitions make use of the macros.  The
+// functions return zero if the character does not meet the requirements, and
+// nonzero if the character does meet the requirements.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+
+
+extern "C" extern __inline int (__cdecl _isleadbyte_l)(int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+    return __acrt_locale_get_ctype_array_value(locale_update.GetLocaleT()->locinfo->_public._locale_pctype, c, _LEADBYTE);
+}
+
+extern "C" extern __inline int (__cdecl isleadbyte)(int const c)
+{
+    return (_isleadbyte_l)(c, nullptr);
+}
+
+extern "C" extern __inline int (__cdecl _iswalpha_l)(wint_t const c, _locale_t)
+{
+    return iswalpha(c);
+}
+
+extern "C" extern __inline int (__cdecl iswalpha)(wint_t const c)
+{
+    return iswalpha(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswupper_l)(wint_t const c, _locale_t)
+{
+    return iswupper(c);
+}
+
+extern "C" extern __inline int (__cdecl iswupper)(wint_t const c)
+{
+    return iswupper(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswlower_l)(wint_t const c, _locale_t)
+{
+    return iswlower(c);
+}
+
+extern "C" extern __inline int (__cdecl iswlower)(wint_t const c)
+{
+    return iswlower(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswdigit_l)(wint_t const c, _locale_t)
+{
+    return iswdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl iswdigit)(wint_t const c)
+{
+    return iswdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswxdigit_l)(wint_t const c, _locale_t)
+{
+    return iswxdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl iswxdigit)(wint_t const c)
+{
+    return iswxdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswspace_l)(wint_t const c, _locale_t)
+{
+    return iswspace(c);
+}
+
+extern "C" extern __inline int (__cdecl iswspace)(wint_t const c)
+{
+    return iswspace(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswpunct_l)(wint_t const c, _locale_t)
+{
+    return iswpunct(c);
+}
+
+extern "C" extern __inline int (__cdecl iswpunct)(wint_t const c)
+{
+    return iswpunct(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswblank_l)(wint_t const c, _locale_t)
+{
+    return iswblank(c);
+}
+
+extern "C" extern __inline int (__cdecl iswblank)(wint_t const c)
+{
+    return iswblank(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswalnum_l)(wint_t const c, _locale_t)
+{
+    return iswalnum(c);
+}
+
+extern "C" extern __inline int (__cdecl iswalnum)(wint_t const c)
+{
+    return iswalnum(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswprint_l)(wint_t const c, _locale_t)
+{
+    return iswprint(c);
+}
+
+extern "C" extern __inline int (__cdecl iswprint)(wint_t const c)
+{
+    return iswprint(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswgraph_l)(wint_t const c, _locale_t)
+{
+    return iswgraph(c);
+}
+
+extern "C" extern __inline int (__cdecl iswgraph)(wint_t const c)
+{
+    return iswgraph(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswcntrl_l)(wint_t const c, _locale_t)
+{
+    return iswcntrl(c);
+}
+
+extern "C" extern __inline int (__cdecl iswcntrl)(wint_t const c)
+{
+    return iswcntrl(c);
+}
+
+extern "C" extern __inline int (__cdecl iswascii)(wint_t const c)
+{
+    return iswascii(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswcsym_l)(wint_t const c, _locale_t)
+{
+    return __iswcsym(c);
+}
+
+extern "C" extern __inline int (__cdecl __iswcsym)(wint_t const c)
+{
+    return __iswcsym(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswcsymf_l)(wint_t const c, _locale_t)
+{
+    return __iswcsymf(c);
+}
+
+extern "C" extern __inline int (__cdecl __iswcsymf)(wint_t const c)
+{
+    return __iswcsymf(c);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atof.cpp

@@ -0,0 +1,96 @@
+//
+// atof.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of the functions that convert strings to floating point numbers.
+// Note that the str- and wcs-prefixed functions are defined elsewhere.  The
+// functions defined here are provided for legacy support.
+//
+// The _atoxxx family of functions convert a string into a floating point
+// number and return either zero (success), or _UNDERFLOW or _OVERFLOW.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_strtox.h>
+
+
+
+template <typename FloatingType, typename Character>
+static int __cdecl common_atodbl_l(
+    FloatingType*    const result,
+    Character const* const string,
+    _locale_t        const locale
+    ) throw()
+{
+    _VALIDATE_RETURN(result != nullptr, EINVAL, _DOMAIN);
+
+    _LocaleUpdate locale_update(locale);
+    SLD_STATUS const status = __crt_strtox::parse_floating_point(
+        locale_update.GetLocaleT(),
+        __crt_strtox::make_c_string_character_source(string, nullptr),
+        result);
+
+    switch (status)
+    {
+    case SLD_OVERFLOW:  return _OVERFLOW;
+    case SLD_UNDERFLOW: return _UNDERFLOW;
+    default:            return 0;
+    }
+}
+
+extern "C" int __cdecl _atoflt_l(_CRT_FLOAT* const result, char const* const string, _locale_t const locale)
+{
+    return common_atodbl_l(&result->f, string, locale);
+}
+
+extern "C" int __cdecl _atoflt(_CRT_FLOAT* const result, char const* const string)
+{
+    return common_atodbl_l(&result->f, string, nullptr);
+}
+
+extern "C" int __cdecl _atodbl_l(_CRT_DOUBLE* const result, char* const string, _locale_t const locale)
+{
+    return common_atodbl_l(&result->x, string, locale);
+}
+
+extern "C" int __cdecl _atodbl(_CRT_DOUBLE* const result, char* const string)
+{
+    return common_atodbl_l(&result->x, string, nullptr);
+}
+
+
+
+template <typename Character>
+static double __cdecl common_atof_l(Character const* const string, _locale_t const locale) throw()
+{
+    _VALIDATE_RETURN(string != nullptr, EINVAL, 0.0);
+
+    _LocaleUpdate locale_update(locale);
+
+    double result{};
+    __crt_strtox::parse_floating_point(
+        locale_update.GetLocaleT(),
+        __crt_strtox::make_c_string_character_source(string, nullptr),
+        &result);
+    return result;
+}
+
+extern "C" double __cdecl _atof_l(char const* const string, _locale_t const locale)
+{
+    return common_atof_l(string, locale);
+}
+
+extern "C" double __cdecl atof(char const* const string)
+{
+    return common_atof_l(string, nullptr);
+}
+
+extern "C" double __cdecl _wtof_l(wchar_t const* const string, _locale_t const locale)
+{
+    return common_atof_l(string, locale);
+}
+
+extern "C" double __cdecl _wtof(wchar_t const* const string)
+{
+    return common_atof_l(string, nullptr);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atoldbl.cpp

@@ -0,0 +1,833 @@
+//
+// atoldbl.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _atoldbl and _atoldbl_l functions, which convert a string representation
+// of a floating point number into a 10-byte _LDOUBLE object.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_strtox.h>
+#include <float.h>
+#include <locale.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+#define PTR_12(x) ((uint8_t*)(&(x)->ld12))
+
+#define MSB_USHORT  ((uint16_t)     0x8000)
+#define MSB_ULONG   ((uint32_t) 0x80000000)
+
+#define TMAX10  5200       /* maximum temporary decimal exponent */
+#define TMIN10 -5200       /* minimum temporary decimal exponent */
+#define LD_MAX_EXP_LEN   4 /* maximum number of decimal exponent digits */
+#define LD_MAX_MAN_LEN  24 /* maximum length of mantissa (decimal)*/
+#define LD_MAX_MAN_LEN1 25 /* MAX_MAN_LEN+1 */
+
+#define LD_BIAS   0x3fff  /* exponent bias for long double */
+#define LD_BIASM1 0x3ffe  /* LD_BIAS - 1 */
+#define LD_MAXEXP 0x7fff  /* maximum biased exponent */
+
+#define D_BIAS   0x3ff  /* exponent bias for double */
+#define D_BIASM1 0x3fe  /* D_BIAS - 1 */
+#define D_MAXEXP 0x7ff  /* maximum biased exponent */
+
+// Macros for manipulation of a 12-byte long double number (an ordinary 10-byte
+// long double plus two extra bytes of mantissa).
+// byte layout:
+//
+//              +-----+--------+--------+-------+
+//              |XT(2)|MANLO(4)|MANHI(4)|EXP(2) |
+//              +-----+--------+--------+-------+
+//              |<-UL_LO->|<-UL_MED->|<-UL_HI ->|
+//                  (4)       (4)        (4)
+#define ALIGN(x) ((unsigned long _UNALIGNED*)(x))
+
+#define U_EXP_12(p)    ((uint16_t           *)(PTR_12(p) + 10))
+#define UL_MANHI_12(p) ((uint32_t _UNALIGNED*)(PTR_12(p) +  6))
+#define UL_MANLO_12(p) ((uint32_t _UNALIGNED*)(PTR_12(p) +  2))
+#define U_XT_12(p)     ((uint16_t           *)(PTR_12(p)     ))
+
+// Pointers to the four low, mid, and high order bytes of the extended mantissa
+#define UL_LO_12(p)  ((uint32_t*)(PTR_12(p)    ))
+#define UL_MED_12(p) ((uint32_t*)(PTR_12(p) + 4))
+#define UL_HI_12(p)  ((uint32_t*)(PTR_12(p) + 8))
+
+// Pointers to the uint8_t, uint16_t, and uint32_t of order i (LSB = 0; MSB = 9)
+#define UCHAR_12(p, i)   ((uint8_t *)(          PTR_12(p) + (i)))
+#define USHORT_12(p, i)  ((uint16_t*)((uint8_t*)PTR_12(p) + (i)))
+#define ULONG_12(p, i)   ((uint32_t*)((uint8_t*)PTR_12(p) + (i)))
+#define TEN_BYTE_PART(p) ((uint8_t *)(          PTR_12(p) +  2 ))
+
+// Manipulation of a 10-byte long double number
+#define U_EXP_LD(p)    ((uint16_t*)(_PTR_LD(p) + 8))
+#define UL_MANHI_LD(p) ((uint32_t*)(_PTR_LD(p) + 4))
+#define UL_MANLO_LD(p) ((uint32_t*)(_PTR_LD(p)    ))
+
+// Manipulation of a 64bit IEEE double
+#define U_SHORT4_D(p) ((uint16_t*)(p) + 3)
+#define UL_HI_D(p)    ((uint32_t*)(p) + 1)
+#define UL_LO_D(p)    ((uint32_t*)(p)    )
+
+#define PUT_INF_12(p, sign)                           \
+    *UL_HI_12 (p) = (sign) ? 0xffff8000 : 0x7fff8000; \
+    *UL_MED_12(p) = 0;                                \
+    *UL_LO_12 (p) = 0;
+
+#define PUT_ZERO_12(p) \
+    *UL_HI_12 (p) = 0; \
+    *UL_MED_12(p) = 0; \
+    *UL_LO_12 (p) = 0;
+
+#define ISZERO_12(p) \
+    ((*UL_HI_12 (p) & 0x7fffffff) == 0 && \
+      *UL_MED_12(p)               == 0 && \
+      *UL_LO_12 (p)               == 0)
+
+#define PUT_INF_LD(p, sign)                     \
+    *U_EXP_LD   (p) = (sign) ? 0xffff : 0x7fff; \
+    *UL_MANHI_LD(p) = 0x8000;                   \
+    *UL_MANLO_LD(p) = 0;
+
+#define PUT_ZERO_LD(p)   \
+    *U_EXP_LD   (p) = 0; \
+    *UL_MANHI_LD(p) = 0; \
+    *UL_MANLO_LD(p) = 0;
+
+#define ISZERO_LD(p)                    \
+    ((*U_EXP_LD   (p) & 0x7fff) == 0 && \
+      *UL_MANHI_LD(p)           == 0 && \
+      *UL_MANLO_LD(p)           == 0)
+
+
+
+static _LDBL12 const ld12_pow10_positive[] =
+{
+    /*P0001*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA0,0x02,0x40}},
+    /*P0002*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC8,0x05,0x40}},
+    /*P0003*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFA,0x08,0x40}},
+    /*P0004*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x9C,0x0C,0x40}},
+    /*P0005*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x50,0xC3,0x0F,0x40}},
+    /*P0006*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x24,0xF4,0x12,0x40}},
+    /*P0007*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x80,0x96,0x98,0x16,0x40}},
+    /*P0008*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x20,0xBC,0xBE,0x19,0x40}},
+    /*P0016*/ {{0x00,0x00, 0x00,0x00,0x00,0x04,0xBF,0xC9,0x1B,0x8E,0x34,0x40}},
+    /*P0024*/ {{0x00,0x00, 0x00,0xA1,0xED,0xCC,0xCE,0x1B,0xC2,0xD3,0x4E,0x40}},
+    /*P0032*/ {{0x20,0xF0, 0x9E,0xB5,0x70,0x2B,0xA8,0xAD,0xC5,0x9D,0x69,0x40}},
+    /*P0040*/ {{0xD0,0x5D, 0xFD,0x25,0xE5,0x1A,0x8E,0x4F,0x19,0xEB,0x83,0x40}},
+    /*P0048*/ {{0x71,0x96, 0xD7,0x95,0x43,0x0E,0x05,0x8D,0x29,0xAF,0x9E,0x40}},
+    /*P0056*/ {{0xF9,0xBF, 0xA0,0x44,0xED,0x81,0x12,0x8F,0x81,0x82,0xB9,0x40}},
+    /*P0064*/ {{0xBF,0x3C, 0xD5,0xA6,0xCF,0xFF,0x49,0x1F,0x78,0xC2,0xD3,0x40}},
+    /*P0128*/ {{0x6F,0xC6, 0xE0,0x8C,0xE9,0x80,0xC9,0x47,0xBA,0x93,0xA8,0x41}},
+    /*P0192*/ {{0xBC,0x85, 0x6B,0x55,0x27,0x39,0x8D,0xF7,0x70,0xE0,0x7C,0x42}},
+    /*P0256*/ {{0xBC,0xDD, 0x8E,0xDE,0xF9,0x9D,0xFB,0xEB,0x7E,0xAA,0x51,0x43}},
+    /*P0320*/ {{0xA1,0xE6, 0x76,0xE3,0xCC,0xF2,0x29,0x2F,0x84,0x81,0x26,0x44}},
+    /*P0384*/ {{0x28,0x10, 0x17,0xAA,0xF8,0xAE,0x10,0xE3,0xC5,0xC4,0xFA,0x44}},
+    /*P0448*/ {{0xEB,0xA7, 0xD4,0xF3,0xF7,0xEB,0xE1,0x4A,0x7A,0x95,0xCF,0x45}},
+    /*P0512*/ {{0x65,0xCC, 0xC7,0x91,0x0E,0xA6,0xAE,0xA0,0x19,0xE3,0xA3,0x46}},
+    /*P1024*/ {{0x0D,0x65, 0x17,0x0C,0x75,0x81,0x86,0x75,0x76,0xC9,0x48,0x4D}},
+    /*P1536*/ {{0x58,0x42, 0xE4,0xA7,0x93,0x39,0x3B,0x35,0xB8,0xB2,0xED,0x53}},
+    /*P2048*/ {{0x4D,0xA7, 0xE5,0x5D,0x3D,0xC5,0x5D,0x3B,0x8B,0x9E,0x92,0x5A}},
+    /*P2560*/ {{0xFF,0x5D, 0xA6,0xF0,0xA1,0x20,0xC0,0x54,0xA5,0x8C,0x37,0x61}},
+    /*P3072*/ {{0xD1,0xFD, 0x8B,0x5A,0x8B,0xD8,0x25,0x5D,0x89,0xF9,0xDB,0x67}},
+    /*P3584*/ {{0xAA,0x95, 0xF8,0xF3,0x27,0xBF,0xA2,0xC8,0x5D,0xDD,0x80,0x6E}},
+    /*P4096*/ {{0x4C,0xC9, 0x9B,0x97,0x20,0x8A,0x02,0x52,0x60,0xC4,0x25,0x75}}
+};
+
+static _LDBL12 const ld12_pow10_negative[] =
+{
+    /*N0001*/ {{0xCD,0xCC, 0xCD,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xFB,0x3F}},
+    /*N0002*/ {{0x71,0x3D, 0x0A,0xD7,0xA3,0x70,0x3D,0x0A,0xD7,0xA3,0xF8,0x3F}},
+    /*N0003*/ {{0x5A,0x64, 0x3B,0xDF,0x4F,0x8D,0x97,0x6E,0x12,0x83,0xF5,0x3F}},
+    /*N0004*/ {{0xC3,0xD3, 0x2C,0x65,0x19,0xE2,0x58,0x17,0xB7,0xD1,0xF1,0x3F}},
+    /*N0005*/ {{0xD0,0x0F, 0x23,0x84,0x47,0x1B,0x47,0xAC,0xC5,0xA7,0xEE,0x3F}},
+    /*N0006*/ {{0x40,0xA6, 0xB6,0x69,0x6C,0xAF,0x05,0xBD,0x37,0x86,0xEB,0x3F}},
+    /*N0007*/ {{0x33,0x3D, 0xBC,0x42,0x7A,0xE5,0xD5,0x94,0xBF,0xD6,0xE7,0x3F}},
+    /*N0008*/ {{0xC2,0xFD, 0xFD,0xCE,0x61,0x84,0x11,0x77,0xCC,0xAB,0xE4,0x3F}},
+    /*N0016*/ {{0x2F,0x4C, 0x5B,0xE1,0x4D,0xC4,0xBE,0x94,0x95,0xE6,0xC9,0x3F}},
+    /*N0024*/ {{0x92,0xC4, 0x53,0x3B,0x75,0x44,0xCD,0x14,0xBE,0x9A,0xAF,0x3F}},
+    /*N0032*/ {{0xDE,0x67, 0xBA,0x94,0x39,0x45,0xAD,0x1E,0xB1,0xCF,0x94,0x3F}},
+    /*N0040*/ {{0x24,0x23, 0xC6,0xE2,0xBC,0xBA,0x3B,0x31,0x61,0x8B,0x7A,0x3F}},
+    /*N0048*/ {{0x61,0x55, 0x59,0xC1,0x7E,0xB1,0x53,0x7C,0x12,0xBB,0x5F,0x3F}},
+    /*N0056*/ {{0xD7,0xEE, 0x2F,0x8D,0x06,0xBE,0x92,0x85,0x15,0xFB,0x44,0x3F}},
+    /*N0064*/ {{0x24,0x3F, 0xA5,0xE9,0x39,0xA5,0x27,0xEA,0x7F,0xA8,0x2A,0x3F}},
+    /*N0128*/ {{0x7D,0xAC, 0xA1,0xE4,0xBC,0x64,0x7C,0x46,0xD0,0xDD,0x55,0x3E}},
+    /*N0192*/ {{0x63,0x7B, 0x06,0xCC,0x23,0x54,0x77,0x83,0xFF,0x91,0x81,0x3D}},
+    /*N0256*/ {{0x91,0xFA, 0x3A,0x19,0x7A,0x63,0x25,0x43,0x31,0xC0,0xAC,0x3C}},
+    /*N0320*/ {{0x21,0x89, 0xD1,0x38,0x82,0x47,0x97,0xB8,0x00,0xFD,0xD7,0x3B}},
+    /*N0384*/ {{0xDC,0x88, 0x58,0x08,0x1B,0xB1,0xE8,0xE3,0x86,0xA6,0x03,0x3B}},
+    /*N0448*/ {{0xC6,0x84, 0x45,0x42,0x07,0xB6,0x99,0x75,0x37,0xDB,0x2E,0x3A}},
+    /*N0512*/ {{0x33,0x71, 0x1C,0xD2,0x23,0xDB,0x32,0xEE,0x49,0x90,0x5A,0x39}},
+    /*N1024*/ {{0xA6,0x87, 0xBE,0xC0,0x57,0xDA,0xA5,0x82,0xA6,0xA2,0xB5,0x32}},
+    /*N1536*/ {{0xE2,0x68, 0xB2,0x11,0xA7,0x52,0x9F,0x44,0x59,0xB7,0x10,0x2C}},
+    /*N2048*/ {{0x25,0x49, 0xE4,0x2D,0x36,0x34,0x4F,0x53,0xAE,0xCE,0x6B,0x25}},
+    /*N2560*/ {{0x8F,0x59, 0x04,0xA4,0xC0,0xDE,0xC2,0x7D,0xFB,0xE8,0xC6,0x1E}},
+    /*N3072*/ {{0x9E,0xE7, 0x88,0x5A,0x57,0x91,0x3C,0xBF,0x50,0x83,0x22,0x18}},
+    /*N3584*/ {{0x4E,0x4B, 0x65,0x62,0xFD,0x83,0x8F,0xAF,0x06,0x94,0x7D,0x11}},
+    /*N4096*/ {{0xE4,0x2D, 0xDE,0x9F,0xCE,0xD2,0xC8,0x04,0xDD,0xA6,0xD8,0x0A}}
+};
+
+
+
+// Adds x and y, storing the result in *sum.  Returns true if overflow occurred;
+// false otherwise.
+static __forceinline bool __cdecl add_uint32_carry(uint32_t const x, uint32_t const y, uint32_t* const sum) throw()
+{
+    uint32_t const r = x + y;
+
+    *sum = r;
+
+    return r < x || r < y; // carry
+}
+
+// Adds *x and *y as 12-byte integers, storing the result in *x.  Overflow is ignored.
+static __forceinline void __cdecl add_ld12(_LDBL12* const x, _LDBL12 const* const y) throw()
+{
+    if (add_uint32_carry(*UL_LO_12(x), *UL_LO_12(y), UL_LO_12(x)))
+    {
+        if (add_uint32_carry(*UL_MED_12(x), 1, UL_MED_12(x)))
+        {
+            ++*UL_HI_12(x);
+        }
+    }
+
+    if (add_uint32_carry(*UL_MED_12(x), *UL_MED_12(y), UL_MED_12(x)))
+    {
+        ++*UL_HI_12(x);
+    }
+
+    // Ignore next carry -- assume no overflow will occur
+    add_uint32_carry(*UL_HI_12(x), *UL_HI_12(y), UL_HI_12(x));
+}
+
+// Shifts *p N bits to the left.  The number is shifted as a 12-byte integer.
+template <uint32_t N>
+static __forceinline void __cdecl shl_ld12(_LDBL12* const p) throw()
+{
+    uint32_t const total_bits{sizeof(uint32_t) * CHAR_BIT};
+    uint32_t const msb_bits{N};
+    uint32_t const lsb_bits{total_bits - N};
+
+    static_assert(msb_bits <= total_bits, "shift too large");
+
+    uint32_t const lsb_mask{(1 << (lsb_bits - 1)) - 1};
+    uint32_t const msb_mask{static_cast<uint32_t>(-1) ^ lsb_mask};
+
+    uint32_t const lo_carry {(*UL_LO_12 (p) & msb_mask) >> lsb_bits};
+    uint32_t const med_carry{(*UL_MED_12(p) & msb_mask) >> lsb_bits};
+
+    *UL_LO_12 (p) = (*UL_LO_12 (p) << msb_bits);
+    *UL_MED_12(p) = (*UL_MED_12(p) << msb_bits) | lo_carry;
+    *UL_HI_12 (p) = (*UL_HI_12 (p) << msb_bits) | med_carry;
+}
+
+// Shifts *p one bit to the right.  The number is shifted as a 12-byte integer.
+static __forceinline void __cdecl shr_ld12(_LDBL12* const p) throw()
+{
+    uint32_t const c2 = *UL_HI_12 (p) & 0x1 ? MSB_ULONG : 0;
+    uint32_t const c1 = *UL_MED_12(p) & 0x1 ? MSB_ULONG : 0;
+
+    *UL_HI_12 (p) >>= 1;
+    *UL_MED_12(p) = *UL_MED_12(p) >> 1 | c2;
+    *UL_LO_12 (p) = *UL_LO_12 (p) >> 1 | c1;
+}
+
+// Multiplies *px and *py, storing the result in *px.
+static __forceinline void __cdecl multiply_ld12(_LDBL12* const px, _LDBL12 const* const py) throw()
+{
+    _LDBL12 tempman; // This is actually a 12-byte mantissa, not a 12-byte long double
+    *UL_LO_12 (&tempman) = 0;
+    *UL_MED_12(&tempman) = 0;
+    *UL_HI_12 (&tempman) = 0;
+
+    uint16_t expx = *U_EXP_12(px);
+    uint16_t expy = *U_EXP_12(py);
+
+    uint16_t const sign = (expx ^ expy) & static_cast<uint16_t>(0x8000);
+    expx &= 0x7fff;
+    expy &= 0x7fff;
+    uint16_t expsum = expx + expy;
+
+    if (expx   >= LD_MAXEXP ||
+        expy   >= LD_MAXEXP ||
+        expsum >  LD_MAXEXP + LD_BIASM1)
+    {
+        // Overflow to infinity
+        PUT_INF_12(px, sign);
+        return;
+    }
+
+    if (expsum <= LD_BIASM1 - 63)
+    {
+        // Underflow to zero
+        PUT_ZERO_12(px);
+        return;
+    }
+
+    if (expx == 0)
+    {
+        // If this is a denormal temp real then the mantissa was shifted right
+        // once to set bit 63 to zero.
+        ++expsum; // Correct for this
+
+        if (ISZERO_12(px))
+        {
+            // Put positive sign:
+            *U_EXP_12(px) = 0;
+            return;
+        }
+    }
+
+    if (expy == 0)
+    {
+        ++expsum; // Because arg2 is denormal
+        if (ISZERO_12(py))
+        {
+            PUT_ZERO_12(px);
+            return;
+        }
+    }
+
+    int roffs = 0;
+    for (int i = 0; i < 5; ++i)
+    {
+        int poffs = i << 1;
+        int qoffs = 8;
+        for (int j = 5 - i; j > 0; --j)
+        {
+            bool carry = false;
+
+            uint16_t* const p = USHORT_12(px, poffs);
+            uint16_t* const q = USHORT_12(py, qoffs);
+            uint32_t* const r = ULONG_12(&tempman, roffs);
+            uint32_t  const prod = static_cast<uint32_t>(*p) * static_cast<uint32_t>(*q);
+
+            #if defined _M_X64 || defined _M_ARM
+            // handle misalignment problems
+            if (i & 0x1) // i is odd
+            {
+                uint32_t sum = 0;
+                carry = add_uint32_carry(*ALIGN(r), prod, &sum);
+                *ALIGN(r) = sum;
+            }
+            else // i is even
+            {
+                carry = add_uint32_carry(*r, prod, r);
+            }
+            #else
+            carry = add_uint32_carry(*r, prod, r);
+            #endif
+
+            if (carry)
+            {
+                // roffs should be less than 8 in this case
+                ++*USHORT_12(&tempman, roffs + 4);
+            }
+
+            poffs += 2;
+            qoffs -= 2;
+        }
+
+        roffs += 2;
+    }
+
+    expsum -= LD_BIASM1;
+
+    // Normalize
+    while (static_cast<int16_t>(expsum) > 0 && (*UL_HI_12(&tempman) & MSB_ULONG) == 0)
+    {
+         shl_ld12<1>(&tempman);
+         expsum--;
+    }
+
+    if (static_cast<int16_t>(expsum) <= 0)
+    {
+        bool sticky = false;
+
+        expsum--;
+        while (static_cast<int16_t>(expsum) < 0)
+        {
+            if (*U_XT_12(&tempman) & 0x1)
+                sticky = true;
+
+            shr_ld12(&tempman);
+            expsum++;
+        }
+
+        if (sticky)
+        {
+            *U_XT_12(&tempman) |= 0x1;
+        }
+    }
+
+    if (*U_XT_12(&tempman) > 0x8000 || (*UL_LO_12(&tempman) & 0x1ffff) == 0x18000)
+    {
+        // Round up:
+        if (*UL_MANLO_12(&tempman) == UINT32_MAX)
+        {
+            *UL_MANLO_12(&tempman) = 0;
+
+            if (*UL_MANHI_12(&tempman) == UINT32_MAX)
+            {
+                *UL_MANHI_12(&tempman) = 0;
+
+                if (*U_EXP_12(&tempman) == UINT16_MAX)
+                {
+                    // 12-byte mantissa overflow:
+                    *U_EXP_12(&tempman) = MSB_USHORT;
+                    ++expsum;
+                }
+                else
+                {
+                    ++*U_EXP_12(&tempman);
+                }
+            }
+            else
+            {
+                ++*UL_MANHI_12(&tempman);
+            }
+        }
+        else
+        {
+            ++*UL_MANLO_12(&tempman);
+        }
+    }
+
+
+    // Check for exponent overflow:
+    if (expsum >= 0x7fff)
+    {
+        PUT_INF_12(px, sign);
+        return;
+    }
+
+    // Put result in px:
+    *U_XT_12    (px) = *USHORT_12(&tempman, 2);
+    *UL_MANLO_12(px) = *UL_MED_12(&tempman);
+    *UL_MANHI_12(px) = *UL_HI_12 (&tempman);
+    *U_EXP_12   (px) = expsum | sign;
+}
+
+// Multiplies *pld12 by 10^pow.
+static __forceinline void __cdecl multiply_ten_pow_ld12(_LDBL12* const pld12, int pow) throw()
+{
+    if (pow == 0)
+        return;
+
+    _LDBL12 const* pow_10p = ld12_pow10_positive - 8;
+    if (pow < 0)
+    {
+        pow     = -pow;
+        pow_10p = ld12_pow10_negative-8;
+    }
+
+    while (pow != 0)
+    {
+        pow_10p += 7;
+        int const last3 = pow & 0x7; // The three least significant bits of pow
+        pow >>= 3;
+
+        if (last3 == 0)
+            continue;
+
+        _LDBL12 const* py = pow_10p + last3;
+
+        _LDBL12 unround;
+
+        // Do an exact 12byte multiplication:
+        if (*U_XT_12(py) >= 0x8000)
+        {
+            // Copy number:
+            unround = *py;
+
+            // Unround adjacent byte:
+            --*UL_MANLO_12(&unround);
+
+            // Point to new operand:
+            py = &unround;
+        }
+
+        multiply_ld12(pld12, py);
+    }
+}
+
+// Multiplies *ld12 by 2^power.
+static __forceinline void __cdecl multiply_two_pow_ld12(_LDBL12* const ld12, int const power) throw()
+{
+    _LDBL12 multiplicand{};
+    *U_XT_12    (&multiplicand) = 0;
+    *UL_MANLO_12(&multiplicand) = 0;
+    *UL_MANHI_12(&multiplicand) = (1u << (sizeof(uint32_t) * CHAR_BIT - 1));
+    *U_EXP_12   (&multiplicand) = static_cast<uint16_t>(power + LD_BIAS);
+
+    multiply_ld12(ld12, &multiplicand);
+}
+
+
+// These multiply a 12-byte integer stored in an _LDBL12 by N.  N must be 10 or 16.
+template <uint32_t N>
+static __forceinline void __cdecl multiply_ld12_by(_LDBL12*) throw();
+
+template <>
+__forceinline void __cdecl multiply_ld12_by<10>(_LDBL12* const ld12) throw()
+{
+    _LDBL12 const original_ld12 = *ld12;
+    shl_ld12<2>(ld12);
+    add_ld12(ld12, &original_ld12);
+    shl_ld12<1>(ld12);
+}
+
+template <>
+__forceinline void __cdecl multiply_ld12_by<16>(_LDBL12* const ld12) throw()
+{
+    shl_ld12<4>(ld12);
+}
+
+// Converts a mantissa into an _LDBL12.  The mantissa to be converted must be
+// represented as an array of BCD digits, one per byte, read from the byte range
+// [mantissa, mantissa + mantissa_count).
+template <uint32_t Base>
+static __forceinline void __cdecl convert_mantissa_to_ld12(
+    uint8_t const* const mantissa,
+    size_t         const mantissa_count,
+    _LDBL12*       const ld12
+    ) throw()
+{
+    *UL_LO_12 (ld12) = 0;
+    *UL_MED_12(ld12) = 0;
+    *UL_HI_12 (ld12) = 0;
+
+    uint8_t const* const mantissa_last = mantissa + mantissa_count;
+    for (uint8_t const* it = mantissa; it != mantissa_last; ++it)
+    {
+        multiply_ld12_by<Base>(ld12);
+
+        // Add the new digit into the mantissa:
+        _LDBL12 digit_ld12{};
+        *UL_LO_12 (&digit_ld12) = *it;
+        *UL_MED_12(&digit_ld12) = 0;
+        *UL_HI_12 (&digit_ld12) = 0;
+        add_ld12(ld12, &digit_ld12);
+    }
+
+    uint16_t expn = LD_BIASM1 + 80;
+
+    // Normalize mantissa.  First shift word-by-word:
+    while (*UL_HI_12(ld12) == 0)
+    {
+        *UL_HI_12 (ld12) = *UL_MED_12(ld12) >> 16;
+        *UL_MED_12(ld12) = *UL_MED_12(ld12) << 16 | *UL_LO_12(ld12) >> 16;
+        *UL_LO_12 (ld12) <<= 16;
+        expn -= 16;
+    }
+
+    while ((*UL_HI_12(ld12) & MSB_USHORT) == 0)
+    {
+        shl_ld12<1>(ld12);
+        --expn;
+    }
+
+    *U_EXP_12(ld12) = expn;
+}
+
+namespace __crt_strtox {
+
+void __cdecl assemble_floating_point_zero(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    // Zero is all zero bits with an optional sign bit:
+    *U_XT_12    (&result) = 0;
+    *UL_MANLO_12(&result) = 0;
+    *UL_MANHI_12(&result) = 0;
+    *U_EXP_12   (&result) = sign_bit;
+}
+
+void __cdecl assemble_floating_point_infinity(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    // Infinity has an all-zero mantissa and an all-one exponent
+    *U_XT_12    (&result) = 0;
+    *UL_MANLO_12(&result) = 0;
+    *UL_MANHI_12(&result) = 0;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+void __cdecl assemble_floating_point_qnan(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    *U_XT_12    (&result) = 0xffff;
+    *UL_MANLO_12(&result) = 0xffffffff;
+    *UL_MANHI_12(&result) = 0xffffffff;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+void __cdecl assemble_floating_point_snan(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    *U_XT_12    (&result) = 0xffff;
+    *UL_MANLO_12(&result) = 0xffffffff;
+    *UL_MANHI_12(&result) = 0xbfffffff;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+void __cdecl assemble_floating_point_ind(_LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(MSB_USHORT)};
+
+    *U_XT_12    (&result) = 0x0000;
+    *UL_MANLO_12(&result) = 0x00000000;
+    *UL_MANHI_12(&result) = 0xc0000000;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+static SLD_STATUS __cdecl common_convert_to_ldbl12(
+    floating_point_string const& immutable_data,
+    bool                  const  is_hexadecimal,
+    _LDBL12                    & result
+    ) throw()
+{
+    floating_point_string data = immutable_data;
+
+    // Cap the number of digits to LD_MAX_MAN_LEN, and round the last digit:
+    if (data._mantissa_count > LD_MAX_MAN_LEN)
+    {
+        if (data._mantissa[LD_MAX_MAN_LEN] >= (is_hexadecimal ? 8 : 5))
+        {
+            ++data._mantissa[LD_MAX_MAN_LEN - 1];
+        }
+
+        data._mantissa_count = LD_MAX_MAN_LEN;
+    }
+
+    // The input exponent is an adjustment from the left (so 12.3456 is represented
+    // as a mantiss a of 123456 with an exponent of 2), but the legacy functions
+    // used here expect an adjustment from the right (so 12.3456 is represented
+    // with an exponent of -4).
+    int const exponent_adjustment_multiplier = is_hexadecimal ? 4 : 1;
+    data._exponent -= data._mantissa_count * exponent_adjustment_multiplier;
+
+    if (is_hexadecimal)
+    {
+        convert_mantissa_to_ld12<16>(data._mantissa, data._mantissa_count, &result);
+        multiply_two_pow_ld12(&result, data._exponent);
+    }
+    else
+    {
+        convert_mantissa_to_ld12<10>(data._mantissa, data._mantissa_count, &result);
+        multiply_ten_pow_ld12(&result, data._exponent);
+    }
+
+    if (data._is_negative)
+    {
+        *U_EXP_12(&result) |= 0x8000;
+    }
+
+    // If the combination of the mantissa and the exponent produced an infinity,
+    // we've overflowed the range of the _LDBL12.
+    if ((*U_EXP_12(&result) & LD_MAXEXP) == LD_MAXEXP)
+    {
+        return SLD_OVERFLOW;
+    }
+
+    return SLD_OK;
+}
+
+SLD_STATUS __cdecl convert_decimal_string_to_floating_type(
+    floating_point_string const& data,
+    _LDBL12                    & result
+    ) throw()
+{
+    return common_convert_to_ldbl12(data, false, result);
+}
+
+SLD_STATUS __cdecl convert_hexadecimal_string_to_floating_type(
+    floating_point_string const& data,
+    _LDBL12                    & result
+    ) throw()
+{
+    return common_convert_to_ldbl12(data, true, result);
+}
+
+} // namespace __crt_strtox
+
+using namespace __crt_strtox;
+
+
+
+static int __cdecl transform_into_return_value(SLD_STATUS const status) throw()
+{
+    switch (status)
+    {
+    case SLD_OVERFLOW:  return _OVERFLOW;
+    case SLD_UNDERFLOW: return _UNDERFLOW;
+    default:            return 0;
+    }
+}
+
+// The internal mantissa length in ints
+#define INTRNMAN_LEN 3
+
+// Internal mantissaa representation for string conversion routines
+typedef uint32_t* mantissa_t;
+
+
+// Tests whether a mantissa ends in nbit zeroes.  Returns true if all mantissa
+// bits after (and including) nbit are zero; returns false otherwise.
+static __forceinline bool __cdecl mantissa_has_zero_tail(mantissa_t const mantissa, int const nbit) throw()
+{
+    int nl = nbit / 32;
+    int const nb = 31 - nbit % 32;
+
+    //
+    //             |<---- tail to be checked --->
+    //
+    //    --  ------------------------           ----
+    //    |...    |          |  ...      |
+    //    --  ------------------------           ----
+    //    ^    ^    ^
+    //    |    |    |<----nb----->
+    //    man    nl   nbit
+    //
+
+    uint32_t const bitmask = ~(UINT32_MAX << nb);
+
+    if (mantissa[nl] & bitmask)
+        return false;
+
+    ++nl;
+
+    for (; nl < INTRNMAN_LEN; ++nl)
+    {
+        if (mantissa[nl])
+            return false;
+    }
+
+    return true;
+}
+
+
+
+// Increments a mantissa.  The nbit argument specifies the end of the part to
+// be incremented.  Returns true if overflow occurs; false otherwise.
+static __forceinline bool __cdecl increment_mantissa(mantissa_t const mantissa, int const nbit) throw()
+{
+    int nl = nbit / 32;
+    int const nb = 31 - nbit % 32;
+
+    //
+    //    |<--- part to be incremented -->|
+    //
+    //    ---------------------------------
+    //    |...          |            |   ...      |
+    //    ---------------------------------
+    //    ^          ^        ^
+    //    |          |        |<--nb-->
+    //    man          nl        nbit
+    //
+
+    uint32_t const one = static_cast<uint32_t>(1) << nb;
+
+    bool carry = add_uint32_carry(mantissa[nl], one, &mantissa[nl]);
+
+    --nl;
+
+    for (; nl >= 0 && carry; --nl)
+    {
+        carry = add_uint32_carry(mantissa[nl], 1, &mantissa[nl]);
+    }
+
+    return carry;
+}
+
+// Rounds a mantissa to the given precision.  Returns true if overflow occurs;
+// returns false otherwise.
+static __forceinline bool __cdecl round_mantissa(mantissa_t const mantissa, int const precision) throw()
+{
+    // The order of the n'th bit is n-1, since the first bit is bit 0
+    // therefore decrement precision to get the order of the last bit
+    // to be kept
+
+    int const nbit = precision - 1;
+
+    int const rndbit = nbit + 1;
+
+    int const nl = rndbit / 32;
+    int const nb = 31 - rndbit % 32;
+
+    // Get value of round bit
+    uint32_t const rndmask = static_cast<uint32_t>(1) << nb;
+
+    bool retval = false;
+    if ((mantissa[nl] & rndmask) && !mantissa_has_zero_tail(mantissa, rndbit))
+    {
+        // round up
+        retval = increment_mantissa(mantissa, nbit);
+    }
+
+    // Fill rest of mantissa with zeroes
+    mantissa[nl] &= UINT32_MAX << nb;
+    for (int i = nl + 1; i < INTRNMAN_LEN; ++i)
+    {
+        mantissa[i] = 0;
+    }
+
+    return retval;
+}
+
+static void __cdecl convert_ld12_to_ldouble(
+    _LDBL12 const* const pld12,
+    _LDOUBLE*      const result
+    ) throw()
+{
+    // This implementation is based on the fact that the _LDBL12 format is
+    // identical to the long double and has 2 extra bytes of mantissa
+    uint16_t       exponent = *U_EXP_12(pld12) & static_cast<uint16_t>(0x7fff);
+    uint16_t const sign     = *U_EXP_12(pld12) & static_cast<uint16_t>(0x8000);
+
+    uint32_t mantissa[] =
+    {
+        *UL_MANHI_12(pld12),
+        *UL_MANLO_12(pld12),
+        uint32_t ((*U_XT_12(pld12)) << 16)
+    };
+
+    if (round_mantissa(mantissa, 64))
+    {
+        // The MSB of the mantissa is explicit and should be 1
+        // since we had a carry, the mantissa is now 0.
+        mantissa[0] = MSB_ULONG;
+        ++exponent;
+    }
+
+    *UL_MANHI_LD(result) = mantissa[0];
+    *UL_MANLO_LD(result) = mantissa[1];
+    *U_EXP_LD   (result) = sign | exponent;
+}
+
+extern "C" int __cdecl _atoldbl_l(_LDOUBLE* const result, char* const string, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    _LDBL12 intermediate_result{};
+    SLD_STATUS const conversion_status = parse_floating_point(
+        locale_update.GetLocaleT(),
+        make_c_string_character_source(string, nullptr),
+        &intermediate_result);
+
+    convert_ld12_to_ldouble(&intermediate_result, result);
+    return transform_into_return_value(conversion_status);
+}
+
+extern "C" int __cdecl _atoldbl(_LDOUBLE* const result, char* const string)
+{
+    return _atoldbl_l(result, string, nullptr);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atox.cpp

@@ -0,0 +1,107 @@
+//
+// atox.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The "simple" string conversion functions:  atoi, atol, atoll, and their wide
+// string functions.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_strtox.h>
+#include <stdlib.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Narrow Strings => Various Integers (Simple Functions, wtox)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" int __cdecl atoi(char const* const string)
+{
+    // Note:  We parse as a long to avoid an extra specialization of parse_integer_from_string
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" int __cdecl _atoi_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long __cdecl atol(char const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long __cdecl _atol_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long long __cdecl atoll(char const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long long __cdecl _atoll_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, locale);
+}
+
+extern "C" __int64 __cdecl _atoi64(char const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, nullptr);
+}
+
+extern "C" __int64 __cdecl _atoi64_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, locale);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Wide Strings => Various Integers (Simple Functions, wtox)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" int __cdecl _wtoi(wchar_t const* const string)
+{
+    // Note:  We parse as a long to avoid an extra specialization of parse_integer_from_string
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" int __cdecl _wtoi_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long __cdecl _wtol(wchar_t const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long __cdecl _wtol_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long long __cdecl _wtoll(wchar_t const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long long __cdecl _wtoll_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, locale);
+}
+
+extern "C" __int64 __cdecl _wtoi64(wchar_t const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, nullptr);
+}
+
+extern "C" __int64 __cdecl _wtoi64_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, locale);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c16rtomb.cpp

@@ -0,0 +1,94 @@
+//
+// c16rtomb.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <uchar.h>
+
+using namespace __crt_mbstring;
+
+namespace
+{
+    inline void store_first_surrogate(char16_t c16, mbstate_t* ps)
+    {
+        // Store the first (high) surrogate masked and shifted, so that all that's left to do
+        // is to add the maksed second surrogate.
+        // Note: _Wchar is the only field used in mbstate_t for this function
+        const char32_t c32 = ((c16 & ~0xd800) << 10) + 0x10000;
+        ps->_Wchar = c32;
+    }
+
+    inline char32_t combine_second_surrogate(char16_t c16, mbstate_t* ps)
+    {
+        return ps->_Wchar + (c16 & ~0xdc00);
+    }
+
+    inline constexpr bool has_surrogate(mbstate_t* ps)
+    {
+        return ps->_Wchar != 0;
+    }
+
+    inline constexpr bool is_first_surrogate(char16_t c16)
+    {
+        // UTF-16 high surrogate
+        return 0xd800 <= c16 && c16 <= 0xdbff;
+    }
+
+    inline constexpr bool is_second_surrogate(char16_t c16)
+    {
+        // UTF-16 low surrogate
+        return 0xdc00 <= c16 && c16 <= 0xdfff;
+    }
+}
+
+extern "C" size_t __cdecl c16rtomb(char* s, char16_t c16, mbstate_t* ps)
+{
+    // TODO: Bug 13307590 says this is always assuming UTF-8.
+    __crt_cached_ptd_host ptd;
+    return __c16rtomb_utf8(s, c16, ps, ptd);
+}
+
+size_t __cdecl __crt_mbstring::__c16rtomb_utf8(char* s, char16_t c16, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    static mbstate_t internal_pst{};
+    if (ps == nullptr)
+    {
+        ps = &internal_pst;
+    }
+
+    if (!has_surrogate(ps))
+    {
+        if (is_second_surrogate(c16))
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        else if (is_first_surrogate(c16))
+        {
+            store_first_surrogate(c16, ps);
+            return 0;
+        }
+        else
+        {
+            return __c32rtomb_utf8(s, static_cast<char32_t>(c16), ps, ptd);
+        }
+    }
+    else
+    {
+        // We've already seen the first (high) surrogate, so we're
+        // expecting to complete this code point with its other half
+        // in the second (low) surrogate
+        if (!is_second_surrogate(c16))
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        const char32_t c32 = combine_second_surrogate(c16, ps);
+
+        mbstate_t temp{};
+        const size_t retval = __c32rtomb_utf8(s, c32, &temp, ptd);
+        return reset_and_return(retval, ps);
+    }
+}
+

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c32rtomb.cpp

@@ -0,0 +1,93 @@
+//
+// c32rtomb.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <stdint.h>
+#include <uchar.h>
+
+using namespace __crt_mbstring;
+
+extern "C" size_t __cdecl c32rtomb(char* s, char32_t c32, mbstate_t* ps)
+{
+    // TODO: Bug 13307590 says this is always assuming UTF-8.
+    __crt_cached_ptd_host ptd;
+    return __c32rtomb_utf8(s, c32, ps, ptd);
+}
+
+size_t __cdecl __crt_mbstring::__c32rtomb_utf8(char* s, char32_t c32, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    if (!s)
+    {
+        // Equivalent to c32rtomb(buf, U'\0', ps) for some internal buffer buf
+        *ps = {};
+        return 1;
+    }
+
+    if (c32 == U'\0')
+    {
+        *s = '\0';
+        *ps = {};
+        return 1;
+    }
+
+    // Fast path for ASCII
+    if ((c32 & ~0x7f) == 0)
+    {
+        *s = static_cast<char>(c32);
+        return 1;
+    }
+
+    // Figure out how many trail bytes we need
+    size_t trail_bytes;
+    uint8_t lead_byte;
+    if ((c32 & ~0x7ff) == 0)
+    {
+        trail_bytes = 1;
+        lead_byte = 0xc0;
+    }
+    else if ((c32 & ~0xffff) == 0)
+    {
+        // high/low surrogates are only valid in UTF-16 encoded data
+        if (0xd800 <= c32 && c32 <= 0xdfff)
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        trail_bytes = 2;
+        lead_byte = 0xe0;
+    }
+    else if ((c32 & ~0x001fffff) == 0)
+    {
+        // Unicode's max code point is 0x10ffff
+        if (0x10ffff < c32)
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        trail_bytes = 3;
+        lead_byte = 0xf0;
+    }
+    else
+    {
+        return return_illegal_sequence(ps, ptd);
+    }
+    _ASSERTE(1 <= trail_bytes && trail_bytes <= 3);
+
+    // Put six bits into each of the trail bytes
+    // Lowest bits are in the last UTF-8 byte.
+    // Filling back to front.
+    for (size_t i = trail_bytes; i > 0; --i)
+    {
+        s[i] = (c32 & 0x3f) | 0x80;
+        c32 >>= 6;
+    }
+
+    // The first byte needs the upper (trail_bytes + 1) bits to store the length
+    // And the lower (7 - trail_bytes) to store the upper bits of the code point
+    _ASSERTE(c32 < (1u << (7 - trail_bytes)));
+    s[0] = static_cast<uint8_t>(c32) | lead_byte;
+
+    return reset_and_return(trail_bytes + 1, ps);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cfout.cpp

@@ -0,0 +1,367 @@
+//
+// 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);
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/common_utf8.cpp

@@ -0,0 +1,27 @@
+//
+// common_utf8.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Common UTF-8 utilities
+//
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+namespace __crt_mbstring
+{
+    size_t return_illegal_sequence(mbstate_t* ps, __crt_cached_ptd_host& ptd)
+    {
+        *ps = {};
+        ptd.get_errno().set(EILSEQ);
+        return INVALID;
+    }
+
+    size_t reset_and_return(size_t retval, mbstate_t* ps)
+    {
+        *ps = {};
+        return retval;
+    }
+}

msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cvt.cpp

@@ -0,0 +1,849 @@
+//
+// cvt.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Functions for formatting floating point values with the %a, %e, %f, and %g
+// printf format specifiers.
+//
+#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>
+
+// The C String pointed to by string is shifted distance bytes to the right.
+// If distance is negative, the string is shifted to the left.
+// The C String pointed to by string and all shifting operations must be
+// contained within buffer_base or buffer_count.
+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()
+{
+    UNREFERENCED_PARAMETER(buffer_base);
+    UNREFERENCED_PARAMETER(buffer_count);
+
+    if (distance != 0)
+    {
+        memmove(string + distance, string, strlen(string) + 1);
+    }
+}
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// NaN and Infinity Formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+_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,
+    _In_range_(0,1)                                     bool            const use_capitals
+    ) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+
+    // Ensure that we have sufficient space to store at least the basic three-
+    // character INF or NAN string, plus the minus sign if required:
+    if (result_buffer_count < _countof("INF") + is_negative)
+    {
+        *result_buffer = '\0';
+        return ENOMEM;
+    }
+
+    if (is_negative)
+    {
+        *result_buffer++ = '-';
+        *result_buffer   = '\0';
+        if (result_buffer_count != _CRT_UNBOUNDED_BUFFER_SIZE)
+        {
+            --result_buffer_count;
+        }
+    }
+
+    static char const* const strings[][4] =
+    {
+        { "INF",       "INF", "inf",       "inf" }, // Infinity
+        { "NAN",       "NAN", "nan",       "nan" }, // Quiet NAN
+        { "NAN(SNAN)", "NAN", "nan(snan)", "nan" }, // Signaling NAN
+        { "NAN(IND)",  "NAN", "nan(ind)",  "nan" }, // Indeterminate
+    };
+
+    uint32_t const row    = static_cast<uint32_t>(classification) - 1;
+    uint32_t const column = use_capitals ? 0 : 2;
+
+    bool const long_string_will_fit = result_buffer_count > strlen(strings[row][column]);
+    _ERRCHECK(strcpy_s(
+        result_buffer,
+        result_buffer_count,
+        strings[row][column + !long_string_will_fit]));
+    return 0;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %e formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %e
+// printf format.  This format has the form [-]d.ddde(+/-)ddd, where there will
+// be 'precision' digits following the decimal point.  If the precision is less
+// than or equal to zero, no decimal point will appear.  The low order digit is
+// rounded.  If 'capitals' is true, then the exponent will appear as E(+/-)ddd.
+_Success_(return == 0)
+static errno_t fp_format_e_internal(
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*              const result_buffer,
+    _In_fits_precision_(precision)                         size_t             const result_buffer_count,
+    _In_                                                   int                const precision,
+    _In_                                                   bool               const capitals,
+    _In_                                                   unsigned           const min_exponent_digits,
+    _In_                                                   STRFLT             const pflt,
+    _In_                                                   bool               const g_fmt,
+    _Inout_                                                __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    // The max length if calculated like this:
+    // 3 = sign + first digit + decimal point
+    // precision = decimal digits
+    // 5 = exponent letter (e or E), exponent sign, three digits exponent
+    // 1 = extra space for rounding
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer_count > static_cast<size_t>(3 + (precision > 0 ? precision : 0) + 5 + 1), ERANGE);
+
+    // Place the output in the buffer and round.  Leave space in the buffer
+    // for the '-' sign (if any) and the decimal point (if any):
+    if (g_fmt)
+    {
+        // Shift it right one place if nec. for decimal point:
+        char* const p = result_buffer + (pflt->sign == '-');
+        shift_bytes(result_buffer, result_buffer_count, p, precision > 0);
+    }
+
+    // Now fix the number up to be in e format:
+    char* p = result_buffer;
+
+    // Put in negative sign if needed:
+    if (pflt->sign == '-')
+        *p++ = '-';
+
+    // Put in decimal point if needed.  Copy the first digit to the place left
+    // for it and put the decimal point in its place:
+    if (precision > 0)
+    {
+        *p = *(p + 1);
+        *++p = *ptd.get_locale()->locinfo->lconv->decimal_point;
+    }
+
+    // Find the end of the string, attach the exponent field and save the
+    // exponent position:
+    p = p + precision + (g_fmt ? 0 : 1);
+    _ERRCHECK(strcpy_s(
+        p,
+        result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE
+            ? result_buffer_count
+            : result_buffer_count - (p - result_buffer), "e+000"));
+    char* exponentpos = p + 2;
+
+    // Adjust exponent indicator according to capitals flag and increment
+    // pointer to point to exponent sign:
+    if (capitals)
+        *p = 'E';
+
+    ++p;
+
+    // If mantissa is zero, then the number is 0 and we are done; otherwise
+    // adjust the exponent sign (if necessary) and value:
+    if (*pflt->mantissa != '0')
+    {
+        // Check to see if exponent is negative; if so adjust exponent sign and
+        // exponent value:
+        int exp = pflt->decpt - 1;
+        if (exp < 0)
+        {
+            exp = -exp;
+            *p = '-';
+        }
+
+        ++p;
+
+        if (exp >= 100)
+        {
+            *p += static_cast<char>(exp / 100);
+            exp %= 100;
+        }
+
+        ++p;
+
+        if (exp >= 10)
+        {
+            *p += static_cast<char>(exp / 10);
+            exp %= 10;
+        }
+
+        *++p += static_cast<char>(exp);
+    }
+
+    if (min_exponent_digits == 2)
+    {
+        // If possible, reduce the exponent to two digits:
+        if (*exponentpos == '0')
+        {
+            memmove(exponentpos, exponentpos + 1, 3);
+        }
+    }
+
+    return 0;
+}
+
+_Success_(return == 0)
+static errno_t __cdecl fp_format_e(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                const result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                  const precision,
+    _In_                                                   bool                 const capitals,
+    _In_                                                   unsigned             const min_exponent_digits,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&     ptd
+    ) throw()
+{
+    // The precision passed to __acrt_fltout is the number of fractional digits.
+    // To ensure that we get enough digits, we require a total of precision + 1 digits,
+    // to account for the digit placed to the left of the decimal point when all digits are fractional.
+    _strflt strflt;
+
+    __acrt_has_trailing_digits const trailing_digits = __acrt_fltout(
+        *reinterpret_cast<_CRT_DOUBLE const*>(argument),
+        precision + 1,
+        __acrt_precision_style::scientific,
+        &strflt,
+        scratch_buffer,
+        scratch_buffer_count
+        );
+
+    errno_t const e = __acrt_fp_strflt_to_string(
+        result_buffer + (strflt.sign == '-') + (precision > 0),
+        (result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE
+            ? result_buffer_count
+            : result_buffer_count - (strflt.sign == '-') - (precision > 0)),
+        precision + 1,
+        &strflt,
+        trailing_digits,
+        rounding_mode,
+        ptd);
+
+    if (e != 0)
+    {
+        result_buffer[0] = '\0';
+        return e;
+    }
+
+    return fp_format_e_internal(result_buffer, result_buffer_count, precision, capitals, min_exponent_digits, &strflt, false, ptd);
+}
+
+static bool fe_to_nearest(double const* const argument, unsigned __int64 const mask, short const maskpos)
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+    components_type const* const components = reinterpret_cast<components_type const*>(argument);
+
+    unsigned short digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
+
+    if (digit > 8)
+    {
+        return true;
+    }
+
+    if (digit < 8)
+    {
+        return false;
+    }
+
+    unsigned __int64 const roundBitsMask = (static_cast<unsigned __int64>(1) << maskpos) - 1;
+    if (components->_mantissa & roundBitsMask)
+    {
+        return true;
+    }
+
+    //if we still have digits to the left to compare
+    if (maskpos != DBL_MANT_DIG - 5)
+    {
+        // We divide the mantisa by 16 to move the digits to the right, after that we apply the mask
+        // to get the digit at the left.
+        digit = static_cast<unsigned short>(((components->_mantissa / 16) & mask) >> maskpos);
+    }
+    else
+    {
+        digit = components->_exponent == 0 ? 0 : 1;
+    }
+
+    return digit % 2 == 1;
+}
+
+static bool should_round_up(double const* const argument, unsigned __int64 const mask, short const maskpos, __acrt_rounding_mode const rounding_mode)
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+    components_type const* const components = reinterpret_cast<components_type const*>(argument);
+
+    unsigned short const digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
+
+    if (rounding_mode == __acrt_rounding_mode::legacy)
+    {
+        return digit >= 8;
+    }
+    int const round_mode = fegetround();
+
+    if (round_mode == FE_TONEAREST)
+    {
+        return fe_to_nearest(argument, mask, maskpos);
+    }
+
+    if (round_mode == FE_UPWARD)
+    {
+        return digit != 0 && !components->_sign;
+    }
+
+    if (round_mode == FE_DOWNWARD)
+    {
+        return digit != 0 && components->_sign;
+    }
+
+    return false;
+}
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %a formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %a
+// printf format.  This format has the form [-]0xh.hhhhp(+/-)d, where there will
+// be 'precision' hex digits following the decimal point.  If the precision is
+// less than or equal to zero, no decimal point will appear.  If 'capitals' is
+// true, then the number will appear as [-]0xH.HHHHP(+/-)d.
+_Success_(return == 0)
+static errno_t __cdecl fp_format_a(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                      result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                        precision,
+    _In_                                                   bool                 const capitals,
+    _In_                                                   unsigned             const min_exponent_digits,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&     ptd
+    )
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+
+    if (precision < 0)
+    {
+        precision = 0;
+    }
+
+    result_buffer[0] = '\0';
+
+    // the constraint for the size of buffer is:
+    // 1 (sign)
+    // 4 ("0xh.")
+    // precision (decimal digits)
+    // 6 ("p+0000")
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer_count > static_cast<size_t>(1 + 4 + precision + 6), ERANGE);
+
+    // Let __acrt_fp_format_e handle the special cases like SNAN, etc.:
+    components_type const* const components = reinterpret_cast<components_type const*>(argument);
+    if (components->_exponent == floating_traits::exponent_mask)
+    {
+        errno_t const e = fp_format_e(
+            argument,
+            result_buffer,
+            result_buffer_count,
+            scratch_buffer,
+            scratch_buffer_count,
+            precision,
+            false,
+            min_exponent_digits,
+            rounding_mode,
+            ptd);
+
+        if (e != 0)
+        {
+            // An error occurred
+            result_buffer[0] = '\0';
+            return e;
+        }
+
+        // Substitute the e with p:
+        char* p = strrchr(result_buffer, 'e');
+        if (p)
+        {
+            *p = capitals ? 'P' : 'p';
+
+            // Trim the exponent (which is 0) to only one digit; skip the
+            // exponent sign and the first digit and put the terminating 0:
+            p += 3;
+            *p = 0;
+        }
+        return e;
+    }
+
+    // Sign:
+    if (components->_sign)
+    {
+        *result_buffer++ = '-';
+    }
+
+    int const hexadd = (capitals ? 'A' : 'a') - '9' - 1;
+
+    // Leading digit (and set the debias):
+    unsigned __int64 debias = floating_traits::exponent_bias;
+    if (components->_exponent == 0)
+    {
+        *result_buffer++ = '0';
+        if (components->_mantissa == 0)
+        {
+            // Zero:
+            debias = 0;
+        }
+        else
+        {
+            // Denormal:
+            debias--;
+        }
+    }
+    else
+    {
+        *result_buffer++ = '1';
+    }
+
+    // Decimal point (save the position in pos):
+    char* pos = result_buffer++;
+    if (precision == 0)
+    {
+        // If precision is 0, then we don't have to print the decimal point:
+        // we mark this putting 0 instead of the decimal point itself
+        *pos = 0;
+    }
+    else
+    {
+        *pos = *ptd.get_locale()->locinfo->lconv->decimal_point;
+    }
+
+    // Mantissa:
+    if (components->_mantissa > 0)
+    {
+        // Print 4 bits at a time, and skip the initial zeroes
+        // Prepare the mask to read the first 4 bits
+        short maskpos = (floating_traits::mantissa_bits - 1) - 4;
+
+        unsigned __int64 mask = 0xf;
+        mask <<= maskpos;
+
+        while (maskpos >= 0 && precision > 0)
+        {
+            unsigned short digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
+            digit += '0';
+            if (digit > '9')
+            {
+                digit += static_cast<unsigned short>(hexadd);
+            }
+            *result_buffer++ = static_cast<char>(digit);
+            mask >>= 4;
+            maskpos -= 4;
+            --precision;
+        }
+
+        // Round the mantissa:
+        if (maskpos >= 0)
+        {
+            if (should_round_up(argument, mask, maskpos, rounding_mode))
+            {
+                char* p = result_buffer;
+                --p;
+                // If the last digit is 'f', we need to add one to the previous
+                // digit, too; pos is the position of the decimal point
+                while (*p == 'f' || *p == 'F')
+                {
+                    *p-- = '0';
+                }
+                // If we reached the decimal point, it means we are rounding
+                // something like 0x0.fffff so this will become 0x1.00000 :
+                if (p != pos)
+                {
+                    if (*p == '9')
+                    {
+                        *p += static_cast<char>(1 + hexadd);
+                    }
+                    else
+                    {
+                        *p += 1;
+                    }
+                }
+                else // p == pos
+                {
+                    // Skip the decimal point:
+                    --p;
+
+                    // The first digit is always 0 or 1, so we don't need to
+                    // add hexadd:
+                    *p += 1;
+                }
+            }
+        }
+    }
+
+    // Add the final zeroes, if needed:
+    for (; precision > 0; --precision)
+    {
+        *result_buffer++ = '0';
+    }
+
+    // Move back the buffer pointer if there is no decimal point:
+    if (*pos == 0)
+    {
+        result_buffer = pos;
+    }
+
+    // Exponent:
+    *result_buffer++ = capitals ? 'P' : 'p';
+    __int64 exponent = components->_exponent - debias;
+    if (exponent >= 0)
+    {
+        *result_buffer++ = '+';
+    }
+    else
+    {
+        *result_buffer++ = '-';
+        exponent = -exponent;
+    }
+    // Save the position in pos and write a '0':
+    pos = result_buffer;
+    *pos = '0';
+
+    if (exponent >= 1000)
+    {
+        *result_buffer++ = '0' + static_cast<char>(exponent / 1000);
+        exponent %= 1000;
+    }
+    if (result_buffer != pos || exponent >= 100)
+    {
+        *result_buffer++ = '0' + static_cast<char>(exponent / 100);
+        exponent %= 100;
+    }
+    if (result_buffer != pos || exponent >= 10)
+    {
+        *result_buffer++ = '0' + static_cast<char>(exponent / 10);
+        exponent %= 10;
+    }
+
+    *result_buffer++ = '0' + static_cast<char>(exponent);
+
+    // Terminate the string:
+    *result_buffer = '\0';
+
+    return 0;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %f formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %f
+// printf format.  This format has the form [-]ddddd.ddddd, where there will be
+// precision digits following the decimal point.  If precision is less than or
+// equal to zero, no decimal point will appear.  The low order digit is rounded.
+_Success_(return == 0)
+static errno_t fp_format_f_internal(
+    _Pre_z_ _Maybe_unsafe_(_Inout_updates_z_, buffer_count) char*              const buffer,
+    _In_fits_precision_(precision)                          size_t             const buffer_count,
+    _In_                                                    int                const precision,
+    _In_                                                    STRFLT             const pflt,
+    _In_                                                    bool               const g_fmt,
+    _Inout_                                                 __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    int const g_magnitude = pflt->decpt - 1;
+
+    // Place the output in the user's buffer and round.  Save space for the
+    // minus sign now if it will be needed:
+    if (g_fmt && g_magnitude == precision)
+    {
+        char* const p = g_magnitude + buffer + (pflt->sign == '-');
+        p[0] = '0';
+        p[1] = '\0';
+
+        // Allows for extra place-holding '0' in the exponent == precision case
+        // of the %g format.
+    }
+
+    // Now fix up the number to be in the correct %f format:
+    char* p = buffer;
+
+    // Put in a negative sign, if necessary:
+    if (pflt->sign == '-')
+        *p++ = '-';
+
+    // Insert a leading zero for purely fractional values and position ourselves
+    // at the correct spot for inserting the decimal point:
+    if (pflt->decpt <= 0)
+    {
+        // In the specific scenario of the 0 when using g format this would cause
+        // to have an extra zero at the end
+        bool const is_zero_pflt = pflt->decpt == 0 && *pflt->mantissa == '0';
+        if (!g_fmt || !is_zero_pflt) {
+            shift_bytes(buffer, buffer_count, p, 1);
+        }
+        *p++ = '0';
+    }
+    else
+    {
+        p += pflt->decpt;
+    }
+
+    // Put a decimal point if required, and add any needed zero padding:
+    if (precision > 0)
+    {
+        shift_bytes(buffer, buffer_count, p, 1);
+        *p++ = *ptd.get_locale()->locinfo->lconv->decimal_point;
+
+        // If the value is less than 1 then we may need to put zeroes out in
+        // front of the first non-zero digit of the mantissa:
+        if (pflt->decpt < 0)
+        {
+            int const computed_precision = (g_fmt || -pflt->decpt < precision)
+                ? -pflt->decpt
+                : precision;
+
+            shift_bytes(buffer, buffer_count, p, computed_precision);
+            memset(p, '0', computed_precision);
+        }
+    }
+
+    return 0;
+}
+
+_Success_(return == 0)
+static errno_t __cdecl fp_format_f(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                const result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                  const precision,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&     ptd
+    ) throw()
+{
+    _strflt strflt{};
+    __acrt_has_trailing_digits const trailing_digits = __acrt_fltout(
+        *reinterpret_cast<_CRT_DOUBLE const*>(argument),
+        precision,
+        __acrt_precision_style::fixed,
+        &strflt,
+        scratch_buffer,
+        scratch_buffer_count
+        );
+
+    errno_t const e = __acrt_fp_strflt_to_string(
+        result_buffer + (strflt.sign == '-'),
+        (result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE ? result_buffer_count : result_buffer_count - (strflt.sign == '-')),
+        precision + strflt.decpt,
+        &strflt,
+        trailing_digits,
+        rounding_mode,
+        ptd);
+
+    if (e != 0)
+    {
+        result_buffer[0] = '\0';
+        return e;
+    }
+
+    return fp_format_f_internal(result_buffer, result_buffer_count, precision, &strflt, false, ptd);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %g formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %g
+// printf format.  The form used depends on the value converted.  The printf %e
+// form will be used if the magnitude of the value is less than -4 or is greater
+// than 'precision', otherwise %f will be used.  The 'precision' always specifies
+// the number of digits following the decimal point.  The low order digit is
+// appropriately rounded.
+_Success_(return == 0)
+static errno_t __cdecl fp_format_g(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                const result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                  const precision,
+    _In_                                                   bool                 const capitals,
+    _In_                                                   unsigned             const min_exponent_digits,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    _strflt strflt{};
+
+    // Generate digits as though we will use %f formatting, then decide based on the result
+    // whether to use %f or %e formatting. %f always requires more generated digits than %e,
+    // so generating them all now will avoid generating more later (generation isn't resumable).
+    __acrt_has_trailing_digits const trailing_digits = __acrt_fltout(
+        *reinterpret_cast<_CRT_DOUBLE const*>(argument),
+        precision,
+        __acrt_precision_style::fixed,
+        &strflt,
+        scratch_buffer,
+        scratch_buffer_count
+        );
+
+    size_t const minus_sign_length = strflt.sign == '-' ? 1 : 0;
+
+    int g_magnitude = strflt.decpt - 1;
+    char* p = result_buffer + minus_sign_length;
+
+    size_t const buffer_count_for_fptostr = result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE
+        ? result_buffer_count
+        : result_buffer_count - minus_sign_length;
+
+    errno_t const fptostr_result = __acrt_fp_strflt_to_string(p, buffer_count_for_fptostr, precision, &strflt, trailing_digits, rounding_mode, ptd);
+    if (fptostr_result != 0)
+    {
+        result_buffer[0] = '\0';
+        return fptostr_result;
+    }
+
+    bool const g_round_expansion = g_magnitude < (strflt.decpt - 1);
+
+    // Compute the magnitude of value:
+    g_magnitude = strflt.decpt - 1;
+
+    // Convert value to the C Language g format:
+    if (g_magnitude < -4 || g_magnitude >= precision) // Use e format
+    {
+        // We can ignore the round expansion flag here:  the extra digit will be
+        // overwritten by "e+xxx".
+        return fp_format_e_internal(result_buffer, result_buffer_count, precision, capitals, min_exponent_digits, &strflt, true, ptd);
+    }
+    else // Use f format
+    {
+        if (g_round_expansion)
+        {
+            // Throw away extra final digit from expansion:
+            while (*p++)
+            {
+                // Iterate to the end of the string
+            }
+
+            *(p - 2) = '\0';
+        }
+
+        return fp_format_f_internal(result_buffer, result_buffer_count, precision, &strflt, true, ptd);
+    }
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Format Dispatch
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The main floating point formatting dispatch function.  This function just
+// looks at the 'format' character, calls the right formatting function, and
+// returns the result.  The other parameters are passed on to the selected
+// formatting function and are used as described in the documentation for
+// those functions.
+extern "C" 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
+    )
+{
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer != nullptr,  EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer_count > 0,   EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, scratch_buffer != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, scratch_buffer_count > 0,  EINVAL);
+
+    bool const use_capitals = format == 'A' || format == 'E' || format == 'F' || format == 'G';
+
+    // Detect special cases (NaNs and infinities) and handle them specially.
+    // Note that the underlying __acrt_fltout function will also handle these
+    // special cases, but it does so using the legacy strings (e.g. 1.#INF).
+    // Our special handling here uses the C99 strings (e.g. INF).
+    if ((options & _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
+    {
+        __acrt_fp_class const classification = __acrt_fp_classify(*value);
+        if (classification != __acrt_fp_class::finite)
+        {
+            return fp_format_nan_or_infinity(
+                classification,
+                __acrt_fp_is_negative(*value),
+                result_buffer,
+                result_buffer_count,
+                use_capitals);
+        }
+    }
+
+    unsigned const min_exponent_digits = (options & _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS) != 0 ? 3 : 2;
+    if ((options & _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING) == 0) {
+        rounding_mode = __acrt_rounding_mode::legacy;
+    }
+
+    switch (format)
+    {
+    case 'a':
+    case 'A':
+        return fp_format_a(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
+
+    case 'e':
+    case 'E':
+        return fp_format_e(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
+
+    case 'f':
+    case 'F':
+        return fp_format_f(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, rounding_mode, ptd);
+
+    default:
+        _ASSERTE(("Unsupported format specifier", 0));
+    case 'g':
+    case 'G':
+        return fp_format_g(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
+    }
+}