locale.c File Reference

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

Include dependency graph for locale.c:

Go to the source code of this file.

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

Definition at line 58 of file locale.c.

LOCALE_NAME_USER_DEFAULT

#define LOCALE_NAME_USER_DEFAULT   NULL

Definition at line 43 of file locale.c.

MB_FLAGSMASK

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

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

REG_SZ

#define REG_SZ   1

Definition at line 45 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)

Definition at line 61 of file locale.c.

WINVER

#define WINVER   DLL_EXPORT_VERSION

Definition at line 40 of file locale.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
BASE
TMIN
TMAX
SKEW
DAMP
INIT_BIAS
INIT_N

Definition at line 5586 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 4908 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 5596 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 4015 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(), _mbscoll(), _mbsicoll(), _mbsnbcoll_l(), _mbsnbicoll_l(), _strcoll_l(), _stricoll_l(), _strncoll_l(), _strnicoll_l(), char_compare(), 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 3955 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(), InitFunctionPointers(), and test_unicode_sorting().

CompareStringW()

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

Definition at line 3946 of file locale.c.

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

Referenced by __acrt_CompareStringEx(), __crtCompareStringW(), _wcscoll_l(), _wcsicoll_l(), _wcsncoll_l(), _wcsnicoll_l(), _WLocale_strcmp_aux(), CEnumMergedFolder::Begin(), ChrCmpIW(), COMCTL32_ChrCmpIW(), CompareStringA(), 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(), and XCOPY_ParseCommandLine().

convert_default_lcid()

static LCID convert_default_lcid ( LCID  lcid, LCTYPE  lctype  )

static

Definition at line 592 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 2879 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(), subtest_valid_manifest_resources_locale(), test_ConvertDefaultLocale(), VarBoolFromStr(), and VarBstrFromBool().

create_registry_key()

static HANDLE create_registry_key ( void  )

inlinestatic

Definition at line 771 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 2953 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 2963 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_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 4830 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 4840 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 4684 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 4705 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 2276 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 2297 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 5519 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 4485 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 4505 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 2986 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(), and InitFunctionPointers().

EnumSystemLocalesW()

BOOL WINAPI EnumSystemLocalesW	(	LOCALE_ENUMPROCW	lpfnLocaleEnum,
		DWORD	dwFlags
	)

Definition at line 3001 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(), enum_system_locales_ex_nolock(), EnumRfc1766_create(), GetLcidFromCountry(), GetLcidFromLangCountry(), GetLcidFromLanguage(), InitFunctionPointers(), InitLanguagesList(), and IsSortPageNeeded().

EnumUILanguagesA()

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

Definition at line 4854 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 4882 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;
}

FoldStringW()

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

Definition at line 3911 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 test_FoldStringW().

get_codepage_table()

static const union cptable * get_codepage_table ( unsigned int  codepage )

static

Definition at line 302 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(), IsValidCodePage(), MultiByteToWideChar(), and WideCharToMultiByte().

get_default_sublang()

static LANGID get_default_sublang ( LANGID  lang )

static

Definition at line 369 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 1252 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 5373 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 288 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(), GetDateFormatA(), GetLocaleInfoA(), GetStringTypeA(), GetTimeFormatA(), LCMapStringA(), LOCALE_Init(), and SetLocaleInfoA().

get_locale()

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

static

Definition at line 1026 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 1461 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 1477 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 277 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 1665 of file locale.c.

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

Referenced by GetLocaleInfoW().

GetACP()

UINT WINAPI GetACP

(

void

)

Definition at line 2023 of file locale.c.

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

Referenced by __acrt_get_qualified_locale(), cicGetOSInfo(), CON_API(), create_mbcinfo(), EngGetCurrentCodePage(), get_codeset(), GetImeStatus(), GetStringTypeA(), GetSupportedCP(), getSystemCP(), Global_Chr(), Imm32InquireIme(), init_locale(), IPropertyStorage_fnReadMultiple(), IPropertyStorage_fnWriteMultiple(), locale_to_sname(), ME_StreamOutRTFHeader(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), MimeInternat_ConvertString(), MimeInternat_GetDefaultCharset(), name_to_codepage(), ProcessCodePage(), PropertyStorage_ConstructEmpty(), PropertyStorage_ReadFromStream(), SetCPGlobal(), test_bitmap_font_metrics(), test_defaultcharset(), test_enum_svc(), test_EnumFontFamiliesEx_default_charset(), test_ExpandEnvironmentStringsA(), test_file_monikers(), test_FoldStringA(), test_GdiGetCodePage(), test_GetFullPathNameA(), test_GetSetEnvironmentVariableAW(), test_mbcp(), test_nonexistent_font(), test_setlocale(), test_text_metrics(), test_threadcp(), test_utf8(), and test_utf8_argument().

