getqloc_downlevel.cpp File Reference

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

Include dependency graph for getqloc_downlevel.cpp:

Go to the source code of this file.

Classes
struct	tagRGLOCINFO

Macros
#define	__LCID_DEFAULT   0x1
#define	__LCID_PRIMARY   0x2
#define	__LCID_FULL   0x4
#define	__LCID_LANGUAGE   0x100
#define	__LCID_EXISTS   0x200

Typedefs
typedef struct tagRGLOCINFO	RGLOCINFO

Functions
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 *)
	__declspec (selectany) LANGID const __rglangidNotDefault[]
BOOL __cdecl	__acrt_get_qualified_locale_downlevel (const __crt_locale_strings *lpInStr, UINT *lpOutCodePage, __crt_locale_strings *lpOutStr)

Macro Definition Documentation

__LCID_DEFAULT

#define __LCID_DEFAULT   0x1

Definition at line 18 of file getqloc_downlevel.cpp.

__LCID_EXISTS

#define __LCID_EXISTS   0x200

Definition at line 22 of file getqloc_downlevel.cpp.

__LCID_FULL

#define __LCID_FULL   0x4

Definition at line 20 of file getqloc_downlevel.cpp.

__LCID_LANGUAGE

#define __LCID_LANGUAGE   0x100

Definition at line 21 of file getqloc_downlevel.cpp.

__LCID_PRIMARY

#define __LCID_PRIMARY   0x2

Definition at line 19 of file getqloc_downlevel.cpp.

Typedef Documentation

RGLOCINFO

typedef struct tagRGLOCINFO RGLOCINFO

Function Documentation

__acrt_get_qualified_locale_downlevel()

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

Definition at line 89 of file getqloc_downlevel.cpp.

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

Referenced by _expandlocale().

__declspec()

__declspec

(

selectany

)

const

CountryEnumProc()

static BOOL CALLBACK CountryEnumProc ( _In_z_ PWSTR  lpLcidString )

static

Definition at line 619 of file getqloc_downlevel.cpp.

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

Referenced by GetLcidFromCountry().

GetLcidFromCountry()

static void GetLcidFromCountry ( __crt_qualified_locale_data_downlevel *  _psetloc_downlevel_data )

static

Definition at line 587 of file getqloc_downlevel.cpp.

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

Referenced by __acrt_get_qualified_locale_downlevel().

GetLcidFromDefault()

static void GetLcidFromDefault ( __crt_qualified_locale_data_downlevel *  _psetloc_downlevel_data )

static

Definition at line 664 of file getqloc_downlevel.cpp.

{
    _psetloc_downlevel_data->iLcidState |= (__LCID_FULL | __LCID_LANGUAGE);
    _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = GetUserDefaultLCID();
}

Referenced by __acrt_get_qualified_locale_downlevel().

GetLcidFromLangCountry()

static void GetLcidFromLangCountry ( __crt_qualified_locale_data_downlevel *  _psetloc_downlevel_data )

static

Definition at line 280 of file getqloc_downlevel.cpp.

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

Referenced by __acrt_get_qualified_locale_downlevel().

GetLcidFromLanguage()

static void GetLcidFromLanguage ( __crt_qualified_locale_data_downlevel *  _psetloc_downlevel_data )

static

Definition at line 488 of file getqloc_downlevel.cpp.

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

Referenced by __acrt_get_qualified_locale_downlevel().

GetPrimaryLen()

static int GetPrimaryLen ( wchar_t const *  pchLanguage )

static

Definition at line 837 of file getqloc_downlevel.cpp.

{
    int     len = 0;
    wchar_t    ch;
 
    ch = *pchLanguage++;
    while ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
    {
        len++;
        ch = *pchLanguage++;
    }
 
    return len;
}

Referenced by GetLcidFromLangCountry(), GetLcidFromLanguage(), and TestDefaultLanguage().

LangCountryEnumProc()

static BOOL CALLBACK LangCountryEnumProc ( _In_z_ PWSTR  lpLcidString )

static

Definition at line 331 of file getqloc_downlevel.cpp.

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

Referenced by GetLcidFromLangCountry().

LanguageEnumProc()

static BOOL CALLBACK LanguageEnumProc ( _In_z_ PWSTR  lpLcidString )

static

Definition at line 523 of file getqloc_downlevel.cpp.

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

Referenced by GetLcidFromLanguage().

LcidFromHexString()

static LCID LcidFromHexString ( _In_z_ PCWSTR  lpHexString )

static

Definition at line 803 of file getqloc_downlevel.cpp.

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

Referenced by CountryEnumProc(), LangCountryEnumProc(), and LanguageEnumProc().

ProcessCodePage()

static int ProcessCodePage ( LPCWSTR  lpCodePageStr, __crt_qualified_locale_data_downlevel *  _psetloc_downlevel_data  )

static

Definition at line 687 of file getqloc_downlevel.cpp.

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

Referenced by __acrt_get_qualified_locale_downlevel().

TestDefaultCountry()

static BOOL TestDefaultCountry ( LCID  lcid )

static

Definition at line 734 of file getqloc_downlevel.cpp.

{
    LANGID  langid = LANGIDFROMLCID(lcid);
    int     i;
 
    for (i = 0; i < _countof(__rglangidNotDefault); i++)
    {
        if (langid == __rglangidNotDefault[i])
            return FALSE;
    }
    return TRUE;
}

Referenced by CountryEnumProc(), and LangCountryEnumProc().

TestDefaultLanguage()

static BOOL TestDefaultLanguage ( LCID  lcid, BOOL  bTestPrimary, __crt_qualified_locale_data_downlevel *  _psetloc_downlevel_data  )

static

Definition at line 766 of file getqloc_downlevel.cpp.

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

Referenced by LangCountryEnumProc(), and LanguageEnumProc().

TranslateName()

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

static

Definition at line 230 of file getqloc_downlevel.cpp.

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

Referenced by __acrt_get_qualified_locale_downlevel().