#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_RETURN_GENITIVE_NAMES

#define LOCALE_RETURN_GENITIVE_NAMES

Definition: winnls.h:24

LOCALE_NOUSEROVERRIDE

#define LOCALE_NOUSEROVERRIDE

Definition: winnls.h:19

LOCALE_USE_CP_ACP

#define LOCALE_USE_CP_ACP

Definition: winnls.h:20

Definition at line 41 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 37 of file lang.c.

◆ REG_SZ

#define REG_SZ 1

Definition at line 32 of file lang.c.

Enumeration Type Documentation

◆ locationkind

enum locationkind

Enumerator
LOCATION_NATION
LOCATION_REGION
LOCATION_BOTH

Definition at line 2766 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 2296 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 2225 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 2272 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(), parseKeyName(), PathCreateFromUrlW(), registry_credential_matches_filter(), Storage_DestroyElement(), StrCmpIW(), StrCmpNIW(), StrCmpNW(), StrCmpW(), StrIsIntlEqualW(), 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 512 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 1499 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 691 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 1553 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 1563 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 1618 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 3405 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 3415 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 3098 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 3119 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 3236 of file lang.c.

 {
     ENUMSYSTEMCODEPAGES_CALLBACKS procs;
 
     TRACE("(%p,0x%08X,0x%08lX)\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 3214 of file lang.c.

 {
     ENUMSYSTEMCODEPAGES_CALLBACKS procs;
 
     TRACE("(%p,0x%08X,0x%08lX)\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 3266 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 2582 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 2602 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 1586 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 1641 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 1601 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 3429 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 3457 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 2134 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 2192 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 3499 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 257 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 1081 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 883 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 1071 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 3597 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 3527 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:
     {
         return NLS_GetGeoFriendlyName(geoid, data, data_len);
     }
     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(), and LocationsEnumProc().

◆ GetLocaleInfoA()

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

Definition at line 1015 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 1095 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::CacheINILocale(), create_utc_string(), CreateLanguagesList(), CreateSortList(), date_parse(), date_to_string(), dateobj_to_date_string(), DATETIME_ReturnFieldWidth(), 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(), get_localized_dayname(), 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_PaintWeeknumbers(), MONTHCAL_SetFirstDayOfWeek(), MonthCalFirstDayOfWeek(), MonthCalReload(), MSVCRT__create_locale(), NLS_EnumCalendarInfo(), NLS_EnumDateFormats(), NLS_EnumTimeFormats(), NLS_GetLocaleNumber(), NLS_GetLocaleString(), ParseDate(), ReadChmSystem(), SaveFontSubstitutionSettings(), SaveSystemSettings(), ScriptRecordDigitSubstitution(), 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
	)

Definition at line 1726 of file nls.c.

 {
     HRSRC hrsrc;
     HGLOBAL hmem;
     LCID lcid;
     LANGID langId;
     const WCHAR *p;
     UINT i;
 
     /* See HACK in winnls/lang/xx-XX.rc files */
     if (uID == 37)
         uID = uID * 100;
 
     lcid = GetUserDefaultLCID();
     lcid = ConvertDefaultLocale(lcid);
 
     langId = LANGIDFROMLCID(lcid);
 
     if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
         langId = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
 
     hrsrc = FindResourceExW(hCurrentModule,
                             (LPWSTR)RT_STRING,
                             MAKEINTRESOURCEW((uID >> 4) + 1),
                             langId);
 
     /* English fallback */
     if (!hrsrc)
     {
         hrsrc = FindResourceExW(hCurrentModule,
                                 (LPWSTR)RT_STRING,
                                 MAKEINTRESOURCEW((uID >> 4) + 1),
                                 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
     }
 
     if (!hrsrc)
         goto NotFound;
 
     hmem = LoadResource(hCurrentModule, hrsrc);
     if (!hmem)
         goto NotFound;
 
     p = LockResource(hmem);
 
     for (i = 0; i < (uID & 0x0F); i++)
         p += *p + 1;
 
     /* Needed for GetGeoInfo(): return the needed string size including the NULL terminator */
     if (cchDest == 0)
         return *p + 1;
     /* Needed for GetGeoInfo(): bail out if the user buffer is not large enough */
     if (*p + 1 > cchDest)
     {
         SetLastError(ERROR_INSUFFICIENT_BUFFER);
         return 0;
     }
 
     i = *p;
     if (i > 0)
     {
         memcpy(lpszDest, p + 1, i * sizeof(WCHAR));
         lpszDest[i] = L'\0';
         return i;
     }
 #if 0
     else
     {
         if (cchDest >= 1)
             lpszDest[0] = L'\0';
         /* Fall-back */
     }
 #endif
 
 NotFound:
     DPRINT1("Resource not found: uID = %lu\n", uID);
     SetLastError(ERROR_INVALID_PARAMETER);
     return 0;
 }

Referenced by GetCPInfoExW(), and NLS_GetGeoFriendlyName().

◆ GetStringTypeA()

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

Definition at line 1810 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 1857 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 1786 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 1696 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(), get_char_script(), GetC1Type(), GetStringType3ExW(), GetStringTypeA(), GetStringTypeExW(), IsCharBlankW(), IsCharCntrlW(), IsCharDigitW(), IsCharPunctW(), IsCharSpaceW(), IsCharXDigitW(), isdigitW(), SampCheckPassword(), test_crtGetStringTypeW(), and test_GetStringTypeW().

◆ GetSystemDefaultLangID()

LANGID WINAPI GetSystemDefaultLangID ( void )

Definition at line 748 of file lang.c.

 {
     return LANGIDFROMLCID(GetSystemDefaultLCID());
 }

Referenced by expect_ff(), fill_os(), 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 784 of file lang.c.

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

Referenced by Applet(), ConvertDefaultLocale(), CreateTypeLib2(), GetSystemDefaultLangID(), 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 823 of file lang.c.

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

Referenced by LsaLookupPrivilegeDisplayName(), and SHGetWebFolderFilePathW().

◆ GetThreadLocale()

LCID WINAPI GetThreadLocale ( void )

Definition at line 1446 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(), enum_proc(), CEnumMergedFolder::FindByName(), get_env(), IntGetCodePageEntry(), IntlStrEqWorkerA(), IntlStrEqWorkerW(), lstrcmpA(), lstrcmpiA(), lstrcmpiW(), lstrcmpW(), msi_strequal(), msi_strprefix(), registry_credential_matches_filter(), SetThreadLocale(), SetupOpenInfFileExW(), SHLWAPI_ChrCmpHelperA(), StrCmpIW(), StrCmpNA(), StrCmpNIA(), StrCmpNIW(), StrCmpNW(), StrCmpW(), StrIsIntlEqualA(), StrIsIntlEqualW(), 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 731 of file lang.c.

 {
     return LANGIDFROMLCID(GetUserDefaultLCID());
 }

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

◆ GetUserDefaultLCID()

LCID WINAPI GetUserDefaultLCID ( void )

Definition at line 765 of file lang.c.

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

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

◆ GetUserDefaultUILanguage()

LANGID WINAPI GetUserDefaultUILanguage ( void )

Definition at line 803 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 3322 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().

◆ InvalidateNLSCache()

BOOL WINAPI InvalidateNLSCache ( void )

Definition at line 3313 of file lang.c.

 {
   FIXME("() stub\n");
   return FALSE;
 }

◆ is_genitive_name_supported()

static BOOL is_genitive_name_supported ( LCTYPE lctype )

static

Definition at line 663 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 2630 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 1545 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 2044 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 1882 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 2018 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 2679 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;
 }

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()