GetCPInfo()

BOOL WINAPI GetCPInfo	(	UINT	codepage,
		LPCPINFO	cpinfo
	)

Definition at line 2146 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 __acrt_locale_initialize_ctype(), _Locale_codecvt_create(), _Locale_ctype_create(), _setmbcp_nolock(), create_locinfo(), create_mbcinfo(), GetCPInfoExW(), GetKerningPairsA(), GetWindowTextLengthA(), Global_Chr(), InternalCompareStringA(), make_csconv(), ME_GetTextLengthEx(), setSBUpLow(), START_TEST(), test_GetCPInfo(), and test_mbcp().

GetCPInfoExA()

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

Definition at line 2204 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(), test_CompareStringA(), and test_threadcp().

GetCPInfoExW()

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

Definition at line 2222 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(), ME_StreamOutRTFHeader(), and test_GetCPInfo().

GetFileMUIInfo()

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

Definition at line 6137 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 6122 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 5475 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 5401 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 1609 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(), create_time_data(), detect_locale(), DosGetCountryInfo(), EnumLocalesProcA(), filetime_to_str(), is_rtl(), lcid_to_rfc1766A(), lineGetTranslateCapsA(), 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(), and VerLanguageNameA().

GetLocaleInfoW()

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

Definition at line 1675 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 __acrt_get_qualified_locale_downlevel(), __acrt_GetLocaleInfoEx(), __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(), CountryEnumProc(), 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(), GetLocaleInfoEx(), GetLocalizedSMFolderName(), GetNumberFormatW(), CConfigParser::GetSectionString(), InatCreateIconBySize(), InitializeDefaultUserLocale(), InitLanguagesList(), InputList_Add(), InputList_Create(), Int64GetNumFormat(), IntGetCodePageEntry(), is_default_metric(), IsBiDiLocalizedSystem(), IsLayoutExists(), LangCountryEnumProc(), LanguageEnumProc(), lcid_to_rfc1766(), lcid_to_rfc1766W(), LOCALE_Init(), LOCALE_InitRegistry(), locale_update_registry(), LocaleList_Create(), LocalesEnumProc(), MONTHCAL_LButtonDown(), MONTHCAL_PaintTitle(), MONTHCAL_SetFirstDayOfWeek(), MonthCalFirstDayOfWeek(), MonthCalReload(), NLS_EnumCalendarInfo(), NLS_EnumDateFormats(), NLS_EnumTimeFormats(), NLS_GetLocaleNumber(), NLS_GetLocaleString(), ParseDate(), ProcessCodePage(), ReadChmSystem(), SaveFontSubstitutionSettings(), SaveSystemSettings(), ScriptRecordDigitSubstitution(), SetUserLocaleName(), SH_FormatInteger(), SortEnumProc(), START_TEST(), test_EnumTimeFormatsW(), test_GetLocaleInfoEx(), test_GetLocaleInfoW(), test_GetNumberFormatA(), test_SetLocaleInfo(), test_unicode_wm_char(), test_VarWeekdayName(), TestDefaultLanguage(), 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 2062 of file locale.c.

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

Referenced by ConCfgInitDefaultSettings(), ConSrvInitConsole(), create_mbcinfo(), EngGetCurrentCodePage(), GetKBCodePage(), GetSupportedCP(), getSystemCP(), init_locale(), ME_StreamOutRTFHeader(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), OnNcCreate(), output_writeconsole(), SetUpConsoleInfo(), START_TEST(), taskkill_vprintfW(), and test_FreeConsole().

GetStringTypeA()

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

Definition at line 3212 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(), and IsCharSpaceA().

GetStringTypeExA()

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

