#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(), 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(), report_error(), 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 %

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