get_qualified_locale.cpp File Reference

#include <corecrt_internal.h>
#include <locale.h>
#include <stdlib.h>

Include dependency graph for get_qualified_locale.cpp:

Go to the source code of this file.

Macros
#define	__LOC_DEFAULT   0x1
#define	__LOC_PRIMARY   0x2
#define	__LOC_FULL   0x4
#define	__LOC_LANGUAGE   0x100
#define	__LOC_EXISTS   0x200

Functions
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)
static BOOL CALLBACK	LangCountryEnumProcEx (LPWSTR lpLocaleString, DWORD dwFlags, LPARAM lParam)
static BOOL CALLBACK	LanguageEnumProcEx (LPWSTR lpLocaleString, DWORD dwFlags, LPARAM lParam)

Variables
__crt_locale_string_table const	__acrt_rg_language []
__crt_locale_string_table const	__acrt_rg_country []
size_t const	__acrt_rg_language_count {_countof(__acrt_rg_language)}
size_t const	__acrt_rg_country_count {_countof(__acrt_rg_country )}

Macro Definition Documentation

__LOC_DEFAULT

#define __LOC_DEFAULT   0x1

Definition at line 19 of file get_qualified_locale.cpp.

__LOC_EXISTS

#define __LOC_EXISTS   0x200

Definition at line 23 of file get_qualified_locale.cpp.

__LOC_FULL

#define __LOC_FULL   0x4

Definition at line 21 of file get_qualified_locale.cpp.

__LOC_LANGUAGE

#define __LOC_LANGUAGE   0x100

Definition at line 22 of file get_qualified_locale.cpp.

__LOC_PRIMARY

#define __LOC_PRIMARY   0x2

Definition at line 20 of file get_qualified_locale.cpp.

Function Documentation

__acrt_get_qualified_locale()

BOOL __cdecl __acrt_get_qualified_locale	(	const __crt_locale_strings *	lpInStr,
		UINT *	lpOutCodePage,
		__crt_locale_strings *	lpOutStr
	)

Definition at line 170 of file get_qualified_locale.cpp.

{
    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;
}

Referenced by _expandlocale().

GetLocaleNameFromDefault()

static void GetLocaleNameFromDefault ( __crt_qualified_locale_data *  _psetloc_data )

static

Definition at line 669 of file get_qualified_locale.cpp.

{
    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));
    }
}

Referenced by __acrt_get_qualified_locale().

GetLocaleNameFromLangCountry()

static void GetLocaleNameFromLangCountry ( __crt_qualified_locale_data *  _psetloc_data )

static

Definition at line 381 of file get_qualified_locale.cpp.

{
    //  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;
}

Referenced by __acrt_get_qualified_locale().

GetLocaleNameFromLanguage()

static void GetLocaleNameFromLanguage ( __crt_qualified_locale_data *  _psetloc_data )

static

Definition at line 592 of file get_qualified_locale.cpp.

{
    //  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;
}

Referenced by __acrt_get_qualified_locale().

GetPrimaryLen()

static int GetPrimaryLen ( LPCWSTR  pchLanguage )

static

Definition at line 831 of file get_qualified_locale.cpp.

{
    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;
}

Referenced by GetLocaleNameFromLangCountry(), GetLocaleNameFromLanguage(), and TestDefaultLanguage().

LangCountryEnumProcEx() [1/2]

static BOOL CALLBACK LangCountryEnumProcEx ( _In_z_  LPWSTR, DWORD  , LPARAM    )

static

Referenced by GetLocaleNameFromLangCountry().

LangCountryEnumProcEx() [2/2]

static BOOL CALLBACK LangCountryEnumProcEx ( LPWSTR  lpLocaleString, DWORD  dwFlags, LPARAM  lParam  )

static

Definition at line 431 of file get_qualified_locale.cpp.

{
    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;
}

LanguageEnumProcEx() [1/2]

static BOOL CALLBACK LanguageEnumProcEx ( _In_z_  LPWSTR, DWORD  , LPARAM    )

static

Referenced by GetLocaleNameFromLanguage().

LanguageEnumProcEx() [2/2]

static BOOL CALLBACK LanguageEnumProcEx ( LPWSTR  lpLocaleString, DWORD  dwFlags, LPARAM  lParam  )

static

Definition at line 627 of file get_qualified_locale.cpp.

{
    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;
}

ProcessCodePage()

static int ProcessCodePage ( LPCWSTR  lpCodePageStr, __crt_qualified_locale_data *  _psetloc_data  )

static

Definition at line 700 of file get_qualified_locale.cpp.

{
    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;
}

Referenced by __acrt_get_qualified_locale().

TestDefaultCountry()

static BOOL TestDefaultCountry ( LPCWSTR  localeName )

static

Definition at line 766 of file get_qualified_locale.cpp.

{
    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;
}

Referenced by LangCountryEnumProcEx(), and TestDefaultLanguage().

TestDefaultLanguage()

static BOOL TestDefaultLanguage ( LPCWSTR  localeName, BOOL  bTestPrimary, __crt_qualified_locale_data *  _psetloc_data  )

static

Definition at line 802 of file get_qualified_locale.cpp.

{
    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;
}

Referenced by LangCountryEnumProcEx().

TranslateName()

static BOOL TranslateName ( const __crt_locale_string_table *  lpTable, int  high, const wchar_t **  ppchName  )

static

Definition at line 320 of file get_qualified_locale.cpp.

{
    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;
}

Referenced by __acrt_get_qualified_locale().

Variable Documentation

__acrt_rg_country

__crt_locale_string_table const __acrt_rg_country[]

extern

Initial value:

{
    { 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" },
}

Referenced by __acrt_get_qualified_locale().

__acrt_rg_country_count

size_t const __acrt_rg_country_count {_countof(__acrt_rg_country )}

extern

Referenced by __acrt_get_qualified_locale().

__acrt_rg_language

__crt_locale_string_table const __acrt_rg_language[]

extern

Referenced by __acrt_get_qualified_locale().

__acrt_rg_language_count

size_t const __acrt_rg_language_count {_countof(__acrt_rg_language)}

extern

Referenced by __acrt_get_qualified_locale().