Definition at line 3259 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 3188 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 3098 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 __acrt_GetStringTypeA(), __crtGetStringTypeW(), _ismbcsymbol_l(), _iswctype_l(), _Locale_ctype_create(), _Success_(), _WLocale_ctype(), create_locinfo(), create_mbcinfo(), DoWordBreakProc(), get_char_script(), GetC1Type(), GetStringType3ExW(), GetStringTypeA(), GetStringTypeExW(), IsBlankLine(), IsCharBlankW(), IsCharCntrlW(), IsCharDigitW(), IsCharPunctW(), IsCharSpaceW(), IsCharXDigitW(), my_wcswidth(), my_wcwidth(), SampCheckPassword(), test_crtGetStringTypeW(), test_FoldStringW(), and test_GetStringTypeW().

GetSystemDefaultLangID()

LANGID WINAPI GetSystemDefaultLangID

(

void

)

Definition at line 1199 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_process_security(), test_ScriptGetFontProperties(), test_SetEntriesInAclA(), test_SetEntriesInAclW(), test_text_metrics(), and validate_package().

GetSystemDefaultLCID()

LCID WINAPI GetSystemDefaultLCID

(

void

)

Definition at line 1235 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(), OnInitAddDialog(), START_TEST(), test_ConvertDefaultLocale(), test_EM_SETCHARFORMAT(), test_GetCodePageInfo(), test_GetFont(), test_GetLocaleInfoEx(), test_GetLocaleInfoW(), test_invariant(), test_LocaleNameToLCID(), test_LsaLookupNames2(), Test_RtlLcidToLocaleName(), test_textfont_global_defaults(), textfont_reset_to_default(), and WriteUserLocale().

GetSystemDefaultLocaleName()

INT WINAPI GetSystemDefaultLocaleName	(	LPWSTR	localename,
		INT	len
	)

Definition at line 1246 of file locale.c.

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

Referenced by test_ResolveLocaleName().

GetSystemDefaultUILanguage()

LANGID WINAPI GetSystemDefaultUILanguage

(

void

)

Definition at line 1400 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 1301 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 2803 of file locale.c.

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

Referenced by CEnumMergedFolder::Begin(), char_compare(), ChrCmpIW(), COMCTL32_ChrCmpHelperA(), COMCTL32_ChrCmpIW(), CreateBindCtx(), CreateLocationsList(), enum_proc(), CEnumMergedFolder::FindByName(), get_env(), GetAddressBarAccessKey(), GetCPInfoExW(), GetDynamicTimeZoneInformation(), Imm32LoadImeLangAndDesc(), IntGetCodePageEntry(), IntlStrEqWorkerA(), IntlStrEqWorkerW(), LocationsEnumProc(), lstrcmpA(), lstrcmpiA(), lstrcmpiW(), lstrcmpW(), msi_strequal(), msi_strprefix(), reg_mui_cache_get(), reg_mui_cache_put(), 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 1334 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(), and test_GetThreadPreferredUILanguages().

GetUserDefaultLangID()

LANGID WINAPI GetUserDefaultLangID

(

void

)

Definition at line 1182 of file locale.c.

{
    return LANGIDFROMLCID(GetUserDefaultLCID());
}

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

GetUserDefaultLCID()

LCID WINAPI GetUserDefaultLCID

(

void

)

Definition at line 1216 of file locale.c.

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

Referenced by __acrt_GetUserDefaultLocaleName(), ActiveScriptSite_GetLCID(), CConfigParser::CacheINI(), call_disp_func(), CliImmInitializeHotKeys(), ConvertDefaultLocale(), CreateLanguagesList(), get_codepage_table(), get_locale_kbd_layout(), GetAcceptLanguagesW(), GetLcidFromDefault(), GetLocalizedSMFolderName(), CConfigParser::GetSectionString(), GetThreadLocale(), GetUserDefaultLangID(), GetUserDefaultLocaleName(), GetUserDefaultUILanguage(), CAvailableApplicationInfo::InsertLanguageInfo(), LISTBOX_Create(), LoadKeyboardLayoutW(), LoadSetupData(), LOCALE_InitRegistry(), LocaleNameToLCID(), SetUserLocaleName(), START_TEST(), test_ConvertDefaultLocale(), test_GetAcceptLanguagesA(), test_GetKeyboardLayoutList(), test_GetLocaleInfoA(), test_GetLocaleInfoEx(), test_LocaleNameToLCID(), Test_RtlLcidToLocaleName(), test_setlocale(), test_SetLocaleInfo(), test_synthesized(), test_VarFormat(), and update_locale_registry().

