Add files using upload-large-folder tool

.gitattributes

@@ -230,3 +230,4 @@ miniMSVC/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/um/x64/nanosrv.lib filter=lf
 miniMSVC/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/um/x64/OneCoreUAP_apiset.Lib filter=lfs diff=lfs merge=lfs -text
 miniMSVC/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/um/x64/OneCoreUAP_downlevel.Lib filter=lfs diff=lfs merge=lfs -text
 miniMSVC/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/um/x64/OneCore.Lib filter=lfs diff=lfs merge=lfs -text
+miniMSVC/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/um/x64/OneCoreUAP.Lib filter=lfs diff=lfs merge=lfs -text

miniMSVC/Windows Kits/10/Lib/10.0.26100.0/um/x64/OneCoreUAP.Lib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:161f77fcd9be3c3543d98be9d97f150da2cd766aec2b288c05556f28a4117a09
+size 3053074

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/SetEnvironmentVariableA.cpp

@@ -0,0 +1,40 @@
+//
+// SetEnvironmentVariableA.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of __acrt_SetEnvironmentVariableA.
+//
+
+#include <corecrt_internal_win32_buffer.h>
+
+BOOL __cdecl __acrt_SetEnvironmentVariableA(
+    LPCSTR const lpName,
+    LPCSTR const lpValue
+    )
+{
+    __crt_internal_win32_buffer<wchar_t> wide_name;
+    __crt_internal_win32_buffer<wchar_t> wide_value;
+
+    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(
+        lpName,
+        wide_name,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt1 != 0) {
+        return FALSE;
+    }
+
+    errno_t const cvt2 = __acrt_mbs_to_wcs_cp(
+        lpValue,
+        wide_value,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt2 != 0) {
+        return FALSE;
+    }
+
+    return ::SetEnvironmentVariableW(wide_name.data(), wide_value.data());
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/shared_initialization.cpp

@@ -0,0 +1,67 @@
+//
+// shared_initialization.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Shared initialization logic used by both the AppCRT and the DesktopCRT.
+//
+#include <corecrt_internal.h>
+
+extern "C" bool __cdecl __acrt_execute_initializers(
+    __acrt_initializer const* const first,
+    __acrt_initializer const* const last
+    )
+{
+    if (first == last)
+        return true;
+
+    // Execute the initializers in [first, last), in order:
+    __acrt_initializer const* it = first;
+    for (; it != last; ++it)
+    {
+        if (it->_initialize == nullptr)
+            continue;
+
+        if (!(it->_initialize)())
+            break;
+    }
+
+    // If we reached the end, all initializers completed successfully:
+    if (it == last)
+        return true;
+
+    // Otherwise, the initializer pointed to by it failed.  We need to roll back
+    // the initialization by executing the uninitializers corresponding to each
+    // of the initializers that completed successfully:
+    for (; it != first; --it)
+    {
+        // During initialization roll back, we do not execute uninitializers
+        // that have no corresponding initializer:
+        if ((it - 1)->_initialize == nullptr || (it - 1)->_uninitialize == nullptr)
+            continue;
+
+        (it - 1)->_uninitialize(false);
+    }
+
+    return false;
+}
+
+extern "C" bool __cdecl __acrt_execute_uninitializers(
+    __acrt_initializer const* const first,
+    __acrt_initializer const* const last
+    )
+{
+    if (first == last)
+        return true;
+
+    // Execute the uninitializers in [first, last), in reverse order:
+    for (__acrt_initializer const* it = last; it != first; --it)
+    {
+        if ((it - 1)->_uninitialize == nullptr)
+            continue;
+
+        (it - 1)->_uninitialize(false);
+    }
+
+    return true;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/win_policies.cpp

@@ -0,0 +1,182 @@
+//
+// win_policies.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Wrapper functions that determine what policies should apply for the process in question.
+//
+
+#include <corecrt_internal.h>
+
+template<typename TPolicy>
+static typename TPolicy::policy_type __cdecl get_win_policy(typename TPolicy::appmodel_policy_type defaultValue)
+{
+    TPolicy::appmodel_policy_type appmodelPolicy = defaultValue;
+
+    // Secure processes cannot load the appmodel DLL, so only attempt loading
+    // policy information if this is not a secure process.
+    if (!__acrt_is_secure_process())
+    {
+        TPolicy::appmodel_get_policy(&appmodelPolicy);
+    }
+
+    return TPolicy::appmodel_policy_to_policy_type(appmodelPolicy);
+}
+
+template<typename TPolicy>
+static typename TPolicy::policy_type __cdecl get_cached_win_policy(typename TPolicy::appmodel_policy_type defaultValue)
+{
+    static long state_cache = 0;
+    if (long const cached_state = __crt_interlocked_read(&state_cache))
+    {
+        return static_cast<TPolicy::policy_type>(cached_state);
+    }
+
+    TPolicy::appmodel_policy_type appmodelPolicy = defaultValue;
+
+    // Secure processes cannot load the appmodel DLL, so only attempt loading
+    // policy information if this is not a secure process.
+    if (!__acrt_is_secure_process())
+    {
+        TPolicy::appmodel_get_policy(&appmodelPolicy);
+    }
+
+    TPolicy::policy_type const policyValue = TPolicy::appmodel_policy_to_policy_type(appmodelPolicy);
+
+    long const cached_state = _InterlockedExchange(&state_cache, static_cast<long>(policyValue));
+    if (cached_state)
+    {
+        _ASSERTE(cached_state == static_cast<long>(policyValue));
+    }
+
+    return policyValue;
+}
+
+// Determines whether ExitProcess() or TerminateProcess() should be used to end the process
+extern "C" process_end_policy __cdecl __acrt_get_process_end_policy()
+{
+    struct process_end_policy_properties
+    {
+        typedef process_end_policy policy_type;
+        typedef AppPolicyProcessTerminationMethod appmodel_policy_type;
+
+        static policy_type appmodel_policy_to_policy_type(appmodel_policy_type const appmodelPolicy) throw()
+        {
+            if (appmodelPolicy == AppPolicyProcessTerminationMethod_TerminateProcess)
+            {
+                return process_end_policy_terminate_process;
+            }
+            else
+            {
+                return process_end_policy_exit_process;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetProcessTerminationMethodInternal(appmodelPolicy);
+        }
+    };
+
+    return get_win_policy<process_end_policy_properties>(AppPolicyProcessTerminationMethod_ExitProcess);
+}
+
+// Determines whether RoInitialize() should be called when creating a thread
+extern "C" begin_thread_init_policy __cdecl __acrt_get_begin_thread_init_policy()
+{
+    struct begin_thread_init_policy_properties
+    {
+        typedef begin_thread_init_policy policy_type;
+        typedef AppPolicyThreadInitializationType appmodel_policy_type;
+
+        static_assert(begin_thread_init_policy_unknown == 0, "Default value for cache must be 0");
+
+        static policy_type appmodel_policy_to_policy_type(long const appmodelPolicy) throw()
+        {
+            if (appmodelPolicy == AppPolicyThreadInitializationType_InitializeWinRT)
+            {
+                return begin_thread_init_policy_ro_initialize;
+            }
+            else
+            {
+                return begin_thread_init_policy_none;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetThreadInitializationTypeInternal(appmodelPolicy);
+        }
+    };
+
+    return get_cached_win_policy<begin_thread_init_policy_properties>(AppPolicyThreadInitializationType_None);
+}
+
+// Determines whether we should attempt to display assert dialog
+extern "C" developer_information_policy __cdecl __acrt_get_developer_information_policy()
+{
+    struct developer_information_policy_properties
+    {
+        typedef developer_information_policy policy_type;
+        typedef AppPolicyShowDeveloperDiagnostic appmodel_policy_type;
+
+        static_assert(developer_information_policy_unknown == 0, "Default value for cache must be 0");
+
+        static policy_type appmodel_policy_to_policy_type(long const appmodelPolicy) throw()
+        {
+            if (appmodelPolicy == AppPolicyShowDeveloperDiagnostic_ShowUI)
+            {
+                return developer_information_policy_ui;
+            }
+            else
+            {
+                return developer_information_policy_none;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetShowDeveloperDiagnosticInternal(appmodelPolicy);
+        }
+    };
+
+    return get_cached_win_policy<developer_information_policy_properties>(AppPolicyShowDeveloperDiagnostic_ShowUI);
+}
+
+// Determines what type of windowing model technology is available
+extern "C" windowing_model_policy __cdecl __acrt_get_windowing_model_policy()
+{
+    struct windowing_model_policy_properties
+    {
+        typedef windowing_model_policy policy_type;
+        typedef AppPolicyWindowingModel appmodel_policy_type;
+
+        static_assert(windowing_model_policy_unknown == 0, "Default value for cache must be 0");
+
+        static policy_type appmodel_policy_to_policy_type(long const appmodelPolicy) throw()
+        {
+            switch (appmodelPolicy)
+            {
+                case AppPolicyWindowingModel_ClassicDesktop:
+                    return windowing_model_policy_hwnd;
+
+                case AppPolicyWindowingModel_Universal:
+                    return windowing_model_policy_corewindow;
+
+                case AppPolicyWindowingModel_ClassicPhone:
+                    return windowing_model_policy_legacyphone;
+
+                case AppPolicyWindowingModel_None:
+                default:
+                    return windowing_model_policy_none;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetWindowingModelInternal(appmodelPolicy);
+        }
+    };
+
+    return get_cached_win_policy<windowing_model_policy_properties>(AppPolicyWindowingModel_ClassicDesktop);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/winapi_thunks.cpp

@@ -0,0 +1,982 @@
+//
+// winapi_thunks.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of wrappers for Windows API functions that cannot be called
+// directly because they are not available on all supported operating systems.
+//
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+#include <ntsecapi.h>
+#include <corecrt_internal.h>
+#include <appmodel.h>
+#include <roapi.h>
+
+ WINBASEAPI
+ _Success_(return > 0 && return < BufferLength)
+ DWORD
+ WINAPI
+ GetTempPath2W(
+     _In_ DWORD BufferLength,
+     _Out_writes_to_opt_(BufferLength,return + 1) LPWSTR Buffer
+     );
+
+// The XState APIs are declared by the Windows headers only when building for
+// x86 and x64.  We declare them here unconditionally so that we can share the
+// same code for all architectures (we simply avoid use of these functions on
+// other architectures).
+extern "C" WINBASEAPI DWORD64 WINAPI GetEnabledXStateFeatures();
+
+_Must_inspect_result_
+extern "C" WINBASEAPI BOOL WINAPI GetXStateFeaturesMask(
+    _In_  PCONTEXT context,
+    _Out_ PDWORD64 feature_mask
+    );
+
+_Success_(return != NULL)
+extern "C" WINBASEAPI PVOID WINAPI LocateXStateFeature(
+    _In_      PCONTEXT context,
+    _In_      DWORD    feature_id,
+    _Out_opt_ PDWORD   length
+    );
+
+_Must_inspect_result_
+extern "C" WINBASEAPI BOOL WINAPI GetFileInformationByName(
+    _In_ PCWSTR FileName,
+    _In_ DWORD /* FILE_INFO_BY_NAME_CLASS */ FileInformationClass,
+    _Out_writes_bytes_(FileInfoBufferSize) PVOID FileInfoBuffer,
+    _In_ ULONG FileInfoBufferSize
+    );
+
+#define _ACRT_APPLY_TO_LATE_BOUND_MODULES_0                                                              \
+    _APPLY(api_ms_win_core_datetime_l1_1_1,              "api-ms-win-core-datetime-l1-1-1"             ) \
+    _APPLY(api_ms_win_core_fibers_l1_1_2,                "api-ms-win-core-fibers-l1-1-2"               ) \
+    _APPLY(api_ms_win_core_file_l1_2_4,                  "api-ms-win-core-file-l1-2-4"                 ) \
+    _APPLY(api_ms_win_core_file_l1_2_2,                  "api-ms-win-core-file-l1-2-2"                 ) \
+    _APPLY(api_ms_win_core_file_l2_1_4,                  "api-ms-win-core-file-l2-1-4"                 ) \
+    _APPLY(api_ms_win_core_localization_l1_2_1,          "api-ms-win-core-localization-l1-2-1"         ) \
+    _APPLY(api_ms_win_core_localization_obsolete_l1_2_0, "api-ms-win-core-localization-obsolete-l1-2-0") \
+    _APPLY(api_ms_win_core_processthreads_l1_1_2,        "api-ms-win-core-processthreads-l1-1-2"       ) \
+    _APPLY(api_ms_win_core_string_l1_1_0,                "api-ms-win-core-string-l1-1-0"               ) \
+    _APPLY(api_ms_win_core_synch_l1_2_0,                 "api-ms-win-core-synch-l1-2-0"                ) \
+    _APPLY(api_ms_win_core_sysinfo_l1_2_1,               "api-ms-win-core-sysinfo-l1-2-1"              ) \
+    _APPLY(api_ms_win_core_winrt_l1_1_0,                 "api-ms-win-core-winrt-l1-1-0"                ) \
+    _APPLY(api_ms_win_core_xstate_l2_1_0,                "api-ms-win-core-xstate-l2-1-0"               ) \
+    _APPLY(api_ms_win_rtcore_ntuser_window_l1_1_0,       "api-ms-win-rtcore-ntuser-window-l1-1-0"      ) \
+    _APPLY(api_ms_win_security_systemfunctions_l1_1_0,   "api-ms-win-security-systemfunctions-l1-1-0"  ) \
+    _APPLY(ext_ms_win_ntuser_dialogbox_l1_1_0,           "ext-ms-win-ntuser-dialogbox-l1-1-0"          ) \
+    _APPLY(ext_ms_win_ntuser_windowstation_l1_1_0,       "ext-ms-win-ntuser-windowstation-l1-1-0"      ) \
+    _APPLY(advapi32,                                     "advapi32"                                    ) \
+    _APPLY(kernel32,                                     "kernel32"                                    ) \
+    _APPLY(kernelbase,                                   "kernelbase"                                  ) \
+    _APPLY(ntdll,                                        "ntdll"                                       ) \
+    _APPLY(api_ms_win_appmodel_runtime_l1_1_2,           "api-ms-win-appmodel-runtime-l1-1-2"          ) \
+    _APPLY(user32,                                       "user32"                                      )
+
+#define _ACRT_APPLY_TO_LATE_BOUND_MODULES  \
+    _ACRT_APPLY_TO_LATE_BOUND_MODULES_0 \
+
+#define _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS_0                                                                                                           \
+    _APPLY(AreFileApisANSI,                             ({ /* api_ms_win_core_file_l1_2_2, */            kernel32                                   })) \
+    _APPLY(CompareStringEx,                             ({ api_ms_win_core_string_l1_1_0,                kernel32                                   })) \
+    _APPLY(EnumSystemLocalesEx,                         ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(FlsGetValue2,                                ({ api_ms_win_core_fibers_l1_1_2,                kernelbase                                 })) \
+    _APPLY(GetActiveWindow,                             ({ api_ms_win_rtcore_ntuser_window_l1_1_0,       user32                                     })) \
+    _APPLY(GetDateFormatEx,                             ({ api_ms_win_core_datetime_l1_1_1,              kernel32                                   })) \
+    _APPLY(GetTempPath2W,                               ({ api_ms_win_core_file_l1_2_4,                  kernelbase                                 })) \
+    _APPLY(GetFileInformationByName,                    ({ api_ms_win_core_file_l2_1_4,                  kernelbase                                 })) \
+    _APPLY(GetEnabledXStateFeatures,                    ({ api_ms_win_core_xstate_l2_1_0,                kernel32                                   })) \
+    _APPLY(GetLastActivePopup,                          ({ ext_ms_win_ntuser_dialogbox_l1_1_0,           user32                                     })) \
+    _APPLY(GetLocaleInfoEx,                             ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(GetProcessWindowStation,                     ({ ext_ms_win_ntuser_windowstation_l1_1_0,       user32                                     })) \
+    _APPLY(GetSystemTimePreciseAsFileTime,              ({ api_ms_win_core_sysinfo_l1_2_1                                                           })) \
+    _APPLY(GetTimeFormatEx,                             ({ api_ms_win_core_datetime_l1_1_1,              kernel32                                   })) \
+    _APPLY(GetUserDefaultLocaleName,                    ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(GetUserObjectInformationW,                   ({ ext_ms_win_ntuser_windowstation_l1_1_0,       user32                                     })) \
+    _APPLY(GetXStateFeaturesMask,                       ({ api_ms_win_core_xstate_l2_1_0,                kernel32                                   })) \
+    _APPLY(IsValidLocaleName,                           ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(LCMapStringEx,                               ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(LCIDToLocaleName,                            ({ api_ms_win_core_localization_obsolete_l1_2_0, kernel32                                   })) \
+    _APPLY(LocaleNameToLCID,                            ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(LocateXStateFeature,                         ({ api_ms_win_core_xstate_l2_1_0,                kernel32                                   })) \
+    _APPLY(MessageBoxA,                                 ({ ext_ms_win_ntuser_dialogbox_l1_1_0,           user32                                     })) \
+    _APPLY(MessageBoxW,                                 ({ ext_ms_win_ntuser_dialogbox_l1_1_0,           user32                                     })) \
+    _APPLY(RoInitialize,                                ({ api_ms_win_core_winrt_l1_1_0                                                             })) \
+    _APPLY(RoUninitialize,                              ({ api_ms_win_core_winrt_l1_1_0                                                             })) \
+    _APPLY(AppPolicyGetProcessTerminationMethod,        ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(AppPolicyGetThreadInitializationType,        ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(AppPolicyGetShowDeveloperDiagnostic,         ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(AppPolicyGetWindowingModel,                  ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(SetThreadStackGuarantee,                     ({ api_ms_win_core_processthreads_l1_1_2,        kernel32                                   })) \
+    _APPLY(SystemFunction036,                           ({ api_ms_win_security_systemfunctions_l1_1_0,   advapi32                                   }))
+
+#define _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS \
+    _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS_0 \
+
+namespace
+{
+    // Generate enumerators for each of the modules:
+    enum module_id : unsigned
+    {
+        #define _APPLY(_SYMBOL, _NAME) _SYMBOL,
+        _ACRT_APPLY_TO_LATE_BOUND_MODULES
+        #undef _APPLY
+
+        module_id_count
+    };
+
+    // Generate a table of module names that can be indexed by the module_id
+    // enumerators:
+    static wchar_t const* const module_names[module_id_count] =
+    {
+        #define _APPLY(_SYMBOL, _NAME) _CRT_WIDE(_NAME),
+        _ACRT_APPLY_TO_LATE_BOUND_MODULES
+        #undef _APPLY
+    };
+
+    // Generate enumerators for each of the functions:
+    enum function_id : unsigned
+    {
+        #define _APPLY(_FUNCTION, _MODULES) _CRT_CONCATENATE(_FUNCTION, _id),
+        _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+        #undef _APPLY
+
+        function_id_count
+    };
+
+    // Generate a typedef for each function of the form function_pft.
+    #define _APPLY(_FUNCTION, _MODULES) \
+        using _CRT_CONCATENATE(_FUNCTION, _pft) = decltype(_FUNCTION)*;
+    _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+    #undef _APPLY
+}
+
+// This table stores the module handles that we have obtained via LoadLibrary.
+// If a handle is null, we have not yet attempted to load that module.  If a
+// handle is -1 (INVALID_HANDLE_VALUE), we have attempted to load the module
+// but the attempt failed.
+static HMODULE module_handles[module_id_count];
+
+// This table stores the function pointers that we have loaded dynamically. 
+// If a function pointer is a null pointer, we have not yet attempted to
+// get that function pointer.  If a function pointer is an -1, we have
+// attempted to get that function pointer but the attempt failed.
+#pragma data_seg(push, almostro, ".fptable")
+#pragma bss_seg(push, almostro, ".fptable")
+static void* function_pointers[function_id_count];
+#pragma bss_seg(pop, almostro)
+#pragma data_seg(pop, almostro)
+
+extern "C" bool __cdecl __acrt_initialize_winapi_thunks()
+{
+    DWORD old_prot;
+    return VirtualProtect(function_pointers, sizeof(function_pointers), PAGE_READONLY, &old_prot) ? true : false;
+}
+
+extern "C" bool __cdecl __acrt_uninitialize_winapi_thunks(bool const terminating)
+{
+    // If the process is terminating, there's no need to free any module handles
+    if (terminating)
+    {
+        return true;
+    }
+
+    for (HMODULE& module : module_handles)
+    {
+        if (module)
+        {
+            if (module != INVALID_HANDLE_VALUE)
+            {
+                FreeLibrary(module);
+            }
+
+            module = nullptr;
+        }
+    }
+
+    return true;
+}
+
+static __forceinline void* __cdecl invalid_function_sentinel() throw()
+{
+    return reinterpret_cast<void*>(static_cast<uintptr_t>(-1));
+}
+
+static HMODULE __cdecl try_load_library_from_system_directory(wchar_t const* const name) throw()
+{
+    HMODULE const handle = LoadLibraryExW(name, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+    if (handle)
+    {
+        return handle;
+    }
+
+    // LOAD_LIBRARY_SEARCH_SYSTEM32 is only supported by Windows 7 and above; if
+    // the OS does not support this flag, try again without it.  On these OSes,
+    // all APISets will be forwarders.  To prevent DLL hijacking, do not attempt
+    // to load the APISet forwarders dynamically.  This will cause our caller to
+    // fall back to the real DLL (e.g. kernel32).  All of those are known DLLs.
+    if (GetLastError() == ERROR_INVALID_PARAMETER &&
+        wcsncmp(name, L"api-ms-", 7) != 0 &&
+        wcsncmp(name, L"ext-ms-", 7) != 0)
+    {
+        return LoadLibraryExW(name, nullptr, 0);
+    }
+
+    return nullptr;
+}
+
+static HMODULE __cdecl try_get_module(module_id const id) throw()
+{
+    // First check to see if we've cached the module handle:
+    if (HMODULE const cached_handle = __crt_interlocked_read_pointer(module_handles + id))
+    {
+        if (cached_handle == INVALID_HANDLE_VALUE)
+        {
+            return nullptr;
+        }
+
+        return cached_handle;
+    }
+
+    // If we haven't yet cached the module handle, try to load the library.  If
+    // this fails, cache the sentinel handle value INVALID_HANDLE_VALUE so that
+    // we don't attempt to load the module again:
+    HMODULE const new_handle = try_load_library_from_system_directory(module_names[id]);
+    if (!new_handle)
+    {
+        if (HMODULE const cached_handle = __crt_interlocked_exchange_pointer(module_handles + id, INVALID_HANDLE_VALUE))
+        {
+            _ASSERTE(cached_handle == INVALID_HANDLE_VALUE);
+        }
+
+        return nullptr;
+    }
+
+    // Swap the new handle into the cache.  If the cache no longer contained a
+    // null handle, then some other thread loaded the module and cached the
+    // handle while we were doing the same.  In that case, we free the handle
+    // once to maintain the reference count:
+    if (HMODULE const cached_handle = __crt_interlocked_exchange_pointer(module_handles + id, new_handle))
+    {
+        _ASSERTE(cached_handle == new_handle);
+        FreeLibrary(new_handle);
+    }
+
+    return new_handle;
+}
+
+static HMODULE __cdecl try_get_first_available_module(
+    module_id const* const first,
+    module_id const* const last
+    ) throw()
+{
+    for (module_id const* it = first; it != last; ++it)
+    {
+        HMODULE const handle = try_get_module(*it);
+        if (handle)
+        {
+            return handle;
+        }
+    }
+
+    return nullptr;
+}
+
+static __forceinline void* __cdecl try_get_proc_address_from_first_available_module(
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    HMODULE const module_handle = try_get_first_available_module(first_module_id, last_module_id);
+    if (!module_handle)
+    {
+        return nullptr;
+    }
+
+    return reinterpret_cast<void*>(GetProcAddress(module_handle, name));
+}
+
+DECLSPEC_NOINLINE
+static void* __cdecl try_get_function_slow(
+    function_id      const id,
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    // If we haven't yet cached the function pointer, try to import it from any
+    // of the modules in which it might be defined.  If this fails, cache the
+    // sentinel pointer so that we don't attempt to load this function again:
+    void* const new_fp = try_get_proc_address_from_first_available_module(name, first_module_id, last_module_id);
+
+    __acrt_lock(__acrt_function_pointer_table_lock);
+
+    DWORD old_prot;
+    BOOL vp_result = VirtualProtect(function_pointers, sizeof(function_pointers), PAGE_READWRITE, &old_prot);
+    if (vp_result == FALSE)
+    {
+        abort();
+    }
+
+    if (!new_fp)
+    {
+        void* const cached_fp =
+            __crt_interlocked_exchange_pointer(
+                function_pointers + id,
+                invalid_function_sentinel());
+
+        if (cached_fp)
+        {
+            _ASSERTE(cached_fp == invalid_function_sentinel());
+        }
+
+        goto end;
+    }
+
+    // Swap the newly obtained function pointer into the cache.  The cache may
+    // no longer contain a null pointer if another thread obtained the
+    // function address while we were doing the same (both threads should have
+    // gotten the same function pointer):
+    {
+        void* const cached_fp =
+            __crt_interlocked_exchange_pointer(
+                function_pointers + id,
+                new_fp);
+
+        if (cached_fp)
+        {
+            _ASSERTE(cached_fp == new_fp);
+        }
+    }
+
+end:
+    vp_result = VirtualProtect(function_pointers, sizeof(function_pointers), PAGE_READONLY, &old_prot);
+    if (vp_result == FALSE)
+    {
+        abort();
+    }
+
+    __acrt_unlock(__acrt_function_pointer_table_lock);
+
+    return new_fp;
+}
+
+static __forceinline void* __cdecl try_get_function(
+    function_id      const id,
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    // First check to see if we've cached the function pointer:
+    {
+        void* const cached_fp =
+            ReadPointerNoFence(function_pointers + id);
+
+        if (cached_fp == invalid_function_sentinel())
+        {
+            return nullptr;
+        }
+
+        if (cached_fp)
+        {
+            return cached_fp;
+        }
+    }
+
+    return try_get_function_slow(id, name, first_module_id, last_module_id);
+}
+
+// Generate accessors that wrap the general try_get_function for each function,
+// passing the correct set of candidate modules and returning a function pointer
+// of the correct type:
+#define _APPLY(_FUNCTION, _MODULES)                                                                   \
+    static _CRT_CONCATENATE(_FUNCTION, _pft) __cdecl _CRT_CONCATENATE(try_get_, _FUNCTION)() throw()  \
+    {                                                                                                 \
+        static module_id const candidate_modules[] = _CRT_UNPARENTHESIZE(_MODULES);                   \
+                                                                                                      \
+        return reinterpret_cast<_CRT_CONCATENATE(_FUNCTION, _pft)>(try_get_function(                  \
+            _CRT_CONCATENATE(_FUNCTION, _id),                                                         \
+            _CRT_STRINGIZE(_FUNCTION),                                                                \
+            candidate_modules,                                                                        \
+            candidate_modules + _countof(candidate_modules)));                                        \
+    }
+_ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+#undef _APPLY
+
+static __forceinline void* __cdecl get_function(
+    function_id      const id,
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    UNREFERENCED_PARAMETER(name);
+    UNREFERENCED_PARAMETER(first_module_id);
+    UNREFERENCED_PARAMETER(last_module_id);
+
+    // This function assumes the cached function pointer is always valid
+    void* const cached_fp =
+        ReadPointerNoFence(function_pointers + id);
+
+    return cached_fp;
+
+}
+
+#pragma warning(push)
+#pragma warning(disable: 4505) // unreferenced local function has been removed
+// Generate accessors that wrap the general try_get_function for each function,
+// passing the correct set of candidate modules and returning a function pointer
+// of the correct type:
+#define _APPLY(_FUNCTION, _MODULES)                                                                   \
+    static __forceinline _CRT_CONCATENATE(_FUNCTION, _pft) __cdecl _CRT_CONCATENATE(get_, _FUNCTION)() throw()  \
+    {                                                                                                 \
+        static module_id const candidate_modules[] = _CRT_UNPARENTHESIZE(_MODULES);                   \
+                                                                                                      \
+        return reinterpret_cast<_CRT_CONCATENATE(_FUNCTION, _pft)>(get_function(                      \
+            _CRT_CONCATENATE(_FUNCTION, _id),                                                         \
+            _CRT_STRINGIZE(_FUNCTION),                                                                \
+            candidate_modules,                                                                        \
+            candidate_modules + _countof(candidate_modules)));                                        \
+    }
+_ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+#undef _APPLY
+#pragma warning(pop)
+
+extern "C" BOOL WINAPI __acrt_AreFileApisANSI()
+{
+    if (auto const are_file_apis_ansi = try_get_AreFileApisANSI())
+    {
+        return are_file_apis_ansi();
+    }
+
+    // If we were unable to get the AreFileApisANSI function, we can safely
+    // assume that the file APIs are, in fact, ANSI:
+    return TRUE;
+}
+
+extern "C" int WINAPI __acrt_CompareStringEx(
+    LPCWSTR          const locale_name,
+    DWORD            const flags,
+    LPCWCH           const string1,
+    int              const string1_count,
+    LPCWCH           const string2,
+    int              const string2_count,
+    LPNLSVERSIONINFO const version,
+    LPVOID           const reserved,
+    LPARAM           const param
+    )
+{
+    if (auto const compare_string_ex = try_get_CompareStringEx())
+    {
+        // On WCOS devices, CompareStringEx may calls into icu.dll which is an OS component using the UCRT.
+        // If icu.dll calls any UCRT export under OS mode (ex: malloc), then CompareStringEx will return under Prog Mode even if
+        // we started in OS mode. To prevent this, an OS mode guard is in place.
+        __crt_state_management::scoped_global_state_reset os_mode_guard;
+        return compare_string_ex(locale_name, flags, string1, string1_count, string2, string2_count, version, reserved, param);
+    }
+
+    return CompareStringW(__acrt_LocaleNameToLCID(locale_name, 0), flags, string1, string1_count, string2, string2_count);
+}
+
+// This has been split into its own function to work around a bug in the Dev12
+// C++ compiler where nested captureless lambdas are not convertible to the
+// required function pointer type.
+static BOOL enum_system_locales_ex_nolock(
+    LOCALE_ENUMPROCEX const enum_proc
+    ) throw()
+{
+    static LOCALE_ENUMPROCEX static_enum_proc;
+
+    static_enum_proc = enum_proc;
+    BOOL const result = EnumSystemLocalesW(
+        [](LPWSTR locale_string) { return (static_enum_proc)(locale_string, 0, 0); },
+        LCID_INSTALLED);
+    static_enum_proc = nullptr;
+
+    return result;
+}
+
+extern "C" BOOL WINAPI __acrt_EnumSystemLocalesEx(
+    LOCALE_ENUMPROCEX const enum_proc,
+    DWORD             const flags,
+    LPARAM            const param,
+    LPVOID            const reserved
+    )
+{
+    if (auto const enum_system_locales_ex = try_get_EnumSystemLocalesEx())
+    {
+        return enum_system_locales_ex(enum_proc, flags, param, reserved);
+    }
+
+    return __acrt_lock_and_call(__acrt_locale_lock, [&]() -> BOOL
+    {
+        return enum_system_locales_ex_nolock(enum_proc);
+    });
+}
+
+// Historically, we needed to conditionally call FLS functions for x86 since the UCRT needed to be consumable down to XP.
+// This is no longer the case as XP is no longer supported, however the enclave implementations of these functions
+// unconditionally call the TLS equivalent APIs (TlsAlloc, etc), hence why these are still kept around
+extern "C" DWORD WINAPI __acrt_FlsAlloc(PFLS_CALLBACK_FUNCTION const callback)
+{
+    return FlsAlloc(callback);
+}
+
+extern "C" BOOL WINAPI __acrt_FlsFree(DWORD const fls_index)
+{
+    return FlsFree(fls_index);
+}
+
+extern "C" PVOID WINAPI __acrt_FlsGetValue(DWORD const fls_index)
+{
+    return FlsGetValue(fls_index);
+}
+
+extern "C"
+DECLSPEC_GUARDNOCF
+PVOID WINAPI __acrt_FlsGetValue2(DWORD const fls_index)
+{
+#if (defined(_M_ARM64_) || defined(_M_ARM64EC)) && _UCRT_DLL
+    return FlsGetValue2(fls_index);
+#else
+    /*
+    * N.B.: This function must be called after checking __acrt_use_tls2_apis.
+    */
+    auto const flsgetvalue2 = get_FlsGetValue2();
+    return flsgetvalue2(fls_index);
+#endif
+}
+
+extern "C" BOOL WINAPI __acrt_FlsSetValue(DWORD const fls_index, PVOID const fls_data)
+{
+    return FlsSetValue(fls_index, fls_data);
+}
+
+extern "C" BOOL WINAPI __acrt_IsThreadAFiber()
+{
+    return IsThreadAFiber();
+}
+
+extern "C" int WINAPI __acrt_GetDateFormatEx(
+    LPCWSTR           const locale_name,
+    DWORD             const flags,
+    SYSTEMTIME CONST* const date,
+    LPCWSTR           const format,
+    LPWSTR            const buffer,
+    int               const buffer_count,
+    LPCWSTR           const calendar
+    )
+{
+    if (auto const get_date_format_ex = try_get_GetDateFormatEx())
+    {
+        return get_date_format_ex(locale_name, flags, date, format, buffer, buffer_count, calendar);
+    }
+
+    return GetDateFormatW(__acrt_LocaleNameToLCID(locale_name, 0), flags, date, format, buffer, buffer_count);
+}
+
+extern "C" int WINAPI __acrt_GetTempPath2W(
+    DWORD nBufferLength,
+    LPWSTR lpBuffer
+)
+{
+    if (auto const get_temp_path2w = try_get_GetTempPath2W())
+    {
+        return get_temp_path2w(nBufferLength, lpBuffer);
+    }
+    return GetTempPathW(nBufferLength, lpBuffer);
+}
+
+extern "C" BOOL WINAPI __acrt_GetFileInformationByName(
+    LPCWSTR FileName,
+    DWORD FileInformationClass,                // FILE_INFO_BY_NAME_CLASS
+    PVOID FileInfoBuffer,
+    ULONG FileInfoBufferSize
+)
+{
+    if (auto const get_file_info = try_get_GetFileInformationByName())
+    {
+        return get_file_info(FileName, FileInformationClass, FileInfoBuffer, FileInfoBufferSize);
+    }
+    return FALSE;
+}
+
+extern "C" DWORD64 WINAPI __acrt_GetEnabledXStateFeatures()
+{
+    if (auto const get_enabled_xstate_features = try_get_GetEnabledXStateFeatures())
+    {
+        return get_enabled_xstate_features();
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" int WINAPI __acrt_GetLocaleInfoEx(
+    LPCWSTR const locale_name,
+    LCTYPE  const lc_type,
+    LPWSTR  const data,
+    int     const data_count
+    )
+{
+    if (auto const get_locale_info_ex = try_get_GetLocaleInfoEx())
+    {
+        return get_locale_info_ex(locale_name, lc_type, data, data_count);
+    }
+
+    return GetLocaleInfoW(__acrt_LocaleNameToLCID(locale_name, 0), lc_type, data, data_count);
+}
+
+extern "C" VOID WINAPI __acrt_GetSystemTimePreciseAsFileTime(LPFILETIME const system_time)
+{
+    if (auto const get_system_time_precise_as_file_time = try_get_GetSystemTimePreciseAsFileTime())
+    {
+        return get_system_time_precise_as_file_time(system_time);
+    }
+
+    return GetSystemTimeAsFileTime(system_time);
+}
+
+extern "C" int WINAPI __acrt_GetTimeFormatEx(
+    LPCWSTR           const locale_name,
+    DWORD             const flags,
+    SYSTEMTIME CONST* const time,
+    LPCWSTR           const format,
+    LPWSTR            const buffer,
+    int               const buffer_count
+    )
+{
+    if (auto const get_time_format_ex = try_get_GetTimeFormatEx())
+    {
+        return get_time_format_ex(locale_name, flags, time, format, buffer, buffer_count);
+    }
+
+    return GetTimeFormatW(__acrt_LocaleNameToLCID(locale_name, 0), flags, time, format, buffer, buffer_count);
+}
+
+extern "C" int WINAPI __acrt_GetUserDefaultLocaleName(
+    LPWSTR const locale_name,
+    int    const locale_name_count
+    )
+{
+    if (auto const get_user_default_locale_name = try_get_GetUserDefaultLocaleName())
+    {
+        return get_user_default_locale_name(locale_name, locale_name_count);
+    }
+
+    return __acrt_LCIDToLocaleName(GetUserDefaultLCID(), locale_name, locale_name_count, 0);
+}
+
+extern "C" BOOL WINAPI __acrt_GetXStateFeaturesMask(
+    PCONTEXT const context,
+    PDWORD64 const feature_mask
+    )
+{
+    if (auto const get_xstate_features_mask = try_get_GetXStateFeaturesMask())
+    {
+        return get_xstate_features_mask(context, feature_mask);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" BOOL WINAPI __acrt_InitializeCriticalSectionEx(
+    LPCRITICAL_SECTION const critical_section,
+    DWORD              const spin_count,
+    DWORD              const flags
+    )
+{
+    return InitializeCriticalSectionEx(critical_section, spin_count, flags);
+}
+
+extern "C" BOOL WINAPI __acrt_IsValidLocaleName(LPCWSTR const locale_name)
+{
+    if (auto const is_valid_locale_name = try_get_IsValidLocaleName())
+    {
+        return is_valid_locale_name(locale_name);
+    }
+
+    return IsValidLocale(__acrt_LocaleNameToLCID(locale_name, 0), LCID_INSTALLED);
+}
+
+extern "C" int WINAPI __acrt_LCMapStringEx(
+    LPCWSTR          const locale_name,
+    DWORD            const flags,
+    LPCWSTR          const source,
+    int              const source_count,
+    LPWSTR           const destination,
+    int              const destination_count,
+    LPNLSVERSIONINFO const version,
+    LPVOID           const reserved,
+    LPARAM           const sort_handle
+    )
+{
+    if (auto const lc_map_string_ex = try_get_LCMapStringEx())
+    {
+        return lc_map_string_ex(locale_name, flags, source, source_count, destination, destination_count, version, reserved, sort_handle);
+    }
+#pragma warning(disable:__WARNING_PRECONDITION_NULLTERMINATION_VIOLATION) // 26035 LCMapStringW annotation is presently incorrect 11/26/2014 Jaykrell
+    return LCMapStringW(__acrt_LocaleNameToLCID(locale_name, 0), flags, source, source_count, destination, destination_count);
+}
+
+extern "C" int WINAPI __acrt_LCIDToLocaleName(
+    LCID   const locale,
+    LPWSTR const name,
+    int    const name_count,
+    DWORD  const flags
+    )
+{
+    if (auto const lcid_to_locale_name = try_get_LCIDToLocaleName())
+    {
+        return lcid_to_locale_name(locale, name, name_count, flags);
+    }
+
+    return __acrt_DownlevelLCIDToLocaleName(locale, name, name_count);
+}
+
+extern "C" LCID WINAPI __acrt_LocaleNameToLCID(
+    LPCWSTR const name,
+    DWORD   const flags
+    )
+{
+    if (auto const locale_name_to_lcid = try_get_LocaleNameToLCID())
+    {
+        return locale_name_to_lcid(name, flags);
+    }
+
+    return __acrt_DownlevelLocaleNameToLCID(name);
+}
+
+extern "C" PVOID WINAPI __acrt_LocateXStateFeature(
+    PCONTEXT const content,
+    DWORD    const feature_id,
+    PDWORD   const length
+    )
+{
+    if (auto const locate_xstate_feature = try_get_LocateXStateFeature())
+    {
+        return locate_xstate_feature(content, feature_id, length);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" int WINAPI __acrt_MessageBoxA(
+    HWND   const hwnd,
+    LPCSTR const text,
+    LPCSTR const caption,
+    UINT   const type
+    )
+{
+    if (auto const message_box_a = try_get_MessageBoxA())
+    {
+        return message_box_a(hwnd, text, caption, type);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" int WINAPI __acrt_MessageBoxW(
+    HWND    const hwnd,
+    LPCWSTR const text,
+    LPCWSTR const caption,
+    UINT    const type
+    )
+{
+    if (auto const message_box_w = try_get_MessageBoxW())
+    {
+        return message_box_w(hwnd, text, caption, type);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" BOOLEAN WINAPI __acrt_RtlGenRandom(
+    PVOID const buffer,
+    ULONG const buffer_count
+    )
+{
+    if (auto const rtl_gen_random = try_get_SystemFunction036())
+    {
+        return rtl_gen_random(buffer, buffer_count);
+    }
+
+    abort(); // No fallback (this function should exist)
+}
+
+extern "C" HRESULT WINAPI __acrt_RoInitialize(RO_INIT_TYPE const init_type)
+{
+    if (auto const ro_initialize = try_get_RoInitialize())
+    {
+        return ro_initialize(init_type);
+    }
+
+    return S_OK; // No fallback (this is a best-effort wrapper)
+}
+
+extern "C" void WINAPI __acrt_RoUninitialize()
+{
+    if (auto const ro_uninitialize = try_get_RoUninitialize())
+    {
+        return ro_uninitialize();
+    }
+
+    // No fallback (this is a best-effort wrapper)
+}
+
+LONG WINAPI __acrt_AppPolicyGetProcessTerminationMethodInternal(_Out_ AppPolicyProcessTerminationMethod* policy)
+{
+    if (auto const app_policy_get_process_terminaton_method_claims = try_get_AppPolicyGetProcessTerminationMethod())
+    {
+        return app_policy_get_process_terminaton_method_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+LONG WINAPI __acrt_AppPolicyGetThreadInitializationTypeInternal(_Out_ AppPolicyThreadInitializationType* policy)
+{
+    if (auto const app_policy_get_thread_initialization_type_claims = try_get_AppPolicyGetThreadInitializationType())
+    {
+        return app_policy_get_thread_initialization_type_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+LONG WINAPI __acrt_AppPolicyGetShowDeveloperDiagnosticInternal(_Out_ AppPolicyShowDeveloperDiagnostic* policy)
+{
+    if (auto const app_policy_get_show_developer_diagnostic_claims = try_get_AppPolicyGetShowDeveloperDiagnostic())
+    {
+        return app_policy_get_show_developer_diagnostic_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+LONG WINAPI __acrt_AppPolicyGetWindowingModelInternal(_Out_ AppPolicyWindowingModel* policy)
+{
+    if (auto const app_policy_get_windowing_model_claims = try_get_AppPolicyGetWindowingModel())
+    {
+        return app_policy_get_windowing_model_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+extern "C" BOOL WINAPI __acrt_SetThreadStackGuarantee(PULONG const stack_size_in_bytes)
+{
+    if (auto const set_thread_stack_guarantee = try_get_SetThreadStackGuarantee())
+    {
+        return set_thread_stack_guarantee(stack_size_in_bytes);
+    }
+
+    return FALSE;
+}
+
+extern "C" bool __cdecl __acrt_can_show_message_box()
+{
+    bool can_show_message_box = false;
+    if (__acrt_get_windowing_model_policy() == windowing_model_policy_hwnd
+        && try_get_MessageBoxA() != nullptr
+        && try_get_MessageBoxW() != nullptr)
+    {
+        can_show_message_box = true;
+    }
+    return can_show_message_box;
+}
+
+extern "C" bool __cdecl __acrt_can_use_vista_locale_apis()
+{
+    return try_get_CompareStringEx() != nullptr;
+}
+
+// This function simply attempts to get each of the locale-related APIs.  This
+// allows a caller to "pre-load" the modules in which these APIs are hosted.  We
+// use this in the _wsetlocale implementation to avoid calls to LoadLibrary while
+// the locale lock is held.
+extern "C" void __cdecl __acrt_eagerly_load_locale_apis()
+{
+    try_get_AreFileApisANSI();
+    try_get_CompareStringEx();
+    try_get_EnumSystemLocalesEx();
+    try_get_GetDateFormatEx();
+    try_get_GetLocaleInfoEx();
+    try_get_GetTimeFormatEx();
+    try_get_GetUserDefaultLocaleName();
+    try_get_IsValidLocaleName();
+    try_get_LCMapStringEx();
+    try_get_LCIDToLocaleName();
+    try_get_LocaleNameToLCID();
+}
+
+extern "C" bool __cdecl __acrt_tls2_supported()
+{
+    return (try_get_FlsGetValue2() != nullptr);
+}
+
+extern "C" bool __cdecl __acrt_can_use_xstate_apis()
+{
+    return try_get_LocateXStateFeature() != nullptr;
+}
+
+extern "C" HWND __cdecl __acrt_get_parent_window()
+{
+    auto const get_active_window = try_get_GetActiveWindow();
+    if (!get_active_window)
+    {
+        return nullptr;
+    }
+
+    HWND const active_window = get_active_window();
+    if (!active_window)
+    {
+        return nullptr;
+    }
+
+    auto const get_last_active_popup = try_get_GetLastActivePopup();
+    if (!get_last_active_popup)
+    {
+        return active_window;
+    }
+
+    return get_last_active_popup(active_window);
+}
+
+extern "C" bool __cdecl __acrt_is_interactive()
+{
+    auto const get_process_window_station = try_get_GetProcessWindowStation();
+    if (!get_process_window_station)
+    {
+        return true;
+    }
+
+    auto const get_user_object_information = try_get_GetUserObjectInformationW();
+    if (!get_user_object_information)
+    {
+        return true;
+    }
+
+    HWINSTA const hwinsta = get_process_window_station();
+    if (!hwinsta)
+    {
+        return false;
+    }
+
+    USEROBJECTFLAGS uof{};
+    if (!get_user_object_information(hwinsta, UOI_FLAGS, &uof, sizeof(uof), nullptr))
+    {
+        return false;
+    }
+
+    if ((uof.dwFlags & WSF_VISIBLE) == 0)
+    {
+        return false;
+    }
+
+    return true;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringA.cpp

@@ -0,0 +1,232 @@
+/***
+*a_cmp.c - A version of CompareString.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Use either CompareStringA or CompareStringW depending on which is
+*       available
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+
+
+
+/***
+*int __cdecl __acrt_CompareStringA - Get type information about an ANSI string.
+*
+*Purpose:
+*       Internal support function. Assumes info in ANSI string format. Tries
+*       to use NLS API call CompareStringA if available and uses CompareStringW
+*       if it must. If neither are available it fails and returns 0.
+*
+*Entry:
+*       LPCWSTR LocaleName  - locale context for the comparison.
+*       DWORD   dwCmpFlags  - see NT\Chicago docs
+*       LPCSTR  lpStringn   - multibyte string to be compared
+*       int     cchCountn   - char (byte) count (NOT including nullptr)
+*                             (-1 if nullptr terminated)
+*       int     code_page   - for MB/WC conversion. If 0, use __lc_codepage
+*
+*Exit:
+*       Success: 1 - if lpString1 <  lpString2
+*                2 - if lpString1 == lpString2
+*                3 - if lpString1 >  lpString2
+*       Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static int __cdecl InternalCompareStringA(
+    _locale_t plocinfo,
+    LPCWSTR   LocaleName,
+    DWORD     dwCmpFlags,
+    PCCH      lpString1,
+    int       cchCount1,
+    PCCH      lpString2,
+    int       cchCount2,
+    int       code_page
+    ) throw()
+{
+    /*
+     * CompareString will compare past nullptr. Must find nullptr if in string
+     * before cchCountn chars.
+     */
+
+    if (cchCount1 > 0)
+        cchCount1 = static_cast<int>(__strncnt(lpString1, cchCount1));
+    else if (cchCount1 < -1)
+        return FALSE;
+
+    if (cchCount2 > 0)
+        cchCount2 = static_cast<int>(__strncnt(lpString2, cchCount2));
+    else if (cchCount2 < -1)
+        return FALSE;
+
+
+    int buff_size1;
+    int buff_size2;
+
+    /*
+     * Use __lc_codepage for conversion if code_page not specified
+     */
+
+    if (0 == code_page)
+        code_page = plocinfo->locinfo->_public._locale_lc_codepage;
+
+    /*
+     * Special case: at least one count is zero
+     */
+
+    if (!cchCount1 || !cchCount2)
+    {
+        unsigned char *cp;  // char pointer
+        CPINFO cpInfo;      // struct for use with GetCPInfo
+
+        /* both strings zero */
+        if (cchCount1 == cchCount2)
+            return 2;
+
+        /* string 1 greater */
+        if (cchCount2 > 1)
+            return 1;
+
+        /* string 2 greater */
+        if (cchCount1 > 1)
+            return 3;
+
+        /*
+         * one has zero count, the other has a count of one
+         * - if the one count is a naked lead byte, the strings are equal
+         * - otherwise it is a single character and they are unequal
+         */
+
+        if (GetCPInfo(code_page, &cpInfo) == FALSE)
+            return 0;
+
+        _ASSERTE(cchCount1==0 && cchCount2==1 || cchCount1==1 && cchCount2==0);
+
+        /* string 1 has count of 1 */
+        if (cchCount1 > 0)
+        {
+            if (cpInfo.MaxCharSize < 2)
+                return 3;
+
+            for ( cp = (unsigned char *)cpInfo.LeadByte ;
+                  cp[0] && cp[1] ;
+                  cp += 2 )
+                if ( (*(unsigned char *)lpString1 >= cp[0]) &&
+                     (*(unsigned char *)lpString1 <= cp[1]) )
+                    return 2;
+
+            return 3;
+        }
+
+        /* string 2 has count of 1 */
+        if (cchCount2 > 0)
+        {
+            if (cpInfo.MaxCharSize < 2)
+            return 1;
+
+            for ( cp = (unsigned char *)cpInfo.LeadByte ;
+                  cp[0] && cp[1] ;
+                  cp += 2 )
+                if ( (*(unsigned char *)lpString2 >= cp[0]) &&
+                     (*(unsigned char *)lpString2 <= cp[1]) )
+                    return 2;
+
+            return 1;
+        }
+    }
+
+    /*
+     * Convert strings and return the requested information.
+     */
+
+    /* find out how big a buffer we need (includes nullptr if any) */
+    if ( 0 == (buff_size1 = __acrt_MultiByteToWideChar( code_page,
+                                                 MB_PRECOMPOSED |
+                                                    MB_ERR_INVALID_CHARS,
+                                                 lpString1,
+                                                 cchCount1,
+                                                 nullptr,
+                                                 0 )) )
+        return 0;
+
+    /* allocate enough space for chars */
+    __crt_scoped_stack_ptr<wchar_t> wbuffer1(_malloca_crt_t(wchar_t, buff_size1));
+    if (wbuffer1.get() == nullptr)
+        return 0;
+
+    /* do the conversion */
+    if ( 0 == __acrt_MultiByteToWideChar( code_page,
+                                   MB_PRECOMPOSED,
+                                   lpString1,
+                                   cchCount1,
+                                   wbuffer1.get(),
+                                   buff_size1 ) )
+        return 0;
+
+    /* find out how big a buffer we need (includes nullptr if any) */
+    if ( 0 == (buff_size2 = __acrt_MultiByteToWideChar( code_page,
+                                                 MB_PRECOMPOSED |
+                                                    MB_ERR_INVALID_CHARS,
+                                                 lpString2,
+                                                 cchCount2,
+                                                 nullptr,
+                                                 0 )) )
+        return 0;
+
+    /* allocate enough space for chars */
+    __crt_scoped_stack_ptr<wchar_t> const wbuffer2(_malloca_crt_t(wchar_t, buff_size2));
+    if (wbuffer2.get() == nullptr)
+        return 0;
+
+    int const actual_size = __acrt_MultiByteToWideChar(
+        code_page,
+        MB_PRECOMPOSED,
+        lpString2,
+        cchCount2,
+        wbuffer2.get(),
+        buff_size2);
+
+    if (actual_size == 0)
+        return 0;
+
+    return __acrt_CompareStringEx(
+        LocaleName,
+        dwCmpFlags,
+        wbuffer1.get(),
+        buff_size1,
+        wbuffer2.get(),
+        buff_size2,
+        nullptr,
+        nullptr,
+        0);
+}
+
+extern "C" int __cdecl __acrt_CompareStringA(
+    _locale_t const locale,
+    LPCWSTR   const locale_name,
+    DWORD     const compare_flags,
+    PCCH      const string1,
+    int       const string1_count,
+    PCCH      const string2,
+    int       const string2_count,
+    int       const code_page
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    return InternalCompareStringA(
+        locale_update.GetLocaleT(),
+        locale_name,
+        compare_flags,
+        string1,
+        string1_count,
+        string2,
+        string2_count,
+        code_page
+        );
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringW.cpp

@@ -0,0 +1,67 @@
+/***
+*w_cmp.c - W versions of CompareString.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Wrapper for CompareStringW.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+
+/***
+*int __cdecl __acrt_CompareStringW - Get type information about a wide string.
+*
+*Purpose:
+*  Internal support function. Assumes info in wide string format.
+*
+*Entry:
+*  LPCWSTR  LocaleName  - locale context for the comparison.
+*  DWORD    dwCmpFlags  - see NT\Chicago docs
+*  LPCWSTR  lpStringn   - wide string to be compared
+*  int      cchCountn   - wide char (word) count (NOT including nullptr)
+*                       (-1 if nullptr terminated)
+*
+*Exit:
+*  Success: 1 - if lpString1 <  lpString2
+*           2 - if lpString1 == lpString2
+*           3 - if lpString1 >  lpString2
+*  Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl __acrt_CompareStringW(
+        LPCWSTR  LocaleName,
+        DWORD    dwCmpFlags,
+        PCWCH    lpString1,
+        int      cchCount1,
+        PCWCH    lpString2,
+        int      cchCount2
+        )
+{
+    /*
+     * CompareString will compare past nullptr. Must find nullptr if in string
+     * before cchCountn wide characters.
+     */
+
+    if (cchCount1 > 0)
+        cchCount1= (int) wcsnlen(lpString1, cchCount1);
+    if (cchCount2 > 0)
+        cchCount2= (int) wcsnlen(lpString2, cchCount2);
+
+    if (!cchCount1 || !cchCount2)
+        return (cchCount1 - cchCount2 == 0) ? 2 :
+               (cchCount1 - cchCount2 < 0) ? 1 : 3;
+
+    return __acrt_CompareStringEx( LocaleName,
+                           dwCmpFlags,
+                           lpString1,
+                           cchCount1,
+                           lpString2,
+                           cchCount2,
+                           nullptr,
+                           nullptr,
+                           0);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetLocaleInfoA.cpp

@@ -0,0 +1,165 @@
+//
+// GetLocaleInfoA.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the CRT-internal GetLocaleInfoA implementation.
+//
+#include <corecrt_internal.h>
+
+
+
+// Wraps a call to GetLocaleInfoEx and translates the result into a narrow string.
+_Success_(return > 0)
+static int __cdecl InternalGetLocaleInfoA(
+                                _locale_t   const   locale,
+                                PCWSTR      const   locale_name,
+                                LCTYPE      const   locale_type,
+    _Out_writes_z_(result_size) char*       const   result,
+                                int         const   result_size
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    int const code_page = locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage;
+
+    int const buffer_size = __acrt_GetLocaleInfoEx(locale_name, locale_type, nullptr, 0);
+    if (buffer_size == 0)
+        return 0;
+
+    __crt_scoped_stack_ptr<wchar_t> const buffer(_malloca_crt_t(wchar_t, buffer_size));
+    if (buffer.get() == nullptr)
+        return 0;
+
+    if (__acrt_GetLocaleInfoEx(locale_name, locale_type, buffer.get(), buffer_size) == 0)
+        return 0;
+
+    // Convert from wide to narrow strings:
+    return __acrt_WideCharToMultiByte(
+        code_page,
+        0,
+        buffer.get(),
+        -1,
+        result_size != 0 ? result : nullptr,
+        result_size,
+        nullptr,
+        nullptr);
+}
+
+
+
+// Gets locale information appropriate for use in the setlocale initialization
+// functions.  In particular, wide locale strings can be converted to narrow
+// strings or numeric values depending on the value of the lc_type parameter.
+//
+// The void_result must be reinterpretable as a pointer to one of the following
+// types, depending on the value of LC_TYPE:
+//
+//  * LC_STR_TYPE:   char*
+//  * LC_WSTR_TYPE:  wchar_t*
+//  * LC_INT_TYPE:   unsigned char
+//
+// For the first two cases, where a pointer to a pointer is passed, if the
+// function succeeds, the caller is responsible for freeing the pointed-to
+// buffer.
+//
+// Returns 0 on success; -1 on failure.
+//
+// Future optimization:  When converting a large number of wide strings to
+// multibyte, we do not need to query the size of the result.  We can convert
+// them one after another into a large character buffer.
+int __cdecl __acrt_GetLocaleInfoA(
+    _locale_t      const locale,
+    int            const lc_type,
+    wchar_t const* const locale_name,
+    LCTYPE         const locale_type,
+    void*          const void_result
+    )
+{
+    *static_cast<void**>(void_result) = nullptr;
+
+    if (lc_type == LC_STR_TYPE)
+    {
+        char** const char_result = static_cast<char**>(void_result);
+
+        int const local_buffer_size = 128;
+        char local_buffer[local_buffer_size];
+
+        int const local_length = InternalGetLocaleInfoA(
+            locale, locale_name, locale_type, local_buffer, local_buffer_size);
+
+        if (local_length != 0)
+        {
+            *char_result = _calloc_crt_t(char, local_length).detach();
+            if (*char_result == nullptr)
+                return -1;
+
+            _ERRCHECK(strncpy_s(*char_result, local_length, local_buffer, local_length - 1));
+            return 0;
+        }
+
+        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+            return -1;
+
+        // If the buffer size was too small, compute the required size and use a
+        // dynamically allocated buffer:
+        int const required_length = InternalGetLocaleInfoA(
+            locale, locale_name, locale_type, nullptr, 0);
+
+        if (required_length == 0)
+            return -1;
+
+        __crt_unique_heap_ptr<char> dynamic_buffer(_calloc_crt_t(char, required_length));
+        if (dynamic_buffer.get() == nullptr)
+            return -1;
+
+        int const actual_length = InternalGetLocaleInfoA(
+            locale, locale_name, locale_type, dynamic_buffer.get(), required_length);
+
+        if (actual_length == 0)
+            return -1;
+
+        *char_result = dynamic_buffer.detach();
+        return 0;
+    }
+    else if (lc_type == LC_WSTR_TYPE)
+    {
+        wchar_t** const wchar_result = static_cast<wchar_t**>(void_result);
+
+        int const required_length = __acrt_GetLocaleInfoEx(locale_name, locale_type, nullptr, 0);
+        if (required_length == 0)
+            return -1;
+
+        __crt_unique_heap_ptr<wchar_t> dynamic_buffer(_calloc_crt_t(wchar_t, required_length));
+        if (dynamic_buffer.get() == nullptr)
+            return -1;
+
+        int const actual_length = __acrt_GetLocaleInfoEx(
+            locale_name, locale_type, dynamic_buffer.get(), required_length);
+
+        if (actual_length == 0)
+            return -1;
+
+        *wchar_result = dynamic_buffer.detach();
+        return 0;
+    }
+    else if (lc_type == LC_INT_TYPE)
+    {
+        unsigned char* const uchar_result = static_cast<unsigned char*>(void_result);
+
+        DWORD value = 0;
+        int const actual_length = __acrt_GetLocaleInfoEx(
+            locale_name,
+            locale_type | LOCALE_RETURN_NUMBER,
+            reinterpret_cast<wchar_t*>(&value),
+            sizeof(value) / sizeof(wchar_t));
+
+        if (actual_length == 0)
+            return -1;
+
+        *uchar_result = static_cast<unsigned char>(value);
+        return 0;
+    }
+
+    return -1;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetStringTypeA.cpp

@@ -0,0 +1,100 @@
+/***
+*a_str.c - A version of GetStringType.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Use either GetStringTypeA or GetStringTypeW depending on which is
+*       unstubbed.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+
+/***
+*int __cdecl __acrt_GetStringTypeA - Get type information about an ANSI string.
+*
+*Purpose:
+*       Internal support function. Assumes info in ANSI string format. Tries
+*       to use NLS API call GetStringTypeA if available and uses GetStringTypeW
+*       if it must. If neither are available it fails and returns FALSE.
+*
+*Entry:
+*       DWORD    dwInfoType  - see NT\Chicago docs
+*       PCCH     lpSrcStr    - char (byte) string for which character types
+*                              are requested
+*       int      cchSrc      - char (byte) count of lpSrcStr (including nullptr
+*                              if any)
+*       LPWORD   lpCharType  - word array to receive character type information
+*                              (must be twice the size of lpSrcStr)
+*       int      code_page   - for MB/WC conversion. If 0, use __lc_codepage
+*       BOOL     bError      - TRUE if MB_ERR_INVALID_CHARS set on call to
+*                              MultiByteToWideChar when GetStringTypeW used.
+*
+*Exit:
+*       Success: TRUE
+*       Failure: FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" BOOL __cdecl __acrt_GetStringTypeA(
+    _locale_t       const locale,
+    DWORD           const info_type,
+    LPCSTR          const string,
+    int             const string_size_in_bytes,
+    unsigned short* const char_type,
+    int             const code_page,
+    BOOL            const error
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    // Convert string and return the requested information. Note that
+    // we are converting to a wide character string so there is not a
+    // one-to-one correspondence between number of multibyte chars in the
+    // input string and the number of wide chars in the buffer. However,
+    // there had *better be* a one-to-one correspondence between the
+    // number of multibyte characters and the number of WORDs in the
+    // return buffer.
+
+    // Use __lc_codepage for conversion if code_page not specified:
+    int const actual_code_page = code_page != 0
+        ? code_page
+        : locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage;
+
+    // Find out how big a buffer we need:
+    int const required_extent = __acrt_MultiByteToWideChar(
+        actual_code_page,
+        error ? (MB_PRECOMPOSED | MB_ERR_INVALID_CHARS) : MB_PRECOMPOSED,
+        string,
+        string_size_in_bytes,
+        nullptr,
+        0);
+
+    if (required_extent == 0)
+        return FALSE;
+
+    // Allocate enough space for the wide character string:
+    __crt_scoped_stack_ptr<wchar_t> buffer(_malloca_crt_t(wchar_t, required_extent));
+    if (buffer.get() == nullptr)
+        return FALSE;
+
+    memset(buffer.get(), 0, sizeof(wchar_t) * required_extent);
+
+    // Do the conversion:
+    int const actual_extent = __acrt_MultiByteToWideChar(
+        actual_code_page,
+        MB_PRECOMPOSED,
+        string,
+        string_size_in_bytes,
+        buffer.get(),
+        required_extent);
+
+    if (actual_extent == 0)
+        return FALSE;
+
+    return GetStringTypeW(info_type, buffer.get(), actual_extent, char_type);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringA.cpp

@@ -0,0 +1,235 @@
+/***
+*a_map.c - A version of LCMapString.
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Use either LCMapStringA or LCMapStringW depending on which is available
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+
+/***
+*int __cdecl __acrt_LCMapStringA - Get type information about an ANSI string.
+*
+*Purpose:
+*       Internal support function. Assumes info in ANSI string format. Tries
+*       to use NLS API call LCMapStringA if available and uses LCMapStringW
+*       if it must. If neither are available it fails and returns 0.
+*
+*Entry:
+*       LPCWSTR  LocaleName  - locale context for the comparison.
+*       DWORD    dwMapFlags  - see NT\Chicago docs
+*       PCCH     cchSrc      - wide char (word) count of input string
+*                              (including nullptr if any)
+*                              (-1 if nullptr terminated)
+*       PCH    lpDestStr     - pointer to memory to store mapping
+*       int      cchDest     - char (byte) count of buffer (including nullptr)
+*       int      code_page   - for MB/WC conversion. If 0, use __lc_codepage
+*       BOOL     bError      - TRUE if MB_ERR_INVALID_CHARS set on call to
+*                              MultiByteToWideChar when GetStringTypeW used.
+*
+*Exit:
+*       Success: number of chars written to lpDestStr (including nullptr)
+*       Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static _Success_(return != 0) int __cdecl __acrt_LCMapStringA_stat(
+        _In_opt_                    _locale_t plocinfo,
+        _In_                        LPCWSTR   LocaleName,
+        _In_                        DWORD     dwMapFlags,
+        _In_CRT_NLS_string_(cchSrc) PCCH      lpSrcStr,
+        _In_                        int       cchSrc,
+        _Out_writes_opt_(cchDest)   PCH       lpDestStr,
+        _In_                        int       cchDest,
+        _In_                        int       code_page,
+        _In_                        BOOL      bError
+        )
+{
+    // LCMapString will map past the null terminator.  We must find the null
+    // terminator if it occurs in the string before cchSrc characters
+    // and cap the number of characters to be considered.
+    if (cchSrc > 0)
+    {
+        int cchSrcCnt = static_cast<int>(__strncnt(lpSrcStr, cchSrc));
+
+        // Include the null terminator if the source string is terminated within
+        // the buffer.
+        if (cchSrcCnt < cchSrc)
+        {
+            cchSrc = cchSrcCnt + 1;
+        }
+        else
+        {
+            cchSrc = cchSrcCnt;
+        }
+    }
+
+    int retval = 0;
+    int inbuff_size;
+    int outbuff_size;
+
+    /*
+     * Convert string and return the requested information. Note that
+     * we are converting to a wide string so there is not a
+     * one-to-one correspondence between number of wide chars in the
+     * input string and the number of *bytes* in the buffer. However,
+     * there had *better be* a one-to-one correspondence between the
+     * number of wide characters and the number of multibyte characters
+     * or the resulting mapped string will be worthless to the user.
+     */
+
+    /*
+     * Use __lc_codepage for conversion if code_page not specified
+     */
+
+    if (0 == code_page)
+        code_page = plocinfo->locinfo->_public._locale_lc_codepage;
+
+    /* find out how big a buffer we need (includes nullptr if any) */
+    if ( 0 == (inbuff_size =
+               __acrt_MultiByteToWideChar( code_page,
+                                           bError ? MB_PRECOMPOSED |
+                                               MB_ERR_INVALID_CHARS :
+                                               MB_PRECOMPOSED,
+                                           lpSrcStr,
+                                           cchSrc,
+                                           nullptr,
+                                           0 )) )
+        return 0;
+
+    /* allocate enough space for wide chars */
+    __crt_scoped_stack_ptr<wchar_t> const inwbuffer(_malloca_crt_t(wchar_t, inbuff_size));
+    if (!inwbuffer)
+        return 0;
+
+    /* do the conversion */
+    if ( 0 == __acrt_MultiByteToWideChar( code_page,
+                                          MB_PRECOMPOSED,
+                                          lpSrcStr,
+                                          cchSrc,
+                                          inwbuffer.get(),
+                                          inbuff_size) )
+        return retval;
+
+    /* get size required for string mapping */
+    if ( 0 == (retval = __acrt_LCMapStringEx( LocaleName,
+                                              dwMapFlags,
+                                              inwbuffer.get(),
+                                              inbuff_size,
+                                              nullptr,
+                                              0,
+                                              nullptr,
+                                              nullptr,
+                                              0)) )
+        return retval;
+
+    if (dwMapFlags & LCMAP_SORTKEY) {
+        /* retval is size in BYTES */
+
+        if (0 != cchDest) {
+
+            if (retval > cchDest)
+                return 0;
+
+            /* do string mapping */
+            // The buffer overflow warning here is due to an inadequate annotation
+            // on __acrt_LCMapStringEx.  When the map flags include LCMAP_SORTKEY,
+            // the destination buffer is actually required to be an array of bytes,
+            // despite the type of the buffer being a wchar_t*.
+            __pragma(warning(suppress: __WARNING_BUFFER_OVERFLOW))
+            if ( 0 == (retval = __acrt_LCMapStringEx( LocaleName,
+                                    dwMapFlags,
+                                    inwbuffer.get(),
+                                    inbuff_size,
+                                    reinterpret_cast<PWCH>(lpDestStr),
+                                    cchDest,
+                                    nullptr,
+                                    nullptr,
+                                    0)) )
+                return retval;
+        }
+    }
+    else {
+        /* retval is size in wide chars */
+
+        outbuff_size = retval;
+
+        /* allocate enough space for wide chars (includes nullptr if any) */
+        __crt_scoped_stack_ptr<wchar_t> const outwbuffer(_malloca_crt_t(wchar_t, outbuff_size));
+        if (!outwbuffer)
+            return 0;
+
+        /* do string mapping */
+        if ( 0 == (retval = __acrt_LCMapStringEx( LocaleName,
+                                dwMapFlags,
+                                inwbuffer.get(),
+                                inbuff_size,
+                                outwbuffer.get(),
+                                outbuff_size,
+                                nullptr,
+                                nullptr,
+                                0)) )
+            return retval;
+
+        if (0 == cchDest) {
+            /* get size required */
+            if ( 0 == (retval =
+                       __acrt_WideCharToMultiByte( code_page,
+                                                   0,
+                                                   outwbuffer.get(),
+                                                   outbuff_size,
+                                                   nullptr,
+                                                   0,
+                                                   nullptr,
+                                                   nullptr )) )
+                return retval;
+        }
+        else {
+            /* convert mapping */
+            if ( 0 == (retval =
+                       __acrt_WideCharToMultiByte( code_page,
+                                                   0,
+                                                   outwbuffer.get(),
+                                                   outbuff_size,
+                                                   lpDestStr,
+                                                   cchDest,
+                                                   nullptr,
+                                                   nullptr )) )
+                return retval;
+        }
+    }
+
+    return retval;
+}
+
+extern "C" int __cdecl __acrt_LCMapStringA(
+        _locale_t const plocinfo,
+        PCWSTR    const LocaleName,
+        DWORD     const dwMapFlags,
+        PCCH      const lpSrcStr,
+        int       const cchSrc,
+        PCH       const lpDestStr,
+        int       const cchDest,
+        int       const code_page,
+        BOOL      const bError
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return __acrt_LCMapStringA_stat(
+            _loc_update.GetLocaleT(),
+            LocaleName,
+            dwMapFlags,
+            lpSrcStr,
+            cchSrc,
+            lpDestStr,
+            cchDest,
+            code_page,
+            bError
+            );
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringW.cpp

@@ -0,0 +1,74 @@
+/***
+*w_map.c - W version of LCMapString.
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Wrapper for LCMapStringW.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+
+/***
+*int __cdecl __acrt_LCMapStringW - Get type information about a wide string.
+*
+*Purpose:
+*       Internal support function. Assumes info in wide string format.
+*
+*Entry:
+*       LPCWSTR  LocaleName  - locale context for the comparison.
+*       DWORD    dwMapFlags  - see NT\Chicago docs
+*       LPCWSTR  lpSrcStr    - pointer to string to be mapped
+*       int      cchSrc      - wide char (word) count of input string
+*                              (including nullptr if any)
+*                              (-1 if nullptr terminated)
+*       LPWSTR   lpDestStr   - pointer to memory to store mapping
+*       int      cchDest     - wide char (word) count of buffer (including nullptr)
+*
+*       NOTE:    if LCMAP_SORTKEY is specified, then cchDest refers to number
+*                of BYTES, not number of wide chars. The return string will be
+*                a series of bytes with a nullptr byte terminator.
+*
+*Exit:
+*       Success: if LCMAP_SORKEY:
+*                   number of bytes written to lpDestStr (including nullptr byte
+*                   terminator)
+*               else
+*                   number of wide characters written to lpDestStr (including
+*                   nullptr)
+*       Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl __acrt_LCMapStringW(
+    LPCWSTR const locale_name,
+    DWORD   const map_flags,
+    LPCWSTR const source,
+    int           source_count,
+    LPWSTR  const destination,
+    int     const destination_count
+    )
+{
+    // LCMapString will map past the null terminator.  We must find the null
+    // terminator if it occurs in the string before source_count characters
+    // and cap the number of characters to be considered.
+    if (source_count > 0)
+    {
+        int const source_length = static_cast<int>(wcsnlen(source, source_count));
+
+        // Include the null terminator if the source string is terminated within
+        // the buffer.
+        if (source_length < source_count)
+        {
+            source_count = source_length + 1;
+        }
+        else
+        {
+            source_count = source_length;
+        }
+    }
+
+    return __acrt_LCMapStringEx(locale_name, map_flags, source, source_count, destination, destination_count, nullptr, nullptr, 0);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/ctype.cpp

@@ -0,0 +1,745 @@
+//
+// ctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of the character classification data used by the character
+// classification macros in <ctype.h>.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+
+
+
+extern "C" unsigned short const* __cdecl __pwctype_func()
+{
+    return _pwctype;
+}
+
+extern "C" unsigned short const* __cdecl __pctype_func()
+{
+    // This is a leaf function and thus use of _LocaleUpdate is not required.
+    __acrt_ptd* const ptd{__acrt_getptd()};
+    __crt_locale_data* locale_info{ptd->_locale_info};
+
+    __acrt_update_locale_info(ptd, &locale_info);
+    return locale_info->_public._locale_pctype;
+}
+
+
+
+// NOTE:  The characteristics stored in this lookup table are not always
+// consistent with what is required by C.  For example, GetStringTypeW returns
+// _DIGIT and _PUNCT for U+00B2 and U+00B3 (SUBSCRIPT TWO and SUBSCRIPT THREE),
+// but these categories are mutually exclusive in C.  We have chosen to
+// implement this lookup table for consistency with GetStringTypeW, rather than
+// try to implement something completely different.  We expect this is sufficient,
+// as C character classification does not map well to Unicode.
+extern "C" extern unsigned short const _wctype[]
+{
+    0,                              // -1 EOF
+    _CONTROL ,                      // 00 (NUL)
+    _CONTROL ,                      // 01 (SOH)
+    _CONTROL ,                      // 02 (STX)
+    _CONTROL ,                      // 03 (ETX)
+    _CONTROL ,                      // 04 (EOT)
+    _CONTROL ,                      // 05 (ENQ)
+    _CONTROL ,                      // 06 (ACK)
+    _CONTROL ,                      // 07 (BEL)
+    _CONTROL ,                      // 08 (BS)
+    // \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.
+    _SPACE | _CONTROL ,             // 09 (HT)
+    _SPACE | _CONTROL ,             // 0A (LF)
+    _SPACE | _CONTROL ,             // 0B (VT)
+    _SPACE | _CONTROL ,             // 0C (FF)
+    _SPACE | _CONTROL ,             // 0D (CR)
+    _CONTROL ,                      // 0E (SI)
+    _CONTROL ,                      // 0F (SO)
+    _CONTROL ,                      // 10 (DLE)
+    _CONTROL ,                      // 11 (DC1)
+    _CONTROL ,                      // 12 (DC2)
+    _CONTROL ,                      // 13 (DC3)
+    _CONTROL ,                      // 14 (DC4)
+    _CONTROL ,                      // 15 (NAK)
+    _CONTROL ,                      // 16 (SYN)
+    _CONTROL ,                      // 17 (ETB)
+    _CONTROL ,                      // 18 (CAN)
+    _CONTROL ,                      // 19 (EM)
+    _CONTROL ,                      // 1A (SUB)
+    _CONTROL ,                      // 1B (ESC)
+    _CONTROL ,                      // 1C (FS)
+    _CONTROL ,                      // 1D (GS)
+    _CONTROL ,                      // 1E (RS)
+    _CONTROL ,                      // 1F (US)
+    _SPACE | _BLANK ,               // 20 SPACE
+    _PUNCT ,                        // 21 !
+    _PUNCT ,                        // 22 "
+    _PUNCT ,                        // 23 #
+    _PUNCT ,                        // 24 $
+    _PUNCT ,                        // 25 %
+    _PUNCT ,                        // 26 &
+    _PUNCT ,                        // 27 '
+    _PUNCT ,                        // 28 (
+    _PUNCT ,                        // 29 )
+    _PUNCT ,                        // 2A *
+    _PUNCT ,                        // 2B +
+    _PUNCT ,                        // 2C ,
+    _PUNCT ,                        // 2D -
+    _PUNCT ,                        // 2E .
+    _PUNCT ,                        // 2F /
+    _DIGIT | _HEX ,                 // 30 0
+    _DIGIT | _HEX ,                 // 31 1
+    _DIGIT | _HEX ,                 // 32 2
+    _DIGIT | _HEX ,                 // 33 3
+    _DIGIT | _HEX ,                 // 34 4
+    _DIGIT | _HEX ,                 // 35 5
+    _DIGIT | _HEX ,                 // 36 6
+    _DIGIT | _HEX ,                 // 37 7
+    _DIGIT | _HEX ,                 // 38 8
+    _DIGIT | _HEX ,                 // 39 9
+    _PUNCT ,                        // 3A :
+    _PUNCT ,                        // 3B ;
+    _PUNCT ,                        // 3C <
+    _PUNCT ,                        // 3D =
+    _PUNCT ,                        // 3E >
+    _PUNCT ,                        // 3F ?
+    _PUNCT ,                        // 40 @
+    _UPPER | _HEX | C1_ALPHA ,      // 41 A
+    _UPPER | _HEX | C1_ALPHA ,      // 42 B
+    _UPPER | _HEX | C1_ALPHA ,      // 43 C
+    _UPPER | _HEX | C1_ALPHA ,      // 44 D
+    _UPPER | _HEX | C1_ALPHA ,      // 45 E
+    _UPPER | _HEX | C1_ALPHA ,      // 46 F
+    _UPPER | C1_ALPHA ,             // 47 G
+    _UPPER | C1_ALPHA ,             // 48 H
+    _UPPER | C1_ALPHA ,             // 49 I
+    _UPPER | C1_ALPHA ,             // 4A J
+    _UPPER | C1_ALPHA ,             // 4B K
+    _UPPER | C1_ALPHA ,             // 4C L
+    _UPPER | C1_ALPHA ,             // 4D M
+    _UPPER | C1_ALPHA ,             // 4E N
+    _UPPER | C1_ALPHA ,             // 4F O
+    _UPPER | C1_ALPHA ,             // 50 P
+    _UPPER | C1_ALPHA ,             // 51 Q
+    _UPPER | C1_ALPHA ,             // 52 R
+    _UPPER | C1_ALPHA ,             // 53 S
+    _UPPER | C1_ALPHA ,             // 54 T
+    _UPPER | C1_ALPHA ,             // 55 U
+    _UPPER | C1_ALPHA ,             // 56 V
+    _UPPER | C1_ALPHA ,             // 57 W
+    _UPPER | C1_ALPHA ,             // 58 X
+    _UPPER | C1_ALPHA ,             // 59 Y
+    _UPPER | C1_ALPHA ,             // 5A Z
+    _PUNCT ,                        // 5B [
+    _PUNCT ,                        // 5C \ 
+    _PUNCT ,                        // 5D ]
+    _PUNCT ,                        // 5E ^
+    _PUNCT ,                        // 5F _
+    _PUNCT ,                        // 60 `
+    _LOWER | _HEX | C1_ALPHA ,      // 61 a
+    _LOWER | _HEX | C1_ALPHA ,      // 62 b
+    _LOWER | _HEX | C1_ALPHA ,      // 63 c
+    _LOWER | _HEX | C1_ALPHA ,      // 64 d
+    _LOWER | _HEX | C1_ALPHA ,      // 65 e
+    _LOWER | _HEX | C1_ALPHA ,      // 66 f
+    _LOWER | C1_ALPHA ,             // 67 g
+    _LOWER | C1_ALPHA ,             // 68 h
+    _LOWER | C1_ALPHA ,             // 69 i
+    _LOWER | C1_ALPHA ,             // 6A j
+    _LOWER | C1_ALPHA ,             // 6B k
+    _LOWER | C1_ALPHA ,             // 6C l
+    _LOWER | C1_ALPHA ,             // 6D m
+    _LOWER | C1_ALPHA ,             // 6E n
+    _LOWER | C1_ALPHA ,             // 6F o
+    _LOWER | C1_ALPHA ,             // 70 p
+    _LOWER | C1_ALPHA ,             // 71 q
+    _LOWER | C1_ALPHA ,             // 72 r
+    _LOWER | C1_ALPHA ,             // 73 s
+    _LOWER | C1_ALPHA ,             // 74 t
+    _LOWER | C1_ALPHA ,             // 75 u
+    _LOWER | C1_ALPHA ,             // 76 v
+    _LOWER | C1_ALPHA ,             // 77 w
+    _LOWER | C1_ALPHA ,             // 78 x
+    _LOWER | C1_ALPHA ,             // 79 y
+    _LOWER | C1_ALPHA ,             // 7A z
+    _PUNCT ,                        // 7B {
+    _PUNCT ,                        // 7C |
+    _PUNCT ,                        // 7D }
+    _PUNCT ,                        // 7E ~
+    _CONTROL ,                      // 7F (DEL)
+    _CONTROL ,                      // 80 (XXX)
+    _CONTROL ,                      // 81 (XXX)
+    _CONTROL ,                      // 82 (BPH / BREAK PERMITTED HERE)
+    _CONTROL ,                      // 83 (NBH / NO BREAK HERE)
+    _CONTROL ,                      // 84 (IND / formerly known as INDEX)
+    _SPACE | _CONTROL ,             // 85 (NEL / NEXT LINE)
+    _CONTROL ,                      // 86 (SSA / START OF SELCETED AREA)
+    _CONTROL ,                      // 87 (ESA / END OF SELECTED AREA)
+    _CONTROL ,                      // 88 (HTS / CHARACTER TABULATION SET)
+    _CONTROL ,                      // 89 (HTJ / CHARACTER TABULATION WITH JUSTIFICATION)
+    _CONTROL ,                      // 8A (VTS / LINE TABULATION SET)
+    _CONTROL ,                      // 8B (PLD / PARTIAL LINE FORWARD)
+    _CONTROL ,                      // 8C (PLU / PARTIAL LINE BACKWARD)
+    _CONTROL ,                      // 8D (RI  / REVERSE LINE FEED)
+    _CONTROL ,                      // 8E (SS2 / SINGLE SHIFT TWO)
+    _CONTROL ,                      // 8F (SS3 / SINGLE SHIFT THREE)
+    _CONTROL ,                      // 90 (DCS / DEVICE CONTROL STRING)
+    _CONTROL ,                      // 91 (PU1 / PRIVATE USE ONE)
+    _CONTROL ,                      // 92 (PU2 / PRIVATE USE TWO)
+    _CONTROL ,                      // 93 (STS / SET TRANSMIT STATE)
+    _CONTROL ,                      // 94 (CCH / CANCEL CHARACTER)
+    _CONTROL ,                      // 95 (MW  / MESSAGE WAITING)
+    _CONTROL ,                      // 96 (SPA / START OF GUARDED AREA)
+    _CONTROL ,                      // 97 (EPA / END OF GUARDED AREA)
+    _CONTROL ,                      // 98 (SOS / START OF STRING)
+    _CONTROL ,                      // 99 (XXX)
+    _CONTROL ,                      // 9A (SCI / SINGLE CHARACTER INTRODUCER)
+    _CONTROL ,                      // 9B (CSI / CONTROL SEQUENCE INTRODUCER)
+    _CONTROL ,                      // 9C (ST  / STRING TERMINATOR)
+    _CONTROL ,                      // 9D (OSC / OPERATING SYSTEM COMMAND)
+    _CONTROL ,                      // 9E (PM  / PRIVACY MESSAGE)
+    _CONTROL ,                      // 9F (APC / APPLICATION PROGRAM COMMAND)
+    _SPACE ,                        // A0 (NBSP / NO-BREAK SPACE)
+    _PUNCT ,                        // A1 (INVERTED EXCLAMATION MARK)
+    _PUNCT ,                        // A2 (CENT SIGN)
+    _PUNCT ,                        // A3 (POUND SIGN)
+    _PUNCT ,                        // A4 (CURRENCY SIGN)
+    _PUNCT ,                        // A5 (YEN SIGN)
+    _PUNCT ,                        // A6 (BROKEN BAR)
+    _PUNCT ,                        // A7 (SECTION SIGN)
+    _PUNCT ,                        // A8 (DIAERESIS)
+    _PUNCT ,                        // A9 (COPYRIGHT SIGN)
+    _LOWER | _PUNCT | C1_ALPHA,     // AA (FEMININE ORDINAL INDICATOR)
+    _PUNCT ,                        // AB (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+    _PUNCT ,                        // AC (NOT SIGN)
+    _PUNCT | _CONTROL ,             // AD (SOFT HYPHEN)
+    _PUNCT ,                        // AE (REGISTERED SIGN)
+    _PUNCT ,                        // AF (MACRON)
+    _PUNCT ,                        // B0 (DEGREE SIGN)
+    _PUNCT ,                        // B1 (PLUS-MINUS SIGN)
+    _DIGIT | _PUNCT ,               // B2 (SUPERSCRIPT TWO)
+    _DIGIT | _PUNCT ,               // B3 (SUPERSCRIPT THREE)
+    _PUNCT ,                        // B4 (ACUTE ACCENT)
+    _LOWER | _PUNCT | C1_ALPHA,     // B5 (MICRO SIGN)
+    _PUNCT ,                        // B6 (PILCROW SIGN)
+    _PUNCT ,                        // B7 (MIDDLE DOT)
+    _PUNCT ,                        // B8 (CEDILLA)
+    _DIGIT | _PUNCT ,               // B9 (SUPERSCRIPT ONE)
+    _LOWER | _PUNCT | C1_ALPHA,     // BA (MASCULINE ORDINAL INDICATOR)
+    _PUNCT ,                        // BB (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+    _PUNCT ,                        // BC (VULGAR FRACTION ONE QUARTER)
+    _PUNCT ,                        // BD (VULGAR FRACTION ONE HALF)
+    _PUNCT ,                        // BE (VULGAR FRACTION THREE QUARTERS)
+    _PUNCT ,                        // BF (INVERTED QUESTION MARK)
+    _UPPER | C1_ALPHA ,             // C0 (LATIN CAPTIAL LETTER A WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // C1 (LATIN CAPITAL LETTER A WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // C2 (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // C3 (LATIN CAPITAL LETTER A WITH TILDE)
+    _UPPER | C1_ALPHA ,             // C4 (LATIN CAPITAL LETTER A WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             // C5 (LATIN CAPITAL LETTER A WITH RING ABOVE)
+    _UPPER | C1_ALPHA ,             // C6 (LATIN CAPITAL LETTER AE)
+    _UPPER | C1_ALPHA ,             // C7 (LATIN CAPITAL LETTER C WITH CEDILLA)
+    _UPPER | C1_ALPHA ,             // C8 (LATIN CAPITAL LETTER E WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // C9 (LATIN CAPITAL LETTER E WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // CA (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // CB (LATIN CAPITAL LETTER E WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             // CC (LATIN CAPITAL LETTER I WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // CD (LATIN CAPITAL LETTER I WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // CE (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // CF (LATIN CAPITAL LETTER I WITH DIAERESIS
+    _UPPER | C1_ALPHA ,             // D0 (LATIN CAPITAL LETTER ETH)
+    _UPPER | C1_ALPHA ,             // D1 (LATIN CAPITAL LETTER N WITH TILDE)
+    _UPPER | C1_ALPHA ,             // D2 (LATIN CAPITAL LETTER O WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // D3 (LATIN CAPITAL LETTER O WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // D4 (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // D5 (LATIN CAPITAL LETTER O WITH TILDE)
+    _UPPER | C1_ALPHA ,             // D6 (LATIN CAPITAL LETTER O WITH DIAERESIS)
+    _PUNCT ,                        // D7 (MULTIPLICATION SIGN)
+    _UPPER | C1_ALPHA ,             // D8 (LATIN CAPITAL LETTER O WITH STROKE)
+    _UPPER | C1_ALPHA ,             // D9 (LATIN CAPITAL LETTER U WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // DA (LATIN CAPITAL LETTER U WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // DB (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // DC (LATIN CAPITAL LETTER U WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             // DD (LATIN CAPITAL LETTER Y WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // DE (LATIN CAPITAL LETTER THORN)
+    _LOWER | C1_ALPHA ,             // DF (LATIN SMALL LETTER SHARP S)
+    _LOWER | C1_ALPHA ,             // E0 (LATIN SMALL LETTER A WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // E1 (LATIN SMALL LETTER A WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // E2 (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // E3 (LATIN SMALL LETTER A WITH TILDE)
+    _LOWER | C1_ALPHA ,             // E4 (LATIN SMALL LETTER A WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // E5 (LATIN SMALL LETTER A WITH RING ABOVE)
+    _LOWER | C1_ALPHA ,             // E6 (LATIN SMALL LETTER AE)
+    _LOWER | C1_ALPHA ,             // E7 (LATIN SMALL LETTER C WITH CEDILLA)
+    _LOWER | C1_ALPHA ,             // E8 (LATIN SMALL LETTER E WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // E9 (LATIN SMALL LETTER E WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // EA (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // EB (LATIN SMALL LETTER E WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // EC (LATIN SMALL LETTER I WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // ED (LATIN SMALL LETTER I WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // EE (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // EF (LATIN SMALL LETTER I WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // F0 (LATIN SMALL LETTER ETH)
+    _LOWER | C1_ALPHA ,             // F1 (LATIN SMALL LETTER N WITH TILDE)
+    _LOWER | C1_ALPHA ,             // F2 (LATIN SMALL LETTER O WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // F3 (LATIN SMALL LETTER O WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // F4 (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // F5 (LATIN SMALL LETTER O WITH TILDE)
+    _LOWER | C1_ALPHA ,             // F6 (LATIN SMALL LETTER O WITH DIAERESIS)
+    _PUNCT ,                        // F7 (DIVISION SIGN)
+    _LOWER | C1_ALPHA ,             // F8 (LATIN SMALL LETTER O WITH STROKE)
+    _LOWER | C1_ALPHA ,             // F9 (LATIN SMALL LETTER U WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // FA (LATIN SMALL LETTER U WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // FB (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // FC (LATIN SMALL LETTER U WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // FD (LATIN SMALL LETTER Y WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // FE (LATIN SMALL LETTER THORN)
+    _LOWER | C1_ALPHA ,             // FF (LATIN SMALL LETTER Y WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             //100 (LATIN CAPITAL LETTER A WITH MACRON)
+};
+
+extern "C" extern unsigned short const __newctype[384]
+{
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0,
+    0,                         // -1 EOF
+    _CONTROL,                  // 00 (NUL)
+    _CONTROL,                  // 01 (SOH)
+    _CONTROL,                  // 02 (STX)
+    _CONTROL,                  // 03 (ETX)
+    _CONTROL,                  // 04 (EOT)
+    _CONTROL,                  // 05 (ENQ)
+    _CONTROL,                  // 06 (ACK)
+    _CONTROL,                  // 07 (BEL)
+    _CONTROL,                  // 08 (BS)
+    // \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.
+    _SPACE+_CONTROL,           // 09 (HT)
+    _SPACE+_CONTROL,           // 0A (LF)
+    _SPACE+_CONTROL,           // 0B (VT)
+    _SPACE+_CONTROL,           // 0C (FF)
+    _SPACE+_CONTROL,           // 0D (CR)
+    _CONTROL,                  // 0E (SI)
+    _CONTROL,                  // 0F (SO)
+    _CONTROL,                  // 10 (DLE)
+    _CONTROL,                  // 11 (DC1)
+    _CONTROL,                  // 12 (DC2)
+    _CONTROL,                  // 13 (DC3)
+    _CONTROL,                  // 14 (DC4)
+    _CONTROL,                  // 15 (NAK)
+    _CONTROL,                  // 16 (SYN)
+    _CONTROL,                  // 17 (ETB)
+    _CONTROL,                  // 18 (CAN)
+    _CONTROL,                  // 19 (EM)
+    _CONTROL,                  // 1A (SUB)
+    _CONTROL,                  // 1B (ESC)
+    _CONTROL,                  // 1C (FS)
+    _CONTROL,                  // 1D (GS)
+    _CONTROL,                  // 1E (RS)
+    _CONTROL,                  // 1F (US)
+    _SPACE+_BLANK,             // 20 SPACE
+    _PUNCT,                    // 21 !
+    _PUNCT,                    // 22 "
+    _PUNCT,                    // 23 #
+    _PUNCT,                    // 24 $
+    _PUNCT,                    // 25 %
+    _PUNCT,                    // 26 &
+    _PUNCT,                    // 27 '
+    _PUNCT,                    // 28 (
+    _PUNCT,                    // 29 )
+    _PUNCT,                    // 2A *
+    _PUNCT,                    // 2B +
+    _PUNCT,                    // 2C ,
+    _PUNCT,                    // 2D -
+    _PUNCT,                    // 2E .
+    _PUNCT,                    // 2F /
+    _DIGIT+_HEX,               // 30 0
+    _DIGIT+_HEX,               // 31 1
+    _DIGIT+_HEX,               // 32 2
+    _DIGIT+_HEX,               // 33 3
+    _DIGIT+_HEX,               // 34 4
+    _DIGIT+_HEX,               // 35 5
+    _DIGIT+_HEX,               // 36 6
+    _DIGIT+_HEX,               // 37 7
+    _DIGIT+_HEX,               // 38 8
+    _DIGIT+_HEX,               // 39 9
+    _PUNCT,                    // 3A :
+    _PUNCT,                    // 3B ;
+    _PUNCT,                    // 3C <
+    _PUNCT,                    // 3D =
+    _PUNCT,                    // 3E >
+    _PUNCT,                    // 3F ?
+    _PUNCT,                    // 40 @
+    _UPPER+_HEX,               // 41 A
+    _UPPER+_HEX,               // 42 B
+    _UPPER+_HEX,               // 43 C
+    _UPPER+_HEX,               // 44 D
+    _UPPER+_HEX,               // 45 E
+    _UPPER+_HEX,               // 46 F
+    _UPPER,                    // 47 G
+    _UPPER,                    // 48 H
+    _UPPER,                    // 49 I
+    _UPPER,                    // 4A J
+    _UPPER,                    // 4B K
+    _UPPER,                    // 4C L
+    _UPPER,                    // 4D M
+    _UPPER,                    // 4E N
+    _UPPER,                    // 4F O
+    _UPPER,                    // 50 P
+    _UPPER,                    // 51 Q
+    _UPPER,                    // 52 R
+    _UPPER,                    // 53 S
+    _UPPER,                    // 54 T
+    _UPPER,                    // 55 U
+    _UPPER,                    // 56 V
+    _UPPER,                    // 57 W
+    _UPPER,                    // 58 X
+    _UPPER,                    // 59 Y
+    _UPPER,                    // 5A Z
+    _PUNCT,                    // 5B [
+    _PUNCT,                    // 5C \ backslash
+    _PUNCT,                    // 5D ]
+    _PUNCT,                    // 5E ^
+    _PUNCT,                    // 5F _
+    _PUNCT,                    // 60 `
+    _LOWER+_HEX,               // 61 a
+    _LOWER+_HEX,               // 62 b
+    _LOWER+_HEX,               // 63 c
+    _LOWER+_HEX,               // 64 d
+    _LOWER+_HEX,               // 65 e
+    _LOWER+_HEX,               // 66 f
+    _LOWER,                    // 67 g
+    _LOWER,                    // 68 h
+    _LOWER,                    // 69 i
+    _LOWER,                    // 6A j
+    _LOWER,                    // 6B k
+    _LOWER,                    // 6C l
+    _LOWER,                    // 6D m
+    _LOWER,                    // 6E n
+    _LOWER,                    // 6F o
+    _LOWER,                    // 70 p
+    _LOWER,                    // 71 q
+    _LOWER,                    // 72 r
+    _LOWER,                    // 73 s
+    _LOWER,                    // 74 t
+    _LOWER,                    // 75 u
+    _LOWER,                    // 76 v
+    _LOWER,                    // 77 w
+    _LOWER,                    // 78 x
+    _LOWER,                    // 79 y
+    _LOWER,                    // 7A z
+    _PUNCT,                    // 7B {
+    _PUNCT,                    // 7C |
+    _PUNCT,                    // 7D }
+    _PUNCT,                    // 7E ~
+    _CONTROL,                  // 7F (DEL)
+    // and the rest are 0...
+};
+
+extern "C" extern unsigned char const __newclmap[384]
+{
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+    0x00,   // 00 (NUL)
+    0x01,   // 01 (SOH)
+    0x02,   // 02 (STX)
+    0x03,   // 03 (ETX)
+    0x04,   // 04 (EOT)
+    0x05,   // 05 (ENQ)
+    0x06,   // 06 (ACK)
+    0x07,   // 07 (BEL)
+    0x08,   // 08 (BS)
+    0x09,   // 09 (HT)
+    0x0A,   // 0A (LF)
+    0x0B,   // 0B (VT)
+    0x0C,   // 0C (FF)
+    0x0D,   // 0D (CR)
+    0x0E,   // 0E (SI)
+    0x0F,   // 0F (SO)
+    0x10,   // 10 (DLE)
+    0x11,   // 11 (DC1)
+    0x12,   // 12 (DC2)
+    0x13,   // 13 (DC3)
+    0x14,   // 14 (DC4)
+    0x15,   // 15 (NAK)
+    0x16,   // 16 (SYN)
+    0x17,   // 17 (ETB)
+    0x18,   // 18 (CAN)
+    0x19,   // 19 (EM)
+    0x1A,   // 1A (SUB)
+    0x1B,   // 1B (ESC)
+    0x1C,   // 1C (FS)
+    0x1D,   // 1D (GS)
+    0x1E,   // 1E (RS)
+    0x1F,   // 1F (US)
+    0x20,   // 20 SPACE
+    0x21,   // 21 !
+    0x22,   // 22 "
+    0x23,   // 23 #
+    0x24,   // 24 $
+    0x25,   // 25 %
+    0x26,   // 26 &
+    0x27,   // 27 '
+    0x28,   // 28 (
+    0x29,   // 29 )
+    0x2A,   // 2A *
+    0x2B,   // 2B +
+    0x2C,   // 2C ,
+    0x2D,   // 2D -
+    0x2E,   // 2E .
+    0x2F,   // 2F /
+    0x30,   // 30 0
+    0x31,   // 31 1
+    0x32,   // 32 2
+    0x33,   // 33 3
+    0x34,   // 34 4
+    0x35,   // 35 5
+    0x36,   // 36 6
+    0x37,   // 37 7
+    0x38,   // 38 8
+    0x39,   // 39 9
+    0x3A,   // 3A :
+    0x3B,   // 3B ;
+    0x3C,   // 3C <
+    0x3D,   // 3D =
+    0x3E,   // 3E >
+    0x3F,   // 3F ?
+    0x40,   // 40 @
+    0x61,   // 41 A
+    0x62,   // 42 B
+    0x63,   // 43 C
+    0x64,   // 44 D
+    0x65,   // 45 E
+    0x66,   // 46 F
+    0x67,   // 47 G
+    0x68,   // 48 H
+    0x69,   // 49 I
+    0x6A,   // 4A J
+    0x6B,   // 4B K
+    0x6C,   // 4C L
+    0x6D,   // 4D M
+    0x6E,   // 4E N
+    0x6F,   // 4F O
+    0x70,   // 50 P
+    0x71,   // 51 Q
+    0x72,   // 52 R
+    0x73,   // 53 S
+    0x74,   // 54 T
+    0x75,   // 55 U
+    0x76,   // 56 V
+    0x77,   // 57 W
+    0x78,   // 58 X
+    0x79,   // 59 Y
+    0x7A,   // 5A Z
+    0x5B,   // 5B [
+    0x5C,   // 5C \ 
+    0x5D,   // 5D ]
+    0x5E,   // 5E ^
+    0x5F,   // 5F _
+    0x60,   // 60 `
+    0x61,   // 61 a
+    0x62,   // 62 b
+    0x63,   // 63 c
+    0x64,   // 64 d
+    0x65,   // 65 e
+    0x66,   // 66 f
+    0x67,   // 67 g
+    0x68,   // 68 h
+    0x69,   // 69 i
+    0x6A,   // 6A j
+    0x6B,   // 6B k
+    0x6C,   // 6C l
+    0x6D,   // 6D m
+    0x6E,   // 6E n
+    0x6F,   // 6F o
+    0x70,   // 70 p
+    0x71,   // 71 q
+    0x72,   // 72 r
+    0x73,   // 73 s
+    0x74,   // 74 t
+    0x75,   // 75 u
+    0x76,   // 76 v
+    0x77,   // 77 w
+    0x78,   // 78 x
+    0x79,   // 79 y
+    0x7A,   // 7A z
+    0x7B,   // 7B {
+    0x7C,   // 7C |
+    0x7D,   // 7D }
+    0x7E,   // 7E ~
+    0x7F,   // 7F (DEL)
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+extern "C" extern unsigned char const __newcumap[384]
+{
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+    0x00,   // 00 (NUL)
+    0x01,   // 01 (SOH)
+    0x02,   // 02 (STX)
+    0x03,   // 03 (ETX)
+    0x04,   // 04 (EOT)
+    0x05,   // 05 (ENQ)
+    0x06,   // 06 (ACK)
+    0x07,   // 07 (BEL)
+    0x08,   // 08 (BS)
+    0x09,   // 09 (HT)
+    0x0A,   // 0A (LF)
+    0x0B,   // 0B (VT)
+    0x0C,   // 0C (FF)
+    0x0D,   // 0D (CR)
+    0x0E,   // 0E (SI)
+    0x0F,   // 0F (SO)
+    0x10,   // 10 (DLE)
+    0x11,   // 11 (DC1)
+    0x12,   // 12 (DC2)
+    0x13,   // 13 (DC3)
+    0x14,   // 14 (DC4)
+    0x15,   // 15 (NAK)
+    0x16,   // 16 (SYN)
+    0x17,   // 17 (ETB)
+    0x18,   // 18 (CAN)
+    0x19,   // 19 (EM)
+    0x1A,   // 1A (SUB)
+    0x1B,   // 1B (ESC)
+    0x1C,   // 1C (FS)
+    0x1D,   // 1D (GS)
+    0x1E,   // 1E (RS)
+    0x1F,   // 1F (US)
+    0x20,   // 20 SPACE
+    0x21,   // 21 !
+    0x22,   // 22 "
+    0x23,   // 23 #
+    0x24,   // 24 $
+    0x25,   // 25 %
+    0x26,   // 26 &
+    0x27,   // 27 '
+    0x28,   // 28 (
+    0x29,   // 29 )
+    0x2A,   // 2A *
+    0x2B,   // 2B +
+    0x2C,   // 2C ,
+    0x2D,   // 2D -
+    0x2E,   // 2E .
+    0x2F,   // 2F /
+    0x30,   // 30 0
+    0x31,   // 31 1
+    0x32,   // 32 2
+    0x33,   // 33 3
+    0x34,   // 34 4
+    0x35,   // 35 5
+    0x36,   // 36 6
+    0x37,   // 37 7
+    0x38,   // 38 8
+    0x39,   // 39 9
+    0x3A,   // 3A :
+    0x3B,   // 3B ;
+    0x3C,   // 3C <
+    0x3D,   // 3D =
+    0x3E,   // 3E >
+    0x3F,   // 3F ?
+    0x40,   // 40 @
+    0x41,   // 41 A
+    0x42,   // 42 B
+    0x43,   // 43 C
+    0x44,   // 44 D
+    0x45,   // 45 E
+    0x46,   // 46 F
+    0x47,   // 47 G
+    0x48,   // 48 H
+    0x49,   // 49 I
+    0x4A,   // 4A J
+    0x4B,   // 4B K
+    0x4C,   // 4C L
+    0x4D,   // 4D M
+    0x4E,   // 4E N
+    0x4F,   // 4F O
+    0x50,   // 50 P
+    0x51,   // 51 Q
+    0x52,   // 52 R
+    0x53,   // 53 S
+    0x54,   // 54 T
+    0x55,   // 55 U
+    0x56,   // 56 V
+    0x57,   // 57 W
+    0x58,   // 58 X
+    0x59,   // 59 Y
+    0x5A,   // 5A Z
+    0x5B,   // 5B [
+    0x5C,   // 5C \ 
+    0x5D,   // 5D ]
+    0x5E,   // 5E ^
+    0x5F,   // 5F _
+    0x60,   // 60 `
+    0x41,   // 61 a
+    0x42,   // 62 b
+    0x43,   // 63 c
+    0x44,   // 64 d
+    0x45,   // 65 e
+    0x46,   // 66 f
+    0x47,   // 67 g
+    0x48,   // 68 h
+    0x49,   // 69 i
+    0x4A,   // 6A j
+    0x4B,   // 6B k
+    0x4C,   // 6C l
+    0x4D,   // 6D m
+    0x4E,   // 6E n
+    0x4F,   // 6F o
+    0x50,   // 70 p
+    0x51,   // 71 q
+    0x52,   // 72 r
+    0x53,   // 73 s
+    0x54,   // 74 t
+    0x55,   // 75 u
+    0x56,   // 76 v
+    0x57,   // 77 w
+    0x58,   // 78 x
+    0x59,   // 79 y
+    0x5A,   // 7A z
+    0x7B,   // 7B {
+    0x7C,   // 7C |
+    0x7D,   // 7D }
+    0x7E,   // 7E ~
+    0x7F,   // 7F (DEL)
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+
+
+extern "C" unsigned short const* _pctype {__newctype + 128}; // Pointer to table for char's
+extern "C" unsigned short const* _pwctype{_wctype    + 1  }; // Pointer to table for wchar_t's

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/get_qualified_locale.cpp

@@ -0,0 +1,851 @@
+/***
+*getqloc.c - get qualified locale
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines __acrt_get_qualified_locale - get complete locale information
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+extern "C" {
+
+
+
+//  local defines
+#define __LOC_DEFAULT  0x1     //  default language locale for country
+#define __LOC_PRIMARY  0x2     //  primary language locale for country
+#define __LOC_FULL     0x4     //  fully matched language locale for country
+#define __LOC_LANGUAGE 0x100   //  language default seen
+#define __LOC_EXISTS   0x200   //  language is installed
+
+
+
+//  non-NLS language string table
+//  The three letter Windows names are non-standard and very limited and should not be used.
+extern __crt_locale_string_table const __acrt_rg_language[]
+{
+    { L"american",                    L"ENU" },
+    { L"american english",            L"ENU" },
+    { L"american-english",            L"ENU" },
+    { L"australian",                  L"ENA" },
+    { L"belgian",                     L"NLB" },
+    { L"canadian",                    L"ENC" },
+    { L"chh",                         L"ZHH" },
+    { L"chi",                         L"ZHI" },
+    { L"chinese",                     L"CHS" },
+    { L"chinese-hongkong",            L"ZHH" },
+    { L"chinese-simplified",          L"CHS" },
+    { L"chinese-singapore",           L"ZHI" },
+    { L"chinese-traditional",         L"CHT" },
+    { L"dutch-belgian",               L"NLB" },
+    { L"english-american",            L"ENU" },
+    { L"english-aus",                 L"ENA" },
+    { L"english-belize",              L"ENL" },
+    { L"english-can",                 L"ENC" },
+    { L"english-caribbean",           L"ENB" },
+    { L"english-ire",                 L"ENI" },
+    { L"english-jamaica",             L"ENJ" },
+    { L"english-nz",                  L"ENZ" },
+    { L"english-south africa",        L"ENS" },
+    { L"english-trinidad y tobago",   L"ENT" },
+    { L"english-uk",                  L"ENG" },
+    { L"english-us",                  L"ENU" },
+    { L"english-usa",                 L"ENU" },
+    { L"french-belgian",              L"FRB" },
+    { L"french-canadian",             L"FRC" },
+    { L"french-luxembourg",           L"FRL" },
+    { L"french-swiss",                L"FRS" },
+    { L"german-austrian",             L"DEA" },
+    { L"german-lichtenstein",         L"DEC" },
+    { L"german-luxembourg",           L"DEL" },
+    { L"german-swiss",                L"DES" },
+    { L"irish-english",               L"ENI" },
+    { L"italian-swiss",               L"ITS" },
+    { L"norwegian",                   L"NOR" },
+    { L"norwegian-bokmal",            L"NOR" },
+    { L"norwegian-nynorsk",           L"NON" },
+    { L"portuguese-brazilian",        L"PTB" },
+    { L"spanish-argentina",           L"ESS" },
+    { L"spanish-bolivia",             L"ESB" },
+    { L"spanish-chile",               L"ESL" },
+    { L"spanish-colombia",            L"ESO" },
+    { L"spanish-costa rica",          L"ESC" },
+    { L"spanish-dominican republic",  L"ESD" },
+    { L"spanish-ecuador",             L"ESF" },
+    { L"spanish-el salvador",         L"ESE" },
+    { L"spanish-guatemala",           L"ESG" },
+    { L"spanish-honduras",            L"ESH" },
+    { L"spanish-mexican",             L"ESM" },
+    { L"spanish-modern",              L"ESN" },
+    { L"spanish-nicaragua",           L"ESI" },
+    { L"spanish-panama",              L"ESA" },
+    { L"spanish-paraguay",            L"ESZ" },
+    { L"spanish-peru",                L"ESR" },
+    { L"spanish-puerto rico",         L"ESU" },
+    { L"spanish-uruguay",             L"ESY" },
+    { L"spanish-venezuela",           L"ESV" },
+    { L"swedish-finland",             L"SVF" },
+    { L"swiss",                       L"DES" },
+    { L"uk",                          L"ENG" },
+    { L"us",                          L"ENU" },
+    { L"usa",                         L"ENU" }
+};
+
+//  non-NLS country/region string table
+//  The three letter Windows names are non-standard and very limited and should not be used.
+extern __crt_locale_string_table const __acrt_rg_country[]
+{
+    { L"america",                     L"USA" },
+    { L"britain",                     L"GBR" },
+    { L"china",                       L"CHN" },
+    { L"czech",                       L"CZE" },
+    { L"england",                     L"GBR" },
+    { L"great britain",               L"GBR" },
+    { L"holland",                     L"NLD" },
+    { L"hong-kong",                   L"HKG" },
+    { L"new-zealand",                 L"NZL" },
+    { L"nz",                          L"NZL" },
+    { L"pr china",                    L"CHN" },
+    { L"pr-china",                    L"CHN" },
+    { L"puerto-rico",                 L"PRI" },
+    { L"slovak",                      L"SVK" },
+    { L"south africa",                L"ZAF" },
+    { L"south korea",                 L"KOR" },
+    { L"south-africa",                L"ZAF" },
+    { L"south-korea",                 L"KOR" },
+    { L"trinidad & tobago",           L"TTO" },
+    { L"uk",                          L"GBR" },
+    { L"united-kingdom",              L"GBR" },
+    { L"united-states",               L"USA" },
+    { L"us",                          L"USA" },
+};
+
+// Number of entries in the language and country tables
+extern size_t const __acrt_rg_language_count{_countof(__acrt_rg_language)};
+extern size_t const __acrt_rg_country_count {_countof(__acrt_rg_country )};
+
+
+
+
+//  function prototypes
+BOOL __cdecl __acrt_get_qualified_locale(const __crt_locale_strings*, UINT*, __crt_locale_strings*);
+static BOOL TranslateName(const __crt_locale_string_table *, int, const wchar_t **);
+
+static void GetLocaleNameFromLangCountry (__crt_qualified_locale_data* _psetloc_data);
+static BOOL CALLBACK LangCountryEnumProcEx(_In_z_ LPWSTR, DWORD, LPARAM);
+
+static void GetLocaleNameFromLanguage (__crt_qualified_locale_data* _psetloc_data);
+static BOOL CALLBACK LanguageEnumProcEx(_In_z_ LPWSTR, DWORD, LPARAM);
+
+static void GetLocaleNameFromDefault (__crt_qualified_locale_data* _psetloc_data);
+
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data* _psetloc_data);
+static BOOL TestDefaultCountry(LPCWSTR localeName);
+static BOOL TestDefaultLanguage (LPCWSTR localeName, BOOL bTestPrimary, __crt_qualified_locale_data* _psetloc_data);
+
+static int GetPrimaryLen(LPCWSTR);
+
+
+/***
+*BOOL __acrt_get_qualified_locale - return fully qualified locale
+*
+*Purpose:
+*       get default locale, qualify partially complete locales
+*
+*Entry:
+*       lpInStr - input strings to be qualified
+*       lpOutStr - pointer to string locale names and codepage output
+*
+*Exit:
+*       TRUE if success, qualified locale is valid
+*       FALSE if failure
+*
+*Exceptions:
+*
+*******************************************************************************/
+BOOL __cdecl __acrt_get_qualified_locale(const __crt_locale_strings* lpInStr, UINT* lpOutCodePage, __crt_locale_strings* lpOutStr)
+{
+    int iCodePage;
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+    _psetloc_data->_cacheLocaleName[0] = L'\x0'; // Initialize to invariant localename
+
+    //  initialize pointer to call locale info routine based on operating system
+
+    _psetloc_data->iLocState = 0;
+    _psetloc_data->pchLanguage = lpInStr->szLanguage;
+    _psetloc_data->pchCountry = lpInStr->szCountry;
+
+    //  if country defined
+    //  convert non-NLS country strings to three-letter abbreviations
+    if (*_psetloc_data->pchCountry)
+        TranslateName(__acrt_rg_country, static_cast<int>(__acrt_rg_country_count - 1),
+                      &_psetloc_data->pchCountry);
+
+
+    //  if language defined ...
+    if (*_psetloc_data->pchLanguage)
+    {
+        //  and country defined
+        if (*_psetloc_data->pchCountry)
+        {
+            //  both language and country strings defined
+            //  get locale info using language and country
+            GetLocaleNameFromLangCountry(_psetloc_data);
+        }
+        else
+        {
+            //  language string defined, but country string undefined
+            //  get locale info using language only
+            GetLocaleNameFromLanguage(_psetloc_data);
+        }
+
+        // still not done?
+        if (_psetloc_data->iLocState == 0)
+        {
+            //  first attempt failed, try substituting the language name
+            //  convert non-NLS language strings to three-letter abbrevs
+            if (TranslateName(__acrt_rg_language, static_cast<int>(__acrt_rg_language_count - 1),
+                              &_psetloc_data->pchLanguage))
+            {
+                if (*_psetloc_data->pchCountry)
+                {
+                    //  get locale info using language and country
+                    GetLocaleNameFromLangCountry(_psetloc_data);
+                }
+                else
+                {
+                    //  get locale info using language only
+                    GetLocaleNameFromLanguage(_psetloc_data);
+                }
+            }
+        }
+    }
+    else
+    {
+        //  language is an empty string, use the User Default locale name
+        GetLocaleNameFromDefault(_psetloc_data);
+    }
+
+    //  test for error in locale processing
+    if (_psetloc_data->iLocState == 0)
+        return FALSE;
+
+    //  process codepage value
+    if (lpInStr == nullptr || *lpInStr->szLanguage || *lpInStr->szCodePage )
+    {
+        // If there's no input, then get the current codepage
+        // If they explicitly chose a language, use that default codepage
+        // If they explicilty set a codepage, then use that
+        iCodePage = ProcessCodePage(lpInStr ? lpInStr->szCodePage : nullptr, _psetloc_data);
+    }
+    else
+    {
+        // No language or codepage means that they want to set to the
+        // user default settings, get that codepage (could be UTF-8)
+        iCodePage = GetACP();
+    }
+
+    //  verify codepage validity
+    //  CP_UTF7 is unexpected and has never been previously permitted.
+    //  CP_UTF8 is the current preferred codepage
+    if (!iCodePage || iCodePage == CP_UTF7 || !IsValidCodePage((WORD)iCodePage))
+        return FALSE;
+
+    //  set codepage
+    if (lpOutCodePage)
+    {
+        *lpOutCodePage = (UINT)iCodePage;
+    }
+
+    //  set locale name and codepage results
+    if (lpOutStr)
+    {
+        lpOutStr->szLocaleName[0] = L'\x0'; // Init the locale name to empty string
+
+        _ERRCHECK(wcsncpy_s(lpOutStr->szLocaleName, _countof(lpOutStr->szLocaleName), _psetloc_data->_cacheLocaleName, wcslen(_psetloc_data->_cacheLocaleName) + 1));
+
+        // Get and store the English language lang name, to be returned to user
+        if (__acrt_GetLocaleInfoEx(lpOutStr->szLocaleName, LOCALE_SENGLISHLANGUAGENAME,
+                                    lpOutStr->szLanguage, MAX_LANG_LEN) == 0)
+            return FALSE;
+
+        // Get and store the English language country name, to be returned to user
+        if (__acrt_GetLocaleInfoEx(lpOutStr->szLocaleName, LOCALE_SENGLISHCOUNTRYNAME,
+                                    lpOutStr->szCountry, MAX_CTRY_LEN) == 0)
+            return FALSE;
+
+        // Special case: Both '.' and '_' are separators in string passed to setlocale,
+        // so if found in Country we use abbreviated name instead.
+        if (wcschr(lpOutStr->szCountry, L'_') || wcschr(lpOutStr->szCountry, L'.'))
+            if (__acrt_GetLocaleInfoEx(lpOutStr->szLocaleName, LOCALE_SABBREVCTRYNAME,
+                                    lpOutStr->szCountry, MAX_CTRY_LEN) == 0)
+                return FALSE;
+
+        if (iCodePage == CP_UTF8)
+        {
+            // We want UTF-8 to look like utf8, not 65001
+            _ERRCHECK(wcsncpy_s(lpOutStr->szCodePage, _countof(lpOutStr->szCodePage), L"utf8", 5));
+        }
+        else
+        {
+            _itow_s((int)iCodePage, (wchar_t *)lpOutStr->szCodePage, MAX_CP_LEN, 10);
+        }
+    }
+
+    return TRUE;
+}
+
+/***
+*BOOL TranslateName - convert known non-NLS string to NLS equivalent
+*
+*Purpose:
+*   Provide compatibility with existing code for non-NLS strings
+*
+*Entry:
+*   lpTable  - pointer to __crt_locale_string_table used for translation
+*   high     - maximum index of table (size - 1)
+*   ppchName - pointer to pointer of string to translate
+*
+*Exit:
+*   ppchName - pointer to pointer of string possibly translated
+*   TRUE if string translated, FALSE if unchanged
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TranslateName (
+    const __crt_locale_string_table * lpTable,
+    int               high,
+    const wchar_t**   ppchName)
+{
+    int     i;
+    int     cmp = 1;
+    int     low = 0;
+
+    //  typical binary search - do until no more to search or match
+    while (low <= high && cmp != 0)
+    {
+        i = (low + high) / 2;
+        cmp = _wcsicmp(*ppchName, (const wchar_t *)(*(lpTable + i)).szName);
+
+        if (cmp == 0)
+            *ppchName = (*(lpTable + i)).chAbbrev;
+        else if (cmp < 0)
+            high = i - 1;
+        else
+            low = i + 1;
+    }
+
+    return !cmp;
+}
+
+/***
+*void GetLocaleNameFromLangCountry - get locale names from language and country strings
+*
+*Purpose:
+*   Match the best locale names to the language and country string given.
+*   After global variables are initialized, the LangCountryEnumProcEx
+*   routine is registered as an EnumSystemLocalesEx callback to actually
+*   perform the matching as the locale names are enumerated.
+*
+*
+*WARNING:
+*   This depends on an exact match with a localized string that can change!
+*   It is strongly recommended that locales be selected with valid BCP-47
+*   tags instead of the English names.
+*
+*   This API is also very brute-force and resource intensive, reading in all
+*   of the locales, forcing them to be cached, and looking up their names.
+*
+*WARNING:
+*   In the event of a 2 or 3 letter friendly name (Asu, Edo, Ewe, Yi, ...)
+*   then this function will fail
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   pchCountry      - country string
+*   bAbbrevCountry  - country string ia a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   localeName - locale name of given language and country
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLocaleNameFromLangCountry (__crt_qualified_locale_data* _psetloc_data)
+{
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->bAbbrevCountry = wcslen(_psetloc_data->pchCountry) == 3;
+
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ?
+                             2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    // Enumerate all locales that come with the operating system,
+    // including replacement locales, but excluding alternate sorts.
+    __acrt_EnumSystemLocalesEx(LangCountryEnumProcEx, LOCALE_WINDOWS | LOCALE_SUPPLEMENTAL, 0, nullptr);
+
+    //  locale value is invalid if the language was not installed or the language
+    //  was not available for the country specified
+    if (!(_psetloc_data->iLocState & __LOC_LANGUAGE) ||
+        !(_psetloc_data->iLocState & __LOC_EXISTS) ||
+        !(_psetloc_data->iLocState & (__LOC_FULL |
+                                    __LOC_PRIMARY |
+                                    __LOC_DEFAULT)))
+        _psetloc_data->iLocState = 0;
+}
+
+/***
+*BOOL CALLBACK LangCountryEnumProcEx - callback routine for GetLocaleNameFromLangCountry
+*
+*Purpose:
+*   Determine if locale name given matches the language in pchLanguage
+*   and country in pchCountry.
+*
+*Entry:
+*   lpLocaleString   - pointer to locale name string string
+*   pchCountry     - pointer to country name
+*   bAbbrevCountry - set if country is three-letter abbreviation
+*
+*Exit:
+*   iLocState   - status of match
+*       __LOC_FULL - both language and country match (best match)
+*       __LOC_PRIMARY - primary language and country match (better)
+*       __LOC_DEFAULT - default language and country match (good)
+*       __LOC_LANGUAGE - default primary language exists
+*       __LOC_EXISTS - full match of language string exists
+*       (Overall match occurs for the best of FULL/PRIMARY/DEFAULT
+*        and LANGUAGE/EXISTS both set.)
+*   localeName - lpLocaleString matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LangCountryEnumProcEx(LPWSTR lpLocaleString, DWORD dwFlags, LPARAM lParam)
+{
+    UNREFERENCED_PARAMETER(dwFlags);
+    UNREFERENCED_PARAMETER(lParam);
+
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+    wchar_t  rgcInfo[MAX_LANG_LEN]; // MAX_LANG_LEN == MAX_CTRY_LEN == 64
+
+    //  test locale country against input value
+    if (__acrt_GetLocaleInfoEx(lpLocaleString,
+                               _psetloc_data->bAbbrevCountry ? LOCALE_SABBREVCTRYNAME : LOCALE_SENGLISHCOUNTRYNAME,
+                               rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_data->iLocState = 0;
+        return TRUE;
+    }
+
+    //  if country names matched
+    if (_wcsicmp(_psetloc_data->pchCountry, rgcInfo) == 0)
+    {
+        //  test for language match
+        if (__acrt_GetLocaleInfoEx(lpLocaleString,
+                                   _psetloc_data->bAbbrevLanguage ?
+                                   LOCALE_SABBREVLANGNAME : LOCALE_SENGLISHLANGUAGENAME,
+                                   rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_data->iLocState = 0;
+            return TRUE;
+        }
+
+        if (_wcsicmp(_psetloc_data->pchLanguage, rgcInfo) == 0)
+        {
+            //  language matched also - set state and value
+            //  this is the best match
+            _psetloc_data->iLocState |= (__LOC_FULL |
+                                       __LOC_LANGUAGE |
+                                       __LOC_EXISTS);
+
+            _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+        }
+        //  test if match already for primary langauage
+        else if (!(_psetloc_data->iLocState & __LOC_PRIMARY))
+        {
+            //  if not, use _psetloc_data->iPrimaryLen to partial match language string
+            if (_psetloc_data->iPrimaryLen && !_wcsnicmp(_psetloc_data->pchLanguage, rgcInfo, _psetloc_data->iPrimaryLen))
+            {
+                //  primary language matched - set locale name
+                _psetloc_data->iLocState |= __LOC_PRIMARY;
+                _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+            }
+
+            //  test if default language already defined
+            else if (!(_psetloc_data->iLocState & __LOC_DEFAULT))
+            {
+                //  if not, test if locale language is default for country
+                if (TestDefaultCountry(lpLocaleString))
+                {
+                    //  default language for country - set state, value
+                    _psetloc_data->iLocState |= __LOC_DEFAULT;
+                    _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+                }
+            }
+        }
+    }
+
+    //  test if input language both exists and default primary language defined
+    if ((_psetloc_data->iLocState & (__LOC_LANGUAGE | __LOC_EXISTS)) !=
+                      (__LOC_LANGUAGE | __LOC_EXISTS))
+    {
+        //  test language match to determine whether it is installed
+        if (__acrt_GetLocaleInfoEx(lpLocaleString, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                                           : LOCALE_SENGLISHLANGUAGENAME,
+                           rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_data->iLocState = 0;
+            return TRUE;
+        }
+
+        // the input language matches
+        if (_wcsicmp(_psetloc_data->pchLanguage, rgcInfo) == 0)
+        {
+            //  language matched - set bit for existance
+            _psetloc_data->iLocState |= __LOC_EXISTS;
+
+            if (_psetloc_data->bAbbrevLanguage)
+            {
+                //  abbreviation - set state
+                //  also set language locale name if not set already
+                _psetloc_data->iLocState |= __LOC_LANGUAGE;
+                if (!_psetloc_data->_cacheLocaleName[0])
+                    _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+            }
+
+            //  test if language is primary only (no sublanguage)
+            else if (_psetloc_data->iPrimaryLen && ((int)wcslen(_psetloc_data->pchLanguage) == _psetloc_data->iPrimaryLen))
+            {
+                //  primary language only - test if default locale name
+                if (TestDefaultLanguage(lpLocaleString, TRUE, _psetloc_data))
+                {
+                    //  default primary language - set state
+                    //  also set locale name if not set already
+                    _psetloc_data->iLocState |= __LOC_LANGUAGE;
+                    if (!_psetloc_data->_cacheLocaleName[0])
+                        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+                }
+            }
+            else
+            {
+                //  language with sublanguage - set state
+                //  also set locale name if not set already
+                _psetloc_data->iLocState |= __LOC_LANGUAGE;
+                if (!_psetloc_data->_cacheLocaleName[0])
+                    _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+            }
+        }
+    }
+
+    //  if LOCALE_FULL set, return FALSE to stop enumeration,
+    //  else return TRUE to continue
+    return (_psetloc_data->iLocState & __LOC_FULL) == 0;
+}
+
+/***
+*void GetLocaleNameFromLanguage - get locale name from language string
+*
+*Purpose:
+*   Match the best locale name to the language string given.  After global
+*   variables are initialized, the LanguageEnumProcEx routine is
+*   registered as an EnumSystemLocalesEx callback to actually perform
+*   the matching as the locale names are enumerated.
+*
+*WARNING:
+*   This depends on an exact match with a localized string that can change!
+*   It is strongly recommended that locales be selected with valid BCP-47
+*   tags instead of the English names.
+*
+*   This API is also very brute-force and resource intensive, reading in all
+*   of the locales, forcing them to be cached, and looking up their names.
+*
+*WARNING:
+*   In the event of a 3 letter BCP-47 tag that happens to match a Windows
+*   propriatary language code, this function will return the wrong answer!
+*
+*WARNING:
+*   In the event of a 2 or 3 letter friendly name (Asu, Edo, Ewe, Yi, ...)
+*   then this function will fail
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   localeName - locale name of language with default country
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLocaleNameFromLanguage (__crt_qualified_locale_data* _psetloc_data)
+{
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ? 2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    // Enumerate all locales that come with the operating system, including replacement locales,
+    // but excluding alternate sorts.
+    __acrt_EnumSystemLocalesEx(LanguageEnumProcEx, LOCALE_WINDOWS | LOCALE_SUPPLEMENTAL, 0, nullptr);
+
+    //  locale value is invalid if the language was not installed
+    //  or the language was not available for the country specified
+    if ((_psetloc_data->iLocState & __LOC_FULL) == 0)
+        _psetloc_data->iLocState = 0;
+}
+
+/***
+*BOOL CALLBACK LanguageEnumProcEx - callback routine for GetLocaleNameFromLanguage
+*
+*Purpose:
+*   Determine if locale name given matches the default country for the
+*   language in pchLanguage.
+*
+*Entry:
+*   lpLocaleString    - pointer to string with locale name
+*   dwFlags     - not used
+*   lParam      - not used
+*
+*Exit:
+*   localeName - locale name matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LanguageEnumProcEx (LPWSTR lpLocaleString, DWORD dwFlags, LPARAM lParam)
+{
+    UNREFERENCED_PARAMETER(dwFlags);
+    UNREFERENCED_PARAMETER(lParam);
+
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+    wchar_t    rgcInfo[120];
+
+    //  test locale for language specified
+    if (__acrt_GetLocaleInfoEx(lpLocaleString, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                                              : LOCALE_SENGLISHLANGUAGENAME,
+                               rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_data->iLocState = 0;
+        return TRUE;
+    }
+
+    if (_wcsicmp(_psetloc_data->pchLanguage, rgcInfo) == 0)
+    {
+        //  language matches
+        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+
+        _psetloc_data->iLocState |= __LOC_FULL;
+    }
+
+    return (_psetloc_data->iLocState & __LOC_FULL) == 0;
+}
+
+
+/***
+*void GetLocaleNameFromDefault - get default locale names
+*
+*Purpose:
+*   Set both language and country locale names to the user default.
+*
+*Entry:
+*   None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLocaleNameFromDefault (__crt_qualified_locale_data* _psetloc_data)
+{
+    wchar_t localeName[LOCALE_NAME_MAX_LENGTH];
+    _psetloc_data->iLocState |= (__LOC_FULL | __LOC_LANGUAGE);
+
+    // Store the default user locale name. The returned buffer size includes the
+    // terminating null character, so only store if the size returned is > 1
+    if (__acrt_GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH) > 1)
+    {
+        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), localeName, wcslen(localeName) + 1));
+    }
+}
+
+/***
+*int ProcessCodePage - convert codepage string to numeric value
+*
+*Purpose:
+*   Process codepage string consisting of a decimal string, or the
+*   special case strings "ACP" and "OCP", for ANSI and OEM codepages,
+*   respectively.  Null pointer or string returns the ANSI codepage.
+*
+*Entry:
+*   lpCodePageStr - pointer to codepage string
+*
+*Exit:
+*   Returns numeric value of codepage, zero if GetLocaleInfoEx failed.
+*   (which then would mean caller aborts and locale is not set)
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data* _psetloc_data)
+{
+    int iCodePage;
+
+    if (!lpCodePageStr || !*lpCodePageStr || wcscmp(lpCodePageStr, L"ACP") == 0)
+    {
+        //  get ANSI codepage for the country locale name
+        //  CONSIDER: If system is running UTF-8 ACP, then always return UTF-8?
+        if (__acrt_GetLocaleInfoEx(_psetloc_data->_cacheLocaleName, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+
+        // Locales with no code page ("Unicode only locales") should return UTF-8
+        // (0, 1 & 2 are Unicode-Only ACP, OEMCP & MacCP flags)
+        if (iCodePage < 3)
+        {
+            return CP_UTF8;
+        }
+
+    }
+    else if (_wcsicmp(lpCodePageStr, L"utf8") == 0 ||
+             _wcsicmp(lpCodePageStr, L"utf-8") == 0)
+    {
+        // Use UTF-8
+        return CP_UTF8;
+    }
+    else if (wcscmp(lpCodePageStr, L"OCP") == 0)
+    {
+        //  get OEM codepage for the country locale name
+        //  CONSIDER: If system is running UTF-8 ACP, then always return UTF-8?
+        if (__acrt_GetLocaleInfoEx(_psetloc_data->_cacheLocaleName, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+
+        // Locales with no code page ("unicode only locales") should return UTF-8
+        // (0, 1 & 2 are Unicode-Only ACP, OEMCP & MacCP flags)
+        if (iCodePage < 3)
+        {
+            return CP_UTF8;
+        }
+    }
+    else
+    {
+         // convert decimal string to numeric value
+         iCodePage = (int)_wtol(lpCodePageStr);
+    }
+
+    return iCodePage;
+}
+
+/***
+*BOOL TestDefaultCountry - determine if default locale for country
+*
+*Purpose:
+*   Determine if the locale of the given locale name has the default sublanguage.
+*   This is determined by checking if the given language is neutral.
+*
+*Entry:
+*   localeName - name of locale to test
+*
+*Exit:
+*   Returns TRUE if default sublanguage, else FALSE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultCountry (LPCWSTR localeName)
+{
+    wchar_t sIso639LangName[9]; // The maximum length for LOCALE_SISO3166CTRYNAME
+                                // is 9 including nullptr
+
+    //  Get 2-letter ISO Standard 639 or 3-letter ISO 639-2 value
+    if (__acrt_GetLocaleInfoEx(localeName, LOCALE_SISO639LANGNAME,
+                                sIso639LangName, _countof(sIso639LangName)) == 0)
+        return FALSE;
+
+    // Determine if this is a neutral language
+    if (wcsncmp(sIso639LangName, localeName, _countof(sIso639LangName)) == 0)
+        return TRUE;
+
+    return FALSE;
+}
+
+/***
+*BOOL TestDefaultLanguage - determine if default locale for language
+*
+*Purpose:
+*   Determines if the given locale name has the default sublanguage.
+*   If bTestPrimary is set, also allow TRUE when string contains an
+*   implicit sublanguage.
+*
+*Entry:
+*   localeName         - locale name of locale to test
+*   bTestPrimary - set if testing if language is primary
+*
+*Exit:
+*   Returns TRUE if sublanguage is default for locale tested.
+*   If bTestPrimary set, TRUE is language has implied sublanguge.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultLanguage(LPCWSTR localeName, BOOL bTestPrimary, __crt_qualified_locale_data* _psetloc_data)
+{
+    if (!TestDefaultCountry (localeName))
+    {
+        //  test if string contains an implicit sublanguage by
+        //  having a character other than upper/lowercase letters.
+        if (bTestPrimary && GetPrimaryLen(_psetloc_data->pchLanguage) == (int)wcslen(_psetloc_data->pchLanguage))
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+/***
+*int GetPrimaryLen - get length of primary language name
+*
+*Purpose:
+*   Determine primary language string length by scanning until
+*   first non-alphabetic character.
+*
+*Entry:
+*   pchLanguage - string to scan
+*
+*Exit:
+*   Returns length of primary language string.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int GetPrimaryLen(LPCWSTR pchLanguage)
+{
+    int     len = 0;
+    wchar_t    ch;
+
+    if (!pchLanguage)
+        return 0;
+
+    ch = *pchLanguage++;
+    while ((ch >= L'A' && ch <= L'Z') || (ch >= L'a' && ch <= L'z'))
+    {
+        len++;
+        ch = *pchLanguage++;
+    }
+
+    return len;
+}
+
+
+
+} // extern "C"

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/getqloc_downlevel.cpp

@@ -0,0 +1,852 @@
+/***
+*getqloc_downlevel.c - get qualified locale for downlevel OS
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines __acrt_get_qualified_locale_downlevel - get complete locale information
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern "C" {
+
+//  local defines
+#define __LCID_DEFAULT  0x1     //  default language locale for country
+#define __LCID_PRIMARY  0x2     //  primary language locale for country
+#define __LCID_FULL     0x4     //  fully matched language locale for country
+#define __LCID_LANGUAGE 0x100   //  language default seen
+#define __LCID_EXISTS   0x200   //  language is installed
+
+typedef struct tagRGLOCINFO
+{
+    LCID        lcid;
+    wchar_t        chILanguage[8];
+    wchar_t *      pchSEngLanguage;
+    wchar_t        chSAbbrevLangName[4];
+    wchar_t *      pchSEngCountry;
+    wchar_t        chSAbbrevCtryName[4];
+    wchar_t        chIDefaultCodepage[8];
+    wchar_t        chIDefaultAnsiCodepage[8];
+} RGLOCINFO;
+
+static bool TranslateName(const __crt_locale_string_table *, int, const wchar_t **);
+
+static void GetLcidFromLangCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL CALLBACK LangCountryEnumProc(_In_z_ PWSTR);
+
+static void GetLcidFromLanguage (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL CALLBACK LanguageEnumProc(_In_z_ PWSTR);
+
+static void GetLcidFromCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL CALLBACK CountryEnumProc(_In_z_ PWSTR);
+
+static void GetLcidFromDefault (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL TestDefaultCountry(LCID);
+static BOOL TestDefaultLanguage (LCID lcid, BOOL bTestPrimary, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+
+static LCID LcidFromHexString(_In_z_ PCWSTR);
+static int GetPrimaryLen(wchar_t const*);
+
+//  LANGID's of locales of nondefault languages
+extern __declspec(selectany) LANGID const __rglangidNotDefault[] =
+{
+    MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH_CANADIAN),
+    MAKELANGID(LANG_SERBIAN, SUBLANG_SERBIAN_CYRILLIC),
+    MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_LUXEMBOURG),
+    MAKELANGID(LANG_AFRIKAANS, SUBLANG_DEFAULT),
+    MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH_BELGIAN),
+    MAKELANGID(LANG_BASQUE, SUBLANG_DEFAULT),
+    MAKELANGID(LANG_CATALAN, SUBLANG_DEFAULT),
+    MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH_SWISS),
+    MAKELANGID(LANG_ITALIAN, SUBLANG_ITALIAN_SWISS),
+    MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH_FINLAND)
+};
+
+/***
+*BOOL __acrt_get_qualified_locale_downlevel - return fully qualified locale
+*
+*Purpose:
+*       get default locale, qualify partially complete locales
+*
+*Entry:
+*       lpInStr - input strings to be qualified
+*       lpOutId - pointer to numeric LCIDs and codepage output
+*       lpOutStr - pointer to string LCIDs and codepage output
+*
+*Exit:
+*       TRUE if success, qualified locale is valid
+*       FALSE if failure
+*
+*Exceptions:
+*
+*******************************************************************************/
+BOOL __cdecl __acrt_get_qualified_locale_downlevel(const __crt_locale_strings* lpInStr, UINT* lpOutCodePage, __crt_locale_strings* lpOutStr)
+{
+    int     iCodePage;
+
+    // Get setloc data from per thread data struct
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    // Set downlevel setloc data in per thread data struct for use by LCID downlevel APIs
+    __crt_qualified_locale_data_downlevel downlevel_setloc;
+    __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data;
+
+    memset(&downlevel_setloc, '\0', sizeof(__crt_qualified_locale_data_downlevel));
+    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data = &downlevel_setloc;
+
+    //  initialize pointer to call locale info routine based on operating system
+
+    _psetloc_data->pchLanguage = lpInStr->szLanguage;
+
+    //  convert non-NLS country strings to three-letter abbreviations
+    _psetloc_data->pchCountry = lpInStr->szCountry;
+    if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+        TranslateName(__acrt_rg_country,
+                      static_cast<int>(__acrt_rg_country_count - 1),
+                      &_psetloc_data->pchCountry);
+
+    _psetloc_downlevel_data->iLcidState = 0;
+
+    if (_psetloc_data->pchLanguage && *_psetloc_data->pchLanguage)
+    {
+        if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+        {
+            //  both language and country strings defined
+            GetLcidFromLangCountry(_psetloc_downlevel_data);
+        }
+        else
+        {
+            //  language string defined, but country string undefined
+            GetLcidFromLanguage(_psetloc_downlevel_data);
+        }
+
+        if (!_psetloc_downlevel_data->iLcidState) {
+            //  first attempt failed, try substituting the language name
+            //  convert non-NLS language strings to three-letter abbrevs
+            if (TranslateName(__acrt_rg_language,
+                              static_cast<int>(__acrt_rg_language_count - 1),
+                              &_psetloc_data->pchLanguage))
+            {
+                if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+                {
+                    GetLcidFromLangCountry(_psetloc_downlevel_data);
+                }
+                else
+                {
+                    GetLcidFromLanguage(_psetloc_downlevel_data);
+                }
+            }
+        }
+    }
+    else
+    {
+        if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+        {
+            //  country string defined, but language string undefined
+            GetLcidFromCountry(_psetloc_downlevel_data);
+        }
+        else
+        {
+            //  both language and country strings undefined
+            GetLcidFromDefault(_psetloc_downlevel_data);
+        }
+    }
+
+    //  test for error in LCID processing
+    if (!_psetloc_downlevel_data->iLcidState)
+        return FALSE;
+
+    //  process codepage value
+    iCodePage = ProcessCodePage(lpInStr ? lpInStr->szCodePage: nullptr, _psetloc_downlevel_data);
+
+    //  verify codepage validity
+    if (!iCodePage || !IsValidCodePage((WORD)iCodePage))
+        return FALSE;
+
+    //  verify locale is installed
+    if (!IsValidLocale(_psetloc_downlevel_data->lcidLanguage, LCID_INSTALLED))
+        return FALSE;
+
+    //  set codepage
+    if (lpOutCodePage)
+    {
+        *lpOutCodePage = (UINT)iCodePage;
+    }
+
+    // store locale name in cache
+    __acrt_LCIDToLocaleName(
+        _psetloc_downlevel_data->lcidLanguage,
+        _psetloc_data->_cacheLocaleName,
+        (int)_countof(_psetloc_data->_cacheLocaleName),
+        0);
+
+    //  set locale name and codepage results
+    if (lpOutStr)
+    {
+        __acrt_LCIDToLocaleName(
+            _psetloc_downlevel_data->lcidLanguage,
+            lpOutStr->szLocaleName,
+            (int)_countof(lpOutStr->szLocaleName),
+            0);
+
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidLanguage, LOCALE_SENGLANGUAGE,
+                                 lpOutStr->szLanguage, MAX_LANG_LEN) == 0)
+            return FALSE;
+
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidCountry, LOCALE_SENGCOUNTRY,
+                                 lpOutStr->szCountry, MAX_CTRY_LEN) == 0)
+            return FALSE;
+
+        _itow_s((int)iCodePage, (wchar_t *)lpOutStr->szCodePage, MAX_CP_LEN, 10);
+    }
+
+    return TRUE;
+}
+
+/***
+*BOOL TranslateName - convert known non-NLS string to NLS equivalent
+*
+*Purpose:
+*   Provide compatibility with existing code for non-NLS strings
+*
+*Entry:
+*   lpTable  - pointer to __crt_locale_string_table used for translation
+*   high     - maximum index of table (size - 1)
+*   ppchName - pointer to pointer of string to translate
+*
+*Exit:
+*   ppchName - pointer to pointer of string possibly translated
+*   TRUE if string translated, FALSE if unchanged
+*
+*Exceptions:
+*
+*******************************************************************************/
+static bool TranslateName (
+    const __crt_locale_string_table* lpTable,
+    int                              high,
+    const wchar_t **                 ppchName)
+{
+    int low = 0;
+
+    //  typical binary search - do until no more to search or match
+    while (low <= high)
+    {
+        int const i = (low + high) / 2;
+        int const cmp = _wcsicmp(*ppchName, lpTable[i].szName);
+
+        if (cmp == 0)
+        {
+            *ppchName = lpTable[i].chAbbrev;
+            return true;
+        }
+        else if (cmp < 0)
+            high = i - 1;
+        else
+            low = i + 1;
+    }
+
+    return false;
+}
+
+/***
+*void GetLcidFromLangCountry - get LCIDs from language and country strings
+*
+*Purpose:
+*   Match the best LCIDs to the language and country string given.
+*   After global variables are initialized, the LangCountryEnumProc
+*   routine is registered as an EnumSystemLocalesA callback to actually
+*   perform the matching as the LCIDs are enumerated.
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   pchCountry      - country string
+*   bAbbrevCountry  - country string ia a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   lcidLanguage - LCID of language string
+*   lcidCountry  - LCID of country string
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromLangCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->bAbbrevCountry = wcslen(_psetloc_data->pchCountry) == 3;
+    _psetloc_downlevel_data->lcidLanguage = 0;
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ?
+                             2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    EnumSystemLocalesW(LangCountryEnumProc, LCID_INSTALLED);
+
+    //  locale value is invalid if the language was not installed or the language
+    //  was not available for the country specified
+    if (!(_psetloc_downlevel_data->iLcidState & __LCID_LANGUAGE) ||
+        !(_psetloc_downlevel_data->iLcidState & __LCID_EXISTS) ||
+        !(_psetloc_downlevel_data->iLcidState & (__LCID_FULL |
+                                    __LCID_PRIMARY |
+                                    __LCID_DEFAULT)))
+        _psetloc_downlevel_data->iLcidState = 0;
+}
+
+/***
+*BOOL CALLBACK LangCountryEnumProc - callback routine for GetLcidFromLangCountry
+*
+*Purpose:
+*   Determine if LCID given matches the language in pchLanguage
+*   and country in pchCountry.
+*
+*Entry:
+*   lpLcidString   - pointer to string with decimal LCID
+*   pchCountry     - pointer to country name
+*   bAbbrevCountry - set if country is three-letter abbreviation
+*
+*Exit:
+*   iLcidState   - status of match
+*       __LCID_FULL - both language and country match (best match)
+*       __LCID_PRIMARY - primary language and country match (better)
+*       __LCID_DEFAULT - default language and country match (good)
+*       __LCID_LANGUAGE - default primary language exists
+*       __LCID_EXISTS - full match of language string exists
+*       (Overall match occurs for the best of FULL/PRIMARY/DEFAULT
+*        and LANGUAGE/EXISTS both set.)
+*   lcidLanguage - LCID matched
+*   lcidCountry  - LCID matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LangCountryEnumProc (_In_z_ PWSTR lpLcidString)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    __crt_qualified_locale_data_downlevel*    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data;
+    LCID    lcid = LcidFromHexString(lpLcidString);
+    wchar_t    rgcInfo[120];
+
+    //  test locale country against input value
+    if (GetLocaleInfoW(lcid,
+                             _psetloc_data->bAbbrevCountry ?
+                             LOCALE_SABBREVCTRYNAME : LOCALE_SENGCOUNTRY,
+                             rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_downlevel_data->iLcidState = 0;
+        return TRUE;
+    }
+    if (!_wcsicmp(_psetloc_data->pchCountry, rgcInfo))
+    {
+        //  country matched - test for language match
+        if (GetLocaleInfoW(lcid,
+                                 _psetloc_data->bAbbrevLanguage ?
+                                 LOCALE_SABBREVLANGNAME : LOCALE_SENGLANGUAGE,
+                                 rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_downlevel_data->iLcidState = 0;
+            return TRUE;
+        }
+        if (!_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+        {
+            //  language matched also - set state and value
+            _psetloc_downlevel_data->iLcidState |= (__LCID_FULL |
+                                       __LCID_LANGUAGE |
+                                       __LCID_EXISTS);
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+        }
+
+        //  test if match already for primary langauage
+        else if (!(_psetloc_downlevel_data->iLcidState & __LCID_PRIMARY))
+        {
+            //  if not, use _psetloc_data->iPrimaryLen to partial match language string
+            if (_psetloc_data->iPrimaryLen && !_wcsnicmp(_psetloc_data->pchLanguage, rgcInfo, _psetloc_data->iPrimaryLen))
+            {
+                //  primary language matched - set state and country LCID
+                _psetloc_downlevel_data->iLcidState |= __LCID_PRIMARY;
+                _psetloc_downlevel_data->lcidCountry = lcid;
+
+                //  if language is primary only (no subtype), set language LCID
+                if ((int)wcslen(_psetloc_data->pchLanguage) == _psetloc_data->iPrimaryLen)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+
+            //  test if default language already defined
+            else if (!(_psetloc_downlevel_data->iLcidState & __LCID_DEFAULT))
+            {
+                //  if not, test if locale language is default for country
+                if (TestDefaultCountry(lcid))
+                {
+                    //  default language for country - set state, value
+                    _psetloc_downlevel_data->iLcidState |= __LCID_DEFAULT;
+                    _psetloc_downlevel_data->lcidCountry = lcid;
+                }
+            }
+        }
+    }
+    //  test if input language both exists and default primary language defined
+    if ((_psetloc_downlevel_data->iLcidState & (__LCID_LANGUAGE | __LCID_EXISTS)) !=
+                      (__LCID_LANGUAGE | __LCID_EXISTS))
+    {
+        //  test language match to determine whether it is installed
+        if (GetLocaleInfoW(lcid, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                       : LOCALE_SENGLANGUAGE,
+                           rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_downlevel_data->iLcidState = 0;
+            return TRUE;
+        }
+
+        if (!_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+        {
+            //  language matched - set bit for existance
+            _psetloc_downlevel_data->iLcidState |= __LCID_EXISTS;
+
+            if (_psetloc_data->bAbbrevLanguage)
+            {
+                //  abbreviation - set state
+                //  also set language LCID if not set already
+                _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                if (!_psetloc_downlevel_data->lcidLanguage)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+
+            //  test if language is primary only (no sublanguage)
+            else if (_psetloc_data->iPrimaryLen && ((int)wcslen(_psetloc_data->pchLanguage) == _psetloc_data->iPrimaryLen))
+            {
+                //  primary language only - test if default LCID
+                if (TestDefaultLanguage(lcid, TRUE, _psetloc_downlevel_data))
+                {
+                    //  default primary language - set state
+                    //  also set LCID if not set already
+                    _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                    if (!_psetloc_downlevel_data->lcidLanguage)
+                        _psetloc_downlevel_data->lcidLanguage = lcid;
+                }
+            }
+            else
+            {
+                //  language with sublanguage - set state
+                //  also set LCID if not set already
+                _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                if (!_psetloc_downlevel_data->lcidLanguage)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+        }
+        else if (!_psetloc_data->bAbbrevLanguage && _psetloc_data->iPrimaryLen
+                               && !_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+        {
+            //  primary language match - test for default language only
+            if (TestDefaultLanguage(lcid, FALSE, _psetloc_downlevel_data))
+            {
+                //  default primary language - set state
+                //  also set LCID if not set already
+                _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                if (!_psetloc_downlevel_data->lcidLanguage)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+        }
+    }
+
+    //  if LOCALE_FULL set, return FALSE to stop enumeration,
+    //  else return TRUE to continue
+    return (_psetloc_downlevel_data->iLcidState & __LCID_FULL) == 0;
+}
+
+/***
+*void GetLcidFromLanguage - get LCIDs from language string
+*
+*Purpose:
+*   Match the best LCIDs to the language string given.  After global
+*   variables are initialized, the LanguageEnumProc routine is
+*   registered as an EnumSystemLocalesA callback to actually perform
+*   the matching as the LCIDs are enumerated.
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   lcidLanguage - lcidCountry  - LCID of language with default
+*                                 country
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromLanguage (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ? 2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    EnumSystemLocalesW(LanguageEnumProc, LCID_INSTALLED);
+
+    //  locale value is invalid if the language was not installed
+    //  or the language was not available for the country specified
+    if (!(_psetloc_downlevel_data->iLcidState & __LCID_FULL))
+        _psetloc_downlevel_data->iLcidState = 0;
+}
+
+/***
+*BOOL CALLBACK LanguageEnumProc - callback routine for GetLcidFromLanguage
+*
+*Purpose:
+*   Determine if LCID given matches the default country for the
+*   language in pchLanguage.
+*
+*Entry:
+*   lpLcidString    - pointer to string with decimal LCID
+*   pchLanguage     - pointer to language name
+*   bAbbrevLanguage - set if language is three-letter abbreviation
+*
+*Exit:
+*   lcidLanguage - lcidCountry - LCID matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LanguageEnumProc (_In_z_ PWSTR lpLcidString)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    __crt_qualified_locale_data_downlevel*    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data;
+
+    LCID    lcid = LcidFromHexString(lpLcidString);
+    wchar_t    rgcInfo[120];
+
+    //  test locale for language specified
+    if (GetLocaleInfoW(lcid, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                   : LOCALE_SENGLANGUAGE,
+                       rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_downlevel_data->iLcidState = 0;
+        return TRUE;
+    }
+
+    if (!_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+    {
+        //  language matched - test if locale country is default
+        //  or if locale is implied in the language string
+        if (_psetloc_data->bAbbrevLanguage || TestDefaultLanguage(lcid, TRUE, _psetloc_downlevel_data))
+        {
+            //  this locale has the default country
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+            _psetloc_downlevel_data->iLcidState |= __LCID_FULL;
+        }
+    }
+    else if (!_psetloc_data->bAbbrevLanguage && _psetloc_data->iPrimaryLen
+                              && !_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+    {
+        //  primary language matched - test if locale country is default
+        if (TestDefaultLanguage(lcid, FALSE, _psetloc_downlevel_data))
+        {
+            //  this is the default country
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+            _psetloc_downlevel_data->iLcidState |= __LCID_FULL;
+        }
+    }
+
+    return (_psetloc_downlevel_data->iLcidState & __LCID_FULL) == 0;
+}
+
+/***
+*void GetLcidFromCountry - get LCIDs from country string
+*
+*Purpose:
+*   Match the best LCIDs to the country string given.  After global
+*   variables are initialized, the CountryEnumProc routine is
+*   registered as an EnumSystemLocalesA callback to actually perform
+*   the matching as the LCIDs are enumerated.
+*
+*Entry:
+*   pchCountry     - country string
+*   bAbbrevCountry - country string is a three-letter abbreviation
+*
+*Exit:
+*   lcidLanguage - lcidCountry  - LCID of country with default
+*                                 language
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    _psetloc_data->bAbbrevCountry = wcslen(_psetloc_data->pchCountry) == 3;
+
+    EnumSystemLocalesW(CountryEnumProc, LCID_INSTALLED);
+
+    //  locale value is invalid if the country was not defined or
+    //  no default language was found
+    if (!(_psetloc_downlevel_data->iLcidState & __LCID_FULL))
+        _psetloc_downlevel_data->iLcidState = 0;
+}
+
+/***
+*BOOL CALLBACK CountryEnumProc - callback routine for GetLcidFromCountry
+*
+*Purpose:
+*   Determine if LCID given matches the default language for the
+*   country in pchCountry.
+*
+*Entry:
+*   lpLcidString   - pointer to string with decimal LCID
+*   pchCountry     - pointer to country name
+*   bAbbrevCountry - set if country is three-letter abbreviation
+*
+*Exit:
+*   lcidLanguage - lcidCountry - LCID matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK CountryEnumProc (_In_z_ PWSTR lpLcidString)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    __crt_qualified_locale_data_downlevel*    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data;
+    LCID    lcid = LcidFromHexString(lpLcidString);
+    wchar_t    rgcInfo[120];
+
+    //  test locale for country specified
+    if (GetLocaleInfoW(lcid, _psetloc_data->bAbbrevCountry ? LOCALE_SABBREVCTRYNAME
+                                                  : LOCALE_SENGCOUNTRY,
+                       rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_downlevel_data->iLcidState = 0;
+        return TRUE;
+    }
+    if (!_wcsicmp(_psetloc_data->pchCountry, rgcInfo))
+    {
+        //  language matched - test if locale country is default
+        if (TestDefaultCountry(lcid))
+        {
+            //  this locale has the default language
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+            _psetloc_downlevel_data->iLcidState |= __LCID_FULL;
+        }
+    }
+    return (_psetloc_downlevel_data->iLcidState & __LCID_FULL) == 0;
+}
+
+/***
+*void GetLcidFromDefault - get default LCIDs
+*
+*Purpose:
+*   Set both language and country LCIDs to the system default.
+*
+*Entry:
+*   None.
+*
+*Exit:
+*   lcidLanguage - set to system LCID
+*   lcidCountry  - set to system LCID
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromDefault (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    _psetloc_downlevel_data->iLcidState |= (__LCID_FULL | __LCID_LANGUAGE);
+    _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = GetUserDefaultLCID();
+}
+
+/***
+*int ProcessCodePage - convert codepage string to numeric value
+*
+*Purpose:
+*   Process codepage string consisting of a decimal string, or the
+*   special case strings "ACP" and "OCP", for ANSI and OEM codepages,
+*   respectively.  Null pointer or string returns the ANSI codepage.
+*
+*Entry:
+*   lpCodePageStr - pointer to codepage string
+*
+*Exit:
+*   Returns numeric value of codepage.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    int iCodePage;
+
+    if (!lpCodePageStr || !*lpCodePageStr || !wcscmp(lpCodePageStr, L"ACP"))
+    {
+        //  get ANSI codepage for the country LCID
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidCountry, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+
+        if (iCodePage == 0) // for locales have no assoicated ANSI codepage, e.g. Hindi locale
+            return GetACP();
+    }
+    else if (!wcscmp(lpCodePageStr, L"OCP"))
+    {
+        //  get OEM codepage for the country LCID
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidCountry, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+    }
+    else
+    {
+         // convert decimal string to numeric value
+         iCodePage = (int)_wtol(lpCodePageStr);
+    }
+
+    return iCodePage;
+}
+
+/***
+*BOOL TestDefaultCountry - determine if default locale for country
+*
+*Purpose:
+*   Using a hardcoded list, determine if the locale of the given LCID
+*   has the default sublanguage for the locale primary language.  The
+*   list contains the locales NOT having the default sublanguage.
+*
+*Entry:
+*   lcid - LCID of locale to test
+*
+*Exit:
+*   Returns TRUE if default sublanguage, else FALSE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultCountry (LCID lcid)
+{
+    LANGID  langid = LANGIDFROMLCID(lcid);
+    int     i;
+
+    for (i = 0; i < _countof(__rglangidNotDefault); i++)
+    {
+        if (langid == __rglangidNotDefault[i])
+            return FALSE;
+    }
+    return TRUE;
+}
+
+/***
+*BOOL TestDefaultLanguage - determine if default locale for language
+*
+*Purpose:
+*   Determines if the given LCID has the default sublanguage.
+*   If bTestPrimary is set, also allow TRUE when string contains an
+*   implicit sublanguage.
+*
+*Entry:
+*   LCID         - lcid of locale to test
+*   bTestPrimary - set if testing if language is primary
+*
+*Exit:
+*   Returns TRUE if sublanguage is default for locale tested.
+*   If bTestPrimary set, TRUE is language has implied sublanguge.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultLanguage (LCID lcid, BOOL bTestPrimary, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    UNREFERENCED_PARAMETER(_psetloc_downlevel_data); // CRT_REFACTOR TODO
+
+    DWORD dwLanguage;
+    LCID lcidDefault = MAKELCID(MAKELANGID(PRIMARYLANGID(LANGIDFROMLCID(lcid)), SUBLANG_DEFAULT), SORT_DEFAULT);
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    if (GetLocaleInfoW(lcidDefault, LOCALE_ILANGUAGE | LOCALE_RETURN_NUMBER,
+                                          (LPWSTR) &dwLanguage, sizeof(dwLanguage) / sizeof(wchar_t)) == 0)
+        return FALSE;
+
+    if (lcid != dwLanguage)
+    {
+        //  test if string contains an implicit sublanguage by
+        //  having a character other than upper/lowercase letters.
+        if (bTestPrimary && GetPrimaryLen(_psetloc_data->pchLanguage) == (int)wcslen(_psetloc_data->pchLanguage))
+            return FALSE;
+    }
+    return TRUE;
+}
+
+/***
+*LCID LcidFromHexString - convert hex string to value for LCID
+*
+*Purpose:
+*   LCID values returned in hex ANSI strings - straight conversion
+*
+*Entry:
+*   lpHexString - pointer to hex string to convert
+*
+*Exit:
+*   Returns LCID computed.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static LCID LcidFromHexString (_In_z_ PCWSTR lpHexString)
+{
+    wchar_t    ch;
+    DWORD   lcid = 0;
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 This is an idiomatic nul termination check that Prefast doesn't understand.
+    while ((ch = *lpHexString++) != '\0')
+    {
+        if (ch >= 'a' && ch <= 'f')
+            ch += static_cast<wchar_t>('9' + 1 - 'a');
+        else if (ch >= 'A' && ch <= 'F')
+            ch += static_cast<wchar_t>('9' + 1 - 'A');
+        lcid = lcid * 0x10 + ch - '0';
+    }
+
+    return (LCID)lcid;
+}
+
+/***
+*int GetPrimaryLen - get length of primary language name
+*
+*Purpose:
+*   Determine primary language string length by scanning until
+*   first non-alphabetic character.
+*
+*Entry:
+*   pchLanguage - string to scan
+*
+*Exit:
+*   Returns length of primary language string.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int GetPrimaryLen (wchar_t const* pchLanguage)
+{
+    int     len = 0;
+    wchar_t    ch;
+
+    ch = *pchLanguage++;
+    while ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
+    {
+        len++;
+        ch = *pchLanguage++;
+    }
+
+    return len;
+}
+
+} // extern "C"

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/glstatus.cpp

@@ -0,0 +1,13 @@
+/***
+*glstatus.c - sets the __globallocalestatus flag
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Sets the __globallocalestatus flag to disable per thread locale
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+
+extern "C" int __globallocalestatus = (~_GLOBAL_LOCALE_BIT);

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initctype.cpp

@@ -0,0 +1,339 @@
+/***
+*initctype.cpp - contains __acrt_locale_initialize_ctype
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the locale-category initialization function: __acrt_locale_initialize_ctype().
+*
+*       Each initialization function sets up locale-specific information
+*       for their category, for use by functions which are affected by
+*       their locale category.
+*
+*       *** For internal use by setlocale() only ***
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+#define _CTABSIZE   257     /* size of ctype tables */
+
+// Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+/***
+*int __acrt_locale_initialize_ctype() - initialization for LC_CTYPE locale category.
+*
+*Purpose:
+*       In non-C locales, preread ctype tables for chars and wide-chars.
+*       Old tables are freed when new tables are fully established, else
+*       the old tables remain intact (as if original state unaltered).
+*       The leadbyte table is implemented as the high bit in ctype1.
+*
+*       In the C locale, ctype tables are freed, and pointers point to
+*       the static ctype table.
+*
+*       Tables contain 257 entries: -1 to 256.
+*       Table pointers point to entry 0 (to allow index -1).
+*
+*Entry:
+*       None.
+*
+*Exit:
+*       0 success
+*       1 fail
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl __acrt_locale_initialize_ctype (
+        __crt_locale_data* ploci
+        )
+{
+    /* non-C locale table for char's */
+    unsigned short *newctype1 = nullptr;          /* temp new table */
+    unsigned char *newclmap = nullptr;            /* temp new map table */
+    unsigned char *newcumap = nullptr;            /* temp new map table */
+
+    /* non-C locale table for wchar_t's */
+
+    unsigned char *cbuffer = nullptr;      /* char working buffer */
+
+    int i;                              /* general purpose counter */
+    unsigned char *cp;                  /* char pointer */
+    CPINFO cpInfo;                      /* struct for use with GetCPInfo */
+    int mb_cur_max;
+    __crt_locale_pointers locinfo;
+
+    locinfo.locinfo = ploci;
+    locinfo.mbcinfo = 0;
+
+    /* allocate and set up buffers before destroying old ones */
+    /* codepage will be restored by setlocale if error */
+
+    if (ploci->locale_name[LC_CTYPE] != nullptr)
+    {
+        long* refcount = nullptr;
+
+        if (ploci->_public._locale_lc_codepage == 0)
+        { /* code page was not specified */
+            if ( __acrt_GetLocaleInfoA( &locinfo, LC_INT_TYPE,
+                                  ploci->locale_name[LC_CTYPE],
+                                  LOCALE_IDEFAULTANSICODEPAGE,
+                                  (char **)&ploci->_public._locale_lc_codepage ) )
+                goto error_cleanup;
+        }
+
+        /* allocate a new (thread) reference counter */
+        refcount = _calloc_crt_t(long, 1).detach();
+
+        /* allocate new buffers for tables */
+        newctype1 = _calloc_crt_t(unsigned short, _COFFSET + _CTABSIZE).detach();
+        newclmap  = _calloc_crt_t(unsigned char,  _COFFSET + _CTABSIZE).detach();
+        newcumap  = _calloc_crt_t(unsigned char,  _COFFSET + _CTABSIZE).detach();
+        cbuffer   = _calloc_crt_t(unsigned char,  _CTABSIZE).detach();
+
+        if (!refcount || !newctype1 || !cbuffer || !newclmap || !newcumap)
+            goto error_cleanup;
+
+        /* construct string composed of first 256 chars in sequence */
+        for (cp=cbuffer, i=0; i<_CTABSIZE-1; i++)
+            *cp++ = (unsigned char)i;
+
+        if (GetCPInfo( ploci->_public._locale_lc_codepage, &cpInfo) == FALSE)
+            goto error_cleanup;
+
+        if (cpInfo.MaxCharSize > MB_LEN_MAX)
+            goto error_cleanup;
+
+        mb_cur_max = (unsigned short) cpInfo.MaxCharSize;
+
+        /* zero (space actually) out leadbytes so GetStringType and
+           LCMapStringA don't interpret them as multi-byte chars */
+        if (mb_cur_max > 1)
+        {
+            if (ploci->_public._locale_lc_codepage == CP_UTF8)
+            {
+                // For UTF-8 anything above 0x7f is part of a multibyte sequence and
+                // would confuse the codepage/character code below.
+                for (i = 0x80; i <= 0xff; i++)
+                {
+                    // spaces are safe.
+                    cbuffer[i] = ' ';
+                }
+            }
+            else
+            {
+                // use the lead byte table to mark off the appropriate bytes
+                for (cp = (unsigned char *)cpInfo.LeadByte; cp[0] && cp[1]; cp += 2)
+                {
+                    for (i = cp[0]; i <= cp[1]; i++)
+                        cbuffer[i] = ' ';
+                }
+            }
+        }
+
+        /*
+         * LCMapString will map past nullptr. Must find nullptr if in string
+         * before cchSrc characters.
+         */
+        if ( __acrt_LCMapStringA(nullptr,
+                    ploci->locale_name[LC_CTYPE],
+                    LCMAP_LOWERCASE,
+                    reinterpret_cast<char*>(cbuffer + 1),
+                    _CTABSIZE-2,
+                    reinterpret_cast<char*>(newclmap + 2 + _COFFSET),
+                    _CTABSIZE-2,
+                    ploci->_public._locale_lc_codepage,
+                    FALSE ) == FALSE)
+            goto error_cleanup;
+
+        if ( __acrt_LCMapStringA(nullptr,
+                    ploci->locale_name[LC_CTYPE],
+                    LCMAP_UPPERCASE,
+                    reinterpret_cast<char*>(cbuffer + 1),
+                    _CTABSIZE-2,
+                    reinterpret_cast<char*>(newcumap + 2 + _COFFSET),
+                    _CTABSIZE-2,
+                    ploci->_public._locale_lc_codepage,
+                    FALSE ) == FALSE)
+            goto error_cleanup;
+
+        /* convert to newctype1 table - ignore invalid char errors */
+        if ( __acrt_GetStringTypeA(nullptr,  CT_CTYPE1,
+                                  reinterpret_cast<char*>(cbuffer),
+                                  _CTABSIZE-1,
+                                  newctype1+1+_COFFSET,
+                                  ploci->_public._locale_lc_codepage,
+                                  FALSE ) == FALSE )
+            goto error_cleanup;
+
+        newctype1[_COFFSET] = 0; /* entry for EOF */
+        newclmap[_COFFSET] = 0;
+        newcumap[_COFFSET] = 0;
+        newclmap[_COFFSET+1] = 0; /* entry for null */
+        newcumap[_COFFSET+1] = 0; /* entry for null */
+
+        /* ignore DefaultChar */
+
+        /* mark lead-byte entries in newctype1 table and
+           restore original values for lead-byte entries for clmap/cumap */
+        if (mb_cur_max > 1)
+        {
+            if (ploci->_public._locale_lc_codepage == CP_UTF8)
+            {
+                // For UTF-8 anything above 0x7f is part of a multibyte sequence
+                // "real" leadbytes start with C0 and end at F7
+                // However, C0 & C1 are overlong encoded ASCII, F5 & F6 would be > U+10FFFF.
+                // Note that some starting with E0 and F0 are overlong and not legal though.
+                for (i = 0x80; i <= 0xff; i++)
+                {
+                    newctype1[_COFFSET + i + 1] = (i >= 0xc2 && i < 0xf5) ? _LEADBYTE : 0;
+                    newclmap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                    newcumap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                }
+            }
+            else
+            {
+                for (cp = (unsigned char *)cpInfo.LeadByte; cp[0] && cp[1]; cp += 2)
+                {
+                    for (i = cp[0]; i <= cp[1]; i++)
+                    {
+                        newctype1[_COFFSET + i + 1] = _LEADBYTE;
+                        newclmap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                        newcumap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                    }
+                }
+            }
+        }
+        /* copy last-1 _COFFSET unsigned short to front
+         * note -1, we don't really want to copy 0xff
+         */
+        memcpy(newctype1,newctype1+_CTABSIZE-1,_COFFSET*sizeof(unsigned short));
+        memcpy(newclmap,newclmap+_CTABSIZE-1,_COFFSET*sizeof(char));
+        memcpy(newcumap,newcumap+_CTABSIZE-1,_COFFSET*sizeof(char));
+
+        /* free old tables */
+        if ((ploci->ctype1_refcount) &&
+            (InterlockedDecrement(ploci->ctype1_refcount) == 0))
+        {
+            _ASSERT(0);
+            _free_crt(ploci->ctype1 - _COFFSET);
+            _free_crt((char *)(ploci->pclmap - _COFFSET - 1));
+            _free_crt((char *)(ploci->pcumap - _COFFSET - 1));
+            _free_crt(ploci->ctype1_refcount);
+        }
+        (*refcount) = 1;
+        ploci->ctype1_refcount = refcount;
+        /* set pointers to point to entry 0 of tables */
+        ploci->_public._locale_pctype     = newctype1 + 1 + _COFFSET;
+        ploci->ctype1                     = newctype1 +     _COFFSET;
+        ploci->pclmap                     = newclmap  + 1 + _COFFSET;
+        ploci->pcumap                     = newcumap  + 1 + _COFFSET;
+        ploci->_public._locale_mb_cur_max = mb_cur_max;
+
+        /* cleanup and return success */
+        _free_crt (cbuffer);
+        return 0;
+
+error_cleanup:
+        _free_crt (refcount);
+        _free_crt (newctype1);
+        _free_crt (newclmap);
+        _free_crt (newcumap);
+        _free_crt (cbuffer);
+        return 1;
+
+    } else {
+
+        if ( (ploci->ctype1_refcount != nullptr)&&
+             (InterlockedDecrement(ploci->ctype1_refcount) == 0))
+        {
+            _ASSERTE(ploci->ctype1_refcount > 0);
+        }
+        ploci->ctype1_refcount        = nullptr;
+        ploci->ctype1                 = nullptr;
+        ploci->_public._locale_pctype = __newctype + 1 + _COFFSET;
+        ploci->pclmap                 = __newclmap + 1 + _COFFSET;
+        ploci->pcumap                 = __newcumap + 1 + _COFFSET;
+        ploci->_public._locale_mb_cur_max = 1;
+
+        return 0;
+    }
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/* Define a number of functions which exist so, under _STATIC_CPPLIB, the
+ * static multithread C++ Library libcpmt.lib can access data found in the
+ * main CRT DLL without using __declspec(dllimport).
+ */
+
+int __cdecl ___mb_cur_max_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->_public._locale_mb_cur_max;
+}
+
+int __cdecl ___mb_cur_max_l_func(_locale_t locale)
+{
+    return locale == nullptr
+        ? ___mb_cur_max_func()
+        : locale->locinfo->_public._locale_mb_cur_max;
+}
+
+unsigned int __cdecl ___lc_codepage_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->_public._locale_lc_codepage;
+}
+
+unsigned int __cdecl ___lc_collate_cp_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->lc_collate_cp;
+}
+
+wchar_t** __cdecl ___lc_locale_name_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->locale_name;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initmon.cpp

@@ -0,0 +1,312 @@
+/***
+*initmon.c - contains __acrt_locale_initialize_monetary
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the locale-category initialization function: __acrt_locale_initialize_monetary().
+*
+*       Each initialization function sets up locale-specific information
+*       for their category, for use by functions which are affected by
+*       their locale category.
+*
+*       *** For internal use by setlocale() only ***
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+
+extern "C" {
+
+
+    // Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+static void fix_grouping(_Inout_z_ char *);
+
+/*
+ *  Note that __acrt_lconv_c is used when the monetary category is in the C locale
+ *  but the numeric category may not necessarily be in the C locale.
+ */
+
+
+/***
+*int __acrt_locale_initialize_monetary() - initialization for LC_MONETARY locale category.
+*
+*Purpose:
+*       In non-C locales, read the localized monetary strings into
+*       __acrt_lconv_intl, and also copy the numeric strings from __acrt_lconv into
+*       __acrt_lconv_intl.  Set __acrt_lconv to point to __acrt_lconv_intl.  The old
+*       __acrt_lconv_intl is not freed until the new one is fully established.
+*
+*       In the C locale, the monetary fields in lconv are filled with
+*       contain C locale values.  Any allocated __acrt_lconv_intl fields are freed.
+*
+*       At startup, __acrt_lconv points to a static lconv structure containing
+*       C locale strings.  This structure is never used again if
+*       __acrt_locale_initialize_monetary is called.
+*
+*Entry:
+*       None.
+*
+*Exit:
+*       0 success
+*       1 fail
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl __acrt_locale_initialize_monetary (
+        __crt_locale_data* ploci
+        )
+{
+    struct lconv *lc;
+    int ret;
+    wchar_t* ctrylocalename;
+    long *lc_refcount;
+    long *lconv_mon_refcount = nullptr;
+    __crt_locale_pointers locinfo;
+
+    locinfo.locinfo = ploci;
+    locinfo.mbcinfo = 0;
+
+    if ( (ploci->locale_name[LC_MONETARY] != nullptr) ||
+         (ploci->locale_name[LC_NUMERIC] != nullptr) )
+    {
+        /*
+         * Allocate structure filled with nullptr pointers
+         */
+        if ((lc = _calloc_crt_t(lconv, 1).detach()) == nullptr)
+            return 1;
+
+        /*
+         * Allocate a new reference counter for the lconv structure
+         */
+        if ( (lc_refcount = _calloc_crt_t(long, 1).detach()) == nullptr )
+        {
+            _free_crt(lc);
+            return 1;
+        }
+
+        if ( ploci->locale_name[LC_MONETARY] != nullptr )
+        {
+            /*
+             * Allocate a new reference counter for the numeric info
+             */
+            if ( (lconv_mon_refcount = _calloc_crt_t(long, 1).detach()) == nullptr )
+            {
+                _free_crt(lc);
+                _free_crt(lc_refcount);
+                return 1;
+            }
+
+            /*
+             * Currency is country--not language--dependent. NT
+             * work-around.
+             */
+            ctrylocalename = ploci->locale_name[LC_MONETARY];
+
+            ret = 0;
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SINTLSYMBOL, (void *)&lc->int_curr_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SCURRENCY, (void *)&lc->currency_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SMONDECIMALSEP, (void *)&lc->mon_decimal_point );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SMONTHOUSANDSEP, (void *)&lc->mon_thousands_sep );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SMONGROUPING, (void *)&lc->mon_grouping );
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SPOSITIVESIGN, (void *)&lc->positive_sign);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SNEGATIVESIGN, (void *)&lc->negative_sign);
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IINTLCURRDIGITS, (void *)&lc->int_frac_digits);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_ICURRDIGITS, (void *)&lc->frac_digits);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IPOSSYMPRECEDES, (void *)&lc->p_cs_precedes);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IPOSSEPBYSPACE, (void *)&lc->p_sep_by_space);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_INEGSYMPRECEDES, (void *)&lc->n_cs_precedes);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_INEGSEPBYSPACE, (void *)&lc->n_sep_by_space);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IPOSSIGNPOSN, (void *)&lc->p_sign_posn);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_INEGSIGNPOSN, (void *)&lc->n_sign_posn);
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SINTLSYMBOL, (void *)&lc->_W_int_curr_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SCURRENCY, (void *)&lc->_W_currency_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SMONDECIMALSEP, (void *)&lc->_W_mon_decimal_point );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SMONTHOUSANDSEP, (void *)&lc->_W_mon_thousands_sep );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SPOSITIVESIGN, (void *)&lc->_W_positive_sign);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SNEGATIVESIGN, (void *)&lc->_W_negative_sign);
+
+            if ( ret != 0 ) {
+                __acrt_locale_free_monetary(lc);
+                _free_crt(lc);
+                _free_crt(lc_refcount);
+                _free_crt(lconv_mon_refcount);
+                return 1;
+            }
+
+            fix_grouping(lc->mon_grouping);
+        }
+        else {
+            /*
+             * C locale for monetary category (the numeric category fields,
+             * which are NOT of the C locale, get fixed up below). Note
+             * that __acrt_lconv_c is copied, rather than directly assigning
+             * the fields of lc because of the uncertainty of the values of
+             * the int_frac_digits,..., n_sign_posn fields (SCHAR_MAX or
+             * UCHAR_MAX, depending on whether or a compliand was built
+             * with -J.
+             */
+            *lc = __acrt_lconv_c;
+        }
+
+        /*
+         * Copy the numeric locale fields from the old struct
+         */
+        lc->decimal_point = ploci->lconv->decimal_point;
+        lc->thousands_sep = ploci->lconv->thousands_sep;
+        lc->grouping = ploci->lconv->grouping;
+        lc->_W_decimal_point = ploci->lconv->_W_decimal_point;
+        lc->_W_thousands_sep = ploci->lconv->_W_thousands_sep;
+
+        *lc_refcount = 1;
+        if (lconv_mon_refcount)
+            *lconv_mon_refcount = 1;
+    }
+    else {
+        /*
+         * C locale for BOTH monetary and numeric categories.
+         */
+        lconv_mon_refcount = nullptr;
+        lc_refcount = nullptr;
+        lc = &__acrt_lconv_c;           /* point to new one */
+
+    }
+
+    if ( (ploci->lconv_mon_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_mon_refcount) == 0))
+    {
+        _ASSERTE(ploci->lconv_mon_refcount > 0);
+    }
+    if ( (ploci->lconv_intl_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_intl_refcount) == 0))
+    {
+        _free_crt(ploci->lconv);
+        _free_crt(ploci->lconv_intl_refcount);
+    }
+    ploci->lconv_mon_refcount = lconv_mon_refcount;
+    ploci->lconv_intl_refcount = lc_refcount;
+    ploci->lconv = lc;                       /* point to new one */
+
+    return 0;
+}
+
+static void fix_grouping(
+        char *grouping
+        )
+{
+    /*
+     * ANSI specifies that the fields should contain "\3" [\3\0] to indicate
+     * thousands groupings (100,000,000.00 for example).
+     * NT uses "3;0"; ASCII 3 instead of value 3 and the ';' is extra.
+     * So here we convert the NT version to the ANSI version.
+     */
+
+    while (*grouping)
+    {
+        /* convert '3' to '\3' */
+        if (*grouping >= '0' && *grouping <= '9')
+        {
+            *grouping = *grouping - '0';
+            grouping++;
+        }
+
+        /* remove ';' */
+        else if (*grouping == ';')
+        {
+            char *tmp = grouping;
+
+            do
+                *tmp = *(tmp+1);
+            while (*++tmp);
+        }
+
+        /* unknown (illegal) character, ignore */
+        else
+            grouping++;
+    }
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/*
+ *  Free the lconv monetary strings.
+ *  Numeric values do not need to be freed.
+ */
+void __cdecl __acrt_locale_free_monetary(lconv* l)
+{
+    if (l == nullptr)
+        return;
+
+    if ( l->int_curr_symbol != __acrt_lconv_c.int_curr_symbol )
+        _free_crt(l->int_curr_symbol);
+
+    if ( l->currency_symbol != __acrt_lconv_c.currency_symbol )
+        _free_crt(l->currency_symbol);
+
+    if ( l->mon_decimal_point != __acrt_lconv_c.mon_decimal_point )
+        _free_crt(l->mon_decimal_point);
+
+    if ( l->mon_thousands_sep != __acrt_lconv_c.mon_thousands_sep )
+        _free_crt(l->mon_thousands_sep);
+
+    if ( l->mon_grouping != __acrt_lconv_c.mon_grouping )
+        _free_crt(l->mon_grouping);
+
+    if ( l->positive_sign != __acrt_lconv_c.positive_sign )
+        _free_crt(l->positive_sign);
+
+    if ( l->negative_sign != __acrt_lconv_c.negative_sign )
+        _free_crt(l->negative_sign);
+
+    if ( l->_W_int_curr_symbol != __acrt_lconv_c._W_int_curr_symbol )
+        _free_crt(l->_W_int_curr_symbol);
+
+    if ( l->_W_currency_symbol != __acrt_lconv_c._W_currency_symbol )
+        _free_crt(l->_W_currency_symbol);
+
+    if ( l->_W_mon_decimal_point != __acrt_lconv_c._W_mon_decimal_point )
+        _free_crt(l->_W_mon_decimal_point);
+
+    if ( l->_W_mon_thousands_sep != __acrt_lconv_c._W_mon_thousands_sep )
+        _free_crt(l->_W_mon_thousands_sep);
+
+    if ( l->_W_positive_sign != __acrt_lconv_c._W_positive_sign )
+        _free_crt(l->_W_positive_sign);
+
+    if ( l->_W_negative_sign != __acrt_lconv_c._W_negative_sign )
+        _free_crt(l->_W_negative_sign);
+}
+
+
+
+} // extern "C"

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initnum.cpp

@@ -0,0 +1,235 @@
+/***
+*initnum.c - contains __acrt_locale_initialize_numeric
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the locale-category initialization function: __acrt_locale_initialize_numeric().
+*
+*       Each initialization function sets up locale-specific information
+*       for their category, for use by functions which are affected by
+*       their locale category.
+*
+*       *** For internal use by setlocale() only ***
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+
+extern "C" {
+
+    // Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+static void fix_grouping(
+        _Inout_z_   char *  grouping
+        )
+{
+    /*
+     * ANSI specifies that the fields should contain "\3" [\3\0] to indicate
+     * thousands groupings (100,000,000.00 for example).
+     * NT uses "3;0"; ASCII 3 instead of value 3 and the ';' is extra.
+     * So here we convert the NT version to the ANSI version.
+     */
+
+    while (*grouping)
+    {
+        /* convert '3' to '\3' */
+        if (*grouping >= '0' && *grouping <= '9')
+        {
+            *grouping = *grouping - '0';
+            grouping++;
+        }
+
+        /* remove ';' */
+        else if (*grouping == ';')
+        {
+            char *tmp = grouping;
+
+            do
+                *tmp = *(tmp+1);
+            while (*++tmp);
+        }
+
+        /* unknown (illegal) character, ignore */
+        else
+            grouping++;
+    }
+}
+
+/***
+*int __acrt_locale_initialize_numeric() - initialization for LC_NUMERIC locale category.
+*
+*Purpose:
+*
+*Entry:
+*       None.
+*
+*Exit:
+*       0 success
+*       1 fail
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl __acrt_locale_initialize_numeric (
+        __crt_locale_data* ploci
+        )
+{
+    struct lconv *lc;
+    int ret = 0;
+    wchar_t* ctrylocalename;
+    long *lc_refcount;
+    long *lconv_num_refcount = nullptr;
+    __crt_locale_pointers locinfo;
+
+    locinfo.locinfo = ploci;
+    locinfo.mbcinfo = 0;
+
+    if ( (ploci->locale_name[LC_NUMERIC] != nullptr) ||
+         (ploci->locale_name[LC_MONETARY] != nullptr) )
+    {
+        /*
+         * Allocate structure filled with nullptr pointers
+         */
+        if ( (lc = (struct lconv *)_calloc_crt(1, sizeof(struct lconv)))
+             == nullptr )
+            return 1;
+
+        /*
+         * Copy over all fields (esp., the monetary category)
+         */
+        *lc = *ploci->lconv;
+
+        /*
+         * Allocate a new reference counter for the lconv structure
+         */
+        if ( (lc_refcount = _malloc_crt_t(long, 1).detach()) == nullptr )
+        {
+            _free_crt(lc);
+            return 1;
+        }
+        *lc_refcount = 0;
+
+        if ( ploci->locale_name[LC_NUMERIC] != nullptr )
+        {
+            /*
+             * Allocate a new reference counter for the numeric info
+             */
+            if ( (lconv_num_refcount = _malloc_crt_t(long, 1).detach()) == nullptr )
+            {
+                _free_crt(lc);
+                _free_crt(lc_refcount);
+                return 1;
+            }
+            *lconv_num_refcount = 0;
+
+            /*
+             * Numeric data is country--not language--dependent.
+             */
+            ctrylocalename = ploci->locale_name[LC_NUMERIC];
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename, LOCALE_SDECIMAL,
+                    (void *)&lc->decimal_point);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename, LOCALE_STHOUSAND,
+                    (void *)&lc->thousands_sep);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename, LOCALE_SGROUPING,
+                    (void *)&lc->grouping);
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename, LOCALE_SDECIMAL,
+                    (void *)&lc->_W_decimal_point);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename, LOCALE_STHOUSAND,
+                    (void *)&lc->_W_thousands_sep);
+
+            if (ret) {
+                    /* Clean up before returning failure */
+                    __acrt_locale_free_numeric(lc);
+                    _free_crt(lc);
+                    _free_crt(lconv_num_refcount);
+                    _free_crt(lc_refcount);
+                    return -1;
+            }
+
+            fix_grouping(lc->grouping);
+        }
+        else {
+            /*
+             * C locale for just the numeric category.
+             */
+            /*
+             * nullptr out the reference count pointer
+             */
+            lconv_num_refcount = nullptr;
+            lc->decimal_point = __acrt_lconv_c.decimal_point;
+            lc->thousands_sep = __acrt_lconv_c.thousands_sep;
+            lc->grouping = __acrt_lconv_c.grouping;
+            lc->_W_decimal_point = __acrt_lconv_c._W_decimal_point;
+            lc->_W_thousands_sep = __acrt_lconv_c._W_thousands_sep;
+        }
+        (*lc_refcount) = 1;
+        if (lconv_num_refcount)
+            (*lconv_num_refcount) = 1;
+    }
+
+    else {
+        /*
+         * C locale for BOTH numeric and monetary categories.
+         */
+        lconv_num_refcount = nullptr;
+        lc_refcount = nullptr;
+        lc = &__acrt_lconv_c;           /* point to new one */
+    }
+    /*
+     * If this is part of LC_ALL, then we need to free the old ploci->lconv
+     * set up in init_monetary() before this.
+     */
+    if ( (ploci->lconv_num_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_num_refcount) == 0))
+    {
+        _ASSERTE(ploci->lconv_num_refcount > 0);
+    }
+    if ( (ploci->lconv_intl_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_intl_refcount) == 0))
+    {
+        _free_crt(ploci->lconv_intl_refcount);
+        _free_crt(ploci->lconv);
+    }
+
+    ploci->lconv_num_refcount = lconv_num_refcount;
+    ploci->lconv_intl_refcount = lc_refcount;
+
+    ploci->lconv = lc;
+    return 0;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/*
+ *  Free the lconv numeric strings.
+ *  Numeric values do not need to be freed.
+ */
+void __cdecl __acrt_locale_free_numeric(lconv* l)
+{
+    if (l == nullptr)
+        return;
+
+    if ( l->decimal_point != __acrt_lconv_c.decimal_point )
+        _free_crt(l->decimal_point);
+
+    if ( l->thousands_sep != __acrt_lconv_c.thousands_sep )
+        _free_crt(l->thousands_sep);
+
+    if ( l->grouping != __acrt_lconv_c.grouping )
+        _free_crt(l->grouping);
+
+    if ( l->_W_decimal_point != __acrt_lconv_c._W_decimal_point )
+        _free_crt(l->_W_decimal_point);
+
+    if ( l->_W_thousands_sep != __acrt_lconv_c._W_thousands_sep )
+        _free_crt(l->_W_thousands_sep);
+}
+
+
+
+} // extern "C"

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/inittime.cpp

@@ -0,0 +1,177 @@
+//
+// inittime.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functionality for initializing and destroying LC_TIME category data structures
+//
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+
+// Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+_Success_(return != false)
+static bool __cdecl initialize_lc_time(
+    _Inout_ __crt_lc_time_data* const lc_time,
+    _In_    __crt_locale_data*  const locale_data
+    ) throw()
+{
+    wchar_t const* const locale_name = locale_data->locale_name[LC_TIME];
+
+    __crt_locale_pointers locinfo = { locale_data, nullptr };
+
+    lc_time->_W_ww_locale_name = __acrt_copy_locale_name(locale_name);
+
+    int ret = 0;
+
+    // The days of the week.  Note that the OS days are numbered 1-7, starting
+    // with Monday, whereas the lc_time days are numbered (indexed, really) 0-6
+    // starting with Sunday (thus the adjustment to the index in the loop).
+    for (unsigned int i = 0; i != 7; ++i)
+    {
+        unsigned int const result_index = (i + 1) % 7;
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SABBREVDAYNAME1 + i, &lc_time->wday_abbr[result_index]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SDAYNAME1       + i, &lc_time->wday     [result_index]);
+
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SABBREVDAYNAME1 + i, &lc_time->_W_wday_abbr[result_index]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SDAYNAME1       + i, &lc_time->_W_wday     [result_index]);
+    }
+
+    // The months of the year
+    for (unsigned int i = 0; i != 12; ++i)
+    {
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE,  locale_name, LOCALE_SABBREVMONTHNAME1 + i, &lc_time->month_abbr[i]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE,  locale_name, LOCALE_SMONTHNAME1       + i, &lc_time->month     [i]);
+
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SABBREVMONTHNAME1 + i, &lc_time->_W_month_abbr[i]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SMONTHNAME1       + i, &lc_time->_W_month     [i]);
+    }
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_S1159, &lc_time->ampm[0]);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_S2359, &lc_time->ampm[1]);
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_S1159, &lc_time->_W_ampm[0]);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_S2359, &lc_time->_W_ampm[1]);
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SSHORTDATE,    &lc_time->ww_sdatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SLONGDATE,     &lc_time->ww_ldatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_STIMEFORMAT,   &lc_time->ww_timefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, locale_name, LOCALE_ICALENDARTYPE, &lc_time->ww_caltype);
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SSHORTDATE,  &lc_time->_W_ww_sdatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SLONGDATE,   &lc_time->_W_ww_ldatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_STIMEFORMAT, &lc_time->_W_ww_timefmt);
+
+    return ret == 0;
+}
+
+
+
+_Success_(return != nullptr)
+static __crt_lc_time_data const* __cdecl get_or_create_lc_time(
+    _In_ __crt_locale_data* const locale_data
+    ) throw()
+{
+    // C Locale
+    if (!locale_data->locale_name[LC_TIME])
+    {
+        return &__lc_time_c;
+    }
+
+    // Non-C Locale
+    __crt_unique_heap_ptr<__crt_lc_time_data> lc_time = _calloc_crt_t(__crt_lc_time_data, 1);
+    if (!lc_time)
+    {
+        return nullptr;
+    }
+
+    if (!initialize_lc_time(lc_time.get(), locale_data))
+    {
+        __acrt_locale_free_time(lc_time.get());
+        return nullptr;
+    }
+
+    lc_time.get()->refcount = 1;
+
+    return lc_time.detach();
+}
+
+
+
+extern "C" int __cdecl __acrt_locale_initialize_time(
+    __crt_locale_data* const locale_data
+    )
+{
+    __crt_lc_time_data const* const lc_time = get_or_create_lc_time(locale_data);
+    if (!lc_time)
+    {
+        return 1;
+    }
+
+    if (__acrt_locale_release_lc_time_reference(locale_data->lc_time_curr) == 0)
+    {
+        _ASSERTE(("lc_time_curr unexpectedly has no remaining references", 0));
+    }
+
+    locale_data->lc_time_curr = lc_time;
+    return 0;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+
+static void __cdecl free_crt_array_internal(
+    _Inout_updates_(array_count) void const** const array,
+    _In_                         size_t       const array_count
+    ) throw()
+{
+    for (void const* const* it = array; it != array + array_count; ++it)
+    {
+        _free_crt(const_cast<void*>(*it));
+    }
+}
+
+
+
+template <typename T, size_t N>
+static void __cdecl free_crt_array(_Inout_ T* (&array)[N]) throw()
+{
+    return free_crt_array_internal(const_cast<void const**>(reinterpret_cast<void const* const*>(array)), N);
+}
+
+
+
+extern "C" void __cdecl __acrt_locale_free_time(
+    __crt_lc_time_data* const lc_time
+    )
+{
+    if (!lc_time)
+    {
+        return;
+    }
+
+    free_crt_array(lc_time->wday_abbr);
+    free_crt_array(lc_time->wday);
+    free_crt_array(lc_time->month_abbr);
+    free_crt_array(lc_time->month);
+    free_crt_array(lc_time->ampm);
+
+    _free_crt(lc_time->ww_sdatefmt);
+    _free_crt(lc_time->ww_ldatefmt);
+    _free_crt(lc_time->ww_timefmt);
+
+    free_crt_array(lc_time->_W_wday_abbr);
+    free_crt_array(lc_time->_W_wday);
+    free_crt_array(lc_time->_W_month_abbr);
+    free_crt_array(lc_time->_W_month);
+    free_crt_array(lc_time->_W_ampm);
+
+    _free_crt(lc_time->_W_ww_sdatefmt);
+    _free_crt(lc_time->_W_ww_ldatefmt);
+    _free_crt(lc_time->_W_ww_timefmt);
+
+    _free_crt(lc_time->_W_ww_locale_name);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lcidtoname_downlevel.cpp

@@ -0,0 +1,604 @@
+//
+// lcidtoname_downlevel.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of wrappers for the Windows XP API functions that are not available on
+// all supported operating system versions.
+//
+
+#include <corecrt_internal.h>
+
+namespace {
+
+// Map of LCID to locale name.
+struct LcidToLocaleName
+{
+    LCID      lcid;
+    wchar_t*  localeName;
+};
+
+// Map of locale name to an index.
+struct LocaleNameIndex
+{
+    wchar_t*  name;
+    int       index;
+};
+
+// Map of LCID to locale name for Windows XP.
+// Data in this table has been obtained from National Language Support (NLS) API Reference at
+// http://msdn.microsoft.com/en-us/goglobal/bb896001.aspx
+// The table is sorted to improve search performance.
+static const LcidToLocaleName LcidToLocaleNameTable[] =
+{
+    { 0x0001, L"ar"         },
+    { 0x0002, L"bg"         },
+    { 0x0003, L"ca"         },
+    { 0x0004, L"zh-CHS"     },
+    { 0x0005, L"cs"         },
+    { 0x0006, L"da"         },
+    { 0x0007, L"de"         },
+    { 0x0008, L"el"         },
+    { 0x0009, L"en"         },
+    { 0x000A, L"es"         },
+    { 0x000B, L"fi"         },
+    { 0x000C, L"fr"         },
+    { 0x000D, L"he"         },
+    { 0x000E, L"hu"         },
+    { 0x000F, L"is"         },
+    { 0x0010, L"it"         },
+    { 0x0011, L"ja"         },
+    { 0x0012, L"ko"         },
+    { 0x0013, L"nl"         },
+    { 0x0014, L"no"         },
+    { 0x0015, L"pl"         },
+    { 0x0016, L"pt"         },
+    { 0x0018, L"ro"         },
+    { 0x0019, L"ru"         },
+    { 0x001A, L"hr"         },
+    { 0x001B, L"sk"         },
+    { 0x001C, L"sq"         },
+    { 0x001D, L"sv"         },
+    { 0x001E, L"th"         },
+    { 0x001F, L"tr"         },
+    { 0x0020, L"ur"         },
+    { 0x0021, L"id"         },
+    { 0x0022, L"uk"         },
+    { 0x0023, L"be"         },
+    { 0x0024, L"sl"         },
+    { 0x0025, L"et"         },
+    { 0x0026, L"lv"         },
+    { 0x0027, L"lt"         },
+    { 0x0029, L"fa"         },
+    { 0x002A, L"vi"         },
+    { 0x002B, L"hy"         },
+    { 0x002C, L"az"         },
+    { 0x002D, L"eu"         },
+    { 0x002F, L"mk"         },
+    { 0x0036, L"af"         },
+    { 0x0037, L"ka"         },
+    { 0x0038, L"fo"         },
+    { 0x0039, L"hi"         },
+    { 0x003E, L"ms"         },
+    { 0x003F, L"kk"         },
+    { 0x0040, L"ky"         },
+    { 0x0041, L"sw"         },
+    { 0x0043, L"uz"         },
+    { 0x0044, L"tt"         },
+    { 0x0046, L"pa"         },
+    { 0x0047, L"gu"         },
+    { 0x0049, L"ta"         },
+    { 0x004A, L"te"         },
+    { 0x004B, L"kn"         },
+    { 0x004E, L"mr"         },
+    { 0x004F, L"sa"         },
+    { 0x0050, L"mn"         },
+    { 0x0056, L"gl"         },
+    { 0x0057, L"kok"        },
+    { 0x005A, L"syr"        },
+    { 0x0065, L"div"        },
+    { 0x007f, L""           },
+    { 0x0401, L"ar-SA"      },
+    { 0x0402, L"bg-BG"      },
+    { 0x0403, L"ca-ES"      },
+    { 0x0404, L"zh-TW"      },
+    { 0x0405, L"cs-CZ"      },
+    { 0x0406, L"da-DK"      },
+    { 0x0407, L"de-DE"      },
+    { 0x0408, L"el-GR"      },
+    { 0x0409, L"en-US"      },
+    { 0x040B, L"fi-FI"      },
+    { 0x040C, L"fr-FR"      },
+    { 0x040D, L"he-IL"      },
+    { 0x040E, L"hu-HU"      },
+    { 0x040F, L"is-IS"      },
+    { 0x0410, L"it-IT"      },
+    { 0x0411, L"ja-JP"      },
+    { 0x0412, L"ko-KR"      },
+    { 0x0413, L"nl-NL"      },
+    { 0x0414, L"nb-NO"      },
+    { 0x0415, L"pl-PL"      },
+    { 0x0416, L"pt-BR"      },
+    { 0x0418, L"ro-RO"      },
+    { 0x0419, L"ru-RU"      },
+    { 0x041A, L"hr-HR"      },
+    { 0x041B, L"sk-SK"      },
+    { 0x041C, L"sq-AL"      },
+    { 0x041D, L"sv-SE"      },
+    { 0x041E, L"th-TH"      },
+    { 0x041F, L"tr-TR"      },
+    { 0x0420, L"ur-PK"      },
+    { 0x0421, L"id-ID"      },
+    { 0x0422, L"uk-UA"      },
+    { 0x0423, L"be-BY"      },
+    { 0x0424, L"sl-SI"      },
+    { 0x0425, L"et-EE"      },
+    { 0x0426, L"lv-LV"      },
+    { 0x0427, L"lt-LT"      },
+    { 0x0429, L"fa-IR"      },
+    { 0x042A, L"vi-VN"      },
+    { 0x042B, L"hy-AM"      },
+    { 0x042C, L"az-AZ-Latn" },
+    { 0x042D, L"eu-ES"      },
+    { 0x042F, L"mk-MK"      },
+    { 0x0432, L"tn-ZA"      },
+    { 0x0434, L"xh-ZA"      },
+    { 0x0435, L"zu-ZA"      },
+    { 0x0436, L"af-ZA"      },
+    { 0x0437, L"ka-GE"      },
+    { 0x0438, L"fo-FO"      },
+    { 0x0439, L"hi-IN"      },
+    { 0x043A, L"mt-MT"      },
+    { 0x043B, L"se-NO"      },
+    { 0x043E, L"ms-MY"      },
+    { 0x043F, L"kk-KZ"      },
+    { 0x0440, L"ky-KG"      },
+    { 0x0441, L"sw-KE"      },
+    { 0x0443, L"uz-UZ-Latn" },
+    { 0x0444, L"tt-RU"      },
+    { 0x0445, L"bn-IN"      },
+    { 0x0446, L"pa-IN"      },
+    { 0x0447, L"gu-IN"      },
+    { 0x0449, L"ta-IN"      },
+    { 0x044A, L"te-IN"      },
+    { 0x044B, L"kn-IN"      },
+    { 0x044C, L"ml-IN"      },
+    { 0x044E, L"mr-IN"      },
+    { 0x044F, L"sa-IN"      },
+    { 0x0450, L"mn-MN"      },
+    { 0x0452, L"cy-GB"      },
+    { 0x0456, L"gl-ES"      },
+    { 0x0457, L"kok-IN"     },
+    { 0x045A, L"syr-SY"     },
+    { 0x0465, L"div-MV"     },
+    { 0x046B, L"quz-BO"     },
+    { 0x046C, L"ns-ZA"      },
+    { 0x0481, L"mi-NZ"      },
+    { 0x0801, L"ar-IQ"      },
+    { 0x0804, L"zh-CN"      },
+    { 0x0807, L"de-CH"      },
+    { 0x0809, L"en-GB"      },
+    { 0x080A, L"es-MX"      },
+    { 0x080C, L"fr-BE"      },
+    { 0x0810, L"it-CH"      },
+    { 0x0813, L"nl-BE"      },
+    { 0x0814, L"nn-NO"      },
+    { 0x0816, L"pt-PT"      },
+    { 0x081A, L"sr-SP-Latn" },
+    { 0x081D, L"sv-FI"      },
+    { 0x082C, L"az-AZ-Cyrl" },
+    { 0x083B, L"se-SE"      },
+    { 0x083E, L"ms-BN"      },
+    { 0x0843, L"uz-UZ-Cyrl" },
+    { 0x086B, L"quz-EC"     },
+    { 0x0C01, L"ar-EG"      },
+    { 0x0C04, L"zh-HK"      },
+    { 0x0C07, L"de-AT"      },
+    { 0x0C09, L"en-AU"      },
+    { 0x0C0A, L"es-ES"      },
+    { 0x0C0C, L"fr-CA"      },
+    { 0x0C1A, L"sr-SP-Cyrl" },
+    { 0x0C3B, L"se-FI"      },
+    { 0x0C6B, L"quz-PE"     },
+    { 0x1001, L"ar-LY"      },
+    { 0x1004, L"zh-SG"      },
+    { 0x1007, L"de-LU"      },
+    { 0x1009, L"en-CA"      },
+    { 0x100A, L"es-GT"      },
+    { 0x100C, L"fr-CH"      },
+    { 0x101A, L"hr-BA"      },
+    { 0x103B, L"smj-NO"     },
+    { 0x1401, L"ar-DZ"      },
+    { 0x1404, L"zh-MO"      },
+    { 0x1407, L"de-LI"      },
+    { 0x1409, L"en-NZ"      },
+    { 0x140A, L"es-CR"      },
+    { 0x140C, L"fr-LU"      },
+    { 0x141A, L"bs-BA-Latn" },
+    { 0x143B, L"smj-SE"     },
+    { 0x1801, L"ar-MA"      },
+    { 0x1809, L"en-IE"      },
+    { 0x180A, L"es-PA"      },
+    { 0x180C, L"fr-MC"      },
+    { 0x181A, L"sr-BA-Latn" },
+    { 0x183B, L"sma-NO"     },
+    { 0x1C01, L"ar-TN"      },
+    { 0x1C09, L"en-ZA"      },
+    { 0x1C0A, L"es-DO"      },
+    { 0x1C1A, L"sr-BA-Cyrl" },
+    { 0x1C3B, L"sma-SE"     },
+    { 0x2001, L"ar-OM"      },
+    { 0x2009, L"en-JM"      },
+    { 0x200A, L"es-VE"      },
+    { 0x203B, L"sms-FI"     },
+    { 0x2401, L"ar-YE"      },
+    { 0x2409, L"en-CB"      },
+    { 0x240A, L"es-CO"      },
+    { 0x243B, L"smn-FI"     },
+    { 0x2801, L"ar-SY"      },
+    { 0x2809, L"en-BZ"      },
+    { 0x280A, L"es-PE"      },
+    { 0x2C01, L"ar-JO"      },
+    { 0x2C09, L"en-TT"      },
+    { 0x2C0A, L"es-AR"      },
+    { 0x3001, L"ar-LB"      },
+    { 0x3009, L"en-ZW"      },
+    { 0x300A, L"es-EC"      },
+    { 0x3401, L"ar-KW"      },
+    { 0x3409, L"en-PH"      },
+    { 0x340A, L"es-CL"      },
+    { 0x3801, L"ar-AE"      },
+    { 0x380A, L"es-UY"      },
+    { 0x3C01, L"ar-BH"      },
+    { 0x3C0A, L"es-PY"      },
+    { 0x4001, L"ar-QA"      },
+    { 0x400A, L"es-BO"      },
+    { 0x440A, L"es-SV"      },
+    { 0x480A, L"es-HN"      },
+    { 0x4C0A, L"es-NI"      },
+    { 0x500A, L"es-PR"      },
+    { 0x7C04, L"zh-CHT"     },
+    { 0x7C1A, L"sr"         }
+};
+
+// Map of locale name to an index in LcidToLocaleNameTable, for Windows XP.
+// Data in this table has been obtained from National Language Support (NLS) API Reference at
+// http://msdn.microsoft.com/en-us/goglobal/bb896001.aspx
+// The table is sorted to improve search performance.
+static const LocaleNameIndex LocaleNameToIndexTable[] =
+{
+    { L""           , 66  },
+    { L"af"         , 44  },
+    { L"af-za"      , 113 },
+    { L"ar"         , 0   },
+    { L"ar-ae"      , 216 },
+    { L"ar-bh"      , 218 },
+    { L"ar-dz"      , 177 },
+    { L"ar-eg"      , 160 },
+    { L"ar-iq"      , 143 },
+    { L"ar-jo"      , 207 },
+    { L"ar-kw"      , 213 },
+    { L"ar-lb"      , 210 },
+    { L"ar-ly"      , 169 },
+    { L"ar-ma"      , 185 },
+    { L"ar-om"      , 196 },
+    { L"ar-qa"      , 220 },
+    { L"ar-sa"      , 67  },
+    { L"ar-sy"      , 204 },
+    { L"ar-tn"      , 191 },
+    { L"ar-ye"      , 200 },
+    { L"az"         , 41  },
+    { L"az-az-cyrl" , 155 },
+    { L"az-az-latn" , 107 },
+    { L"be"         , 33  },
+    { L"be-by"      , 99  },
+    { L"bg"         , 1   },
+    { L"bg-bg"      , 68  },
+    { L"bn-in"      , 125 },
+    { L"bs-ba-latn" , 183 },
+    { L"ca"         , 2   },
+    { L"ca-es"      , 69  },
+    { L"cs"         , 4   },
+    { L"cs-cz"      , 71  },
+    { L"cy-gb"      , 135 },
+    { L"da"         , 5   },
+    { L"da-dk"      , 72  },
+    { L"de"         , 6   },
+    { L"de-at"      , 162 },
+    { L"de-ch"      , 145 },
+    { L"de-de"      , 73  },
+    { L"de-li"      , 179 },
+    { L"de-lu"      , 171 },
+    { L"div"        , 65  },
+    { L"div-mv"     , 139 },
+    { L"el"         , 7   },
+    { L"el-gr"      , 74  },
+    { L"en"         , 8   },
+    { L"en-au"      , 163 },
+    { L"en-bz"      , 205 },
+    { L"en-ca"      , 172 },
+    { L"en-cb"      , 201 },
+    { L"en-gb"      , 146 },
+    { L"en-ie"      , 186 },
+    { L"en-jm"      , 197 },
+    { L"en-nz"      , 180 },
+    { L"en-ph"      , 214 },
+    { L"en-tt"      , 208 },
+    { L"en-us"      , 75  },
+    { L"en-za"      , 192 },
+    { L"en-zw"      , 211 },
+    { L"es"         , 9   },
+    { L"es-ar"      , 209 },
+    { L"es-bo"      , 221 },
+    { L"es-cl"      , 215 },
+    { L"es-co"      , 202 },
+    { L"es-cr"      , 181 },
+    { L"es-do"      , 193 },
+    { L"es-ec"      , 212 },
+    { L"es-es"      , 164 },
+    { L"es-gt"      , 173 },
+    { L"es-hn"      , 223 },
+    { L"es-mx"      , 147 },
+    { L"es-ni"      , 224 },
+    { L"es-pa"      , 187 },
+    { L"es-pe"      , 206 },
+    { L"es-pr"      , 225 },
+    { L"es-py"      , 219 },
+    { L"es-sv"      , 222 },
+    { L"es-uy"      , 217 },
+    { L"es-ve"      , 198 },
+    { L"et"         , 35  },
+    { L"et-ee"      , 101 },
+    { L"eu"         , 42  },
+    { L"eu-es"      , 108 },
+    { L"fa"         , 38  },
+    { L"fa-ir"      , 104 },
+    { L"fi"         , 10  },
+    { L"fi-fi"      , 76  },
+    { L"fo"         , 46  },
+    { L"fo-fo"      , 115 },
+    { L"fr"         , 11  },
+    { L"fr-be"      , 148 },
+    { L"fr-ca"      , 165 },
+    { L"fr-ch"      , 174 },
+    { L"fr-fr"      , 77  },
+    { L"fr-lu"      , 182 },
+    { L"fr-mc"      , 188 },
+    { L"gl"         , 62  },
+    { L"gl-es"      , 136 },
+    { L"gu"         , 55  },
+    { L"gu-in"      , 127 },
+    { L"he"         , 12  },
+    { L"he-il"      , 78  },
+    { L"hi"         , 47  },
+    { L"hi-in"      , 116 },
+    { L"hr"         , 24  },
+    { L"hr-ba"      , 175 },
+    { L"hr-hr"      , 90  },
+    { L"hu"         , 13  },
+    { L"hu-hu"      , 79  },
+    { L"hy"         , 40  },
+    { L"hy-am"      , 106 },
+    { L"id"         , 31  },
+    { L"id-id"      , 97  },
+    { L"is"         , 14  },
+    { L"is-is"      , 80  },
+    { L"it"         , 15  },
+    { L"it-ch"      , 149 },
+    { L"it-it"      , 81  },
+    { L"ja"         , 16  },
+    { L"ja-jp"      , 82  },
+    { L"ka"         , 45  },
+    { L"ka-ge"      , 114 },
+    { L"kk"         , 49  },
+    { L"kk-kz"      , 120 },
+    { L"kn"         , 58  },
+    { L"kn-in"      , 130 },
+    { L"ko"         , 17  },
+    { L"kok"        , 63  },
+    { L"kok-in"     , 137 },
+    { L"ko-kr"      , 83  },
+    { L"ky"         , 50  },
+    { L"ky-kg"      , 121 },
+    { L"lt"         , 37  },
+    { L"lt-lt"      , 103 },
+    { L"lv"         , 36  },
+    { L"lv-lv"      , 102 },
+    { L"mi-nz"      , 142 },
+    { L"mk"         , 43  },
+    { L"mk-mk"      , 109 },
+    { L"ml-in"      , 131 },
+    { L"mn"         , 61  },
+    { L"mn-mn"      , 134 },
+    { L"mr"         , 59  },
+    { L"mr-in"      , 132 },
+    { L"ms"         , 48  },
+    { L"ms-bn"      , 157 },
+    { L"ms-my"      , 119 },
+    { L"mt-mt"      , 117 },
+    { L"nb-no"      , 85  },
+    { L"nl"         , 18  },
+    { L"nl-be"      , 150 },
+    { L"nl-nl"      , 84  },
+    { L"nn-no"      , 151 },
+    { L"no"         , 19  },
+    { L"ns-za"      , 141 },
+    { L"pa"         , 54  },
+    { L"pa-in"      , 126 },
+    { L"pl"         , 20  },
+    { L"pl-pl"      , 86  },
+    { L"pt"         , 21  },
+    { L"pt-br"      , 87  },
+    { L"pt-pt"      , 152 },
+    { L"quz-bo"     , 140 },
+    { L"quz-ec"     , 159 },
+    { L"quz-pe"     , 168 },
+    { L"ro"         , 22  },
+    { L"ro-ro"      , 88  },
+    { L"ru"         , 23  },
+    { L"ru-ru"      , 89  },
+    { L"sa"         , 60  },
+    { L"sa-in"      , 133 },
+    { L"se-fi"      , 167 },
+    { L"se-no"      , 118 },
+    { L"se-se"      , 156 },
+    { L"sk"         , 25  },
+    { L"sk-sk"      , 91  },
+    { L"sl"         , 34  },
+    { L"sl-si"      , 100 },
+    { L"sma-no"     , 190 },
+    { L"sma-se"     , 195 },
+    { L"smj-no"     , 176 },
+    { L"smj-se"     , 184 },
+    { L"smn-fi"     , 203 },
+    { L"sms-fi"     , 199 },
+    { L"sq"         , 26  },
+    { L"sq-al"      , 92  },
+    { L"sr"         , 227 },
+    { L"sr-ba-cyrl" , 194 },
+    { L"sr-ba-latn" , 189 },
+    { L"sr-sp-cyrl" , 166 },
+    { L"sr-sp-latn" , 153 },
+    { L"sv"         , 27  },
+    { L"sv-fi"      , 154 },
+    { L"sv-se"      , 93  },
+    { L"sw"         , 51  },
+    { L"sw-ke"      , 122 },
+    { L"syr"        , 64  },
+    { L"syr-sy"     , 138 },
+    { L"ta"         , 56  },
+    { L"ta-in"      , 128 },
+    { L"te"         , 57  },
+    { L"te-in"      , 129 },
+    { L"th"         , 28  },
+    { L"th-th"      , 94  },
+    { L"tn-za"      , 110 },
+    { L"tr"         , 29  },
+    { L"tr-tr"      , 95  },
+    { L"tt"         , 53  },
+    { L"tt-ru"      , 124 },
+    { L"uk"         , 32  },
+    { L"uk-ua"      , 98  },
+    { L"ur"         , 30  },
+    { L"ur-pk"      , 96  },
+    { L"uz"         , 52  },
+    { L"uz-uz-cyrl" , 158 },
+    { L"uz-uz-latn" , 123 },
+    { L"vi"         , 39  },
+    { L"vi-vn"      , 105 },
+    { L"xh-za"      , 111 },
+    { L"zh-chs"     , 3   },
+    { L"zh-cht"     , 226 },
+    { L"zh-cn"      , 144 },
+    { L"zh-hk"      , 161 },
+    { L"zh-mo"      , 178 },
+    { L"zh-sg"      , 170 },
+    { L"zh-tw"      , 70  },
+    { L"zu-za"      , 112 }
+};
+
+} // unnamed namespace
+
+// Maps input locale name to the index on LcidToLocaleNameTable
+static int GetTableIndexFromLocaleName(const wchar_t* localeName) throw()
+{
+    LocaleNameIndex *localeNamesIndex = (LocaleNameIndex *) LocaleNameToIndexTable;
+    int bottom = 0;
+    int top = _countof(LocaleNameToIndexTable) - 1;
+
+    while (bottom <= top)
+    {
+        int middle = (bottom + top) / 2;
+        int testIndex = __ascii_wcsnicmp(localeName, localeNamesIndex[middle].name, LOCALE_NAME_MAX_LENGTH);
+
+        if (testIndex == 0)
+            return localeNamesIndex[middle].index;
+
+        if (testIndex < 0)
+            top = middle - 1;
+        else
+            bottom = middle + 1;
+    }
+
+    return -1;
+}
+
+// Maps input LCID to an index in LcidToLocaleNameTable
+static int GetTableIndexFromLcid(LCID lcid) throw()
+{
+
+    int bottom = 0;
+    int top = _countof(LcidToLocaleNameTable) - 1;
+
+    while (bottom <= top)
+    {
+        int middle = (bottom + top) / 2;
+        int testIndex = lcid - LcidToLocaleNameTable[middle].lcid;
+
+        if (testIndex == 0)
+            return middle;
+
+        if (testIndex < 0)
+            top = middle - 1;
+        else
+            bottom = middle + 1;
+    }
+
+    return -1;
+}
+
+
+extern "C" LCID __cdecl __acrt_DownlevelLocaleNameToLCID(LPCWSTR localeName)
+{
+    int index;
+
+    if (localeName == nullptr)
+        return 0;
+
+    index = GetTableIndexFromLocaleName(localeName);
+
+    if (index < 0 || (index >= _countof(LcidToLocaleNameTable)))
+        return 0;
+
+    return LcidToLocaleNameTable[index].lcid;
+}
+
+extern "C" int __cdecl __acrt_DownlevelLCIDToLocaleName(
+    LCID   lcid,
+    LPWSTR outLocaleName,
+    int    cchLocaleName
+    )
+{
+    size_t     count;
+    wchar_t*   buffer;
+    int        index;
+
+    if (lcid == 0                           ||
+        lcid == LOCALE_USER_DEFAULT         ||
+        lcid == LOCALE_SYSTEM_DEFAULT)
+    {
+        return 0;
+    }
+
+    if ((outLocaleName == nullptr && cchLocaleName>0) || cchLocaleName < 0)
+    {
+        return 0;
+    }
+
+    index = GetTableIndexFromLcid(lcid);
+    if (index < 0)
+        return 0;
+
+    buffer = LcidToLocaleNameTable[index].localeName;
+    count = wcsnlen(buffer, LOCALE_NAME_MAX_LENGTH);
+
+    if (cchLocaleName > 0)
+    {
+        if ((int)count >= cchLocaleName)
+            return 0;
+
+        _ERRCHECK(wcscpy_s(outLocaleName, cchLocaleName, buffer));
+    }
+
+    return (int) count + 1;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lconv_unsigned_char_initialization.cpp

@@ -0,0 +1,52 @@
+//
+// lconv_unsigned_char_initialization.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// lconv initialization used to support an unsigned 'char' type (enabled by the
+// -J flag during compilation).  Per the specification, some members of the lconv
+// structure must be initialized to CHAR_MAX.  The value of CHAR_MAX, however,
+// depends on whether the 'char' type is signed or unsigned (it is 127 for a
+// signed 'char'; 255 for an unsigned 'char').
+//
+// By default, these members of lconv are initialized to SCHAR_MAX (127).  If an
+// unsigned 'char' type is used, we call this function to update those members
+// to UCHAR_MAX (255).  Note that this is not done for DLLs that are linked to
+// the CRT DLL, because we do not want such DLLs to override the -J setting for
+// an EXE linked to the CRT DLL.
+//
+// There is code in several other files that is required to make all of this work:
+//
+// * locale.h:  When -J is used to compile a source file that includes <locale.h>,
+//   it generates an unresolved external to __do_unsigned_char_lconv_initialization.
+//
+// * lconv_unsigned_char_static.cpp:  This file defines a global variable named
+//   __do_unsigned_char_lconv_initialization, and is used during the link to
+//   satisfy the unresolved external.  This file adds a call to
+//   __initialize_lconv_for_unsigned_char to the list of initializers to be
+//   executed.  That function (defined below) updates the fields of the lconv
+//   structure to be set to UCHAR_MAX.
+//
+// * localeconv.cpp:  This file defines the __acrt_lconv_c structure.
+//
+#include <corecrt_internal.h>
+#include <limits.h>
+#include <locale.h>
+
+#pragma warning(disable: 4310) // cast truncates constant value
+
+
+
+extern "C" int __cdecl __initialize_lconv_for_unsigned_char()
+{
+    __acrt_lconv_c.int_frac_digits = (char)UCHAR_MAX;
+    __acrt_lconv_c.frac_digits     = (char)UCHAR_MAX;
+    __acrt_lconv_c.p_cs_precedes   = (char)UCHAR_MAX;
+    __acrt_lconv_c.p_sep_by_space  = (char)UCHAR_MAX;
+    __acrt_lconv_c.n_cs_precedes   = (char)UCHAR_MAX;
+    __acrt_lconv_c.n_sep_by_space  = (char)UCHAR_MAX;
+    __acrt_lconv_c.p_sign_posn     = (char)UCHAR_MAX;
+    __acrt_lconv_c.n_sign_posn     = (char)UCHAR_MAX;
+
+    return 0;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_refcounting.cpp

@@ -0,0 +1,353 @@
+/***
+*localref.c - Contains the __[add|remove]localeref() functions.
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Contains the __[add|remove]localeref() functions.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+
+
+
+/***
+* __acrt_add_locale_ref(__crt_locale_data* ptloci)
+*
+* Purpose:
+*       Increment the refrence count for each element in the localeinfo struct.
+*
+*******************************************************************************/
+extern "C" void __cdecl __acrt_add_locale_ref(__crt_locale_data* ptloci)
+{
+    _InterlockedIncrement(&ptloci->refcount);
+
+    if (ptloci->lconv_intl_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->lconv_intl_refcount);
+    }
+
+    if (ptloci->lconv_mon_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->lconv_mon_refcount);
+    }
+
+    if (ptloci->lconv_num_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->lconv_num_refcount);
+    }
+
+    if (ptloci->ctype1_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->ctype1_refcount);
+    }
+
+    for (int category = LC_MIN; category <= LC_MAX; ++category)
+    {
+        if (ptloci->lc_category[category].wlocale != __acrt_wide_c_locale_string &&
+            ptloci->lc_category[category].wrefcount != nullptr)
+        {
+            _InterlockedIncrement(ptloci->lc_category[category].wrefcount);
+        }
+
+        if (ptloci->lc_category[category].locale != nullptr &&
+            ptloci->lc_category[category].refcount != nullptr)
+        {
+            _InterlockedIncrement(ptloci->lc_category[category].refcount);
+        }
+    }
+
+    __acrt_locale_add_lc_time_reference(ptloci->lc_time_curr);
+}
+
+/***
+* __acrt_release_locale_ref(__crt_locale_data* ptloci)
+*
+* Purpose:
+*       Decrement the refrence count for each elemnt in the localeinfo struct.
+*
+******************************************************************************/
+extern "C" void __cdecl __acrt_release_locale_ref(__crt_locale_data* ptloci)
+{
+    if (ptloci == nullptr)
+        return;
+
+    _InterlockedDecrement(&ptloci->refcount);
+
+    if (ptloci->lconv_intl_refcount != nullptr)
+        _InterlockedDecrement(ptloci->lconv_intl_refcount);
+
+    if (ptloci->lconv_mon_refcount != nullptr)
+        _InterlockedDecrement(ptloci->lconv_mon_refcount);
+
+    if (ptloci->lconv_num_refcount != nullptr)
+        _InterlockedDecrement(ptloci->lconv_num_refcount);
+
+    if (ptloci->ctype1_refcount != nullptr)
+        _InterlockedDecrement(ptloci->ctype1_refcount);
+
+    for (int category = LC_MIN; category <= LC_MAX; ++category)
+    {
+        if (ptloci->lc_category[category].wlocale != __acrt_wide_c_locale_string &&
+            ptloci->lc_category[category].wrefcount != nullptr)
+        {
+            _InterlockedDecrement(ptloci->lc_category[category].wrefcount);
+        }
+
+        if (ptloci->lc_category[category].locale != nullptr &&
+            ptloci->lc_category[category].refcount != nullptr)
+        {
+            _InterlockedDecrement(ptloci->lc_category[category].refcount);
+        }
+    }
+
+    __acrt_locale_release_lc_time_reference(ptloci->lc_time_curr);
+}
+
+
+/***
+*__acrt_free_locale() - free __crt_locale_data
+*
+*Purpose:
+*       Free up the per-thread locale info structure specified by the passed
+*       pointer.
+*
+*Entry:
+*       __crt_locale_data* ptloci
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl __acrt_free_locale(__crt_locale_data* ptloci)
+{
+    /*
+     * Free up lconv struct
+     */
+    if (ptloci->lconv != nullptr &&
+        ptloci->lconv != &__acrt_lconv_c &&
+        ptloci->lconv_intl_refcount != nullptr &&
+        *ptloci->lconv_intl_refcount == 0)
+    {
+        if (ptloci->lconv_mon_refcount != nullptr && *ptloci->lconv_mon_refcount == 0)
+        {
+            _free_crt(ptloci->lconv_mon_refcount);
+            __acrt_locale_free_monetary(ptloci->lconv);
+        }
+
+        if (ptloci->lconv_num_refcount != nullptr && *ptloci->lconv_num_refcount == 0)
+        {
+            _free_crt(ptloci->lconv_num_refcount);
+            __acrt_locale_free_numeric(ptloci->lconv);
+        }
+
+        _free_crt(ptloci->lconv_intl_refcount);
+        _free_crt(ptloci->lconv);
+    }
+
+    /*
+     * Free up ctype tables
+     */
+    if (ptloci->ctype1_refcount != nullptr && *ptloci->ctype1_refcount == 0)
+    {
+        _free_crt(ptloci->ctype1 - _COFFSET);
+        _free_crt(const_cast<unsigned char*>(ptloci->pclmap - _COFFSET - 1));
+        _free_crt(const_cast<unsigned char*>(ptloci->pcumap - _COFFSET - 1));
+        _free_crt(ptloci->ctype1_refcount);
+    }
+
+    __acrt_locale_free_lc_time_if_unreferenced(ptloci->lc_time_curr);
+
+    for (int category = LC_MIN; category <= LC_MAX; ++category)
+    {
+        if (ptloci->lc_category[category].wlocale != __acrt_wide_c_locale_string &&
+            ptloci->lc_category[category].wrefcount != nullptr &&
+            *ptloci->lc_category[category].wrefcount == 0)
+        {
+            _free_crt(ptloci->lc_category[category].wrefcount);
+            _free_crt(ptloci->locale_name[category]);
+        }
+
+        _ASSERTE((ptloci->lc_category[category].locale != nullptr && ptloci->lc_category[category].refcount != nullptr) ||
+                 (ptloci->lc_category[category].locale == nullptr && ptloci->lc_category[category].refcount == nullptr));
+
+        if (ptloci->lc_category[category].locale != nullptr &&
+            ptloci->lc_category[category].refcount != nullptr &&
+            *ptloci->lc_category[category].refcount == 0)
+        {
+            _free_crt(ptloci->lc_category[category].refcount);
+        }
+    }
+
+    /*
+     * Free up the __crt_locale_data struct
+     */
+    _free_crt(ptloci);
+}
+
+
+/***
+*
+* _updatelocinfoEx_nolock(__crt_locale_data* *pptlocid, __crt_locale_data* ptlocis)
+*
+* Purpose:
+*       Update *pptlocid to ptlocis. This might include freeing contents of *pptlocid.
+*
+******************************************************************************/
+extern "C" __crt_locale_data* __cdecl _updatetlocinfoEx_nolock(
+    __crt_locale_data** pptlocid,
+    __crt_locale_data*  ptlocis
+    )
+{
+    if (ptlocis == nullptr || pptlocid == nullptr)
+        return nullptr;
+
+    __crt_locale_data* const ptloci = *pptlocid;
+    if (ptloci == ptlocis)
+        return ptlocis;
+
+    /*
+    * Update to the current locale info structure and increment the
+    * reference counts.
+    */
+    *pptlocid = ptlocis;
+    __acrt_add_locale_ref(ptlocis);
+
+    /*
+    * Decrement the reference counts in the old locale info
+    * structure.
+    */
+    if (ptloci != nullptr)
+    {
+        __acrt_release_locale_ref(ptloci);
+    }
+
+    /*
+    * Free the old locale info structure, if necessary.  Must be done
+    * after incrementing reference counts in current locale in case
+    * any refcounts are shared with the old locale.
+    */
+    if (ptloci != nullptr &&
+        ptloci->refcount == 0 &&
+        ptloci != &__acrt_initial_locale_data)
+    {
+        __acrt_free_locale(ptloci);
+    }
+
+    return ptlocis;
+}
+
+
+/***
+*__acrt_update_thread_locale_data() - refresh the thread's locale info
+*
+*Purpose:
+*       If this thread does not have it's ownlocale which means that either
+*       ownlocale flag in ptd is not set or ptd->ptloci == nullptr, then Update
+*       the current thread's reference to the locale information to match the
+*       current global locale info. Decrement the reference on the old locale
+*       information struct and if this count is now zero (so that no threads
+*       are using it), free it.
+*
+*Entry:
+*
+*Exit:
+*
+*       if (!_getptd()->ownlocale || _getptd()->ptlocinfo == nullptr)
+*           _getptd()->ptlocinfo == __acrt_current_locale_data
+*       else
+*           _getptd()->ptlocinfo
+*
+*Exceptions:
+*
+*******************************************************************************/
+extern "C" __crt_locale_data* __cdecl __acrt_update_thread_locale_data()
+{
+    __crt_locale_data* ptloci = nullptr;
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    if (__acrt_should_sync_with_global_locale(ptd) || ptd->_locale_info == nullptr)
+    {
+        __acrt_lock(__acrt_locale_lock);
+        __try
+        {
+            ptloci = _updatetlocinfoEx_nolock(&ptd->_locale_info, __acrt_current_locale_data.value());
+        }
+        __finally
+        {
+            __acrt_unlock(__acrt_locale_lock);
+        }
+    }
+    else
+    {
+        ptloci = ptd->_locale_info;
+    }
+
+    if (!ptloci)
+    {
+        abort();
+    }
+
+    return ptloci;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// __crt_lc_time_data reference counting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The C locale lc_time data is immutable and persistent.  The lc_time data for
+// any other locale is dynamically allocated (and thus not actually immutable).
+// The lc_time_curr data member of __crt_locale_data is declared const to help
+// ensure that code does not accidentally attempt to modify the C locale lc_time
+// data.
+//
+// These functions encapsulate all mutation of the lc_time_curr.  They accept a
+// __crt_lc_time_data const*, handle the C locale as a special case, then cast
+// away constness to mutate the lc_time data.
+extern "C" long __cdecl __acrt_locale_add_lc_time_reference(
+    __crt_lc_time_data const* const lc_time
+    )
+{
+    if (lc_time == nullptr || lc_time == &__lc_time_c)
+    {
+        return LONG_MAX;
+    }
+
+    return _InterlockedIncrement(&const_cast<__crt_lc_time_data*>(lc_time)->refcount);
+}
+
+extern "C" long __cdecl __acrt_locale_release_lc_time_reference(
+    __crt_lc_time_data const* const lc_time
+    )
+{
+    if (lc_time == nullptr || lc_time == &__lc_time_c)
+    {
+        return LONG_MAX;
+    }
+
+    return _InterlockedDecrement(&const_cast<__crt_lc_time_data*>(lc_time)->refcount);
+}
+
+extern "C" void __cdecl __acrt_locale_free_lc_time_if_unreferenced(
+    __crt_lc_time_data const* const lc_time
+    )
+{
+    if (lc_time == nullptr || lc_time == &__lc_time_c)
+    {
+        return;
+    }
+
+    if (__crt_interlocked_read(&lc_time->refcount) != 0)
+    {
+        return;
+    }
+
+    __acrt_locale_free_time(const_cast<__crt_lc_time_data*>(lc_time));
+    _free_crt(const_cast<__crt_lc_time_data*>(lc_time));
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_update.cpp

@@ -0,0 +1,55 @@
+//
+// locale_update.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Encapsulated implementation details of _LocaleUpdate that cannot be defined
+// in the header because they refer to data not exported from the AppCRT DLL.
+//
+#include <corecrt_internal.h>
+
+extern "C" void __acrt_update_locale_info(
+    __acrt_ptd*         const ptd,
+    __crt_locale_data** const locale_info
+    )
+{
+    if (*locale_info != __acrt_current_locale_data.value() && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *locale_info = __acrt_update_thread_locale_data();
+    }
+}
+
+extern "C" void __acrt_update_multibyte_info(
+    __acrt_ptd*            const ptd,
+    __crt_multibyte_data** const multibyte_info
+    )
+{
+    if (*multibyte_info != __acrt_current_multibyte_data.value() && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *multibyte_info = __acrt_update_thread_multibyte_data();
+    }
+}
+
+extern "C" void __acrt_update_locale_info_explicit(
+    __acrt_ptd*         const ptd,
+    __crt_locale_data** const locale_info,
+    size_t              const current_global_state_index
+    )
+{
+    if (*locale_info != __acrt_current_locale_data.value_explicit(current_global_state_index) && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *locale_info = __acrt_update_thread_locale_data();
+    }
+}
+
+extern "C" void __acrt_update_multibyte_info_explicit(
+    __acrt_ptd*            const ptd,
+    __crt_multibyte_data** const multibyte_info,
+    size_t                 const current_global_state_index
+    )
+{
+    if (*multibyte_info != __acrt_current_multibyte_data.value_explicit(current_global_state_index) && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *multibyte_info = __acrt_update_thread_multibyte_data();
+    }
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/localeconv.cpp

@@ -0,0 +1,86 @@
+/***
+*lconv.c - Contains the localeconv function
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the localeconv() function.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <limits.h>
+#include <locale.h>
+
+
+
+/* pointer to original static to avoid freeing */
+extern "C" char    __acrt_lconv_static_decimal  []{"."};
+extern "C" char    __acrt_lconv_static_null     []{""};
+extern "C" wchar_t __acrt_lconv_static_W_decimal[]{L"."};
+extern "C" wchar_t __acrt_lconv_static_W_null   []{L""};
+
+/* lconv settings for "C" locale */
+extern "C" struct lconv __acrt_lconv_c
+{
+    __acrt_lconv_static_decimal,   // decimal_point
+    __acrt_lconv_static_null,      // thousands_sep
+    __acrt_lconv_static_null,      // grouping
+    __acrt_lconv_static_null,      // int_curr_symbol
+    __acrt_lconv_static_null,      // currency_symbol
+    __acrt_lconv_static_null,      // mon_decimal_point
+    __acrt_lconv_static_null,      // mon_thousands_sep
+    __acrt_lconv_static_null,      // mon_grouping
+    __acrt_lconv_static_null,      // positive_sign
+    __acrt_lconv_static_null,      // negative_sign
+    CHAR_MAX,                      // int_frac_digits
+    CHAR_MAX,                      // frac_digits
+    CHAR_MAX,                      // p_cs_precedes
+    CHAR_MAX,                      // p_sep_by_space
+    CHAR_MAX,                      // n_cs_precedes
+    CHAR_MAX,                      // n_sep_by_space
+    CHAR_MAX,                      // p_sign_posn
+    CHAR_MAX,                      // n_sign_posn
+    __acrt_lconv_static_W_decimal, // _W_decimal_point
+    __acrt_lconv_static_W_null,    // _W_thousands_sep
+    __acrt_lconv_static_W_null,    // _W_int_curr_symbol
+    __acrt_lconv_static_W_null,    // _W_currency_symbol
+    __acrt_lconv_static_W_null,    // _W_mon_decimal_point
+    __acrt_lconv_static_W_null,    // _W_mon_thousands_sep
+    __acrt_lconv_static_W_null,    // _W_positive_sign
+    __acrt_lconv_static_W_null,    // _W_negative_sign
+};
+
+
+/* pointer to current lconv structure */
+
+extern "C" struct lconv* __acrt_lconv{&__acrt_lconv_c};
+
+/***
+*struct lconv *localeconv(void) - Return the numeric formatting convention
+*
+*Purpose:
+*       The localeconv() routine returns the numeric formatting conventions
+*       for the current locale setting.  [ANSI]
+*
+*Entry:
+*       void
+*
+*Exit:
+*       struct lconv * = pointer to struct indicating current numeric
+*                        formatting conventions.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" lconv* __cdecl localeconv()
+{
+    // Note that we don't need _LocaleUpdate in this function.  The main reason
+    // being, that this is a leaf function in locale usage terms.
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* locale_info = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &locale_info);
+
+    return locale_info->lconv;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/nlsdata.cpp

@@ -0,0 +1,140 @@
+//
+// nlsdata.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Globals for the locale and code page implementation.  These are utilized by
+// almost all locale-dependent functions.
+//
+#include <corecrt_internal.h>
+
+
+
+extern "C" int __mb_cur_max{1};
+
+
+
+extern "C" int* __cdecl __p___mb_cur_max()
+{
+    __acrt_ptd* ptd = __acrt_getptd();
+    __crt_locale_data* locale_info = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &locale_info);
+    return &locale_info->_public._locale_mb_cur_max;
+}
+
+
+
+extern "C" wchar_t __acrt_wide_c_locale_string[]{L"C"};
+
+
+
+extern "C" __crt_lc_time_data const __lc_time_c
+{
+    { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
+
+    {
+        "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+        "Friday", "Saturday"
+    },
+
+    {
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
+        "Sep", "Oct", "Nov", "Dec"
+    },
+
+    {
+        "January", "February", "March", "April", "May", "June",
+        "July", "August", "September", "October",
+        "November", "December"
+    },
+
+    { "AM", "PM" },
+
+    "MM/dd/yy",
+    "dddd, MMMM dd, yyyy",
+    "HH:mm:ss",
+
+    1,
+    0,
+
+    { L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat" },
+
+    {
+        L"Sunday", L"Monday", L"Tuesday", L"Wednesday",
+        L"Thursday", L"Friday", L"Saturday"
+    },
+
+    {
+        L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun", L"Jul",
+        L"Aug", L"Sep", L"Oct", L"Nov", L"Dec"
+    },
+
+    {
+        L"January", L"February", L"March", L"April", L"May",
+        L"June", L"July", L"August", L"September", L"October",
+        L"November", L"December"
+    },
+
+    { L"AM", L"PM" },
+
+    L"MM/dd/yy",
+    L"dddd, MMMM dd, yyyy",
+    L"HH:mm:ss",
+    L"en-US"
+};
+
+
+
+// The initial locale information structure, containing the C locale data.  It
+// is used until the first call to setlocale().
+extern "C" __crt_locale_data __acrt_initial_locale_data
+{
+    {
+        __newctype + 128,    // _locale_pctype
+        1,                   // _locale_mb_cur_max
+        CP_ACP               // _locale_lc_codepage
+    },
+    1,                       // refcount
+    CP_ACP,                  // lc_collate_cp
+    CP_ACP,                  // lc_time_cp
+    1,                       // lc_clike
+    {
+        { nullptr, nullptr,                     nullptr, nullptr }, // lc_category[LC_ALL]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_COLLATE]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_CTYPE]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_MONETARY]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_NUMERIC]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }  // lc_category[LC_TIME]
+    },
+    nullptr,                 // lconv_intl_refcount
+    nullptr,                 // lconv_num_refcount
+    nullptr,                 // lconv_mon_refcount
+    &__acrt_lconv_c,         // lconv
+    nullptr,                 // ctype1_refcount
+    nullptr,                 // ctype1
+    __newclmap + 128,        // pclmap
+    __newcumap + 128,        // pcumap
+    &__lc_time_c,            // lc_time_curr
+    {
+        nullptr,             // locale_name[LC_ALL]
+        nullptr,             // locale_name[LC_COLLATE]
+        nullptr,             // locale_name[LC_CTYPE]
+        nullptr,             // locale_name[LC_MONETARY]
+        nullptr,             // locale_name[LC_NUMERIC]
+        nullptr              // locale_name[LC_TIME]
+    }
+};
+
+
+
+// Global pointer to the current per-thread locale information structure.
+__crt_state_management::dual_state_global<__crt_locale_data*> __acrt_current_locale_data;
+
+
+
+extern "C" __crt_locale_pointers __acrt_initial_locale_pointers
+{
+    &__acrt_initial_locale_data,
+    &__acrt_initial_multibyte_data
+};

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/setlocale.cpp

@@ -0,0 +1,118 @@
+/***
+*setlocal.c - Contains the setlocale function
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the _wsetlocale() function.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+extern "C" static wchar_t* __cdecl call_wsetlocale(int const category, char const* const narrow_locale)
+{
+    if (narrow_locale == nullptr)
+        return _wsetlocale(category, nullptr);
+
+    size_t size;
+    _ERRCHECK_EINVAL_ERANGE(mbstowcs_s(&size, nullptr, 0, narrow_locale, INT_MAX));
+
+    __crt_unique_heap_ptr<wchar_t> wide_locale(_calloc_crt_t(wchar_t, size));
+    if (wide_locale.get() == nullptr)
+        return nullptr;
+
+    if (_ERRCHECK_EINVAL_ERANGE(mbstowcs_s(nullptr, wide_locale.get(), size, narrow_locale, _TRUNCATE)) != 0)
+        return nullptr;
+
+    return _wsetlocale(category, wide_locale.get());
+}
+
+extern "C" char* __cdecl setlocale(int _category, char const* _locale)
+{
+    // Deadlock Avoidance:  See the comment in _wsetlocale on usage of this function.
+    __acrt_eagerly_load_locale_apis();
+
+    return __acrt_lock_and_call(__acrt_locale_lock, [&]() -> char*
+    {
+        // Convert ASCII string into a wide character string:
+        wchar_t* const outwlocale = call_wsetlocale(_category, _locale);
+        if (outwlocale == nullptr)
+        {
+            return nullptr;
+        }
+
+        __acrt_ptd* const ptd = __acrt_getptd();
+
+        __crt_locale_pointers locale;
+        locale.locinfo = ptd->_locale_info;
+        locale.mbcinfo = ptd->_multibyte_info;
+
+        // We now have a locale string, but the global locale can be changed by
+        // another thread.  If we allow this thread's locale to be updated before
+        // we're done with this string, it might be freed from under us.  We call
+        // the versions of the wide-to-multibyte conversions that do not update the
+        // current thread's locale.
+        size_t size = 0;
+        if (_ERRCHECK_EINVAL_ERANGE(_wcstombs_s_l(&size, nullptr, 0, outwlocale, 0, &locale)) != 0)
+        {
+            return nullptr;
+        }
+
+        long* const refcount = static_cast<long*>(_malloc_crt(size + sizeof(long)));
+        if (refcount == nullptr)
+        {
+            return nullptr;
+        }
+
+        char* outlocale = reinterpret_cast<char*>(&refcount[1]);
+
+        /* convert return value to ASCII */
+        if (_ERRCHECK_EINVAL_ERANGE(_wcstombs_s_l(nullptr, outlocale, size, outwlocale, _TRUNCATE, &locale)) != 0)
+        {
+            _free_crt(refcount);
+            return nullptr;
+        }
+
+        __crt_locale_data* ptloci = locale.locinfo;
+
+        _ASSERTE((ptloci->lc_category[_category].locale != nullptr && ptloci->lc_category[_category].refcount != nullptr) ||
+                 (ptloci->lc_category[_category].locale == nullptr && ptloci->lc_category[_category].refcount == nullptr));
+
+        if (ptloci->lc_category[_category].refcount != nullptr &&
+            _InterlockedDecrement(ptloci->lc_category[_category].refcount) == 0)
+        {
+            _free_crt(ptloci->lc_category[_category].refcount);
+            ptloci->lc_category[_category].refcount = nullptr;
+        }
+
+        if (__acrt_should_sync_with_global_locale(ptd))
+        {
+            if (ptloci->lc_category[_category].refcount != nullptr &&
+                _InterlockedDecrement(ptloci->lc_category[_category].refcount) == 0)
+            {
+                _free_crt(ptloci->lc_category[_category].refcount);
+                ptloci->lc_category[_category].refcount = nullptr;
+            }
+        }
+
+        /*
+        * Note that we are using a risky trick here.  We are adding this
+        * locale to an existing __crt_locale_data struct, and thus starting
+        * the locale's refcount with the same value as the whole struct.
+        * That means all code which modifies both __crt_locale_data::refcount
+        * and __crt_locale_data::lc_category[]::refcount in structs that are
+        * potentially shared across threads must make those modifications
+        * under the locale lock.  Otherwise, there's a race condition
+        * for some other thread modifying __crt_locale_data::refcount after
+        * we load it but before we store it to refcount.
+        */
+        *refcount = ptloci->refcount;
+        ptloci->lc_category[_category].refcount = refcount;
+        ptloci->lc_category[_category].locale = outlocale;
+
+        return outlocale;
+    });
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/wsetlocale.cpp

@@ -0,0 +1,1430 @@
+/***
+*wsetlocale.cpp - Contains the wsetlocale function
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Contains the wsetlocale() function.
+*
+****/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+
+extern "C" {
+
+static const char _first_127char[] = {
+        1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17,
+        18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+        35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
+        69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
+        86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,101,102,
+        103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,
+        120,121,122,123,124,125,126,127
+};
+
+extern __crt_locale_data __acrt_initial_locale_data;
+extern const unsigned short _wctype[];
+static const unsigned short *_ctype_loc_style = _wctype + 2;
+
+long __acrt_locale_changed_data = FALSE;
+
+/* helper function prototypes */
+_Success_(return != 0)
+static wchar_t * _expandlocale(
+    _In_z_                                wchar_t const * expr,
+    _Out_writes_z_(sizeInChars)           wchar_t *       output,
+    _In_                                  size_t          sizeInChars,
+    _Out_writes_z_(localeNameSizeInChars) wchar_t *       localeNameOutput,
+    _In_                                  size_t          localeNameSizeInChars,
+    _Out_                                 UINT&           cp
+    );
+
+void _wcscats(_Inout_updates_z_(_Param_(2)) wchar_t *, size_t, int, ...);
+void __lc_lctowcs(_Inout_updates_z_(_Param_(2)) wchar_t *, size_t, const __crt_locale_strings *);
+int __lc_wcstolc(__crt_locale_strings *, const wchar_t *);
+static wchar_t * __cdecl _wsetlocale_set_cat(__crt_locale_data*, int, const wchar_t *);
+static wchar_t * __cdecl _wsetlocale_get_all(__crt_locale_data*);
+static __crt_locale_data* __cdecl _updatetlocinfo_nolock(void);
+static wchar_t * __cdecl _wsetlocale_nolock(__crt_locale_data*, int, const wchar_t *);
+int __cdecl _setmbcp_nolock(int, __crt_multibyte_data*);
+__crt_locale_data* __cdecl _updatetlocinfoEx_nolock(__crt_locale_data**, __crt_locale_data*);
+
+void __cdecl __acrt_set_locale_changed()
+{
+    _InterlockedExchange(&__acrt_locale_changed_data, TRUE);
+}
+
+/***
+* _configthreadlocale(int i)
+*
+* Purpose:
+*       To set _own_locale flag on threadinfo sturct. If this flag is set, this thread
+*       is going own it's threadlocinfo struct. Setlocale call on other thread will have
+*       no effect on this thread's locale. If 0 is passed then nothing is changed, but
+*       current status is returned.
+* Exit   :
+*       Returns the current status - i.e. per thread locale is enabled or not.
+*
+*******************************************************************************/
+int __cdecl _configthreadlocale(int i)
+{
+    /*
+     * ownlocale flag struct:
+     * bits: 000000000000000000000000 000W 00P1
+     * P is set when _ENABLE_PER_THREAD_LOCALE is called for this thread
+     * or _ENABLE_PER_THREAD_LOCALE_NEW was set when this thread was created.
+     * W is set when _WSETLOCALE_AVOID_SYNC_LOCALE_BIT is set by _wsetlocale.
+     * It is used to disable global-ptd resynchronization during a call to _wsetlocale.
+     *
+     * __globallocalestatus structure:
+     * bits: 111111111111111111111111 1111 1N1G
+     * G is set if _ENABLE_PER_THREAD_LOCALE_GLOBAL is set.
+     * G is 0 if _ENABLE_PER_THREAD_LOCALE_GLOBAL is not set.
+     * N is set if _ENABLE_PER_THREAD_LOCALE_NEW is set.
+     * N is 0 if _ENABLE_PER_THREAD_LOCALE_NEW is not set.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    int retval = (ptd->_own_locale & _PER_THREAD_LOCALE_BIT)==0 ? _DISABLE_PER_THREAD_LOCALE:_ENABLE_PER_THREAD_LOCALE;
+
+    switch(i)
+    {
+        case _ENABLE_PER_THREAD_LOCALE:
+            // same behavior as __acrt_disable_global_locale_sync()
+            ptd->_own_locale = ptd->_own_locale | _PER_THREAD_LOCALE_BIT;
+            break;
+
+        case _DISABLE_PER_THREAD_LOCALE:
+            // same behavior as __acrt_enable_global_locale_sync()
+            ptd->_own_locale = ptd->_own_locale & ~_PER_THREAD_LOCALE_BIT;
+            break;
+
+        case 0:
+            break;
+
+        /* used only during dll startup for linkopt */
+        case -1:
+            __globallocalestatus = -1;
+            break;
+
+        default:
+            _VALIDATE_RETURN(("Invalid parameter for _configthreadlocale",0),EINVAL,-1);
+            break;
+    }
+
+    return retval;
+}
+
+extern "C" void __cdecl __acrt_uninitialize_locale()
+{
+    __acrt_lock_and_call(__acrt_locale_lock, [&]
+    {
+        __acrt_current_locale_data.uninitialize([](__crt_locale_data*& locale)
+        {
+            if (locale == &__acrt_initial_locale_data)
+            {
+                return;
+            }
+
+            locale = _updatetlocinfoEx_nolock(&locale, &__acrt_initial_locale_data);
+        });
+    });
+}
+
+/***
+*_free_locale() - free threadlocinfo
+*
+*Purpose:
+*       Free up the per-thread locale info structure specified by the passed
+*       pointer.
+*
+*Entry:
+*       __crt_locale_data* ptloci
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void __cdecl _free_locale(
+        _locale_t plocinfo
+        )
+{
+    if (plocinfo != nullptr)
+    {
+        __acrt_lock(__acrt_multibyte_cp_lock);
+        __try
+        {
+            if (plocinfo->mbcinfo != nullptr &&
+                    InterlockedDecrement(&(plocinfo->mbcinfo->refcount)) == 0 &&
+                    plocinfo->mbcinfo != &__acrt_initial_multibyte_data )
+            {
+                _free_crt(plocinfo->mbcinfo);
+            }
+        }
+        __finally
+        {
+            __acrt_unlock(__acrt_multibyte_cp_lock);
+        }
+
+        if (plocinfo->locinfo != nullptr)
+        {
+            /*
+             * this portion has to be in locale lock as there may be case when
+             * not this thread but some other thread is still holding to this
+             * locale and is also trying to free this locale. In this case
+             * we may end up leaking memory.
+             */
+
+            __acrt_lock(__acrt_locale_lock);
+            __try
+            {
+                __acrt_release_locale_ref(plocinfo->locinfo);
+                if ( (plocinfo->locinfo != nullptr) &&
+                     (plocinfo->locinfo->refcount == 0) &&
+                     (plocinfo->locinfo != &__acrt_initial_locale_data) )
+                    __acrt_free_locale(plocinfo->locinfo);
+            }
+            __finally
+            {
+                __acrt_unlock(__acrt_locale_lock);
+            }
+        }
+
+        _free_crt(plocinfo);
+    }
+}
+
+/*
+* _locale_t _get_current_locale() -
+*    Gets the current locale setting.
+*
+* Purpose:
+*       Gets the current locale setting for this thread. Returns locale
+*       in form of _locale_t, which then can be used with other locale
+*       aware string functions.
+*
+*/
+
+_locale_t __cdecl _get_current_locale(void)
+{
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    auto locale_copy(_calloc_crt_t(__crt_locale_pointers, 1));
+    if (!locale_copy)
+        return nullptr; // calloc will set errno
+
+    __acrt_update_thread_locale_data();
+    __acrt_update_thread_multibyte_data();
+
+    // No one can free the data pointed to by ptlocinfo while we're copying
+    // it, since we're copying this thread's ptlocinfo, which won't be updated
+    // during the copy.  So there are no worries about it being freed from
+    // under us.  We still need a lock while adding a reference for the new
+    // copy, though, because of the race condition found in _wsetlocale.
+    locale_copy.get()->locinfo = ptd->_locale_info;
+    locale_copy.get()->mbcinfo = ptd->_multibyte_info;
+    __acrt_lock_and_call(__acrt_locale_lock, [&]
+    {
+        __acrt_add_locale_ref(locale_copy.get()->locinfo);
+    });
+
+    __acrt_lock_and_call(__acrt_multibyte_cp_lock, [&]
+    {
+        InterlockedIncrement(&locale_copy.get()->mbcinfo->refcount);
+    });
+
+    return locale_copy.detach();
+}
+
+// Enclaves do not support dynamic locales, but they support reading the default one.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+// This is used as the initializer if a category does not need initialization.
+static int __cdecl no_op_initialize(__crt_locale_data*)
+{
+    return 0;
+}
+
+void __cdecl __acrt_free_locale(__crt_locale_data*);
+
+_CRT_LINKER_FORCE_INCLUDE(__acrt_locale_terminator);
+
+extern __declspec(selectany) struct {
+        const wchar_t * catname;
+        wchar_t * locale;
+        int (* init)(__crt_locale_data*);
+} const __lc_category[LC_MAX-LC_MIN+1] = {
+        /* code assumes locale initialization is "__wclocalestr" */
+        { L"LC_ALL",     nullptr,                        no_op_initialize                  },
+        { L"LC_COLLATE", __acrt_wide_c_locale_string,    no_op_initialize                  },
+        { L"LC_CTYPE",   __acrt_wide_c_locale_string,    __acrt_locale_initialize_ctype    },
+        { L"LC_MONETARY",__acrt_wide_c_locale_string,    __acrt_locale_initialize_monetary },
+        { L"LC_NUMERIC", __acrt_wide_c_locale_string,    __acrt_locale_initialize_numeric  },
+        { L"LC_TIME",    __acrt_wide_c_locale_string,    __acrt_locale_initialize_time     }
+};
+
+/***
+*
+* _copytlocinfo_nolock(__crt_locale_data* ptlocid, __crt_locale_data* ptlocis)
+*
+* Purpose:
+*       Copy the contents of ptlocis to ptlocid and increase the refcount of all the
+*       elements in ptlocid after copy.
+*
+******************************************************************************/
+static void __cdecl _copytlocinfo_nolock(
+    __crt_locale_data* ptlocid,
+    __crt_locale_data* ptlocis)
+{
+    if (ptlocis != nullptr && ptlocid != nullptr && ptlocid != ptlocis) {
+        *ptlocid = *ptlocis;
+        ptlocid->refcount = 0;
+        __acrt_add_locale_ref(ptlocid);
+    }
+}
+
+/***
+* void sync_legacy_variables_lk()
+*
+* Purpose:
+*   Syncs all the legacy locale specific variables to the global locale.
+*
+*******************************************************************************/
+static __inline void sync_legacy_variables_lk()
+{
+    __acrt_lconv = __acrt_current_locale_data.value()->lconv;
+    _pctype = __acrt_current_locale_data.value()->_public._locale_pctype;
+    __mb_cur_max = __acrt_current_locale_data.value()->_public._locale_mb_cur_max;
+}
+
+/***
+* _locale_t _wcreate_locale(int category, char *wlocale) -
+*    Set one or all locale categories of global locale structure
+*
+* Purpose:
+*       The _wcreate_locale() routine allows the user to create a _locale_t
+*       object that can be used with other locale functions.
+*
+* Entry:
+*       int category = One of the locale categories defined in locale.h
+*       char *locale = String identifying a specific locale.
+*
+* Exit:
+*       If supplied locale pointer != nullptr:
+*
+*           If locale string is '\0', set locale to default.
+*
+*           If desired setting can be honored, return a pointer to the
+*           locale string for the appropriate category.
+*
+*           If desired setting can NOT be honored, return nullptr.
+*
+* Exceptions:
+*       Compound locale strings of the form "LC_COLLATE=xxx;LC_CTYPE=xxx;..."
+*       are allowed for the LC_ALL category.  This is to support the ability
+*       to restore locales with the returned string, as specified by ANSI.
+*       Setting the locale with a compound locale string will succeed unless
+*       *all* categories failed.  The returned string will reflect the current
+*       locale.  For example, if LC_CTYPE fails in the above string, setlocale
+*       will return "LC_COLLATE=xxx;LC_CTYPE=yyy;..." where yyy is the
+*       previous locale (or the C locale if restoring the previous locale
+*       also failed).  Unrecognized LC_* categories are ignored.
+*
+*******************************************************************************/
+
+_locale_t __cdecl _wcreate_locale(
+        int _category,
+        const wchar_t *locale
+        )
+{
+    if (_category < LC_MIN || _category > LC_MAX || locale == nullptr)
+        return nullptr;
+
+    auto result = _calloc_crt_t(__crt_locale_pointers, 1);
+    _VALIDATE_RETURN_NOEXC(result, ENOMEM, nullptr);
+
+    auto locale_data = _calloc_crt_t(__crt_locale_data, 1);
+    _VALIDATE_RETURN_NOEXC(locale_data, ENOMEM, nullptr);
+
+    auto multibyte_data = _calloc_crt_t(__crt_multibyte_data, 1);
+    _VALIDATE_RETURN_NOEXC(multibyte_data, ENOMEM, nullptr);
+
+    _copytlocinfo_nolock(locale_data.get(), &__acrt_initial_locale_data);
+
+    if (_wsetlocale_nolock(locale_data.get(), _category, locale) == nullptr ||
+        _setmbcp_nolock(locale_data.get()->_public._locale_lc_codepage, multibyte_data.get()) != 0)
+    {
+        __acrt_release_locale_ref(locale_data.get());
+        __acrt_free_locale(locale_data.detach());
+        return nullptr;
+    }
+
+    multibyte_data.get()->refcount = 1;
+
+    result.get()->locinfo = locale_data.detach();
+    result.get()->mbcinfo = multibyte_data.detach();
+    return result.detach();
+}
+
+/***
+* _locale_t _create_locale(int category, char *locale) -
+*    Set one or all locale categories of global locale structure
+****/
+_locale_t __cdecl _create_locale(
+        int _category,
+        const char *_locale
+        )
+{
+    wchar_t _wlocale[MAX_LC_LEN];
+
+    /* Early input validation */
+    if ( (_category < LC_MIN) || (_category > LC_MAX) || _locale == nullptr)
+        return nullptr;
+
+    if ( __acrt_MultiByteToWideChar(CP_ACP, 0, _locale, -1, _wlocale, _countof(_wlocale)) == 0 )
+    { // conversion to wide char failed
+        return nullptr;
+    }
+
+    return _wcreate_locale(_category, _wlocale);
+}
+
+/*
+*char * setlocale(int category, char *locale) - Set one or all locale categories
+*
+*Purpose:
+*       The setlocale() routine allows the user to set one or more of
+*       the locale categories to the specific locale selected by the
+*       user.  [ANSI]
+*
+*       NOTE: Under !_INTL, the C libraries only support the "C" locale.
+*       Attempts to change the locale will fail.
+*
+*Entry:
+*       int category = One of the locale categories defined in locale.h
+*       char *locale = String identifying a specific locale or nullptr to
+*                  query the current locale.
+*
+*Exit:
+*       If supplied locale pointer == nullptr:
+*
+*           Return pointer to current locale string and do NOT change
+*           the current locale.
+*
+*       If supplied locale pointer != nullptr:
+*
+*           If locale string is '\0', set locale to default.
+*
+*           If desired setting can be honored, return a pointer to the
+*           locale string for the appropriate category.
+*
+*           If desired setting can NOT be honored, return nullptr.
+*
+*Exceptions:
+*       Compound locale strings of the form "LC_COLLATE=xxx;LC_CTYPE=xxx;..."
+*       are allowed for the LC_ALL category.  This is to support the ability
+*       to restore locales with the returned string, as specified by ANSI.
+*       Setting the locale with a compound locale string will succeed unless
+*       *all* categories failed.  The returned string will reflect the current
+*       locale.  For example, if LC_CTYPE fails in the above string, setlocale
+*       will return "LC_COLLATE=xxx;LC_CTYPE=yyy;..." where yyy is the
+*       previous locale (or the C locale if restoring the previous locale
+*       also failed).  Unrecognized LC_* categories are ignored.
+*
+*/
+
+wchar_t * __cdecl _wsetlocale (
+        int _category,
+        const wchar_t *_wlocale
+        )
+{
+    wchar_t * retval=nullptr;
+    __crt_locale_data* ptloci = nullptr;
+
+    /* Validate category */
+    _VALIDATE_RETURN(LC_MIN <= _category && _category <= LC_MAX, EINVAL, nullptr);
+
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    // Deadlock Avoidance:  When a new thread is created in the process, we
+    // create a new PTD for the thread.  The PTD initialization function is
+    // called under the loader lock.  This initialization function will also
+    // acquire the locale lock in order to acquire a reference to the current
+    // global locale for the new thread.
+    //
+    // Some of the locale APIs are not available on all supported target OSes.
+    // We dynamically obtain these libraries via LoadLibrary/GetProcAddress.
+    // We must ensure that no call to LoadLibrary is made while we hold the
+    // locale lock, lest we deadlock due to lock order inversion between the
+    // loader lock and the locale lock.
+    //
+    // This function call here will ensure that any required modules are loaded
+    // before we acquire the locale lock.
+    __acrt_eagerly_load_locale_apis();
+
+    __acrt_update_thread_locale_data();
+
+    // Prevent global locale resynchronization - we call things like stricmp() further down
+    // without passing our _locale_t which would trigger a resynchronization.
+    // Use _WSETLOCALE_AVOID_SYNC_LOCALE_BIT to avoid interfering with other locale settings
+    // (see _configthreadlocale() for details).
+
+    // This may not be necessary anymore and may be a hold-over from when _wsetlocale called
+    // setlocale instead of the other way around.
+    // (MSFT:20394962 - Investigate whether _WSETLOCALE_AVOID_SYNC_LOCALE_BIT is needed)
+    __acrt_disable_global_locale_sync(ptd, _WSETLOCALE_AVOID_SYNC_LOCALE_BIT);
+
+    __crt_call_and_cleanup([&]
+    {
+        if ((ptloci = _calloc_crt_t(__crt_locale_data, 1).detach()) != nullptr)
+        {
+            __acrt_lock_and_call(__acrt_locale_lock, [&]
+            {
+                _copytlocinfo_nolock(ptloci, ptd->_locale_info);
+
+                if ((retval = _wsetlocale_nolock(ptloci, _category, _wlocale)) != 0)
+                {
+                    // If no call has been made to setlocale to change locale from "C" locale
+                    // to some other locale, we keep locale_changed = 0. Other functions that
+                    // depend on locale use this variable to optimize performance for C locale
+                    // which is normally the case in applications.
+                    if (_wlocale != nullptr)
+                    {
+                        if (wcscmp(_wlocale, __acrt_wide_c_locale_string) != 0)
+                        {
+                            __acrt_set_locale_changed();
+                        }
+                        // If it is again set to the C locale, could we not retain that state?
+                        // else
+                        // {
+                        //    __acrt_set_locale_unchanged();
+                        // }
+                    }
+
+                    (void)_updatetlocinfoEx_nolock(&ptd->_locale_info, ptloci);
+                    __acrt_release_locale_ref(ptloci);
+                    // Note that after incrementing _own_locale, if this thread doesn't
+                    // have its own locale, _own_locale variable should be 1.
+
+                    // Do not use __acrt_should_sync_with_global_locale() because
+                    // _WSETLOCALE_AVOID_SYNC_LOCALE_BIT will interfere.
+                    if (!(ptd->_own_locale & _PER_THREAD_LOCALE_BIT) &&
+                        !(__globallocalestatus & _GLOBAL_LOCALE_BIT))
+                    {
+                        (void)_updatetlocinfoEx_nolock(&__acrt_current_locale_data.value(), ptd->_locale_info);
+                        sync_legacy_variables_lk();
+                    }
+                }
+                else
+                {
+                    __acrt_release_locale_ref(ptloci);
+                    __acrt_free_locale(ptloci);
+                }
+            });
+        }
+    },
+    [&]{ __acrt_enable_global_locale_sync(ptd, _WSETLOCALE_AVOID_SYNC_LOCALE_BIT); });
+
+    return retval;
+}
+
+static wchar_t * __cdecl _wsetlocale_nolock(
+        __crt_locale_data* ploci,
+        int _category,
+        const wchar_t *_wlocale
+        )
+{
+    wchar_t * retval;
+    /* Interpret locale */
+
+    if (_category != LC_ALL)
+    {
+        retval = (_wlocale) ? _wsetlocale_set_cat(ploci, _category,_wlocale) :
+            ploci->lc_category[_category].wlocale;
+
+    } else { /* LC_ALL */
+        wchar_t lctemp[MAX_LC_LEN];
+        int i;
+        int same = 1;
+        int fLocaleSet = 0; /* flag to indicate if anything successfully set */
+
+        if (_wlocale != nullptr)
+        {
+            if ( (_wlocale[0]==L'L') && (_wlocale[1]==L'C') && (_wlocale[2]==L'_') )
+            {
+                /* parse compound locale string */
+                size_t len;
+                const wchar_t * p = _wlocale;  /* start of string to parse */
+                const wchar_t * s;
+
+                do {
+                    s = wcspbrk(p, L"=;");
+
+                    if (s == nullptr || (len=(size_t)(s - p)) == 0 || (*s == L';'))
+                        return nullptr;  /* syntax error */
+
+                    /* match with known LC_ strings, if possible, else ignore */
+                    for (i=LC_ALL+1; i<=LC_MAX; i++)
+                    {
+                        if ((!wcsncmp(__lc_category[i].catname,p,len))
+                            && (len==wcslen(__lc_category[i].catname)))
+                        {
+                            break;  /* matched i */
+                        }
+                    } /* no match if (i>LC_MAX) -- just ignore */
+
+                    if ((len = wcscspn(++s, L";")) == 0 && *s != L';')
+                        return nullptr;  /* syntax error */
+
+                    if (i<=LC_MAX)
+                    {
+                        _ERRCHECK(wcsncpy_s(lctemp, _countof(lctemp), s, len));
+                        lctemp[len]=L'\0';   /* null terminate string */
+
+                        /* don't fail unless all categories fail */
+                        if (_wsetlocale_set_cat(ploci, i,lctemp))
+                            fLocaleSet++;       /* record a success */
+                    }
+                    if (*(p = s+len)!=L'\0')
+                        p++;  /* skip ';', if present */
+
+                } while (*p);
+
+                retval = (fLocaleSet) ? _wsetlocale_get_all(ploci) : nullptr;
+
+            } else { /* simple LC_ALL locale string */
+
+                UINT code_page;
+                wchar_t localeNameTemp[LOCALE_NAME_MAX_LENGTH];
+                /* confirm locale is supported, get expanded locale */
+                retval = _expandlocale(_wlocale, lctemp, _countof(lctemp), localeNameTemp, _countof(localeNameTemp), code_page);
+                if (retval != 0)
+                {
+                    for (i=LC_MIN; i<=LC_MAX; i++)
+                    {
+                        if (i!=LC_ALL)
+                        {
+                            if (wcscmp(lctemp, ploci->lc_category[i].wlocale) != 0)
+                            { // does not match the LC_ALL locale
+                                if (_wsetlocale_set_cat(ploci, i, lctemp))
+                                {
+                                    fLocaleSet++;   /* record a success */
+                                }
+                                else
+                                {
+                                    same = 0;       /* record a failure */
+                                }
+                            }
+                            else
+                                fLocaleSet++;   /* trivial succcess */
+                        }
+                    }
+                    if (same) /* needn't call setlocale_get_all() if all the same */
+                    {
+                        retval = _wsetlocale_get_all(ploci);
+                        /* retval set above */
+                    }
+                    else
+                        retval = (fLocaleSet) ? _wsetlocale_get_all(ploci) : nullptr;
+                }
+            }
+        } else { /* LC_ALL & nullptr */
+            retval = _wsetlocale_get_all (ploci);
+        }
+    }
+
+    /* common exit point */
+    return retval;
+} /* setlocale */
+
+
+static wchar_t * __cdecl _wsetlocale_set_cat (
+        __crt_locale_data* ploci,
+        int category,
+        const wchar_t * wlocale
+        )
+{
+    wchar_t * oldlocale;
+    wchar_t * oldlocalename;
+    UINT oldcodepage;
+
+    UINT cptemp;
+    wchar_t lctemp[MAX_LC_LEN];
+    wchar_t localeNameString[LOCALE_NAME_MAX_LENGTH];
+    wchar_t * pch = nullptr;
+    wchar_t * pch_cat_locale = nullptr;
+    size_t cch = 0;
+    unsigned short out[sizeof(_first_127char)];
+    int i;
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_ctype_compatibility_data* _Loc_c = ptd->_setloc_data._Loc_c; // __setloc_data._Loc_c is array
+    int _LOC_CCACHE = _countof(ptd->_setloc_data._Loc_c);
+    __crt_ctype_compatibility_data buf1, buf2;
+
+    if (!_expandlocale(wlocale, lctemp, _countof(lctemp), localeNameString, _countof(localeNameString), cptemp))
+        return nullptr;
+
+    // if this category's locale hadn't changed
+    if (wcscmp(lctemp, ploci->lc_category[category].wlocale) == 0)
+    {
+        return ploci->lc_category[category].wlocale;
+    }
+
+    cch = wcslen(lctemp) + 1;
+    if ((pch = static_cast<wchar_t*>(_malloc_crt(sizeof(int) + (cch * sizeof(wchar_t))))) == nullptr)
+        return nullptr;  /* error if malloc fails */
+
+    pch_cat_locale = pch + (sizeof(int) / sizeof(wchar_t));
+
+     /* save for possible restore */
+    oldlocale = ploci->lc_category[category].wlocale;
+    oldlocalename = ploci->locale_name[category];
+    oldcodepage = ploci->_public._locale_lc_codepage;
+
+    /* update locale string */
+    _ERRCHECK(wcscpy_s(pch_cat_locale, cch, lctemp));
+    ploci->lc_category[category].wlocale = pch_cat_locale;
+
+    /* Copy locale name */
+    if (lctemp[0] == L'C' && lctemp[1] == L'\x0') // if "C" locale
+        ploci->locale_name[category] = nullptr;
+    else
+        ploci->locale_name[category] = __acrt_copy_locale_name(localeNameString);
+
+    /* To speedup locale based comparisions, we identify if the current
+     * local has first 127 character set same as CLOCALE. If yes then
+     * ploci->lc_clike = TRUE.
+     */
+
+    if (category==LC_CTYPE)
+    {
+        ploci->_public._locale_lc_codepage = cptemp;
+        buf1 = _Loc_c[_LOC_CCACHE -1];
+        /* brings the recently used codepage to the top. or else shifts
+         * every thing down by one so that new _Loc_c can be placed at
+         * the top.
+         */
+        for ( i = 0; i < _LOC_CCACHE; i++)
+        {
+            if (ploci->_public._locale_lc_codepage == _Loc_c[i].id)
+            {
+                /* We don't really want to swap cache around in case what we are looking
+                 *  for is the first element of the cache
+                 */
+                if (i!=0)
+                {
+                    _Loc_c[0] = _Loc_c[i];
+                    _Loc_c[i] = buf1;
+                }
+                break;
+            }
+            else
+            {
+                buf2 = _Loc_c[i];
+                _Loc_c[i] = buf1;
+                buf1 = buf2;
+            }
+        }
+        if ( i == _LOC_CCACHE)
+        {
+            if ( __acrt_GetStringTypeA(nullptr, CT_CTYPE1,
+                                       _first_127char,
+                                       sizeof(_first_127char),
+                                       out,
+                                       ploci->_public._locale_lc_codepage,
+                                       TRUE ))
+            {
+                int j;
+                for ( j = 0; j < sizeof(_first_127char); j++)
+                    out[j] = out[j]&
+                            (_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_ALPHA);
+                if ( !memcmp(out, _ctype_loc_style, (sizeof(_first_127char)/sizeof(char))*sizeof(short)))
+                {
+                    _Loc_c[0].is_clike = TRUE;
+                }
+                else
+                {
+                    _Loc_c[0].is_clike = FALSE;
+                }
+            }
+            else
+                _Loc_c[0].is_clike = FALSE;
+            _Loc_c[0].id = ploci->_public._locale_lc_codepage;
+        }
+        ploci->lc_clike = _Loc_c[0].is_clike;
+    } /* category==LC_CTYPE */
+    else if ( category == LC_COLLATE )
+        ploci->lc_collate_cp = cptemp;
+    else if ( category == LC_TIME )
+        ploci->lc_time_cp = cptemp;
+
+    if (__lc_category[category].init(ploci) != 0)
+    {
+        /* restore previous state */
+        ploci->lc_category[category].wlocale = oldlocale;
+        _free_crt(ploci->locale_name[category]);
+        ploci->locale_name[category] = oldlocalename;
+        _free_crt(pch);
+        ploci->_public._locale_lc_codepage = oldcodepage;
+
+        return nullptr; /* error if non-zero return */
+    }
+
+    /* locale set up successfully */
+    /* Cleanup */
+    if ((oldlocale != __acrt_wide_c_locale_string) &&
+        (InterlockedDecrement(ploci->lc_category[category].wrefcount) == 0)
+        )
+    {
+        _ASSERT(0);
+        _free_crt(ploci->lc_category[category].wrefcount);
+        _free_crt(ploci->lc_category[category].refcount);
+        _free_crt(ploci->locale_name[category]);
+        ploci->lc_category[category].wlocale = nullptr;
+        ploci->locale_name[category] = nullptr;
+    }
+    if (pch)
+    {
+        reinterpret_cast<long&>(*pch) = 1;
+    }
+    ploci->lc_category[category].wrefcount = reinterpret_cast<long*>(pch);
+
+    return ploci->lc_category[category].wlocale;
+} /* _wsetlocale_set_cat */
+
+
+
+static wchar_t * __cdecl _wsetlocale_get_all ( __crt_locale_data* ploci)
+{
+    int i;
+    int same = 1;
+    wchar_t *pch = nullptr;
+    size_t cch = 0;
+    long *refcount = nullptr;
+    size_t refcountSize = 0;
+
+    /* allocate memory if necessary */
+    refcountSize = sizeof(int) + (sizeof(wchar_t) * (MAX_LC_LEN+1) * (LC_MAX-LC_MIN+1)) + (sizeof(wchar_t) * CATNAMES_LEN);
+    if ( (refcount = static_cast<long*>(_malloc_crt(refcountSize))) == nullptr)
+        return nullptr;
+
+    pch = ((wchar_t*)refcount) + (sizeof(int) / sizeof(wchar_t));
+    cch = (refcountSize - sizeof(int)) / sizeof(wchar_t);
+    *pch = L'\0';
+    *refcount = 1;
+    for (i=LC_MIN+1; ; i++)
+    {
+        _wcscats(pch, cch, 3, __lc_category[i].catname, L"=", ploci->lc_category[i].wlocale);
+        if (i<LC_MAX)
+        {
+            _ERRCHECK(wcscat_s(pch, cch, L";"));
+            if (wcscmp(ploci->lc_category[i].wlocale, ploci->lc_category[i+1].wlocale))
+                same=0;
+        }
+        else
+        {
+            if (!same) {
+                if (ploci->lc_category[LC_ALL].wrefcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].wrefcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].wrefcount);
+                }
+                if (ploci->lc_category[LC_ALL].refcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].refcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].refcount);
+                }
+                ploci->lc_category[LC_ALL].refcount = nullptr;
+                ploci->lc_category[LC_ALL].locale = nullptr;
+                ploci->lc_category[LC_ALL].wrefcount = refcount;
+                return ploci->lc_category[LC_ALL].wlocale = pch;
+            } else {
+                _free_crt(refcount);
+                if (ploci->lc_category[LC_ALL].wrefcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].wrefcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].wrefcount);
+                }
+                if (ploci->lc_category[LC_ALL].refcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].refcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].refcount);
+                }
+                ploci->lc_category[LC_ALL].refcount = nullptr;
+                ploci->lc_category[LC_ALL].locale = nullptr;
+                ploci->lc_category[LC_ALL].wrefcount = nullptr;
+                ploci->lc_category[LC_ALL].wlocale = nullptr;
+                return ploci->lc_category[LC_CTYPE].wlocale;
+            }
+        }
+    }
+} /* _wsetlocale_get_all */
+
+// --- BCP-47 tag parsing for _expandlocale() ---
+//
+// Provides parse_bcp47() which parses a given locale expression and updates a __crt_locale_strings structure accordingly.
+// Unsupported:
+// * Extension and private tags
+// * 4-8 character language subtags
+// * Grandfathered tags
+// * Lone code page specifiers (POSIX extension for BCP-47)
+
+enum class _bcp47_section_delimiter
+{
+    normal,
+    end_of_string,
+    code_page
+};
+
+struct _bcp47_section
+{
+    wchar_t const *          ptr;
+    size_t                   length;
+    _bcp47_section_delimiter delimiter;
+};
+
+static _bcp47_section_delimiter categorize_delimiter(wchar_t const wc)
+{
+    switch (wc)
+    {
+        case '-':
+        case '_':
+            return _bcp47_section_delimiter::normal;
+        case '.':
+            return _bcp47_section_delimiter::code_page;
+        case '\0':
+        default:
+            return _bcp47_section_delimiter::end_of_string;
+    }
+}
+
+static bool string_is_alpha(wchar_t const * const str, size_t const len)
+{
+    for (size_t i = 0; i < len; ++i)
+    {
+        if (!__ascii_isalpha(str[i]))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool string_is_digit(wchar_t const * const str, size_t const len)
+{
+    for (size_t i = 0; i < len; ++i)
+    {
+        if (!__ascii_isdigit(str[i]))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool parse_bcp47_language(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::normal)
+    {
+        return false;
+    }
+
+    if (section.length < 2 || section.length > 3)
+    {
+        return false; // Failure, only 2-3 letter language codes permitted.
+    }
+
+    if (!string_is_alpha(section.ptr, section.length))
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncpy_s(names->szLanguage, _countof(names->szLanguage), section.ptr, section.length));
+    _ERRCHECK(wcsncpy_s(names->szLocaleName, _countof(names->szLocaleName), section.ptr, section.length));
+    return true;
+}
+
+static bool parse_bcp47_script(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::normal)
+    {
+        return false;
+    }
+
+    if (section.length != 4) {
+        return false; // Failure, only 4 letter script codes permitted.
+    }
+
+    if (!string_is_alpha(section.ptr, section.length))
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), L"-", 1));
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), section.ptr, section.length));
+    return true;
+}
+
+static bool parse_bcp47_region(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::normal)
+    {
+        return false;
+    }
+
+    if (   !(section.length == 2 && string_is_alpha(section.ptr, section.length))  // if not 2 letters
+        && !(section.length == 3 && string_is_digit(section.ptr, section.length))) // and not 3 digits
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncpy_s(names->szCountry, _countof(names->szCountry), section.ptr, section.length));
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), L"-", 1));
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), section.ptr, section.length));
+    return true;
+}
+
+static bool parse_bcp47_code_page(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::code_page)
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncpy_s(names->szCodePage, _countof(names->szCodePage), section.ptr, section.length));
+    return true; // Success
+}
+
+static bool parse_bcp47(__crt_locale_strings * const names, const wchar_t * const expr)
+{
+    wchar_t const * p = expr;
+    wchar_t const * const delimiters = L"-_.";
+
+    memset(names, 0, sizeof(__crt_locale_strings));
+
+    size_t const max_sections = 4;
+    _bcp47_section sections[max_sections];
+    size_t num_sections = 0;
+
+    for (auto last_delimiter = _bcp47_section_delimiter::normal;
+         last_delimiter != _bcp47_section_delimiter::end_of_string;
+         last_delimiter = categorize_delimiter(*p++)
+        )
+    {
+        if (num_sections >= max_sections)
+        {
+            // Didn't reach end of string before running out of sections to parse.
+            return false;
+        }
+
+        size_t const section_length = (last_delimiter != _bcp47_section_delimiter::code_page)
+            ? wcscspn(p, delimiters) : wcslen(p);
+
+        sections[num_sections].ptr = p;
+        sections[num_sections].length = section_length;
+        sections[num_sections].delimiter = last_delimiter;
+
+        p += section_length;
+        ++num_sections;
+    }
+
+    switch (num_sections)
+    {
+        case 1:
+            // en
+            return parse_bcp47_language(names, sections[0]);
+        case 2:
+            // en-US
+            // zh-Hans
+            // en.utf-8
+            // .utf-8
+            return parse_bcp47_language(names, sections[0])
+                   && (   parse_bcp47_script(names, sections[1])
+                       || parse_bcp47_region(names, sections[1])
+                       || parse_bcp47_code_page(names, sections[1])
+                      );
+        case 3:
+            // en-US.utf-8
+            // zh-Hans-HK
+            return parse_bcp47_language(names, sections[0])
+                   && (    parse_bcp47_script(names, sections[1]) && (parse_bcp47_region(names, sections[2]) || parse_bcp47_code_page(names, sections[2]))
+                       || (parse_bcp47_region(names, sections[1]) &&  parse_bcp47_code_page(names, sections[2]))
+                      );
+        case 4:
+            // zh-Hans-HK.utf-8
+            return parse_bcp47_language(names, sections[0])
+                && parse_bcp47_script(names, sections[1])
+                && parse_bcp47_region(names, sections[2])
+                && parse_bcp47_code_page(names, sections[3]);
+        default:
+            return false;
+    }
+}
+
+// Utility functions/structs for _expandlocale().
+
+static int get_default_code_page(wchar_t const * const valid_windows_locale_name)
+{
+    int code_page{};
+
+    int const size_written = __acrt_GetLocaleInfoEx(
+        valid_windows_locale_name,
+        LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
+        reinterpret_cast<LPWSTR>(&code_page),
+        sizeof(int) / sizeof(wchar_t)
+        );
+
+    if (size_written == 0 || code_page == 0)
+    {   // Default to UTF-8 if could not find or no default code page.
+        return CP_UTF8;
+    }
+
+    return code_page;
+}
+
+class _expandlocale_locale_name_cache
+{
+    // Scope guard to keep invariants in _expandlocale for the localeNameOutput and _cacheLocaleName variables.
+    // The cacheLocaleName/localeNameOutput is the only cache where work is done progressively in the cache value,
+    // (inside __acrt_get_qualified_locale and __acrt_get_qualified_locale_downlevel)
+    // so we must save/restore at function start and invalidate the cache once we have stuff to commit to both.
+public:
+    _expandlocale_locale_name_cache(
+        wchar_t *                     const localeNameOutput,
+        size_t                        const localeNameSizeInChars,
+        __crt_qualified_locale_data * const psetloc_data
+    ) : _localeNameOutput(localeNameOutput),
+        _localeNameSizeInChars(localeNameSizeInChars),
+        _psetloc_data(psetloc_data),
+        _committed(false)
+    {
+        _ERRCHECK(wcsncpy_s(localeNameOutput, localeNameSizeInChars, psetloc_data->_cacheLocaleName, _countof(psetloc_data->_cacheLocaleName)));
+    }
+
+    ~_expandlocale_locale_name_cache()
+    {
+        if (!_committed)
+        {
+            _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), _localeNameOutput, _localeNameSizeInChars));
+        }
+    }
+
+    _expandlocale_locale_name_cache(_expandlocale_locale_name_cache const&) = delete;
+    _expandlocale_locale_name_cache& operator=(_expandlocale_locale_name_cache const&) = delete;
+
+    void commit_locale_name(wchar_t const * const new_locale_name, size_t const new_locale_name_length)
+    {
+        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), new_locale_name, new_locale_name_length));
+        commit_locale_name_cache_already_updated(new_locale_name, new_locale_name_length);
+    }
+
+    void commit_locale_name_cache_already_updated(wchar_t const * const new_locale_name, size_t const new_locale_name_length)
+    {
+        _ERRCHECK(wcsncpy_s(_localeNameOutput, _localeNameSizeInChars, new_locale_name, new_locale_name_length));
+        _committed = true;
+    }
+
+private:
+    wchar_t *                     _localeNameOutput;
+    size_t                        _localeNameSizeInChars;
+    __crt_qualified_locale_data * _psetloc_data;
+    bool                          _committed;
+};
+
+wchar_t * _expandlocale(
+    wchar_t const * const expr,
+    wchar_t *       const output,
+    size_t          const sizeInChars,
+    wchar_t *       const localeNameOutput,
+    size_t          const localeNameSizeInChars,
+    UINT&                 output_code_page
+    )
+{
+    // Returns: locale name to return to user (lifetime bound to PTD variable _cacheout)
+    // Out Parameters:
+    //  * output: locale name to return to user (lifetime bound to supplied buffer)
+    //  * localeNameOutput: normalized locale name to be used internally (lifetime bound to supplied buffer)
+    //  * output_code_page: code page used
+    //
+    // Effects:
+    //  Parses an input locale string and returns the string that will replicate the effects just taken (output), the string to be used
+    //  for Win32 calls (localeNameOutput), and the code page.
+    //  Note that there are three modes here:
+    //  * Legacy and Windows Locale Names:
+    //      The output locale string and internally used locale string become normalized for Win32 APIs.
+    //      Neither necessarily match the user input locale.
+    //      Uses ACP as default if Windows does not know the code page.
+    //  * Permissive Windows locale names:
+    //      Ask Windows whether full given user string is a known locale name.
+    //      In that case, the output locale string, internally used locale string, and user input locale all match.
+    //      Uses UTF-8 as default if Windows does not know the code page.
+    //  * BCP-47 Locale Names:
+    //      Windows doesn't recognize BCP-47 + code page specifiers, but we must support them for proper UTF-8 support.
+    //      The output locale name must include the code page, but internally we modify the format so Windows understands it.
+    //      Uses UTF-8 as default if Windows does not know the code page.
+    //
+    //  Also populates _psetloc_data structure from the PTD:
+    //  Caching Internals:
+    //    * _cachein: Caches last successful 'expr'.
+    //    * _cacheout: Caches last successful 'output' (which is also the return value).
+    //    * _cachecp: Caches last successful 'output_code_page'.
+    //    * _cacheLocaleName: Caches last successful 'localeNameOutput'.
+    //  Legacy Internals (used by __acrt_get_qualified_locale and __acrt_get_qualified_locale_downlevel only):
+    //    * pchLanguage: Pointer to start of language name, ex: "English"
+    //    * pchCountry: Pointer to start of country/region name, ex: "United States"
+    //    * iLocState: Used to record the match degree for locales checked (i.e. language and region match vs just language match)
+    //    * bAbbrevLanguage: Whether language name is a three-letter short-form, ex: "ENU"
+    //    * bAbbrevCountry: Whether country/region name is a three letter short-form, ex: "USA"
+    //    * iPrimaryLen: Length of pchLanguage portion of locale string
+    //  Also in _psetloc_data, but not used in _expandlocale: _Loc_c
+
+    if (!expr)
+    {
+        return nullptr; // error if no input
+    }
+
+    // C locale
+    // Callers know that LocaleNameOutput has not been updated and check for "C" locale before using it.
+    if (expr[0] == L'C' && expr[1] == L'\0')
+    {
+        _ERRCHECK(wcscpy_s(output, sizeInChars, L"C"));
+        output_code_page = CP_ACP;
+        return output;
+    }
+
+    __crt_qualified_locale_data * const _psetloc_data    = &__acrt_getptd()->_setloc_data;
+    UINT *                        const pcachecp         = &_psetloc_data->_cachecp;
+    wchar_t *                     const cachein          = _psetloc_data->_cachein;
+    size_t                        const cacheinLen       = _countof(_psetloc_data->_cachein);
+    wchar_t *                     const cacheout         = _psetloc_data->_cacheout;
+    size_t                        const cacheoutLen      = _countof(_psetloc_data->_cacheout);
+    size_t                              charactersInExpression = 0;
+    int                                 iCodePage = 0;
+
+    // This guard owns access to localeNameOutput. It expresses the invariants that localeNameOutput and _cacheLocaleName have.
+    _expandlocale_locale_name_cache locale_name_guard(localeNameOutput, localeNameSizeInChars, _psetloc_data);
+
+    // First, make sure we didn't just do this one
+    charactersInExpression = wcslen(expr);
+    if (charactersInExpression >= MAX_LC_LEN ||       // we would never have cached this
+        (wcscmp(cacheout, expr) && wcscmp(cachein, expr)))
+    {
+        __crt_locale_strings names;
+        BOOL getqloc_results = FALSE;
+        BOOL const isDownlevel = !__acrt_can_use_vista_locale_apis();
+
+        // Check if can parse as Legacy/Windows locale name
+        if (__lc_wcstolc(&names, expr) == 0)
+        {
+            if (isDownlevel)
+            {
+                getqloc_results = __acrt_get_qualified_locale_downlevel(&names, pcachecp, &names);
+            }
+            else
+            {
+                getqloc_results = __acrt_get_qualified_locale(&names, pcachecp, &names);
+            }
+        }
+
+        // If successfully parsed as Legacy/Windows name
+        if (getqloc_results)
+        {
+            // Legacy/Windows name resolution returns applies normalization to both returned and internally used locale names.
+            __lc_lctowcs(cacheout, cacheoutLen, &names);
+
+            // __acrt_get_qualified_locale and __acrt_get_qualified_locale_downlevel update _cacheLocaleName - if successful commit locale changes
+            locale_name_guard.commit_locale_name_cache_already_updated(names.szLocaleName, wcslen(names.szLocaleName) + 1);
+        }
+        else if (__acrt_IsValidLocaleName(expr))
+        {
+            // Windows recognizes the locale expression - only work is to grab the code page to be used.
+            iCodePage = get_default_code_page(expr);
+
+            // Commit code page
+            *pcachecp = static_cast<WORD>(iCodePage);
+
+            // Commit locale name that we will return to the user (same as input locale string).
+            _ERRCHECK(wcsncpy_s(cacheout, cacheoutLen, expr, charactersInExpression + 1));
+
+            // Commit locale name for internal use (same as input locale string).
+            locale_name_guard.commit_locale_name(expr, charactersInExpression + 1);
+        }
+        else if (parse_bcp47(&names, expr) && __acrt_IsValidLocaleName(names.szLocaleName))
+        {
+            // Parsed as Windows-recognized BCP-47 tag
+            wchar_t const * const normalized_locale_name = names.szLocaleName;
+
+            if (names.szCodePage[0])
+            {
+                wchar_t const * const cp = names.szCodePage;
+
+                // Allow .utf8/.utf-8 for BCP-47 tags.
+                if (   __ascii_towlower(cp[0]) == L'u'
+                    && __ascii_towlower(cp[1]) == L't'
+                    && __ascii_towlower(cp[2]) == L'f'
+                    &&     (cp[3] == L'8' && cp[4] == L'\0')
+                        || (cp[3] == L'-' && cp[4] == L'8' && cp[5] == L'\0'))
+                {
+                    iCodePage = CP_UTF8;
+                }
+                else
+                {
+                    // Other codepage tokens (fr-FR.1252, etc.) aren't supported for BCP-47 tags (eg: Use Unicode!)
+                    return nullptr;
+                }
+            }
+            else
+            {
+                iCodePage = get_default_code_page(normalized_locale_name);
+            }
+
+            // Commit code page
+            *pcachecp = static_cast<WORD>(iCodePage);
+
+            // Commit locale name that we will return to the user (same as input locale string).
+            _ERRCHECK(wcsncpy_s(cacheout, cacheoutLen, expr, charactersInExpression + 1));
+
+            // Commit normalized name for internal use.
+            locale_name_guard.commit_locale_name(normalized_locale_name, wcslen(normalized_locale_name) + 1);
+        }
+        else
+        {
+            return nullptr;  // input unrecognized as locale name
+        }
+
+        // Operation succeeded - commit input cache.
+        if (*expr && charactersInExpression < MAX_LC_LEN)
+        {
+            _ERRCHECK(wcsncpy_s(cachein, cacheinLen, expr, charactersInExpression + 1));
+        }
+        else
+        {
+            *cachein = L'\x0';
+        }
+    }
+
+    output_code_page = *pcachecp; // Update code page
+
+    _ERRCHECK(wcscpy_s(output, sizeInChars, cacheout));
+    return cacheout; // Return locale name to be given back to user, with lifetime bound in PTD
+}
+
+/* helpers */
+
+void _wcscats ( wchar_t *outstr, size_t numberOfElements, int n, ...)
+{
+    int i;
+    va_list substr;
+
+    va_start (substr, n);
+
+    for (i =0; i<n; i++)
+    {
+        _ERRCHECK(wcscat_s(outstr, numberOfElements, va_arg(substr, wchar_t *)));
+    }
+    va_end(substr);
+}
+
+// Parse the wlocale string to find the array of language/region/codepage strings (if available)
+// in the form .CodePage, Language, Language_Region, Language_Region.Codepage, or Language.CodePage
+// If the input is a BCP-47 tag, then that tag is returned in the names language.
+int __lc_wcstolc ( __crt_locale_strings *names, const wchar_t *wlocale)
+{
+    int i;
+    size_t len;
+    wchar_t wch;
+
+    memset((void *)names, '\0', sizeof(__crt_locale_strings));  /* clear out result */
+
+    if (*wlocale==L'\0')
+        return 0; /* trivial case */
+
+    /* only code page is given */
+    if (wlocale[0] == L'.' && wlocale[1] != L'\0')
+    {
+        _ERRCHECK(wcsncpy_s(names->szCodePage, _countof(names->szCodePage), &wlocale[1], MAX_CP_LEN-1));
+        /* Make sure to null terminate the string in case wlocale is > MAX_CP_LEN */
+        names->szCodePage[ MAX_CP_LEN -1] = 0;
+        return 0;
+    }
+
+    // Looks like Language_Country/Region.Codepage
+    for (i=0; ; i++)
+    {
+        // _ language country/region separator, . is before codepage, either , or \0 are end of string.
+        len = wcscspn(wlocale, L"_.,");
+        if (len == 0)
+            return -1;  /* syntax error, can't start with a separator */
+
+        wch = wlocale[len];
+
+        if ((i == 0) && (len < MAX_LANG_LEN))
+        {
+            _ERRCHECK(wcsncpy_s(names->szLanguage, _countof(names->szLanguage), wlocale, len));
+            if (wch == L'.')
+            {
+                // '.' is a delimiter before codepage, so codepage is expected next (skip country/region)
+                i++;
+            }
+        }
+
+        else if ((i==1) && (len<MAX_CTRY_LEN) && (wch!=L'_'))
+            _ERRCHECK(wcsncpy_s(names->szCountry, _countof(names->szCountry), wlocale, len));
+
+        else if ((i==2) && (len<MAX_CP_LEN) && (wch==L'\0' || wch==L','))
+            _ERRCHECK(wcsncpy_s(names->szCodePage, _countof(names->szCodePage), wlocale, len));
+
+        else
+            return -1;  /* error parsing wlocale string */
+
+        if (wch==L',')
+        {
+            /* modifier not used in current implementation, but it
+               must be parsed to for POSIX/XOpen conformance */
+            /*  wcsncpy(names->szModifier, wlocale, MAX_MODIFIER_LEN-1); */
+            break;
+        }
+
+        if (!wch)
+            break;
+        wlocale+=(len+1);
+    }
+    return 0;
+}
+// Append locale name pieces together in the form of "Language_country/region.CodePage"
+// Note that the preferred form is the BCP-47 tag, but we don't want to change legacy names
+void __lc_lctowcs ( wchar_t *locale, size_t numberOfElements, const __crt_locale_strings *names)
+{
+    _ERRCHECK(wcscpy_s(locale, numberOfElements, names->szLanguage));
+    if (*(names->szCountry))
+        _wcscats(locale, numberOfElements, 2, L"_", names->szCountry);
+    if (*(names->szCodePage))
+        _wcscats(locale, numberOfElements, 2, L".", names->szCodePage);
+}
+
+// Create a copy of a locale name string
+LPWSTR __cdecl __acrt_copy_locale_name(LPCWSTR localeName)
+{
+    size_t cch;
+    wchar_t* localeNameCopy;
+
+    if (!localeName) // Input cannot be nullptr
+        return nullptr;
+
+    cch = wcsnlen(localeName, LOCALE_NAME_MAX_LENGTH);
+    if (cch >= LOCALE_NAME_MAX_LENGTH) // locale name length must be <= LOCALE_NAME_MAX_LENGTH
+        return nullptr;
+
+    if ((localeNameCopy = (wchar_t *) _malloc_crt((cch + 1) * sizeof(wchar_t))) == nullptr)
+        return nullptr;
+
+    _ERRCHECK(wcsncpy_s(localeNameCopy, cch+1, localeName, cch+1));
+    return localeNameCopy;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+} // extern "C"

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/chsize.cpp

@@ -0,0 +1,148 @@
+//
+// chsize.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _chsize() and _chsize_s(), which change the size of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+// Changes the size of the given file, either extending or truncating it.  The
+// file must have been opened with write permissions or this will fail.  Returns
+// 0 on success; returns an errno error code on failure,
+static errno_t __cdecl _chsize_s_internal(int const fh, __int64 const size, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN_ERRCODE(ptd, fh, EBADF);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(ptd, (_osfile(fh) & FOPEN), EBADF);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(ptd, (size >= 0), EINVAL);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if (_osfile(fh) & FOPEN)
+        {
+            return _chsize_nolock_internal(fh, size, ptd);
+        }
+        else
+        {
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread", 0));
+            return ptd.get_errno().set(EBADF);
+        }
+    });
+}
+
+extern "C" errno_t __cdecl _chsize_s(int const fh, __int64 const size)
+{
+    __crt_cached_ptd_host ptd;
+    return _chsize_s_internal(fh, size, ptd);
+}
+
+struct __crt_seek_guard
+{
+
+    __crt_seek_guard(int const fh, __int64 const size)
+        : place(_lseeki64_nolock(fh, 0, SEEK_CUR)),
+        end(_lseeki64_nolock(fh, 0, SEEK_END)),
+        extend(size - end),
+        fhh(fh)
+    {
+    }
+
+    ~__crt_seek_guard()
+    {
+        _lseeki64_nolock(fhh, place, SEEK_SET);
+    }
+
+    __crt_seek_guard(__crt_seek_guard const &) = delete;
+    __crt_seek_guard& operator=(__crt_seek_guard const &) = delete;
+
+    __int64 place;
+    __int64 end;
+    __int64 extend;
+    int fhh;
+};
+
+extern "C" errno_t __cdecl _chsize_nolock_internal(int const fh, __int64 const size, __crt_cached_ptd_host& ptd)
+{
+    // Get current file position and seek to end
+    __crt_seek_guard seek_guard(fh, size);
+
+    if (seek_guard.place == -1 || seek_guard.end == -1)
+    {
+        // EBADF if earlier lseek (in __crt_seek_guard) failed
+        // EINVAL otherwise (ex: too large of a offset)
+        return ptd.get_errno().value_or(EINVAL);
+    }
+
+    // Grow or shrink the file as necessary:
+    if (seek_guard.extend > 0)
+    {
+        // Extend the file by filling the new area with zeroes:
+        __crt_unique_heap_ptr<char> const zero_buffer(_calloc_crt_t(char, _INTERNAL_BUFSIZ));
+        if (!zero_buffer)
+        {
+            return ptd.get_errno().set(ENOMEM);
+        }
+
+        int const old_mode = _setmode_nolock(fh, _O_BINARY);
+
+        do
+        {
+            int const bytes_to_write = seek_guard.extend >= static_cast<__int64>(_INTERNAL_BUFSIZ)
+                ? _INTERNAL_BUFSIZ
+                : static_cast<int>(seek_guard.extend);
+
+            int const bytes_written = _write_nolock(fh, zero_buffer.get(), bytes_to_write, ptd);
+            if (bytes_written == -1)
+            {
+                // Error on write:
+                if (ptd.get_doserrno().check(ERROR_ACCESS_DENIED))
+                {
+                    ptd.get_errno().set(EACCES);
+                }
+
+                return ptd.get_errno().value_or(0);
+            }
+
+            seek_guard.extend -= bytes_written;
+        } while (seek_guard.extend > 0);
+
+#pragma warning(suppress:6031) // return value ignored
+        _setmode_nolock(fh, old_mode);
+    }
+    else if (seek_guard.extend < 0)
+    {
+        // Shorten the file by truncating it:
+        __int64 const new_end = _lseeki64_nolock(fh, size, SEEK_SET);
+        if (new_end == -1)
+        {
+            return ptd.get_errno().value_or(0);
+        }
+
+        if (!SetEndOfFile(reinterpret_cast<HANDLE>(_get_osfhandle(fh))))
+        {
+            ptd.get_doserrno().set(GetLastError());
+            return ptd.get_errno().set(EACCES);
+        }
+    }
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl _chsize_nolock(int const fh, __int64 const size)
+{   // TODO: _chsize_nolock is already internal-only.
+    // Once PTD is propagated everywhere, rename _chsize_nolock_internal to _chsize_nolock.
+    __crt_cached_ptd_host ptd;
+    return _chsize_nolock_internal(fh, size, ptd);
+}
+
+
+// Changes the size of the given file, either extending or truncating it.  The
+// file must have been opened with write permissions or this will fail.  Returns
+// 0 on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl _chsize(int const fh, long const size)
+{
+    return _chsize_s(fh, size) == 0 ? 0 : -1;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/close.cpp

@@ -0,0 +1,101 @@
+//
+// close.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _close(), which closes a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Closes the underlying OS file handle, if and only if nt needs to be closed.
+// Returns 0 on success; returns the OS error on failure.
+static DWORD close_os_handle_nolock(int const fh) throw()
+{
+    // If the underlying handle is INVALID_HANDLE_VALUE, don't try to acutally
+    // close it:
+    if (_get_osfhandle(fh) == (intptr_t)INVALID_HANDLE_VALUE)
+    {
+        return 0;
+    }
+
+    // If the file handle is stdout or stderr, and if stdout and stderr are
+    // mapped to the same OS file handle, skip the CloseHandle without error.
+    //
+    // stdout and stderr are the only handles for which this support is
+    // provided.  Other handles may be mapped to the same OS file handle only
+    // at the programmer's risk.
+    bool is_other_std_handle_open =
+        fh == 1 && (_osfile(2) & FOPEN) ||
+        fh == 2 && (_osfile(1) & FOPEN);
+
+    if (is_other_std_handle_open && _get_osfhandle(1) == _get_osfhandle(2))
+    {
+        return 0;
+    }
+
+    // Otherwise, we can go ahead and close the handle:
+    if (CloseHandle(reinterpret_cast<HANDLE>(_get_osfhandle(fh))))
+    {
+        return 0;
+    }
+
+    return GetLastError();
+}
+
+
+
+// Closes the file associated with the given file handle.  On success, returns 0.
+// On failure, returns -1 and sets errno.
+extern "C" int __cdecl _close_internal(int const fh, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if (_osfile(fh) & FOPEN)
+        {
+            return _close_nolock_internal(fh, ptd);
+        }
+        else
+        {
+            ptd.get_errno().set(EBADF);
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            return -1;
+        }
+    });
+}
+
+extern "C" int __cdecl _close(int const fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _close_internal(fh, ptd);
+}
+
+
+
+extern "C" int __cdecl _close_nolock_internal(int const fh, __crt_cached_ptd_host& ptd)
+{
+    DWORD const close_os_handle_error = close_os_handle_nolock(fh);
+
+    _free_osfhnd(fh);
+    _osfile(fh) = 0;
+
+    if (close_os_handle_error != 0)
+    {
+        __acrt_errno_map_os_error_ptd(close_os_handle_error, ptd);
+        return -1;
+    }
+
+    return 0;
+}
+
+extern "C" int __cdecl _close_nolock(int const fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _close_nolock_internal(fh, ptd);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/commit.cpp

@@ -0,0 +1,36 @@
+//
+// commit.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _commit(), which flushes a file buffer to disk.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+// Flushes the buffer for the given file to disk.
+//
+// On success, 0 is returned.  On failure, -1 is returned and errno is set.
+extern "C" int __cdecl _commit(int const fh)
+{
+    _CHECK_FH_RETURN(fh, EBADF, -1);
+    _VALIDATE_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _VALIDATE_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if (_osfile(fh) & FOPEN)
+        {
+            if (FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(fh))))
+                return 0; // Success
+
+            _doserrno = GetLastError();
+        }
+
+        errno = EBADF;
+
+        _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+        return -1;
+    });
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/creat.cpp

@@ -0,0 +1,41 @@
+//
+// creat.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _creat() (and _wcreat(), via inclusion), which creates a new file.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+// Creates a new file.
+//
+// If the file does not exist, this function creates a new file with the given
+// permission setting and opens it for writing.  If the file already exists and
+// its permission allows writing, this function truncates it to zero length and
+// opens it for writing.
+//
+// The only XENIX mode bit supported is user write (S_IWRITE).
+//
+// On success, the handle for the newly created file is returned.  On failure,
+// -1 is returned and errno is set.
+template <typename Character>
+static int __cdecl common_creat(Character const* const path, int const pmode) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+    // creat is just the same as open...
+    int fh = -1;
+    errno_t e = traits::tsopen_s(&fh, path, _O_CREAT + _O_TRUNC + _O_RDWR, _SH_DENYNO, pmode);
+    return e == 0 ? fh : -1;
+}
+
+extern "C" int __cdecl _creat(char const* const path, int const pmode)
+{
+    return common_creat(path, pmode);
+}
+
+extern "C" int __cdecl _wcreat(wchar_t const* const path, int const pmode)
+{
+    return common_creat(path, pmode);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup.cpp

@@ -0,0 +1,95 @@
+//
+// dup.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _dup() and _dup_nolock, which duplicate lowio file handles
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+static int __cdecl duplicate_osfhnd(int const fh, int const new_fh, __crt_cached_ptd_host& ptd) throw()
+{
+    // Duplicate the file handle:
+    intptr_t new_osfhandle;
+
+    BOOL const result = DuplicateHandle(
+        GetCurrentProcess(),
+        reinterpret_cast<HANDLE>(_get_osfhandle(fh)),
+        GetCurrentProcess(),
+        &reinterpret_cast<HANDLE&>(new_osfhandle),
+        0L,
+        TRUE,
+        DUPLICATE_SAME_ACCESS);
+
+    if (!result)
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    // Duplicate the handle state:
+    __acrt_lowio_set_os_handle(new_fh, new_osfhandle);
+    _osfile(new_fh) = _osfile(fh) & ~FNOINHERIT;
+    _textmode(new_fh) = _textmode(fh);
+    _tm_unicode(new_fh) = _tm_unicode(fh);
+    return new_fh;
+}
+
+static int __cdecl _dup_nolock_internal(int const fh, __crt_cached_ptd_host& ptd) throw()
+{
+    if ((_osfile(fh) & FOPEN) == 0)
+    {
+        ptd.get_errno().set(EBADF);
+        ptd.get_doserrno().set(0);
+        _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread", 0));
+        return -1;
+    }
+
+    // Allocate a duplicate handle
+    int const new_fh = _alloc_osfhnd();
+    if (new_fh == -1)
+    {
+        ptd.get_errno().set(EMFILE);
+        ptd.get_doserrno().set(0);
+        return -1;
+    }
+
+    int return_value = -1;
+    __try
+    {
+        return_value = duplicate_osfhnd(fh, new_fh, ptd);
+    }
+    __finally
+    {
+        // The handle returned by _alloc_osfhnd is both open and locked.  If we
+        // failed to duplicate the handle, we need to abandon the handle by
+        // unsetting the open flag.  We always need to unlock the handle:
+        if (return_value == -1)
+        {
+            _osfile(new_fh) &= ~FOPEN;
+        }
+
+        __acrt_lowio_unlock_fh(new_fh);
+    }
+    return return_value;
+}
+
+static int __cdecl _dup_internal(int const fh, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&](){
+        return _dup_nolock_internal(fh, ptd);
+    });
+}
+
+// _dup() duplicates a file handle and returns the duplicate.  If the function
+// fails, -1 is returned and errno is set.
+extern "C" int __cdecl _dup(int const fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _dup_internal(fh, ptd);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup2.cpp

@@ -0,0 +1,120 @@
+//
+// dup2.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _dup2() and _dup2_nolock, which duplicate lowio file handles
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+static int __cdecl _dup2_nolock_internal(int const source_fh, int const target_fh, __crt_cached_ptd_host& ptd) throw()
+{
+    if ((_osfile(source_fh) & FOPEN) == 0)
+    {
+        // If the source handle is not open, return an error.  Noe that the
+        // DuplicateHandle API will not detect this error, because it implies
+        // that _osfhnd(source_fh) == INVALID_HANDLE_VALUE, and this is a
+        // legal HANDLE value to be duplicated.
+        ptd.get_errno().set(EBADF);
+        ptd.get_doserrno().set(0);
+        _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+        return -1;
+    }
+
+    // Duplicate the source file onto the target file:
+    intptr_t new_osfhandle;
+
+    BOOL const result = DuplicateHandle(
+        GetCurrentProcess(),
+        reinterpret_cast<HANDLE>(_get_osfhandle(source_fh)),
+        GetCurrentProcess(),
+        &reinterpret_cast<HANDLE&>(new_osfhandle),
+        0,
+        TRUE,
+        DUPLICATE_SAME_ACCESS);
+
+    if (!result)
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    // If the target is open, close it once we know the OS handle was duplicated successfully.
+    // We ignore the possibility of an error here: an error simply means that the OS handle
+    // value may remain bound for the duration of the process.
+    if (_osfile(target_fh) & FOPEN)
+    {
+        _close_nolock_internal(target_fh, ptd);
+    }
+
+    __acrt_lowio_set_os_handle(target_fh, new_osfhandle);
+
+    // Copy the _osfile information, with the FNOINHERIT bit cleared:
+    _osfile(target_fh) = _osfile(source_fh) & ~FNOINHERIT;
+    _textmode(target_fh) = _textmode(source_fh);
+    _tm_unicode(target_fh) = _tm_unicode(source_fh);
+
+    return 0;
+}
+
+static int __cdecl _dup2_internal(int const source_fh, int const target_fh, __crt_cached_ptd_host& ptd) throw()
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, source_fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (source_fh >= 0 && (unsigned)source_fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(source_fh) & FOPEN), EBADF, -1);
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, target_fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, ((unsigned)target_fh < _NHANDLE_), EBADF, -1);
+
+    // Make sure there is an __crt_lowio_handle_data struct corresponding to the target_fh:
+    if (target_fh >= _nhandle && __acrt_lowio_ensure_fh_exists(target_fh) != 0)
+    {
+        return -1;
+    }
+
+    // If the source and target are the same, return success (we've already
+    // verified that the file handle is open, above).  This is for conformance
+    // with the POSIX specification for dup2.
+    if (source_fh == target_fh)
+    {
+        return 0;
+    }
+
+    // Obtain the two file handle locks.  In order to prevent deadlock, we
+    // always obtain the lock for the lower-numbered file handle first:
+    if (source_fh < target_fh)
+    {
+        __acrt_lowio_lock_fh(source_fh);
+        __acrt_lowio_lock_fh(target_fh);
+    }
+    else if (source_fh > target_fh)
+    {
+        __acrt_lowio_lock_fh(target_fh);
+        __acrt_lowio_lock_fh(source_fh);
+    }
+
+    int result = 0;
+
+    __try
+    {
+        result = _dup2_nolock_internal(source_fh, target_fh, ptd);
+    }
+    __finally
+    {
+        // The order in which we unlock the file handles does not matter:
+        __acrt_lowio_unlock_fh(source_fh);
+        __acrt_lowio_unlock_fh(target_fh);
+    }
+    return result;
+}
+
+// _dup2() makes the target file handle a duplicate of the source file handle,
+// so that both handles refer to the same file.  If the target handle is open
+// upon entry, it is closed so that it is not leaked.
+//
+// Returns 0 if successful; returns -1 and sets errno on failure.
+extern "C" int __cdecl _dup2(int const source_fh, int const target_fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _dup2_internal(source_fh, target_fh, ptd);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/eof.cpp

@@ -0,0 +1,50 @@
+//
+// eof.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _eof(), which tests whether a file is at EOF.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+// Tests if a file is at EOF.  Returns:
+//  *  1 if at EOF
+//  *  0 if not at EOF
+//  * -1 on failure (errno is set)
+extern "C" int __cdecl _eof(int const fh)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            return -1;
+        }
+
+        __int64 const here = _lseeki64_nolock(fh, 0i64, SEEK_CUR);
+        if (here == -1i64)
+            return -1;
+
+
+        __int64 const end = _lseeki64_nolock(fh, 0i64, SEEK_END);
+        if (end == -1i64)
+            return -1;
+
+        // Now we can test if we're at the end:
+        if (here == end)
+            return 1;
+
+        // If we aren't at the end, we need to reset the stream to its original
+        // state before we return:
+        _lseeki64_nolock(fh, here, SEEK_SET);
+        return 0;
+    });
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/filelength.cpp

@@ -0,0 +1,62 @@
+//
+// filelength.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _filelength(), which computes the length of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// Computes the length, in bytes, of the given file. Returns -1 on failure.
+template <typename Integer>
+_Success_(return != -1)
+static Integer __cdecl common_filelength(int const fh) throw()
+{
+    typedef __crt_integer_traits<Integer> traits;
+
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN,                          EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    Integer end = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread", 0));
+            __leave;
+        }
+
+        // Seek to the end to get the length:
+        Integer const here = traits::lseek_nolock(fh, 0, SEEK_CUR);
+        if (here == -1)
+            __leave;
+
+        end = traits::lseek_nolock(fh, 0, SEEK_END);
+        if (here != end)
+            traits::lseek_nolock(fh, here, SEEK_SET);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return end;
+}
+
+extern "C" long __cdecl _filelength(int const fh)
+{
+    return common_filelength<long>(fh);
+}
+
+extern "C" __int64 __cdecl _filelengthi64(int const fh)
+{
+    return common_filelength<__int64>(fh);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/ioinit.cpp

@@ -0,0 +1,265 @@
+//
+// ioinit.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines initialization and termination routines for the lowio library, along
+// with global data shared by most of the lowio library.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_stdio.h>
+
+
+
+// This is a special static lowio file object referenced only by the safe access
+// functionality in the internal headers.  It is used in certain stdio-level
+// functions to more gracefully handle a FILE with -1 as its lowio file id.
+extern "C" __crt_lowio_handle_data __badioinfo =
+{
+    { },                         // lock
+    static_cast<intptr_t>(-1),   // osfhnd
+    0,                           // startpos
+    FTEXT,                       // osfile
+    __crt_lowio_text_mode::ansi, // textmode
+    { LF, LF, LF },              // _pipe_lookahead
+};
+
+
+
+// This is the number of lowio file objects that have been allocated.  This
+// includes both in-use and unused elements, since not all allocated files
+// are necessarily in use at any given time.
+//
+// This number is in the range of [IOINFO_ARRAY_ELTS, _NHANDLE_]
+extern "C" int _nhandle = 0;
+
+
+
+// This is the global array of file object arrays:
+extern "C" __crt_lowio_handle_data* __pioinfo[IOINFO_ARRAYS] = { 0 };
+
+
+
+static DWORD __cdecl get_std_handle_id(int const fh) throw()
+{
+    // Convert the CRT file handle to the OS file handle for the three 
+    // standard streams:
+    switch (fh)
+    {
+    case 0: return STD_INPUT_HANDLE;
+    case 1: return STD_OUTPUT_HANDLE;
+    case 2: return STD_ERROR_HANDLE;
+    }
+
+    return STD_ERROR_HANDLE; // Unreachable, but the compiler can't know.
+}
+
+
+
+static void __cdecl initialize_inherited_file_handles_nolock() throw()
+{
+    STARTUPINFOW startup_info;
+    GetStartupInfoW(&startup_info);
+
+    // First check and see if we inherited any file handles.  If we didn't, then
+    // we don't have anything to initialize:
+    if (startup_info.cbReserved2 == 0 || startup_info.lpReserved2 == nullptr)
+        return;
+
+    // Get the number of inherited handles:
+    int const handle_count = *reinterpret_cast<UNALIGNED int*>(startup_info.lpReserved2);
+
+    // Compute the start of the passed file info and OS HANDLEs:
+    unsigned char* const first_file =
+        reinterpret_cast<unsigned char*>(startup_info.lpReserved2) + sizeof(int);
+
+    UNALIGNED intptr_t* const first_handle =
+        reinterpret_cast<UNALIGNED intptr_t*>(first_file + handle_count);
+
+    // Do not attempt to inherit more than the maximum number of supported handles:
+    int handles_to_inherit = handle_count < _NHANDLE_ 
+        ? handle_count
+        : _NHANDLE_;
+
+    // Attempt to allocate the required number of handles.  If we fail for any
+    // reason, we'll inherit as many handles as we can:
+    __acrt_lowio_ensure_fh_exists(handles_to_inherit);
+    if (handles_to_inherit > _nhandle)
+        handles_to_inherit = _nhandle;
+
+    // Validate and copy the provided file information:
+    unsigned char*      it_file   = first_file;
+    UNALIGNED intptr_t* it_handle = first_handle;
+
+    for (int fh = 0; fh != handles_to_inherit; ++fh, ++it_file, ++it_handle)
+    {
+        HANDLE const real_handle = reinterpret_cast<HANDLE>(*it_handle);
+
+        // If the provided information does not appear to describe an open,
+        // valid file or device, skip it:
+        if (real_handle == INVALID_HANDLE_VALUE)
+            continue;
+
+        if (*it_handle == _NO_CONSOLE_FILENO)
+            continue;
+
+        if ((*it_file & FOPEN) == 0)
+            continue;
+
+        // GetFileType cannot be called for pipe handles since it may "hang" if
+        // there is a blocked read pending on the pipe in the parent.
+        if ((*it_file & FPIPE) == 0 && GetFileType(real_handle) == FILE_TYPE_UNKNOWN)
+            continue;
+
+        // Okay, the file looks valid:
+        __crt_lowio_handle_data* const pio = _pioinfo(fh);
+        pio->osfhnd = *it_handle;
+        pio->osfile = *it_file;
+    }
+}
+
+
+
+static void initialize_stdio_handles_nolock() throw()
+{
+    for (int fh = 0; fh != STDIO_HANDLES_COUNT; ++fh)
+    {
+        __crt_lowio_handle_data* const pio = _pioinfo(fh);
+
+        // If this handle was inherited from the parent process and initialized
+        // already, make sure it has the FTEXT flag and continue:
+        if (pio->osfhnd != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE) &&
+            pio->osfhnd != _NO_CONSOLE_FILENO)
+        {
+            pio->osfile |= FTEXT;
+            continue;
+        }
+
+        // Regardless what happens next, the file will be treated as if it is
+        // open in text mode:
+        pio->osfile = FOPEN | FTEXT;
+
+        // This handle has not yet been initialized, so  let's see if we can get
+        // the handle from the OS:
+        intptr_t const os_handle = reinterpret_cast<intptr_t>(GetStdHandle(get_std_handle_id(fh)));
+
+        bool const is_valid_handle = 
+            os_handle != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE) &&
+            os_handle != reinterpret_cast<intptr_t>(nullptr);
+
+        DWORD const handle_type = is_valid_handle
+            ? GetFileType(reinterpret_cast<HANDLE>(os_handle))
+            : FILE_TYPE_UNKNOWN;
+
+
+        if (handle_type != FILE_TYPE_UNKNOWN)
+        {
+            // The file type is known, so we obtained a valid handle from the
+            // OS.  Finish initializing the lowio file object for this handle,
+            // including the flag specifying whether this is a character device
+            // or a pipe:
+            pio->osfhnd = os_handle;
+
+            if ((handle_type & 0xff) == FILE_TYPE_CHAR)
+                pio->osfile |= FDEV;
+
+            else if ((handle_type & 0xff) == FILE_TYPE_PIPE)
+                pio->osfile |= FPIPE;
+        }
+        else
+        {
+            // We were unable to get the handles from the OS.  For stdin, stdout,
+            // and stderr, if there is no valid OS handle, treat the CRT handle
+            // as being open in text mode on a device with _NO_CONSOLE_FILENO
+            // underlying it.  We use this value instead of INVALID_HANDLE_VALUE
+            // to distinguish between a failure in opening a file and a program
+            // run without a console:
+            pio->osfile |= FDEV;
+            pio->osfhnd = _NO_CONSOLE_FILENO;
+
+            // Also update the corresponding stdio stream, unless stdio was
+            // already terminated:
+            if (__piob)
+                __piob[fh]->_file = _NO_CONSOLE_FILENO;
+        }
+    }
+}
+
+
+
+// Initializes the lowio library.  This initialization comprises several steps:
+//
+// [1] An initial array of __crt_lowio_handle_data structures is allocated.
+//
+// [2] Inherited file handles are initialized.  To do this, sthe startup info
+//     is obtained from the OS, via the lpReserved2 member.  The format of the
+//     information is as follows:
+//
+//     [Bytes 0 - 3]       Integer value N, which is the number of handles that
+//                         are provided by the parent process.
+//
+//     [Bytes 4 - N+3]     The N osfile values.
+//
+//     [Bytes N+4 - 5*N+3] The N OS HANDLE values, as DWORDs
+//
+// [3] Next, the first three lowio files (corresponding to stdin, stdout, and
+//     stderr) are initialized as follows:  If the value in osfhnd is 
+//     INVALID_HANDLE_VALUE, then we try to obtain a HANDLE from the OS.  These
+//     handles are forced to text mode, as standard input, output, and error
+//     always start out in text mode.
+//
+// Notes:
+//
+// [1] In general, not all of the pased info from the parent process will
+//     describe open handles.  If, for example, only C handle 1 (stdout) and
+//     C handle 6 are open in the parent, info for C handles 0 through 6 are
+//     passed to the child.  0, 2, 3, 4, and 5 will not describe open handles.
+//
+// [2] Care is taken not to "overflow" the arrays of lowio file objects.
+//
+// [3] See the dospawn logic for the encoding of the file handle info to be
+//     passed to a child process.
+//
+// This funtion returns 0 on success; -1 on failure.
+extern "C" bool __cdecl __acrt_initialize_lowio()
+{
+    __acrt_lock(__acrt_lowio_index_lock);
+    bool result = false;
+    __try
+    {
+        // First, allocate and initialize the initial array of lowio files:
+        if (__acrt_lowio_ensure_fh_exists(0) != 0)
+            __leave;
+
+        // Next, process and initialize all inherited file handles:
+        initialize_inherited_file_handles_nolock();
+
+        // Finally, initialize the stdio handles, if they were not inherited:
+        initialize_stdio_handles_nolock();
+        result = true;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_lowio_index_lock);
+    }
+
+    return result;
+}
+
+
+
+// Shuts down the lowio library, freeing all allocated memory and destroying all
+// created synchronization objects.
+extern "C" bool __cdecl __acrt_uninitialize_lowio(bool const /* terminating */)
+{
+    for (size_t i = 0; i < IOINFO_ARRAYS; ++i)
+    {
+        if (!__pioinfo[i])
+            continue;
+
+        __acrt_lowio_destroy_handle_array(__pioinfo[i]);
+        __pioinfo[i] = nullptr;
+    }
+
+    return true;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/isatty.cpp

@@ -0,0 +1,32 @@
+//
+// isatty.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _isatty(), which tests whether a file refers to a character device.
+//
+#include <corecrt_internal_lowio.h>
+
+// VSO 41542369 - Ruby tries to locate the __pioinfo pointer by looking 
+// backwards from the ret instruction. This is not supported in general,
+// but in addition Ruby expects an [add rsp] instruction before the ret.
+// Whether that pattern exists depends on what optimizations are applied.
+// This creates AppCompat issues as Ruby based applications abort at start.
+// We work around it having _isatty being a jmp to the real fucntion,
+// followed by non-reachable code that Ruby looks for.
+// See also isatty_ruby.asm
+
+// Tests if the given file refers to a character device (e.g. terminal, console,
+// printer, serial port, etc.).  Returns nonzero if so; zero if not.
+
+#if defined(_ISATTY_ASM) && !defined(_ARM64EC_)
+extern "C" int __cdecl _isatty_proc(int const fh)
+#else
+extern "C" int __cdecl _isatty(int const fh)
+#endif
+{
+    _CHECK_FH_RETURN(fh, EBADF, 0);
+    _VALIDATE_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, 0);
+
+    return static_cast<int>(_osfile(fh) & FDEV);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/locking.cpp

@@ -0,0 +1,120 @@
+//
+// locking.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _locking(), which locks and unlocks regions of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <sys\locking.h>
+
+
+
+static int __cdecl locking_nolock(int const fh, int const locking_mode, long const number_of_bytes) throw()
+{
+    __int64 const lock_offset = _lseeki64_nolock(fh, 0L, SEEK_CUR);
+    if (lock_offset == -1)
+        return -1;
+
+    OVERLAPPED overlapped = { 0 };
+    overlapped.Offset     = static_cast<DWORD>(lock_offset);
+    overlapped.OffsetHigh = static_cast<DWORD>((lock_offset >> 32) & 0xffffffff);
+
+    // Set the retry count, based on the mode:
+    bool const allow_retry = locking_mode == _LK_LOCK || locking_mode == _LK_RLCK;
+    int  const retry_count = allow_retry ? 10 : 1;
+
+    // Ask the OS to lock the file either until the request succeeds or the
+    // retry count is reached, whichever comes first.  Note that the only error
+    // possible is a locking violation, since an invalid handle would have
+    // already failed above.
+    bool succeeded = false;
+    for (int i = 0; i != retry_count; ++i)
+    {
+        if (locking_mode == _LK_UNLCK)
+        {
+            succeeded = UnlockFileEx(
+                reinterpret_cast<HANDLE>(_get_osfhandle(fh)),
+                0,
+                number_of_bytes,
+                0,
+                &overlapped) == TRUE;
+        }
+        else
+        {
+            // Ensure exclusive lock access, and return immediately if lock
+            // acquisition fails:
+            succeeded = LockFileEx(
+                reinterpret_cast<HANDLE>(_get_osfhandle(fh)),
+                LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY,
+                0,
+                number_of_bytes,
+                0,
+                &overlapped) == TRUE;
+        }
+
+        if (succeeded)
+        {
+            break;
+        }
+
+        // Doesnt sleep on the last try
+        if (i != retry_count - 1)
+        {
+            Sleep(1000);
+        }
+    }
+
+    // If an OS error occurred (e.g., if the file was already locked), return
+    // EDEADLOCK if this was ablocking call; otherwise map the error noramlly:
+    if (!succeeded)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        if (locking_mode == _LK_LOCK || locking_mode == _LK_RLCK)
+        {
+            errno = EDEADLOCK;
+        }
+
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+// Locks or unlocks the requested number of bytes in the specified file.
+//
+// Note that this function acquires the lock for the specified file and holds
+// this lock for the entire duration of the call, even during the one second
+// delays between calls into the operating system.  This is to prevent other
+// threads from changing the file during the call.
+//
+// Returns 0 on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl _locking(int const fh, int const locking_mode, long const number_of_bytes)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(number_of_bytes >= 0, EINVAL, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0)); 
+            __leave;
+        }
+
+        result = locking_nolock(fh, locking_mode, number_of_bytes);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/lseek.cpp

@@ -0,0 +1,171 @@
+//
+// lseek.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lseek(), which seeks the file pointer of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <stdlib.h>
+
+#if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END
+    #error Xenix and Win32 seek constants not compatible
+#endif
+
+
+
+// These functions actually seek the underlying operating system file handle.
+// The logic is different for 32-bit and 64-bit seek values because a seek may
+// end up moving out of range of 32-bit values.
+static long __cdecl common_lseek_do_seek_nolock(HANDLE const os_handle, long const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    LARGE_INTEGER const origin_pos = { 0 };
+
+    LARGE_INTEGER saved_pos;
+    if (!SetFilePointerEx(os_handle, origin_pos, &saved_pos, FILE_CURRENT))
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    LARGE_INTEGER seek_pos = { 0 };
+    seek_pos.QuadPart = offset;
+
+    LARGE_INTEGER new_pos = { 0 };
+    if (!SetFilePointerEx(os_handle, seek_pos, &new_pos, origin))
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    // The call succeeded, but the new file pointer location is too large for
+    // the return type or is a negative value.  So, restore the file pointer
+    // to the saved location and return an error:
+    if (new_pos.QuadPart > LONG_MAX)
+    {
+        SetFilePointerEx(os_handle, saved_pos, nullptr, FILE_BEGIN);
+        ptd.get_errno().set(EINVAL);
+        return -1;
+    }
+
+    return static_cast<long>(new_pos.LowPart);
+}
+
+static __int64 __cdecl common_lseek_do_seek_nolock(HANDLE const os_handle, __int64 const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    LARGE_INTEGER new_pos;
+    if (!SetFilePointerEx(os_handle, *reinterpret_cast<LARGE_INTEGER const*>(&offset), &new_pos, origin))
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    return new_pos.QuadPart;
+}
+
+
+template <typename Integer>
+static Integer __cdecl common_lseek_nolock(int const fh, Integer const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_get_osfhandle(fh));
+    if (os_handle == reinterpret_cast<HANDLE>(-1))
+    {
+        ptd.get_errno().set(EBADF);
+        _ASSERTE(("Invalid file descriptor",0));
+        return -1;
+    }
+
+    Integer const new_position = common_lseek_do_seek_nolock(os_handle, offset, origin, ptd);
+    if (new_position == -1)
+    {
+        return -1;
+    }
+
+    // The call succeeded, so return success:
+    _osfile(fh) &= ~FEOFLAG; // Clear the Ctrl-Z flag
+    return new_position;
+}
+
+// Moves the file pointer associated with the given file to a new position.  The
+// new position is 'offset' bytes (the offset may be negative) away from the
+// origin specified by 'origin'.
+//
+//     If origin == SEEK_SET, the origin in the beginning of file
+//     If origin == SEEK_CUR, the origin is the current file pointer position
+//     If origin == SEEK_END, the origin is the end of the file
+//
+// Returns the offset, in bytes, of the new position, from the beginning of the
+// file.  Returns -1 and sets errno on failure.  Note that seeking beyond the
+// end of the file is not an error, but seeking before the beginning is.
+template <typename Integer>
+static Integer __cdecl common_lseek(int const fh, Integer const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, _osfile(fh) & FOPEN, EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    Integer result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            ptd.get_errno().set(EBADF);
+            ptd.get_doserrno().set(0);
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = common_lseek_nolock(fh, offset, origin, ptd);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+extern "C" long __cdecl _lseek_internal(int const fh, long const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64_internal(int const fh, __int64 const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" long __cdecl _lseek_nolock_internal(int const fh, long const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64_nolock_internal(int const fh, __int64 const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}
+
+extern "C" long __cdecl _lseek(int const fh, long const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64(int const fh, __int64 const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" long __cdecl _lseek_nolock(int const fh, long const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64_nolock(int const fh, __int64 const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/mktemp.cpp

@@ -0,0 +1,168 @@
+//
+// mktemp.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _tmktemp() and _tmktemp_s(), which create unique file names.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_securecrt.h>
+#include <mbctype.h>
+#include <process.h>
+#include <stddef.h>
+#include <stdio.h>
+
+
+
+// These functions test whether we should continue scanning for X's.
+static bool common_mktemp_s_continue(char const* const string, char const* const current) throw()
+{
+    return !_ismbstrail(
+        reinterpret_cast<unsigned char const*>(string),
+        reinterpret_cast<unsigned char const*>(current));
+}
+
+static bool common_mktemp_s_continue(wchar_t const* const, wchar_t const* const) throw()
+{
+    return true;
+}
+
+
+
+// Creates a unique file name given a template string of the form "fnamXXXXXX".
+// The "XXXXXX" sequence is replaced by a letter and the five-digit thread
+// identifier.
+//
+// The template string is modified in-place.  Returns 0 on success; returns an
+// errno error code on failure.
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_mktemp_s(
+    _Inout_updates_z_(buffer_size_in_chars) Character* const    template_string,
+                                            size_t     const    buffer_size_in_chars
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN_ERRCODE(template_string != nullptr && buffer_size_in_chars > 0, EINVAL);
+
+    size_t const template_string_length = traits::tcsnlen(template_string, buffer_size_in_chars);
+    if (template_string_length >= buffer_size_in_chars)
+    {
+        _RESET_STRING(template_string, buffer_size_in_chars);
+        _RETURN_DEST_NOT_NULL_TERMINATED(template_string, buffer_size_in_chars);
+    }
+    _FILL_STRING(template_string, buffer_size_in_chars, template_string_length + 1);
+
+    if(template_string_length < 6 || buffer_size_in_chars <= template_string_length)
+    {
+        _RESET_STRING(template_string, buffer_size_in_chars);
+        _VALIDATE_RETURN_ERRCODE(("Incorrect Input for mktemp", 0), EINVAL);
+    }
+
+    // The Win32 thread identifier is unique across all threads in all processes.
+    // Note, however, that unlike *NIX process identifiers, which are not reused
+    // until all values up to 32K have been used, Win32 thread identifiers are
+    // frequenty reused and usually have small numbers.
+    unsigned number = GetCurrentThreadId();
+
+    // 'string' points to the null-terminator:
+    Character* string = template_string + template_string_length;
+
+    size_t template_length = 0;
+
+    // Replace the last five 'X' characters with the number:
+    while (--string >= template_string 
+        && common_mktemp_s_continue(template_string, string)
+        && *string == 'X'
+        && template_length < 5)
+    {
+        ++template_length;
+        *string = static_cast<Character>((number % 10) + '0');
+        number /= 10;
+    }
+
+    // Too few X's?
+    if (*string != 'X' || template_length < 5)
+    {
+        _RESET_STRING(template_string, buffer_size_in_chars);
+        _VALIDATE_RETURN_ERRCODE(("Incorrect Input for mktemp", 0), EINVAL);
+    }
+
+    // Finally, add the letter:
+    Character letter = 'a';
+
+    *string = letter++;
+
+    errno_t const saved_errno = errno;
+    errno = 0;
+
+    // Test each letter, from a-z, until we find a name that is not yet used:
+    while (traits::taccess_s(template_string, 0) == 0)
+    {
+        if (letter == 'z' + 1)
+        {
+            _RESET_STRING(template_string, buffer_size_in_chars);
+            errno = EEXIST;
+            return errno;
+        }
+
+        *string = letter++;
+        errno = 0;
+    }
+
+    // Restore the old value of errno and return success:
+    errno = saved_errno;
+    return 0;
+}
+
+extern "C" errno_t __cdecl _mktemp_s(
+    char*  const template_string,
+    size_t const buffer_size_in_chars
+    )
+{
+    return common_mktemp_s(template_string, buffer_size_in_chars);
+}
+
+extern "C" errno_t __cdecl _wmktemp_s(
+    wchar_t* const template_string,
+    size_t   const buffer_size_in_chars
+    )
+{
+    return common_mktemp_s(template_string, buffer_size_in_chars);
+}
+
+
+
+// Creates a unique file name given a template string of the form "fnamXXXXXX".
+// The "XXXXXX" sequence is replaced by a letter and the five-digit thread
+// identifier.  The template string is modified in-place.
+//
+// On success, returns the pointer to the modified template string.  On failure,
+// nullptr is returned (e.g. if the template string is malformed or there are no
+// more unique names).
+template <typename Character>
+static Character* __cdecl common_mktemp(
+    Character* const template_string
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(template_string != nullptr, EINVAL, nullptr);
+
+    errno_t const result = common_mktemp_s(
+        template_string,
+        static_cast<size_t>(traits::tcslen(template_string) + 1));
+
+    return result == 0 ? template_string : nullptr;
+}
+
+extern "C" char* __cdecl _mktemp(char* const template_string)
+{
+    return common_mktemp(template_string);
+}
+
+extern "C" wchar_t* __cdecl _wmktemp(wchar_t* const template_string)
+{
+    return common_mktemp(template_string);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/open.cpp

@@ -0,0 +1,907 @@
+//
+// open.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _open() and its friends, who are used to open or create files.
+//
+// These functions are used to open a file.
+//
+// oflag:   The primary file open flags are passed via this parameter.  It may
+//          have a combination of the following flags:
+//           * _O_APPEND:     Reposition file ptr to end before every write
+//           * _O_BINARY:     Open in binary mode
+//           * _O_CREAT:      Create a new file* no effect if file already exists
+//           * _O_EXCL:       Return error if file exists, only use with O_CREAT
+//           * _O_RDONLY:     Open for reading only
+//           * _O_RDWR:       Open for reading and writing
+//           * _O_TEXT:       Open in text mode
+//           * _O_TRUNC:      Open and truncate to 0 length (must have write permission)
+//           * _O_WRONLY:     Open for writing only
+//           * _O_NOINHERIT:  Handle will not be inherited by child processes.
+//          Exactly one of _O_RDONLY, _O_WRONLY, and _O_RDWR must be present.
+//
+// shflag:  Specifies the sharing options with which the file is to be opened.
+//          This parameter is only supported by the sharing-enabled open
+//          functions (_tsopen, _tsopen_s, etc.). The following flags are
+//          supported:
+//           * _SH_COMPAT:  Set compatability mode
+//           * _SH_DENYRW:  Deny read and write access to the file
+//           * _SH_DENYWR:  Deny write access to the file
+//           * _SH_DENYRD:  Deny read access to the file
+//           * _SH_DENYNO:  Permit read and write access
+//
+// pmode:   The pmode argument is only required when _O_CREAT is specified.  Its
+//          flags are as follows:
+//           * _S_IWRITE:
+//           * _S_IREAD:
+//          These flags may be combined (_S_IWRITE | _S_IREAD) to enable both
+//          reading and writing.  The current file permission mask is applied to
+//          pmode before setting the permission (see umask).
+//
+// Functions that return an errno_t return 0 on success and an error code on
+// failure.  Functions that return an int return the file handle on success, and
+// return -1 and set errno on failure.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+
+
+namespace
+{
+    DWORD const GENERIC_READ_WRITE = (GENERIC_READ | GENERIC_WRITE);
+
+    struct file_options
+    {
+        // These are the flags that are used for the osflag of the CRT file
+        // object that is created.
+        char  crt_flags;
+
+        // These are the flags that are eventually passed to CreateFile to tell
+        // the Operating System how to create the file:
+        DWORD access;
+        DWORD create;
+        DWORD share;
+        DWORD attributes;
+        DWORD flags;
+    };
+}
+
+
+
+#define UTF16LE_BOM     0xFEFF      // UTF16 Little Endian Byte Order Mark
+#define UTF16BE_BOM     0xFFFE      // UTF16 Big Endian Byte Order Mark
+#define BOM_MASK        0xFFFF      // Mask for testing Byte Order Mark
+#define UTF8_BOM        0xBFBBEF    // UTF8 Byte Order Mark
+#define UTF16_BOMLEN    2           // No of Bytes in a UTF16 BOM
+#define UTF8_BOMLEN     3           // No of Bytes in a UTF8 BOM
+
+template <typename Character>
+static int __cdecl common_open(
+    _In_z_  Character const* const  path,
+            int              const  oflag,
+            int              const  pmode
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(path != nullptr, EINVAL, -1);
+
+    int fh = -1;
+    int unlock_flag = 0;
+    errno_t error_code = 0;
+    __try
+    {
+        error_code = traits::tsopen_nolock(&unlock_flag, &fh, path, oflag, _SH_DENYNO, pmode, 0);
+    }
+    __finally
+    {
+        if (unlock_flag)
+        {
+            if (error_code)
+            {
+                _osfile(fh) &= ~FOPEN;
+            }
+
+            __acrt_lowio_unlock_fh(fh);
+        }
+    }
+
+    if (error_code != 0)
+    {
+        errno = error_code;
+        return -1;
+    }
+
+    return fh;
+}
+
+extern "C" int _open(char const* const path, int const oflag, ...)
+{
+    va_list arglist;
+    va_start(arglist, oflag);
+    int const pmode = va_arg(arglist, int);
+    va_end(arglist);
+
+    return common_open(path, oflag, pmode);
+}
+
+extern "C" int _wopen(wchar_t const* const path, int const oflag, ...)
+{
+    va_list arglist;
+    va_start(arglist, oflag);
+    int const pmode = va_arg(arglist, int);
+    va_end(arglist);
+
+    return common_open(path, oflag, pmode);
+}
+
+
+
+template <typename Character>
+static errno_t __cdecl common_sopen_dispatch(
+    _In_z_  Character const* const path,
+            int              const oflag,
+            int              const shflag,
+            int              const pmode,
+            int*             const pfh,
+            int              const secure
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN_ERRCODE(pfh != nullptr, EINVAL);
+    *pfh = -1;
+
+    _VALIDATE_RETURN_ERRCODE(path != nullptr, EINVAL);
+
+    if(secure)
+    {
+        _VALIDATE_RETURN_ERRCODE((pmode & (~(_S_IREAD | _S_IWRITE))) == 0, EINVAL);
+    }
+
+
+    int unlock_flag = 0;
+    errno_t error_code = 0;
+    __try
+    {
+        error_code = traits::tsopen_nolock(&unlock_flag, pfh, path, oflag, shflag, pmode, secure);
+    }
+    __finally
+    {
+        if (unlock_flag)
+        {
+            if (error_code)
+            {
+                _osfile(*pfh) &= ~FOPEN;
+            }
+            __acrt_lowio_unlock_fh(*pfh);
+        }
+    }
+
+    if (error_code != 0)
+    {
+        *pfh = -1;
+    }
+
+    return error_code;
+}
+
+extern "C" errno_t __cdecl _sopen_dispatch(
+    char const* const path,
+    int         const oflag,
+    int         const shflag,
+    int         const pmode,
+    int*        const pfh,
+    int         const secure
+    )
+{
+    return common_sopen_dispatch(path, oflag, shflag, pmode, pfh, secure);
+}
+
+extern "C" errno_t __cdecl _wsopen_dispatch(
+    wchar_t const* const path,
+    int            const oflag,
+    int            const shflag,
+    int            const pmode,
+    int*           const pfh,
+    int            const secure
+    )
+{
+    return common_sopen_dispatch(path, oflag, shflag, pmode, pfh, secure);
+}
+
+
+
+static HANDLE __cdecl create_file(
+    PCWSTR               const path,
+    SECURITY_ATTRIBUTES* const security_attributes,
+    file_options         const options
+    ) throw()
+{
+    return CreateFileW(
+        path,
+        options.access,
+        options.share,
+        security_attributes,
+        options.create,
+        options.flags | options.attributes,
+        nullptr);
+}
+
+
+
+static DWORD decode_access_flags(int const oflag) throw()
+{
+    switch (oflag & (_O_RDONLY | _O_WRONLY | _O_RDWR))
+    {
+    case _O_RDONLY:
+            return GENERIC_READ;
+
+    case _O_WRONLY:
+        // If the file is being opened in append mode, we give read access as
+        // well because in append (a, not a+) mode, we need to read the BOM to
+        // determine the encoding (ANSI, UTF-8, or UTF-16).
+        if ((oflag & _O_APPEND) && (oflag & (_O_WTEXT | _O_U16TEXT | _O_U8TEXT)) != 0)
+            return GENERIC_READ | GENERIC_WRITE;
+
+        return GENERIC_WRITE;
+
+    case _O_RDWR:
+        return GENERIC_READ | GENERIC_WRITE;
+    }
+
+    // This is unreachable, but the compiler can't tell.
+    _VALIDATE_RETURN(("Invalid open flag", 0), EINVAL, static_cast<DWORD>(-1));
+    return 0;
+}
+
+static DWORD decode_open_create_flags(int const oflag) throw()
+{
+    switch (oflag & (_O_CREAT | _O_EXCL | _O_TRUNC))
+    {
+    case 0:
+    case _O_EXCL: // ignore EXCL w/o CREAT
+        return OPEN_EXISTING;
+
+    case _O_CREAT:
+        return OPEN_ALWAYS;
+
+    case _O_CREAT | _O_EXCL:
+    case _O_CREAT | _O_TRUNC | _O_EXCL:
+        return CREATE_NEW;
+
+    case _O_TRUNC:
+    case _O_TRUNC | _O_EXCL: // ignore EXCL w/o CREAT
+        return TRUNCATE_EXISTING;
+
+    case _O_CREAT | _O_TRUNC:
+        return CREATE_ALWAYS;
+    }
+
+    // This is unreachable, but the compiler can't tell.
+    _VALIDATE_RETURN(("Invalid open flag", 0), EINVAL, static_cast<DWORD>(-1));
+    return 0;
+}
+
+static DWORD decode_sharing_flags(int const shflag, int const access) throw()
+{
+    switch (shflag)
+    {
+    case _SH_DENYRW:
+        return 0;
+
+    case _SH_DENYWR:
+        return FILE_SHARE_READ;
+
+    case _SH_DENYRD:
+        return FILE_SHARE_WRITE;
+
+    case _SH_DENYNO:
+        return FILE_SHARE_READ | FILE_SHARE_WRITE;
+
+    case _SH_SECURE:
+        if (access == GENERIC_READ)
+            return FILE_SHARE_READ;
+        else
+            return 0;
+    }
+
+    _VALIDATE_RETURN(("Invalid sharing flag", 0), EINVAL, static_cast<DWORD>(-1));
+    return 0;
+}
+
+static bool is_text_mode(int const oflag) throw()
+{
+    if (oflag & _O_BINARY)
+        return false;
+
+    if (oflag & (_O_TEXT | _O_WTEXT | _O_U16TEXT | _O_U8TEXT))
+        return true;
+
+    // Finally, check the global default mode:
+    int fmode;
+    _ERRCHECK(_get_fmode(&fmode));
+    if (fmode != _O_BINARY)
+        return true;
+
+    return false;
+}
+
+static file_options decode_options(int const oflag, int const shflag, int const pmode) throw()
+{
+    file_options result;
+    result.crt_flags  = 0;
+    result.access     = decode_access_flags(oflag);
+    result.create     = decode_open_create_flags(oflag);
+    result.share      = decode_sharing_flags(shflag, result.access);
+    result.attributes = FILE_ATTRIBUTE_NORMAL;
+    result.flags      = 0;
+
+    if (oflag & _O_NOINHERIT)
+    {
+        result.crt_flags |= FNOINHERIT;
+    }
+
+    if (is_text_mode(oflag))
+    {
+        result.crt_flags |= FTEXT;
+    }
+
+    if (oflag & _O_CREAT)
+    {
+        if (((pmode & ~_umaskval) & _S_IWRITE) == 0)
+            result.attributes = FILE_ATTRIBUTE_READONLY;
+    }
+
+    if (oflag & _O_TEMPORARY)
+    {
+        result.flags  |= FILE_FLAG_DELETE_ON_CLOSE;
+        result.access |= DELETE;
+        result.share  |= FILE_SHARE_DELETE;
+    }
+
+    if (oflag & _O_SHORT_LIVED)
+    {
+        result.attributes |= FILE_ATTRIBUTE_TEMPORARY;
+    }
+
+    if (oflag & _O_OBTAIN_DIR)
+    {
+        result.flags |= FILE_FLAG_BACKUP_SEMANTICS;
+    }
+
+    if (oflag & _O_SEQUENTIAL)
+    {
+        result.flags |= FILE_FLAG_SEQUENTIAL_SCAN;
+    }
+    else if (oflag & _O_RANDOM)
+    {
+        result.flags |= FILE_FLAG_RANDOM_ACCESS;
+    }
+
+    return result;
+}
+
+
+
+// If we open a text mode file for writing, and the file ends in Ctrl+Z, we need
+// to remove the Ctrl+Z character so that appending will work.  We do this by
+// seeking to the end of the file, testing if the last character is a Ctrl+Z,
+// truncating the file if it is, then rewinding back to the beginning.
+static errno_t truncate_ctrl_z_if_present(int const fh) throw()
+{
+    // No truncation is possible for devices and pipes:
+    if (_osfile(fh) & (FDEV | FPIPE))
+        return 0;
+
+    // No truncation is necessary for binary files:
+    if ((_osfile(fh) & FTEXT) == 0)
+        return 0;
+
+    // Find the end of the file:
+    __int64 const last_char_position = _lseeki64_nolock(fh, -1, SEEK_END);
+
+    // If the seek failed, either the file is empty or an error occurred.
+    // (It's not an error if the file is empty.)
+    if (last_char_position == -1)
+    {
+        if (_doserrno == ERROR_NEGATIVE_SEEK)
+            return 0;
+
+        return errno;
+    }
+
+    // Read the last character.  If the read succeeds and the character
+    // is a Ctrl+Z, remove the character from the file by shortening:
+    wchar_t c = 0;
+    if (_read_nolock(fh, &c, 1) == 0 && c == 26)
+    {
+        if (_chsize_nolock(fh, last_char_position) == -1)
+            return errno;
+    }
+
+    // Now, rewind the file pointer back to the beginning:
+    if (_lseeki64_nolock(fh, 0, SEEK_SET) == -1)
+        return errno;
+
+    return 0;
+}
+
+
+
+// Computes the text mode to be used for a file, using a combination of the
+// options passed into the open function and the BOM read from the file.
+static errno_t configure_text_mode(
+    int              const fh,
+    file_options     const options,
+    int                    oflag,
+    __crt_lowio_text_mode& text_mode
+    ) throw()
+{
+    // The text mode is ANSI by default:
+    text_mode = __crt_lowio_text_mode::ansi;
+
+    // If the file is open in binary mode, it gets the default text mode:
+    if ((_osfile(fh) & FTEXT) == 0)
+        return 0;
+
+    // Set the default text mode per the oflag.  The BOM may change the default,
+    // if one is present.  If oflag does not specify a text mode, use the _fmode
+    // default:
+    DWORD const text_mode_mask = (_O_TEXT | _O_WTEXT | _O_U16TEXT | _O_U8TEXT);
+    if ((oflag & text_mode_mask) == 0)
+    {
+        int fmode = 0;
+        _ERRCHECK(_get_fmode(&fmode));
+
+        if ((fmode & text_mode_mask) == 0)
+            oflag |= _O_TEXT; // Default to ANSI.
+        else
+            oflag |= fmode & text_mode_mask;
+    }
+
+    // Now oflags should be set to one of the text modes:
+    _ASSERTE((oflag & text_mode_mask) != 0);
+
+    switch (oflag & text_mode_mask)
+    {
+    case _O_TEXT:
+        text_mode = __crt_lowio_text_mode::ansi;
+        break;
+
+    case _O_WTEXT:
+    case _O_WTEXT | _O_TEXT:
+        if ((oflag & (_O_WRONLY | _O_CREAT | _O_TRUNC)) == (_O_WRONLY | _O_CREAT | _O_TRUNC))
+            text_mode = __crt_lowio_text_mode::utf16le;
+        break;
+
+    case _O_U16TEXT:
+    case _O_U16TEXT | _O_TEXT:
+        text_mode = __crt_lowio_text_mode::utf16le;
+        break;
+
+    case _O_U8TEXT:
+    case _O_U8TEXT | _O_TEXT:
+        text_mode = __crt_lowio_text_mode::utf8;
+        break;
+    }
+
+
+    // If the file hasn't been opened with the UNICODE flags then we have
+    // nothing to do:  the text mode is the default mode that we just set:
+    if ((oflag & (_O_WTEXT | _O_U16TEXT | _O_U8TEXT)) == 0)
+        return 0;
+
+    // If this file refers to a device, we cannot check the BOM, so we have
+    // nothing to do:  the text mode is the default mode that we just set:
+    if ((options.crt_flags & FDEV) != 0)
+        return 0;
+
+
+    // Determine whether we need to check or write the BOM, by testing the
+    // access with which the file was opened and whether the file already
+    // existed or was just created:
+    int check_bom = 0;
+    int write_bom = 0;
+    switch (options.access & GENERIC_READ_WRITE)
+    {
+    case GENERIC_READ:
+        check_bom = 1;
+        break;
+
+    case GENERIC_WRITE:
+    case GENERIC_READ_WRITE:
+        switch (options.create)
+        {
+        // If this file was opened, we will read the BOM if the file was opened
+        // with read/write access.  We will write the BOM if and only if the
+        // file is empty:
+        case OPEN_EXISTING:
+        case OPEN_ALWAYS:
+        {
+            if (_lseeki64_nolock(fh, 0, SEEK_END) != 0)
+            {
+                if (_lseeki64_nolock(fh, 0, SEEK_SET) == -1)
+                    return errno;
+
+                // If we have read access, then we need to check the BOM.  Note
+                // that we've taken a shortcut here:  if the file is empty, then
+                // we do not set this flag because the file doesn't have a BOM
+                // to be read.
+                check_bom = (options.access & GENERIC_READ) != 0;
+            }
+            else
+            {
+                write_bom = 1;
+                break;
+            }
+            break;
+        }
+
+        // If this is a new or truncated file, then we always write the BOM:
+        case CREATE_NEW:
+        case CREATE_ALWAYS:
+        case TRUNCATE_EXISTING:
+        {
+            write_bom = 1;
+            break;
+        }
+        }
+        break;
+    }
+
+    if (check_bom)
+    {
+        int bom = 0;
+        int const count = _read_nolock(fh, &bom, UTF8_BOMLEN);
+
+        // Intrernal validation:  This branch should never be taken if write_bom
+        // is true and count > 0:
+        if (count > 0 && write_bom == 1)
+        {
+            _ASSERTE(0 && "Internal Error");
+            write_bom = 0;
+        }
+
+        switch (count)
+        {
+        case -1:
+            return errno;
+
+        case UTF8_BOMLEN:
+            if (bom == UTF8_BOM)
+            {
+                text_mode = __crt_lowio_text_mode::utf8;
+                break;
+            }
+
+        case UTF16_BOMLEN:
+            if((bom & BOM_MASK) == UTF16BE_BOM)
+            {
+                _ASSERTE(0 && "Only UTF-16 little endian & UTF-8 is supported for reads");
+                errno = EINVAL;
+                return errno;
+            }
+
+            if((bom & BOM_MASK) == UTF16LE_BOM)
+            {
+                // We have read three bytes, so we should seek back one byte:
+                if(_lseeki64_nolock(fh, UTF16_BOMLEN, SEEK_SET) == -1)
+                    return errno;
+
+                text_mode = __crt_lowio_text_mode::utf16le;
+                break;
+            }
+
+            // Fall through to default case to lseek to beginning of file
+
+        default:
+            // The file has no BOM, so we seek back to the beginning:
+            if (_lseeki64_nolock(fh, 0, SEEK_SET) == -1)
+                return errno;
+
+            break;
+        }
+    }
+
+    if (write_bom)
+    {
+        // If we are creating a new file, we write a UTF-16LE or UTF8 BOM:
+        int bom_length = 0;
+        int bom = 0;
+        switch (text_mode)
+        {
+        case __crt_lowio_text_mode::utf16le:
+        {
+            bom        = UTF16LE_BOM;
+            bom_length = UTF16_BOMLEN;
+            break;
+        }
+        case __crt_lowio_text_mode::utf8:
+        {
+            bom        = UTF8_BOM;
+            bom_length = UTF8_BOMLEN;
+            break;
+        }
+        }
+
+        for (int total_written = 0; bom_length > total_written; )
+        {
+            char const* const bom_begin = reinterpret_cast<char const*>(&bom);
+
+            // Note that the call to write may write less than bom_length
+            // characters but not really fail.  We retry until the write fails
+            // or we have written all of the characters:
+            int const written = _write(fh, bom_begin + total_written, bom_length - total_written);
+            if (written == -1)
+                return errno;
+
+            total_written += written;
+        }
+    }
+
+    return 0; // Success!
+}
+
+
+
+extern "C" errno_t __cdecl _wsopen_nolock(
+    int*           const punlock_flag,
+    int*           const pfh,
+    wchar_t const* const path,
+    int            const oflag,
+    int            const shflag,
+    int            const pmode,
+    int            const secure
+    )
+{
+    UNREFERENCED_PARAMETER(secure);
+
+    // First, do the initial parse of the options.  The only thing that can fail
+    // here is the parsing of the share options, in which case -1 is returned
+    // and errno is set.
+    file_options options = decode_options(oflag, shflag, pmode);
+    if (options.share == static_cast<DWORD>(-1))
+    {
+        _doserrno = 0;
+        *pfh = -1;
+        return errno;
+    }
+
+    // Allocate the CRT file handle.  Note that if a handle is allocated, it is
+    // locked when it is returned by the allocation function.  It is our caller's
+    // responsibility to unlock the file handle (we do not unlock it before
+    // returning).
+    *pfh = _alloc_osfhnd();
+    if (*pfh == -1)
+    {
+        _doserrno = 0;
+        *pfh = -1;
+        errno = EMFILE;
+        return errno;
+    }
+
+    // Beyond this point, do not change *pfh, even if an error occurs.  Our
+    // caller requires the handle in order to release its lock.
+    *punlock_flag = 1;
+
+
+
+    SECURITY_ATTRIBUTES security_attributes;
+    security_attributes.nLength = sizeof(security_attributes);
+    security_attributes.lpSecurityDescriptor = nullptr;
+    security_attributes.bInheritHandle = (oflag & _O_NOINHERIT) == 0;
+
+
+    // Try to open or create the file:
+    HANDLE os_handle = create_file(path, &security_attributes, options);
+    if (os_handle == INVALID_HANDLE_VALUE)
+    {
+        if ((options.access & GENERIC_READ_WRITE) == GENERIC_READ_WRITE && (oflag & _O_WRONLY))
+        {
+            // The call may have failed because we may be trying to open
+            // something for reading that does not allow reading (e.g. a pipe or
+            // a device).  So, we try again with just GENERIC_WRITE.  If this
+            // succeeds, we will have to assume the default encoding because we
+            // will have no way to read the BOM.
+            options.access &= ~GENERIC_READ;
+
+            os_handle = create_file(path, &security_attributes, options);
+        }
+    }
+
+    if (os_handle == INVALID_HANDLE_VALUE)
+    {
+        // We failed to open the file.  We need to free the CRT file handle, but
+        // we do not release the lock--our caller releases the lock.
+        _osfile(*pfh) &= ~FOPEN;
+        __acrt_errno_map_os_error(GetLastError());
+        return errno;
+    }
+
+    // Find out what type of file this is (e.g., file, device, pipe, etc.)
+    DWORD const file_type = GetFileType(os_handle);
+
+    if (file_type == FILE_TYPE_UNKNOWN)
+    {
+        DWORD const last_error = GetLastError();
+        __acrt_errno_map_os_error(last_error);
+
+        _osfile(*pfh) &= ~FOPEN;
+        CloseHandle(os_handle);
+
+        // If GetFileType returns FILE_TYPE_UNKNOWN but doesn't fail, the file
+        // type really is unknown.  This function is not designed to handle
+        // unknown types of files, so we must return an error.
+        if (last_error == ERROR_SUCCESS)
+            errno = EACCES;
+
+        return errno;
+    }
+
+    if (file_type == FILE_TYPE_CHAR)
+    {
+        options.crt_flags |= FDEV;
+    }
+    else if (file_type == FILE_TYPE_PIPE)
+    {
+        options.crt_flags |= FPIPE;
+    }
+
+    // The file is open and valid.  Set the OS handle:
+    __acrt_lowio_set_os_handle(*pfh, reinterpret_cast<intptr_t>(os_handle));
+
+
+    // Mark the handle as open, and store the flags we gathered so far:
+    options.crt_flags |= FOPEN;
+    _osfile(*pfh) = options.crt_flags;
+
+
+    // The text mode is set to ANSI by default.  If we find a BOM, then we will
+    // reset this to the appropriate type (this check happens below).
+    _textmode(*pfh) = __crt_lowio_text_mode::ansi;
+
+
+    // If the text mode file is opened for writing and allows reading, remove
+    // any trailing Ctrl+Z character, if present, to ensure appending works:
+    if (oflag & _O_RDWR)
+    {
+        errno_t const result = truncate_ctrl_z_if_present(*pfh);
+        if (result != 0)
+        {
+            _close_nolock(*pfh);
+            return result;
+        }
+    }
+
+    // Configure the text mode:
+    __crt_lowio_text_mode text_mode = __crt_lowio_text_mode::ansi;
+    errno_t const text_mode_result = configure_text_mode(*pfh, options, oflag, text_mode);
+    if (text_mode_result != 0)
+    {
+        _close_nolock(*pfh);
+        return text_mode_result;
+    }
+
+    _textmode(*pfh)   = text_mode;
+    _tm_unicode(*pfh) = (oflag & _O_WTEXT) != 0;
+
+
+    // Set FAPPEND flag if appropriate. Don't do this for devices or pipes:
+    if ((options.crt_flags & (FDEV | FPIPE)) == 0 && (oflag & _O_APPEND))
+        _osfile(*pfh) |= FAPPEND;
+
+
+    // Finally, if we were asked only to open the file with write access but we
+    // opened it with read and write access in order to read the BOM, close the
+    // file and re-open it with only write access:
+    if ((options.access & GENERIC_READ_WRITE) == GENERIC_READ_WRITE && (oflag & _O_WRONLY))
+    {
+        CloseHandle(os_handle);
+        options.access &= ~GENERIC_READ;
+        os_handle = create_file(path, &security_attributes, options);
+
+        if (os_handle == INVALID_HANDLE_VALUE)
+        {
+            // Note that we can't use the normal close function here because the
+            // file isn't really open anymore.  We need only release the file
+            // handle by unsetting the FOPEN flag:
+            __acrt_errno_map_os_error(GetLastError());
+            _osfile(*pfh) &= ~FOPEN;
+            _free_osfhnd(*pfh);
+            return errno;
+        }
+        else
+        {
+            // We were able to open the file successfully, set the file
+            // handle in the _ioinfo structure, then we are done.  All
+            // the options.crt_flags should have been set properly already.
+            _osfhnd(*pfh) = reinterpret_cast<intptr_t>(os_handle);
+        }
+    }
+
+    return 0; // Success!
+}
+
+
+
+extern "C" errno_t __cdecl _sopen_nolock(
+    int*        const punlock_flag,
+    int*        const pfh,
+    char const* const path,
+    int         const oflag,
+    int         const shflag,
+    int         const pmode,
+    int         const secure
+    )
+{
+    // At this point we know path is not null already
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return _wsopen_nolock(punlock_flag, pfh, wide_path.data(), oflag, shflag, pmode, secure);
+}
+
+
+
+extern "C" int __cdecl _sopen(char const* const path, int const oflag, int const shflag, ...)
+{
+    va_list ap;
+    va_start(ap, shflag);
+    int const pmode = va_arg(ap, int);
+    va_end(ap);
+
+    // The last argument is 0 so thta the pmode is not validated in open_s:
+    int fh = -1;
+    errno_t const result = _sopen_dispatch(path, oflag, shflag, pmode, &fh, FALSE);
+    return result ? -1 : fh;
+}
+
+extern "C" int __cdecl _wsopen(wchar_t const* const path, int const oflag, int const shflag, ...)
+{
+    va_list ap;
+    va_start(ap, shflag);
+    int const pmode = va_arg(ap, int);
+    va_end(ap);
+
+    // The last argument is 0 so thta the pmode is not validated in open_s:
+    int fh = -1;
+    errno_t const result = _wsopen_dispatch(path, oflag, shflag, pmode, &fh, FALSE);
+    return result ? -1 : fh;
+}
+
+
+
+extern "C" errno_t __cdecl _sopen_s(
+    int*        const pfh,
+    char const* const path,
+    int         const oflag,
+    int         const shflag,
+    int         const pmode
+    )
+{
+    // The last argument is 1 so that pmode is validated in open_s:
+    return _sopen_dispatch(path, oflag, shflag, pmode, pfh, TRUE);
+}
+
+extern "C" errno_t __cdecl _wsopen_s(
+    int*           const pfh,
+    wchar_t const* const path,
+    int            const oflag,
+    int            const shflag,
+    int            const pmode
+    )
+{
+    // The last argument is 1 so that pmode is validated in open_s:
+    return _wsopen_dispatch(path, oflag, shflag, pmode, pfh, TRUE);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/osfinfo.cpp

@@ -0,0 +1,348 @@
+//
+// osfinfo.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the functions used to control allocation, locking, and freeing of CRT
+// file handles.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+extern "C" __crt_lowio_handle_data* __cdecl __acrt_lowio_create_handle_array()
+{
+    __crt_unique_heap_ptr<__crt_lowio_handle_data> array(_calloc_crt_t(
+        __crt_lowio_handle_data,
+        IOINFO_ARRAY_ELTS));
+
+    if (!array)
+        return nullptr;
+
+    __crt_lowio_handle_data* const first = array.get();
+    __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
+    for (auto it = first; it != last; ++it)
+    {
+        __acrt_InitializeCriticalSectionEx(&it->lock, _CORECRT_SPINCOUNT, 0);
+        it->osfhnd             = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+        it->startpos           = 0;
+        it->osfile             = 0;
+        it->textmode           = __crt_lowio_text_mode::ansi;
+        it->_pipe_lookahead[0] = LF;
+        it->_pipe_lookahead[1] = LF;
+        it->_pipe_lookahead[2] = LF;
+        it->unicode            = false;
+        it->utf8translations   = false;
+        it->dbcsBufferUsed     = false;
+        for (int i = 0; i < sizeof(it->mbBuffer); ++i)
+        {
+            it->mbBuffer[i] = '\0';
+        }
+    }
+
+    return array.detach();
+}
+
+extern "C" void __cdecl __acrt_lowio_destroy_handle_array(__crt_lowio_handle_data* const array)
+{
+    if (!array)
+        return;
+
+    __crt_lowio_handle_data* const first = array;
+    __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
+    for (auto it = first; it != last; ++it)
+    {
+        DeleteCriticalSection(&it->lock);
+    }
+
+    _free_crt(array);
+}
+
+// Ensures that a lowio handle data object has been created for file handle 'fh'.
+// The 'fh' must be less than the hard maximum, _NHANDLE_.  If 'fh' is already
+// backed by a handle data object, this function has no effect.  Otherwise, this
+// function extends the global arrays of handle data objects until 'fh' is backed
+// by a handle data object. 
+extern "C" errno_t __cdecl __acrt_lowio_ensure_fh_exists(int const fh)
+{
+    _VALIDATE_RETURN_ERRCODE(static_cast<unsigned>(fh) < _NHANDLE_, EBADF);
+
+    errno_t status = 0;
+
+    __acrt_lock(__acrt_lowio_index_lock);
+    __try
+    {
+        for (size_t i = 0; fh >= _nhandle; ++i)
+        {
+            if (__pioinfo[i])
+            {
+                continue;
+            }
+
+            __pioinfo[i] = __acrt_lowio_create_handle_array();
+            if (!__pioinfo[i])
+            {
+                status = ENOMEM;
+                __leave;
+            }
+
+            _nhandle += IOINFO_ARRAY_ELTS;
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_lowio_index_lock);
+    }
+
+    return status;
+}
+
+
+
+// Allocates a CRT file handle.  This function finds the first free entry in
+// the arrays of file objects and returns the index of that entry (that index
+// is the CRT file handle) to the caller.  The FOPEN flag is set in the new
+// entry, to pevent multithreaded race conditions and deadlocks.
+//
+// Returns the CRT file handle on success; returns -1 on failure (e.g. if no
+// more file handles are available or if memory allocation is required but
+// fails).
+//
+// MULTITHREADING NOTE:  If this function is successful and returns a CRT file
+// handle, the handle is locked when it is returned and the FOPEN flag has been
+// set.  The caller must be sure to release the lock, and if the caller abandons
+// the file handle, it must clear the FOPEN flag to free the handle.
+extern "C" int __cdecl _alloc_osfhnd()
+{
+    __acrt_lock(__acrt_lowio_index_lock);
+    int result = -1;
+    __try
+    {
+        // Search the arrays of file objects, in order, looking for the first
+        // free entry.  The compound index of this free entry is the return
+        // value.
+        //
+        // The compound index of the file object entry *(__pioinfo[i] + j) is
+        // k = i * IOINFO_ARRAY_ELTS + j.
+        for (int i = 0; i < IOINFO_ARRAYS; ++i)
+        {
+            // If this __crt_lowio_handle_data array does not yet exist, create a new one:
+            if (!__pioinfo[i])
+            {
+                __pioinfo[i] = __acrt_lowio_create_handle_array();
+                if (!__pioinfo[i])
+                    __leave;
+
+                _nhandle += IOINFO_ARRAY_ELTS;
+
+                // The first element of the newly allocated array of handle data
+                // objects is our first free entry.  Note that since we hold the
+                // index lock, no one else can allocate this handle.
+                int const fh = i * IOINFO_ARRAY_ELTS;
+
+                __acrt_lowio_lock_fh(fh);
+                _osfile(fh) = FOPEN;
+                result = fh;
+                __leave;
+            }
+
+            // Otherwise, this file object array already exists.  Search it looking
+            // for the first free entry:
+            __crt_lowio_handle_data* const first = __pioinfo[i];
+            __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
+            for (__crt_lowio_handle_data* pio = first; pio != last; ++pio)
+            {
+                if (pio->osfile & FOPEN)
+                    continue;
+
+                // Another thread may have grabbed this file handle out from
+                // under us while we waited for the lock.  If so, continue on
+                // searching through the array.
+                //
+                // CRT_REFACTOR TODO:  Resolve lowio synchronization issues.
+                EnterCriticalSection(&pio->lock);
+                if ((pio->osfile & FOPEN) != 0)
+                {
+                    LeaveCriticalSection(&pio->lock);
+                    continue;
+                }
+
+                // Otherwise, this entry is ours:  we hold the lock, so we can
+                // initialize it and return its handle:
+                int const fh = i * IOINFO_ARRAY_ELTS + static_cast<int>(pio - first);
+                _osfile(fh) = FOPEN;
+                _osfhnd(fh) = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+                result = fh;
+                __leave;
+            }
+        }
+
+        // All entries are in use if we fall out of the loop.  return -1 in this case (which result is already set to)
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_lowio_index_lock);
+    }
+    return result;
+}
+
+
+
+// Sets the Win32 HANDLE associated with the specified CRT file.  Returns 0
+// on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl __acrt_lowio_set_os_handle(int const fh, intptr_t const value)
+{
+    if (fh >= 0 &&
+        static_cast<unsigned>(fh) < static_cast<unsigned>(_nhandle) &&
+        _osfhnd(fh) == reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE))
+    {
+        if (_query_app_type() == _crt_console_app)
+        {
+            HANDLE const handle_value = reinterpret_cast<HANDLE>(value);
+            switch (fh)
+            {
+            case 0: SetStdHandle(STD_INPUT_HANDLE,  handle_value); break;
+            case 1: SetStdHandle(STD_OUTPUT_HANDLE, handle_value); break;
+            case 2: SetStdHandle(STD_ERROR_HANDLE,  handle_value); break;
+            }
+        }
+
+        _osfhnd(fh) = value;
+        return 0 ;
+    }
+    else
+    {
+        errno = EBADF; // Bad handle
+        _doserrno = 0; // This is not an OS error
+        return -1;
+    }
+}
+
+
+
+// Marks the specified CRT file handle as free and available for allocation.
+// Returns 0 on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl _free_osfhnd(int const fh)
+{
+    if (fh >= 0 &&
+        static_cast<unsigned>(fh) < static_cast<unsigned>(_nhandle) &&
+        (_osfile(fh) & FOPEN) &&
+        _osfhnd(fh) != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE))
+    {
+        if (_query_app_type() == _crt_console_app)
+        {
+            switch (fh)
+            {
+            case 0: SetStdHandle(STD_INPUT_HANDLE,  nullptr); break;
+            case 1: SetStdHandle(STD_OUTPUT_HANDLE, nullptr); break;
+            case 2: SetStdHandle(STD_ERROR_HANDLE,  nullptr); break;
+            }
+        }
+
+        _osfhnd(fh) = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+        return 0;
+    }
+    else
+    {
+        errno = EBADF; // Bad handle
+        _doserrno = 0; // This is not an OS error
+        return -1;
+    }
+}
+
+
+
+// Gets the Win32 HANDLE with which the given CRT file handle is associated.
+// On success, returns the Win32 HANDLE; on failure, returns -1 and sets errno.
+extern "C" intptr_t __cdecl _get_osfhandle(int const fh)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1 );
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+
+    return _osfhnd(fh);
+}
+
+
+
+// Allocates a free CRT file handle and associates it with the provided Win32
+// HANDLE and sets its flags to the given flags.  Returns the CRT file handle
+// on success; returns -1 on failure.
+extern "C" int __cdecl _open_osfhandle(intptr_t const osfhandle, int const source_flags)
+{
+    // Copy relevant source_flags from second parameter
+    unsigned char file_flags = 0;
+
+    if (source_flags & _O_APPEND)
+        file_flags |= FAPPEND;
+
+    if (source_flags & _O_TEXT)
+        file_flags |= FTEXT;
+
+    if (source_flags & _O_NOINHERIT)
+        file_flags |= FNOINHERIT;
+
+    // Find out what type of file (file/device/pipe):
+    DWORD const file_type = GetFileType(reinterpret_cast<HANDLE>(osfhandle));
+    if (file_type == FILE_TYPE_UNKNOWN)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    if (file_type == FILE_TYPE_CHAR)
+        file_flags |= FDEV;
+
+    else if (file_type == FILE_TYPE_PIPE)
+        file_flags |= FPIPE;
+
+    // Attempt to allocate a CRT file handle:
+    int const fh = _alloc_osfhnd();
+    if (fh == -1)
+    {
+        errno = EMFILE; // Too many open files
+        _doserrno = 0L; // This is not an OS error
+        return -1;
+    }
+
+    bool success = false;
+    __try
+    {
+        // The file is open. now set the info in _osfhnd array:
+        __acrt_lowio_set_os_handle(fh, osfhandle);
+
+        file_flags |= FOPEN;
+
+        _osfile(fh) = file_flags;
+        _textmode(fh) = __crt_lowio_text_mode::ansi;
+        _tm_unicode(fh) = false;
+
+        success = true;
+    }
+    __finally
+    {
+        if (!success)
+        {
+            _osfile(fh) &= ~FOPEN;
+        }
+
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return fh;
+}
+
+
+
+// Acquires the lock associated with the given file handle.
+extern "C" void __cdecl __acrt_lowio_lock_fh(int const fh)
+{
+    EnterCriticalSection(&_pioinfo(fh)->lock);
+}
+
+
+
+// Releases the lock associated with the given file handle.
+extern "C" void __cdecl __acrt_lowio_unlock_fh(int const fh)
+{
+    LeaveCriticalSection(&_pioinfo(fh)->lock);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/read.cpp

@@ -0,0 +1,635 @@
+//
+// read.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _read(), which reads bytes from a file.
+//
+#include <corecrt_internal_lowio.h>
+
+// Lookup table for UTF-8 lead bytes
+// Probably preferable to just ask if the bits are set than use an entire
+// table, however the macros using this were #defined in the header so
+// removing this extern table would break apps compiled to an earlier verison.
+//    1 for pattern 110xxxxx - 1 trailbyte
+//    2 for pattern 1110xxxx - 2 trailbytes
+//    3 for pattern 11110xxx - 3 trailbytes
+//    0 for everything else, including invalid patterns.
+// We return 0 for invalid patterns because we rely on MultiByteToWideChar to
+// do the validations.
+extern "C" char _lookuptrailbytes[256] =
+{
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+
+static void store_lookahead(int const fh, char const c) throw()
+{
+    _pipe_lookahead(fh)[0] = c;
+}
+
+static void store_lookahead(int const fh, wchar_t const c) throw()
+{
+    char const* const byte_pointer = reinterpret_cast<char const*>(&c);
+    _pipe_lookahead(fh)[0] = byte_pointer[0];
+    _pipe_lookahead(fh)[1] = byte_pointer[1];
+    _pipe_lookahead(fh)[2] = LF; // Mark as empty
+}
+
+
+
+static int __cdecl translate_utf16_from_console_nolock(
+                            int      const  fh,
+    _Inout_updates_(count)  wchar_t* const  buffer,
+                            size_t   const  count
+    ) throw()
+{
+    // The translation can be performend in-place, because we are converting
+    // CRLF sequences into LF, so the resulting text will never be longer than
+    // any corresponding source text.
+    wchar_t* const buffer_end = buffer + count;
+
+    wchar_t* source_it = buffer;
+    wchar_t* result_it = buffer;
+
+    while (source_it < buffer_end)
+    {
+        // If at any point during translation we encounter a Ctrl+Z, we stop
+        // translating immediately:
+        if (*source_it == CTRLZ)
+        {
+            _osfile(fh) |= FEOFLAG;
+            break;
+        }
+
+        // When a CR character is encountered, we must check to see if the next
+        // character is an LF.  If it is, then we skip the CR and copy only the
+        // LF:
+        if (*source_it == CR && source_it + 1 < buffer_end && *(source_it + 1) == LF)
+        {
+            source_it += 2;
+            *result_it++ = LF;
+            continue;
+        }
+
+        // Otherwise, we just copy the character:
+        *result_it++ = *source_it++;
+    }
+
+    // Return the number of bytes that we translated:
+    return static_cast<int>((result_it - buffer) * sizeof(wchar_t));
+}
+
+
+
+template <typename Character>
+static int __cdecl translate_text_mode_nolock(
+    _In_                                                         int        const fh,
+    _Pre_writable_size_(count) _Post_readable_byte_size_(return) Character* const buffer,
+    _In_                                                         size_t     const count
+    ) throw()
+{
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_osfhnd(fh));
+
+    // If there is an LF at the beginning of the buffer, set the CRLF flag:
+    if (count != 0 && *buffer == LF)
+    {
+        _osfile(fh) |= FCRLF;
+    }
+    else
+    {
+        _osfile(fh) &= ~FCRLF;
+    }
+
+    // The translation can be performend in-place, because we are converting
+    // CRLF sequences into LF, so the resulting text will never be longer than
+    // any corresponding source text.
+    Character* const buffer_end = buffer + count;
+
+    Character* source_it = buffer;
+    Character* result_it = buffer;
+
+    while (source_it < buffer_end)
+    {
+        // If during translation we encounter a Ctrl+Z, we stop translating
+        // immeidately.  For devices, we need to just set the Ctrl+Z flag;
+        // for other files, we just copy the Ctrl+Z as a normal character
+        // before returning:
+        if (*source_it == CTRLZ)
+        {
+            if ((_osfile(fh) & FDEV) == 0)
+            {
+                _osfile(fh) |= FEOFLAG;
+            }
+            else
+            {
+                *result_it++ = *source_it++;
+            }
+
+            break;
+        }
+
+        // If the character is not a CR, then we can simply copy it:
+        if (*source_it != CR)
+        {
+            *result_it++ = *source_it++;
+            continue;
+        }
+
+        // Otherwise, the character is a CR.  We need to look-ahead to see if
+        // the next character is an LF, so that we can perform the CRLF => LF
+        // translation.  First, handle the easy case where the CR does not
+        // appear at the end of the buffer:
+        if (source_it + 1 < buffer_end)
+        {
+            if (*(source_it + 1) == LF)
+            {
+                source_it += 2;
+                *result_it++ = LF; // Convert CRLF => LF
+            }
+            else
+            {
+                *result_it++ = *source_it++;
+            }
+
+            continue;
+        }
+
+        // This is the hard case:  The CR is at the end of the buffer.  We need
+        // to peek ahead to see if the next character is an LF:
+        ++source_it;
+
+        Character peek;
+        DWORD     peek_size;
+        if (!ReadFile(os_handle, &peek, sizeof(peek), &peek_size, nullptr) || peek_size == 0)
+        {
+            // We couldn't peek ahead; just store the CR:
+            *result_it++ = CR;
+            continue;
+        }
+
+        // The peek succeeded.  What we do next depends on whether the file is
+        // seekable or not.  First we handle the case where the file does not
+        // allow seeking:
+        if (_osfile(fh) & (FDEV | FPIPE))
+        {
+            // If the peek character is an LF, then we just need to copy that
+            // character to the output buffer:
+            if (peek == LF)
+            {
+                *result_it++ = LF;
+            }
+            // Otherwise, it was some other character.  We need to write the CR
+            // to the output buffer, then we need to store the peek character
+            // for later retrieval:
+            else
+            {
+                *result_it++ = CR;
+                store_lookahead(fh, peek);
+            }
+        }
+        // If the file does allow seeking, then we handle the peek differently.
+        // For seekable files, we translate the CRLF => LF by eliminating the
+        // CR.  If the peek character is an LF, we simply do not write it to
+        // the output buffer; instead, we will seek backwards to unpeek the
+        // character, then let the LF get retrieved during the next call to
+        // read().
+        else
+        {
+            // However, if the buffer is currenty empty, then this is a one-
+            // character read, so we store the LF in order that we make progress
+            if (peek == LF && result_it == buffer)
+            {
+                *result_it++ = LF;
+            }
+            // Otherwise, we do what is described above:  we seek backwards and
+            // write the CR if and only if the peek character was not an LF:
+            else
+            {
+                _lseeki64_nolock(fh, -1 * static_cast<int>(sizeof(Character)), FILE_CURRENT);
+                if (peek != LF)
+                {
+                    *result_it++ = CR;
+                }
+            }
+        }
+    }
+
+    // Return the number of bytes that we translated:
+    return static_cast<int>((result_it - buffer) * sizeof(Character));
+}
+
+
+
+_Success_(return != -1)
+static int __cdecl translate_ansi_or_utf8_nolock(
+                                                                        int      const fh,
+    _In_reads_(source_count)                                            char*    const source_buffer,
+                                                                        size_t   const source_count,
+    _Pre_writable_size_(result_count) _Post_readable_byte_size_(return) wchar_t* const result_buffer,
+                                                                        size_t   const result_count
+    ) throw()
+{
+    int const text_mode_translation_result_size = translate_text_mode_nolock(fh, source_buffer, source_count);
+
+    // If we read no characters, then we are done:
+    if (text_mode_translation_result_size == 0)
+    {
+        return 0;
+    }
+
+    // If the file is open in ANSI mode, then no further translation is
+    // required; we can simply return the number of bytes that we read.
+    // Even though there is no translation, there may still be
+    // characters in the buffer due to CRLF translation (a CR without
+    // a LF would 'unget' the would-be LF).
+    // text_mode_translation_result_size has already been adjusted for
+    // CRLF translation by translate_text_mode_nolock().
+    if (_textmode(fh) == __crt_lowio_text_mode::ansi)
+    {
+        return text_mode_translation_result_size;
+    }
+
+    // Otherwise, the file is open in UTF-8 mode and we read a nonzero number
+    // of characters.  We need to translate from UTF-8 to UTF-16.  To do this,
+    // we first need to hunt for the end of the translatable buffer.  This may
+    // not be result_it, because we may have read a partial multibyte UTF-8
+    // character.
+    char* result_it = source_buffer + text_mode_translation_result_size - 1;
+
+    // If the last character is an independent character, then we can
+    // translate the entire buffer:
+    if (_utf8_is_independent(*result_it))
+    {
+        ++result_it; // Reset the result_it
+    }
+    // Otherwise, we have to find the end of the last full UTF-8 character
+    // that was read:
+    else
+    {
+        // Walk backwards from the end of the buffer until we find a lead byte:
+        unsigned counter = 1;
+        while (!_utf8_is_leadbyte(*result_it) && counter <= 4 && result_it >= source_buffer)
+        {
+            --result_it;
+            ++counter;
+        }
+
+        // Now that we've found the last lead byte, determine whether the
+        // character is complete or incomplete.  We compute the number of
+        // trailbytes...
+        unsigned const trailbyte_count = _utf8_no_of_trailbytes(static_cast<const unsigned char>(*result_it));
+        if (trailbyte_count == 0)
+        {
+            // Oh, apparently that wasn't a lead byte; the file contains invalid
+            // UTF-8 character sequences:
+            errno = EILSEQ;
+            return -1;
+        }
+
+        // If the lead byte plus the remaining bytes form a full set, then we
+        // can translate the entire buffer:
+        if (trailbyte_count + 1 == counter)
+        {
+            result_it += counter;
+        }
+        // Otherwise, the last character is incomplete, so we will not include
+        // this character in the result.  We unget the last characters, either
+        // by seeking backwards if the file is seekable, or by buffering the
+        // characters.  Note that result_it currently points one-past-the-end
+        // of the translatable buffer, because it points to the lead byte of
+        // the partially read character.
+        else
+        {
+            // If the file does not support seeking, buffer the characters:
+            if (_osfile(fh) & (FDEV | FPIPE))
+            {
+                _pipe_lookahead(fh)[0] = *result_it++;
+
+                if (counter >= 2)
+                {
+                    _pipe_lookahead(fh)[1] = *result_it++;
+                }
+
+                if (counter == 3)
+                {
+                    _pipe_lookahead(fh)[2] = *result_it++;
+                }
+
+                // Now that we've buffered the characters, seek the end iterator
+                // back to the actual end of the translatable sequence:
+                result_it -= counter;
+
+            }
+            // If the file does support seeking, we can just seek backwards so
+            // that the next read will get the characters directly:
+            else
+            {
+                _lseeki64_nolock(fh, -static_cast<int>(counter), FILE_CURRENT);
+            }
+        }
+    }
+
+    // Finally, we can translate the characters into the result buffer:
+    int const characters_translated = static_cast<int>(__acrt_MultiByteToWideChar(
+            CP_UTF8,
+            0,
+            source_buffer,
+            static_cast<DWORD>(result_it - source_buffer),
+            result_buffer,
+            static_cast<DWORD>(result_count)));
+
+    if (characters_translated == 0)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    _utf8translations(fh) = (characters_translated != static_cast<int>(result_it - source_buffer));
+
+    // MultiByteToWideChar returns the number of wide characters that
+    // it produced; we need to return the number of bytes:
+    return characters_translated * sizeof(wchar_t);
+}
+
+
+
+// Reads bytes from a file.  This function attempts to read enough bytes to fill
+// the provided buffer.  If the file is in text mode, CRLF sequences are mapped
+// to LF, thus affecting the number of characters read.  This mapping does not
+// affect the file pointer.
+//
+// Returns the number of bytes read, which may be less than the number of bytes
+// requested if EOF was reached or if the file is in text mode.  Returns -1 and
+// sets errno on failure.
+extern "C" int __cdecl _read(int const fh, void* const buffer, unsigned const buffer_size)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(buffer_size <= INT_MAX, EINVAL, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = _read_nolock(fh, buffer, buffer_size);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _read_nolock(
+    int      const fh,
+    void*    const result_buffer,
+    unsigned const result_buffer_size
+    )
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1 );
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(result_buffer_size <= INT_MAX, EINVAL, -1);
+
+    // If there is no data to be written or if the file is at EOF, no work to do:
+    if (result_buffer_size == 0 || (_osfile(fh) & FEOFLAG))
+        return 0;
+
+    _VALIDATE_CLEAR_OSSERR_RETURN(result_buffer != nullptr, EINVAL, -1);
+
+
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    __crt_lowio_text_mode const text_mode = _textmode(fh);
+
+
+    __crt_unique_heap_ptr<char> owned_internal_buffer;
+
+    char*    internal_buffer;
+    unsigned internal_buffer_remaining;
+    switch (text_mode)
+    {
+    case __crt_lowio_text_mode::utf8:
+        // For UTF-8 files, we need two buffers, because after reading we need
+        // to convert the text into Unicode.  MultiByteToWideChar doesn't do
+        // in-place conversions.
+        //
+        // The multibyte to wide character conversion may double the size of the
+        // text, hence we halve the size here.
+        //
+        // Since we are reading a UTF-8 stream, the number of bytes read may
+        // vary from 'size' characters to 'size/4' characters.  For this reason,
+        // if we need to read 'size' characters, we will allocate an MBCS buffer
+        // of size 'size'.  In case the size is zero, we will use four as a
+        // minimum value.  This will make sure we don't overflow when we read
+        // from a pipe.
+        //
+        // In this case, the number of wide characters that we can read is
+        // size / 2.  This means that we require a buffer of size size / 2.
+
+        // For UTF-8 the count always needs to be an even number:
+        _VALIDATE_CLEAR_OSSERR_RETURN(result_buffer_size % 2 == 0, EINVAL, -1);
+
+        internal_buffer_remaining = (result_buffer_size / 2) < 4
+            ? 4
+            : (result_buffer_size/2);
+
+        owned_internal_buffer = _malloc_crt_t(char, internal_buffer_remaining);
+        internal_buffer = owned_internal_buffer.get();
+        if (!internal_buffer)
+        {
+            errno = ENOMEM;
+            _doserrno = ERROR_NOT_ENOUGH_MEMORY;
+            return -1;
+        }
+
+        _startpos(fh) = _lseeki64_nolock(fh, 0, FILE_CURRENT);
+        break;
+
+    case __crt_lowio_text_mode::utf16le:
+        // For UTF-16 the count always needs to be an even number:
+        _VALIDATE_CLEAR_OSSERR_RETURN((result_buffer_size % 2) == 0, EINVAL, -1);
+
+        // For UTF-16 files, we can directly use the input buffer:
+        internal_buffer_remaining = result_buffer_size;
+        internal_buffer           = static_cast<char*>(result_buffer);
+        break;
+
+    default:
+        // For ANSI files, we can directly use the input buffer:
+        internal_buffer_remaining = result_buffer_size;
+        internal_buffer           = static_cast<char*>(result_buffer);
+        break;
+    }
+
+    wchar_t* wide_internal_buffer = reinterpret_cast<wchar_t*>(internal_buffer);
+
+    int bytes_read = 0;
+
+    // We may have buffered look-ahead characters during the last read.  If
+    // so, read them into the buffer and set the look-ahead buffers back to
+    // empty state (with the value of LF):
+    //
+    // CRT_REFACTOR This look-ahead buffering could use additional work, but
+    // will require nonlocal changes, so that work is not included in this
+    // changeset.
+    if ((_osfile(fh) & (FPIPE | FDEV)) &&
+        _pipe_lookahead(fh)[0] != LF &&
+        internal_buffer_remaining != 0)
+    {
+        *internal_buffer++ = _pipe_lookahead(fh)[0];
+        ++bytes_read;
+        --internal_buffer_remaining;
+        _pipe_lookahead(fh)[0] = LF;
+
+        // For UTF-16, there may be an additional look-ahead character
+        // bufferred.  For UTF-8, there may be two more:
+        if (text_mode != __crt_lowio_text_mode::ansi &&
+            _pipe_lookahead(fh)[1] != LF &&
+            internal_buffer_remaining != 0)
+        {
+            *internal_buffer++ = _pipe_lookahead(fh)[1];
+            ++bytes_read;
+            --internal_buffer_remaining;
+            _pipe_lookahead(fh)[1] = LF;
+
+            if (text_mode == __crt_lowio_text_mode::utf8 &&
+                _pipe_lookahead(fh)[2] != LF &&
+                internal_buffer_remaining != 0)
+            {
+                *internal_buffer++ = _pipe_lookahead(fh)[2];
+                ++bytes_read;
+                --internal_buffer_remaining;
+                _pipe_lookahead(fh)[2] = LF;
+            }
+        }
+    }
+
+    DWORD console_mode;
+    bool const from_console =
+        _isatty(fh) &&
+        (_osfile(fh) & FTEXT) &&
+        GetConsoleMode(os_handle, &console_mode);
+
+    // Read the data directly from the console:
+    if (from_console && text_mode == __crt_lowio_text_mode::utf16le)
+    {
+        DWORD console_characters_read;
+        if (!ReadConsoleW(
+                os_handle,
+                internal_buffer,
+                internal_buffer_remaining / sizeof(wchar_t),
+                &console_characters_read,
+                nullptr))
+        {
+            __acrt_errno_map_os_error(GetLastError());
+            return -1;
+        }
+
+        // In UTF-16 mode, the return value is the actual number of wide
+        // characters read; we need the number of bytes:
+        bytes_read += console_characters_read * sizeof(wchar_t);
+    }
+    // Otherwise, read the data from the file normally:
+    else
+    {
+        DWORD bytes_read_from_file;
+        if (!ReadFile(
+                os_handle,
+                internal_buffer,
+                internal_buffer_remaining,
+                &bytes_read_from_file,
+                nullptr
+            ) || bytes_read_from_file > result_buffer_size)
+        {
+            DWORD const last_error = GetLastError();
+            if (last_error == ERROR_ACCESS_DENIED)
+            {
+                // ERROR_ACCESS_DENIED occurs if the file is open with the wrong
+                // read/write mode.  For this error, we should return EBADF, not
+                // the EACCES that will be set by __acrt_errno_map_os_error:
+                errno = EBADF;
+                _doserrno = last_error;
+                return -1;
+
+            }
+            else if (last_error == ERROR_BROKEN_PIPE)
+            {
+                // Return 0 if ERROR_BROKEN_PIPE occurs.  It means the handle is
+                // a read handle on a pipe for which all write handles have been
+                // closed and all data has been read:
+                return 0;
+            }
+            else
+            {
+                // Otherwise, map the error normally and return:
+                __acrt_errno_map_os_error(last_error);
+                return -1;
+            }
+        }
+
+        bytes_read += bytes_read_from_file;
+    }
+
+
+    // If the file is open in binary mode, no translation is required, so we
+    // can skip all of the rest of this function:
+    if ((_osfile(fh) & FTEXT) == 0)
+        return bytes_read;
+
+
+    // Perform the CRLF => LF translation and convert to the required
+    // encoding (UTF-8 must be converted to UTF-16).  This first case
+    // handles UTF-8 and ANSI:
+    if (text_mode != __crt_lowio_text_mode::utf16le)
+    {
+        return translate_ansi_or_utf8_nolock(
+            fh,
+            internal_buffer,
+            bytes_read,
+            static_cast<wchar_t*>(result_buffer),
+            result_buffer_size / sizeof(wchar_t));
+    }
+
+    // The text mode is __crt_lowio_text_mode::utf16le and we are reading from the
+    // console:
+    else if (from_console)
+    {
+        return translate_utf16_from_console_nolock(
+            fh,
+            wide_internal_buffer,
+            bytes_read / sizeof(wchar_t));
+    }
+    // Otherwise, the text mode is __crt_lowio_text_mode::utf16le and we are NOT
+    // reading from the console:
+    else
+    {
+        return translate_text_mode_nolock(
+            fh,
+            wide_internal_buffer,
+            bytes_read / sizeof(wchar_t));
+    }
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/setmode.cpp

@@ -0,0 +1,121 @@
+//
+// setmode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _setmode(), which sets the translation mode for a file, and
+// _set_fmode() and _get_fmode(), which control the global default translation
+// mode.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdlib.h>
+
+
+
+// Sets the file translation mode.  This changes the file mode to text or binary,
+// depending on the mode argument.  This affects whether reads and writes on the
+// file translate between CRLF and LF.  Returns the old file translation mode on
+// success, or -1 on failure.
+extern "C" int __cdecl _setmode(int const fh, int const mode)
+{
+    _VALIDATE_RETURN(mode == _O_TEXT   ||
+                     mode == _O_BINARY ||
+                     mode == _O_WTEXT  ||
+                     mode == _O_U8TEXT ||
+                     mode == _O_U16TEXT,
+                     EINVAL, -1);
+
+    _CHECK_FH_RETURN(fh, EBADF, -1);
+    _VALIDATE_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _VALIDATE_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = _setmode_nolock(fh, mode);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _setmode_nolock(int const fh, int const mode)
+{
+    int const old_mode = _osfile(fh) & FTEXT;
+    __crt_lowio_text_mode const old_textmode = _textmode(fh);
+
+    switch (mode)
+    {
+    case _O_BINARY:
+        _osfile(fh) &= ~FTEXT;
+        break;
+
+    case _O_TEXT:
+        _osfile(fh) |= FTEXT;
+        _textmode(fh) = __crt_lowio_text_mode::ansi;
+        break;
+
+    case _O_U8TEXT:
+        _osfile(fh) |= FTEXT;
+        _textmode(fh) = __crt_lowio_text_mode::utf8;
+        break;
+
+    case _O_U16TEXT:
+    case _O_WTEXT:
+        _osfile(fh) |= FTEXT;
+        _textmode(fh) = __crt_lowio_text_mode::utf16le;
+        break;
+    }
+
+    if (old_mode == 0)
+        return _O_BINARY;
+
+	if (old_textmode == __crt_lowio_text_mode::ansi)
+	{
+		return _O_TEXT;
+	}
+	else if (old_textmode == __crt_lowio_text_mode::utf8)
+	{
+		return _O_U8TEXT;
+	}
+
+    return _O_WTEXT;
+}
+
+
+
+extern "C" errno_t __cdecl _set_fmode(int const mode)
+{
+    _VALIDATE_RETURN_ERRCODE(mode == _O_TEXT || mode == _O_BINARY || mode == _O_WTEXT, EINVAL);
+
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    _InterlockedExchange(reinterpret_cast<long*>(&_fmode.value()), mode);
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+
+    return 0;
+}
+
+
+
+extern "C" errno_t __cdecl _get_fmode(int* const pMode)
+{
+    _VALIDATE_RETURN_ERRCODE(pMode != nullptr, EINVAL);
+
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    *pMode = __crt_interlocked_read(&_fmode.value());
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+
+    return 0;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/tell.cpp

@@ -0,0 +1,18 @@
+//
+// tell.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _tell(), which gets the current position of the file pointer.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdio.h>
+
+
+
+// Gets the current position of the file pointer, without adjustment for
+// buffering.  Returns -1 on error.
+extern "C" long __cdecl _tell(int const fh)
+{
+    return _lseek(fh, 0, SEEK_CUR);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/telli64.cpp

@@ -0,0 +1,18 @@
+//
+// telli64.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _telli64(), which gets the current position of the file pointer.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdio.h>
+
+
+
+// Gets the current position of the file pointer, without adjustment for
+// buffering.  Returns -1 on error.
+extern "C" __int64 __cdecl _telli64(int const fh)
+{
+    return _lseeki64(fh, 0, SEEK_CUR);
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/txtmode.cpp

@@ -0,0 +1,47 @@
+//
+// txtmode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the global _fmode variable and sets the global file mode to text.
+// This is the default behavior.
+//
+#include <corecrt_internal.h>
+#include <fcntl.h>
+#include <stdlib.h>
+
+// Clients of the static CRT can choose to access _fmode directly as a global variable; they do so as if it was declared as an int.
+// Because state separation is disabled in the static CRT, the dual_state_global<int> has the same representation as an int, so this is okay, if a bit messy.
+__crt_state_management::dual_state_global<int> _fmode;  // This is automatically initialized to zero by the compiler
+
+extern "C" int* __cdecl __p__fmode()
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return &_fmode.value();
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
+
+// Initializer for fmode global correction.
+_CRT_LINKER_FORCE_INCLUDE(__acrt_fmode_initializer);
+
+extern "C" int __cdecl __acrt_initialize_fmode()
+{
+    // The initial mode for _fmode is initialized during pre_c_initializer() in vcstartup, so that it can be overridden with a linkopt.
+    // The default value is provided by _get_startup_file_mode(), but this value is not used to initialize both _fmode states.
+    // (ex: if exe is Prog-Mode, OS-Mode _fmode is uninitialized, if exe is OS-Mode, Prog-Mode _fmode is uninitialized)
+
+    // To fix this, we adjust zero-value _fmode to _O_TEXT, since that is the default.
+    // Only the exe can use the linkopt, so the state that is not being initialized could not have requested _O_BINARY.
+
+    int * const fmode_states = _fmode.dangerous_get_state_array();
+    for (unsigned int i = 0; i != __crt_state_management::state_index_count; ++i)
+    {
+        int& fmode_state = fmode_states[i];
+        if (fmode_state == 0)
+        {
+            fmode_state = _O_TEXT;
+        }
+    }
+
+    return 0;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/umask.cpp

@@ -0,0 +1,66 @@
+/***
+*umask.c - set file permission mask
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _umask() - sets file permission mask of current process*
+*       affecting files created by creat, open, or sopen.
+*
+*******************************************************************************/
+
+#include <corecrt_internal_lowio.h>
+#include <sys\stat.h>
+
+extern "C" int _umaskval = 0;
+
+/***
+*errno_t _umask(mode, poldmode) - set the file mode mask
+*
+*Purpose :
+*    Works similiar to umask except it validates input params.
+*
+*
+*******************************************************************************/
+
+extern "C" errno_t __cdecl _umask_s(
+    int  const mode,
+    int* const old_mode
+    )
+{
+    _VALIDATE_RETURN_ERRCODE(old_mode != nullptr, EINVAL);
+    *old_mode = _umaskval;
+    _VALIDATE_RETURN_ERRCODE((mode & ~(_S_IREAD | _S_IWRITE)) == 0, EINVAL);
+
+    _umaskval = mode;
+    return 0;
+}
+
+/***
+*int _umask(mode) - set the file mode mask
+*
+*Purpose:
+*       Sets the file-permission mask of the current process* which
+*       modifies the permission setting of new files created by creat,
+*       open, or sopen.
+*
+*Entry:
+*       int mode - new file permission mask
+*                  may contain _S_IWRITE, _S_IREAD, _S_IWRITE | _S_IREAD.
+*                  The S_IREAD bit has no effect under Win32
+*
+*Exit:
+*       returns the previous setting of the file permission mask.
+*
+*Exceptions:
+*
+*******************************************************************************/
+extern "C" int __cdecl _umask(int const mode)
+{
+    // Silently ignore non-Windows modes:
+    int const masked_mode = mode & (_S_IREAD | _S_IWRITE);
+
+    int old_mode = 0;
+    _umask_s(masked_mode, &old_mode);
+    return old_mode;
+}

miniMSVC/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/write.cpp

@@ -0,0 +1,754 @@
+//
+// write.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _write(), which writes a buffer to a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <ctype.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+
+
+namespace
+{
+    struct write_result
+    {
+        DWORD error_code;
+        DWORD char_count;
+        DWORD lf_count;
+    };
+}
+
+
+
+// This is the normal size of the LF => CRLF translation buffer.  The default
+// buffer is 4K, plus extra room for LF characters.  Not all buffers are exactly
+// this size, but this is used as the base size.
+static size_t const BUF_SIZE = 5 * 1024;
+
+
+
+// Writes a buffer to a file.  The way in which the buffer is written depends on
+// the mode in which the file was opened (e.g., if the file is a text mode file,
+// linefeed translation will take place).
+//
+// On success, this function returns the number of bytes actually written (note
+// that "bytes" here is "bytes from the original buffer;" more or fewer bytes
+// may have actually been written, due to linefeed translation, codepage
+// translation, and other transformations).  On failure, this function returns 0
+// and sets errno.
+extern "C" int __cdecl _write_internal(int const fh, void const* const buffer, unsigned const size, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(fh) & FOPEN), EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            ptd.get_errno().set(EBADF);
+            ptd.get_doserrno().set(0);
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = _write_nolock(fh, buffer, size, ptd);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+extern "C" int __cdecl _write(int const fh, void const* const buffer, unsigned const size)
+{
+    __crt_cached_ptd_host ptd;
+    return _write_internal(fh, buffer, size, ptd);
+}
+
+static bool __cdecl write_requires_double_translation_nolock(int const fh, __crt_cached_ptd_host& ptd) throw()
+{
+    // Double translation is required if both [a] the current locale is not the C
+    // locale or the file is open in a non-ANSI mode and [b] we are writing to the
+    // console.
+
+    // If this isn't a TTY or a text mode screen, then it isn't the console:
+    if (!_isatty(fh))
+    {
+        return false;
+    }
+
+    if ((_osfile(fh) & FTEXT) == 0) {
+        return false;
+    }
+
+    // Get the current locale.  If we're in the C locale and the file is open
+    // in ANSI mode, we don't need double translation:
+    bool const is_c_locale = ptd.get_locale()->locinfo->locale_name[LC_CTYPE] == nullptr;
+    if (is_c_locale && _textmode(fh) == __crt_lowio_text_mode::ansi)
+    {
+        return false;
+    }
+
+    // If we can't get the console mode, it's not the console:
+    DWORD mode;
+    if (!GetConsoleMode(reinterpret_cast<HANDLE>(_osfhnd(fh)), &mode))
+    {
+        return false;
+    }
+
+    // Otherwise, double translation is required:
+    return true;
+}
+
+
+
+static write_result __cdecl write_double_translated_ansi_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size,
+    __crt_cached_ptd_host&                    ptd
+    ) throw()
+{
+    HANDLE      const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    char const* const buffer_end = buffer + buffer_size;
+    UINT        const console_cp = GetConsoleOutputCP();
+    _locale_t   const locale     = ptd.get_locale();
+    bool        const is_utf8    = locale->locinfo->_public._locale_lc_codepage == CP_UTF8;
+
+    write_result result = { 0 };
+
+    for (char const* source_it = buffer; source_it < buffer_end; )
+    {
+        char const c = *source_it;
+
+        // We require double conversion, to convert from the source multibyte
+        // to Unicode, then from Unicode back to multibyte, but in the console
+        // codepage.
+        //
+        // Here, we have to take into account that _write() might be called
+        // byte-by-byte, so when we see a lead byte without a trail byte, we
+        // have to store it and return no error.  When this function is called
+        // again, that byte will be combined with the next available character.
+        wchar_t wc[2] = { 0 };
+        int wc_used = 1;
+        if (is_utf8)
+        {
+            _ASSERTE(!_dbcsBufferUsed(fh));
+            const int mb_buf_size = sizeof(_mbBuffer(fh));
+            int mb_buf_used;
+            for (mb_buf_used = 0; mb_buf_used < mb_buf_size && _mbBuffer(fh)[mb_buf_used]; ++mb_buf_used)
+            {}
+
+            if (mb_buf_used > 0)
+            {
+                const int mb_len = _utf8_no_of_trailbytes(_mbBuffer(fh)[0]) + 1;
+                _ASSERTE(1 < mb_len && mb_buf_used < mb_len);
+                const int remaining_bytes = mb_len - mb_buf_used;
+                if (remaining_bytes <= (buffer_end - source_it))
+                {
+                    // We now have enough bytes to complete the code point
+                    char mb_buffer[MB_LEN_MAX];
+
+                    for (int i = 0; i < mb_buf_used; ++i)
+                    {
+                        mb_buffer[i] = _mbBuffer(fh)[i];
+                    }
+                    for (int i = 0; i < remaining_bytes; ++i)
+                    {
+                        mb_buffer[i + mb_buf_used] = source_it[i];
+                    }
+
+                    // Clear out the temp buffer
+                    for (int i = 0; i < mb_buf_used; ++i)
+                    {
+                        _mbBuffer(fh)[i] = 0;
+                    }
+
+                    mbstate_t state{};
+                    const char* str = mb_buffer;
+                    if (mb_len == 4)
+                    {
+                        wc_used = 2;
+                    }
+                    if (__crt_mbstring::__mbsrtowcs_utf8(wc, &str, wc_used, &state, ptd) == -1)
+                    {
+                        return result;
+                    }
+                    source_it += (remaining_bytes - 1);
+                }
+                else
+                {
+                    // Need to add some more bytes to the buffer for later
+                    const auto bytes_to_add = buffer_end - source_it;
+                    _ASSERTE(mb_buf_used + bytes_to_add < mb_buf_size);
+                    for (int i = 0; i < bytes_to_add; ++i)
+                    {
+                        _mbBuffer(fh)[i + mb_buf_used] = source_it[i];
+                    }
+                    // Pretend we wrote the bytes, because this isn't an error *yet*.
+                    result.char_count += static_cast<DWORD>(bytes_to_add);
+                    return result;
+                }
+            }
+            else
+            {
+                const int mb_len = _utf8_no_of_trailbytes(*source_it) + 1;
+                const auto available_bytes = buffer_end - source_it;
+                if (mb_len <= (available_bytes))
+                {
+                    // We have enough bytes to write the entire code point
+                    mbstate_t state{};
+                    const char* str = source_it;
+                    if (mb_len == 4)
+                    {
+                        wc_used = 2;
+                    }
+                    if (__crt_mbstring::__mbsrtowcs_utf8(wc, &str, wc_used, &state, ptd) == -1)
+                    {
+                        return result;
+                    }
+                    source_it += (mb_len - 1);
+                }
+                else
+                {
+                    // Not enough bytes for this code point
+                    _ASSERTE(available_bytes <= sizeof(_mbBuffer(fh)));
+                    for (int i = 0; i < available_bytes; ++i)
+                    {
+                        _mbBuffer(fh)[i] = source_it[i];
+                    }
+                    // Pretend we wrote the bytes, because this isn't an error *yet*.
+                    result.char_count += static_cast<DWORD>(available_bytes);
+                    return result;
+                }
+            }
+        }
+        else if (_dbcsBufferUsed(fh))
+        {
+            // We already have a DBCS lead byte buffered.  Take the current
+            // character, combine it with the lead byte, and convert:
+            _ASSERTE(_isleadbyte_fast_internal(_dbcsBuffer(fh), locale));
+
+            char mb_buffer[MB_LEN_MAX];
+            mb_buffer[0] = _dbcsBuffer(fh);
+            mb_buffer[1] = *source_it;
+
+            _dbcsBufferUsed(fh) = false;
+
+            if (_mbtowc_internal(wc, mb_buffer, 2, ptd) == -1)
+            {
+                return result;
+            }
+        }
+        else
+        {
+            if (_isleadbyte_fast_internal(*source_it, locale))
+            {
+                if ((source_it + 1) < buffer_end)
+                {
+                    // And we have more bytes to read, just convert...
+                    if (_mbtowc_internal(wc, source_it, 2, ptd) == -1)
+                    {
+                        return result;
+                    }
+
+                    // Increment the source_it to accomodate the DBCS character:
+                    ++source_it;
+                }
+                else
+                {
+                    // And we ran out of bytes to read, so buffer the lead byte:
+                    _dbcsBuffer(fh) = *source_it;
+                    _dbcsBufferUsed(fh) = true;
+
+                    // We lie here that we actually wrote the last character, to
+                    // ensure we don't consider this an error:
+                    ++result.char_count;
+                    return result;
+                }
+            }
+            else
+            {
+                // single character conversion:
+                if (_mbtowc_internal(wc, source_it, 1, ptd) == -1)
+                {
+                    return result;
+                }
+            }
+        }
+
+        ++source_it;
+
+        // Translate the Unicode character into Multibyte in the console codepage
+        // and write the character to the file:
+        char mb_buffer[MB_LEN_MAX];
+        DWORD const size = static_cast<DWORD>(__acrt_WideCharToMultiByte(
+            console_cp, 0, wc, wc_used, mb_buffer, sizeof(mb_buffer), nullptr, nullptr));
+
+        if(size == 0)
+            return result;
+
+        DWORD written;
+        if (!WriteFile(os_handle, mb_buffer, size, &written, nullptr))
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        // When we are converting, some conversions may result in:
+        //
+        //     2 MBCS characters => 1 wide character => 1 MBCS character.
+        //
+        // For example, when printing Japanese characters in the English console
+        // codepage, each source character is transformed into a single question
+        // mark.  Therefore, we want to track the number of bytes we converted,
+        // plus the linefeed count, instead of how many bytes we actually wrote.
+        result.char_count = result.lf_count + static_cast<DWORD>(source_it - buffer);
+
+        // If the write succeeded but didn't write all of the characters, return:
+        if (written < size)
+        {
+            return result;
+        }
+
+        // If the original character that we read was an LF, write a CR too:
+        // CRT_REFACTOR TODO Doesn't this write LFCR instead of CRLF?
+        if (c == LF)
+        {
+            wchar_t const cr = CR;
+            if (!WriteFile(os_handle, &cr, 1, &written, nullptr))
+            {
+                result.error_code = GetLastError();
+                return result;
+            }
+
+            if (written < 1)
+            {
+                return result;
+            }
+
+            ++result.lf_count;
+            ++result.char_count;
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_double_translated_unicode_nolock(
+    _In_reads_(buffer_size)                      char const* const buffer,
+    _In_ _Pre_satisfies_((buffer_size % 2) == 0) unsigned    const buffer_size
+    ) throw()
+{
+    // When writing to a Unicode file (UTF-8 or UTF-16LE) that corresponds to
+    // the console, we don't actually need double translation.  We just need to
+    // print each character to the console, one-by-one.  (This function is
+    // named what it is because its use is guarded by the double translation
+    // check, and to match the name of the corresponding ANSI function.)
+
+    write_result result = { 0 };
+
+    // Needed for SAL to clarify that buffer_size is even.
+    _Analysis_assume_((buffer_size/2) != ((buffer_size-1)/2));
+    char const* const buffer_end = buffer + buffer_size;
+    for (char const* pch = buffer; pch < buffer_end; pch += 2)
+    {
+        wchar_t const c = *reinterpret_cast<wchar_t const*>(pch);
+
+        // _putwch_nolock does not depend on global state, no PTD needed to be propagated.
+        if (_putwch_nolock(c) == c)
+        {
+            result.char_count += 2;
+        }
+        else
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        // If the character was a carriage return, also emit a line feed.
+        // CRT_REFACTOR TODO Doesn't this print LFCR instead of CRLF?
+        if (c == LF)
+        {
+            // _putwch_nolock does not depend on global state, no PTD needed to be propagated.
+            if (_putwch_nolock(CR) != CR)
+            {
+                result.error_code = GetLastError();
+                return result;
+            }
+
+            ++result.char_count;
+            ++result.lf_count;
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_text_ansi_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE      const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    char const* const buffer_end = buffer + buffer_size;
+
+    write_result result = { 0 };
+
+    for (char const* source_it = buffer; source_it < buffer_end; )
+    {
+        char lfbuf[BUF_SIZE]; // The LF => CRLF translation buffer
+
+        // One-past-the-end of the translation buffer.  Note that we subtract
+        // one to account for the case where we're pointing to the last element
+        // in the buffer and we need to write both a CR and an LF.
+        char* const lfbuf_end = lfbuf + sizeof(lfbuf) - 1;
+
+        // Translate the source buffer into the translation buffer.  Note that
+        // both source_it and lfbuf_it are incremented in the loop.
+        char* lfbuf_it = lfbuf;
+        while (lfbuf_it < lfbuf_end && source_it < buffer_end)
+        {
+            char const c = *source_it++;
+
+            if (c == LF)
+            {
+                ++result.lf_count;
+                *lfbuf_it++ = CR;
+            }
+
+            *lfbuf_it++ = c;
+        }
+
+        DWORD const lfbuf_length = static_cast<DWORD>(lfbuf_it - lfbuf);
+
+        DWORD written;
+        if (!WriteFile(os_handle, lfbuf, lfbuf_length, &written, nullptr))
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        result.char_count += written;
+        if (written < lfbuf_length)
+        {
+            return result; // The write succeeded but didn't write everything
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_text_utf16le_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE         const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    wchar_t const* const buffer_end = reinterpret_cast<wchar_t const*>(buffer + buffer_size);
+
+    write_result result = { 0 };
+
+    wchar_t const* source_it = reinterpret_cast<wchar_t const*>(buffer);
+    while (source_it < buffer_end)
+    {
+        wchar_t lfbuf[BUF_SIZE / sizeof(wchar_t)]; // The translation buffer
+
+        // One-past-the-end of the translation buffer.  Note that we subtract
+        // one to account for the case where we're pointing to the last element
+        // in the buffer and we need to write both a CR and an LF.
+        wchar_t const* lfbuf_end = lfbuf + BUF_SIZE / sizeof(wchar_t) - 1;
+
+        // Translate the source buffer into the translation buffer.  Note that
+        // both source_it and lfbuf_it are incremented in the loop.
+        wchar_t* lfbuf_it = lfbuf;
+        while (lfbuf_it < lfbuf_end && source_it < buffer_end)
+        {
+            wchar_t const c = *source_it++;
+
+            if (c == LF)
+            {
+                result.lf_count += 2;
+                *lfbuf_it++ = CR;
+            }
+
+            *lfbuf_it++ = c;
+        }
+
+        // Note that this length is in bytes, not wchar_t elemnts, since we need
+        // to tell WriteFile how many bytes (not characters) to write:
+        DWORD const lfbuf_length = static_cast<DWORD>(lfbuf_it - lfbuf) * sizeof(wchar_t);
+
+
+        // Attempt the write and return immediately if it fails:
+        DWORD written;
+        if (!WriteFile(os_handle, lfbuf, lfbuf_length, &written, nullptr))
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        result.char_count += written;
+        if (written < lfbuf_length)
+        {
+            return result; // The write succeeded, but didn't write everything
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_text_utf8_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE         const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    wchar_t const* const buffer_end = reinterpret_cast<wchar_t const*>(buffer + buffer_size);
+
+    write_result result = { 0 };
+
+    wchar_t const* source_it = reinterpret_cast<wchar_t const*>(buffer);
+    while (source_it < buffer_end)
+    {
+        // The translation buffer.  We use two buffers:  the first is used to
+        // store the UTF-16 LF => CRLF translation (this is that buffer here).
+        // The second is used for storing the conversion to UTF-8 (defined
+        // below).  The sizes are selected to handle the worst-case scenario
+        // where each UTF-8 character is four bytes long.
+        wchar_t utf16_buf[BUF_SIZE / 6];
+
+        // One-past-the-end of the translation buffer.  Note that we subtract
+        // one to account for the case where we're pointing to the last element
+        // in the buffer and we need to write both a CR and an LF.
+        wchar_t const* utf16_buf_end = utf16_buf + (BUF_SIZE / 6 - 1);
+
+        // Translate the source buffer into the translation buffer.  Note that
+        // both source_it and lfbuf_it are incremented in the loop.
+        wchar_t* utf16_buf_it = utf16_buf;
+        while (utf16_buf_it < utf16_buf_end && source_it < buffer_end)
+        {
+            wchar_t const c = *source_it++;
+
+            if (c == LF)
+            {
+                // No need to count the number of line-feeds translated; we
+                // track the number of written characters by counting the total
+                // number of characters written from the UTF8 buffer (see below
+                // where we update the char_count).
+                *utf16_buf_it++ = CR;
+            }
+
+            *utf16_buf_it++ = c;
+        }
+
+        // Note that this length is in characters, not bytes.
+        DWORD const utf16_buf_length = static_cast<DWORD>(utf16_buf_it - utf16_buf);
+
+
+        // This is the second translation, where we translate the UTF-16 text to
+        // UTF-8, into the UTF-8 buffer:
+        char utf8_buf[(BUF_SIZE * 2) / 3];
+        DWORD const bytes_converted = static_cast<DWORD>(__acrt_WideCharToMultiByte(
+                CP_UTF8,
+                0,
+                utf16_buf,
+                utf16_buf_length,
+                utf8_buf,
+                sizeof(utf8_buf),
+                nullptr,
+                nullptr));
+
+        if (bytes_converted == 0)
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        // Here, we need to make every attempt to write all of the converted
+        // characters to avoid corrupting the stream.  If, for example, we write
+        // only half of the bytes of a UTF-8 character, the stream may be
+        // corrupted.
+        //
+        // This loop will ensure that we exit only if either (a) all of the
+        // bytes are written, ensuring that no partial MBCSes are written, or
+        // (b) there is an error in the stream.
+        for (DWORD bytes_written = 0; bytes_written < bytes_converted; )
+        {
+            char const* const current      = utf8_buf + bytes_written;
+            DWORD       const current_size = bytes_converted - bytes_written;
+
+            DWORD written;
+            if (!WriteFile(os_handle, current, current_size, &written, nullptr))
+            {
+                result.error_code = GetLastError();
+                return result;
+            }
+
+            bytes_written += written;
+        }
+
+        // If this chunk was committed successfully, update the character count:
+        result.char_count = static_cast<DWORD>(reinterpret_cast<char const*>(source_it) - buffer);
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_binary_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_osfhnd(fh));
+
+    // Compared to text files, binary files are easy...
+    write_result result = { 0 };
+    if (!WriteFile(os_handle, buffer, buffer_size, &result.char_count, nullptr))
+    {
+        result.error_code = GetLastError();
+    }
+
+    return result;
+}
+
+
+
+extern "C" int __cdecl _write_nolock(int const fh, void const* const buffer, unsigned const buffer_size, __crt_cached_ptd_host& ptd)
+{
+    // If the buffer is empty, there is nothing to be written:
+    if (buffer_size == 0)
+    {
+        return 0;
+    }
+
+    // If the buffer is null, though... well, that is not allowed:
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, buffer != nullptr, EINVAL, -1);
+
+    __crt_lowio_text_mode const fh_textmode = _textmode(fh);
+
+    // If the file is open for Unicode, the buffer size must always be even:
+    if (fh_textmode == __crt_lowio_text_mode::utf16le || fh_textmode == __crt_lowio_text_mode::utf8)
+    {
+        _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, buffer_size % 2 == 0, EINVAL, -1);
+    }
+
+    // If the file is opened for appending, seek to the end of the file.  We
+    // ignore errors because the underlying file may not allow seeking.
+    if (_osfile(fh) & FAPPEND)
+    {
+        (void)_lseeki64_nolock_internal(fh, 0, FILE_END, ptd);
+    }
+
+    char const* const char_buffer = static_cast<char const*>(buffer);
+
+    // Dispatch the actual writing to one of the helper routines based on the
+    // text mode of the file and whether or not the file refers to the console.
+    //
+    // Note that in the event that the handle belongs to the console, WriteFile
+    // will generate garbage output.  To print to the console correctly, we need
+    // to print ANSI.  Also note that when printing to the console, we need to
+    // convert the characters to the console codepge.
+    write_result result = { 0 };
+    if (write_requires_double_translation_nolock(fh, ptd))
+    {
+        switch (fh_textmode)
+        {
+        case __crt_lowio_text_mode::ansi:
+            result = write_double_translated_ansi_nolock(fh, char_buffer, buffer_size, ptd);
+            break;
+
+        case __crt_lowio_text_mode::utf16le:
+        case __crt_lowio_text_mode::utf8:
+            _Analysis_assume_((buffer_size % 2) == 0);
+            result = write_double_translated_unicode_nolock(char_buffer, buffer_size);
+            break;
+        }
+    }
+    else if (_osfile(fh) & FTEXT)
+    {
+        switch (fh_textmode)
+        {
+        case __crt_lowio_text_mode::ansi:
+            result = write_text_ansi_nolock(fh, char_buffer, buffer_size);
+            break;
+
+        case __crt_lowio_text_mode::utf16le:
+            result = write_text_utf16le_nolock(fh, char_buffer, buffer_size);
+            break;
+
+        case __crt_lowio_text_mode::utf8:
+            result = write_text_utf8_nolock(fh, char_buffer, buffer_size);
+            break;
+        }
+    }
+    else
+    {
+        result = write_binary_nolock(fh, char_buffer, buffer_size);
+    }
+
+
+    // Why did we not write anything?  Lettuce find out...
+    if (result.char_count == 0)
+    {
+        // If nothing was written, check to see if it was due to an OS error:
+        if (result.error_code != 0)
+        {
+            // An OS error occurred.  ERROR_ACCESS_DENIED should be mapped in
+            // this case to EBADF, not EACCES.  All other errors are mapped
+            // normally:
+            if (result.error_code == ERROR_ACCESS_DENIED)
+            {
+                ptd.get_errno().set(EBADF);
+                ptd.get_doserrno().set(result.error_code);
+            }
+            else
+            {
+                __acrt_errno_map_os_error_ptd(result.error_code, ptd);
+            }
+
+            return -1;
+        }
+
+        // If this file is a device and the first character was Ctrl+Z, then
+        // writing nothing is the expected behavior and is not an error:
+        if ((_osfile(fh) & FDEV) && *char_buffer == CTRLZ)
+        {
+            return 0;
+        }
+
+        // Otherwise, the error is reported as ENOSPC:
+        ptd.get_errno().set(ENOSPC);
+        ptd.get_doserrno().set(0);
+        return -1;
+    }
+
+    // The write succeeded.  Return the adjusted number of bytes written:
+    return result.char_count - result.lf_count;
+}