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

Include dependency graph for locale.c:

Classes
struct	locale_name

struct	registry_value

struct	enum_locale_ex_data

struct	ENUMLANGUAGEGROUP_CALLBACKS

struct	ENUMLANGUAGEGROUPLOCALE_CALLBACKS

struct	ENUM_UILANG_CALLBACK

struct	geoinfo_t

Macros
#define	NDEBUG

#define	WINVER DLL_EXPORT_VERSION

#define	LOCALE_NAME_USER_DEFAULT NULL

#define	REG_SZ 1

#define	NLSRC_OFFSET 5000 /* FIXME */

#define	LOCALE_LOCALEINFOFLAGSMASK

#define	MB_FLAGSMASK (MB_PRECOMPOSED\|MB_COMPOSITE\|MB_USEGLYPHCHARS\|MB_ERR_INVALID_CHARS)

#define	WC_FLAGSMASK

#define	GET_UNIX_LOCALE(cat)

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

enum	{ BASE = 36 , TMIN = 1 , TMAX = 26 , SKEW = 38 , DAMP = 700 , INIT_BIAS = 72 , INIT_N = 128 }

Functions
	DEBUG_CHANNEL (nls)

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

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 unsigned short	get_table_entry (const unsigned short *table, WCHAR ch)

static UINT	get_lcid_codepage (LCID lcid)

static const union cptable *	get_codepage_table (unsigned int codepage)

static LANGID	get_default_sublang (LANGID lang)

static LCID	convert_default_lcid (LCID lcid, LCTYPE lctype)

static BOOL	is_genitive_name_supported (LCTYPE lctype)

static HANDLE	create_registry_key (void)

static BOOL	locale_update_registry (HKEY hkey, const WCHAR name, LCID lcid, const LCTYPE values, UINT nb_values)

void	LOCALE_InitRegistry (void)

static const char *	get_locale (int category, const char *category_name)

static UINT	setup_unix_locales (void)

LANGID WINAPI	GetUserDefaultLangID (void)

LANGID WINAPI	GetSystemDefaultLangID (void)

LCID WINAPI	GetUserDefaultLCID (void)

LCID WINAPI	GetSystemDefaultLCID (void)

INT WINAPI	GetSystemDefaultLocaleName (LPWSTR localename, INT len)

static BOOL	get_dummy_preferred_ui_language (DWORD flags, ULONG count, WCHAR buffer, ULONG *size)

BOOL WINAPI	GetSystemPreferredUILanguages (DWORD flags, ULONG count, WCHAR buffer, ULONG *size)

BOOL WINAPI	SetThreadPreferredUILanguages (DWORD flags, PCZZWSTR buffer, PULONG count)

BOOL WINAPI	GetThreadPreferredUILanguages (DWORD flags, ULONG count, WCHAR buf, ULONG *size)

LANGID WINAPI	GetUserDefaultUILanguage (void)

LANGID WINAPI	GetSystemDefaultUILanguage (void)

static struct registry_value *	get_locale_registry_value (DWORD lctype)

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)

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)

UINT WINAPI	GetACP (void)

UINT WINAPI	SetCPGlobal (UINT acp)

UINT WINAPI	GetOEMCP (void)

BOOL WINAPI	IsValidCodePage (UINT codepage)

BOOL WINAPI	IsDBCSLeadByteEx (UINT codepage, BYTE testchar)

BOOL WINAPI	IsDBCSLeadByte (BYTE testchar)

BOOL WINAPI	GetCPInfo (UINT codepage, LPCPINFO cpinfo)

BOOL WINAPI	GetCPInfoExA (UINT codepage, DWORD dwFlags, LPCPINFOEXA cpinfo)

BOOL WINAPI	GetCPInfoExW (UINT codepage, DWORD dwFlags, LPCPINFOEXW cpinfo)

BOOL WINAPI	EnumSystemCodePagesA (CODEPAGE_ENUMPROCA lpfnCodePageEnum, DWORD flags)

BOOL WINAPI	EnumSystemCodePagesW (CODEPAGE_ENUMPROCW lpfnCodePageEnum, DWORD flags)

static BOOL	utf7_write_w (WCHAR dst, int dstlen, int index, WCHAR character)

static int	utf7_mbstowcs (const char src, int srclen, WCHAR dst, int dstlen)

INT WINAPI	MultiByteToWideChar (UINT page, DWORD flags, LPCSTR src, INT srclen, LPWSTR dst, INT dstlen)

static BOOL	utf7_can_directly_encode (WCHAR codepoint)

static BOOL	utf7_write_c (char dst, int dstlen, int index, char character)

static int	utf7_wcstombs (const WCHAR src, int srclen, char dst, int dstlen)

INT WINAPI	WideCharToMultiByte (UINT page, DWORD flags, LPCWSTR src, INT srclen, LPSTR dst, INT dstlen, LPCSTR defchar, BOOL *used)

LCID WINAPI	GetThreadLocale (void)

BOOL WINAPI	SetThreadLocale (LCID lcid)

LANGID WINAPI	SetThreadUILanguage (LANGID langid)

LCID WINAPI	ConvertDefaultLocale (LCID lcid)

BOOL WINAPI	IsValidLocale (LCID lcid, DWORD flags)

BOOL WINAPI	IsValidLocaleName (LPCWSTR locale)

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 locale, DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen, LPNLSVERSIONINFO version, LPVOID reserved, LPARAM handle)

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

int WINAPI	lstrcmpA (LPCSTR str1, LPCSTR str2)

int WINAPI	lstrcmpiA (LPCSTR str1, LPCSTR str2)

int WINAPI	lstrcmpW (LPCWSTR str1, LPCWSTR str2)

int WINAPI	lstrcmpiW (LPCWSTR str1, LPCWSTR str2)

void	LOCALE_Init (void)

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)

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

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

INT WINAPI	GetUserDefaultLocaleName (LPWSTR localename, int buffersize)

INT WINAPI	NormalizeString (NORM_FORM NormForm, LPCWSTR lpSrcString, INT cwSrcLength, LPWSTR lpDstString, INT cwDstLength)

BOOL WINAPI	IsNormalizedString (NORM_FORM NormForm, LPCWSTR lpString, INT cwLength)

static INT	adapt (INT delta, INT numpoints, BOOL firsttime)

INT WINAPI	IdnToAscii (DWORD dwFlags, LPCWSTR lpUnicodeCharStr, INT cchUnicodeChar, LPWSTR lpASCIICharStr, INT cchASCIIChar)

INT WINAPI	IdnToNameprepUnicode (DWORD dwFlags, LPCWSTR lpUnicodeCharStr, INT cchUnicodeChar, LPWSTR lpNameprepCharStr, INT cchNameprepChar)

INT WINAPI	IdnToUnicode (DWORD dwFlags, LPCWSTR lpASCIICharStr, INT cchASCIIChar, LPWSTR lpUnicodeCharStr, INT cchUnicodeChar)

BOOL WINAPI	GetFileMUIPath (DWORD flags, PCWSTR filepath, PWSTR language, PULONG languagelen, PWSTR muipath, PULONG muipathlen, PULONGLONG enumerator)

BOOL WINAPI	GetFileMUIInfo (DWORD flags, PCWSTR path, FILEMUIINFO info, DWORD size)

INT WINAPI	ResolveLocaleName (LPCWSTR name, LPWSTR localename, INT len)

Variables
HMODULE	kernel32_handle

static const union cptable *	ansi_cptable

static const union cptable *	oem_cptable

static const union cptable *	mac_cptable

static const union cptable *	unix_cptable

static const WCHAR	szLocaleKeyName []

static const WCHAR	szLangGroupsKeyName []

static LCID	lcid_LC_COLLATE

static LCID	lcid_LC_CTYPE

static LCID	lcid_LC_MESSAGES

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

◆ GET_UNIX_LOCALE

#define GET_UNIX_LOCALE ( cat )

Value:

    do \
    if ((locale = get_locale( cat, #cat ))) \
    { \
        strcpynAtoW( buffer, locale, sizeof(buffer)/sizeof(WCHAR) ); \
        if (!strcmpW( buffer, ctype_buff )) lcid_##cat = lcid_LC_CTYPE; \
        else { \
            parse_locale_name( buffer, &locale_name );  \
            lcid_##cat = locale_name.lcid; \
            TRACE( "got lcid %04x (%d matches) for " #cat "=%s\n",        \
                   locale_name.lcid, locale_name.matches, debugstr_a(locale) ); \
        } \
    } while (0)

◆ 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 57 of file locale.c.

◆ LOCALE_NAME_USER_DEFAULT

#define LOCALE_NAME_USER_DEFAULT NULL

Definition at line 42 of file locale.c.

◆ MB_FLAGSMASK

#define MB_FLAGSMASK (MB_PRECOMPOSED|MB_COMPOSITE|MB_USEGLYPHCHARS|MB_ERR_INVALID_CHARS)

Definition at line 59 of file locale.c.

◆ NDEBUG

#define NDEBUG

Definition at line 26 of file locale.c.

◆ NLSRC_OFFSET

#define NLSRC_OFFSET 5000 /* FIXME */

Definition at line 53 of file locale.c.

◆ REG_SZ

#define REG_SZ 1

Definition at line 44 of file locale.c.

◆ WC_FLAGSMASK

#define WC_FLAGSMASK

Value:

(WC_DISCARDNS|WC_SEPCHARS|WC_DEFAULTCHAR|WC_ERR_INVALID_CHARS|\

WC_COMPOSITECHECK|WC_NO_BEST_FIT_CHARS)

WC_DEFAULTCHAR

#define WC_DEFAULTCHAR

Definition: unicode.h:45

WC_COMPOSITECHECK

#define WC_COMPOSITECHECK

Definition: unicode.h:43

WC_DISCARDNS

#define WC_DISCARDNS

Definition: unicode.h:44

WC_ERR_INVALID_CHARS

#define WC_ERR_INVALID_CHARS

Definition: unicode.h:47

WC_NO_BEST_FIT_CHARS

#define WC_NO_BEST_FIT_CHARS

Definition: unicode.h:46

WC_SEPCHARS

#define WC_SEPCHARS

Definition: winnls.h:219

Definition at line 60 of file locale.c.

◆ WINVER

#define WINVER DLL_EXPORT_VERSION

Definition at line 39 of file locale.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
BASE
TMIN
TMAX
SKEW
DAMP
INIT_BIAS
INIT_N

Definition at line 5676 of file locale.c.

     {
    BASE = 36,
    TMIN = 1,
    TMAX = 26,
    SKEW = 38,
    DAMP = 700,
    INIT_BIAS = 72,
    INIT_N = 128
};

◆ locationkind

enum locationkind

Enumerator
LOCATION_NATION
LOCATION_REGION
LOCATION_BOTH

Definition at line 4998 of file locale.c.

                  {
    LOCATION_NATION = 0,
    LOCATION_REGION,
    LOCATION_BOTH
};

Function Documentation

◆ adapt()

static INT adapt	(	INT	delta,
		INT	numpoints,
		BOOL	firsttime
	)

inlinestatic

Definition at line 5686 of file locale.c.

{
    INT k;
 
    delta /= (firsttime ? DAMP : 2);
    delta += delta/numpoints;
 
    for(k=0; delta>((BASE-TMIN)*TMAX)/2; k+=BASE)
        delta /= BASE-TMIN;
    return k+((BASE-TMIN+1)*delta)/(delta+SKEW);
}

Referenced by IdnToAscii(), and IdnToUnicode().

◆ CompareStringA()

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

Definition at line 4082 of file locale.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 4022 of file locale.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 4013 of file locale.c.

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

Referenced by __crtCompareStringW(), _WLocale_strcmp_aux(), CEnumMergedFolder::Begin(), ChrCmpIW(), COMCTL32_ChrCmpIW(), CEnumMergedFolder::FindByName(), HTMLElementCollection_tags(), HTTP_DealWithProxy(), HTTP_FixURL(), IntlStrEqWorkerW(), LISTBOX_lstrcmpiW(), lstrcmpiW(), lstrcmpW(), lstrncmpiW(), lstrstri(), map_type(), MatchString(), 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 586 of file locale.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 2876 of file locale.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 = get_default_sublang( langid );
          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 765 of file locale.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(), LOCALE_InitRegistry(), 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 2950 of file locale.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 2960 of file locale.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 3015 of file locale.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, sizeof(buffer) / sizeof(WCHAR) );
    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 4920 of file locale.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 4930 of file locale.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 4774 of file locale.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 4795 of file locale.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	lpfnCodePageEnum,
		DWORD	flags
	)

Definition at line 2273 of file locale.c.

{
    const union cptable *table;
    char buffer[10];
    int index = 0;
 
    for (;;)
    {
        if (!(table = wine_cp_enum_table( index++ ))) break;
        sprintf( buffer, "%d", table->info.codepage );
        if (!lpfnCodePageEnum( buffer )) break;
    }
    return TRUE;
}

◆ EnumSystemCodePagesW()

BOOL WINAPI EnumSystemCodePagesW	(	CODEPAGE_ENUMPROCW	lpfnCodePageEnum,
		DWORD	flags
	)

Definition at line 2294 of file locale.c.

{
    const union cptable *table;
    WCHAR buffer[10], *p;
    int page, index = 0;
 
    for (;;)
    {
        if (!(table = wine_cp_enum_table( index++ ))) break;
        p = buffer + sizeof(buffer)/sizeof(WCHAR);
        *--p = 0;
        page = table->info.codepage;
        do
        {
            *--p = '0' + (page % 10);
            page /= 10;
        } while( page );
        if (!lpfnCodePageEnum( p )) break;
    }
    return TRUE;
}

Referenced by InitCodePagesList().

◆ EnumSystemGeoID()

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

Definition at line 5609 of file locale.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 4575 of file locale.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 4595 of file locale.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 2983 of file locale.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 3038 of file locale.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 2998 of file locale.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 4944 of file locale.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 4972 of file locale.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 3920 of file locale.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 3978 of file locale.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_codepage_table()

static const union cptable * get_codepage_table ( unsigned int codepage )

static

Definition at line 301 of file locale.c.

{
    const union cptable *ret = NULL;
 
    assert( ansi_cptable );  /* init must have been done already */
 
    switch(codepage)
    {
    case CP_ACP:
        return ansi_cptable;
    case CP_OEMCP:
        return oem_cptable;
    case CP_MACCP:
        return mac_cptable;
    case CP_UTF7:
    case CP_UTF8:
        break;
    case CP_THREAD_ACP:
        if (NtCurrentTeb()->CurrentLocale == GetUserDefaultLCID()) return ansi_cptable;
        codepage = get_lcid_codepage( NtCurrentTeb()->CurrentLocale );
        if (!codepage) return ansi_cptable;
        /* fall through */
    default:
        if (codepage == ansi_cptable->info.codepage) return ansi_cptable;
        if (codepage == oem_cptable->info.codepage) return oem_cptable;
        if (codepage == mac_cptable->info.codepage) return mac_cptable;
        ret = wine_cp_get_table( codepage );
        break;
    }
    return ret;
}

Referenced by GetCPInfo(), GetCPInfoExW(), IsDBCSLeadByteEx(), MultiByteToWideChar(), and WideCharToMultiByte().

◆ get_default_sublang()

static LANGID get_default_sublang ( LANGID lang )

static

Definition at line 366 of file locale.c.

{
    switch (lang)
    {
    case MAKELANGID( LANG_SPANISH, SUBLANG_NEUTRAL ):
        return MAKELANGID( LANG_SPANISH, SUBLANG_SPANISH_MODERN );
    case MAKELANGID( LANG_CHINESE, SUBLANG_NEUTRAL ):
        return MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED );
    case MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_SINGAPORE ):
        return MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED );
    case MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL ):
    case MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_MACAU ):
        return MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_HONGKONG );
    }
    if (SUBLANGID( lang ) == SUBLANG_NEUTRAL) lang = MAKELANGID( PRIMARYLANGID(lang), SUBLANG_DEFAULT );
    return lang;
}

