#include <k32.h>
#include <debug.h>
#include "lcformat_private.h"

Include dependency graph for lang.c:

Classes
struct	locale_name

struct	registry_value

struct	enum_locale_ex_data

struct	ENUMLANGUAGEGROUP_CALLBACKS

struct	ENUMLANGUAGEGROUPLOCALE_CALLBACKS

struct	geoinfo_t

struct	ENUMSYSTEMCODEPAGES_CALLBACKS

struct	ENUM_UILANG_CALLBACK

Macros
#define	NDEBUG

#define	REG_SZ 1

#define	NLSRC_OFFSET 5000 /* FIXME */

#define	LOCALE_LOCALEINFOFLAGSMASK

Enumerations
enum	locationkind { LOCATION_NATION = 0 , LOCATION_REGION , LOCATION_BOTH }

Functions
	DEBUG_CHANNEL (nls)

int	wine_fold_string (int flags, const WCHAR src, int srclen, WCHAR dst, int dstlen)

int	wine_get_sortkey (int flags, const WCHAR src, int srclen, char dst, int dstlen)

int	wine_compare_string (int flags, const WCHAR str1, int len1, const WCHAR str2, int len2)

UINT	GetLocalisedText (IN UINT uID, IN LPWSTR lpszDest, IN UINT cchDest)

static void	strcpynAtoW (WCHAR dst, const char src, size_t n)

static UINT	get_lcid_codepage (LCID lcid)

static LCID	convert_default_lcid (LCID lcid, LCTYPE lctype)

static BOOL	is_genitive_name_supported (LCTYPE lctype)

static HANDLE	create_registry_key (void)

LANGID WINAPI	GetUserDefaultLangID (void)

LANGID WINAPI	GetSystemDefaultLangID (void)

LCID WINAPI	GetUserDefaultLCID (void)

LCID WINAPI	GetSystemDefaultLCID (void)

LANGID WINAPI	GetUserDefaultUILanguage (void)

LANGID WINAPI	GetSystemDefaultUILanguage (void)

static INT	get_registry_locale_info (struct registry_value *registry_value, LPWSTR buffer, INT len)

INT WINAPI	GetLocaleInfoA (LCID lcid, LCTYPE lctype, LPSTR buffer, INT len)

static int	get_value_base_by_lctype (LCTYPE lctype)

static struct registry_value *	get_locale_registry_value (DWORD lctype)

INT WINAPI	GetLocaleInfoW (LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len)

BOOL WINAPI	SetLocaleInfoA (LCID lcid, LCTYPE lctype, LPCSTR data)

BOOL WINAPI	SetLocaleInfoW (LCID lcid, LCTYPE lctype, LPCWSTR data)

LCID WINAPI	GetThreadLocale (void)

BOOL WINAPI	SetThreadLocale (LCID lcid)

LCID WINAPI	ConvertDefaultLocale (LCID lcid)

BOOL WINAPI	IsValidLocale (LCID lcid, DWORD flags)

static BOOL CALLBACK	enum_lang_proc_a (HMODULE hModule, LPCSTR type, LPCSTR name, WORD LangID, LONG_PTR lParam)

static BOOL CALLBACK	enum_lang_proc_w (HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD LangID, LONG_PTR lParam)

BOOL WINAPI	EnumSystemLocalesA (LOCALE_ENUMPROCA lpfnLocaleEnum, DWORD dwFlags)

BOOL WINAPI	EnumSystemLocalesW (LOCALE_ENUMPROCW lpfnLocaleEnum, DWORD dwFlags)

static BOOL CALLBACK	enum_locale_ex_proc (HMODULE module, LPCWSTR type, LPCWSTR name, WORD lang, LONG_PTR lparam)

BOOL WINAPI	EnumSystemLocalesEx (LOCALE_ENUMPROCEX proc, DWORD flags, LPARAM lparam, LPVOID reserved)

DWORD WINAPI	VerLanguageNameA (DWORD wLang, LPSTR szLang, DWORD nSize)

DWORD WINAPI	VerLanguageNameW (DWORD wLang, LPWSTR szLang, DWORD nSize)

BOOL WINAPI	GetStringTypeW (DWORD type, LPCWSTR src, INT count, LPWORD chartype)

BOOL WINAPI	GetStringTypeExW (LCID locale, DWORD type, LPCWSTR src, INT count, LPWORD chartype)

BOOL WINAPI	GetStringTypeA (LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype)

BOOL WINAPI	GetStringTypeExA (LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype)

INT WINAPI	LCMapStringEx (LPCWSTR name, DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen, LPNLSVERSIONINFO version, LPVOID reserved, LPARAM lparam)

INT WINAPI	LCMapStringW (LCID lcid, DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen)

INT WINAPI	LCMapStringA (LCID lcid, DWORD flags, LPCSTR src, INT srclen, LPSTR dst, INT dstlen)

INT WINAPI	FoldStringA (DWORD dwFlags, LPCSTR src, INT srclen, LPSTR dst, INT dstlen)

INT WINAPI	FoldStringW (DWORD dwFlags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen)

INT WINAPI	CompareStringEx (LPCWSTR locale, DWORD flags, LPCWSTR str1, INT len1, LPCWSTR str2, INT len2, LPNLSVERSIONINFO version, LPVOID reserved, LPARAM lParam)

INT WINAPI	CompareStringW (LCID lcid, DWORD flags, LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)

INT WINAPI	CompareStringA (LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)

static HANDLE	NLS_RegOpenKey (HANDLE hRootKey, LPCWSTR szKeyName)

static BOOL	NLS_RegEnumValue (HANDLE hKey, UINT ulIndex, LPWSTR szValueName, ULONG valueNameSize, LPWSTR szValueData, ULONG valueDataSize)

static BOOL	NLS_RegGetDword (HANDLE hKey, LPCWSTR szValueName, DWORD *lpVal)

static BOOL	NLS_GetLanguageGroupName (LGRPID lgrpid, LPWSTR szName, ULONG nameSize)

static BOOL	NLS_EnumSystemLanguageGroups (ENUMLANGUAGEGROUP_CALLBACKS *lpProcs)

BOOL WINAPI	EnumSystemLanguageGroupsA (LANGUAGEGROUP_ENUMPROCA pLangGrpEnumProc, DWORD dwFlags, LONG_PTR lParam)

BOOL WINAPI	EnumSystemLanguageGroupsW (LANGUAGEGROUP_ENUMPROCW pLangGrpEnumProc, DWORD dwFlags, LONG_PTR lParam)

BOOL WINAPI	IsValidLanguageGroup (LGRPID lgrpid, DWORD dwFlags)

static BOOL	NLS_EnumLanguageGroupLocales (ENUMLANGUAGEGROUPLOCALE_CALLBACKS *lpProcs)

BOOL WINAPI	EnumLanguageGroupLocalesA (LANGGROUPLOCALE_ENUMPROCA pLangGrpLcEnumProc, LGRPID lgrpid, DWORD dwFlags, LONG_PTR lParam)

BOOL WINAPI	EnumLanguageGroupLocalesW (LANGGROUPLOCALE_ENUMPROCW pLangGrpLcEnumProc, LGRPID lgrpid, DWORD dwFlags, LONG_PTR lParam)

static BOOL	NLS_EnumSystemCodePages (ENUMSYSTEMCODEPAGES_CALLBACKS *lpProcs)

BOOL WINAPI	EnumSystemCodePagesW (CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags)

BOOL WINAPI	EnumSystemCodePagesA (CODEPAGE_ENUMPROCA lpCodePageEnumProc, DWORD dwFlags)

BOOL WINAPI	EnumSystemGeoID (GEOCLASS geoclass, GEOID parent, GEO_ENUMPROC enumproc)

BOOL WINAPI	InvalidateNLSCache (void)

GEOID WINAPI	GetUserGeoID (GEOCLASS GeoClass)

BOOL WINAPI	SetUserGeoID (GEOID GeoID)

static BOOL CALLBACK	enum_uilang_proc_a (HMODULE hModule, LPCSTR type, LPCSTR name, WORD LangID, LONG_PTR lParam)

static BOOL CALLBACK	enum_uilang_proc_w (HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD LangID, LONG_PTR lParam)

BOOL WINAPI	EnumUILanguagesA (UILANGUAGE_ENUMPROCA pUILangEnumProc, DWORD dwFlags, LONG_PTR lParam)

BOOL WINAPI	EnumUILanguagesW (UILANGUAGE_ENUMPROCW pUILangEnumProc, DWORD dwFlags, LONG_PTR lParam)

static int	NLS_GetGeoFriendlyName (GEOID Location, LPWSTR szFriendlyName, int cchData)

static const struct geoinfo_t *	get_geoinfo_dataptr (GEOID geoid)

INT WINAPI	GetGeoInfoW (GEOID geoid, GEOTYPE geotype, LPWSTR data, int data_len, LANGID lang)

INT WINAPI	GetGeoInfoA (GEOID geoid, GEOTYPE geotype, LPSTR data, int data_len, LANGID lang)

Variables
HMODULE	kernel32_handle

static const WCHAR	szLocaleKeyName []

static const WCHAR	szLangGroupsKeyName []

static LCID	lcid_LC_COLLATE

static LCID	lcid_LC_CTYPE

static LCID	lcid_LC_MONETARY

static LCID	lcid_LC_NUMERIC

static LCID	lcid_LC_TIME

static LCID	lcid_LC_PAPER

static LCID	lcid_LC_MEASUREMENT

static LCID	lcid_LC_TELEPHONE

static const WCHAR	iCalendarTypeW [] = {'i','C','a','l','e','n','d','a','r','T','y','p','e',0}

static const WCHAR	iCountryW [] = {'i','C','o','u','n','t','r','y',0}

static const WCHAR	iCurrDigitsW [] = {'i','C','u','r','r','D','i','g','i','t','s',0}

static const WCHAR	iCurrencyW [] = {'i','C','u','r','r','e','n','c','y',0}

static const WCHAR	iDateW [] = {'i','D','a','t','e',0}

static const WCHAR	iDigitsW [] = {'i','D','i','g','i','t','s',0}

static const WCHAR	iFirstDayOfWeekW [] = {'i','F','i','r','s','t','D','a','y','O','f','W','e','e','k',0}

static const WCHAR	iFirstWeekOfYearW [] = {'i','F','i','r','s','t','W','e','e','k','O','f','Y','e','a','r',0}

static const WCHAR	iLDateW [] = {'i','L','D','a','t','e',0}

static const WCHAR	iLZeroW [] = {'i','L','Z','e','r','o',0}

static const WCHAR	iMeasureW [] = {'i','M','e','a','s','u','r','e',0}

static const WCHAR	iNegCurrW [] = {'i','N','e','g','C','u','r','r',0}

static const WCHAR	iNegNumberW [] = {'i','N','e','g','N','u','m','b','e','r',0}

static const WCHAR	iPaperSizeW [] = {'i','P','a','p','e','r','S','i','z','e',0}

static const WCHAR	iTLZeroW [] = {'i','T','L','Z','e','r','o',0}

static const WCHAR	iTimePrefixW [] = {'i','T','i','m','e','P','r','e','f','i','x',0}

static const WCHAR	iTimeW [] = {'i','T','i','m','e',0}

static const WCHAR	s1159W [] = {'s','1','1','5','9',0}

static const WCHAR	s2359W [] = {'s','2','3','5','9',0}

static const WCHAR	sCountryW [] = {'s','C','o','u','n','t','r','y',0}

static const WCHAR	sCurrencyW [] = {'s','C','u','r','r','e','n','c','y',0}

static const WCHAR	sDateW [] = {'s','D','a','t','e',0}

static const WCHAR	sDecimalW [] = {'s','D','e','c','i','m','a','l',0}

static const WCHAR	sGroupingW [] = {'s','G','r','o','u','p','i','n','g',0}

static const WCHAR	sLanguageW [] = {'s','L','a','n','g','u','a','g','e',0}

static const WCHAR	sListW [] = {'s','L','i','s','t',0}

static const WCHAR	sLongDateW [] = {'s','L','o','n','g','D','a','t','e',0}

static const WCHAR	sMonDecimalSepW [] = {'s','M','o','n','D','e','c','i','m','a','l','S','e','p',0}

static const WCHAR	sMonGroupingW [] = {'s','M','o','n','G','r','o','u','p','i','n','g',0}

static const WCHAR	sMonThousandSepW [] = {'s','M','o','n','T','h','o','u','s','a','n','d','S','e','p',0}

static const WCHAR	sNativeDigitsW [] = {'s','N','a','t','i','v','e','D','i','g','i','t','s',0}

static const WCHAR	sNegativeSignW [] = {'s','N','e','g','a','t','i','v','e','S','i','g','n',0}

static const WCHAR	sPositiveSignW [] = {'s','P','o','s','i','t','i','v','e','S','i','g','n',0}

static const WCHAR	sShortDateW [] = {'s','S','h','o','r','t','D','a','t','e',0}

static const WCHAR	sThousandW [] = {'s','T','h','o','u','s','a','n','d',0}

static const WCHAR	sTimeFormatW [] = {'s','T','i','m','e','F','o','r','m','a','t',0}

static const WCHAR	sTimeW [] = {'s','T','i','m','e',0}

static const WCHAR	sYearMonthW [] = {'s','Y','e','a','r','M','o','n','t','h',0}

static const WCHAR	NumShapeW [] = {'N','u','m','s','h','a','p','e',0}

static struct registry_value	registry_values []

static RTL_CRITICAL_SECTION	cache_section = { NULL, -1, 0, 0, 0, 0 }

static const struct geoinfo_t	geoinfodata []

Macro Definition Documentation

◆ LOCALE_LOCALEINFOFLAGSMASK

#define LOCALE_LOCALEINFOFLAGSMASK

Value:

(LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP|\

LOCALE_RETURN_NUMBER|LOCALE_RETURN_GENITIVE_NAMES)

LOCALE_USE_CP_ACP

#define LOCALE_USE_CP_ACP

Definition: winnls.h:20

LOCALE_NOUSEROVERRIDE

#define LOCALE_NOUSEROVERRIDE

Definition: winnls.h:19

LOCALE_RETURN_GENITIVE_NAMES

#define LOCALE_RETURN_GENITIVE_NAMES

Definition: winnls.h:24

Definition at line 48 of file lang.c.

◆ NDEBUG

#define NDEBUG

Definition at line 26 of file lang.c.

◆ NLSRC_OFFSET

#define NLSRC_OFFSET 5000 /* FIXME */

Definition at line 44 of file lang.c.

◆ REG_SZ

#define REG_SZ 1

Definition at line 35 of file lang.c.

Enumeration Type Documentation

◆ locationkind

enum locationkind

Enumerator
LOCATION_NATION
LOCATION_REGION
LOCATION_BOTH

Definition at line 2787 of file lang.c.

                  {
    LOCATION_NATION = 0,
    LOCATION_REGION,
    LOCATION_BOTH
};

Function Documentation

◆ CompareStringA()

INT WINAPI CompareStringA	(	LCID	lcid,
		DWORD	flags,
		LPCSTR	str1,
		INT	len1,
		LPCSTR	str2,
		INT	len2
	)

Definition at line 2303 of file lang.c.