GetUserDefaultLocaleName()

INT WINAPI GetUserDefaultLocaleName	(	LPWSTR	localename,
		int	buffersize
	)

Definition at line 5555 of file locale.c.

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

Referenced by locale_to_sname().

GetUserDefaultUILanguage()

LANGID WINAPI GetUserDefaultUILanguage

(

void

)

Definition at line 1380 of file locale.c.

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

Referenced by _tWinMain(), detect_locale(), FGetComponentPath(), get_langid_precedence(), IsBiDiLocalizedSystem(), LsaLookupPrivilegeDisplayName(), OmNavigator_get_browserLanguage(), SHGetWebFolderFilePathW(), test_ConvertDefaultLocale(), test_GetFileVersionInfoEx(), test_GetLocaleInfoA(), test_LocaleNameToLCID(), UXTHEME_ApplyTheme(), WinMain(), and wWinMain().

GetUserGeoID()

GEOID WINAPI GetUserGeoID

(

GEOCLASS

GeoClass

)

Definition at line 4747 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(), GetUserDefaultGeoName(), SetUserLocaleName(), and test_geo_name().

IdnToAscii()

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

Definition at line 5612 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 5750 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 5965 of file locale.c.

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

Referenced by InitFunctionPointers().

InvalidateNLSCache()

BOOL WINAPI InvalidateNLSCache

(

void

)

Definition at line 4733 of file locale.c.

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

is_genitive_name_supported()

static BOOL is_genitive_name_supported ( LCTYPE  lctype )

static

Definition at line 743 of file locale.c.

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

Referenced by GetLocaleInfoW().

IsDBCSLeadByte()

BOOL WINAPI IsDBCSLeadByte

(

BYTE

testchar

)

Definition at line 2126 of file locale.c.

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

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

IsDBCSLeadByteEx()

BOOL WINAPI IsDBCSLeadByteEx	(	UINT	codepage,
		BYTE	testchar
	)

Definition at line 2106 of file locale.c.

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

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

IsNormalizedString()

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

Definition at line 5579 of file locale.c.

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

IsValidCodePage()

BOOL WINAPI IsValidCodePage

(

UINT

codepage

)

Definition at line 2081 of file locale.c.

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

Referenced by __acrt_get_qualified_locale(), __acrt_get_qualified_locale_downlevel(), _setmbcp_nolock(), AddCodePage(), ChangeOutputCP_(), ConCfgReadUserSettings(), ConDrvInitConsole(), ConDrvSetConsoleCP(), ConSrvApplyUserSettings(), fnIMultiLanguage3_ValidateCodePageEx(), locale_to_sname(), make_csconv(), match_name_table_language(), test_CP_ThreadLang(), test_EnumCodePages(), test_IsCodePageInstallable(), test_setlocale(), test_string_conversion(), test_undefined_byte_char(), testScreenBuffer(), and validate_codepage().

IsValidLanguageGroup()

BOOL WINAPI IsValidLanguageGroup	(	LGRPID	lgrpid,
		DWORD	dwFlags
	)

Definition at line 4533 of file locale.c.

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

Referenced by InitFunctionPointers().

IsValidLocale()

BOOL WINAPI IsValidLocale	(	LCID	lcid,
		DWORD	flags
	)

Definition at line 2925 of file locale.c.

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

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

IsValidLocaleName()

BOOL WINAPI IsValidLocaleName

(

LPCWSTR

locale

)

Definition at line 2936 of file locale.c.

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

Referenced by InitFunctionPointers(), and locale_to_sname().

LCMapStringA()

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

Definition at line 3834 of file locale.c.

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

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

LCMapStringEx()

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

Definition at line 3746 of file locale.c.