Referenced by ConvertDefaultLocale(), GetLocaleInfoW(), and NLS_GetLanguageGroupName().

◆ get_dummy_preferred_ui_language()

static BOOL get_dummy_preferred_ui_language	(	DWORD	flags,
		ULONG *	count,
		WCHAR *	buffer,
		ULONG *	size
	)

static

Definition at line 1246 of file locale.c.

{
    LCTYPE type;
    int lsize;
 
    FIXME("(0x%x %p %p %p) returning a dummy value (current locale)\n", flags, count, buffer, size);
 
    if (flags & MUI_LANGUAGE_ID)
        type = LOCALE_ILANGUAGE;
    else
        type = LOCALE_SNAME;
 
    lsize = GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, type, NULL, 0);
    if (!lsize)
    {
        /* keep last error from callee */
        return FALSE;
    }
    lsize++;
    if (!*size)
    {
        *size = lsize;
        *count = 1;
        return TRUE;
    }
 
    if (lsize > *size)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    if (!GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, type, buffer, *size))
    {
        /* keep last error from callee */
        return FALSE;
    }
 
    buffer[lsize-1] = 0;
    *size = lsize;
    *count = 1;
    TRACE("returned variable content: %d, \"%s\", %d\n", *count, debugstr_w(buffer), *size);
    return TRUE;
 
}

Referenced by GetSystemPreferredUILanguages(), and GetThreadPreferredUILanguages().

◆ get_geoinfo_dataptr()

static const struct geoinfo_t * get_geoinfo_dataptr ( GEOID geoid )

static

Definition at line 5463 of file locale.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 entries */
            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 287 of file locale.c.

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

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

◆ get_locale()

static const char * get_locale	(	int	category,
		const char *	category_name
	)

static

Definition at line 1020 of file locale.c.

{
    const char* ret = setlocale(category, NULL);
 
#ifdef __ANDROID__
    if (!strcmp(ret, "C"))
    {
        ret = getenv( category_name );
        if (!ret || !ret[0]) ret = getenv( "LC_ALL" );
        if (!ret || !ret[0]) ret = "C";
    }
#endif
 
#ifdef __APPLE__
    /* If LC_ALL is set, respect it as a user override.
       If LC_* is set, respect it as a user override, except if it's LC_CTYPE
       and equal to UTF-8.  That's because, when the Mac locale isn't supported
       by the C library, Terminal.app sets LC_CTYPE=UTF-8 and doesn't set LANG.
       parse_locale_name() doesn't handle that properly, so we override that
       with the Mac locale (which uses UTF-8 for the charset, anyway).
       Otherwise:
       For LC_MESSAGES, we override the C library because the user language
       setting is separate from the locale setting on which LANG was based.
       If the C library didn't get anything better from LANG than C or POSIX,
       override that.  That probably means the Mac locale isn't supported by
       the C library. */
    if (!has_env( "LC_ALL" ) &&
        ((category == LC_CTYPE && !strcmp( ret, "UTF-8" )) ||
         (!has_env( category_name ) &&
          (category == LC_MESSAGES || !strcmp( ret, "C" ) || !strcmp( ret, "POSIX" )))))
    {
        const char* override = get_mac_locale();
 
        if (category == LC_MESSAGES)
        {
            /* Retrieve the preferred language as chosen in System Preferences. */
            static char messages_locale[50];
 
            if (!messages_locale[0])
            {
                CFArrayRef preferred_langs = CFLocaleCopyPreferredLanguages();
                if (preferred_langs && CFArrayGetCount( preferred_langs ))
                {
                    CFStringRef preferred_lang = CFArrayGetValueAtIndex( preferred_langs, 0 );
                    CFDictionaryRef components = CFLocaleCreateComponentsFromLocaleIdentifier( NULL, preferred_lang );
                    if (components)
                    {
                        CFStringRef lang = CFDictionaryGetValue( components, kCFLocaleLanguageCode );
                        CFStringRef country = CFDictionaryGetValue( components, kCFLocaleCountryCode );
                        CFLocaleRef locale = NULL;
                        CFStringRef locale_string;
 
                        if (!country)
                        {
                            locale = CFLocaleCopyCurrent();
                            country = CFLocaleGetValue( locale, kCFLocaleCountryCode );
                        }
 
                        if (country)
                            locale_string = CFStringCreateWithFormat( NULL, NULL, CFSTR("%@_%@"), lang, country );
                        else
                            locale_string = CFStringCreateCopy( NULL, lang );
                        CFStringGetCString( locale_string, messages_locale, sizeof(messages_locale), kCFStringEncodingUTF8 );
                        strcat( messages_locale, ".UTF-8" );
 
                        CFRelease( locale_string );
                        if (locale) CFRelease( locale );
                        CFRelease( components );
                    }
                }
                if (preferred_langs)
                    CFRelease( preferred_langs );
            }
 
            if (messages_locale[0])
                override = messages_locale;
        }
 
        TRACE( "%s is %s; overriding with %s\n", category_name, debugstr_a(ret), debugstr_a(override) );
        ret = override;
    }
#endif
 
    return ret;
}

◆ get_locale_registry_value()

static struct registry_value * get_locale_registry_value ( DWORD lctype )

static

Definition at line 1451 of file locale.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 1467 of file locale.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_table_entry()

static unsigned short get_table_entry	(	const unsigned short *	table,
		WCHAR	ch
	)

inlinestatic

Definition at line 276 of file locale.c.

{
    return table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0xf)];
}

Referenced by IdnToNameprepUnicode(), and IdnToUnicode().

◆ get_value_base_by_lctype()

static int get_value_base_by_lctype ( LCTYPE lctype )

static

Definition at line 1655 of file locale.c.

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

Referenced by GetLocaleInfoW().

◆ GetACP()

UINT WINAPI GetACP ( void )

Definition at line 2020 of file locale.c.

{
    assert( ansi_cptable );
    return ansi_cptable->info.codepage;
}

Referenced by _setmbcp_l(), cicGetOSInfo(), CON_API(), EngGetCurrentCodePage(), get_codeset(), GetStringTypeA(), GetSupportedCP(), Global_Chr(), Imm32InquireIme(), IPropertyStorage_fnReadMultiple(), IPropertyStorage_fnWriteMultiple(), ME_StreamOutRTFHeader(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), MimeInternat_ConvertString(), MimeInternat_GetDefaultCharset(), name_to_codepage(), PropertyStorage_ConstructEmpty(), PropertyStorage_ReadFromStream(), SetCPGlobal(), test_bitmap_font_metrics(), test_defaultcharset(), test_EnumFontFamiliesEx_default_charset(), test_file_monikers(), test_FoldStringA(), test_GdiGetCodePage(), test_GetFullPathNameA(), test_mbcp(), test_nonexistent_font(), test_text_metrics(), and test_threadcp().

◆ GetCPInfo()

BOOL WINAPI GetCPInfo	(	UINT	codepage,
		LPCPINFO	cpinfo
	)

Definition at line 2143 of file locale.c.