{
    WCHAR *buf1W = NtCurrentTeb()->StaticUnicodeBuffer;
    WCHAR *buf2W = buf1W + 130;
    LPWSTR str1W, str2W;
    INT len1W = 0, len2W = 0, ret;
    UINT locale_cp = CP_ACP;
 
    if (!str1 || !str2)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    if (len1 < 0) len1 = strlen(str1);
    if (len2 < 0) len2 = strlen(str2);
 
    if (!(flags & LOCALE_USE_CP_ACP)) locale_cp = get_lcid_codepage( lcid );
 
    if (len1)
    {
        if (len1 <= 130) len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, buf1W, 130);
        if (len1W)
            str1W = buf1W;
        else
        {
            len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, NULL, 0);
            str1W = HeapAlloc(GetProcessHeap(), 0, len1W * sizeof(WCHAR));
            if (!str1W)
            {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return 0;
            }
            MultiByteToWideChar(locale_cp, 0, str1, len1, str1W, len1W);
        }
    }
    else
    {
        len1W = 0;
        str1W = buf1W;
    }
 
    if (len2)
    {
        if (len2 <= 130) len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, buf2W, 130);
        if (len2W)
            str2W = buf2W;
        else
        {
            len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, NULL, 0);
            str2W = HeapAlloc(GetProcessHeap(), 0, len2W * sizeof(WCHAR));
            if (!str2W)
            {
                if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return 0;
            }
            MultiByteToWideChar(locale_cp, 0, str2, len2, str2W, len2W);
        }
    }
    else
    {
        len2W = 0;
        str2W = buf2W;
    }
 
    ret = CompareStringEx(NULL, flags, str1W, len1W, str2W, len2W, NULL, NULL, 0);
 
    if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
    if (str2W != buf2W) HeapFree(GetProcessHeap(), 0, str2W);
    return ret;
}

Referenced by __crtCompareStringA(), _Locale_strcmp_auxA(), check_format(), COMCTL32_ChrCmpHelperA(), compare_line(), compare_string2(), FPropContainsProp(), get_env(), IntlStrEqWorkerA(), lstrcmpA(), lstrcmpiA(), SHLWAPI_ChrCmpHelperA(), StrCmpNA(), StrCmpNIA(), StrIsIntlEqualA(), test_CompareStringA(), test_encoders(), test_sh_new_link_info(), and UrlIsA().

◆ CompareStringEx()

INT WINAPI CompareStringEx	(	LPCWSTR	locale,
		DWORD	flags,
		LPCWSTR	str1,
		INT	len1,
		LPCWSTR	str2,
		INT	len2,
		LPNLSVERSIONINFO	version,
		LPVOID	reserved,
		LPARAM	lParam
	)

Definition at line 2232 of file lang.c.

{
    DWORD supported_flags = NORM_IGNORECASE|NORM_IGNORENONSPACE|NORM_IGNORESYMBOLS|SORT_STRINGSORT
                           |NORM_IGNOREKANATYPE|NORM_IGNOREWIDTH|LOCALE_USE_CP_ACP;
    DWORD semistub_flags = NORM_LINGUISTIC_CASING|LINGUISTIC_IGNORECASE|0x10000000;
    /* 0x10000000 is related to diacritics in Arabic, Japanese, and Hebrew */
    INT ret;
    static int once;
 
    if (version) FIXME("unexpected version parameter\n");
    if (reserved) FIXME("unexpected reserved value\n");
    if (lParam) FIXME("unexpected lParam\n");
 
    if (!str1 || !str2)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (flags & ~(supported_flags|semistub_flags))
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (flags & semistub_flags)
    {
        if (!once++)
            FIXME("semi-stub behavior for flag(s) 0x%x\n", flags & semistub_flags);
    }
 
    if (len1 < 0) len1 = strlenW(str1);
    if (len2 < 0) len2 = strlenW(str2);
 
    ret = wine_compare_string(flags, str1, len1, str2, len2);
 
    if (ret) /* need to translate result */
        return (ret < 0) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
    return CSTR_EQUAL;
}

Referenced by CompareStringA(), CompareStringW(), and InitFunctionPointers().

◆ CompareStringW()

INT WINAPI CompareStringW	(	LCID	lcid,
		DWORD	flags,
		LPCWSTR	str1,
		INT	len1,
		LPCWSTR	str2,
		INT	len2
	)

Definition at line 2279 of file lang.c.

{
    return CompareStringEx(NULL, flags, str1, len1, str2, len2, NULL, NULL, 0);
}

Referenced by __crtCompareStringW(), _WLocale_strcmp_aux(), CEnumMergedFolder::Begin(), ChrCmpIW(), COMCTL32_ChrCmpIW(), CompareData(), CEnumMergedFolder::FindByName(), HTMLElementCollection_tags(), HTTP_DealWithProxy(), HTTP_FixURL(), IntlStrEqWorkerW(), LISTBOX_lstrcmpiW(), lstrcmpiW(), lstrcmpW(), lstrncmpiW(), lstrstri(), map_type(), msi_strequal(), msi_strprefix(), MSSTYLES_ParseThemeIni(), OLEFontImpl_IsEqual(), PathCreateFromUrlW(), registry_credential_matches_filter(), Storage_DestroyElement(), StrCmpIW(), StrCmpNIW(), StrCmpNW(), StrCmpW(), StrIsIntlEqualW(), StrStrCase(), test_CompareStringW(), test_metadata_gif(), UrlIsW(), UXINI_FindSection(), UXINI_FindValue(), VarBstrCmp(), XCOPY_ParseCommandLine(), and xsltLocaleStrcmp().

◆ convert_default_lcid()

static LCID convert_default_lcid	(	LCID	lcid,
		LCTYPE	lctype
	)

static

Definition at line 519 of file lang.c.

{
    if (lcid == LOCALE_SYSTEM_DEFAULT ||
        lcid == LOCALE_USER_DEFAULT ||
        lcid == LOCALE_NEUTRAL)
    {
        LCID default_id = 0;
 
        switch(lctype & 0xffff)
        {
        case LOCALE_SSORTNAME:
            default_id = lcid_LC_COLLATE;
            break;
 
        case LOCALE_FONTSIGNATURE:
        case LOCALE_IDEFAULTANSICODEPAGE:
        case LOCALE_IDEFAULTCODEPAGE:
        case LOCALE_IDEFAULTEBCDICCODEPAGE:
        case LOCALE_IDEFAULTMACCODEPAGE:
        case LOCALE_IDEFAULTUNIXCODEPAGE:
            default_id = lcid_LC_CTYPE;
            break;
 
        case LOCALE_ICURRDIGITS:
        case LOCALE_ICURRENCY:
        case LOCALE_IINTLCURRDIGITS:
        case LOCALE_INEGCURR:
        case LOCALE_INEGSEPBYSPACE:
        case LOCALE_INEGSIGNPOSN:
        case LOCALE_INEGSYMPRECEDES:
        case LOCALE_IPOSSEPBYSPACE:
        case LOCALE_IPOSSIGNPOSN:
        case LOCALE_IPOSSYMPRECEDES:
        case LOCALE_SCURRENCY:
        case LOCALE_SINTLSYMBOL:
        case LOCALE_SMONDECIMALSEP:
        case LOCALE_SMONGROUPING:
        case LOCALE_SMONTHOUSANDSEP:
        case LOCALE_SNATIVECURRNAME:
            default_id = lcid_LC_MONETARY;
            break;
 
        case LOCALE_IDIGITS:
        case LOCALE_IDIGITSUBSTITUTION:
        case LOCALE_ILZERO:
        case LOCALE_INEGNUMBER:
        case LOCALE_SDECIMAL:
        case LOCALE_SGROUPING:
        //case LOCALE_SNAN:
        case LOCALE_SNATIVEDIGITS:
        case LOCALE_SNEGATIVESIGN:
        //case LOCALE_SNEGINFINITY:
        //case LOCALE_SPOSINFINITY:
        case LOCALE_SPOSITIVESIGN:
        case LOCALE_STHOUSAND:
            default_id = lcid_LC_NUMERIC;
            break;
 
        case LOCALE_ICALENDARTYPE:
        case LOCALE_ICENTURY:
        case LOCALE_IDATE:
        case LOCALE_IDAYLZERO:
        case LOCALE_IFIRSTDAYOFWEEK:
        case LOCALE_IFIRSTWEEKOFYEAR:
        case LOCALE_ILDATE:
        case LOCALE_IMONLZERO:
        case LOCALE_IOPTIONALCALENDAR:
        case LOCALE_ITIME:
        case LOCALE_ITIMEMARKPOSN:
        case LOCALE_ITLZERO:
        case LOCALE_S1159:
        case LOCALE_S2359:
        case LOCALE_SABBREVDAYNAME1:
        case LOCALE_SABBREVDAYNAME2:
        case LOCALE_SABBREVDAYNAME3:
        case LOCALE_SABBREVDAYNAME4:
        case LOCALE_SABBREVDAYNAME5:
        case LOCALE_SABBREVDAYNAME6:
        case LOCALE_SABBREVDAYNAME7:
        case LOCALE_SABBREVMONTHNAME1:
        case LOCALE_SABBREVMONTHNAME2:
        case LOCALE_SABBREVMONTHNAME3:
        case LOCALE_SABBREVMONTHNAME4:
        case LOCALE_SABBREVMONTHNAME5:
        case LOCALE_SABBREVMONTHNAME6:
        case LOCALE_SABBREVMONTHNAME7:
        case LOCALE_SABBREVMONTHNAME8:
        case LOCALE_SABBREVMONTHNAME9:
        case LOCALE_SABBREVMONTHNAME10:
        case LOCALE_SABBREVMONTHNAME11:
        case LOCALE_SABBREVMONTHNAME12:
        case LOCALE_SABBREVMONTHNAME13:
        case LOCALE_SDATE:
        case LOCALE_SDAYNAME1:
        case LOCALE_SDAYNAME2:
        case LOCALE_SDAYNAME3:
        case LOCALE_SDAYNAME4:
        case LOCALE_SDAYNAME5:
        case LOCALE_SDAYNAME6:
        case LOCALE_SDAYNAME7:
        //case LOCALE_SDURATION:
        case LOCALE_SLONGDATE:
        case LOCALE_SMONTHNAME1:
        case LOCALE_SMONTHNAME2:
        case LOCALE_SMONTHNAME3:
        case LOCALE_SMONTHNAME4:
        case LOCALE_SMONTHNAME5:
        case LOCALE_SMONTHNAME6:
        case LOCALE_SMONTHNAME7:
        case LOCALE_SMONTHNAME8:
        case LOCALE_SMONTHNAME9:
        case LOCALE_SMONTHNAME10:
        case LOCALE_SMONTHNAME11:
        case LOCALE_SMONTHNAME12:
        case LOCALE_SMONTHNAME13:
        case LOCALE_SSHORTDATE:
        //case LOCALE_SSHORTESTDAYNAME1:
        //case LOCALE_SSHORTESTDAYNAME2:
        //case LOCALE_SSHORTESTDAYNAME3:
        //case LOCALE_SSHORTESTDAYNAME4:
        //case LOCALE_SSHORTESTDAYNAME5:
        //case LOCALE_SSHORTESTDAYNAME6:
        //case LOCALE_SSHORTESTDAYNAME7:
        case LOCALE_STIME:
        case LOCALE_STIMEFORMAT:
        case LOCALE_SYEARMONTH:
            default_id = lcid_LC_TIME;
            break;
 
        case LOCALE_IPAPERSIZE:
            default_id = lcid_LC_PAPER;
            break;
 
        case LOCALE_IMEASURE:
            default_id = lcid_LC_MEASUREMENT;
            break;
 
        case LOCALE_ICOUNTRY:
            default_id = lcid_LC_TELEPHONE;
            break;
        }
        if (default_id) lcid = default_id;
    }
    return ConvertDefaultLocale( lcid );
}

Referenced by GetLocaleInfoW().

◆ ConvertDefaultLocale()

LCID WINAPI ConvertDefaultLocale ( LCID lcid )

Definition at line 1506 of file lang.c.

{
    LANGID langid;
 
    switch (lcid)
    {
    case LOCALE_INVARIANT:
        /* keep as-is */
        break;
    case LOCALE_SYSTEM_DEFAULT:
        lcid = GetSystemDefaultLCID();
        break;
    case LOCALE_USER_DEFAULT:
    case LOCALE_NEUTRAL:
        lcid = GetUserDefaultLCID();
        break;
    default:
        /* Replace SUBLANG_NEUTRAL with SUBLANG_DEFAULT */
        langid = LANGIDFROMLCID(lcid);
        if (SUBLANGID(langid) == SUBLANG_NEUTRAL)
        {
          langid = MAKELANGID(PRIMARYLANGID(langid), SUBLANG_DEFAULT);
          lcid = MAKELCID(langid, SORTIDFROMLCID(lcid));
        }
    }
    return lcid;
}

Referenced by convert_default_lcid(), GetLocalisedText(), LHashValOfNameSysA(), NLS_IsUnicodeOnlyLcid(), ScriptRecordDigitSubstitution(), SetThreadLocale(), test_ConvertDefaultLocale(), VarBoolFromStr(), and VarBstrFromBool().

◆ create_registry_key()

static HANDLE create_registry_key ( void )

inlinestatic

Definition at line 698 of file lang.c.