{
    if (version) FIXME("unsupported version structure %p\n", version);
    if (reserved) FIXME("unsupported reserved pointer %p\n", reserved);
    if (handle)
    {
        static int once;
        if (!once++) FIXME("unsupported lparam %Ix\n", handle);
    }
 
    if (!src || !srclen || dstlen < 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (srclen < 0) srclen = lstrlenW(src) + 1;
 
    TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
           debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
 
    flags &= ~LOCALE_USE_CP_ACP;
 
    if (src == dst && (flags & ~(LCMAP_LOWERCASE | LCMAP_UPPERCASE)))
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (!dstlen) dst = NULL;
 
    if (flags & LCMAP_SORTKEY)
    {
        INT ret;
 
        if (srclen < 0)
            srclen = strlenW(src);
 
        ret = wine_get_sortkey(flags, src, srclen, (char *)dst, dstlen);
        if (ret == 0)
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
        else
            ret++;
        return ret;
    }
 
    /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
    if (flags & SORT_STRINGSORT)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    return lcmap_string(flags, src, srclen, dst, dstlen);
}

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

LCMapStringW()

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

Definition at line 3808 of file locale.c.

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

Referenced by __acrt_LCMapStringEx(), __crtLCMapStringA(), __crtLCMapStringW(), _towlower_l(), _towupper_l(), _wcsxfrm_l(), _WLocale_strxfrm(), _WLocale_tolower(), _WLocale_toupper(), CharLowerBuffW(), CharUpperBuffW(), create_locinfo(), create_mbcinfo(), lcid_to_rfc1766(), lcid_to_rfc1766W(), LCMapStringA(), LCMapStringW_wrapper(), SHELL32_AssocGetExtensionDescription(), SvchostCharLowerW(), TEST_LCMapStringW(), test_LCMapStringW(), test_tolower(), and xsltStrxfrm().

LOCALE_Init()

void LOCALE_Init

(

void

)

Definition at line 4188 of file locale.c.

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

LOCALE_InitRegistry()

void LOCALE_InitRegistry

(

void

)

Definition at line 843 of file locale.c.

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

locale_update_registry()

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

static

Definition at line 804 of file locale.c.

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

Referenced by LOCALE_InitRegistry().

lstrcmpA()

int WINAPI lstrcmpA	(	LPCSTR	str1,
		LPCSTR	str2
	)

Definition at line 4104 of file locale.c.

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

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

lstrcmpiA()

int WINAPI lstrcmpiA	(	LPCSTR	str1,
		LPCSTR	str2
	)

Definition at line 4133 of file locale.c.

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

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

lstrcmpiW()

int WINAPI lstrcmpiW	(	LPCWSTR	str1,
		LPCWSTR	str2
	)

Definition at line 4171 of file locale.c.

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

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

lstrcmpW()

int WINAPI lstrcmpW	(	LPCWSTR	str1,
		LPCWSTR	str2
	)

Definition at line 4152 of file locale.c.

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

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

MultiByteToWideChar()

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

Definition at line 2468 of file locale.c.

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

NLS_EnumLanguageGroupLocales()

static BOOL NLS_EnumLanguageGroupLocales ( ENUMLANGUAGEGROUPLOCALE_CALLBACKS *  lpProcs )

static

Definition at line 4582 of file locale.c.

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

Referenced by EnumLanguageGroupLocalesA(), and EnumLanguageGroupLocalesW().

NLS_EnumSystemLanguageGroups()

static BOOL NLS_EnumSystemLanguageGroups ( ENUMLANGUAGEGROUP_CALLBACKS *  lpProcs )

static

Definition at line 4386 of file locale.c.

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

Referenced by EnumSystemLanguageGroupsA(), and EnumSystemLanguageGroupsW().

NLS_GetLanguageGroupName()

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

static

Definition at line 4336 of file locale.c.

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

Referenced by NLS_EnumSystemLanguageGroups().

NLS_RegEnumValue()

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

static

Definition at line 4287 of file locale.c.

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

Referenced by NLS_EnumLanguageGroupLocales(), and NLS_EnumSystemLanguageGroups().

NLS_RegGetDword()

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

static

Definition at line 4315 of file locale.c.

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

Referenced by IsValidLanguageGroup().

NLS_RegOpenKey()

static HANDLE NLS_RegOpenKey ( HANDLE  hRootKey, LPCWSTR  szKeyName  )

static

Definition at line 4262 of file locale.c.

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

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

NormalizeString()

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

Definition at line 5568 of file locale.c.

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

Referenced by InitFunctionPointers().

ResolveLocaleName()

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

Definition at line 6149 of file locale.c.

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

Referenced by InitFunctionPointers().

SetCPGlobal()

UINT WINAPI SetCPGlobal

(

UINT

acp

)

Definition at line 2041 of file locale.c.

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

SetLocaleInfoA()

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

Definition at line 1891 of file locale.c.

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

Referenced by test_GetNumberFormatA(), test_SetLocaleInfo(), and test_VarCat().

SetLocaleInfoW()

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

Definition at line 1923 of file locale.c.

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

Referenced by locale_update_registry(), SetLocaleInfoA(), test_GetNumberFormatA(), and test_SetLocaleInfo().

SetThreadLocale()

BOOL WINAPI SetThreadLocale

(

LCID

lcid

)

Definition at line 2822 of file locale.c.

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

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

SetThreadPreferredUILanguages()

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

Definition at line 1325 of file locale.c.

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

SetThreadUILanguage()

LANGID WINAPI SetThreadUILanguage

(

LANGID

langid

)

Definition at line 2857 of file locale.c.

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

Referenced by InitFunctionPointers().

setup_unix_locales()

static UINT setup_unix_locales ( void  )

static

Definition at line 1116 of file locale.c.

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

Referenced by LOCALE_Init().

SetUserGeoID()

BOOL WINAPI SetUserGeoID

(

GEOID

GeoID

)

Definition at line 4784 of file locale.c.

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

Referenced by SetUserGeoName(), test_geo_name(), and update_locale_registry().

strcpynAtoW()

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

inlinestatic

Definition at line 267 of file locale.c.

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

Referenced by setup_unix_locales().

utf7_can_directly_encode()

static BOOL utf7_can_directly_encode ( WCHAR  codepoint )

inlinestatic

Definition at line 2553 of file locale.c.

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

Referenced by utf7_wcstombs().

utf7_mbstowcs()

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

static

Definition at line 2352 of file locale.c.

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

Referenced by MultiByteToWideChar().

utf7_wcstombs()

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

static

Definition at line 2602 of file locale.c.

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

Referenced by WideCharToMultiByte().

utf7_write_c()

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

inlinestatic

Definition at line 2578 of file locale.c.

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

Referenced by utf7_wcstombs().

utf7_write_w()

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

inlinestatic

Definition at line 2328 of file locale.c.

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

Referenced by utf7_mbstowcs().

VerLanguageNameA()

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

Definition at line 3076 of file locale.c.

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

VerLanguageNameW()

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

Definition at line 3087 of file locale.c.

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

Referenced by CFileVersionInfo::GetLangName().

WideCharToMultiByte()

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

Definition at line 2694 of file locale.c.

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

wine_compare_string()

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

Definition at line 358 of file sortkey.c.

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

Referenced by CompareStringEx().

wine_fold_string()

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

Definition at line 118 of file fold.c.

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

Referenced by FoldStringW().

wine_get_sortkey()

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

Definition at line 33 of file sortkey.c.

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

Referenced by LCMapStringA(), and LCMapStringEx().

Variable Documentation

ansi_cptable

const union cptable* ansi_cptable

static

Definition at line 65 of file locale.c.

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

cache_section

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

static

Definition at line 263 of file locale.c.

Referenced by get_registry_locale_info(), and SetLocaleInfoW().

geoinfodata

const struct geoinfo_t geoinfodata[]

static

Definition at line 4923 of file locale.c.

Referenced by EnumSystemGeoID(), and get_geoinfo_dataptr().

iCalendarTypeW

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

static

Definition at line 171 of file locale.c.

iCountryW

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

static

Definition at line 172 of file locale.c.

iCurrDigitsW

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

static

Definition at line 173 of file locale.c.

iCurrencyW

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

static

Definition at line 174 of file locale.c.

iDateW

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

static

Definition at line 175 of file locale.c.

iDigitsW

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

static

Definition at line 176 of file locale.c.

iFirstDayOfWeekW

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

static

Definition at line 177 of file locale.c.

iFirstWeekOfYearW

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

static

Definition at line 178 of file locale.c.

iLDateW

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

static

Definition at line 179 of file locale.c.

iLZeroW

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

static

Definition at line 180 of file locale.c.

iMeasureW

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

static

Definition at line 181 of file locale.c.

iNegCurrW

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

static

Definition at line 182 of file locale.c.

iNegNumberW

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

static

Definition at line 183 of file locale.c.

iPaperSizeW

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

static

Definition at line 184 of file locale.c.

iTimePrefixW

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

static

Definition at line 186 of file locale.c.

iTimeW

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

static

Definition at line 187 of file locale.c.

iTLZeroW

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

static

Definition at line 185 of file locale.c.

kernel32_handle

HMODULE kernel32_handle

extern

Definition at line 26 of file dllmain.c.

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

lcid_LC_COLLATE

LCID lcid_LC_COLLATE

static

Definition at line 161 of file locale.c.

Referenced by convert_default_lcid().

lcid_LC_CTYPE

LCID lcid_LC_CTYPE

static

Definition at line 162 of file locale.c.

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

lcid_LC_MEASUREMENT

LCID lcid_LC_MEASUREMENT

static

Definition at line 168 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

lcid_LC_MESSAGES

LCID lcid_LC_MESSAGES

static

Definition at line 163 of file locale.c.

Referenced by LOCALE_Init(), and LOCALE_InitRegistry().

lcid_LC_MONETARY

LCID lcid_LC_MONETARY

static

Definition at line 164 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

lcid_LC_NUMERIC

LCID lcid_LC_NUMERIC

static

Definition at line 165 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

lcid_LC_PAPER

LCID lcid_LC_PAPER

static

Definition at line 167 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

lcid_LC_TELEPHONE

LCID lcid_LC_TELEPHONE

static

Definition at line 169 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

lcid_LC_TIME

LCID lcid_LC_TIME

static

Definition at line 166 of file locale.c.

Referenced by convert_default_lcid(), and LOCALE_InitRegistry().

mac_cptable

const union cptable* mac_cptable

static

Definition at line 67 of file locale.c.

Referenced by get_codepage_table(), and LOCALE_Init().

NumShapeW

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

static

Definition at line 209 of file locale.c.

oem_cptable

const union cptable* oem_cptable

static

Definition at line 66 of file locale.c.

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

registry_values

struct registry_value registry_values[]

static

Referenced by get_locale_registry_value().

s1159W

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

static

Definition at line 188 of file locale.c.

s2359W

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

static

Definition at line 189 of file locale.c.

sCountryW

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

static

Definition at line 190 of file locale.c.

sCurrencyW

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

static

Definition at line 191 of file locale.c.

sDateW

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

static

Definition at line 192 of file locale.c.

sDecimalW

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

static

Definition at line 193 of file locale.c.

sGroupingW

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

static

Definition at line 194 of file locale.c.

sLanguageW

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

static

Definition at line 195 of file locale.c.

sListW

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

static

Definition at line 196 of file locale.c.

sLongDateW

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

static

Definition at line 197 of file locale.c.

sMonDecimalSepW

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

static

Definition at line 198 of file locale.c.

sMonGroupingW

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

static

Definition at line 199 of file locale.c.

sMonThousandSepW

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

static

Definition at line 200 of file locale.c.

sNativeDigitsW

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

static

Definition at line 201 of file locale.c.

sNegativeSignW

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

static

Definition at line 202 of file locale.c.

sPositiveSignW

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

static

Definition at line 203 of file locale.c.

sShortDateW

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

static

Definition at line 204 of file locale.c.

sThousandW

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

static

Definition at line 205 of file locale.c.

sTimeFormatW

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

static

Definition at line 206 of file locale.c.

sTimeW

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

static

Definition at line 207 of file locale.c.

sYearMonthW

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

static

Definition at line 208 of file locale.c.

szLangGroupsKeyName

const WCHAR szLangGroupsKeyName[]

static

Initial value:

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

Definition at line 76 of file locale.c.

Referenced by IsValidLanguageGroup(), and NLS_EnumSystemLanguageGroups().

szLocaleKeyName

const WCHAR szLocaleKeyName[]

static

Initial value:

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

Definition at line 70 of file locale.c.

Referenced by NLS_EnumLanguageGroupLocales().

unix_cptable

const union cptable* unix_cptable

static

Definition at line 68 of file locale.c.

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