{
    const union cptable *table;
 
    if (!cpinfo)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (!(table = get_codepage_table( codepage )))
    {
        switch(codepage)
        {
            case CP_UTF7:
            case CP_UTF8:
                cpinfo->DefaultChar[0] = 0x3f;
                cpinfo->DefaultChar[1] = 0;
                cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
                cpinfo->MaxCharSize = (codepage == CP_UTF7) ? 5 : 4;
                return TRUE;
        }
 
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (table->info.def_char & 0xff00)
    {
        cpinfo->DefaultChar[0] = (table->info.def_char & 0xff00) >> 8;
        cpinfo->DefaultChar[1] = table->info.def_char & 0x00ff;
    }
    else
    {
        cpinfo->DefaultChar[0] = table->info.def_char & 0xff;
        cpinfo->DefaultChar[1] = 0;
    }
    if ((cpinfo->MaxCharSize = table->info.char_size) == 2)
        memcpy( cpinfo->LeadByte, table->dbcs.lead_bytes, sizeof(cpinfo->LeadByte) );
    else
        cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
 
    return TRUE;
}

Referenced by _Locale_codecvt_create(), _Locale_ctype_create(), _setmbcp_l(), GetCPInfoExW(), GetKerningPairsA(), Global_Chr(), make_csconv(), ME_GetTextLengthEx(), MSVCRT__create_locale(), test_GetCPInfo(), and test_mbcp().

◆ GetCPInfoExA()

BOOL WINAPI GetCPInfoExA	(	UINT	codepage,
		DWORD	dwFlags,
		LPCPINFOEXA	cpinfo
	)

Definition at line 2201 of file locale.c.

{
    CPINFOEXW cpinfoW;
 
    if (!GetCPInfoExW( codepage, dwFlags, &cpinfoW ))
      return FALSE;
 
    /* the layout is the same except for CodePageName */
    memcpy(cpinfo, &cpinfoW, sizeof(CPINFOEXA));
    WideCharToMultiByte(CP_ACP, 0, cpinfoW.CodePageName, -1, cpinfo->CodePageName, sizeof(cpinfo->CodePageName), NULL, NULL);
    return TRUE;
}

Referenced by init_procs(), and test_threadcp().

◆ GetCPInfoExW()

BOOL WINAPI GetCPInfoExW	(	UINT	codepage,
		DWORD	dwFlags,
		LPCPINFOEXW	cpinfo
	)

Definition at line 2219 of file locale.c.

{
    if (!GetCPInfo( codepage, (LPCPINFO)cpinfo ))
      return FALSE;
 
    switch(codepage)
    {
        case CP_UTF7:
        {
            static const WCHAR utf7[] = {'U','n','i','c','o','d','e',' ','(','U','T','F','-','7',')',0};
 
            cpinfo->CodePage = CP_UTF7;
            cpinfo->UnicodeDefaultChar = 0x3f;
            strcpyW(cpinfo->CodePageName, utf7);
            break;
        }
 
        case CP_UTF8:
        {
            static const WCHAR utf8[] = {'U','n','i','c','o','d','e',' ','(','U','T','F','-','8',')',0};
 
            cpinfo->CodePage = CP_UTF8;
            cpinfo->UnicodeDefaultChar = 0x3f;
            strcpyW(cpinfo->CodePageName, utf8);
            break;
        }
 
        default:
        {
            const union cptable *table = get_codepage_table( codepage );
 
            cpinfo->CodePage = table->info.codepage;
            cpinfo->UnicodeDefaultChar = table->info.def_unicode_char;
            MultiByteToWideChar( CP_ACP, 0, table->info.name, -1, cpinfo->CodePageName,
                                 sizeof(cpinfo->CodePageName)/sizeof(WCHAR));
            break;
        }
    }
    return TRUE;
}

Referenced by AddCodePage(), FillCharacterSetComboList(), GetCPInfoExA(), GetSupportedCP(), and ME_StreamOutRTFHeader().

◆ GetFileMUIInfo()

BOOL WINAPI GetFileMUIInfo	(	DWORD	flags,
		PCWSTR	path,
		FILEMUIINFO *	info,
		DWORD *	size
	)

Definition at line 6227 of file locale.c.

{
    FIXME("stub: %u, %s, %p, %p\n", flags, debugstr_w(path), info, size);
 
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

◆ GetFileMUIPath()

BOOL WINAPI GetFileMUIPath	(	DWORD	flags,
		PCWSTR	filepath,
		PWSTR	language,
		PULONG	languagelen,
		PWSTR	muipath,
		PULONG	muipathlen,
		PULONGLONG	enumerator
	)

Definition at line 6212 of file locale.c.

{
    FIXME("stub: 0x%x, %s, %s, %p, %p, %p, %p\n", flags, debugstr_w(filepath),
           debugstr_w(language), languagelen, muipath, muipathlen, enumerator);
 
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 
    return FALSE;
}

◆ GetGeoInfoA()

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

Definition at line 5565 of file locale.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 5491 of file locale.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 1599 of file locale.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 1665 of file locale.c.

{
    LANGID lang_id;
    HRSRC hrsrc;
    HGLOBAL hmem;
    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 = get_default_sublang( lang_id );
 
    if (!(hrsrc = FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING,
                                   ULongToPtr((lctype >> 4) + 1), lang_id )))
    {
        SetLastError( ERROR_INVALID_FLAGS );  /* no such lctype */
        return 0;
    }
    if (!(hmem = LoadResource( kernel32_handle, hrsrc )))
        return 0;
 
    p = LockResource( hmem );
    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
        ret = (lctype == LOCALE_FONTSIGNATURE) ? *p : *p + 1;
 
    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
    {
        memcpy( buffer, p + 1, 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_dummy_preferred_ui_language(), get_input_codepage(), get_lcid_codepage(), get_locale(), GetCalendarInfoW(), CicProfile::GetCodePageA(), GetCurrencyFormatW(), GetFileVersion(), GetFontSig(), GetHKLName(), GetKeyboardLayoutCP(), GetLocaleInfoA(), GetLocalizedSMFolderName(), GetNumberFormatW(), CConfigParser::GetSectionString(), InatCreateIconBySize(), InitializeDefaultUserLocale(), InitLanguagesList(), InputList_Add(), InputList_Create(), Int64GetNumFormat(), IntGetCodePageEntry(), is_default_metric(), IsBiDiLocalizedSystem(), IsLayoutExists(), lcid_to_rfc1766W(), LOCALE_Init(), LOCALE_InitRegistry(), locale_update_registry(), 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
	)

◆ GetOEMCP()

UINT WINAPI GetOEMCP ( void )

Definition at line 2059 of file locale.c.

{
    assert( oem_cptable );
    return oem_cptable->info.codepage;
}

Referenced by _setmbcp_l(), ConCfgInitDefaultSettings(), ConSrvInitConsole(), EngGetCurrentCodePage(), GetKBCodePage(), GetSupportedCP(), ME_StreamOutRTFHeader(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), OnNcCreate(), output_writeconsole(), SetUpConsoleInfo(), and START_TEST().

◆ GetStringTypeA()

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

Definition at line 3208 of file locale.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 3255 of file locale.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 3184 of file locale.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 3094 of file locale.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 1193 of file locale.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 1229 of file locale.c.

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

Referenced by Applet(), ConvertDefaultLocale(), CreateTypeLib2(), GetSystemDefaultLangID(), GetSystemDefaultLocaleName(), Imm32IsSystemJapaneseOrKorean(), ImmFreeLayout(), ImmGenerateMessage(), ImmPostMessages(), ImmProcessKey(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), InitLangChangeHotKey(), 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().

◆ GetSystemDefaultLocaleName()

INT WINAPI GetSystemDefaultLocaleName	(	LPWSTR	localename,
		INT	len
	)

Definition at line 1240 of file locale.c.

{
    LCID lcid = GetSystemDefaultLCID();
    return LCIDToLocaleName(lcid, localename, len, 0);
}

◆ GetSystemDefaultUILanguage()

LANGID WINAPI GetSystemDefaultUILanguage ( void )

Definition at line 1394 of file locale.c.

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

Referenced by LsaLookupPrivilegeDisplayName(), and SHGetWebFolderFilePathW().

◆ GetSystemPreferredUILanguages()

BOOL WINAPI GetSystemPreferredUILanguages	(	DWORD	flags,
		ULONG *	count,
		WCHAR *	buffer,
		ULONG *	size
	)

Definition at line 1295 of file locale.c.

{
    if (flags & ~(MUI_LANGUAGE_NAME | MUI_LANGUAGE_ID | MUI_MACHINE_LANGUAGE_SETTINGS))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if ((flags & MUI_LANGUAGE_NAME) && (flags & MUI_LANGUAGE_ID))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (*size && !buffer)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    return get_dummy_preferred_ui_language( flags, count, buffer, size );
}

Referenced by InitFunctionPointers().

◆ GetThreadLocale()

LCID WINAPI GetThreadLocale ( void )

Definition at line 2800 of file locale.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(), GetAddressBarAccessKey(), 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().

◆ GetThreadPreferredUILanguages()

BOOL WINAPI GetThreadPreferredUILanguages	(	DWORD	flags,
		ULONG *	count,
		WCHAR *	buf,
		ULONG *	size
	)

Definition at line 1328 of file locale.c.

{
    FIXME( "%08x, %p, %p %p\n", flags, count, buf, size );
    return get_dummy_preferred_ui_language( flags, count, buf, size );
}

Referenced by InitFunctionPointers().

◆ GetUserDefaultLangID()

LANGID WINAPI GetUserDefaultLangID ( void )

Definition at line 1176 of file locale.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 1210 of file locale.c.

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

Referenced by ActiveScriptSite_GetLCID(), CConfigParser::CacheINI(), call_disp_func(), CliImmInitializeHotKeys(), ConvertDefaultLocale(), CreateLanguagesList(), get_codepage_table(), GetAcceptLanguagesW(), GetLocalizedSMFolderName(), CConfigParser::GetSectionString(), GetThreadLocale(), GetUserDefaultLangID(), GetUserDefaultLocaleName(), InputProcessorProfiles_Constructor(), CAvailableApplicationInfo::InsertLanguageInfo(), LISTBOX_Create(), LoadSetupData(), LOCALE_InitRegistry(), SetUserLocaleName(), START_TEST(), test_ConvertDefaultLocale(), test_GetAcceptLanguagesA(), test_GetKeyboardLayoutList(), test_GetLocaleInfoEx(), test_LocaleNameToLCID(), test_SetLocaleInfoA(), test_synthesized(), and test_VarFormat().

◆ GetUserDefaultLocaleName()

INT WINAPI GetUserDefaultLocaleName	(	LPWSTR	localename,
		int	buffersize
	)

Definition at line 5645 of file locale.c.

{
    LCID userlcid;
 
    TRACE("%p, %d\n", localename,  buffersize);
 
    userlcid = GetUserDefaultLCID();
    return LCIDToLocaleName(userlcid, localename, buffersize, 0);
}

◆ GetUserDefaultUILanguage()

LANGID WINAPI GetUserDefaultUILanguage ( void )

Definition at line 1374 of file locale.c.

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

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

◆ GetUserGeoID()

GEOID WINAPI GetUserGeoID ( GEOCLASS GeoClass )

Definition at line 4837 of file locale.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().

◆ IdnToAscii()

INT WINAPI IdnToAscii	(	DWORD	dwFlags,
		LPCWSTR	lpUnicodeCharStr,
		INT	cchUnicodeChar,
		LPWSTR	lpASCIICharStr,
		INT	cchASCIIChar
	)

Definition at line 5702 of file locale.c.

{
    static const WCHAR prefixW[] = {'x','n','-','-'};
 
    WCHAR *norm_str;
    INT i, label_start, label_end, norm_len, out_label, out = 0;
 
    TRACE("%x %p %d %p %d\n", dwFlags, lpUnicodeCharStr, cchUnicodeChar,
        lpASCIICharStr, cchASCIIChar);
 
    norm_len = IdnToNameprepUnicode(dwFlags, lpUnicodeCharStr, cchUnicodeChar, NULL, 0);
    if(!norm_len)
        return 0;
    norm_str = HeapAlloc(GetProcessHeap(), 0, norm_len*sizeof(WCHAR));
    if(!norm_str) {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return 0;
    }
    norm_len = IdnToNameprepUnicode(dwFlags, lpUnicodeCharStr,
            cchUnicodeChar, norm_str, norm_len);
    if(!norm_len) {
        HeapFree(GetProcessHeap(), 0, norm_str);
        return 0;
    }
 
    for(label_start=0; label_start<norm_len;) {
        INT n = INIT_N, bias = INIT_BIAS;
        INT delta = 0, b = 0, h;
 
        out_label = out;
        for(i=label_start; i<norm_len && norm_str[i]!='.' &&
                norm_str[i]!=0x3002 && norm_str[i]!='\0'; i++)
            if(norm_str[i] < 0x80)
                b++;
        label_end = i;
 
        if(b == label_end-label_start) {
            if(label_end < norm_len)
                b++;
            if(!lpASCIICharStr) {
                out += b;
            }else if(out+b <= cchASCIIChar) {
                memcpy(lpASCIICharStr+out, norm_str+label_start, b*sizeof(WCHAR));
                out += b;
            }else {
                HeapFree(GetProcessHeap(), 0, norm_str);
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
            label_start = label_end+1;
            continue;
        }
 
        if(!lpASCIICharStr) {
            out += 5+b; /* strlen(xn--...-) */
        }else if(out+5+b <= cchASCIIChar) {
            memcpy(lpASCIICharStr+out, prefixW, sizeof(prefixW));
            out += 4;
            for(i=label_start; i<label_end; i++)
                if(norm_str[i] < 0x80)
                    lpASCIICharStr[out++] = norm_str[i];
            lpASCIICharStr[out++] = '-';
        }else {
            HeapFree(GetProcessHeap(), 0, norm_str);
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return 0;
        }
        if(!b)
            out--;
 
        for(h=b; h<label_end-label_start;) {
            INT m = 0xffff, q, k;
 
            for(i=label_start; i<label_end; i++) {
                if(norm_str[i]>=n && m>norm_str[i])
                    m = norm_str[i];
            }
            delta += (m-n)*(h+1);
            n = m;
 
            for(i=label_start; i<label_end; i++) {
                if(norm_str[i] < n) {
                    delta++;
                }else if(norm_str[i] == n) {
                    for(q=delta, k=BASE; ; k+=BASE) {
                        INT t = k<=bias ? TMIN : k>=bias+TMAX ? TMAX : k-bias;
                        INT disp = q<t ? q : t+(q-t)%(BASE-t);
                        if(!lpASCIICharStr) {
                            out++;
                        }else if(out+1 <= cchASCIIChar) {
                            lpASCIICharStr[out++] = disp<='z'-'a' ?
                                'a'+disp : '0'+disp-'z'+'a'-1;
                        }else {
                            HeapFree(GetProcessHeap(), 0, norm_str);
                            SetLastError(ERROR_INSUFFICIENT_BUFFER);
                            return 0;
                        }
                        if(q < t)
                            break;
                        q = (q-t)/(BASE-t);
                    }
                    bias = adapt(delta, h+1, h==b);
                    delta = 0;
                    h++;
                }
            }
            delta++;
            n++;
        }
 
        if(out-out_label > 63) {
            HeapFree(GetProcessHeap(), 0, norm_str);
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        if(label_end < norm_len) {
            if(!lpASCIICharStr) {
                out++;
            }else if(out+1 <= cchASCIIChar) {
                lpASCIICharStr[out++] = norm_str[label_end] ? '.' : 0;
            }else {
                HeapFree(GetProcessHeap(), 0, norm_str);
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
        }
        label_start = label_end+1;
    }
 
    HeapFree(GetProcessHeap(), 0, norm_str);
    return out;
}

Referenced by InitFunctionPointers().

◆ IdnToNameprepUnicode()

INT WINAPI IdnToNameprepUnicode	(	DWORD	dwFlags,
		LPCWSTR	lpUnicodeCharStr,
		INT	cchUnicodeChar,
		LPWSTR	lpNameprepCharStr,
		INT	cchNameprepChar
	)

Definition at line 5840 of file locale.c.

{
    enum {
        UNASSIGNED = 0x1,
        PROHIBITED = 0x2,
        BIDI_RAL   = 0x4,
        BIDI_L     = 0x8
    };
 
    extern const unsigned short nameprep_char_type[] DECLSPEC_HIDDEN;
    extern const WCHAR nameprep_mapping[] DECLSPEC_HIDDEN;
    const WCHAR *ptr;
    WORD flags;
    WCHAR buf[64], *map_str, norm_str[64], ch;
    DWORD i, map_len, norm_len, mask, label_start, label_end, out = 0;
    BOOL have_bidi_ral, prohibit_bidi_ral, ascii_only;
 
    TRACE("%x %p %d %p %d\n", dwFlags, lpUnicodeCharStr, cchUnicodeChar,
        lpNameprepCharStr, cchNameprepChar);
 
    if(dwFlags & ~(IDN_ALLOW_UNASSIGNED|IDN_USE_STD3_ASCII_RULES)) {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if(!lpUnicodeCharStr || cchUnicodeChar<-1) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if(cchUnicodeChar == -1)
        cchUnicodeChar = strlenW(lpUnicodeCharStr)+1;
    if(!cchUnicodeChar || (cchUnicodeChar==1 && lpUnicodeCharStr[0]==0)) {
        SetLastError(ERROR_INVALID_NAME);
        return 0;
    }
 
    for(label_start=0; label_start<cchUnicodeChar;) {
        ascii_only = TRUE;
        for(i=label_start; i<cchUnicodeChar; i++) {
            ch = lpUnicodeCharStr[i];
 
            if(i!=cchUnicodeChar-1 && !ch) {
                SetLastError(ERROR_INVALID_NAME);
                return 0;
            }
            /* check if ch is one of label separators defined in RFC3490 */
            if(!ch || ch=='.' || ch==0x3002 || ch==0xff0e || ch==0xff61)
                break;
 
            if(ch > 0x7f) {
                ascii_only = FALSE;
                continue;
            }
 
            if((dwFlags&IDN_USE_STD3_ASCII_RULES) == 0)
                continue;
            if((ch>='a' && ch<='z') || (ch>='A' && ch<='Z')
                    || (ch>='0' && ch<='9') || ch=='-')
                continue;
 
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
        label_end = i;
        /* last label may be empty */
        if(label_start==label_end && ch) {
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        if((dwFlags&IDN_USE_STD3_ASCII_RULES) && (lpUnicodeCharStr[label_start]=='-' ||
                    lpUnicodeCharStr[label_end-1]=='-')) {
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        if(ascii_only) {
            /* maximal label length is 63 characters */
            if(label_end-label_start > 63) {
                SetLastError(ERROR_INVALID_NAME);
                return 0;
            }
            if(label_end < cchUnicodeChar)
                label_end++;
 
            if(!lpNameprepCharStr) {
                out += label_end-label_start;
            }else if(out+label_end-label_start <= cchNameprepChar) {
                memcpy(lpNameprepCharStr+out, lpUnicodeCharStr+label_start,
                        (label_end-label_start)*sizeof(WCHAR));
                if(lpUnicodeCharStr[label_end-1] > 0x7f)
                    lpNameprepCharStr[out+label_end-label_start-1] = '.';
                out += label_end-label_start;
            }else {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
 
            label_start = label_end;
            continue;
        }
 
        map_len = 0;
        for(i=label_start; i<label_end; i++) {
            ch = lpUnicodeCharStr[i];
            ptr = nameprep_mapping + nameprep_mapping[ch>>8];
            ptr = nameprep_mapping + ptr[(ch>>4)&0x0f] + 3*(ch&0x0f);
 
            if(!ptr[0]) map_len++;
            else if(!ptr[1]) map_len++;
            else if(!ptr[2]) map_len += 2;
            else if(ptr[0]!=0xffff || ptr[1]!=0xffff || ptr[2]!=0xffff) map_len += 3;
        }
        if(map_len*sizeof(WCHAR) > sizeof(buf)) {
            map_str = HeapAlloc(GetProcessHeap(), 0, map_len*sizeof(WCHAR));
            if(!map_str) {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return 0;
            }
        }else {
            map_str = buf;
        }
        map_len = 0;
        for(i=label_start; i<label_end; i++) {
            ch = lpUnicodeCharStr[i];
            ptr = nameprep_mapping + nameprep_mapping[ch>>8];
            ptr = nameprep_mapping + ptr[(ch>>4)&0x0f] + 3*(ch&0x0f);
 
            if(!ptr[0]) {
                map_str[map_len++] = ch;
            }else if(!ptr[1]) {
                map_str[map_len++] = ptr[0];
            }else if(!ptr[2]) {
                map_str[map_len++] = ptr[0];
                map_str[map_len++] = ptr[1];
            }else if(ptr[0]!=0xffff || ptr[1]!=0xffff || ptr[2]!=0xffff) {
                map_str[map_len++] = ptr[0];
                map_str[map_len++] = ptr[1];
                map_str[map_len++] = ptr[2];
            }
        }
 
        norm_len = FoldStringW(MAP_FOLDCZONE, map_str, map_len,
                norm_str, sizeof(norm_str)/sizeof(WCHAR)-1);
        if(map_str != buf)
            HeapFree(GetProcessHeap(), 0, map_str);
        if(!norm_len) {
            if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
                SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        if(label_end < cchUnicodeChar) {
            norm_str[norm_len++] = lpUnicodeCharStr[label_end] ? '.' : 0;
            label_end++;
        }
 
        if(!lpNameprepCharStr) {
            out += norm_len;
        }else if(out+norm_len <= cchNameprepChar) {
            memcpy(lpNameprepCharStr+out, norm_str, norm_len*sizeof(WCHAR));
            out += norm_len;
        }else {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return 0;
        }
 
        have_bidi_ral = prohibit_bidi_ral = FALSE;
        mask = PROHIBITED;
        if((dwFlags&IDN_ALLOW_UNASSIGNED) == 0)
            mask |= UNASSIGNED;
        for(i=0; i<norm_len; i++) {
            ch = norm_str[i];
            flags = get_table_entry( nameprep_char_type, ch );
 
            if(flags & mask) {
                SetLastError((flags & PROHIBITED) ? ERROR_INVALID_NAME
                        : ERROR_NO_UNICODE_TRANSLATION);
                return 0;
            }
 
            if(flags & BIDI_RAL)
                have_bidi_ral = TRUE;
            if(flags & BIDI_L)
                prohibit_bidi_ral = TRUE;
        }
 
        if(have_bidi_ral) {
            ch = norm_str[0];
            flags = get_table_entry( nameprep_char_type, ch );
            if((flags & BIDI_RAL) == 0)
                prohibit_bidi_ral = TRUE;
 
            ch = norm_str[norm_len-1];
            flags = get_table_entry( nameprep_char_type, ch );
            if((flags & BIDI_RAL) == 0)
                prohibit_bidi_ral = TRUE;
        }
 
        if(have_bidi_ral && prohibit_bidi_ral) {
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        label_start = label_end;
    }
 
    return out;
}

Referenced by IdnToAscii(), and InitFunctionPointers().

◆ IdnToUnicode()

INT WINAPI IdnToUnicode	(	DWORD	dwFlags,
		LPCWSTR	lpASCIICharStr,
		INT	cchASCIIChar,
		LPWSTR	lpUnicodeCharStr,
		INT	cchUnicodeChar
	)

Definition at line 6055 of file locale.c.

{
    extern const unsigned short nameprep_char_type[];
 
    INT i, label_start, label_end, out_label, out = 0;
    WCHAR ch;
 
    TRACE("%x %p %d %p %d\n", dwFlags, lpASCIICharStr, cchASCIIChar,
        lpUnicodeCharStr, cchUnicodeChar);
 
    for(label_start=0; label_start<cchASCIIChar;) {
        INT n = INIT_N, pos = 0, old_pos, w, k, bias = INIT_BIAS, delim=0, digit, t;
 
        out_label = out;
        for(i=label_start; i<cchASCIIChar; i++) {
            ch = lpASCIICharStr[i];
 
            if(ch>0x7f || (i!=cchASCIIChar-1 && !ch)) {
                SetLastError(ERROR_INVALID_NAME);
                return 0;
            }
 
            if(!ch || ch=='.')
                break;
            if(ch == '-')
                delim = i;
 
            if((dwFlags&IDN_USE_STD3_ASCII_RULES) == 0)
                continue;
            if((ch>='a' && ch<='z') || (ch>='A' && ch<='Z')
                    || (ch>='0' && ch<='9') || ch=='-')
                continue;
 
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
        label_end = i;
        /* last label may be empty */
        if(label_start==label_end && ch) {
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        if((dwFlags&IDN_USE_STD3_ASCII_RULES) && (lpASCIICharStr[label_start]=='-' ||
                    lpASCIICharStr[label_end-1]=='-')) {
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
        if(label_end-label_start > 63) {
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        if(label_end-label_start<4 ||
                tolowerW(lpASCIICharStr[label_start])!='x' ||
                tolowerW(lpASCIICharStr[label_start+1])!='n' ||
                lpASCIICharStr[label_start+2]!='-' || lpASCIICharStr[label_start+3]!='-') {
            if(label_end < cchASCIIChar)
                label_end++;
 
            if(!lpUnicodeCharStr) {
                out += label_end-label_start;
            }else if(out+label_end-label_start <= cchUnicodeChar) {
                memcpy(lpUnicodeCharStr+out, lpASCIICharStr+label_start,
                        (label_end-label_start)*sizeof(WCHAR));
                out += label_end-label_start;
            }else {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
 
            label_start = label_end;
            continue;
        }
 
        if(delim == label_start+3)
            delim++;
        if(!lpUnicodeCharStr) {
            out += delim-label_start-4;
        }else if(out+delim-label_start-4 <= cchUnicodeChar) {
            memcpy(lpUnicodeCharStr+out, lpASCIICharStr+label_start+4,
                    (delim-label_start-4)*sizeof(WCHAR));
            out += delim-label_start-4;
        }else {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return 0;
        }
        if(out != out_label)
            delim++;
 
        for(i=delim; i<label_end;) {
            old_pos = pos;
            w = 1;
            for(k=BASE; ; k+=BASE) {
                ch = i<label_end ? tolowerW(lpASCIICharStr[i++]) : 0;
                if((ch<'a' || ch>'z') && (ch<'0' || ch>'9')) {
                    SetLastError(ERROR_INVALID_NAME);
                    return 0;
                }
                digit = ch<='9' ? ch-'0'+'z'-'a'+1 : ch-'a';
                pos += digit*w;
                t = k<=bias ? TMIN : k>=bias+TMAX ? TMAX : k-bias;
                if(digit < t)
                    break;
                w *= BASE-t;
            }
            bias = adapt(pos-old_pos, out-out_label+1, old_pos==0);
            n += pos/(out-out_label+1);
            pos %= out-out_label+1;
 
            if((dwFlags&IDN_ALLOW_UNASSIGNED)==0 &&
                    get_table_entry(nameprep_char_type, n)==1/*UNASSIGNED*/) {
                SetLastError(ERROR_INVALID_NAME);
                return 0;
            }
            if(!lpUnicodeCharStr) {
                out++;
            }else if(out+1 <= cchASCIIChar) {
                memmove(lpUnicodeCharStr+out_label+pos+1,
                        lpUnicodeCharStr+out_label+pos,
                        (out-out_label-pos)*sizeof(WCHAR));
                lpUnicodeCharStr[out_label+pos] = n;
                out++;
            }else {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
            pos++;
        }
 
        if(out-out_label > 63) {
            SetLastError(ERROR_INVALID_NAME);
            return 0;
        }
 
        if(label_end < cchASCIIChar) {
            if(!lpUnicodeCharStr) {
                out++;
            }else if(out+1 <= cchUnicodeChar) {
                lpUnicodeCharStr[out++] = lpASCIICharStr[label_end];
            }else {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
        }
        label_start = label_end+1;
    }
 
    return out;
}

Referenced by InitFunctionPointers().

◆ InvalidateNLSCache()

BOOL WINAPI InvalidateNLSCache ( void )

Definition at line 4823 of file locale.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 737 of file locale.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().

◆ IsDBCSLeadByte()

BOOL WINAPI IsDBCSLeadByte ( BYTE testchar )

Definition at line 2123 of file locale.c.

{
    if (!ansi_cptable) return FALSE;
    return wine_is_dbcs_leadbyte( ansi_cptable, testchar );
}

Referenced by CharNextA(), CharPrevA(), COMCTL32_ChrCmpHelperA(), IsShortName_U(), map_wparam_AtoW(), PathGetDriveNumberA(), PathIsLFNFileSpecA(), PathIsRelativeA(), PathMakePrettyA(), PathSkipRootA(), RealDefWindowProcA(), server_end_to_end_callback(), SHLWAPI_ChrCmpHelperA(), SHLWAPI_StrRChrHelperA(), SHTruncateString(), StrRChrA(), StrRChrIA(), StrRStrIA(), VkKeyScanA(), and VkKeyScanExA().

◆ IsDBCSLeadByteEx()

BOOL WINAPI IsDBCSLeadByteEx	(	UINT	codepage,
		BYTE	testchar
	)

Definition at line 2103 of file locale.c.

{
    const union cptable *table = get_codepage_table( codepage );
    return table && wine_is_dbcs_leadbyte( table, testchar );
}

Referenced by CharNextExA(), CharPrevExA(), dbcs_mblen(), Global_Chr(), IchWideFromAnsi(), Imm32CompAttrAnsiToWide(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), START_TEST(), test_bitmap_font_glyph_index(), test_text_metrics(), and test_threadcp().

◆ IsNormalizedString()

BOOL WINAPI IsNormalizedString	(	NORM_FORM	NormForm,
		LPCWSTR	lpString,
		INT	cwLength
	)

Definition at line 5669 of file locale.c.

{
    FIXME("%x %p %d\n", NormForm, lpString, cwLength);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

◆ IsValidCodePage()

BOOL WINAPI IsValidCodePage ( UINT codepage )

Definition at line 2078 of file locale.c.

{
    switch(codepage) {
    case CP_UTF7:
    case CP_UTF8:
        return TRUE;
    default:
        return wine_cp_get_table( codepage ) != NULL;
    }
}

Referenced by AddCodePage(), ChangeOutputCP_(), ConCfgReadUserSettings(), ConDrvInitConsole(), ConDrvSetConsoleCP(), ConSrvApplyUserSettings(), fnIMultiLanguage3_ValidateCodePageEx(), make_csconv(), match_name_table_language(), MSVCRT_locale_to_LCID(), test_CP_ThreadLang(), test_EnumCodePages(), test_IsCodePageInstallable(), test_string_conversion(), test_undefined_byte_char(), testScreenBuffer(), and validate_codepage().

◆ IsValidLanguageGroup()

BOOL WINAPI IsValidLanguageGroup	(	LGRPID	lgrpid,
		DWORD	dwFlags
	)

Definition at line 4623 of file locale.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 2922 of file locale.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().

◆ IsValidLocaleName()

BOOL WINAPI IsValidLocaleName ( LPCWSTR locale )

Definition at line 2933 of file locale.c.

{
    struct locale_name locale_name;
 
    if (!locale)
        return FALSE;
 
    /* string parsing */
    parse_locale_name( locale, &locale_name );
 
    TRACE( "found lcid %x for %s, matches %d\n",
           locale_name.lcid, debugstr_w(locale), locale_name.matches );
 
    return locale_name.matches > 0;
}

Referenced by InitFunctionPointers().

◆ LCMapStringA()

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

Definition at line 3830 of file locale.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	locale,
		DWORD	flags,
		LPCWSTR	src,
		INT	srclen,
		LPWSTR	dst,
		INT	dstlen,
		LPNLSVERSIONINFO	version,
		LPVOID	reserved,
		LPARAM	handle
	)

Definition at line 3742 of file locale.c.

{
    if (version) FIXME("unsupported version structure %p\n", version);
    if (reserved) FIXME("unsupported reserved pointer %p\n", reserved);
    if (handle)
    {
        static int once;
        if (!once++) FIXME("unsupported lparam %Ix\n", handle);
    }
 
    if (!src || !srclen || dstlen < 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (srclen < 0) srclen = lstrlenW(src) + 1;
 
    TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
           debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
 
    flags &= ~LOCALE_USE_CP_ACP;
 
    if (src == dst && (flags & ~(LCMAP_LOWERCASE | LCMAP_UPPERCASE)))
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (!dstlen) dst = NULL;
 
    if (flags & LCMAP_SORTKEY)
    {
        INT ret;
 
        if (srclen < 0)
            srclen = strlenW(src);
 
        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;
    }
 
    return lcmap_string(flags, src, srclen, dst, dstlen);
}

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 3804 of file locale.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(), test_LCMapStringW(), and test_tolower().

◆ LOCALE_Init()

void LOCALE_Init ( void )

Definition at line 4278 of file locale.c.

{
    extern void CDECL __wine_init_codepages( const union cptable *ansi_cp, const union cptable *oem_cp,
                                             const union cptable *unix_cp );
 
    UINT ansi_cp = 1252, oem_cp = 437, mac_cp = 10000, unix_cp;
 
    setlocale( LC_ALL, "" );
 
#ifdef __APPLE__
    /* MacOS doesn't set the locale environment variables so we have to do it ourselves */
    if (!has_env("LANG"))
    {
        const char* mac_locale = get_mac_locale();
 
        setenv( "LANG", mac_locale, 1 );
        if (setlocale( LC_ALL, "" ))
            TRACE( "setting LANG to '%s'\n", mac_locale );
        else
        {
            /* no C library locale matching Mac locale; don't pass garbage to children */
            unsetenv("LANG");
            TRACE( "Mac locale %s is not supported by the C library\n", debugstr_a(mac_locale) );
        }
    }
#endif /* __APPLE__ */
 
    unix_cp = setup_unix_locales();
    if (!lcid_LC_MESSAGES) lcid_LC_MESSAGES = lcid_LC_CTYPE;
 
#ifdef __APPLE__
    if (!unix_cp)
        unix_cp = CP_UTF8;  /* default to utf-8 even if we don't get a valid locale */
#endif
 
    NtSetDefaultUILanguage( LANGIDFROMLCID(lcid_LC_MESSAGES) );
    NtSetDefaultLocale( TRUE, lcid_LC_MESSAGES );
    NtSetDefaultLocale( FALSE, lcid_LC_CTYPE );
 
    ansi_cp = get_lcid_codepage( LOCALE_USER_DEFAULT );
    GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IDEFAULTMACCODEPAGE | LOCALE_RETURN_NUMBER,
                    (LPWSTR)&mac_cp, sizeof(mac_cp)/sizeof(WCHAR) );
    GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
                    (LPWSTR)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR) );
    if (!unix_cp)
        GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IDEFAULTUNIXCODEPAGE | LOCALE_RETURN_NUMBER,
                        (LPWSTR)&unix_cp, sizeof(unix_cp)/sizeof(WCHAR) );
 
    if (!(ansi_cptable = wine_cp_get_table( ansi_cp )))
        ansi_cptable = wine_cp_get_table( 1252 );
    if (!(oem_cptable = wine_cp_get_table( oem_cp )))
        oem_cptable  = wine_cp_get_table( 437 );
    if (!(mac_cptable = wine_cp_get_table( mac_cp )))
        mac_cptable  = wine_cp_get_table( 10000 );
    if (unix_cp != CP_UTF8)
    {
        if (!(unix_cptable = wine_cp_get_table( unix_cp )))
            unix_cptable  = wine_cp_get_table( 28591 );
    }
 
    __wine_init_codepages( ansi_cptable, oem_cptable, unix_cptable );
 
    TRACE( "ansi=%03d oem=%03d mac=%03d unix=%03d\n",
           ansi_cptable->info.codepage, oem_cptable->info.codepage,
           mac_cptable->info.codepage, unix_cp );
 
    setlocale(LC_NUMERIC, "C");  /* FIXME: oleaut32 depends on this */
}

◆ LOCALE_InitRegistry()

void LOCALE_InitRegistry ( void )

Definition at line 837 of file locale.c.

{
    static const WCHAR acpW[] = {'A','C','P',0};
    static const WCHAR oemcpW[] = {'O','E','M','C','P',0};
    static const WCHAR maccpW[] = {'M','A','C','C','P',0};
    static const WCHAR localeW[] = {'L','o','c','a','l','e',0};
    static const WCHAR lc_ctypeW[] = { 'L','C','_','C','T','Y','P','E',0 };
    static const WCHAR lc_monetaryW[] = { 'L','C','_','M','O','N','E','T','A','R','Y',0 };
    static const WCHAR lc_numericW[] = { 'L','C','_','N','U','M','E','R','I','C',0 };
    static const WCHAR lc_timeW[] = { 'L','C','_','T','I','M','E',0 };
    static const WCHAR lc_measurementW[] = { 'L','C','_','M','E','A','S','U','R','E','M','E','N','T',0 };
    static const WCHAR lc_telephoneW[] = { 'L','C','_','T','E','L','E','P','H','O','N','E',0 };
    static const WCHAR lc_paperW[] = { 'L','C','_','P','A','P','E','R',0};
    static const struct
    {
        LPCWSTR name;
        USHORT value;
    } update_cp_values[] = {
        { acpW, LOCALE_IDEFAULTANSICODEPAGE },
        { oemcpW, LOCALE_IDEFAULTCODEPAGE },
        { maccpW, LOCALE_IDEFAULTMACCODEPAGE }
    };
    static const LCTYPE lc_messages_values[] = {
      LOCALE_SABBREVLANGNAME,
      LOCALE_SCOUNTRY,
      LOCALE_SLIST };
    static const LCTYPE lc_monetary_values[] = {
      LOCALE_SCURRENCY,
      LOCALE_ICURRENCY,
      LOCALE_INEGCURR,
      LOCALE_ICURRDIGITS,
      LOCALE_ILZERO,
      LOCALE_SMONDECIMALSEP,
      LOCALE_SMONGROUPING,
      LOCALE_SMONTHOUSANDSEP };
    static const LCTYPE lc_numeric_values[] = {
      LOCALE_SDECIMAL,
      LOCALE_STHOUSAND,
      LOCALE_IDIGITS,
      LOCALE_IDIGITSUBSTITUTION,
      LOCALE_SNATIVEDIGITS,
      LOCALE_INEGNUMBER,
      LOCALE_SNEGATIVESIGN,
      LOCALE_SPOSITIVESIGN,
      LOCALE_SGROUPING };
    static const LCTYPE lc_time_values[] = {
      LOCALE_S1159,
      LOCALE_S2359,
      LOCALE_STIME,
      LOCALE_ITIME,
      LOCALE_ITLZERO,
      LOCALE_SSHORTDATE,
      LOCALE_SLONGDATE,
      LOCALE_SDATE,
      LOCALE_ITIMEMARKPOSN,
      LOCALE_ICALENDARTYPE,
      LOCALE_IFIRSTDAYOFWEEK,
      LOCALE_IFIRSTWEEKOFYEAR,
      LOCALE_STIMEFORMAT,
      LOCALE_SYEARMONTH,
      LOCALE_IDATE };
    static const LCTYPE lc_measurement_values[] = { LOCALE_IMEASURE };
    static const LCTYPE lc_telephone_values[] = { LOCALE_ICOUNTRY };
    static const LCTYPE lc_paper_values[] = { LOCALE_IPAPERSIZE };
 
    UNICODE_STRING nameW;
    WCHAR bufferW[80];
    DWORD count, i;
    HANDLE hkey;
    LCID lcid = GetUserDefaultLCID();
 
    if (!(hkey = create_registry_key()))
        return;  /* don't do anything if we can't create the registry key */
 
    locale_update_registry( hkey, localeW, lcid_LC_MESSAGES, lc_messages_values,
                            sizeof(lc_messages_values)/sizeof(lc_messages_values[0]) );
    locale_update_registry( hkey, lc_monetaryW, lcid_LC_MONETARY, lc_monetary_values,
                            sizeof(lc_monetary_values)/sizeof(lc_monetary_values[0]) );
    locale_update_registry( hkey, lc_numericW, lcid_LC_NUMERIC, lc_numeric_values,
                            sizeof(lc_numeric_values)/sizeof(lc_numeric_values[0]) );
    locale_update_registry( hkey, lc_timeW, lcid_LC_TIME, lc_time_values,
                            sizeof(lc_time_values)/sizeof(lc_time_values[0]) );
    locale_update_registry( hkey, lc_measurementW, lcid_LC_MEASUREMENT, lc_measurement_values,
                            sizeof(lc_measurement_values)/sizeof(lc_measurement_values[0]) );
    locale_update_registry( hkey, lc_telephoneW, lcid_LC_TELEPHONE, lc_telephone_values,
                            sizeof(lc_telephone_values)/sizeof(lc_telephone_values[0]) );
    locale_update_registry( hkey, lc_paperW, lcid_LC_PAPER, lc_paper_values,
                            sizeof(lc_paper_values)/sizeof(lc_paper_values[0]) );
 
    if (locale_update_registry( hkey, lc_ctypeW, lcid_LC_CTYPE, NULL, 0 ))
    {
        static const WCHAR codepageW[] =
            {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\','S','y','s','t','e','m','\\',
             'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
             'C','o','n','t','r','o','l','\\','N','l','s','\\','C','o','d','e','p','a','g','e',0};
 
        OBJECT_ATTRIBUTES attr;
        HANDLE nls_key;
        DWORD len = 14;
 
        RtlInitUnicodeString( &nameW, codepageW );
        InitializeObjectAttributes( &attr, &nameW, 0, 0, NULL );
        while (codepageW[len])
        {
            nameW.Length = len * sizeof(WCHAR);
            if (NtCreateKey( &nls_key, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) break;
            NtClose( nls_key );
            len++;
            while (codepageW[len] && codepageW[len] != '\\') len++;
        }
        nameW.Length = len * sizeof(WCHAR);
        if (!NtCreateKey( &nls_key, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
        {
            for (i = 0; i < sizeof(update_cp_values)/sizeof(update_cp_values[0]); i++)
            {
                count = GetLocaleInfoW( lcid, update_cp_values[i].value | LOCALE_NOUSEROVERRIDE,
                                        bufferW, sizeof(bufferW)/sizeof(WCHAR) );
                RtlInitUnicodeString( &nameW, update_cp_values[i].name );
                NtSetValueKey( nls_key, &nameW, 0, REG_SZ, bufferW, count * sizeof(WCHAR) );
            }
            NtClose( nls_key );
        }
    }
 
    NtClose( hkey );
}

◆ locale_update_registry()

static BOOL locale_update_registry	(	HKEY	hkey,
		const WCHAR *	name,
		LCID	lcid,
		const LCTYPE *	values,
		UINT	nb_values
	)

static

Definition at line 798 of file locale.c.

{
    static const WCHAR formatW[] = { '%','0','8','x',0 };
    WCHAR bufferW[40];
    UNICODE_STRING nameW;
    DWORD count, i;
 
    RtlInitUnicodeString( &nameW, name );
    count = sizeof(bufferW);
    if (!NtQueryValueKey(hkey, &nameW, KeyValuePartialInformation, bufferW, count, &count))
    {
        const KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)bufferW;
        LPCWSTR text = (LPCWSTR)info->Data;
 
        if (strtoulW( text, NULL, 16 ) == lcid) return FALSE; /* already set correctly */
        TRACE( "updating registry, locale %s changed %s -> %08x\n",
               debugstr_w(name), debugstr_w(text), lcid );
    }
    else TRACE( "updating registry, locale %s changed none -> %08x\n", debugstr_w(name), lcid );
    sprintfW( bufferW, formatW, lcid );
    NtSetValueKey( hkey, &nameW, 0, REG_SZ, bufferW, (strlenW(bufferW) + 1) * sizeof(WCHAR) );
 
    for (i = 0; i < nb_values; i++)
    {
        GetLocaleInfoW( lcid, values[i] | LOCALE_NOUSEROVERRIDE, bufferW,
                        sizeof(bufferW)/sizeof(WCHAR) );
        SetLocaleInfoW( lcid, values[i], bufferW );
    }
    return TRUE;
}

Referenced by LOCALE_InitRegistry().

◆ lstrcmpA()

int WINAPI lstrcmpA	(	LPCSTR	str1,
		LPCSTR	str2
	)

Definition at line 4194 of file locale.c.

{
    int ret;
 
    if ((str1 == NULL) && (str2 == NULL)) return 0;
    if (str1 == NULL) return -1;
    if (str2 == NULL) return 1;
 
    ret = CompareStringA(GetThreadLocale(), LOCALE_USE_CP_ACP, str1, -1, str2, -1);
    if (ret) ret -= 2;
 
    return ret;
}

Referenced by check_font(), check_list(), check_reg_str(), check_wellknown_name(), compare_string1(), CryptFindOIDInfo(), dde_msg_client_wndproc(), dde_server_wndproc(), dde_server_wndprocA(), dde_server_wndprocW(), DoStepCheck(), eto_emf_enum_proc(), expect_shim_imp(), file_matches(), find_prop_in_property(), FindTest(), hook_WaitForInputIdle(), is_prefix_wa(), JustDoIt(), LPropCompareProp(), main(), match_emf_record(), mdi_child_wnd_proc_1(), mdi_child_wnd_proc_2(), mdr_GetValue(), notify_datetime_handler(), notify_generic_text_handler(), notify_tooltip_handler(), option_equal(), parse_clr_metadata(), PathMatchSpecA(), PRINTDLG_ChangePrinterA(), PropertyStorage_PropNameCompare(), proppage_callback_a(), PropVariantCompareEx(), PropVariantToBoolean(), server_ddeml_callback(), server_end_to_end_callback(), START_TEST(), str_eq_wa(), strcmp_wa(), strcmp_ww(), StrCmpCA(), strcomparefunc(), test_32bit_win(), test_appsearch_complocator(), test_appsearch_drlocator(), test_appsearch_inilocator(), test_appsearch_reglocator(), test_authentication(), test_binary(), test_binary_import(), test_BstrCopy(), test_ccpsearch(), test_collation(), test_CompareStringA(), test_complocator(), test_ConvertINetUnicodeToMultiByte(), test_CreateAssemblyNameObject(), test_CreateFontIndirect(), test_CredMarshalCredentialA(), test_CryptCATAdminAddRemoveCatalog(), test_db(), test_dbmerge(), test_dbtopackage(), test_DdeCreateDataHandle(), test_DdeCreateStringHandleW(), test_ddeml_client(), test_DoEnvironmentSubst(), test_EM_GETHANDLE(), test_EM_SETTEXTEX(), test_emptypackage(), test_EnumDateFormatsA(), test_enumerate(), test_enumerate_name(), test_EnumTimeFormatsA(), test_Extract(), test_fieldzero(), test_FoldStringA(), test_font_substitution(), test_forcecodepage(), test_formatrecord(), test_formatrecord_package(), test_formatrecord_tables(), test_fullname(), test_fullname2_helper(), test_GetAcceptLanguagesA(), test_GetDisplayName(), test_GetFullPathNameA(), test_GetLocaleInfoA(), test_GetPrivateProfileString(), test_GetPtrAW(), test_GetRfc1766FromLcid(), test_GetRfc1766Info(), test_GetSetConsoleInputExeName(), test_GetSetEnvironmentVariableA(), test_getstring(), test_GetSystemDirectoryA(), test_GetTextFace(), test_GetUrlCacheConfigInfo(), test_GetWindowsDirectoryA(), test_IMultiLanguage2_ConvertStringFromUnicode(), test_inffilelistA(), test_initialization(), test_Installer_InstallProduct(), test_installprops(), test_InternetCanonicalizeUrlA(), test_interthread_messages(), test_kerberos(), test_lastusedsource(), test_LcidToRfc1766(), test_lcmapstring_unicode(), test_LCMapStringA(), test_LookupAccountName(), test_LookupAccountSid(), test_LZOpenFileA(), test_LZOpenFileA_existing_compressed(), test_LZOpenFileA_nonexisting_compressed(), test_LZOpenFileW(), test_LZOpenFileW_existing_compressed(), test_LZOpenFileW_nonexisting_compressed(), test_MsiDatabaseCommit(), test_MsiEnumClients(), test_MsiEnumPatches(), test_MsiEnumPatchesEx(), test_MsiEnumPatchesEx_machine(), test_MsiEnumPatchesEx_usermanaged(), test_MsiEnumPatchesEx_userunmanaged(), test_msiexport(), test_MsiGetComponentPath(), test_MsiGetComponentPathEx(), test_MsiGetFileVersion(), test_MsiGetPatchInfo(), test_MsiGetPatchInfoEx(), test_MsiGetProductCode(), test_MsiGetProductInfoEx(), test_MsiGetProductProperty(), test_MsiGetSourcePath(), test_MsiGetUserInfo(), test_MsiInstallProduct(), test_MsiOpenProduct(), test_MsiProvideQualifiedComponentEx(), test_MsiRecordGetString(), test_MsiSetProperty(), test_MsiSourceListAddSourceEx(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListGetInfo(), test_multibyte_to_unicode_translations(), test_negative_dest_length(), test_negative_source_length(), test_norecompute(), test_notify_generic_text_helper(), test_notify_proc(), test_oemcharset(), test_Option_PerConnectionOptionA(), test_ParseURLFromOutsideSourceA(), test_ParseURLFromOutsideSourceW(), test_PathAddBackslash(), test_PathAppendA(), test_PathBuildRootA(), test_PathCanonicalizeA(), test_PathCombineA(), test_PathCommonPrefixA(), test_PathFindExtensionA(), test_PathNameA(), test_PdhLookupPerfNameByIndexA(), test_process_components(), test_PropCopyMore(), test_property_table(), test_pSetupGetField(), test_publish_sourcelist(), test_queryreader(), test_readwrite(), test_reg_query_value(), test_RegisterClipboardFormatA(), test_RtlGetFullPathName_U(), test_ScriptGetFontProperties(), test_SetDefaultPrinter(), test_settargetpath(), test_SetupGetFileCompressionInfo(), test_SetupGetFileCompressionInfoEx(), test_SetupGetSourceFileLocation(), test_SetupGetSourceInfo(), test_SHCreateWorkerWindowA(), test_SHFormatDateTimeA(), test_SHGetFolderPathAndSubDirA(), test_SHGetObjectCompatFlags(), test_shortlongsource(), test_sorting(), test_sourcedir(), test_storages_table(), test_streamtable(), test_summary_binary(), test_SysAllocStringByteLen(), test_try_transform(), test_UDS_SETBUDDYINT(), test_updown_base(), test_UrlApplyScheme(), test_urlcacheW(), test_XcvDataPort_ConfigureLPTPortCommandOK(), testAuth(), testGetValidUsages(), testPropsHelper(), testScreenBuffer(), verify_shima_imp(), WorkerThread(), and wsprintfATest().

◆ lstrcmpiA()

int WINAPI lstrcmpiA	(	LPCSTR	str1,
		LPCSTR	str2
	)

Definition at line 4223 of file locale.c.

{
    int ret;
 
    if ((str1 == NULL) && (str2 == NULL)) return 0;
    if (str1 == NULL) return -1;
    if (str2 == NULL) return 1;
 
    ret = CompareStringA(GetThreadLocale(), NORM_IGNORECASE|LOCALE_USE_CP_ACP, str1, -1, str2, -1);
    if (ret) ret -= 2;
 
    return ret;
}

Referenced by __ConvertName(), __GetLCIDFromName(), cbt_global_hook_proc(), check_info_filename(), check_lnk_(), check_reg_str(), cmp_mru_strA(), create_sub_body(), dns_strcmpX(), DoTestEntry(), enum_all_fonts_proc(), EnumLocalesProcA(), fdi_decomp(), file_in_list(), find_default_prop(), find_prop(), FindImportDescriptor(), get_window_attributes(), hook_WaitForInputIdle(), IntGetImageBase(), CCopyMoveToMenu::InvokeCommand(), is_local_machineA(), is_our_logged_class(), is_stub_dll(), MACRO_CloseSecondarys(), MACRO_CloseWindow(), MACRO_FocusWindow(), MACRO_HelpOnTop(), MACRO_LookupButton(), main(), matchSpecialFolderPathToEnv(), MimeBody_DeleteProp(), MimeBody_GetProp(), MimeBody_IsContentType(), MimeBody_SetProp(), MimeInternat_FindCharset(), okChildString_(), path_hook_proc(), PathIsExeA(), PropertyStorage_PropNameCompare(), PropVariantCompareEx(), PropVariantToBoolean(), read_prop(), RedirectIat(), scan_subkeys(), SHADD_compare_mru(), SHELL32_GetFSItemAttributes(), SHRegGetBoolUSValueA(), START_TEST(), StrCmpICA(), stricmp_wa(), Test2(), test_appsearch_drlocator(), TEST_AssocQueryStringA(), test_bitmap_font_glyph_index(), test_CompareStringA(), test_CurrentDirectoryA(), test_enum_sections(), test_enumdisplaydevices_monitor(), test_filenames(), test_FindFirstFileA(), test_FunnyChars(), test_get_displayname(), test_get_file_info(), test_get_servicekeyname(), test_get_set(), test_GetFinalPathNameByHandleA(), test_GetIconLocation(), test_GetLongPathNameA(), test_GetProcessImageFileNameA(), test_GetStandardColorSpaceProfileA(), test_GetStandardColorSpaceProfileW(), test_GetTempFileNameA(), test_GetTempPathA(), test_handles(), test_hwnd_message(), test_IME(), test_InitPathA(), test_LoadLibraryEx_search_flags(), test_LongtoShortA(), test_LookupAccountName(), test_module(), test_nonexistent_font(), test_open_svc(), test_OpenFile(), test_PathCreateFromUrl(), test_PathNameA(), test_PrintDlgA(), test_process_components(), test_QueryFullProcessImageNameA(), test_readwrite(), test_registerDefaultOIDFunction(), test_setdir(), test_SetSearchPathMode(), test_settargetpath(), test_SetupGetTargetPath(), test_sh_new_link_info(), test_SHGetFolderPathA(), test_urlcacheA(), test_UrlCreateFromPath(), test_ValidPathA(), testing_status_routine(), testSystemDir(), testWinDir(), translateinfstringex_test(), TTIsEmbeddingEnabledForFacename(), VerInstallFileA(), WDML_ClientProc(), WDML_ServerNameProc(), win_event_global_hook_proc(), WINHELP_CreateHelpWindow(), WINHELP_DeleteWindow(), and WINHELP_GetWindowInfo().

◆ lstrcmpiW()

int WINAPI lstrcmpiW	(	LPCWSTR	str1,
		LPCWSTR	str2
	)

Definition at line 4261 of file locale.c.

{
    int ret;
 
    if ((str1 == NULL) && (str2 == NULL)) return 0;
    if (str1 == NULL) return -1;
    if (str2 == NULL) return 1;
 
    ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, -1, str2, -1);
    if (ret) ret -= 2;
 
    return ret;
}

Referenced by ActivateContentTopic(), add_favs_to_menu(), add_font(), AviMux_FindPin(), BaseRendererImpl_FindPin(), CFn_WMCommand(), CFSExtractIcon_CreateInstance(), CExplorerBand::CompareTreeItems(), compareUrlArray(), copy_files(), count_moniker_matches(), CRYPT_FileNameOpenStoreW(), CRYPT_FindStringInMultiString(), CRYPT_SysRegOpenStoreW(), CryptFindLocalizedName(), DdeCmpStringHandles(), DEVENUM_IMediaCatMoniker_IsEqual(), dns_name_matches(), dns_strcmpX(), do_process_key(), ATL::CRegObject::do_process_key(), do_process_root_key(), ATL::CRegObject::do_process_root_key(), DoEntry(), DoInitAutoCompleteWithCWD(), domain_name_matches(), DoSync(), DoTestComputerName(), DoTestEntry(), EditTypeDlg_OnCommand(), EditTypeDlg_OnDrawItem(), EnumStubProc(), CDirectoryItem::EqualPath(), extract_cab_cb(), FILEDLG95_FILETYPE_SearchExt(), FILEDLG95_OnOpen(), FileMonikerImpl_CommonPrefixWith(), FileMonikerImpl_IsEqual(), FileMonikerImpl_RelativePathTo(), CMenuSFToolbar::FillToolbar(), find_control(), find_installed_ports(), find_portinfo2(), find_top_window(), FindExeCplClass(), fnIMultiLanguage3_GetCharsetInfo(), format_filelist_filename(), get_operation(), GetBinaryTypeW(), GetFileTypeIconsEx(), CShellDispatch::GetSystemInformation(), HTMLFormElement_put_encoding(), HTMLFormElement_put_method(), IAssemblyCacheImpl_InstallAssembly(), ILIsParentOrSpecialParent(), Imm32IsRunningInMsoobe(), Imm32WriteImeLayout(), ImmInstallIMEW(), CACLCustomMRU::Initialize(), CVfdShExt::InvokeCommand(), IsPidlPrograms(), IsSwitch(), ITypeComp_fnBind(), ITypeInfo_fnGetIDsOfNames(), JapaneseEra_IsFirstYearGannen(), ldr_enum_callback(), ldr_notify_callback1(), ldr_notify_callback_imports(), load_mapi_provider(), LocalmonAddPortEx(), MSSTYLES_FindClass(), MSSTYLES_GetActiveThemeIni(), MSSTYLES_GetFont(), MSSTYLES_LoadBitmap(), MSSTYLES_LookupEnum(), MSSTYLES_LookupPartState(), MSSTYLES_LookupProperty(), MSSTYLES_OpenThemeFile(), MSSTYLES_ParseThemeIni(), MSTASK_ITaskScheduler_SetTargetComputer(), ok_child_stringWA(), CDesktopBrowser::OnSettingChange(), CTrayWindow::OnSettingChanged(), parse_display_name(), parse_procarch(), parse_pubkey(), PathIsDosDevice(), PrintOSVersion(), PropertyStorage_PropNameCompare(), PropStgNameToFmtId(), PropVariantCompareEx(), PropVariantToBoolean(), pSetupStringTableAddString(), pSetupStringTableAddStringEx(), pSetupStringTableLookUpString(), pSetupStringTableLookUpStringEx(), CDummyPropertyBag::Read(), realize_font(), reg_add(), reg_copy(), reg_delete(), reg_export(), reg_import(), reg_query(), registry_set_filelist(), rfc822_name_matches(), SampleGrabber_IBaseFilter_FindPin(), ScanAdvancedSettings(), SECUR32_findPackageW(), ServiceStarter(), set_ldids(), SHADD_compare_mru(), SHAddToRecentDocs(), SHCreatePropertyBagOnProfileSection(), shellex_run_context_menu_default(), SHGetSpecialFolderID(), SHRegGetBoolUSValueW(), SHSettingsChanged(), START_TEST(), StrCmpICW(), SvcRegisterStopCallback(), TEST_AssocQueryStringW(), test_createfont(), test_detailed_info(), TEST_DoTestEntryStruct(), test_EnumCodePages(), test_file_all_name_information(), test_file_info(), test_file_link_information(), test_file_name_information(), test_file_rename_information(), test_FolderCollection(), test_FolderShortcut(), test_fontfamily(), test_format_object(), test_GetAbsolutePathName(), test_GetDisplayName(), test_GetFile(), test_GetFinalPathNameByHandleW(), Test_GetFontResourceInfoW_case1(), Test_GetFontResourceInfoW_case2(), Test_GetFontResourceInfoW_case4(), test_getgenerics(), test_GetSpecialFolder(), test_getstring_bad(), test_GetTempPathW(), test_HashLinks(), test_info_in_assembly(), test_knownFolders(), test_LocalizedNames(), test_namespace(), test_ParseDisplayNamePBC(), test_PathCreateFromUrl(), test_PathSearchAndQualify(), test_ProgIDFromCLSID(), test_QueryFullProcessImageNameW(), test_realization(), test_RtlStringFromGUID(), test_SetApplicationName_GetApplicationName(), test_SetTargetComputer(), test_SHGetFolderPathEx(), test_SHGetPathFromIDList(), test_SHGetSetFolderCustomSettings(), TEST_Start(), test_streamenum(), test_StringFromGUID2(), test_StringTableStringFromId(), test_type_info(), test_typelib(), test_UrlCreateFromPath(), test_Win32_ComputerSystem(), TestCommandLine(), ThemeDlgPostWindowProc(), TLB_get_typeinfo_by_name(), TLB_get_vardesc_by_name(), TREEVIEW_SortOnName(), UPDOWN_SetBuddy(), UPDOWN_SetBuddyInt(), URLMoniker_IsEqual(), Validate_EmptyShimData_Win10(), validate_envW(), validate_operation(), Validate_ShimData_Win10(), ViewTree_FindIcon(), ViewTree_LoadTree(), WDML_BroadcastEnumProc(), WDML_ClientProc(), WDML_ServerNameProc(), WICMapShortNameToGuid(), CDummyPropertyBag::Write(), write_registry_values(), and wWinMain().

◆ lstrcmpW()

int WINAPI lstrcmpW	(	LPCWSTR	str1,
		LPCWSTR	str2
	)

Definition at line 4242 of file locale.c.

{
    int ret;
 
    if ((str1 == NULL) && (str2 == NULL)) return 0;
    if (str1 == NULL) return -1;
    if (str2 == NULL) return 1;
 
    ret = CompareStringW(GetThreadLocale(), 0, str1, -1, str2, -1);
    if (ret) ret -= 2;
 
    return ret;
}

Referenced by _check_default_props(), _check_set_props(), _findProviderIndexW(), _test_GetCurMoniker(), _test_language_string(), ActiveScript_AddNamedItem(), ActiveScriptSite_GetItemInfo(), add_favs_to_menu(), ADVAPI_IsLocalComputer(), AVIBuildFilterW(), cert_mgr_sort_by_text(), check_display_name_(), check_dropdown_(), check_known_folder(), ClassTest(), compare_addrinfow(), compare_export_(), compare_font(), compare_items(), compare_metadata(), compareAltNameEntry(), CRegistryFolder::CompareIDs(), ConfigFileHandler_startElement(), cpinfo_cmp(), CredDialogFillUsernameCombo(), CredUIConfirmCredentialsW(), CredUIPromptForCredentialsW(), CRYPT_RegReadSerializedFromReg(), CryptFindOIDInfo(), dde_server_wndprocA(), dde_server_wndprocW(), DELNODE_recurse_dirtree(), DEVENUM_IPropertyBag_Read(), dispex_GetDispID(), DoEntry(), DoGetProductType(), DoTestComputerName(), DoTestEntry(), DSPROPERTY_WaveDeviceMappingW(), enum_find_filter(), enum_gac_assemblies(), enum_stream_names(), enumeration_callback(), EnumJoysticks(), export_password_dlg_proc(), FEqualNames(), find_existing_credential(), find_property_index(), find_window(), find_window_callback(), FindDll(), general_on_notify(), get_dest_dir(), get_encoder_clsid(), GetFileTypeIconsEx(), getstring_test(), GetTypeFromName(), HlinkBrowseContext_GetObject(), hls_site_Moniker_ComposeWith(), HttpNegotiate_BeginningTransaction(), IAssemblyNameImpl_IsEqual(), IDxDiagContainerImpl_GetChildContainerInternal(), IDxDiagContainerImpl_GetProp(), iframe_onreadystatechange(), Imm32UnitTest(), InitPropertyBag_IPropertyBag_Read(), InPlaceFrame_SetActiveObject(), InPlaceUIWindow_SetActiveObject(), inst_func2(), InstallColorProfileW(), InternetProtocolInfo_CombineUrl(), InternetProtocolInfo_ParseUrl(), is_expected_variant(), is_ime_window_proc(), is_in_strarray(), is_netmeeting_running(), JustDoIt(), ldap_parse_page_controlW(), LISTVIEW_EndEditLabelT(), LISTVIEW_FindItemW(), LPropCompareProp(), LsapIsLocalComputer(), map_shortname_to_schema(), MimeProtocol_Start(), mixer_test_deviceW(), MMDevEnum_GetDevice(), MNLS_lstrcmpW(), MonikerProp_PutProperty(), MSACM_FillFormatTagsCB(), MsgConversionProcW(), notify_generic_text_handler(), notify_if_changed(), ok_child_stringWA(), on_default_action(), on_fontlist_modified(), on_mime_message_available(), on_sizelist_modified(), pagesetup_set_devnames(), parse_file_header(), parse_hhindex(), ParseDisplayName_ParseDisplayName(), PathMatchSpecW(), PB_Read(), PerformRegAction(), pointer_tests(), PRINTDLG_ChangePrinterW(), PRINTDLG_CreateDevNamesW(), PropertyNotifySink_OnChanged(), proppage_callback_w(), PropVariantCompareEx(), PropVariantToBoolean(), Protocol_Continue(), Protocol_Start(), protocol_start(), ProtocolSink_ReportProgress(), pSetupStringTableAddString(), pSetupStringTableAddStringEx(), pSetupStringTableLookUpString(), pSetupStringTableLookUpStringEx(), r_getMonikerRef(), r_getStringRef(), r_verify_pidl(), REBAR_MoveChildWindows(), REBAR_strdifW(), REGPROC_open_export_file(), res_sec_url_cmp(), resource_strcmp(), RtlAtomTestThread(), run_get_comp_name_tests(), run_test(), run_usergetinfo_tests(), run_wkstausergetinfo_tests(), scriptinfo_cmp(), search_dll_path(), server_end_to_end_callback(), set_up_attribute_test(), SetupQuerySpaceRequiredOnDriveW(), SHGetFileInfoW(), should_enumerate_device(), simple_callbackW(), site_GetItemInfo(), SmartTeeFilter_FindPin(), START_TEST(), STATUSBAR_SetTextT(), statusclb_OnDataAvailable(), statusclb_OnProgress(), Storage_CreateStream(), Storage_OpenStream(), strcmp_aw(), strcmp_wa(), StrCmpCW(), tear_down_attribute_test(), test_32bit_win(), test_about_protocol(), test_aclist_expand(), test_assembly_name_props_line(), test_aw_conversion_dlgproc(), test_aw_conversion_dlgprocA(), test_aw_conversion_dlgprocW(), test_aw_conversion_wndproc(), test_bad_header(), test_basics(), test_BindToObject(), test_BindToStorage(), test_bstr_cache(), test_BuildPath(), test_button_class(), test_catalog_properties(), test_CertRDNValueToStrW(), test_CharToOem_OemToChar(), test_chunked_read(), Test_ClassAtoms(), test_cloneNode(), test_codec(), test_CoInternetCombineIUri_Pluggable(), test_CoInternetCombineUrlEx_Pluggable(), test_CoInternetParseIUri_InvalidArgs(), test_CoInternetParseIUri_Pluggable(), test_CoInternetParseUrl(), test_collation(), test_commandline2argv(), test_convert(), test_cookies(), test_copy(), test_CopyStgMedium(), test_costs(), test_create(), test_create_attribute(), test_create_catalog_file(), test_createNode(), test_CreateTextFile(), test_CreateTypeLib(), test_CredUnmarshalCredentialA(), test_cryptunprotectdata(), test_cue_banner(), test_custom_source(), test_customize(), test_customize_onfolderchange(), test_datalink(), test_DavGetHTTPFromUNCPath(), test_DavGetUNCFromHTTPPath(), test_DdeCreateStringHandleW(), test_decodeAltName(), test_decodeAuthorityKeyId2(), test_decodeCatMemberInfo(), test_decodeCatNameValue(), test_decodeCRLDistPoints(), test_decodePolicyQualifierUserNotice(), test_decoder_info(), test_decodeSPCLink(), test_decodeSPCPEImage(), test_decodeSpOpusInfo(), test_default_client_accessible_object(), test_default_format(), test_default_handler(), test_default_properties(), test_desktop_displaynameof(), test_directory_sort(), test_directshow_filter(), test_dmo(), test_doc_load_from_path(), test_DoEnvironmentSubst(), test_domdoc(), test_domnode(), test_DsClientMakeSpnForTargetServer(), test_DsMakeSpn(), test_dsound(), test_EM_GETHANDLE(), test_EM_GETLINE(), test_EM_SETTEXTEX(), test_EnumTimeFormatsW(), test_exec_fontname(), test_FileCollection(), test_filename_opendlg_(), test_filename_savedlg_(), test_filesourcefilter(), test_find_com_redirection(), test_find_surrogate(), test_find_window_class(), test_FindName(), test_findOIDInfo(), test_fm2_enummatchingfilters(), test_FolderCollection(), test_font_events_disp(), test_format_object(), test_format_record(), test_FormattingXML(), test_get_attributes(), test_get_childNodes(), test_get_doctype(), test_get_firstChild(), test_get_namespaces(), test_get_nodeTypeString(), test_get_prefix(), test_get_tagName(), test_getAttribute(), test_GetBaseName(), test_GetCachePath(), test_GetCharsetInfo_other(), test_GetCodePageInfo(), test_GetDisplayName(), test_GetDrive(), test_GetDriveName(), test_GetDynamicTimeZoneInformation(), test_GetExtensionName(), test_GetFileName(), test_GetFullPathNameW(), test_GetLocaleInfoEx(), test_GetLocaleInfoW(), test_GetLocalName(), test_GetName(), test_GetParentFolderName(), test_GetRemoteName(), test_GetRfc1766Info(), test_getruntime(), test_GetSetEnvironmentVariableW(), test_getstring(), test_GetSystemDirectoryW(), test_GetText(), test_GetTextFace(), test_GetTimeZoneInformationForYear(), test_getuserobjectinformation(), test_GetWindowsDirectoryW(), test_Global(), test_globalness(), test_HlinkClone(), test_HlinkCreateExtensionServices(), test_HlinkGetSetMonikerReference(), test_HlinkGetSetStringReference(), test_HlinkParseDisplayName(), test_HttpOptions(), test_IActiveScriptError(), test_ICInfo(), test_inffilelist(), test_insertBefore(), test_Installer_Products(), test_Installer_RegistryValue(), test_InternetGetSecurityUrl(), test_ITEMIDLIST_format(), test_items(), test_ITextDocument_Open(), test_ITextFont(), test_IUriBuilder_GetFragment(), test_IUriBuilder_GetHost(), test_IUriBuilder_GetPassword(), test_IUriBuilder_GetPath(), test_IUriBuilder_GetQuery(), test_IUriBuilder_GetSchemeName(), test_IUriBuilder_GetUserName(), test_IUriBuilder_HasBeenModified(), test_IWbemPath_GetClassName(), test_IWbemPath_GetNamespaceAt(), test_IWbemPath_GetServer(), test_IWbemPath_GetText(), test_IWbemPath_RemoveNamespaceAt(), test_IWbemPath_SetClassName(), test_IWbemPath_SetNamespaceAt(), test_IWbemPath_SetServer(), test_IWbemPath_SetText(), test_knownFolders(), test_lcmapstring_unicode(), test_LCMapStringEx(), test_legacy_filter(), test_legacy_filter_registration(), test_load(), test_LocaleNameToLCID(), test_marshal_array(), test_marshal_SNB(), test_media_streams(), test_mediadet(), test_menu_add_string(), test_message_allocate_buffer_wide(), test_message_from_64bit_number(), test_message_from_string_wide(), test_message_ignore_inserts_wide(), test_message_invalid_flags_wide(), test_MessageBoxFontTest(), test_MessageSetProp(), test_metadata_APE(), test_metadata_cHRM(), test_metadata_gAMA(), test_metadata_GCE(), test_metadata_gif(), test_metadata_GIF_comment(), test_metadata_IMD(), test_metadata_LSD(), test_midiout(), test_MkParseDisplayNameEx(), test_moniker(), test_mouse_keyboard(), test_MsiGetProductProperty(), test_multibyte_to_unicode_translations(), test_mxattr_addAttribute(), test_mxattr_clear(), test_mxnamespacemanager(), test_mxnamespacemanager_override(), test_mxwriter_cdata(), test_mxwriter_characters(), test_mxwriter_comment(), test_mxwriter_default_properties(), test_mxwriter_dtd(), test_mxwriter_encoding(), test_mxwriter_ignorablespaces(), test_mxwriter_indent(), test_mxwriter_pi(), test_mxwriter_properties(), test_mxwriter_startenddocument(), test_mxwriter_startendelement(), test_mxwriter_startendelement_batch(), test_mxwriter_startendelement_batch2(), test_mxwriter_stream(), test_namedmap_newenum(), test_namespace(), test_namespaces_as_attributes(), test_namespaces_basic(), test_namespaces_change(), test_NameToStrConversionW(), test_negative_source_length(), test_NetFwAuthorizedApplication(), test_newline_normalization(), test_nodeTypedValue(), test_nodeValue(), test_note(), test_notify_generic_text_helper(), test_notify_proc(), test_NtAtom(), test_NtIntAtom(), test_null(), test_OleRegGetUserType(), test_OleUIAddVerbMenu(), test_one_cmdline(), test_Option_PerConnectionOption(), test_overwrite(), test_para_numbering(), test_ParseDisplayName(), test_passport_auth(), test_PathUnExpandEnvStrings(), test_PathUnquoteSpaces(), test_PathYetAnotherMakeUniqueName(), test_prefix_filtering(), test_preserve_charref(), test_profile_string(), test_propertybag_getpropertyinfo(), test_propertytovariant(), test_props(), test_PropVariantChangeType_LPWSTR(), test_PropVariantToString(), test_PropVariantToStringAlloc(), test_PropVariantToStringWithDefault(), test_proxy_direct(), test_pSetupGetField(), test_put_data(), test_put_nodeTypedValue(), test_QueryAssemblyInfo(), test_queryconfig2(), test_QueryPathOfRegTypeLib(), test_queryreader(), test_Read(), test_read_attribute(), test_read_charref(), test_read_element(), test_read_pi(), test_read_public_dtd(), test_read_system_dtd(), test_read_xmldeclaration(), test_ReadAll(), test_recinfo(), test_reference(), test_reg_query_value(), test_registry(), test_registry_property_w(), test_RegQueryValueExPerformanceData(), test_root_children(), test_RtlGetFullPathName_U(), test_RtlInitUnicodeString(), test_RtlQueryPackageIdentity(), test_save(), test_saxreader_properties(), test_Sdb(), test_SdbTagToString(), test_SearchPathW(), test_selection(), test_Session(), test_SetAccountInformation_GetAccountInformation(), test_setAttributeNode(), test_SetComment_GetComment(), test_SetInitialHlink(), test_SetParameters_GetParameters(), test_SetupPromptForDiskW(), test_SHCreateShellItem(), test_SHCreateShellItemArray(), test_SHFormatDateTimeW(), test_SHGetIniString(), test_SHGetNameFromIDList(), test_SHGetPathFromIDList(), test_SQLGetPrivateProfileStringW(), test_SspiEncodeStringsAsAuthIdentity(), test_SspiPrepareForCredWrite(), test_StdHlink(), test_SysAllocString(), test_SysAllocStringByteLen(), test_SysAllocStringLen(), test_SysReAllocString(), test_SysReAllocStringLen(), test_targetpath(), test_textfont_global_defaults(), test_ToUnicode(), test_typelibmarshal(), test_url_canonicalize(), test_url_combine(), test_url_part(), test_urlcacheW(), test_UrlEscapeW(), test_UrlUnescape(), test_VarDateChangeTypeEx(), test_vfw(), test_wavein(), test_waveout(), test_wcscpy_s(), test_WICMapGuidToShortName(), test_WICMapSchemaToName(), test_Win32_Service(), test_WinHttpSendRequest(), test_wm_notify_comboboxex(), test_wm_notify_datetime(), test_wm_notify_tooltip(), test_wndclass_section(), test_WriteLine(), test_WTSEnumerateProcessesW(), test_XDR_datatypes(), test_xmldoc(), test_xmlelem(), test_xmlelem_collection(), test_XMLHTTP(), test_xmlns_attribute(), test_xmlTypes(), test_XPath(), test_xsltext(), testAddCertificateLink(), testCreateSelfSignCert(), testExpand(), testQuery(), testScreenBuffer(), testSetHelper(), textcmpWT(), TREEVIEW_InsertItemT(), update_font_list(), update_size_list(), validate_endptr(), Validate_ShimData_Win2k3(), Validate_ShimData_Win7(), variant_func2(), verify_shimw_imp(), WICMapSchemaToName(), Widget_complex_struct(), Widget_VarArg_Ref_Run(), Widget_VarArg_Run(), Widget_variant(), Widget_variant_array(), WinHttpCrackUrl_test(), WinHttpCreateUrl_test(), winproc_convW(), WNetOpenEnumW(), WorkerThread(), wsprintfWTest(), and XCOPY_DoCopy().

◆ MultiByteToWideChar()

INT WINAPI MultiByteToWideChar	(	UINT	page,
		DWORD	flags,
		LPCSTR	src,
		INT	srclen,
		LPWSTR	dst,
		INT	dstlen
	)

Definition at line 2465 of file locale.c.

{
    const union cptable *table;
    int ret;
 
    if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (srclen < 0) srclen = strlen(src) + 1;
 
    switch(page)
    {
    case CP_SYMBOL:
        if (flags)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = wine_cpsymbol_mbstowcs( src, srclen, dst, dstlen );
        break;
    case CP_UTF7:
        if (flags)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = utf7_mbstowcs( src, srclen, dst, dstlen );
        break;
    case CP_UNIXCP:
        if (unix_cptable)
        {
            ret = wine_cp_mbstowcs( unix_cptable, flags, src, srclen, dst, dstlen );
            break;
        }
#ifdef __APPLE__
        flags |= MB_COMPOSITE;  /* work around broken Mac OS X filesystem that enforces decomposed Unicode */
#endif
        /* fall through */
    case CP_UTF8:
        if (flags & ~MB_FLAGSMASK)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = wine_utf8_mbstowcs( flags, src, srclen, dst, dstlen );
        break;
    default:
        if (!(table = get_codepage_table( page )))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        if (flags & ~MB_FLAGSMASK)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = wine_cp_mbstowcs( table, flags, src, srclen, dst, dstlen );
        break;
    }
 
    if (ret < 0)
    {
        switch(ret)
        {
        case -1: SetLastError( ERROR_INSUFFICIENT_BUFFER ); break;
        case -2: SetLastError( ERROR_NO_UNICODE_TRANSLATION ); break;
        }
        ret = 0;
    }
    TRACE("cp %d %s -> %s, ret = %d\n",
          page, debugstr_an(src, srclen), debugstr_wn(dst, ret), ret);
    return ret;
}

◆ NLS_EnumLanguageGroupLocales()

static BOOL NLS_EnumLanguageGroupLocales ( ENUMLANGUAGEGROUPLOCALE_CALLBACKS * lpProcs )

static

Definition at line 4672 of file locale.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_EnumSystemLanguageGroups()

static BOOL NLS_EnumSystemLanguageGroups ( ENUMLANGUAGEGROUP_CALLBACKS * lpProcs )

static

Definition at line 4476 of file locale.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_GetLanguageGroupName()

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

static

Definition at line 4426 of file locale.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 = get_default_sublang( langId );
 
    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 4377 of file locale.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(), and NLS_EnumSystemLanguageGroups().

◆ NLS_RegGetDword()

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

static

Definition at line 4405 of file locale.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 4352 of file locale.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(), and NLS_EnumSystemLanguageGroups().

◆ NormalizeString()

INT WINAPI NormalizeString	(	NORM_FORM	NormForm,
		LPCWSTR	lpSrcString,
		INT	cwSrcLength,
		LPWSTR	lpDstString,
		INT	cwDstLength
	)

Definition at line 5658 of file locale.c.

{
    FIXME("%x %p %d %p %d\n", NormForm, lpSrcString, cwSrcLength, lpDstString, cwDstLength);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

◆ ResolveLocaleName()

INT WINAPI ResolveLocaleName	(	LPCWSTR	name,
		LPWSTR	localename,
		INT	len
	)

Definition at line 6239 of file locale.c.

{
    FIXME("stub: %s, %p, %d\n", wine_dbgstr_w(name), localename, len);
 
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

◆ SetCPGlobal()

UINT WINAPI SetCPGlobal ( UINT acp )

Definition at line 2038 of file locale.c.

{
    UINT ret = GetACP();
    const union cptable *new_cptable = wine_cp_get_table( acp );
 
    if (new_cptable) ansi_cptable = new_cptable;
    return ret;
}

◆ SetLocaleInfoA()

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

Definition at line 1888 of file locale.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 1920 of file locale.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 locale_update_registry(), and SetLocaleInfoA().

◆ SetThreadLocale()

BOOL WINAPI SetThreadLocale ( LCID lcid )

Definition at line 2819 of file locale.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().

◆ SetThreadPreferredUILanguages()

BOOL WINAPI SetThreadPreferredUILanguages	(	DWORD	flags,
		PCZZWSTR	buffer,
		PULONG	count
	)

Definition at line 1319 of file locale.c.

{
    FIXME( "%u, %p, %p\n", flags, buffer, count );
    return TRUE;
}

◆ SetThreadUILanguage()

LANGID WINAPI SetThreadUILanguage ( LANGID langid )

Definition at line 2854 of file locale.c.

{
    TRACE("(0x%04x) stub - returning success\n", langid);
    return langid;
}

◆ setup_unix_locales()

static UINT setup_unix_locales ( void )

static

Definition at line 1110 of file locale.c.

{
    struct locale_name locale_name;
    WCHAR buffer[128], ctype_buff[128];
    const char *locale;
    UINT unix_cp = 0;
 
    if ((locale = get_locale( LC_CTYPE, "LC_CTYPE" )))
    {
        strcpynAtoW( ctype_buff, locale, sizeof(ctype_buff)/sizeof(WCHAR) );
        parse_locale_name( ctype_buff, &locale_name );
        lcid_LC_CTYPE = locale_name.lcid;
        unix_cp = locale_name.codepage;
    }
    if (!lcid_LC_CTYPE)  /* this one needs a default value */
        lcid_LC_CTYPE = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT );
 
    TRACE( "got lcid %04x (%d matches) for LC_CTYPE=%s\n",
           locale_name.lcid, locale_name.matches, debugstr_a(locale) );
 
#define GET_UNIX_LOCALE(cat) do \
    if ((locale = get_locale( cat, #cat ))) \
    { \
        strcpynAtoW( buffer, locale, sizeof(buffer)/sizeof(WCHAR) ); \
        if (!strcmpW( buffer, ctype_buff )) lcid_##cat = lcid_LC_CTYPE; \
        else { \
            parse_locale_name( buffer, &locale_name );  \
            lcid_##cat = locale_name.lcid; \
            TRACE( "got lcid %04x (%d matches) for " #cat "=%s\n",        \
                   locale_name.lcid, locale_name.matches, debugstr_a(locale) ); \
        } \
    } while (0)
 
    GET_UNIX_LOCALE( LC_COLLATE );
    GET_UNIX_LOCALE( LC_MESSAGES );
    GET_UNIX_LOCALE( LC_MONETARY );
    GET_UNIX_LOCALE( LC_NUMERIC );
    GET_UNIX_LOCALE( LC_TIME );
#ifdef LC_PAPER
    GET_UNIX_LOCALE( LC_PAPER );
#endif
#ifdef LC_MEASUREMENT
    GET_UNIX_LOCALE( LC_MEASUREMENT );
#endif
#ifdef LC_TELEPHONE
    GET_UNIX_LOCALE( LC_TELEPHONE );
#endif
 
#undef GET_UNIX_LOCALE
 
    return unix_cp;
}

Referenced by LOCALE_Init().

◆ SetUserGeoID()

BOOL WINAPI SetUserGeoID ( GEOID GeoID )

Definition at line 4874 of file locale.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 266 of file locale.c.

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

Referenced by setup_unix_locales().

◆ utf7_can_directly_encode()

static BOOL utf7_can_directly_encode ( WCHAR codepoint )

inlinestatic

Definition at line 2550 of file locale.c.

{
    static const BOOL directly_encodable_table[] =
    {
        1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, /* 0x00 - 0x0F */
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1F */
        1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* 0x20 - 0x2F */
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 0x30 - 0x3F */
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4F */
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 0x50 - 0x5F */
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6F */
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1                 /* 0x70 - 0x7A */
    };
 
    return codepoint <= 0x7A ? directly_encodable_table[codepoint] : FALSE;
}

Referenced by utf7_wcstombs().

◆ utf7_mbstowcs()

static int utf7_mbstowcs	(	const char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2349 of file locale.c.

{
    static const signed char base64_decoding_table[] =
    {
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00-0x0F */
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10-0x1F */
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20-0x2F */
        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 0x30-0x3F */
        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, /* 0x40-0x4F */
        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50-0x5F */
        -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60-0x6F */
        41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1  /* 0x70-0x7F */
    };
 
    const char *source_end = src + srclen;
    int dest_index = 0;
 
    DWORD byte_pair = 0;
    short offset = 0;
 
    while (src < source_end)
    {
        if (*src == '+')
        {
            src++;
            if (src >= source_end)
                break;
 
            if (*src == '-')
            {
                /* just a plus sign escaped as +- */
                if (!utf7_write_w(dst, dstlen, &dest_index, '+'))
                    return -1;
                src++;
                continue;
            }
 
            do
            {
                signed char sextet = *src;
                if (sextet == '-')
                {
                    /* skip over the dash and end base64 decoding
                     * the current, unfinished byte pair is discarded */
                    src++;
                    offset = 0;
                    break;
                }
                if (sextet < 0)
                {
                    /* the next character of src is < 0 and therefore not part of a base64 sequence
                     * the current, unfinished byte pair is NOT discarded in this case
                     * this is probably a bug in Windows */
                    break;
                }
 
                sextet = base64_decoding_table[sextet];
                if (sextet == -1)
                {
                    /* -1 means that the next character of src is not part of a base64 sequence
                     * in other words, all sextets in this base64 sequence have been processed
                     * the current, unfinished byte pair is discarded */
                    offset = 0;
                    break;
                }
 
                byte_pair = (byte_pair << 6) | sextet;
                offset += 6;
 
                if (offset >= 16)
                {
                    /* this byte pair is done */
                    if (!utf7_write_w(dst, dstlen, &dest_index, (byte_pair >> (offset - 16)) & 0xFFFF))
                        return -1;
                    offset -= 16;
                }
 
                src++;
            }
            while (src < source_end);
        }
        else
        {
            /* we have to convert to unsigned char in case *src < 0 */
            if (!utf7_write_w(dst, dstlen, &dest_index, (unsigned char)*src))
                return -1;
            src++;
        }
    }
 
    return dest_index;
}

Referenced by MultiByteToWideChar().

◆ utf7_wcstombs()

static int utf7_wcstombs	(	const WCHAR *	src,
		int	srclen,
		char *	dst,
		int	dstlen
	)

static

Definition at line 2599 of file locale.c.

{
    static const char base64_encoding_table[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
    const WCHAR *source_end = src + srclen;
    int dest_index = 0;
 
    while (src < source_end)
    {
        if (*src == '+')
        {
            if (!utf7_write_c(dst, dstlen, &dest_index, '+'))
                return -1;
            if (!utf7_write_c(dst, dstlen, &dest_index, '-'))
                return -1;
            src++;
        }
        else if (utf7_can_directly_encode(*src))
        {
            if (!utf7_write_c(dst, dstlen, &dest_index, *src))
                return -1;
            src++;
        }
        else
        {
            unsigned int offset = 0;
            DWORD byte_pair = 0;
 
            if (!utf7_write_c(dst, dstlen, &dest_index, '+'))
                return -1;
 
            while (src < source_end && !utf7_can_directly_encode(*src))
            {
                byte_pair = (byte_pair << 16) | *src;
                offset += 16;
                while (offset >= 6)
                {
                    if (!utf7_write_c(dst, dstlen, &dest_index, base64_encoding_table[(byte_pair >> (offset - 6)) & 0x3F]))
                        return -1;
                    offset -= 6;
                }
                src++;
            }
 
            if (offset)
            {
                /* Windows won't create a padded base64 character if there's no room for the - sign
                 * as well ; this is probably a bug in Windows */
                if (dstlen > 0 && dest_index + 1 >= dstlen)
                    return -1;
 
                byte_pair <<= (6 - offset);
                if (!utf7_write_c(dst, dstlen, &dest_index, base64_encoding_table[byte_pair & 0x3F]))
                    return -1;
            }
 
            /* Windows always explicitly terminates the base64 sequence
               even though RFC 2152 (page 3, rule 2) does not require this */
            if (!utf7_write_c(dst, dstlen, &dest_index, '-'))
                return -1;
        }
    }
 
    return dest_index;
}

Referenced by WideCharToMultiByte().

◆ utf7_write_c()

static BOOL utf7_write_c	(	char *	dst,
		int	dstlen,
		int *	index,
		char	character
	)

inlinestatic

Definition at line 2575 of file locale.c.

{
    if (dstlen > 0)
    {
        if (*index >= dstlen)
            return FALSE;
 
        dst[*index] = character;
    }
 
    (*index)++;
 
    return TRUE;
}

Referenced by utf7_wcstombs().

◆ utf7_write_w()

static BOOL utf7_write_w	(	WCHAR *	dst,
		int	dstlen,
		int *	index,
		WCHAR	character
	)

inlinestatic

Definition at line 2325 of file locale.c.

{
    if (dstlen > 0)
    {
        if (*index >= dstlen)
            return FALSE;
 
        dst[*index] = character;
    }
 
    (*index)++;
 
    return TRUE;
}

Referenced by utf7_mbstowcs().

◆ VerLanguageNameA()

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

Definition at line 3072 of file locale.c.

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

◆ VerLanguageNameW()

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

Definition at line 3083 of file locale.c.

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

Referenced by CFileVersionInfo::GetLangName().

◆ WideCharToMultiByte()

INT WINAPI WideCharToMultiByte	(	UINT	page,
		DWORD	flags,
		LPCWSTR	src,
		INT	srclen,
		LPSTR	dst,
		INT	dstlen,
		LPCSTR	defchar,
		BOOL *	used
	)

Definition at line 2691 of file locale.c.

{
    const union cptable *table;
    int ret, used_tmp;
 
    if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (srclen < 0) srclen = strlenW(src) + 1;
 
    switch(page)
    {
    case CP_SYMBOL:
        /* when using CP_SYMBOL, ERROR_INVALID_FLAGS takes precedence */
        if (flags)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        if (defchar || used)
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        ret = wine_cpsymbol_wcstombs( src, srclen, dst, dstlen );
        break;
    case CP_UTF7:
        /* when using CP_UTF7, ERROR_INVALID_PARAMETER takes precedence */
        if (defchar || used)
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        if (flags)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = utf7_wcstombs( src, srclen, dst, dstlen );
        break;
    case CP_UNIXCP:
        if (unix_cptable)
        {
            ret = wine_cp_wcstombs( unix_cptable, flags, src, srclen, dst, dstlen,
                                    defchar, used ? &used_tmp : NULL );
            break;
        }
        /* fall through */
    case CP_UTF8:
        if (defchar || used)
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        if (flags & ~WC_FLAGSMASK)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = wine_utf8_wcstombs( flags, src, srclen, dst, dstlen );
        break;
    default:
        if (!(table = get_codepage_table( page )))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        if (flags & ~WC_FLAGSMASK)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = wine_cp_wcstombs( table, flags, src, srclen, dst, dstlen,
                                defchar, used ? &used_tmp : NULL );
        if (used) *used = used_tmp;
        break;
    }
 
    if (ret < 0)
    {
        switch(ret)
        {
        case -1: SetLastError( ERROR_INSUFFICIENT_BUFFER ); break;
        case -2: SetLastError( ERROR_NO_UNICODE_TRANSLATION ); break;
        }
        ret = 0;
    }
    TRACE("cp %d %s -> %s, ret = %d\n",
          page, debugstr_wn(src, srclen), debugstr_an(dst, ret), ret);
    return ret;
}

◆ 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

◆ ansi_cptable

const union cptable* ansi_cptable

static

Definition at line 64 of file locale.c.

Referenced by get_codepage_table(), GetACP(), IsDBCSLeadByte(), LOCALE_Init(), and SetCPGlobal().

◆ cache_section

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

static

Definition at line 262 of file locale.c.

Referenced by get_registry_locale_info(), and SetLocaleInfoW().

◆ geoinfodata

const struct geoinfo_t geoinfodata[]

static

Definition at line 5013 of file locale.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 170 of file locale.c.

◆ iCountryW

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

static

Definition at line 171 of file locale.c.

◆ iCurrDigitsW

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

static

Definition at line 172 of file locale.c.

◆ iCurrencyW

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

static

Definition at line 173 of file locale.c.

◆ iDateW

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

static

Definition at line 174 of file locale.c.

◆ iDigitsW

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

static

Definition at line 175 of file locale.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 176 of file locale.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 177 of file locale.c.

◆ iLDateW

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

static

Definition at line 178 of file locale.c.

◆ iLZeroW

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

static

Definition at line 179 of file locale.c.

◆ iMeasureW

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

static

Definition at line 180 of file locale.c.

◆ iNegCurrW

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

static

Definition at line 181 of file locale.c.

◆ iNegNumberW

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

static

Definition at line 182 of file locale.c.

◆ iPaperSizeW

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

static

Definition at line 183 of file locale.c.

◆ iTimePrefixW

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

static

Definition at line 185 of file locale.c.

◆ iTimeW

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

static

Definition at line 186 of file locale.c.

◆ iTLZeroW

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

static

Definition at line 184 of file locale.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 160 of file locale.c.

Referenced by convert_default_lcid().

◆ lcid_LC_CTYPE

LCID lcid_LC_CTYPE

static

Definition at line 161 of file locale.c.

Referenced by convert_default_lcid(), LOCALE_Init(), LOCALE_InitRegistry(), and setup_unix_locales().

◆ lcid_LC_MEASUREMENT

LCID lcid_LC_MEASUREMENT

static

Definition at line 167 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

◆ lcid_LC_MESSAGES

LCID lcid_LC_MESSAGES

static

Definition at line 162 of file locale.c.

Referenced by LOCALE_Init(), and LOCALE_InitRegistry().

◆ lcid_LC_MONETARY

LCID lcid_LC_MONETARY

static

Definition at line 163 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

◆ lcid_LC_NUMERIC

LCID lcid_LC_NUMERIC

static

Definition at line 164 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

◆ lcid_LC_PAPER

LCID lcid_LC_PAPER

static

Definition at line 166 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

◆ lcid_LC_TELEPHONE

LCID lcid_LC_TELEPHONE

static

Definition at line 168 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

◆ lcid_LC_TIME

LCID lcid_LC_TIME

static

Definition at line 165 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

◆ mac_cptable

const union cptable* mac_cptable

static

Definition at line 66 of file locale.c.

Referenced by get_codepage_table(), and LOCALE_Init().

◆ NumShapeW

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

static

Definition at line 208 of file locale.c.

◆ oem_cptable

const union cptable* oem_cptable

static

Definition at line 65 of file locale.c.

Referenced by get_codepage_table(), GetOEMCP(), and LOCALE_Init().

◆ registry_values

struct registry_value registry_values[]

static

Referenced by get_locale_registry_value().

◆ s1159W

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

static

Definition at line 187 of file locale.c.

◆ s2359W

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

static

Definition at line 188 of file locale.c.

◆ sCountryW

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

static

Definition at line 189 of file locale.c.

◆ sCurrencyW

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

static

Definition at line 190 of file locale.c.

◆ sDateW

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

static

Definition at line 191 of file locale.c.

◆ sDecimalW

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

static

Definition at line 192 of file locale.c.

◆ sGroupingW

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

static

Definition at line 193 of file locale.c.

◆ sLanguageW

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

static

Definition at line 194 of file locale.c.

◆ sListW

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

static

Definition at line 195 of file locale.c.

◆ sLongDateW

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

static

Definition at line 196 of file locale.c.

◆ sMonDecimalSepW

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

static

Definition at line 197 of file locale.c.

◆ sMonGroupingW

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

static

Definition at line 198 of file locale.c.

◆ sMonThousandSepW

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

static

Definition at line 199 of file locale.c.

◆ sNativeDigitsW

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

static

Definition at line 200 of file locale.c.

◆ sNegativeSignW

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

static

Definition at line 201 of file locale.c.

◆ sPositiveSignW

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

static

Definition at line 202 of file locale.c.

◆ sShortDateW

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

static

Definition at line 203 of file locale.c.

◆ sThousandW

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

static

Definition at line 204 of file locale.c.

◆ sTimeFormatW

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

static

Definition at line 205 of file locale.c.

◆ sTimeW

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

static

Definition at line 206 of file locale.c.

◆ sYearMonthW

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

static

Definition at line 207 of file locale.c.

◆ szLangGroupsKeyName

const WCHAR szLangGroupsKeyName[]

static

Initial value:

= {
    '\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\','S','y','s','t','e','m','\\',
    'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
    'C','o','n','t','r','o','l','\\','N','l','s','\\',
    'L','a','n','g','u','a','g','e',' ','G','r','o','u','p','s',0
}

Definition at line 75 of file locale.c.

Referenced by IsValidLanguageGroup(), and NLS_EnumSystemLanguageGroups().

◆ szLocaleKeyName

const WCHAR szLocaleKeyName[]

static

Initial value:

= {
    '\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\','S','y','s','t','e','m','\\',
    'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
    'C','o','n','t','r','o','l','\\','N','l','s','\\','L','o','c','a','l','e',0
}

Definition at line 69 of file locale.c.

Referenced by NLS_EnumLanguageGroupLocales().

◆ unix_cptable

const union cptable* unix_cptable

static

Definition at line 67 of file locale.c.

Referenced by LOCALE_Init(), MultiByteToWideChar(), and WideCharToMultiByte().

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ GET_UNIX_LOCALE

◆ LOCALE_LOCALEINFOFLAGSMASK

◆ LOCALE_NAME_USER_DEFAULT

◆ MB_FLAGSMASK

◆ NDEBUG

◆ NLSRC_OFFSET

◆ REG_SZ

◆ WC_FLAGSMASK

◆ WINVER

Enumeration Type Documentation

◆ anonymous enum

◆ locationkind

Function Documentation

◆ adapt()

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

◆ get_default_sublang()

◆ get_dummy_preferred_ui_language()

◆ get_geoinfo_dataptr()

◆ get_lcid_codepage()

◆ get_locale()

◆ get_locale_registry_value()

◆ get_registry_locale_info()

◆ get_table_entry()

◆ get_value_base_by_lctype()

◆ GetACP()

◆ GetCPInfo()

◆ GetCPInfoExA()

◆ GetCPInfoExW()

◆ GetFileMUIInfo()

◆ GetFileMUIPath()

◆ GetGeoInfoA()

◆ GetGeoInfoW()

◆ GetLocaleInfoA()

◆ GetLocaleInfoW()

◆ GetLocalisedText()

◆ GetOEMCP()

◆ GetStringTypeA()

◆ GetStringTypeExA()

◆ GetStringTypeExW()

◆ GetStringTypeW()

◆ GetSystemDefaultLangID()

◆ GetSystemDefaultLCID()

◆ GetSystemDefaultLocaleName()

◆ GetSystemDefaultUILanguage()

◆ GetSystemPreferredUILanguages()

◆ GetThreadLocale()

◆ GetThreadPreferredUILanguages()

◆ GetUserDefaultLangID()