{
    static const WCHAR cplW[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l',0};
    static const WCHAR intlW[] = {'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
    OBJECT_ATTRIBUTES attr;
    UNICODE_STRING nameW;
    HANDLE cpl_key, hkey = 0;
 
    if (RtlOpenCurrentUser( KEY_ALL_ACCESS, &hkey ) != STATUS_SUCCESS) return 0;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = hkey;
    attr.ObjectName = &nameW;
    attr.Attributes = 0;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    RtlInitUnicodeString( &nameW, cplW );
 
    if (!NtCreateKey( &cpl_key, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
    {
        NtClose( attr.RootDirectory );
        attr.RootDirectory = cpl_key;
        RtlInitUnicodeString( &nameW, intlW );
        if (NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) hkey = 0;
    }
    NtClose( attr.RootDirectory );
    return hkey;
}

Referenced by get_registry_locale_info(), GetUserGeoID(), SetLocaleInfoW(), and SetUserGeoID().

◆ DEBUG_CHANNEL()

DEBUG_CHANNEL ( nls )

◆ enum_lang_proc_a()

static BOOL CALLBACK enum_lang_proc_a	(	HMODULE	hModule,
		LPCSTR	type,
		LPCSTR	name,
		WORD	LangID,
		LONG_PTR	lParam
	)

static

Definition at line 1560 of file lang.c.

{
    LOCALE_ENUMPROCA lpfnLocaleEnum = (LOCALE_ENUMPROCA)lParam;
    char buf[20];
 
    sprintf(buf, "%08x", (UINT)LangID);
    return lpfnLocaleEnum( buf );
}

Referenced by EnumSystemLocalesA().

◆ enum_lang_proc_w()

static BOOL CALLBACK enum_lang_proc_w	(	HMODULE	hModule,
		LPCWSTR	type,
		LPCWSTR	name,
		WORD	LangID,
		LONG_PTR	lParam
	)

static

Definition at line 1570 of file lang.c.

{
    static const WCHAR formatW[] = {'%','0','8','x',0};
    LOCALE_ENUMPROCW lpfnLocaleEnum = (LOCALE_ENUMPROCW)lParam;
    WCHAR buf[20];
    sprintfW( buf, formatW, (UINT)LangID );
    return lpfnLocaleEnum( buf );
}

Referenced by EnumSystemLocalesW().

◆ enum_locale_ex_proc()

static BOOL CALLBACK enum_locale_ex_proc	(	HMODULE	module,
		LPCWSTR	type,
		LPCWSTR	name,
		WORD	lang,
		LONG_PTR	lparam
	)

static

Definition at line 1625 of file lang.c.

{
    struct enum_locale_ex_data *data = (struct enum_locale_ex_data *)lparam;
    WCHAR buffer[256];
    DWORD neutral;
    unsigned int flags;
 
    GetLocaleInfoW( MAKELCID( lang, SORT_DEFAULT ), LOCALE_SNAME | LOCALE_NOUSEROVERRIDE,
                    buffer, ARRAY_SIZE( buffer ));
    if (!GetLocaleInfoW( MAKELCID( lang, SORT_DEFAULT ),
                         LOCALE_INEUTRAL | LOCALE_NOUSEROVERRIDE | LOCALE_RETURN_NUMBER,
                         (LPWSTR)&neutral, sizeof(neutral) / sizeof(WCHAR) ))
        neutral = 0;
    flags = LOCALE_WINDOWS;
    flags |= neutral ? LOCALE_NEUTRALDATA : LOCALE_SPECIFICDATA;
    if (data->flags && !(data->flags & flags)) return TRUE;
    return data->proc( buffer, flags, data->lparam );
}

Referenced by EnumSystemLocalesEx().

◆ enum_uilang_proc_a()

static BOOL CALLBACK enum_uilang_proc_a	(	HMODULE	hModule,
		LPCSTR	type,
		LPCSTR	name,
		WORD	LangID,
		LONG_PTR	lParam
	)

static

Definition at line 3431 of file lang.c.

{
    ENUM_UILANG_CALLBACK *enum_uilang = (ENUM_UILANG_CALLBACK *)lParam;
    char buf[20];
 
    sprintf(buf, "%08x", (UINT)LangID);
    return enum_uilang->u.procA( buf, enum_uilang->param );
}

Referenced by EnumUILanguagesA().

◆ enum_uilang_proc_w()

static BOOL CALLBACK enum_uilang_proc_w	(	HMODULE	hModule,
		LPCWSTR	type,
		LPCWSTR	name,
		WORD	LangID,
		LONG_PTR	lParam
	)

static

Definition at line 3441 of file lang.c.

{
    static const WCHAR formatW[] = {'%','0','8','x',0};
    ENUM_UILANG_CALLBACK *enum_uilang = (ENUM_UILANG_CALLBACK *)lParam;
    WCHAR buf[20];
 
    sprintfW( buf, formatW, (UINT)LangID );
    return enum_uilang->u.procW( buf, enum_uilang->param );
}

Referenced by EnumUILanguagesW().

◆ EnumLanguageGroupLocalesA()

BOOL WINAPI EnumLanguageGroupLocalesA	(	LANGGROUPLOCALE_ENUMPROCA	pLangGrpLcEnumProc,
		LGRPID	lgrpid,
		DWORD	dwFlags,
		LONG_PTR	lParam
	)

Definition at line 3119 of file lang.c.

{
    ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
 
    TRACE("(%p,0x%08X,0x%08X,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
 
    callbacks.procA   = pLangGrpLcEnumProc;
    callbacks.procW   = NULL;
    callbacks.dwFlags = dwFlags;
    callbacks.lgrpid  = lgrpid;
    callbacks.lParam  = lParam;
 
    return NLS_EnumLanguageGroupLocales( pLangGrpLcEnumProc ? &callbacks : NULL );
}

Referenced by InitFunctionPointers(), and test_digit_substitution().

◆ EnumLanguageGroupLocalesW()

BOOL WINAPI EnumLanguageGroupLocalesW	(	LANGGROUPLOCALE_ENUMPROCW	pLangGrpLcEnumProc,
		LGRPID	lgrpid,
		DWORD	dwFlags,
		LONG_PTR	lParam
	)

Definition at line 3140 of file lang.c.

{
    ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
 
    TRACE("(%p,0x%08X,0x%08X,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
 
    callbacks.procA   = NULL;
    callbacks.procW   = pLangGrpLcEnumProc;
    callbacks.dwFlags = dwFlags;
    callbacks.lgrpid  = lgrpid;
    callbacks.lParam  = lParam;
 
    return NLS_EnumLanguageGroupLocales( pLangGrpLcEnumProc ? &callbacks : NULL );
}

◆ EnumSystemCodePagesA()

BOOL WINAPI EnumSystemCodePagesA	(	CODEPAGE_ENUMPROCA	lpCodePageEnumProc,
		DWORD	dwFlags
	)

Definition at line 3257 of file lang.c.

{
    ENUMSYSTEMCODEPAGES_CALLBACKS procs;
 
    TRACE("(%p,0x%08X)\n", lpCodePageEnumProc, dwFlags);
 
    procs.procA = lpCodePageEnumProc;
    procs.procW = NULL;
    procs.dwFlags = dwFlags;
 
    return NLS_EnumSystemCodePages(lpCodePageEnumProc ? &procs : NULL);
}

◆ EnumSystemCodePagesW()

BOOL WINAPI EnumSystemCodePagesW	(	CODEPAGE_ENUMPROCW	lpCodePageEnumProc,
		DWORD	dwFlags
	)

Definition at line 3235 of file lang.c.

{
    ENUMSYSTEMCODEPAGES_CALLBACKS procs;
 
    TRACE("(%p,0x%08X)\n", lpCodePageEnumProc, dwFlags);
 
    procs.procA = NULL;
    procs.procW = lpCodePageEnumProc;
    procs.dwFlags = dwFlags;
 
    return NLS_EnumSystemCodePages(lpCodePageEnumProc ? &procs : NULL);
}

Referenced by InitCodePagesList().

◆ EnumSystemGeoID()

BOOL WINAPI EnumSystemGeoID	(	GEOCLASS	geoclass,
		GEOID	parent,
		GEO_ENUMPROC	enumproc
	)

Definition at line 3287 of file lang.c.

{
    INT i;
 
    TRACE("(%d, %d, %p)\n", geoclass, parent, enumproc);
 
    if (!enumproc) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (geoclass != GEOCLASS_NATION && geoclass != GEOCLASS_REGION) {
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    for (i = 0; i < sizeof(geoinfodata)/sizeof(struct geoinfo_t); i++) {
        const struct geoinfo_t *ptr = &geoinfodata[i];
 
        if (geoclass == GEOCLASS_NATION && (ptr->kind == LOCATION_REGION))
            continue;
 
        if (geoclass == GEOCLASS_REGION && (ptr->kind == LOCATION_NATION))
            continue;
 
        if (parent && ptr->parent != parent)
            continue;
 
        if (!enumproc(ptr->id))
            return TRUE;
    }
 
    return TRUE;
}

Referenced by CreateLocationsList(), and InitFunctionPointers().

◆ EnumSystemLanguageGroupsA()

BOOL WINAPI EnumSystemLanguageGroupsA	(	LANGUAGEGROUP_ENUMPROCA	pLangGrpEnumProc,
		DWORD	dwFlags,
		LONG_PTR	lParam
	)

Definition at line 2603 of file lang.c.

{
    ENUMLANGUAGEGROUP_CALLBACKS procs;
 
    TRACE("(%p,0x%08X,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
 
    procs.procA = pLangGrpEnumProc;
    procs.procW = NULL;
    procs.dwFlags = dwFlags;
    procs.lParam = lParam;
 
    return NLS_EnumSystemLanguageGroups( pLangGrpEnumProc ? &procs : NULL);
}

Referenced by InitFunctionPointers().

◆ EnumSystemLanguageGroupsW()

BOOL WINAPI EnumSystemLanguageGroupsW	(	LANGUAGEGROUP_ENUMPROCW	pLangGrpEnumProc,
		DWORD	dwFlags,
		LONG_PTR	lParam
	)

Definition at line 2623 of file lang.c.

{
    ENUMLANGUAGEGROUP_CALLBACKS procs;
 
    TRACE("(%p,0x%08X,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
 
    procs.procA = NULL;
    procs.procW = pLangGrpEnumProc;
    procs.dwFlags = dwFlags;
    procs.lParam = lParam;
 
    return NLS_EnumSystemLanguageGroups( pLangGrpEnumProc ? &procs : NULL);
}

◆ EnumSystemLocalesA()

BOOL WINAPI EnumSystemLocalesA	(	LOCALE_ENUMPROCA	lpfnLocaleEnum,
		DWORD	dwFlags
	)

Definition at line 1593 of file lang.c.

{
    TRACE("(%p,%08x)\n", lpfnLocaleEnum, dwFlags);
    EnumResourceLanguagesA( kernel32_handle, (LPSTR)RT_STRING,
                            (LPCSTR)LOCALE_ILANGUAGE, enum_lang_proc_a,
                            (LONG_PTR)lpfnLocaleEnum);
    return TRUE;
}

Referenced by __GetLCID().

◆ EnumSystemLocalesEx()

BOOL WINAPI EnumSystemLocalesEx	(	LOCALE_ENUMPROCEX	proc,
		DWORD	flags,
		LPARAM	lparam,
		LPVOID	reserved
	)

Definition at line 1648 of file lang.c.

{
    struct enum_locale_ex_data data;
 
    if (reserved)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    data.proc   = proc;
    data.flags  = flags;
    data.lparam = lparam;
    EnumResourceLanguagesW( kernel32_handle, (LPCWSTR)RT_STRING,
                            (LPCWSTR)MAKEINTRESOURCE((LOCALE_SNAME >> 4) + 1),
                            enum_locale_ex_proc, (LONG_PTR)&data );
    return TRUE;
}

Referenced by InitFunctionPointers().

◆ EnumSystemLocalesW()

BOOL WINAPI EnumSystemLocalesW	(	LOCALE_ENUMPROCW	lpfnLocaleEnum,
		DWORD	dwFlags
	)

Definition at line 1608 of file lang.c.

{
    TRACE("(%p,%08x)\n", lpfnLocaleEnum, dwFlags);
    EnumResourceLanguagesW( kernel32_handle, (LPWSTR)RT_STRING,
                            (LPCWSTR)LOCALE_ILANGUAGE, enum_lang_proc_w,
                            (LONG_PTR)lpfnLocaleEnum);
    return TRUE;
}

Referenced by CreateLanguagesList(), CreateSortList(), EnumRfc1766_create(), InitLanguagesList(), and IsSortPageNeeded().

◆ EnumUILanguagesA()

BOOL WINAPI EnumUILanguagesA	(	UILANGUAGE_ENUMPROCA	pUILangEnumProc,
		DWORD	dwFlags,
		LONG_PTR	lParam
	)

Definition at line 3455 of file lang.c.

{
    ENUM_UILANG_CALLBACK enum_uilang;
 
    TRACE("%p, %x, %lx\n", pUILangEnumProc, dwFlags, lParam);
 
    if(!pUILangEnumProc) {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
    }
    if(dwFlags) {
    SetLastError(ERROR_INVALID_FLAGS);
    return FALSE;
    }
 
    enum_uilang.u.procA = pUILangEnumProc;
    enum_uilang.flags = dwFlags;
    enum_uilang.param = lParam;
 
    EnumResourceLanguagesA( kernel32_handle, (LPCSTR)RT_STRING,
                            (LPCSTR)LOCALE_ILANGUAGE, enum_uilang_proc_a,
                            (LONG_PTR)&enum_uilang);
    return TRUE;
}

Referenced by InitFunctionPointers().

◆ EnumUILanguagesW()

BOOL WINAPI EnumUILanguagesW	(	UILANGUAGE_ENUMPROCW	pUILangEnumProc,
		DWORD	dwFlags,
		LONG_PTR	lParam
	)

Definition at line 3483 of file lang.c.

{
    ENUM_UILANG_CALLBACK enum_uilang;
 
    TRACE("%p, %x, %lx\n", pUILangEnumProc, dwFlags, lParam);
 
 
    if(!pUILangEnumProc) {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
    }
    if(dwFlags) {
    SetLastError(ERROR_INVALID_FLAGS);
    return FALSE;
    }
 
    enum_uilang.u.procW = pUILangEnumProc;
    enum_uilang.flags = dwFlags;
    enum_uilang.param = lParam;
 
    EnumResourceLanguagesW( kernel32_handle, (LPCWSTR)RT_STRING,
                            (LPCWSTR)LOCALE_ILANGUAGE, enum_uilang_proc_w,
                            (LONG_PTR)&enum_uilang);
    return TRUE;
}

◆ FoldStringA()

INT WINAPI FoldStringA	(	DWORD	dwFlags,
		LPCSTR	src,
		INT	srclen,
		LPSTR	dst,
		INT	dstlen
	)

Definition at line 2141 of file lang.c.

{
    INT ret = 0, srclenW = 0;
    WCHAR *srcW = NULL, *dstW = NULL;
 
    if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    srclenW = MultiByteToWideChar(CP_ACP, dwFlags & MAP_COMPOSITE ? MB_COMPOSITE : 0,
                                  src, srclen, NULL, 0);
    srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
 
    if (!srcW)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto FoldStringA_exit;
    }
 
    MultiByteToWideChar(CP_ACP, dwFlags & MAP_COMPOSITE ? MB_COMPOSITE : 0,
                        src, srclen, srcW, srclenW);
 
    dwFlags = (dwFlags & ~MAP_PRECOMPOSED) | MAP_FOLDCZONE;
 
    ret = FoldStringW(dwFlags, srcW, srclenW, NULL, 0);
    if (ret && dstlen)
    {
        dstW = HeapAlloc(GetProcessHeap(), 0, ret * sizeof(WCHAR));
 
        if (!dstW)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto FoldStringA_exit;
        }
 
        ret = FoldStringW(dwFlags, srcW, srclenW, dstW, ret);
        if (!WideCharToMultiByte(CP_ACP, 0, dstW, ret, dst, dstlen, NULL, NULL))
        {
            ret = 0;
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
        }
    }
 
    HeapFree(GetProcessHeap(), 0, dstW);
 
FoldStringA_exit:
    HeapFree(GetProcessHeap(), 0, srcW);
    return ret;
}

Referenced by InitFunctionPointers().

◆ FoldStringW()

INT WINAPI FoldStringW	(	DWORD	dwFlags,
		LPCWSTR	src,
		INT	srclen,
		LPWSTR	dst,
		INT	dstlen
	)

Definition at line 2199 of file lang.c.

{
    int ret;
 
    switch (dwFlags & (MAP_COMPOSITE|MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES))
    {
    case 0:
        if (dwFlags)
          break;
        /* Fall through for dwFlags == 0 */
    case MAP_PRECOMPOSED|MAP_COMPOSITE:
    case MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES:
    case MAP_COMPOSITE|MAP_EXPAND_LIGATURES:
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    ret = wine_fold_string(dwFlags, src, srclen, dst, dstlen);
    if (!ret)
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
    return ret;
}

Referenced by FoldStringA(), IdnToNameprepUnicode(), and InitFunctionPointers().

◆ get_geoinfo_dataptr()

static const struct geoinfo_t * get_geoinfo_dataptr ( GEOID geoid )

static

Definition at line 3537 of file lang.c.

{
    int min, max;
 
    min = 0;
    max = sizeof(geoinfodata)/sizeof(struct geoinfo_t)-1;
 
    while (min <= max) {
        const struct geoinfo_t *ptr;
        int n = (min+max)/2;
 
        ptr = &geoinfodata[n];
        if (geoid == ptr->id)
            /* we don't need empty entry */
            return *ptr->iso2W ? ptr : NULL;
 
        if (ptr->id > geoid)
            max = n-1;
        else
            min = n+1;
    }
 
    return NULL;
}

Referenced by GetGeoInfoW().

◆ get_lcid_codepage()

static UINT get_lcid_codepage ( LCID lcid )

inlinestatic

Definition at line 264 of file lang.c.

{
    UINT ret;
    if (!GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER, (WCHAR *)&ret,
                         sizeof(ret)/sizeof(WCHAR) )) ret = 0;
    return ret;
}

Referenced by CompareStringA(), GetLocaleInfoA(), GetStringTypeA(), LCMapStringA(), and SetLocaleInfoA().

◆ get_locale_registry_value()

static struct registry_value * get_locale_registry_value ( DWORD lctype )

static

Definition at line 1088 of file lang.c.

{
    int i;
    for (i=0; i < sizeof(registry_values)/sizeof(registry_values[0]); i++)
        if (registry_values[i].lctype == lctype)
            return &registry_values[i];
    return NULL;
}

Referenced by GetLocaleInfoW(), and SetLocaleInfoW().

◆ get_registry_locale_info()

static INT get_registry_locale_info	(	struct registry_value *	registry_value,
		LPWSTR	buffer,
		INT	len
	)

static

Definition at line 890 of file lang.c.

{
    DWORD size;
    INT ret;
    HANDLE hkey;
    NTSTATUS status;
    UNICODE_STRING nameW;
    KEY_VALUE_PARTIAL_INFORMATION *info;
    static const int info_size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
 
    RtlEnterCriticalSection( &cache_section );
 
    if (!registry_value->cached_value)
    {
        if (!(hkey = create_registry_key()))
        {
            RtlLeaveCriticalSection( &cache_section );
            return -1;
        }
 
        RtlInitUnicodeString( &nameW, registry_value->name );
        size = info_size + len * sizeof(WCHAR);
 
        if (!(info = HeapAlloc( GetProcessHeap(), 0, size )))
        {
            NtClose( hkey );
            SetLastError( ERROR_NOT_ENOUGH_MEMORY );
            RtlLeaveCriticalSection( &cache_section );
            return 0;
        }
 
        status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, info, size, &size );
 
        /* try again with a bigger buffer when we have to return the correct size */
        if (status == STATUS_BUFFER_OVERFLOW && !buffer && size > info_size)
        {
            KEY_VALUE_PARTIAL_INFORMATION *new_info;
            if ((new_info = HeapReAlloc( GetProcessHeap(), 0, info, size )))
            {
                info = new_info;
                status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, info, size, &size );
            }
        }
 
        NtClose( hkey );
 
        if (!status)
        {
            INT length = (size - info_size) / sizeof(WCHAR);
            LPWSTR cached_value;
 
            if (!length || ((WCHAR *)&info->Data)[length-1])
                length++;
 
            cached_value = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
 
            if (!cached_value)
            {
                HeapFree( GetProcessHeap(), 0, info );
                SetLastError( ERROR_NOT_ENOUGH_MEMORY );
                RtlLeaveCriticalSection( &cache_section );
                return 0;
            }
 
            memcpy( cached_value, info->Data, (length-1) * sizeof(WCHAR) );
            cached_value[length-1] = 0;
            HeapFree( GetProcessHeap(), 0, info );
            registry_value->cached_value = cached_value;
        }
        else
        {
            if (status == STATUS_BUFFER_OVERFLOW && !buffer)
            {
                ret = (size - info_size) / sizeof(WCHAR);
            }
            else if (status == STATUS_OBJECT_NAME_NOT_FOUND)
            {
                ret = -1;
            }
            else
            {
                SetLastError( RtlNtStatusToDosError(status) );
                ret = 0;
            }
            HeapFree( GetProcessHeap(), 0, info );
            RtlLeaveCriticalSection( &cache_section );
            return ret;
        }
    }
 
    ret = lstrlenW( registry_value->cached_value ) + 1;
 
    if (buffer)
    {
        if (ret > len)
        {
            SetLastError( ERROR_INSUFFICIENT_BUFFER );
            ret = 0;
        }
        else
        {
            lstrcpyW( buffer, registry_value->cached_value );
        }
    }
 
    RtlLeaveCriticalSection( &cache_section );
 
    return ret;
}

Referenced by GetLocaleInfoW().

◆ get_value_base_by_lctype()

static int get_value_base_by_lctype ( LCTYPE lctype )

static

Definition at line 1078 of file lang.c.

{
    return lctype == LOCALE_ILANGUAGE || lctype == LOCALE_IDEFAULTLANGUAGE ? 16 : 10;
}

Referenced by GetLocaleInfoW().

◆ GetGeoInfoA()

INT WINAPI GetGeoInfoA	(	GEOID	geoid,
		GEOTYPE	geotype,
		LPSTR	data,
		int	data_len,
		LANGID	lang
	)

Definition at line 3639 of file lang.c.

{
    WCHAR *buffW;
    INT len;
 
    TRACE("%d %d %p %d %d\n", geoid, geotype, data, data_len, lang);
 
    len = GetGeoInfoW(geoid, geotype, NULL, 0, lang);
    if (!len)
        return 0;
 
    buffW = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
    if (!buffW)
        return 0;
 
    GetGeoInfoW(geoid, geotype, buffW, len, lang);
    len = WideCharToMultiByte(CP_ACP, 0, buffW, -1, NULL, 0, NULL, NULL);
    if (!data || !data_len) {
        HeapFree(GetProcessHeap(), 0, buffW);
        return len;
    }
 
    len = WideCharToMultiByte(CP_ACP, 0, buffW, -1, data, data_len, NULL, NULL);
    HeapFree(GetProcessHeap(), 0, buffW);
 
    if (data_len < len)
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
    return data_len < len ? 0 : len;
}

Referenced by InitFunctionPointers().

◆ GetGeoInfoW()

INT WINAPI GetGeoInfoW	(	GEOID	geoid,
		GEOTYPE	geotype,
		LPWSTR	data,
		int	data_len,
		LANGID	lang
	)

Definition at line 3565 of file lang.c.

{
    const struct geoinfo_t *ptr;
    const WCHAR *str = NULL;
    WCHAR buffW[12];
    LONG val = 0;
    INT len;
 
    TRACE("%d %d %p %d %d\n", geoid, geotype, data, data_len, lang);
 
    if (!(ptr = get_geoinfo_dataptr(geoid))) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    switch (geotype) {
    case GEO_FRIENDLYNAME:
    {
#ifdef __REACTOS__
        return NLS_GetGeoFriendlyName(geoid, data, data_len, lang);
#else
        return NLS_GetGeoFriendlyName(geoid, data, data_len);
#endif
    }
    case GEO_NATION:
        val = geoid;
        break;
    case GEO_ISO_UN_NUMBER:
        val = ptr->uncode;
        break;
    case GEO_PARENT:
        val = ptr->parent;
        break;
    case GEO_ISO2:
    case GEO_ISO3:
    {
        str = geotype == GEO_ISO2 ? ptr->iso2W : ptr->iso3W;
        break;
    }
    case GEO_RFC1766:
    case GEO_LCID:
    case GEO_OFFICIALNAME:
    case GEO_TIMEZONES:
    case GEO_OFFICIALLANGUAGES:
    case GEO_LATITUDE:
    case GEO_LONGITUDE:
        FIXME("type %d is not supported\n", geotype);
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return 0;
    default:
        WARN("unrecognized type %d\n", geotype);
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (val) {
        static const WCHAR fmtW[] = {'%','d',0};
        sprintfW(buffW, fmtW, val);
        str = buffW;
    }
 
    len = strlenW(str) + 1;
    if (!data || !data_len)
        return len;
 
    memcpy(data, str, min(len, data_len)*sizeof(WCHAR));
    if (data_len < len)
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
    return data_len < len ? 0 : len;
}

Referenced by CreateLocationsList(), GetGeoInfoA(), InitFunctionPointers(), LocationsEnumProc(), and SetUserLocaleName().

◆ GetLocaleInfoA()

INT WINAPI GetLocaleInfoA	(	LCID	lcid,
		LCTYPE	lctype,
		LPSTR	buffer,
		INT	len
	)

Definition at line 1022 of file lang.c.

{
    WCHAR *bufferW;
    INT lenW, ret;
 
    TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d)\n", lcid, lctype, buffer, len );
 
    if (len < 0 || (len && !buffer))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (((lctype & ~LOCALE_LOCALEINFOFLAGSMASK) == LOCALE_SSHORTTIME) ||
         (lctype & LOCALE_RETURN_GENITIVE_NAMES))
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (!len) buffer = NULL;
 
    if (!(lenW = GetLocaleInfoW( lcid, lctype, NULL, 0 ))) return 0;
 
    if (!(bufferW = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return 0;
    }
    if ((ret = GetLocaleInfoW( lcid, lctype, bufferW, lenW )))
    {
        if ((lctype & LOCALE_RETURN_NUMBER) ||
            ((lctype & ~LOCALE_LOCALEINFOFLAGSMASK) == LOCALE_FONTSIGNATURE))
        {
            /* it's not an ASCII string, just bytes */
            ret *= sizeof(WCHAR);
            if (buffer)
            {
                if (ret <= len) memcpy( buffer, bufferW, ret );
                else
                {
                    SetLastError( ERROR_INSUFFICIENT_BUFFER );
                    ret = 0;
                }
            }
        }
        else
        {
            UINT codepage = CP_ACP;
            if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
            ret = WideCharToMultiByte( codepage, 0, bufferW, ret, buffer, len, NULL, NULL );
        }
    }
    HeapFree( GetProcessHeap(), 0, bufferW );
    return ret;
}

Referenced by __GetLocaleInfoUsingACP(), __GetLocaleName(), __intGetACP(), __intGetOCP(), _Locale_monetary_create(), _Locale_n_cs_precedes(), _Locale_n_sep_by_space(), _Locale_n_sign_posn(), _Locale_numeric_create(), _Locale_p_cs_precedes(), _Locale_p_sep_by_space(), _Locale_p_sign_posn(), _Locale_time_create(), compare_info(), detect_locale(), DosGetCountryInfo(), EnumLocalesProcA(), filetime_to_str(), is_rtl(), lcid_to_rfc1766A(), lineGetTranslateCapsA(), MSVCRT__create_locale(), MSVCRT_locale_to_LCID(), NLS_EnumDateFormats(), NLS_EnumTimeFormats(), START_TEST(), test__Gettnames(), test_EM_POSFROMCHAR(), test_EM_SETCHARFORMAT(), test_EnumDateFormatsA(), test_EnumTimeFormatsA(), test_EnumTimeFormatsW(), test_firstDay(), test_GetAcceptLanguagesA(), test_GetLocaleInfoA(), test_GetLocaleInfoW(), test_hittest(), test_invariant(), test_setlocale(), test_threadcp(), test_VarAbs(), test_VarCat(), test_VarFormat(), test_VarFormatNumber(), test_VarRound(), test_wm_set_get_text(), update_threadlocinfo_category(), and VerLanguageNameA().

◆ GetLocaleInfoW()

INT WINAPI GetLocaleInfoW	(	LCID	lcid,
		LCTYPE	lctype,
		LPWSTR	buffer,
		INT	len
	)

Definition at line 1102 of file lang.c.

{
    LANGID lang_id;
    HRSRC hrsrc;
    HGLOBAL hmem;
    LPCWSTR lpType, lpName;
    INT ret;
    UINT lcflags;
    const WCHAR *p;
    unsigned int i;
 
    if (len < 0 || (len && !buffer))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (lctype & LOCALE_RETURN_GENITIVE_NAMES &&
       !is_genitive_name_supported( lctype ))
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (!len) buffer = NULL;
 
    lcid = convert_default_lcid( lcid, lctype );
 
    lcflags = lctype & LOCALE_LOCALEINFOFLAGSMASK;
    lctype &= 0xffff;
 
    TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d)\n", lcid, lctype, buffer, len );
 
    /* first check for overrides in the registry */
 
    if (!(lcflags & LOCALE_NOUSEROVERRIDE) &&
        lcid == convert_default_lcid( LOCALE_USER_DEFAULT, lctype ))
    {
        struct registry_value *value = get_locale_registry_value(lctype);
 
        if (value)
        {
            if (lcflags & LOCALE_RETURN_NUMBER)
            {
                WCHAR tmp[16];
                ret = get_registry_locale_info( value, tmp, sizeof(tmp)/sizeof(WCHAR) );
                if (ret > 0)
                {
                    WCHAR *end;
                    UINT number = strtolW( tmp, &end, get_value_base_by_lctype( lctype ) );
                    if (*end)  /* invalid number */
                    {
                        SetLastError( ERROR_INVALID_FLAGS );
                        return 0;
                    }
                    ret = sizeof(UINT)/sizeof(WCHAR);
                    if (!buffer) return ret;
                    if (ret > len)
                    {
                        SetLastError( ERROR_INSUFFICIENT_BUFFER );
                        return 0;
                    }
                    memcpy( buffer, &number, sizeof(number) );
                }
            }
            else ret = get_registry_locale_info( value, buffer, len );
 
            if (ret != -1) return ret;
        }
    }
 
    /* now load it from kernel resources */
 
    lang_id = LANGIDFROMLCID( lcid );
 
    /* replace SUBLANG_NEUTRAL by SUBLANG_DEFAULT */
    if (SUBLANGID(lang_id) == SUBLANG_NEUTRAL)
        lang_id = MAKELANGID(PRIMARYLANGID(lang_id), SUBLANG_DEFAULT);
 
    if (lctype != LOCALE_FONTSIGNATURE)
    {
        lpType = MAKEINTRESOURCEW(RT_STRING);
        lpName = MAKEINTRESOURCEW(ULongToPtr((lctype >> 4) + 1));
    }
    else
    {
        lpType = MAKEINTRESOURCEW(RT_RCDATA);
        lpName = MAKEINTRESOURCEW(lctype);
    }
 
    if (!(hrsrc = FindResourceExW( kernel32_handle, lpType, lpName, lang_id )))
    {
        SetLastError( ERROR_INVALID_FLAGS );  /* no such lctype */
        return 0;
    }
    if (!(hmem = LoadResource( kernel32_handle, hrsrc )))
        return 0;
 
    p = LockResource( hmem );
    if (lctype != LOCALE_FONTSIGNATURE)
    {
        for (i = 0; i < (lctype & 0x0f); i++) p += *p + 1;
    }
 
    if (lcflags & LOCALE_RETURN_NUMBER) ret = sizeof(UINT)/sizeof(WCHAR);
    else if (is_genitive_name_supported( lctype ) && *p)
    {
        /* genitive form's stored after a null separator from a nominative */
        for (i = 1; i <= *p; i++) if (!p[i]) break;
 
        if (i <= *p && (lcflags & LOCALE_RETURN_GENITIVE_NAMES))
        {
            ret = *p - i + 1;
            p += i;
        }
        else ret = i;
    }
    else if (lctype != LOCALE_FONTSIGNATURE)
        ret = *p + 1;
    else
        ret = SizeofResource(kernel32_handle, hrsrc) / sizeof(WCHAR);
 
    if (!buffer) return ret;
 
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
 
    if (lcflags & LOCALE_RETURN_NUMBER)
    {
        UINT number;
        WCHAR *end, *tmp = HeapAlloc( GetProcessHeap(), 0, (*p + 1) * sizeof(WCHAR) );
        if (!tmp) return 0;
        memcpy( tmp, p + 1, *p * sizeof(WCHAR) );
        tmp[*p] = 0;
        number = strtolW( tmp, &end, get_value_base_by_lctype( lctype ) );
        if (!*end)
            memcpy( buffer, &number, sizeof(number) );
        else  /* invalid number */
        {
            SetLastError( ERROR_INVALID_FLAGS );
            ret = 0;
        }
        HeapFree( GetProcessHeap(), 0, tmp );
 
        TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning number %d\n",
               lcid, lctype, buffer, len, number );
    }
    else
    {
        if (lctype != LOCALE_FONTSIGNATURE) p++;
        memcpy( buffer, p, ret * sizeof(WCHAR) );
        if (lctype != LOCALE_FONTSIGNATURE) buffer[ret-1] = 0;
 
        TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning %d %s\n",
               lcid, lctype, buffer, len, ret, debugstr_w(buffer) );
    }
    return ret;
}

Referenced by __crtGetLocaleInfoW(), _WLocale_abbrev_dayofweek(), _WLocale_abbrev_monthname(), _WLocale_am_str(), _WLocale_currency_symbol(), _WLocale_decimal_point(), _WLocale_full_dayofweek(), _WLocale_full_monthname(), _WLocale_int_curr_symbol(), _WLocale_negative_sign(), _WLocale_pm_str(), _WLocale_positive_sign(), _WLocale_thousands_sep(), AboutDlgProc(), add_cert_to_list(), add_cert_to_view(), add_date_string_to_control(), AddCommasW(), AddNewKbLayoutsByLcid(), AddNewLayout(), AllSysInfo(), CConfigParser::CacheINI(), create_utc_string(), CreateLanguagesList(), CreateLayoutIcon(), CreateSortList(), date_parse(), date_to_string(), dateobj_to_date_string(), DATETIME_GetFieldWidth(), DATETIME_ReturnTxt(), DATETIME_SetFormatW(), detect_locale(), enum_locale_ex_proc(), enum_locales_proc(), fill_language_information(), FillMonthsComboBox(), FillNumberFmt(), fnIMultiLanguage3_GetRfc1766Info(), fnIMultiLanguage_GetRfc1766Info(), format_long_date(), format_size(), FormatInteger(), GeneralPropertyPageLocalesEnumProc(), get_countrycode(), get_date_format(), get_decimal_sep(), get_input_codepage(), get_lcid_codepage(), get_locale(), GetCalendarInfoW(), GetCurrencyFormatW(), GetFileVersion(), GetLocaleInfoA(), GetNumberFormatW(), InitializeDefaultUserLocale(), InitLanguagesList(), InputList_Add(), InputList_Create(), IntGetCodePageEntry(), is_default_metric(), IsLayoutExists(), lcid_to_rfc1766W(), LocaleList_Create(), LocalesEnumProc(), MONTHCAL_LButtonDown(), MONTHCAL_PaintTitle(), MONTHCAL_SetFirstDayOfWeek(), MonthCalFirstDayOfWeek(), MonthCalReload(), MSVCRT__create_locale(), NLS_EnumCalendarInfo(), NLS_EnumDateFormats(), NLS_EnumTimeFormats(), NLS_GetLocaleNumber(), NLS_GetLocaleString(), ParseDate(), ReadChmSystem(), SaveFontSubstitutionSettings(), SaveSystemSettings(), ScriptRecordDigitSubstitution(), SetUserLocaleName(), SH_FormatInteger(), SortEnumProc(), START_TEST(), test_EnumTimeFormatsW(), test_GetLocaleInfoEx(), test_GetLocaleInfoW(), test_unicode_wm_char(), test_VarWeekdayName(), TranslateCharsetInfo(), UPDOWN_GetThousandSep(), VarBstrFromDate(), VarDateFromStr(), VarFormatCurrency(), VarFormatNumber(), VARIANT_BstrReplaceDecimal(), VARIANT_FormatDate(), VARIANT_FormatNumber(), VARIANT_GetLocalisedNumberChars(), VarMonthName(), VarWeekdayName(), VerLanguageNameW(), and WriteUserLocale().

◆ GetLocalisedText()

UINT GetLocalisedText	(	IN UINT	uID,
		IN LPWSTR	lpszDest,
		IN UINT	cchDest
	)

Referenced by NLS_GetGeoFriendlyName().

◆ GetStringTypeA()

BOOL WINAPI GetStringTypeA	(	LCID	locale,
		DWORD	type,
		LPCSTR	src,
		INT	count,
		LPWORD	chartype
	)

Definition at line 1817 of file lang.c.

{
    UINT cp;
    INT countW;
    LPWSTR srcW;
    BOOL ret = FALSE;
 
    if(count == -1) count = strlen(src) + 1;
 
    if (!(cp = get_lcid_codepage( locale )))
    {
        FIXME("For locale %04x using current ANSI code page\n", locale);
        cp = GetACP();
    }
 
    countW = MultiByteToWideChar(cp, 0, src, count, NULL, 0);
    if((srcW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
    {
        MultiByteToWideChar(cp, 0, src, count, srcW, countW);
    /*
     * NOTE: the target buffer has 1 word for each CHARACTER in the source
     * string, with multibyte characters there maybe be more bytes in count
     * than character space in the buffer!
     */
        ret = GetStringTypeW(type, srcW, countW, chartype);
        HeapFree(GetProcessHeap(), 0, srcW);
    }
    return ret;
}

Referenced by _Locale_ctype_create(), GetStringTypeExA(), IsCharSpaceA(), and MSVCRT__create_locale().

◆ GetStringTypeExA()

BOOL WINAPI GetStringTypeExA	(	LCID	locale,
		DWORD	type,
		LPCSTR	src,
		INT	count,
		LPWORD	chartype
	)

Definition at line 1864 of file lang.c.

{
    return GetStringTypeA(locale, type, src, count, chartype);
}

Referenced by _isctype_l().

◆ GetStringTypeExW()

BOOL WINAPI GetStringTypeExW	(	LCID	locale,
		DWORD	type,
		LPCWSTR	src,
		INT	count,
		LPWORD	chartype
	)

Definition at line 1793 of file lang.c.

{
    /* locale is ignored for Unicode */
    return GetStringTypeW( type, src, count, chartype );
}

◆ GetStringTypeW()

BOOL WINAPI GetStringTypeW	(	DWORD	type,
		LPCWSTR	src,
		INT	count,
		LPWORD	chartype
	)

Definition at line 1703 of file lang.c.

{
    static const unsigned char type2_map[16] =
    {
        C2_NOTAPPLICABLE,      /* unassigned */
        C2_LEFTTORIGHT,        /* L */
        C2_RIGHTTOLEFT,        /* R */
        C2_EUROPENUMBER,       /* EN */
        C2_EUROPESEPARATOR,    /* ES */
        C2_EUROPETERMINATOR,   /* ET */
        C2_ARABICNUMBER,       /* AN */
        C2_COMMONSEPARATOR,    /* CS */
        C2_BLOCKSEPARATOR,     /* B */
        C2_SEGMENTSEPARATOR,   /* S */
        C2_WHITESPACE,         /* WS */
        C2_OTHERNEUTRAL,       /* ON */
        C2_RIGHTTOLEFT,        /* AL */
        C2_NOTAPPLICABLE,      /* NSM */
        C2_NOTAPPLICABLE,      /* BN */
        C2_OTHERNEUTRAL        /* LRE, LRO, RLE, RLO, PDF */
    };
 
    if (!src)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (count == -1) count = strlenW(src) + 1;
    switch(type)
    {
    case CT_CTYPE1:
        while (count--) *chartype++ = get_char_typeW( *src++ ) & 0xfff;
        break;
    case CT_CTYPE2:
        while (count--) *chartype++ = type2_map[get_char_typeW( *src++ ) >> 12];
        break;
    case CT_CTYPE3:
    {
        WARN("CT_CTYPE3: semi-stub.\n");
        while (count--)
        {
            int c = *src;
            WORD type1, type3 = 0; /* C3_NOTAPPLICABLE */
 
            type1 = get_char_typeW( *src++ ) & 0xfff;
            /* try to construct type3 from type1 */
            if(type1 & C1_SPACE) type3 |= C3_SYMBOL;
            if(type1 & C1_ALPHA) type3 |= C3_ALPHA;
            if ((c>=0x30A0)&&(c<=0x30FF)) type3 |= C3_KATAKANA;
            if ((c>=0x3040)&&(c<=0x309F)) type3 |= C3_HIRAGANA;
            if ((c>=0x4E00)&&(c<=0x9FAF)) type3 |= C3_IDEOGRAPH;
            if (c == 0x0640) type3 |= C3_KASHIDA;
            if ((c>=0x3000)&&(c<=0x303F)) type3 |= C3_SYMBOL;
 
            if ((c>=0xD800)&&(c<=0xDBFF)) type3 |= C3_HIGHSURROGATE;
            if ((c>=0xDC00)&&(c<=0xDFFF)) type3 |= C3_LOWSURROGATE;
 
            if ((c>=0xFF00)&&(c<=0xFF60)) type3 |= C3_FULLWIDTH;
            if ((c>=0xFF00)&&(c<=0xFF20)) type3 |= C3_SYMBOL;
            if ((c>=0xFF3B)&&(c<=0xFF40)) type3 |= C3_SYMBOL;
            if ((c>=0xFF5B)&&(c<=0xFF60)) type3 |= C3_SYMBOL;
            if ((c>=0xFF21)&&(c<=0xFF3A)) type3 |= C3_ALPHA;
            if ((c>=0xFF41)&&(c<=0xFF5A)) type3 |= C3_ALPHA;
            if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_FULLWIDTH;
            if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_SYMBOL;
 
            if ((c>=0xFF61)&&(c<=0xFFDC)) type3 |= C3_HALFWIDTH;
            if ((c>=0xFF61)&&(c<=0xFF64)) type3 |= C3_SYMBOL;
            if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_KATAKANA;
            if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_ALPHA;
            if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_HALFWIDTH;
            if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_SYMBOL;
            *chartype++ = type3;
        }
        break;
    }
    default:
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    return TRUE;
}

Referenced by __crtGetStringTypeW(), _Locale_ctype_create(), _setmbcp_l(), _WLocale_ctype(), DoWordBreakProc(), get_char_script(), GetC1Type(), GetStringType3ExW(), GetStringTypeA(), GetStringTypeExW(), IsBlankLine(), IsCharBlankW(), IsCharCntrlW(), IsCharDigitW(), IsCharPunctW(), IsCharSpaceW(), IsCharXDigitW(), isdigitW(), SampCheckPassword(), test_crtGetStringTypeW(), and test_GetStringTypeW().

◆ GetSystemDefaultLangID()

LANGID WINAPI GetSystemDefaultLangID ( void )

Definition at line 755 of file lang.c.

{
    return LANGIDFROMLCID(GetSystemDefaultLCID());
}

Referenced by expect_ff(), fill_operatingsystem(), find_entry_language(), init(), load_ttf_name_id(), NLS_GetLanguageGroupName(), set_installer_properties(), START_TEST(), test_fullname2_helper(), test_LookupAccountName(), test_package_validation(), test_ScriptGetFontProperties(), test_SetEntriesInAclA(), test_SetEntriesInAclW(), test_text_metrics(), and validate_package().

◆ GetSystemDefaultLCID()

LCID WINAPI GetSystemDefaultLCID ( void )

Definition at line 791 of file lang.c.

{
    LCID lcid;
    NtQueryDefaultLocale( FALSE, &lcid );
    return lcid;
}

Referenced by Applet(), ConvertDefaultLocale(), CreateTypeLib2(), GetSystemDefaultLangID(), Imm32IsSystemJapaneseOrKorean(), ImmFreeLayout(), ImmGenerateMessage(), ImmPostMessages(), ImmProcessKey(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), IsCharSpaceA(), ITypeInfo_fnInvoke(), ME_MakeFirstParagraph(), MSVCRT__create_locale(), OnInitAddDialog(), START_TEST(), test_ConvertDefaultLocale(), test_EM_SETCHARFORMAT(), test_GetCodePageInfo(), test_GetFont(), test_GetLocaleInfoEx(), test_GetLocaleInfoW(), test_invariant(), test_LsaLookupNames2(), test_textfont_global_defaults(), textfont_reset_to_default(), and WriteUserLocale().

◆ GetSystemDefaultUILanguage()

LANGID WINAPI GetSystemDefaultUILanguage ( void )

Definition at line 830 of file lang.c.

{
    LANGID lang;
    NtQueryInstallUILanguage( &lang );
    return lang;
}

Referenced by LsaLookupPrivilegeDisplayName(), and SHGetWebFolderFilePathW().

◆ GetThreadLocale()

LCID WINAPI GetThreadLocale ( void )

Definition at line 1453 of file lang.c.

{
    LCID ret = NtCurrentTeb()->CurrentLocale;
    if (!ret) NtCurrentTeb()->CurrentLocale = ret = GetUserDefaultLCID();
    return ret;
}

Referenced by CEnumMergedFolder::Begin(), BindCtxImpl_Construct(), ChrCmpIW(), COMCTL32_ChrCmpHelperA(), COMCTL32_ChrCmpIW(), CreateLocationsList(), enum_proc(), CEnumMergedFolder::FindByName(), get_env(), GetCPInfoExW(), Imm32LoadImeLangAndDesc(), IntGetCodePageEntry(), IntlStrEqWorkerA(), IntlStrEqWorkerW(), LocationsEnumProc(), lstrcmpA(), lstrcmpiA(), lstrcmpiW(), lstrcmpW(), msi_strequal(), msi_strprefix(), registry_credential_matches_filter(), SetThreadLocale(), SetupOpenInfFileExW(), SetUserLocaleName(), SHLWAPI_ChrCmpHelperA(), StrCmpIW(), StrCmpNA(), StrCmpNIA(), StrCmpNIW(), StrCmpNW(), StrCmpW(), StrIsIntlEqualA(), StrIsIntlEqualW(), StrStrCase(), test_bind_context(), test_GetCodePageInfo(), test_GetLocaleInfoEx(), test_GetLocaleInfoW(), test_invariant(), test_LsaLookupNames2(), test_openCloseWAVE(), test_stringtable_layout(), test_threadcp(), and test_unicode_wm_char().

◆ GetUserDefaultLangID()

LANGID WINAPI GetUserDefaultLangID ( void )

Definition at line 738 of file lang.c.

{
    return LANGIDFROMLCID(GetUserDefaultLCID());
}

Referenced by AdjustStatusMessageWindow(), detect_locale(), find_entry_language(), GetVersionInfoString(), is_cjk(), is_lang_english(), is_locale_english(), LanguagesPageProc(), LPK_ApplyMirroring(), ME_StreamOutRTFHeader(), MsiLoadStringW(), NOTEPAD_LoadSettingsFromRegistry(), set_installer_properties(), ShowUsage(), START_TEST(), test_EM_FORMATRANGE(), test_EnumFonts(), test_installprops(), and test_MessageBox_WM_COPY_Test().

◆ GetUserDefaultLCID()

LCID WINAPI GetUserDefaultLCID ( void )

Definition at line 772 of file lang.c.

{
    LCID lcid;
    NtQueryDefaultLocale( TRUE, &lcid );
    return lcid;
}

Referenced by ActiveScriptSite_GetLCID(), CConfigParser::CacheINI(), call_disp_func(), CliImmInitializeHotKeys(), ConvertDefaultLocale(), CreateLanguagesList(), GetAcceptLanguagesW(), GetThreadLocale(), GetUserDefaultLangID(), CAvailableApplicationInfo::HasNativeLanguage(), InputProcessorProfiles_Constructor(), LISTBOX_Create(), SetUserLocaleName(), START_TEST(), test_ConvertDefaultLocale(), test_GetAcceptLanguagesA(), test_GetKeyboardLayoutList(), test_GetLocaleInfoEx(), test_LocaleNameToLCID(), test_SetLocaleInfoA(), test_synthesized(), and test_VarFormat().

◆ GetUserDefaultUILanguage()

LANGID WINAPI GetUserDefaultUILanguage ( void )

Definition at line 810 of file lang.c.

{
    LANGID lang;
    NtQueryDefaultUILanguage( &lang );
    return lang;
}

Referenced by _tWinMain(), detect_locale(), FGetComponentPath(), LsaLookupPrivilegeDisplayName(), OmNavigator_get_browserLanguage(), SHGetWebFolderFilePathW(), test_GetFileVersionInfoEx(), WinMain(), and wWinMain().

◆ GetUserGeoID()

GEOID WINAPI GetUserGeoID ( GEOCLASS GeoClass )

Definition at line 3348 of file lang.c.

{
    GEOID ret = GEOID_NOT_AVAILABLE;
    static const WCHAR geoW[] = {'G','e','o',0};
    static const WCHAR nationW[] = {'N','a','t','i','o','n',0};
    WCHAR bufferW[40], *end;
    DWORD count;
    HANDLE hkey, hSubkey = 0;
    UNICODE_STRING keyW;
    const KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)bufferW;
    RtlInitUnicodeString( &keyW, nationW );
    count = sizeof(bufferW);
 
    if(!(hkey = create_registry_key())) return ret;
 
    switch( GeoClass ){
    case GEOCLASS_NATION:
        if ((hSubkey = NLS_RegOpenKey(hkey, geoW)))
        {
            if((NtQueryValueKey(hSubkey, &keyW, KeyValuePartialInformation,
                                bufferW, count, &count) == STATUS_SUCCESS ) && info->DataLength)
                ret = strtolW((LPCWSTR)info->Data, &end, 10);
        }
        break;
    case GEOCLASS_REGION:
        FIXME("GEOCLASS_REGION not handled yet\n");
        break;
    }
 
    NtClose(hkey);
    if (hSubkey) NtClose(hSubkey);
    return ret;
}

Referenced by CreateLocationsList(), and SetUserLocaleName().

◆ InvalidateNLSCache()

BOOL WINAPI InvalidateNLSCache ( void )

Definition at line 3334 of file lang.c.

{
#ifdef __REACTOS__
    JapaneseEra_ClearCache();
    return TRUE;
#else
  FIXME("() stub\n");
  return FALSE;
#endif
}

◆ is_genitive_name_supported()

static BOOL is_genitive_name_supported ( LCTYPE lctype )

static

Definition at line 670 of file lang.c.

{
    switch(lctype & 0xffff)
    {
    case LOCALE_SMONTHNAME1:
    case LOCALE_SMONTHNAME2:
    case LOCALE_SMONTHNAME3:
    case LOCALE_SMONTHNAME4:
    case LOCALE_SMONTHNAME5:
    case LOCALE_SMONTHNAME6:
    case LOCALE_SMONTHNAME7:
    case LOCALE_SMONTHNAME8:
    case LOCALE_SMONTHNAME9:
    case LOCALE_SMONTHNAME10:
    case LOCALE_SMONTHNAME11:
    case LOCALE_SMONTHNAME12:
    case LOCALE_SMONTHNAME13:
         return TRUE;
    default:
         return FALSE;
    }
}

Referenced by GetLocaleInfoW().

◆ IsValidLanguageGroup()

BOOL WINAPI IsValidLanguageGroup	(	LGRPID	lgrpid,
		DWORD	dwFlags
	)

Definition at line 2651 of file lang.c.

{
    static const WCHAR szFormat[] = { '%','x','\0' };
    WCHAR szValueName[16], szValue[2];
    BOOL bSupported = FALSE, bInstalled = FALSE;
    HANDLE hKey;
 
 
    switch (dwFlags)
    {
    case LGRPID_INSTALLED:
    case LGRPID_SUPPORTED:
 
        hKey = NLS_RegOpenKey( 0, szLangGroupsKeyName );
 
        sprintfW( szValueName, szFormat, lgrpid );
 
        if (NLS_RegGetDword( hKey, szValueName, (LPDWORD)szValue ))
        {
            bSupported = TRUE;
 
            if (szValue[0] == '1')
                bInstalled = TRUE;
        }
 
        if (hKey)
            NtClose( hKey );
 
        break;
    }
 
    if ((dwFlags == LGRPID_SUPPORTED && bSupported) ||
        (dwFlags == LGRPID_INSTALLED && bInstalled))
        return TRUE;
 
    return FALSE;
}

Referenced by InitFunctionPointers().

◆ IsValidLocale()

BOOL WINAPI IsValidLocale	(	LCID	lcid,
		DWORD	flags
	)

Definition at line 1552 of file lang.c.

{
    /* check if language is registered in the kernel32 resources */
    return FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING,
                            (LPCWSTR)LOCALE_ILANGUAGE, LANGIDFROMLCID(lcid)) != 0;
}

Referenced by enum_proc(), GeneralPropertyPageLocalesEnumProc(), GetCurrencyFormatW(), GetNumberFormatW(), lgrplocale_procA(), LISTBOX_WindowProc(), ListBoxWndProc_common(), LocalesEnumProc(), ScriptRecordDigitSubstitution(), SetThreadLocale(), START_TEST(), test_GetNumberFormatA(), and validate_package().

◆ LCMapStringA()

INT WINAPI LCMapStringA	(	LCID	lcid,
		DWORD	flags,
		LPCSTR	src,
		INT	srclen,
		LPSTR	dst,
		INT	dstlen
	)

Definition at line 2051 of file lang.c.

{
    WCHAR *bufW = NtCurrentTeb()->StaticUnicodeBuffer;
    LPWSTR srcW, dstW;
    INT ret = 0, srclenW, dstlenW;
    UINT locale_cp = CP_ACP;
 
    if (!src || !srclen || dstlen < 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (!(flags & LOCALE_USE_CP_ACP)) locale_cp = get_lcid_codepage( lcid );
 
    srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, bufW, 260);
    if (srclenW)
        srcW = bufW;
    else
    {
        srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, NULL, 0);
        srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
        if (!srcW)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0;
        }
        MultiByteToWideChar(locale_cp, 0, src, srclen, srcW, srclenW);
    }
 
    if (flags & LCMAP_SORTKEY)
    {
        if (src == dst)
        {
            SetLastError(ERROR_INVALID_FLAGS);
            goto map_string_exit;
        }
        ret = wine_get_sortkey(flags, srcW, srclenW, dst, dstlen);
        if (ret == 0)
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
        else
            ret++;
        goto map_string_exit;
    }
 
    if (flags & SORT_STRINGSORT)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        goto map_string_exit;
    }
 
    dstlenW = LCMapStringEx(NULL, flags, srcW, srclenW, NULL, 0, NULL, NULL, 0);
    if (!dstlenW)
        goto map_string_exit;
 
    dstW = HeapAlloc(GetProcessHeap(), 0, dstlenW * sizeof(WCHAR));
    if (!dstW)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto map_string_exit;
    }
 
    LCMapStringEx(NULL, flags, srcW, srclenW, dstW, dstlenW, NULL, NULL, 0);
    ret = WideCharToMultiByte(locale_cp, 0, dstW, dstlenW, dst, dstlen, NULL, NULL);
    HeapFree(GetProcessHeap(), 0, dstW);
 
map_string_exit:
    if (srcW != bufW) HeapFree(GetProcessHeap(), 0, srcW);
    return ret;
}

Referenced by __crtLCMapStringA(), _Locale_strxfrm(), _Locale_tolower(), _Locale_toupper(), _strxfrm_l(), compare_string3(), lcid_to_rfc1766A(), MSVCRT__create_locale(), test_GetRfc1766FromLcid(), test_LcidToRfc1766(), and test_LCMapStringA().

◆ LCMapStringEx()

INT WINAPI LCMapStringEx	(	LPCWSTR	name,
		DWORD	flags,
		LPCWSTR	src,
		INT	srclen,
		LPWSTR	dst,
		INT	dstlen,
		LPNLSVERSIONINFO	version,
		LPVOID	reserved,
		LPARAM	lparam
	)

Definition at line 1889 of file lang.c.

{
    LPWSTR dst_ptr;
 
    if (version) FIXME("unsupported version structure %p\n", version);
    if (reserved) FIXME("unsupported reserved pointer %p\n", reserved);
    if (lparam)
    {
        static int once;
        if (!once++) FIXME("unsupported lparam %lx\n", lparam);
    }
 
    if (!src || !srclen || dstlen < 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    /* mutually exclusive flags */
    if ((flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE)) == (LCMAP_LOWERCASE | LCMAP_UPPERCASE) ||
        (flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA)) == (LCMAP_HIRAGANA | LCMAP_KATAKANA) ||
        (flags & (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) == (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH) ||
        (flags & (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE)) == (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE))
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (!dstlen) dst = NULL;
 
    if (flags & LCMAP_SORTKEY)
    {
        INT ret;
        if (src == dst)
        {
            SetLastError(ERROR_INVALID_FLAGS);
            return 0;
        }
 
        if (srclen < 0) srclen = strlenW(src);
 
        TRACE("(%s,0x%08x,%s,%d,%p,%d)\n",
              debugstr_w(name), flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
 
        ret = wine_get_sortkey(flags, src, srclen, (char *)dst, dstlen);
        if (ret == 0)
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
        else
            ret++;
        return ret;
    }
 
    /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
    if (flags & SORT_STRINGSORT)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (srclen < 0) srclen = strlenW(src) + 1;
 
    TRACE("(%s,0x%08x,%s,%d,%p,%d)\n",
          debugstr_w(name), flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
 
    if (!dst) /* return required string length */
    {
        INT len;
 
        for (len = 0; srclen; src++, srclen--)
        {
            WCHAR wch = *src;
            /* tests show that win2k just ignores NORM_IGNORENONSPACE,
             * and skips white space and punctuation characters for
             * NORM_IGNORESYMBOLS.
             */
            if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
                continue;
            len++;
        }
        return len;
    }
 
    if (flags & LCMAP_UPPERCASE)
    {
        for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
        {
            WCHAR wch = *src;
            if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
                continue;
            *dst_ptr++ = toupperW(wch);
            dstlen--;
        }
    }
    else if (flags & LCMAP_LOWERCASE)
    {
        for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
        {
            WCHAR wch = *src;
            if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
                continue;
            *dst_ptr++ = tolowerW(wch);
            dstlen--;
        }
    }
    else
    {
        if (src == dst)
        {
            SetLastError(ERROR_INVALID_FLAGS);
            return 0;
        }
        for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
        {
            WCHAR wch = *src;
            if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
                continue;
            *dst_ptr++ = wch;
            dstlen--;
        }
    }
 
    if (srclen)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return 0;
    }
 
    return dst_ptr - dst;
}

Referenced by InitFunctionPointers(), LCMapStringA(), and LCMapStringW().

◆ LCMapStringW()

INT WINAPI LCMapStringW	(	LCID	lcid,
		DWORD	flags,
		LPCWSTR	src,
		INT	srclen,
		LPWSTR	dst,
		INT	dstlen
	)

Definition at line 2025 of file lang.c.

{
    TRACE("(0x%04x,0x%08x,%s,%d,%p,%d)\n",
          lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
 
    return LCMapStringEx(NULL, flags, src, srclen, dst, dstlen, NULL, NULL, 0);
}

Referenced by __crtLCMapStringW(), _WLocale_strxfrm(), _WLocale_tolower(), _WLocale_toupper(), lcid_to_rfc1766W(), LCMapStringW_wrapper(), SvchostCharLowerW(), test_LCMapStringW(), and test_tolower().

◆ NLS_EnumLanguageGroupLocales()

static BOOL NLS_EnumLanguageGroupLocales ( ENUMLANGUAGEGROUPLOCALE_CALLBACKS * lpProcs )

static

Definition at line 2700 of file lang.c.

{
    static const WCHAR szAlternateSortsKeyName[] = {
      'A','l','t','e','r','n','a','t','e',' ','S','o','r','t','s','\0'
    };
    WCHAR szNumber[10], szValue[4];
    HANDLE hKey;
    BOOL bContinue = TRUE, bAlternate = FALSE;
    LGRPID lgrpid;
    ULONG ulIndex = 1;  /* Ignore default entry of 1st key */
 
    if (!lpProcs || !lpProcs->lgrpid || lpProcs->lgrpid > LGRPID_ARMENIAN)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (lpProcs->dwFlags)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    hKey = NLS_RegOpenKey( 0, szLocaleKeyName );
 
    if (!hKey)
        WARN("NLS registry key not found. Please apply the default registry file 'wine.inf'\n");
 
    while (bContinue)
    {
        if (NLS_RegEnumValue( hKey, ulIndex, szNumber, sizeof(szNumber),
                              szValue, sizeof(szValue) ))
        {
            lgrpid = strtoulW( szValue, NULL, 16 );
 
            TRACE("lcid %s, grpid %d (%smatched)\n", debugstr_w(szNumber),
                   lgrpid, lgrpid == lpProcs->lgrpid ? "" : "not ");
 
            if (lgrpid == lpProcs->lgrpid)
            {
                LCID lcid;
 
                lcid = strtoulW( szNumber, NULL, 16 );
 
                /* FIXME: native returns extra text for a few (17/150) locales, e.g:
                 * '00000437          ;Georgian'
                 * At present we only pass the LCID string.
                 */
 
                if (lpProcs->procW)
                    bContinue = lpProcs->procW( lgrpid, lcid, szNumber, lpProcs->lParam );
                else
                {
                    char szNumberA[sizeof(szNumber)/sizeof(WCHAR)];
 
                    WideCharToMultiByte(CP_ACP, 0, szNumber, -1, szNumberA, sizeof(szNumberA), 0, 0);
 
                    bContinue = lpProcs->procA( lgrpid, lcid, szNumberA, lpProcs->lParam );
                }
            }
 
            ulIndex++;
        }
        else
        {
            /* Finished enumerating this key */
            if (!bAlternate)
            {
                /* Enumerate alternate sorts also */
                hKey = NLS_RegOpenKey( hKey, szAlternateSortsKeyName );
                bAlternate = TRUE;
                ulIndex = 0;
            }
            else
                bContinue = FALSE; /* Finished both keys */
        }
 
        if (!bContinue)
            break;
    }
 
    if (hKey)
        NtClose( hKey );
 
    return TRUE;
}

Referenced by EnumLanguageGroupLocalesA(), and EnumLanguageGroupLocalesW().

◆ NLS_EnumSystemCodePages()

static BOOL NLS_EnumSystemCodePages ( ENUMSYSTEMCODEPAGES_CALLBACKS * lpProcs )

static

Definition at line 3165 of file lang.c.

{
    WCHAR szNumber[5 + 1], szValue[MAX_PATH];
    HANDLE hKey;
    BOOL bContinue = TRUE;
    ULONG ulIndex = 0;
 
    if (!lpProcs)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    switch (lpProcs->dwFlags)
    {
        case CP_INSTALLED:
        case CP_SUPPORTED:
            break;
        default:
            SetLastError(ERROR_INVALID_FLAGS);
            return FALSE;
    }
 
    hKey = NLS_RegOpenKey(0, L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\CodePage");
    if (!hKey)
    {
        WARN("NLS_RegOpenKey() failed\n");
        return FALSE;
    }
 
    while (bContinue)
    {
        if (NLS_RegEnumValue(hKey, ulIndex, szNumber, sizeof(szNumber),
                             szValue, sizeof(szValue)))
        {
            if ((lpProcs->dwFlags == CP_SUPPORTED)||
                ((lpProcs->dwFlags == CP_INSTALLED)&&(wcslen(szValue) > 2)))
            {
                if (lpProcs->procW)
                {
                    bContinue = lpProcs->procW(szNumber);
                }
                else
                {
                    char szNumberA[sizeof(szNumber)/sizeof(WCHAR)];
 
                    WideCharToMultiByte(CP_ACP, 0, szNumber, -1, szNumberA, sizeof(szNumberA), 0, 0);
                    bContinue = lpProcs->procA(szNumberA);
                }
            }
 
            ulIndex++;
 
        } else bContinue = FALSE;
 
        if (!bContinue)
            break;
    }
 
    if (hKey)
        NtClose(hKey);
 
    return TRUE;
}

Referenced by EnumSystemCodePagesA(), and EnumSystemCodePagesW().

◆ NLS_EnumSystemLanguageGroups()

static BOOL NLS_EnumSystemLanguageGroups ( ENUMLANGUAGEGROUP_CALLBACKS * lpProcs )

static

Definition at line 2504 of file lang.c.

{
    WCHAR szNumber[10], szValue[4];
    HANDLE hKey;
    BOOL bContinue = TRUE;
    ULONG ulIndex = 0;
 
    if (!lpProcs)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    switch (lpProcs->dwFlags)
    {
    case 0:
        /* Default to LGRPID_INSTALLED */
        lpProcs->dwFlags = LGRPID_INSTALLED;
        /* Fall through... */
    case LGRPID_INSTALLED:
    case LGRPID_SUPPORTED:
        break;
    default:
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    hKey = NLS_RegOpenKey( 0, szLangGroupsKeyName );
 
    if (!hKey)
        FIXME("NLS registry key not found. Please apply the default registry file 'wine.inf'\n");
 
    while (bContinue)
    {
        if (NLS_RegEnumValue( hKey, ulIndex, szNumber, sizeof(szNumber),
                              szValue, sizeof(szValue) ))
        {
            BOOL bInstalled = szValue[0] == '1';
            LGRPID lgrpid = strtoulW( szNumber, NULL, 16 );
 
            TRACE("grpid %s (%sinstalled)\n", debugstr_w(szNumber),
                   bInstalled ? "" : "not ");
 
            if (lpProcs->dwFlags == LGRPID_SUPPORTED || bInstalled)
            {
                WCHAR szGrpName[48];
 
                if (!NLS_GetLanguageGroupName( lgrpid, szGrpName, sizeof(szGrpName) / sizeof(WCHAR) ))
                    szGrpName[0] = '\0';
 
                if (lpProcs->procW)
                    bContinue = lpProcs->procW( lgrpid, szNumber, szGrpName, lpProcs->dwFlags,
                                                lpProcs->lParam );
                else
                {
                    char szNumberA[sizeof(szNumber)/sizeof(WCHAR)];
                    char szGrpNameA[48];
 
                    /* FIXME: MSDN doesn't say which code page the W->A translation uses,
                     *        or whether the language names are ever localised. Assume CP_ACP.
                     */
 
                    WideCharToMultiByte(CP_ACP, 0, szNumber, -1, szNumberA, sizeof(szNumberA), 0, 0);
                    WideCharToMultiByte(CP_ACP, 0, szGrpName, -1, szGrpNameA, sizeof(szGrpNameA), 0, 0);
 
                    bContinue = lpProcs->procA( lgrpid, szNumberA, szGrpNameA, lpProcs->dwFlags,
                                                lpProcs->lParam );
                }
            }
 
            ulIndex++;
        }
        else
            bContinue = FALSE;
 
        if (!bContinue)
            break;
    }
 
    if (hKey)
        NtClose( hKey );
 
    return TRUE;
}

Referenced by EnumSystemLanguageGroupsA(), and EnumSystemLanguageGroupsW().

◆ NLS_GetGeoFriendlyName()

static int NLS_GetGeoFriendlyName	(	GEOID	Location,
		LPWSTR	szFriendlyName,
		int	cchData
	)

static

Definition at line 3513 of file lang.c.

{
    /* FIXME: move *.nls resources out of kernel32 into locale.nls */
    Location += NLSRC_OFFSET;
    Location &= 0xFFFF;
 
    if (cchData == 0)
#ifdef __REACTOS__
        return GetLocalisedText(Location, NULL, 0, lang);
#else
        return GetLocalisedText(Location, NULL, 0);
#endif
 
#ifdef __REACTOS__
    if (GetLocalisedText(Location, szFriendlyName, (UINT)cchData, lang))
#else
    if (GetLocalisedText(Location, szFriendlyName, (UINT)cchData))
#endif
        return strlenW(szFriendlyName) + 1;
 
    return 0;
}

Referenced by GetGeoInfoW().

◆ NLS_GetLanguageGroupName()

static BOOL NLS_GetLanguageGroupName	(	LGRPID	lgrpid,
		LPWSTR	szName,
		ULONG	nameSize
	)

static

Definition at line 2453 of file lang.c.

{
    LANGID  langId;
    LPCWSTR szResourceName = MAKEINTRESOURCEW(((lgrpid + 0x2000) >> 4) + 1);
    HRSRC   hResource;
    BOOL    bRet = FALSE;
 
    /* FIXME: Is it correct to use the system default langid? */
    langId = GetSystemDefaultLangID();
 
    if (SUBLANGID(langId) == SUBLANG_NEUTRAL)
        langId = MAKELANGID( PRIMARYLANGID(langId), SUBLANG_DEFAULT );
 
    hResource = FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING, szResourceName, langId );
 
    if (hResource)
    {
        HGLOBAL hResDir = LoadResource( kernel32_handle, hResource );
 
        if (hResDir)
        {
            ULONG   iResourceIndex = lgrpid & 0xf;
            LPCWSTR lpResEntry = LockResource( hResDir );
            ULONG   i;
 
            for (i = 0; i < iResourceIndex; i++)
                lpResEntry += *lpResEntry + 1;
 
            if (*lpResEntry < nameSize)
            {
                memcpy( szName, lpResEntry + 1, *lpResEntry * sizeof(WCHAR) );
                szName[*lpResEntry] = '\0';
                bRet = TRUE;
            }
 
        }
        FreeResource( hResource );
    }
    return bRet;
}

Referenced by NLS_EnumSystemLanguageGroups().

◆ NLS_RegEnumValue()

static BOOL NLS_RegEnumValue	(	HANDLE	hKey,
		UINT	ulIndex,
		LPWSTR	szValueName,
		ULONG	valueNameSize,
		LPWSTR	szValueData,
		ULONG	valueDataSize
	)

static

Definition at line 2404 of file lang.c.

{
    BYTE buffer[80];
    KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
    DWORD dwLen;
 
    if (NtEnumerateValueKey( hKey, ulIndex, KeyValueFullInformation,
        buffer, sizeof(buffer), &dwLen ) != STATUS_SUCCESS ||
        info->NameLength > valueNameSize ||
        info->DataLength > valueDataSize)
    {
        return FALSE;
    }
 
    TRACE("info->Name %s info->DataLength %d\n", debugstr_w(info->Name), info->DataLength);
 
    memcpy( szValueName, info->Name, info->NameLength);
    szValueName[info->NameLength / sizeof(WCHAR)] = '\0';
    memcpy( szValueData, buffer + info->DataOffset, info->DataLength );
    szValueData[info->DataLength / sizeof(WCHAR)] = '\0';
 
    TRACE("returning %s %s\n", debugstr_w(szValueName), debugstr_w(szValueData));
    return TRUE;
}

Referenced by NLS_EnumLanguageGroupLocales(), NLS_EnumSystemCodePages(), and NLS_EnumSystemLanguageGroups().

◆ NLS_RegGetDword()

static BOOL NLS_RegGetDword	(	HANDLE	hKey,
		LPCWSTR	szValueName,
		DWORD *	lpVal
	)

static

Definition at line 2432 of file lang.c.

{
    BYTE buffer[128];
    const KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
    DWORD dwSize = sizeof(buffer);
    UNICODE_STRING valueName;
 
    RtlInitUnicodeString( &valueName, szValueName );
 
    TRACE("%p, %s\n", hKey, debugstr_w(szValueName));
    if (NtQueryValueKey( hKey, &valueName, KeyValuePartialInformation,
                         buffer, dwSize, &dwSize ) == STATUS_SUCCESS &&
        info->DataLength == sizeof(DWORD))
    {
        memcpy(lpVal, info->Data, sizeof(DWORD));
        return TRUE;
    }
 
    return FALSE;
}

Referenced by IsValidLanguageGroup().

◆ NLS_RegOpenKey()

static HANDLE NLS_RegOpenKey	(	HANDLE	hRootKey,
		LPCWSTR	szKeyName
	)

static

Definition at line 2379 of file lang.c.

{
    UNICODE_STRING keyName;
    OBJECT_ATTRIBUTES attr;
    HANDLE hkey;
 
    RtlInitUnicodeString( &keyName, szKeyName );
#ifdef __REACTOS__
    InitializeObjectAttributes(&attr, &keyName, OBJ_CASE_INSENSITIVE, hRootKey, NULL);
#else
    InitializeObjectAttributes(&attr, &keyName, 0, hRootKey, NULL);
#endif
 
    if (NtOpenKey( &hkey, KEY_READ, &attr ) != STATUS_SUCCESS)
        hkey = 0;
 
    return hkey;
}

Referenced by GetUserGeoID(), IsValidLanguageGroup(), NLS_EnumLanguageGroupLocales(), NLS_EnumSystemCodePages(), and NLS_EnumSystemLanguageGroups().

◆ SetLocaleInfoA()

BOOL WINAPI SetLocaleInfoA	(	LCID	lcid,
		LCTYPE	lctype,
		LPCSTR	data
	)

Definition at line 1323 of file lang.c.

{
    UINT codepage = CP_ACP;
    WCHAR *strW;
    DWORD len;
    BOOL ret;
 
    if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
 
    if (!data)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    len = MultiByteToWideChar( codepage, 0, data, -1, NULL, 0 );
    if (!(strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return FALSE;
    }
    MultiByteToWideChar( codepage, 0, data, -1, strW, len );
    ret = SetLocaleInfoW( lcid, lctype, strW );
    HeapFree( GetProcessHeap(), 0, strW );
    return ret;
}

Referenced by test_SetLocaleInfoA(), and test_VarCat().

◆ SetLocaleInfoW()

BOOL WINAPI SetLocaleInfoW	(	LCID	lcid,
		LCTYPE	lctype,
		LPCWSTR	data
	)

Definition at line 1355 of file lang.c.

{
    struct registry_value *value;
    static const WCHAR intlW[] = {'i','n','t','l',0 };
    UNICODE_STRING valueW;
    NTSTATUS status;
    HANDLE hkey;
 
    lctype &= 0xffff;
    value = get_locale_registry_value( lctype );
 
    if (!data || !value)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (lctype == LOCALE_IDATE || lctype == LOCALE_ILDATE)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return FALSE;
    }
 
    TRACE("setting %x (%s) to %s\n", lctype, debugstr_w(value->name), debugstr_w(data) );
 
    /* FIXME: should check that data to set is sane */
 
    /* FIXME: profile functions should map to registry */
    WriteProfileStringW( intlW, value->name, data );
 
    if (!(hkey = create_registry_key())) return FALSE;
    RtlInitUnicodeString( &valueW, value->name );
    status = NtSetValueKey( hkey, &valueW, 0, REG_SZ, (PVOID)data, (strlenW(data)+1)*sizeof(WCHAR) );
 
    RtlEnterCriticalSection( &cache_section );
    HeapFree( GetProcessHeap(), 0, value->cached_value );
    value->cached_value = NULL;
    RtlLeaveCriticalSection( &cache_section );
 
    if (lctype == LOCALE_SSHORTDATE || lctype == LOCALE_SLONGDATE)
    {
      /* Set I-value from S value */
      WCHAR *lpD, *lpM, *lpY;
      WCHAR szBuff[2];
 
      lpD = strrchrW(data, 'd');
      lpM = strrchrW(data, 'M');
      lpY = strrchrW(data, 'y');
 
      if (lpD <= lpM)
      {
        szBuff[0] = '1'; /* D-M-Y */
      }
      else
      {
        if (lpY <= lpM)
          szBuff[0] = '2'; /* Y-M-D */
        else
          szBuff[0] = '0'; /* M-D-Y */
      }
 
      szBuff[1] = '\0';
 
      if (lctype == LOCALE_SSHORTDATE)
        lctype = LOCALE_IDATE;
      else
        lctype = LOCALE_ILDATE;
 
      value = get_locale_registry_value( lctype );
 
      WriteProfileStringW( intlW, value->name, szBuff );
 
      RtlInitUnicodeString( &valueW, value->name );
      status = NtSetValueKey( hkey, &valueW, 0, REG_SZ, szBuff, sizeof(szBuff) );
 
      RtlEnterCriticalSection( &cache_section );
      HeapFree( GetProcessHeap(), 0, value->cached_value );
      value->cached_value = NULL;
      RtlLeaveCriticalSection( &cache_section );
    }
 
    NtClose( hkey );
 
    if (status) SetLastError( RtlNtStatusToDosError(status) );
    return !status;
}

Referenced by SetLocaleInfoA().

◆ SetThreadLocale()

BOOL WINAPI SetThreadLocale ( LCID lcid )

Definition at line 1472 of file lang.c.

{
    TRACE("(0x%04X)\n", lcid);
 
    lcid = ConvertDefaultLocale(lcid);
 
    if (lcid != GetThreadLocale())
    {
        if (!IsValidLocale(lcid, LCID_SUPPORTED))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
 
        NtCurrentTeb()->CurrentLocale = lcid;
    }
    return TRUE;
}

Referenced by enum_proc(), SetTEBLangID(), SetupOpenInfFileExW(), and test_threadcp().

◆ SetUserGeoID()

BOOL WINAPI SetUserGeoID ( GEOID GeoID )

Definition at line 3385 of file lang.c.

{
    static const WCHAR geoW[] = {'G','e','o',0};
    static const WCHAR nationW[] = {'N','a','t','i','o','n',0};
    static const WCHAR formatW[] = {'%','i',0};
    UNICODE_STRING nameW,keyW;
    WCHAR bufferW[10];
    OBJECT_ATTRIBUTES attr;
    HANDLE hkey;
 
    if(!(hkey = create_registry_key())) return FALSE;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = hkey;
    attr.ObjectName = &nameW;
    attr.Attributes = 0;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    RtlInitUnicodeString( &nameW, geoW );
    RtlInitUnicodeString( &keyW, nationW );
 
    if (NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
 
    {
        NtClose(attr.RootDirectory);
        return FALSE;
    }
 
    sprintfW(bufferW, formatW, GeoID);
    NtSetValueKey(hkey, &keyW, 0, REG_SZ, bufferW, (strlenW(bufferW) + 1) * sizeof(WCHAR));
    NtClose(attr.RootDirectory);
    NtClose(hkey);
    return TRUE;
}

◆ strcpynAtoW()

static void strcpynAtoW	(	WCHAR *	dst,
		const char *	src,
		size_t	n
	)

inlinestatic

Definition at line 248 of file lang.c.

{
    while (n > 1 && *src)
    {
        *dst++ = (unsigned char)*src++;
        n--;
    }
    if (n) *dst = 0;
}

◆ VerLanguageNameA()

DWORD WINAPI VerLanguageNameA	(	DWORD	wLang,
		LPSTR	szLang,
		DWORD	nSize
	)

Definition at line 1682 of file lang.c.

{
    return GetLocaleInfoA( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
}

◆ VerLanguageNameW()

DWORD WINAPI VerLanguageNameW	(	DWORD	wLang,
		LPWSTR	szLang,
		DWORD	nSize
	)

Definition at line 1693 of file lang.c.

{
    return GetLocaleInfoW( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
}

Referenced by CFileVersionInfo::GetLangName().

◆ wine_compare_string()

int wine_compare_string	(	int	flags,
		const WCHAR *	str1,
		int	len1,
		const WCHAR *	str2,
		int	len2
	)

Definition at line 358 of file sortkey.c.

{
    int ret;
 
    ret = compare_unicode_weights(flags, str1, len1, str2, len2);
    if (!ret)
    {
        if (!(flags & NORM_IGNORENONSPACE))
            ret = compare_diacritic_weights(flags, str1, len1, str2, len2);
        if (!ret && !(flags & NORM_IGNORECASE))
            ret = compare_case_weights(flags, str1, len1, str2, len2);
    }
    return ret;
}

Referenced by CompareStringEx().

◆ wine_fold_string()

int wine_fold_string	(	int	flags,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

Definition at line 118 of file fold.c.

{
    WCHAR *dstbase = dst;
    const WCHAR *expand;
    int i;
 
    if (srclen == -1)
        srclen = strlenW(src) + 1; /* Include terminating NUL in count */
 
    if (!dstlen)
    {
        /* Calculate the required size for dst */
        dstlen = srclen;
 
        if (flags & MAP_EXPAND_LIGATURES)
        {
            while (srclen--)
            {
                dstlen += get_ligature_len(*src);
                src++;
            }
        }
        else if (flags & MAP_COMPOSITE)
        {
            /* FIXME */
        }
        else if (flags & MAP_PRECOMPOSED)
        {
            /* FIXME */
        }
        return dstlen;
    }
 
    if (srclen > dstlen)
        return 0;
 
    dstlen -= srclen;
 
    /* Actually perform the mapping(s) specified */
    for (i = 0; i < srclen; i++)
    {
        WCHAR ch = *src;
 
        if (flags & MAP_EXPAND_LIGATURES)
        {
            expand = get_ligature(ch);
            if (expand[0])
            {
                if (!dstlen--)
                    return 0;
                dst[0] = expand[0];
                if (expand[2])
                {
                    if (!dstlen--)
                        return 0;
                    *++dst = expand[1];
                    ch = expand[2];
                }
                else
                    ch = expand[1];
                dst++;
            }
        }
        else if (flags & MAP_COMPOSITE)
        {
            /* FIXME */
        }
        else if (flags & MAP_PRECOMPOSED)
        {
            /* FIXME */
        }
        if (flags & MAP_FOLDDIGITS)
            ch = to_unicode_digit(ch);
        if (flags & MAP_FOLDCZONE)
            ch = to_unicode_native(ch);
 
        *dst++ = ch;
        src++;
    }
    return dst - dstbase;
}

Referenced by FoldStringW().

◆ wine_get_sortkey()

int wine_get_sortkey	(	int	flags,
		const WCHAR *	src,
		int	srclen,
		char *	dst,
		int	dstlen
	)

Definition at line 33 of file sortkey.c.

{
    WCHAR dummy[4]; /* no decomposition is larger than 4 chars */
    int key_len[4];
    char *key_ptr[4];
    const WCHAR *src_save = src;
    int srclen_save = srclen;
 
    key_len[0] = key_len[1] = key_len[2] = key_len[3] = 0;
    for (; srclen; srclen--, src++)
    {
        unsigned int i, decomposed_len = 1;/*wine_decompose(*src, dummy, 4);*/
        dummy[0] = *src;
        if (decomposed_len)
        {
            for (i = 0; i < decomposed_len; i++)
            {
                WCHAR wch = dummy[i];
                unsigned int ce;
 
                /* tests show that win2k just ignores NORM_IGNORENONSPACE,
                 * and skips white space and punctuation characters for
                 * NORM_IGNORESYMBOLS.
                 */
                if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
                    continue;
 
                if (flags & NORM_IGNORECASE) wch = tolowerW(wch);
 
                ce = collation_table[collation_table[wch >> 8] + (wch & 0xff)];
                if (ce != (unsigned int)-1)
                {
                    if (ce >> 16) key_len[0] += 2;
                    if ((ce >> 8) & 0xff) key_len[1]++;
                    if ((ce >> 4) & 0x0f) key_len[2]++;
                    if (ce & 1)
                    {
                        if (wch >> 8) key_len[3]++;
                        key_len[3]++;
                    }
                }
                else
                {
                    key_len[0] += 2;
                    if (wch >> 8) key_len[0]++;
                    if (wch & 0xff) key_len[0]++;
        }
            }
        }
    }
 
    if (!dstlen) /* compute length */
        /* 4 * '\1' + 1 * '\0' + key length */
        return key_len[0] + key_len[1] + key_len[2] + key_len[3] + 4 + 1;
 
    if (dstlen < key_len[0] + key_len[1] + key_len[2] + key_len[3] + 4 + 1)
        return 0; /* overflow */
 
    src = src_save;
    srclen = srclen_save;
 
    key_ptr[0] = dst;
    key_ptr[1] = key_ptr[0] + key_len[0] + 1;
    key_ptr[2] = key_ptr[1] + key_len[1] + 1;
    key_ptr[3] = key_ptr[2] + key_len[2] + 1;
 
    for (; srclen; srclen--, src++)
    {
        unsigned int i, decomposed_len = 1;/*wine_decompose(*src, dummy, 4);*/
        dummy[0] = *src;
        if (decomposed_len)
        {
            for (i = 0; i < decomposed_len; i++)
            {
                WCHAR wch = dummy[i];
                unsigned int ce;
 
                /* tests show that win2k just ignores NORM_IGNORENONSPACE,
                 * and skips white space and punctuation characters for
                 * NORM_IGNORESYMBOLS.
                 */
                if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
                    continue;
 
                if (flags & NORM_IGNORECASE) wch = tolowerW(wch);
 
                ce = collation_table[collation_table[wch >> 8] + (wch & 0xff)];
                if (ce != (unsigned int)-1)
                {
                    WCHAR key;
                    if ((key = ce >> 16))
                    {
                        *key_ptr[0]++ = key >> 8;
                        *key_ptr[0]++ = key & 0xff;
                    }
                    /* make key 1 start from 2 */
                    if ((key = (ce >> 8) & 0xff)) *key_ptr[1]++ = key + 1;
                    /* make key 2 start from 2 */
                    if ((key = (ce >> 4) & 0x0f)) *key_ptr[2]++ = key + 1;
                    /* key 3 is always a character code */
                    if (ce & 1)
                    {
                        if (wch >> 8) *key_ptr[3]++ = wch >> 8;
                        if (wch & 0xff) *key_ptr[3]++ = wch & 0xff;
                    }
                }
                else
                {
                    *key_ptr[0]++ = 0xff;
                    *key_ptr[0]++ = 0xfe;
                    if (wch >> 8) *key_ptr[0]++ = wch >> 8;
                    if (wch & 0xff) *key_ptr[0]++ = wch & 0xff;
                }
            }
        }
    }
 
    *key_ptr[0] = '\1';
    *key_ptr[1] = '\1';
    *key_ptr[2] = '\1';
    *key_ptr[3]++ = '\1';
    *key_ptr[3] = 0;
 
    return key_ptr[3] - dst;
}

Referenced by LCMapStringA(), and LCMapStringEx().

Variable Documentation

◆ cache_section

RTL_CRITICAL_SECTION cache_section = { NULL, -1, 0, 0, 0, 0 }

static

Definition at line 244 of file lang.c.

Referenced by get_registry_locale_info(), and SetLocaleInfoW().

◆ geoinfodata

const struct geoinfo_t geoinfodata[]

static

Definition at line 2802 of file lang.c.

Referenced by EnumSystemGeoID(), and get_geoinfo_dataptr().

◆ iCalendarTypeW

const WCHAR iCalendarTypeW[] = {'i','C','a','l','e','n','d','a','r','T','y','p','e',0}

static

Definition at line 152 of file lang.c.

◆ iCountryW

const WCHAR iCountryW[] = {'i','C','o','u','n','t','r','y',0}

static

Definition at line 153 of file lang.c.

◆ iCurrDigitsW

const WCHAR iCurrDigitsW[] = {'i','C','u','r','r','D','i','g','i','t','s',0}

static

Definition at line 154 of file lang.c.

◆ iCurrencyW

const WCHAR iCurrencyW[] = {'i','C','u','r','r','e','n','c','y',0}

static

Definition at line 155 of file lang.c.

◆ iDateW

const WCHAR iDateW[] = {'i','D','a','t','e',0}

static

Definition at line 156 of file lang.c.

◆ iDigitsW

const WCHAR iDigitsW[] = {'i','D','i','g','i','t','s',0}

static

Definition at line 157 of file lang.c.

◆ iFirstDayOfWeekW

const WCHAR iFirstDayOfWeekW[] = {'i','F','i','r','s','t','D','a','y','O','f','W','e','e','k',0}

static

Definition at line 158 of file lang.c.

◆ iFirstWeekOfYearW

const WCHAR iFirstWeekOfYearW[] = {'i','F','i','r','s','t','W','e','e','k','O','f','Y','e','a','r',0}

static

Definition at line 159 of file lang.c.

◆ iLDateW

const WCHAR iLDateW[] = {'i','L','D','a','t','e',0}

static

Definition at line 160 of file lang.c.

◆ iLZeroW

const WCHAR iLZeroW[] = {'i','L','Z','e','r','o',0}

static

Definition at line 161 of file lang.c.

◆ iMeasureW

const WCHAR iMeasureW[] = {'i','M','e','a','s','u','r','e',0}

static

Definition at line 162 of file lang.c.

◆ iNegCurrW

const WCHAR iNegCurrW[] = {'i','N','e','g','C','u','r','r',0}

static

Definition at line 163 of file lang.c.

◆ iNegNumberW

const WCHAR iNegNumberW[] = {'i','N','e','g','N','u','m','b','e','r',0}

static

Definition at line 164 of file lang.c.

◆ iPaperSizeW

const WCHAR iPaperSizeW[] = {'i','P','a','p','e','r','S','i','z','e',0}

static

Definition at line 165 of file lang.c.

◆ iTimePrefixW

const WCHAR iTimePrefixW[] = {'i','T','i','m','e','P','r','e','f','i','x',0}

static

Definition at line 167 of file lang.c.

◆ iTimeW

const WCHAR iTimeW[] = {'i','T','i','m','e',0}

static

Definition at line 168 of file lang.c.

◆ iTLZeroW

const WCHAR iTLZeroW[] = {'i','T','L','Z','e','r','o',0}

static

Definition at line 166 of file lang.c.

◆ kernel32_handle

HMODULE kernel32_handle

extern

Definition at line 26 of file dllmain.c.

Referenced by DllMain(), EnumSystemLocalesA(), EnumSystemLocalesEx(), EnumSystemLocalesW(), EnumUILanguagesA(), EnumUILanguagesW(), GetLocaleInfoW(), IsValidLocale(), NLS_GetLanguageGroupName(), and search_message().

◆ lcid_LC_COLLATE

LCID lcid_LC_COLLATE

static

Definition at line 143 of file lang.c.

Referenced by convert_default_lcid().

◆ lcid_LC_CTYPE

LCID lcid_LC_CTYPE

static

Definition at line 144 of file lang.c.

Referenced by convert_default_lcid().

◆ lcid_LC_MEASUREMENT

LCID lcid_LC_MEASUREMENT

static

Definition at line 149 of file lang.c.

Referenced by convert_default_lcid().

◆ lcid_LC_MONETARY

LCID lcid_LC_MONETARY

static

Definition at line 145 of file lang.c.

Referenced by convert_default_lcid().

◆ lcid_LC_NUMERIC

LCID lcid_LC_NUMERIC

static

Definition at line

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ LOCALE_LOCALEINFOFLAGSMASK

◆ NDEBUG

◆ NLSRC_OFFSET

◆ REG_SZ

Enumeration Type Documentation

◆ locationkind

Function Documentation

◆ CompareStringA()

◆ CompareStringEx()

◆ CompareStringW()

◆ convert_default_lcid()

◆ ConvertDefaultLocale()

◆ create_registry_key()

◆ DEBUG_CHANNEL()

◆ enum_lang_proc_a()

◆ enum_lang_proc_w()

◆ enum_locale_ex_proc()

◆ enum_uilang_proc_a()

◆ enum_uilang_proc_w()

◆ EnumLanguageGroupLocalesA()

◆ EnumLanguageGroupLocalesW()

◆ EnumSystemCodePagesA()

◆ EnumSystemCodePagesW()

◆ EnumSystemGeoID()

◆ EnumSystemLanguageGroupsA()

◆ EnumSystemLanguageGroupsW()

◆ EnumSystemLocalesA()

◆ EnumSystemLocalesEx()

◆ EnumSystemLocalesW()

◆ EnumUILanguagesA()

◆ EnumUILanguagesW()

◆ FoldStringA()

◆ FoldStringW()

◆ get_geoinfo_dataptr()

◆ get_lcid_codepage()

◆ get_locale_registry_value()

◆ get_registry_locale_info()

◆ get_value_base_by_lctype()

◆ GetGeoInfoA()

◆ GetGeoInfoW()

◆ GetLocaleInfoA()

◆ GetLocaleInfoW()

◆ GetLocalisedText()

◆ GetStringTypeA()

◆ GetStringTypeExA()

◆ GetStringTypeExW()

◆ GetStringTypeW()

◆ GetSystemDefaultLangID()

◆ GetSystemDefaultLCID()

◆ GetSystemDefaultUILanguage()

◆ GetThreadLocale()

◆ GetUserDefaultLangID()

◆ GetUserDefaultLCID()

◆ GetUserDefaultUILanguage()

◆ GetUserGeoID()

◆ InvalidateNLSCache()

◆ is_genitive_name_supported()

◆ IsValidLanguageGroup()

◆ IsValidLocale()

◆ LCMapStringA()

◆ LCMapStringEx()

◆ LCMapStringW()

◆ NLS_EnumLanguageGroupLocales()

◆ NLS_EnumSystemCodePages()

◆ NLS_EnumSystemLanguageGroups()

◆ NLS_GetGeoFriendlyName()

◆ NLS_GetLanguageGroupName()

◆ NLS_RegEnumValue()

◆ NLS_RegGetDword()

◆ NLS_RegOpenKey()

◆ SetLocaleInfoA()

◆ SetLocaleInfoW()

◆ SetThreadLocale()

◆ SetUserGeoID()