#include <stdarg.h>
#include <stdlib.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winnls.h"
#include "winuser.h"
#include "winternl.h"
#include "kernelbase.h"
#include "wine/debug.h"

Include dependency graph for locale.c:

Classes
struct	registry_entry

struct	calendar

struct	geo_id

struct	geo_index

struct	norm_table

struct	sortguid

struct	sort_expansion

struct	jamo_sort

struct	sort_compression

union	char_weights

struct	sortkey

struct	sortkey_state

struct	mui_resource

Macros
#define	WIN32_NO_STATUS

#define	WINNORMALIZEAPI

#define	CALINFO_MAX_YEAR 2029

#define	FLAG_HAS_3_BYTE_WEIGHTS 0x01

#define	FLAG_REVERSEDIACRITICS 0x10

#define	FLAG_DOUBLECOMPRESSION 0x20

#define	FLAG_INVERSECASING 0x40

#define	CASE_FULLWIDTH 0x01 /* full width kana (vs. half width) */

#define	CASE_FULLSIZE 0x02 /* full size kana (vs. small) */

#define	CASE_SUBSCRIPT 0x08 /* sub/super script */

#define	CASE_UPPER 0x10 /* upper case */

#define	CASE_KATAKANA 0x20 /* katakana (vs. hiragana) */

#define	CASE_COMPR_2 0x40 /* compression exists for >= 2 chars */

#define	CASE_COMPR_4 0x80 /* compression exists for >= 4 chars */

#define	CASE_COMPR_6 0xc0 /* compression exists for >= 6 chars */

#define	UPDATE(val, entry) update_registry_value( LOCALE_NOUSEROVERRIDE \| (val), (entry).subkey, (entry).value )

#define	OUTPUT(ch)

#define	ENCODABLE(ch) ((ch) <= 0x7a && directly_encodable[(ch)])

#define	OUTPUT(ch)

#define	HANGUL_SBASE 0xac00

#define	HANGUL_LCOUNT 19

#define	HANGUL_VCOUNT 21

#define	HANGUL_TCOUNT 28

#define	MUI_SIGNATURE 0xfecdfecd

Enumerations
enum	charmaps { CHARMAP_FOLDDIGITS , CHARMAP_COMPAT , CHARMAP_HIRAGANA , CHARMAP_KATAKANA , CHARMAP_HALFWIDTH , CHARMAP_FULLWIDTH , CHARMAP_TRADITIONAL , CHARMAP_SIMPLIFIED , NB_CHARMAPS }

enum	sortkey_script { SCRIPT_UNSORTABLE = 0 , SCRIPT_NONSPACE_MARK = 1 , SCRIPT_EXPANSION = 2 , SCRIPT_EASTASIA_SPECIAL = 3 , SCRIPT_JAMO_SPECIAL = 4 , SCRIPT_EXTENSION_A = 5 , SCRIPT_PUNCTUATION = 6 , SCRIPT_SYMBOL_1 = 7 , SCRIPT_SYMBOL_2 = 8 , SCRIPT_SYMBOL_3 = 9 , SCRIPT_SYMBOL_4 = 10 , SCRIPT_SYMBOL_5 = 11 , SCRIPT_SYMBOL_6 = 12 , SCRIPT_DIGIT = 13 , SCRIPT_LATIN = 14 , SCRIPT_GREEK = 15 , SCRIPT_CYRILLIC = 16 , SCRIPT_KANA = 34 , SCRIPT_HEBREW = 40 , SCRIPT_ARABIC = 41 , SCRIPT_PUA_FIRST = 169 , SCRIPT_PUA_LAST = 175 , SCRIPT_CJK_FIRST = 192 , SCRIPT_CJK_LAST = 239 }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (nls)

static int	compression_size (int len)

static void	load_locale_nls (void)

static void	load_sortdefault_nls (void)

static const struct sortguid *	find_sortguid (const GUID *guid)

static const NLS_LOCALE_DATA *	get_locale_data (UINT idx)

static const struct calendar *	get_calendar_data (const NLS_LOCALE_DATA *locale, UINT id)

static int	compare_locale_names (const WCHAR n1, const WCHAR n2)

static const NLS_LOCALE_LCNAME_INDEX *	find_lcname_entry (const WCHAR *name)

static const NLS_LOCALE_LCID_INDEX *	find_lcid_entry (LCID lcid)

static const struct geo_id *	find_geo_id_entry (GEOID id)

static const struct geo_id *	find_geo_name_entry (const WCHAR *name)

static const NLS_LOCALE_DATA *	get_locale_by_name (const WCHAR name, LCID lcid)

static const struct sortguid *	get_language_sort (const WCHAR *name)

const NLS_LOCALE_DATA *WINAPI	NlsValidateLocale (LCID *lcid, ULONG flags)

static int	locale_return_data (const WCHAR data, int datalen, LCTYPE type, WCHAR buffer, int len)

static BOOL	set_registry_entry (struct registry_entry entry, const WCHAR data)

static int	locale_return_reg_string (struct registry_entry entry, LCTYPE type, WCHAR buffer, int len)

static int	locale_return_string (DWORD pos, LCTYPE type, WCHAR *buffer, int len)

static int	locale_return_number (UINT val, LCTYPE type, WCHAR *buffer, int len)

static int	locale_return_reg_number (struct registry_entry entry, LCTYPE type, WCHAR buffer, int len)

static int	locale_return_grouping (DWORD pos, LCTYPE type, WCHAR *buffer, int len)

static int	locale_return_strarray (DWORD pos, WORD idx, LCTYPE type, WCHAR *buffer, int len)

static int	locale_return_strarray_concat (DWORD pos, LCTYPE type, WCHAR *buffer, int len)

static int	cal_return_number (UINT val, CALTYPE type, WCHAR buffer, int len, DWORD value)

static WCHAR *	find_format (WCHAR str, const WCHAR accept)

static WCHAR *	locale_replace_separator (WCHAR buffer, const WCHAR sep)

static const WCHAR *	get_locale_sortname (LCID lcid)

static int	get_locale_info (const NLS_LOCALE_DATA locale, LCID lcid, LCTYPE type, WCHAR buffer, int len)

static int	get_calendar_info (const NLS_LOCALE_DATA locale, CALID id, CALTYPE type, WCHAR buffer, int len, DWORD *value)

static int	get_geo_info (const struct geo_id geo, enum SYSGEOTYPE type, WCHAR buffer, int len, LANGID lang)

static void	update_registry_value (UINT type, const WCHAR subkey, const WCHAR value)

static void	update_locale_registry (void)

void	init_locale (HMODULE module)

static WCHAR	casemap (const USHORT *table, WCHAR ch)

static unsigned int	casemap_high (const USHORT *table, WCHAR high, WCHAR low)

static BOOL	table_has_high_planes (const USHORT *table)

static int	put_utf16 (WCHAR *dst, int pos, int dstlen, unsigned int ch)

static WORD	get_char_type (DWORD type, WCHAR ch)

static void	map_byterev (const WCHAR src, int len, WCHAR dst)

static int	casemap_string (const USHORT table, const WCHAR src, int srclen, WCHAR *dst, int dstlen)

static union char_weights	get_char_weights (WCHAR c, UINT except)

static BYTE	rol (BYTE val, BYTE count)

static BYTE	get_char_props (const struct norm_table *info, unsigned int ch)

static const WCHAR *	get_decomposition (WCHAR ch, unsigned int *ret_len)

static WCHAR	compose_chars (WCHAR ch1, WCHAR ch2)

static UINT	get_locale_codepage (const NLS_LOCALE_DATA *locale, ULONG flags)

static UINT	get_lcid_codepage (LCID lcid, ULONG flags)

static const CPTABLEINFO *	get_codepage_table (UINT codepage)

static const WCHAR *	get_ligature (WCHAR wc)

static NTSTATUS	expand_ligatures (const WCHAR src, int srclen, WCHAR dst, int *dstlen)

static NTSTATUS	fold_digits (const WCHAR src, int srclen, WCHAR dst, int *dstlen)

static NTSTATUS	fold_string (DWORD flags, const WCHAR src, int srclen, WCHAR dst, int *dstlen)

static int	mbstowcs_cpsymbol (DWORD flags, const char src, int srclen, WCHAR dst, int dstlen)

static int	mbstowcs_utf7 (DWORD flags, const char src, int srclen, WCHAR dst, int dstlen)

static int	mbstowcs_utf8 (DWORD flags, const char src, int srclen, WCHAR dst, int dstlen)

static int	is_private_use_area_char (WCHAR code)

static int	check_invalid_chars (const CPTABLEINFO info, const unsigned char src, int srclen)

static int	mbstowcs_decompose (const CPTABLEINFO info, const unsigned char src, int srclen, WCHAR *dst, int dstlen)

static int	mbstowcs_sbcs (const CPTABLEINFO info, const unsigned char src, int srclen, WCHAR *dst, int dstlen)

static int	mbstowcs_dbcs (const CPTABLEINFO info, const unsigned char src, int srclen, WCHAR *dst, int dstlen)

static int	mbstowcs_codepage (const CPTABLEINFO info, DWORD flags, const char src, int srclen, WCHAR *dst, int dstlen)

static int	wcstombs_cpsymbol (DWORD flags, const WCHAR src, int srclen, char dst, int dstlen, const char defchar, BOOL used)

static int	wcstombs_utf7 (DWORD flags, const WCHAR src, int srclen, char dst, int dstlen, const char defchar, BOOL used)

static int	wcstombs_utf8 (DWORD flags, const WCHAR src, int srclen, char dst, int dstlen, const char defchar, BOOL used)

static int	wcstombs_sbcs (const CPTABLEINFO info, const WCHAR src, unsigned int srclen, char *dst, unsigned int dstlen)

static int	wcstombs_dbcs (const CPTABLEINFO info, const WCHAR src, unsigned int srclen, char *dst, unsigned int dstlen)

static int	is_valid_sbcs_mapping (const CPTABLEINFO *info, DWORD flags, unsigned int wch)

static int	is_valid_dbcs_mapping (const CPTABLEINFO *info, DWORD flags, unsigned int wch)

static int	wcstombs_sbcs_slow (const CPTABLEINFO info, DWORD flags, const WCHAR src, unsigned int srclen, char dst, unsigned int dstlen, const char defchar, BOOL *used)

static int	wcstombs_dbcs_slow (const CPTABLEINFO info, DWORD flags, const WCHAR src, unsigned int srclen, char dst, unsigned int dstlen, const char defchar, BOOL *used)

static int	wcstombs_codepage (const CPTABLEINFO info, DWORD flags, const WCHAR src, int srclen, char dst, int dstlen, const char defchar, BOOL *used)

static void	append_sortkey (struct sortkey *key, BYTE val)

static void	reverse_sortkey (struct sortkey *key)

static int	compare_sortkeys (const struct sortkey key1, const struct sortkey key2, BOOL shorter_wins)

static void	append_normal_weights (const struct sortguid sortid, struct sortkey key_primary, struct sortkey key_diacritic, struct sortkey key_case, union char_weights weights, DWORD flags)

static void	append_nonspace_weights (struct sortkey *key, union char_weights weights, DWORD flags)

static void	append_expansion_weights (const struct sortguid sortid, struct sortkey key_primary, struct sortkey key_diacritic, struct sortkey key_case, union char_weights weights, DWORD flags, BOOL is_compare)

static const UINT *	find_compression (const WCHAR src, const WCHAR table, int count, int len)

static int	get_compression_weights (UINT compression, const WCHAR compr_tables[8], const WCHAR src, int srclen, union char_weights *weights)

static WCHAR	get_digit_zero_char (WCHAR ch)

static int	append_digit_weights (struct sortkey key, const WCHAR src, UINT srclen)

static int	append_extra_kana_weights (struct sortkey keys[4], const WCHAR src, int pos, UINT except, BYTE case_mask, union char_weights weights)

static int	append_hangul_weights (struct sortkey key, const WCHAR src, int srclen, UINT except)

static int	put_sortkey (BYTE dst, int dstlen, int pos, const struct sortkey key, BYTE terminator)

static void	init_sortkey_state (struct sortkey_state s, DWORD flags, UINT srclen, BYTE primary_buf, UINT primary_size)

static BOOL	remove_unneeded_weights (const struct sortguid sortid, struct sortkey_state s)

static void	free_sortkey_state (struct sortkey_state *s)

static int	append_weights (const struct sortguid sortid, DWORD flags, const WCHAR src, int srclen, int pos, BYTE case_mask, UINT except, const WCHAR compr_tables[8], struct sortkey_state s, BOOL is_compare)

static int	get_sortkey (const struct sortguid sortid, DWORD flags, const WCHAR src, int srclen, BYTE *dst, int dstlen)

static int	compare_string (const struct sortguid sortid, DWORD flags, const WCHAR src1, int srclen1, const WCHAR *src2, int srclen2)

static int	find_substring (const struct sortguid sortid, DWORD flags, const WCHAR src, int srclen, const WCHAR value, int valuelen, int reslen)

static int	map_to_fullwidth (const USHORT table, const WCHAR src, int srclen, WCHAR *dst, int dstlen)

static int	nonspace_ignored (WCHAR ch)

static int	map_remove_ignored (DWORD flags, const WCHAR src, int srclen, WCHAR dst, int dstlen)

static int	map_to_halfwidth (const USHORT table, const WCHAR src, int srclen, WCHAR *dst, int dstlen)

static int	lcmap_string (const struct sortguid sortid, DWORD flags, const WCHAR src, int srclen, WCHAR *dst, int dstlen)

static int	compare_tzdate (const TIME_FIELDS tf, const SYSTEMTIME compare)

static DWORD	get_timezone_id (const TIME_ZONE_INFORMATION *info, LARGE_INTEGER time, BOOL is_local)

BOOL WINAPI DECLSPEC_HOTPATCH	Internal_EnumCalendarInfo (CALINFO_ENUMPROCW proc, const NLS_LOCALE_DATA *locale, CALID id, CALTYPE type, BOOL unicode, BOOL ex, BOOL exex, LPARAM lparam)

static BOOL	call_enum_date_func (DATEFMT_ENUMPROCW proc, const NLS_LOCALE_DATA locale, DWORD flags, DWORD str, WCHAR buffer, CALID id, BOOL unicode, BOOL ex, BOOL exex, LPARAM lparam)

BOOL WINAPI DECLSPEC_HOTPATCH	Internal_EnumDateFormats (DATEFMT_ENUMPROCW proc, const NLS_LOCALE_DATA *locale, DWORD flags, BOOL unicode, BOOL ex, BOOL exex, LPARAM lparam)

BOOL WINAPI DECLSPEC_HOTPATCH	Internal_EnumLanguageGroupLocales (LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id, DWORD flags, LONG_PTR param, BOOL unicode)

BOOL WINAPI DECLSPEC_HOTPATCH	Internal_EnumSystemCodePages (CODEPAGE_ENUMPROCW proc, DWORD flags, BOOL unicode)

BOOL WINAPI DECLSPEC_HOTPATCH	Internal_EnumSystemLanguageGroups (LANGUAGEGROUP_ENUMPROCW proc, DWORD flags, LONG_PTR param, BOOL unicode)

BOOL WINAPI DECLSPEC_HOTPATCH	Internal_EnumTimeFormats (TIMEFMT_ENUMPROCW proc, const NLS_LOCALE_DATA *locale, DWORD flags, BOOL unicode, BOOL ex, LPARAM lparam)

BOOL WINAPI DECLSPEC_HOTPATCH	Internal_EnumUILanguages (UILANGUAGE_ENUMPROCW proc, DWORD flags, LONG_PTR param, BOOL unicode)

INT WINAPI	CompareStringEx (const WCHAR locale, DWORD flags, const WCHAR str1, int len1, const WCHAR str2, int len2, NLSVERSIONINFO version, void *reserved, LPARAM handle)

INT WINAPI DECLSPEC_HOTPATCH	CompareStringA (LCID lcid, DWORD flags, const char str1, int len1, const char str2, int len2)

INT WINAPI DECLSPEC_HOTPATCH	CompareStringW (LCID lcid, DWORD flags, const WCHAR str1, int len1, const WCHAR str2, int len2)

INT WINAPI DECLSPEC_HOTPATCH	CompareStringOrdinal (const WCHAR str1, INT len1, const WCHAR str2, INT len2, BOOL ignore_case)

LCID WINAPI DECLSPEC_HOTPATCH	ConvertDefaultLocale (LCID lcid)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumCalendarInfoW (CALINFO_ENUMPROCW proc, LCID lcid, CALID id, CALTYPE type)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumCalendarInfoExW (CALINFO_ENUMPROCEXW proc, LCID lcid, CALID id, CALTYPE type)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumCalendarInfoExEx (CALINFO_ENUMPROCEXEX proc, LPCWSTR locale, CALID id, LPCWSTR reserved, CALTYPE type, LPARAM lparam)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumDateFormatsW (DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumDateFormatsExW (DATEFMT_ENUMPROCEXW proc, LCID lcid, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumDateFormatsExEx (DATEFMT_ENUMPROCEXEX proc, const WCHAR *locale, DWORD flags, LPARAM lparam)

DWORD WINAPI DECLSPEC_HOTPATCH	EnumDynamicTimeZoneInformation (DWORD index, DYNAMIC_TIME_ZONE_INFORMATION *info)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumLanguageGroupLocalesW (LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id, DWORD flags, LONG_PTR param)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumUILanguagesW (UILANGUAGE_ENUMPROCW proc, DWORD flags, LONG_PTR param)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumSystemCodePagesW (CODEPAGE_ENUMPROCW proc, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumSystemGeoID (GEOCLASS class, GEOID parent, GEO_ENUMPROC proc)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumSystemLanguageGroupsW (LANGUAGEGROUP_ENUMPROCW proc, DWORD flags, LONG_PTR param)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumSystemLocalesA (LOCALE_ENUMPROCA proc, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumSystemLocalesW (LOCALE_ENUMPROCW proc, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumSystemLocalesEx (LOCALE_ENUMPROCEX proc, DWORD wanted_flags, LPARAM param, void *reserved)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumTimeFormatsW (TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	EnumTimeFormatsEx (TIMEFMT_ENUMPROCEX proc, const WCHAR *locale, DWORD flags, LPARAM lparam)

INT WINAPI DECLSPEC_HOTPATCH	FindNLSString (LCID lcid, DWORD flags, const WCHAR src, int srclen, const WCHAR value, int valuelen, int *found)

INT WINAPI DECLSPEC_HOTPATCH	FindNLSStringEx (const WCHAR locale, DWORD flags, const WCHAR src, int srclen, const WCHAR value, int valuelen, int found, NLSVERSIONINFO version, void reserved, LPARAM handle)

INT WINAPI DECLSPEC_HOTPATCH	FindStringOrdinal (DWORD flag, const WCHAR src, INT src_size, const WCHAR val, INT val_size, BOOL ignore_case)

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

static const WCHAR *	get_message (DWORD flags, const void src, UINT id, UINT lang, BOOL ansi, WCHAR *buffer)

DWORD WINAPI DECLSPEC_HOTPATCH	FormatMessageA (DWORD flags, const void source, DWORD msgid, DWORD langid, char buffer, DWORD size, va_list *args)

DWORD WINAPI DECLSPEC_HOTPATCH	FormatMessageW (DWORD flags, const void source, DWORD msgid, DWORD langid, WCHAR buffer, DWORD size, va_list *args)

UINT WINAPI	GetACP (void)

BOOL WINAPI DECLSPEC_HOTPATCH	GetCPInfo (UINT codepage, CPINFO *cpinfo)

BOOL WINAPI	GetCPInfoExW (UINT codepage, DWORD flags, CPINFOEXW *cpinfo)

INT WINAPI DECLSPEC_HOTPATCH	GetCalendarInfoW (LCID lcid, CALID calendar, CALTYPE type, WCHAR buffer, INT len, DWORD value)

INT WINAPI DECLSPEC_HOTPATCH	GetCalendarInfoEx (const WCHAR name, CALID calendar, const WCHAR reserved, CALTYPE type, WCHAR buffer, INT len, DWORD value)

DWORD WINAPI DECLSPEC_HOTPATCH	GetDynamicTimeZoneInformation (DYNAMIC_TIME_ZONE_INFORMATION *info)

DWORD WINAPI DECLSPEC_HOTPATCH	GetDynamicTimeZoneInformationEffectiveYears (const DYNAMIC_TIME_ZONE_INFORMATION info, DWORD first, DWORD *last)

static BOOL	validate_mui_resource (struct mui_resource *mui, DWORD size)

BOOL WINAPI DECLSPEC_HOTPATCH	GetFileMUIInfo (DWORD flags, const WCHAR path, FILEMUIINFO info, DWORD *size)

BOOL WINAPI	GetFileMUIPath (DWORD flags, const WCHAR filepath, WCHAR language, ULONG languagelen, WCHAR muipath, ULONG muipathlen, ULONGLONG enumerator)

INT WINAPI DECLSPEC_HOTPATCH	GetGeoInfoW (GEOID id, GEOTYPE type, WCHAR *data, int count, LANGID lang)

INT WINAPI DECLSPEC_HOTPATCH	GetGeoInfoEx (WCHAR location, GEOTYPE type, WCHAR data, int data_count)

INT WINAPI DECLSPEC_HOTPATCH	GetLocaleInfoA (LCID lcid, LCTYPE lctype, char *buffer, INT len)

INT WINAPI DECLSPEC_HOTPATCH	GetLocaleInfoW (LCID lcid, LCTYPE lctype, WCHAR *buffer, INT len)

INT WINAPI DECLSPEC_HOTPATCH	GetLocaleInfoEx (const WCHAR name, LCTYPE info, WCHAR buffer, INT len)

BOOL WINAPI DECLSPEC_HOTPATCH	GetNLSVersion (NLS_FUNCTION func, LCID lcid, NLSVERSIONINFO *info)

BOOL WINAPI DECLSPEC_HOTPATCH	GetNLSVersionEx (NLS_FUNCTION func, const WCHAR locale, NLSVERSIONINFOEX info)

UINT WINAPI	GetOEMCP (void)

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

BOOL WINAPI DECLSPEC_HOTPATCH	GetStringTypeA (LCID locale, DWORD type, const char src, int count, WORD chartype)

BOOL WINAPI DECLSPEC_HOTPATCH	GetStringTypeW (DWORD type, const WCHAR src, INT count, WORD chartype)

BOOL WINAPI DECLSPEC_HOTPATCH	GetStringTypeExW (LCID locale, DWORD type, const WCHAR src, int count, WORD chartype)

LCID WINAPI DECLSPEC_HOTPATCH	GetSystemDefaultLCID (void)

LANGID WINAPI DECLSPEC_HOTPATCH	GetSystemDefaultLangID (void)

INT WINAPI DECLSPEC_HOTPATCH	GetSystemDefaultLocaleName (LPWSTR name, INT count)

LANGID WINAPI DECLSPEC_HOTPATCH	GetSystemDefaultUILanguage (void)

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

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

DWORD WINAPI DECLSPEC_HOTPATCH	GetTimeZoneInformation (TIME_ZONE_INFORMATION *info)

BOOL WINAPI DECLSPEC_HOTPATCH	GetTimeZoneInformationForYear (USHORT year, DYNAMIC_TIME_ZONE_INFORMATION dynamic, TIME_ZONE_INFORMATION info)

LCID WINAPI DECLSPEC_HOTPATCH	GetUserDefaultLCID (void)

LANGID WINAPI DECLSPEC_HOTPATCH	GetUserDefaultLangID (void)

INT WINAPI DECLSPEC_HOTPATCH	GetUserDefaultLocaleName (LPWSTR name, INT len)

LANGID WINAPI DECLSPEC_HOTPATCH	GetUserDefaultUILanguage (void)

GEOID WINAPI DECLSPEC_HOTPATCH	GetUserGeoID (GEOCLASS geoclass)

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

INT WINAPI DECLSPEC_HOTPATCH	IdnToAscii (DWORD flags, const WCHAR src, INT srclen, WCHAR dst, INT dstlen)

INT WINAPI DECLSPEC_HOTPATCH	IdnToNameprepUnicode (DWORD flags, const WCHAR src, INT srclen, WCHAR dst, INT dstlen)

INT WINAPI DECLSPEC_HOTPATCH	IdnToUnicode (DWORD flags, const WCHAR src, INT srclen, WCHAR dst, INT dstlen)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharAlphaA (CHAR c)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharAlphaW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharAlphaNumericA (CHAR c)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharAlphaNumericW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharBlankW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharCntrlW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharDigitW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharLowerA (CHAR c)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharLowerW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharPunctW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharSpaceA (CHAR c)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharSpaceW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharUpperA (CHAR c)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharUpperW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsCharXDigitW (WCHAR wc)

BOOL WINAPI DECLSPEC_HOTPATCH	IsDBCSLeadByte (BYTE testchar)

BOOL WINAPI DECLSPEC_HOTPATCH	IsDBCSLeadByteEx (UINT codepage, BYTE testchar)

BOOL WINAPI DECLSPEC_HOTPATCH	IsNormalizedString (NORM_FORM form, const WCHAR *str, INT len)

BOOL WINAPI DECLSPEC_HOTPATCH	IsValidCodePage (UINT codepage)

BOOL WINAPI DECLSPEC_HOTPATCH	IsValidLanguageGroup (LGRPID id, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	IsValidLocale (LCID lcid, DWORD flags)

BOOL WINAPI DECLSPEC_HOTPATCH	IsValidLocaleName (const WCHAR *locale)

BOOL WINAPI DECLSPEC_HOTPATCH	IsNLSDefinedString (NLS_FUNCTION func, DWORD flags, NLSVERSIONINFO info, const WCHAR str, int len)

DWORD WINAPI DECLSPEC_HOTPATCH	IsValidNLSVersion (NLS_FUNCTION func, const WCHAR locale, NLSVERSIONINFOEX info)

INT WINAPI DECLSPEC_HOTPATCH	LCIDToLocaleName (LCID lcid, WCHAR *name, INT count, DWORD flags)

INT WINAPI DECLSPEC_HOTPATCH	LCMapStringEx (const WCHAR locale, DWORD flags, const WCHAR src, int srclen, WCHAR dst, int dstlen, NLSVERSIONINFO version, void *reserved, LPARAM handle)

INT WINAPI DECLSPEC_HOTPATCH	LCMapStringA (LCID lcid, DWORD flags, const char src, int srclen, char dst, int dstlen)

INT WINAPI DECLSPEC_HOTPATCH	LCMapStringW (LCID lcid, DWORD flags, const WCHAR src, int srclen, WCHAR dst, int dstlen)

LCID WINAPI DECLSPEC_HOTPATCH	LocaleNameToLCID (const WCHAR *name, DWORD flags)

INT WINAPI DECLSPEC_HOTPATCH	MultiByteToWideChar (UINT codepage, DWORD flags, const char src, INT srclen, WCHAR dst, INT dstlen)

INT WINAPI DECLSPEC_HOTPATCH	NormalizeString (NORM_FORM form, const WCHAR src, INT src_len, WCHAR dst, INT dst_len)

INT WINAPI DECLSPEC_HOTPATCH	ResolveLocaleName (LPCWSTR name, LPWSTR buffer, INT len)

BOOL WINAPI DECLSPEC_HOTPATCH	SetLocaleInfoW (LCID lcid, LCTYPE lctype, const WCHAR *data)

INT WINAPI	SetCalendarInfoW (LCID lcid, CALID calendar, CALTYPE type, const WCHAR *data)

BOOL WINAPI DECLSPEC_HOTPATCH	SetProcessPreferredUILanguages (DWORD flags, PCZZWSTR buffer, ULONG *count)

BOOL WINAPI DECLSPEC_HOTPATCH	SetThreadPreferredUILanguages (DWORD flags, PCZZWSTR buffer, ULONG *count)

BOOL WINAPI DECLSPEC_HOTPATCH	SetTimeZoneInformation (const TIME_ZONE_INFORMATION *info)

BOOL WINAPI DECLSPEC_HOTPATCH	SetUserGeoID (GEOID id)

BOOL WINAPI DECLSPEC_HOTPATCH	SystemTimeToTzSpecificLocalTime (const TIME_ZONE_INFORMATION info, const SYSTEMTIME system, SYSTEMTIME *local)

BOOL WINAPI DECLSPEC_HOTPATCH	TzSpecificLocalTimeToSystemTime (const TIME_ZONE_INFORMATION info, const SYSTEMTIME local, SYSTEMTIME *system)

DWORD WINAPI DECLSPEC_HOTPATCH	VerLanguageNameA (DWORD lang, LPSTR buffer, DWORD size)

DWORD WINAPI DECLSPEC_HOTPATCH	VerLanguageNameW (DWORD lang, LPWSTR buffer, DWORD size)

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

INT WINAPI	GetUserDefaultGeoName (LPWSTR geo_name, int count)

BOOL WINAPI	SetUserGeoName (PWSTR geo_name)

static void	grouping_to_string (UINT grouping, WCHAR *buffer)

static WCHAR *	prepend_str (WCHAR end, const WCHAR str)

static WCHAR *	format_number (WCHAR end, const WCHAR value, const WCHAR decimal_sep, const WCHAR thousand_sep, const WCHAR *grouping, UINT digits, BOOL lzero)

static int	get_number_format (const NLS_LOCALE_DATA locale, DWORD flags, const WCHAR value, const NUMBERFMTW format, WCHAR buffer, int len)

static int	get_currency_format (const NLS_LOCALE_DATA locale, DWORD flags, const WCHAR value, const CURRENCYFMTW format, WCHAR buffer, int len)

static int	get_pattern_len (const WCHAR pattern, const WCHAR accept)

static int	get_date_format (const NLS_LOCALE_DATA locale, DWORD flags, const SYSTEMTIME systime, const WCHAR format, WCHAR buffer, int len)

static int	get_time_format (const NLS_LOCALE_DATA locale, DWORD flags, const SYSTEMTIME systime, const WCHAR format, WCHAR buffer, int len)

int WINAPI	GetNumberFormatW (LCID lcid, DWORD flags, const WCHAR value, const NUMBERFMTW format, WCHAR *buffer, int len)

int WINAPI	GetNumberFormatEx (const WCHAR name, DWORD flags, const WCHAR value, const NUMBERFMTW format, WCHAR buffer, int len)

int WINAPI	GetCurrencyFormatW (LCID lcid, DWORD flags, const WCHAR value, const CURRENCYFMTW format, WCHAR *buffer, int len)

int WINAPI	GetCurrencyFormatEx (const WCHAR name, DWORD flags, const WCHAR value, const CURRENCYFMTW format, WCHAR buffer, int len)

int WINAPI	GetDateFormatA (LCID lcid, DWORD flags, const SYSTEMTIME time, const char format, char *buffer, int len)

int WINAPI	GetDateFormatW (LCID lcid, DWORD flags, const SYSTEMTIME systime, const WCHAR format, WCHAR *buffer, int len)

int WINAPI	GetDateFormatEx (const WCHAR name, DWORD flags, const SYSTEMTIME systime, const WCHAR format, WCHAR buffer, int len, const WCHAR *calendar)

int WINAPI	GetTimeFormatA (LCID lcid, DWORD flags, const SYSTEMTIME time, const char format, char *buffer, int len)

int WINAPI	GetTimeFormatW (LCID lcid, DWORD flags, const SYSTEMTIME systime, const WCHAR format, WCHAR *buffer, int len)

int WINAPI	GetTimeFormatEx (const WCHAR name, DWORD flags, const SYSTEMTIME systime, const WCHAR format, WCHAR buffer, int len)

Variables
static HMODULE	kernelbase_handle

static const WCHAR	world_subkey [] = { 0xd83c, 0xdf0e, 0xd83c, 0xdf0f, 0xd83c, 0xdf0d, 0 }

static struct registry_entry	entry_icalendartype = { L"iCalendarType" }

static struct registry_entry	entry_icountry = { L"iCountry" }

static struct registry_entry	entry_icurrdigits = { L"iCurrDigits" }

static struct registry_entry	entry_icurrency = { L"iCurrency" }

static struct registry_entry	entry_idigits = { L"iDigits" }

static struct registry_entry	entry_idigitsubstitution = { L"NumShape" }

static struct registry_entry	entry_ifirstdayofweek = { L"iFirstDayOfWeek" }

static struct registry_entry	entry_ifirstweekofyear = { L"iFirstWeekOfYear" }

static struct registry_entry	entry_ilzero = { L"iLZero" }

static struct registry_entry	entry_imeasure = { L"iMeasure" }

static struct registry_entry	entry_inegcurr = { L"iNegCurr" }

static struct registry_entry	entry_inegnumber = { L"iNegNumber" }

static struct registry_entry	entry_ipapersize = { L"iPaperSize" }

static struct registry_entry	entry_s1159 = { L"s1159" }

static struct registry_entry	entry_s2359 = { L"s2359" }

static struct registry_entry	entry_scurrency = { L"sCurrency" }

static struct registry_entry	entry_sdecimal = { L"sDecimal" }

static struct registry_entry	entry_sgrouping = { L"sGrouping" }

static struct registry_entry	entry_sintlsymbol = { L"Currencies", world_subkey }

static struct registry_entry	entry_slist = { L"sList" }

static struct registry_entry	entry_slongdate = { L"sLongDate" }

static struct registry_entry	entry_smondecimalsep = { L"sMonDecimalSep" }

static struct registry_entry	entry_smongrouping = { L"sMonGrouping" }

static struct registry_entry	entry_smonthousandsep = { L"sMonThousandSep" }

static struct registry_entry	entry_snativedigits = { L"sNativeDigits" }

static struct registry_entry	entry_snegativesign = { L"sNegativeSign" }

static struct registry_entry	entry_spositivesign = { L"sPositiveSign" }

static struct registry_entry	entry_sshortdate = { L"sShortDate" }

static struct registry_entry	entry_sshorttime = { L"sShortTime" }

static struct registry_entry	entry_sthousand = { L"sThousand" }

static struct registry_entry	entry_stimeformat = { L"sTimeFormat" }

static struct registry_entry	entry_syearmonth = { L"sYearMonth" }

struct {
UINT cp

const WCHAR * name

}	codepage_names []

static const WCHAR	ligatures [][5]

static const struct geo_id *	geo_ids

static const struct geo_index *	geo_index

static unsigned int	geo_ids_count

static unsigned int	geo_index_count

static const USHORT *	charmaps [NB_CHARMAPS]

static CPTABLEINFO	ansi_cpinfo

static CPTABLEINFO	oem_cpinfo

static UINT	unix_cp = CP_UTF8

static LCID	system_lcid

static LCID	user_lcid

static HKEY	intl_key

static HKEY	nls_key

static HKEY	tz_key

static const NLS_LOCALE_LCID_INDEX *	lcids_index

static const NLS_LOCALE_LCNAME_INDEX *	lcnames_index

static const NLS_LOCALE_HEADER *	locale_table

static const WCHAR *	locale_strings

static const NLS_LOCALE_DATA *	system_locale

static const NLS_LOCALE_DATA *	user_locale

static CPTABLEINFO	codepages [128]

static unsigned int	nb_codepages

static struct norm_table *	norm_info

static const struct sortguid **	locale_sorts

static const struct sortguid *	current_locale_sort

struct {
UINT version

UINT guid_count

UINT exp_count

UINT compr_count

const UINT * keys

const USHORT * casemap

const WORD * ctypes

const BYTE * ctype_idx

const struct sortguid * guids

const struct sort_expansion * expansions

const struct sort_compression * compressions

const WCHAR * compr_data

const struct jamo_sort * jamo

}	sort

static CRITICAL_SECTION	locale_section = { &critsect_debug, -1, 0, 0, 0, 0 }

static CRITICAL_SECTION_DEBUG	critsect_debug

static CRITICAL_SECTION	tzname_section = { &tzname_section_debug, -1, 0, 0, 0, 0 }

static CRITICAL_SECTION_DEBUG	tzname_section_debug

struct {
LCID lcid

WCHAR key_name [128]

WCHAR standard_name [32]

WCHAR daylight_name [32]

}	cached_tzname

Macro Definition Documentation

◆ CALINFO_MAX_YEAR

#define CALINFO_MAX_YEAR 2029

Definition at line 45 of file locale.c.

◆ CASE_COMPR_2

#define CASE_COMPR_2 0x40 /* compression exists for >= 2 chars */

Definition at line 377 of file locale.c.

◆ CASE_COMPR_4

#define CASE_COMPR_4 0x80 /* compression exists for >= 4 chars */

Definition at line 378 of file locale.c.

◆ CASE_COMPR_6

#define CASE_COMPR_6 0xc0 /* compression exists for >= 6 chars */

Definition at line 379 of file locale.c.

◆ CASE_FULLSIZE

#define CASE_FULLSIZE 0x02 /* full size kana (vs. small) */

Definition at line 373 of file locale.c.

◆ CASE_FULLWIDTH

#define CASE_FULLWIDTH 0x01 /* full width kana (vs. half width) */

Definition at line 372 of file locale.c.

◆ CASE_KATAKANA

#define CASE_KATAKANA 0x20 /* katakana (vs. hiragana) */

Definition at line 376 of file locale.c.

◆ CASE_SUBSCRIPT

#define CASE_SUBSCRIPT 0x08 /* sub/super script */

Definition at line 374 of file locale.c.

◆ CASE_UPPER

#define CASE_UPPER 0x10 /* upper case */

Definition at line 375 of file locale.c.

◆ ENCODABLE

#define ENCODABLE ( ch ) ((ch) <= 0x7a && directly_encodable[(ch)])

◆ FLAG_DOUBLECOMPRESSION

#define FLAG_DOUBLECOMPRESSION 0x20

Definition at line 338 of file locale.c.

◆ FLAG_HAS_3_BYTE_WEIGHTS

#define FLAG_HAS_3_BYTE_WEIGHTS 0x01

Definition at line 336 of file locale.c.

◆ FLAG_INVERSECASING

#define FLAG_INVERSECASING 0x40

Definition at line 339 of file locale.c.

◆ FLAG_REVERSEDIACRITICS

#define FLAG_REVERSEDIACRITICS 0x10

Definition at line 337 of file locale.c.

◆ HANGUL_LCOUNT

#define HANGUL_LCOUNT 19

Definition at line 3504 of file locale.c.

◆ HANGUL_SBASE

#define HANGUL_SBASE 0xac00

Definition at line 3503 of file locale.c.

◆ HANGUL_TCOUNT

#define HANGUL_TCOUNT 28

Definition at line 3506 of file locale.c.

◆ HANGUL_VCOUNT

#define HANGUL_VCOUNT 21

Definition at line 3505 of file locale.c.

◆ MUI_SIGNATURE

#define MUI_SIGNATURE 0xfecdfecd

Definition at line 5738 of file locale.c.

◆ OUTPUT [1/2]

#define OUTPUT ( ch )

Value:

    do { \
        if (dstlen > 0) \
        { \
            if (pos >= dstlen) goto overflow; \
            dst[pos] = (ch); \
        } \
        pos++; \
    } while(0)

◆ OUTPUT [2/2]

#define OUTPUT ( ch )

Value:

    do { \
        if (dstlen > 0) \
        { \
            if (pos >= dstlen) goto overflow; \
            dst[pos] = (ch); \
        } \
        pos++; \
    } while (0)

◆ UPDATE

#define UPDATE	(	val,
		entry
	)	update_registry_value( LOCALE_NOUSEROVERRIDE \| (val), (entry).subkey, (entry).value )

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 30 of file locale.c.

◆ WINNORMALIZEAPI

#define WINNORMALIZEAPI

Definition at line 31 of file locale.c.

Enumeration Type Documentation

◆ charmaps

enum charmaps

Enumerator
CHARMAP_FOLDDIGITS
CHARMAP_COMPAT
CHARMAP_HIRAGANA
CHARMAP_KATAKANA
CHARMAP_HALFWIDTH
CHARMAP_FULLWIDTH
CHARMAP_TRADITIONAL
CHARMAP_SIMPLIFIED
NB_CHARMAPS

Definition at line 260 of file locale.c.

{
    CHARMAP_FOLDDIGITS,
    CHARMAP_COMPAT,
    CHARMAP_HIRAGANA,
    CHARMAP_KATAKANA,
    CHARMAP_HALFWIDTH,
    CHARMAP_FULLWIDTH,
    CHARMAP_TRADITIONAL,
    CHARMAP_SIMPLIFIED,
    NB_CHARMAPS
};

◆ sortkey_script

enum sortkey_script

Enumerator
SCRIPT_UNSORTABLE
SCRIPT_NONSPACE_MARK
SCRIPT_EXPANSION
SCRIPT_EASTASIA_SPECIAL
SCRIPT_JAMO_SPECIAL
SCRIPT_EXTENSION_A
SCRIPT_PUNCTUATION
SCRIPT_SYMBOL_1
SCRIPT_SYMBOL_2
SCRIPT_SYMBOL_3
SCRIPT_SYMBOL_4
SCRIPT_SYMBOL_5
SCRIPT_SYMBOL_6
SCRIPT_DIGIT
SCRIPT_LATIN
SCRIPT_GREEK
SCRIPT_CYRILLIC
SCRIPT_KANA
SCRIPT_HEBREW
SCRIPT_ARABIC
SCRIPT_PUA_FIRST
SCRIPT_PUA_LAST
SCRIPT_CJK_FIRST
SCRIPT_CJK_LAST

Definition at line 381 of file locale.c.

{
    SCRIPT_UNSORTABLE = 0,
    SCRIPT_NONSPACE_MARK = 1,
    SCRIPT_EXPANSION = 2,
    SCRIPT_EASTASIA_SPECIAL = 3,
    SCRIPT_JAMO_SPECIAL = 4,
    SCRIPT_EXTENSION_A = 5,
    SCRIPT_PUNCTUATION = 6,
    SCRIPT_SYMBOL_1 = 7,
    SCRIPT_SYMBOL_2 = 8,
    SCRIPT_SYMBOL_3 = 9,
    SCRIPT_SYMBOL_4 = 10,
    SCRIPT_SYMBOL_5 = 11,
    SCRIPT_SYMBOL_6 = 12,
    SCRIPT_DIGIT = 13,
    SCRIPT_LATIN = 14,
    SCRIPT_GREEK = 15,
    SCRIPT_CYRILLIC = 16,
    SCRIPT_KANA = 34,
    SCRIPT_HEBREW = 40,
    SCRIPT_ARABIC = 41,
    SCRIPT_PUA_FIRST = 169,
    SCRIPT_PUA_LAST = 175,
    SCRIPT_CJK_FIRST = 192,
    SCRIPT_CJK_LAST = 239,
};

Function Documentation

◆ append_digit_weights()

static int append_digit_weights	(	struct sortkey *	key,
		const WCHAR *	src,
		UINT	srclen
	)

static

Definition at line 3433 of file locale.c.

{
    UINT i, zero, len, lzero;
    BYTE val, values[19];
 
    if (!(zero = get_digit_zero_char( *src ))) return -1;
 
    values[0] = *src - zero;
    for (len = 1; len < ARRAY_SIZE(values) && len < srclen; len++)
    {
        if (src[len] < zero || src[len] > zero + 9) break;
        values[len] = src[len] - zero;
    }
    for (lzero = 0; lzero < len; lzero++) if (values[lzero]) break;
 
    append_sortkey( key, SCRIPT_DIGIT );
    append_sortkey( key, 2 );
    append_sortkey( key, 2 + len - lzero );
    for (i = lzero, val = 2; i < len; i++)
    {
        if ((len - i) % 2) append_sortkey( key, (val << 4) + values[i] + 2 );
        else val = values[i] + 2;
    }
    append_sortkey( key, 0xfe - lzero );
    return len - 1;
}

Referenced by append_weights().

◆ append_expansion_weights()

static void append_expansion_weights	(	const struct sortguid *	sortid,
		struct sortkey *	key_primary,
		struct sortkey *	key_diacritic,
		struct sortkey *	key_case,
		union char_weights	weights,
		DWORD	flags,
		BOOL	is_compare
	)

static

Definition at line 3346 of file locale.c.

{
    /* sortkey and comparison behave differently here */
    if (is_compare)
    {
        if (weights.script == SCRIPT_UNSORTABLE) return;
        if (weights.script == SCRIPT_NONSPACE_MARK)
        {
            append_nonspace_weights( key_diacritic, weights, flags );
            return;
        }
    }
    append_normal_weights( sortid, key_primary, key_diacritic, key_case, weights, flags );
}

Referenced by append_weights().

◆ append_extra_kana_weights()

static int append_extra_kana_weights	(	struct sortkey	keys[4],
		const WCHAR *	src,
		int	pos,
		UINT	except,
		BYTE	case_mask,
		union char_weights *	weights
	)

static

Definition at line 3461 of file locale.c.

{
    BYTE extra1 = 3, case_weight = weights->_case;
 
    if (weights->primary <= 1)
    {
        while (pos > 0)
        {
            union char_weights prev = get_char_weights( src[--pos], except );
            if (prev.script == SCRIPT_UNSORTABLE || prev.script == SCRIPT_NONSPACE_MARK) continue;
            if (prev.script == SCRIPT_EXPANSION) return 0;
            if (prev.script != SCRIPT_EASTASIA_SPECIAL)
            {
                *weights = prev;
                return 1;
            }
            if (prev.primary <= 1) continue;
 
            case_weight = prev._case & case_mask;
            if (weights->primary == 1)  /* prolonged sound mark */
            {
                prev.primary &= 0x87;
                case_weight &= ~CASE_FULLWIDTH;
                case_weight |= weights->_case & CASE_FULLWIDTH;
            }
            extra1 = 4 + weights->primary;
            weights->primary = prev.primary;
            goto done;
        }
        return 0;
    }
done:
    append_sortkey( &keys[0], 0xc4 | (case_weight & CASE_FULLSIZE) );
    append_sortkey( &keys[1], extra1 );
    append_sortkey( &keys[2], 0xc4 | (case_weight & CASE_KATAKANA) );
    append_sortkey( &keys[3], 0xc4 | (case_weight & CASE_FULLWIDTH) );
    weights->script = SCRIPT_KANA;
    return 1;
}

Referenced by append_weights().

◆ append_hangul_weights()

static int append_hangul_weights	(	struct sortkey *	key,
		const WCHAR *	src,
		int	srclen,
		UINT	except
	)

static

Definition at line 3508 of file locale.c.

{
    int leading_idx = 0x115f - 0x1100;  /* leading filler */
    int vowel_idx = 0x1160 - 0x1100;  /* vowel filler */
    int trailing_idx = -1;
    BYTE leading_off, vowel_off, trailing_off;
    union char_weights weights;
    WCHAR composed;
    BYTE filler_mask = 0;
    int pos = 0;
 
    /* leading */
    if (src[pos] >= 0x1100 && src[pos] <= 0x115f) leading_idx = src[pos++] - 0x1100;
    else if (src[pos] >= 0xa960 && src[pos] <= 0xa97c) leading_idx = src[pos++] - (0xa960 - 0x100);
 
    /* vowel */
    if (srclen > pos)
    {
        if (src[pos] >= 0x1160 && src[pos] <= 0x11a7) vowel_idx = src[pos++] - 0x1100;
        else if (src[pos] >= 0xd7b0 && src[pos] <= 0xd7c6) vowel_idx = src[pos++] - (0xd7b0 - 0x11d);
    }
 
    /* trailing */
    if (srclen > pos)
    {
        if (src[pos] >= 0x11a8 && src[pos] <= 0x11ff) trailing_idx = src[pos++] - 0x1100;
        else if (src[pos] >= 0xd7cb && src[pos] <= 0xd7fb) trailing_idx = src[pos++] - (0xd7cb - 0x134);
    }
 
    if (!sort.jamo[leading_idx].is_old && !sort.jamo[vowel_idx].is_old &&
        (trailing_idx == -1 || !sort.jamo[trailing_idx].is_old))
    {
        /* not old Hangul, only use leading char; vowel and trailing will be handled in the next pass */
        pos = 1;
        vowel_idx = 0x1160 - 0x1100;
        trailing_idx = -1;
    }
 
    leading_off = max( sort.jamo[leading_idx].leading, sort.jamo[vowel_idx].leading );
    vowel_off = max( sort.jamo[leading_idx].vowel, sort.jamo[vowel_idx].vowel );
    trailing_off = max( sort.jamo[leading_idx].trailing, sort.jamo[vowel_idx].trailing );
    if (trailing_idx != -1) trailing_off = max( trailing_off, sort.jamo[trailing_idx].trailing );
    composed = HANGUL_SBASE + (leading_off * HANGUL_VCOUNT + vowel_off) * HANGUL_TCOUNT + trailing_off;
 
    if (leading_idx == 0x115f - 0x1100 || vowel_idx == 0x1160 - 0x1100)
    {
        filler_mask = 0x80;
        composed--;
    }
    if (composed < HANGUL_SBASE) composed = 0x3260;
 
    weights = get_char_weights( composed, except );
    append_sortkey( key, weights.script );
    append_sortkey( key, weights.primary );
    append_sortkey( key, 0xff );
    append_sortkey( key, sort.jamo[leading_idx].weight | filler_mask );
    append_sortkey( key, 0xff );
    append_sortkey( key, sort.jamo[vowel_idx].weight );
    append_sortkey( key, 0xff );
    append_sortkey( key, trailing_idx != -1 ? sort.jamo[trailing_idx].weight : 2 );
    return pos - 1;
}

Referenced by append_weights().

◆ append_nonspace_weights()

static void append_nonspace_weights	(	struct sortkey *	key,
		union char_weights	weights,
		DWORD	flags
	)

static

Definition at line 3339 of file locale.c.

{
    if (flags & LINGUISTIC_IGNOREDIACRITIC) weights.diacritic = 2;
    if (key->len) key->buf[key->len - 1] += weights.diacritic;
    else append_sortkey( key, weights.diacritic );
}

Referenced by append_expansion_weights(), and append_weights().

◆ append_normal_weights()

static void append_normal_weights	(	const struct sortguid *	sortid,
		struct sortkey *	key_primary,
		struct sortkey *	key_diacritic,
		struct sortkey *	key_case,
		union char_weights	weights,
		DWORD	flags
	)

static

Definition at line 3315 of file locale.c.

{
    append_sortkey( key_primary, weights.script );
    append_sortkey( key_primary, weights.primary );
 
    if ((weights.script >= SCRIPT_PUA_FIRST && weights.script <= SCRIPT_PUA_LAST) ||
        ((sortid->flags & FLAG_HAS_3_BYTE_WEIGHTS) &&
         (weights.script >= SCRIPT_CJK_FIRST && weights.script <= SCRIPT_CJK_LAST)))
    {
        append_sortkey( key_primary, weights.diacritic );
        append_sortkey( key_case, weights._case );
        return;
    }
    if (weights.script <= SCRIPT_ARABIC && weights.script != SCRIPT_HEBREW)
    {
        if (flags & LINGUISTIC_IGNOREDIACRITIC) weights.diacritic = 2;
        if (flags & LINGUISTIC_IGNORECASE) weights._case = 2;
    }
    append_sortkey( key_diacritic, weights.diacritic );
    append_sortkey( key_case, weights._case );
}

Referenced by append_expansion_weights(), and append_weights().

◆ append_sortkey()

static void append_sortkey	(	struct sortkey *	key,
		BYTE	val
	)

static

Definition at line 3282 of file locale.c.

{
    if (key->len >= key->max) return;
    if (key->len >= key->size)
    {
        key->new_buf = RtlAllocateHeap( GetProcessHeap(), 0, key->max );
        if (key->new_buf) memcpy( key->new_buf, key->buf, key->len );
        else key->max = 0;
        key->buf = key->new_buf;
        key->size = key->max;
    }
    key->buf[key->len++] = val;
}

Referenced by append_digit_weights(), append_extra_kana_weights(), append_hangul_weights(), append_nonspace_weights(), append_normal_weights(), and append_weights().

◆ append_weights()

static int append_weights	(	const struct sortguid *	sortid,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		int	pos,
		BYTE	case_mask,
		UINT	except,
		const WCHAR *	compr_tables[8],
		struct sortkey_state *	s,
		BOOL	is_compare
	)

static

Definition at line 3666 of file locale.c.

{
    union char_weights weights = get_char_weights( src[pos], except );
    WCHAR idx = (weights.val >> 16) & ~(CASE_COMPR_6 << 8);  /* expansion index */
    int ret = 1;
 
    if (weights._case & CASE_COMPR_6)
        ret += get_compression_weights( sortid->compr, compr_tables, src + pos, srclen - pos, &weights );
 
    weights._case &= case_mask;
 
    switch (weights.script)
    {
    case SCRIPT_UNSORTABLE:
        break;
 
    case SCRIPT_NONSPACE_MARK:
        append_nonspace_weights( &s->key_diacritic, weights, flags );
        break;
 
    case SCRIPT_EXPANSION:
        while (weights.script == SCRIPT_EXPANSION)
        {
            weights = get_char_weights( sort.expansions[idx].exp[0], except );
            weights._case &= case_mask;
            append_expansion_weights( sortid, &s->key_primary, &s->key_diacritic,
                                      &s->key_case, weights, flags, is_compare );
            weights = get_char_weights( sort.expansions[idx].exp[1], except );
            idx = weights.val >> 16;
            weights._case &= case_mask;
        }
        append_expansion_weights( sortid, &s->key_primary, &s->key_diacritic,
                                  &s->key_case, weights, flags, is_compare );
        break;
 
    case SCRIPT_EASTASIA_SPECIAL:
        if (!append_extra_kana_weights( s->key_extra, src, pos, except, case_mask, &weights ))
        {
            append_sortkey( &s->key_primary, 0xff );
            append_sortkey( &s->key_primary, 0xff );
            break;
        }
        weights._case = 2;
        append_normal_weights( sortid, &s->key_primary, &s->key_diacritic, &s->key_case, weights, flags );
        break;
 
    case SCRIPT_JAMO_SPECIAL:
        ret += append_hangul_weights( &s->key_primary, src + pos, srclen - pos, except );
        append_sortkey( &s->key_diacritic, 2 );
        append_sortkey( &s->key_case, 2 );
        break;
 
    case SCRIPT_EXTENSION_A:
        append_sortkey( &s->key_primary, 0xfd );
        append_sortkey( &s->key_primary, 0xff );
        append_sortkey( &s->key_primary, weights.primary );
        append_sortkey( &s->key_primary, weights.diacritic );
        append_sortkey( &s->key_diacritic, 2 );
        append_sortkey( &s->key_case, 2 );
        break;
 
    case SCRIPT_PUNCTUATION:
        if (flags & NORM_IGNORESYMBOLS) break;
        if (!(flags & SORT_STRINGSORT))
        {
            short len = -((s->key_primary.len + s->primary_pos) / 2) - 1;
            if (flags & LINGUISTIC_IGNORECASE) weights._case = 2;
            if (flags & LINGUISTIC_IGNOREDIACRITIC) weights.diacritic = 2;
            append_sortkey( &s->key_special, len >> 8 );
            append_sortkey( &s->key_special, len & 0xff );
            append_sortkey( &s->key_special, weights.primary );
            append_sortkey( &s->key_special, weights._case | (weights.diacritic << 3) );
            break;
        }
        /* fall through */
    case SCRIPT_SYMBOL_1:
    case SCRIPT_SYMBOL_2:
    case SCRIPT_SYMBOL_3:
    case SCRIPT_SYMBOL_4:
    case SCRIPT_SYMBOL_5:
    case SCRIPT_SYMBOL_6:
        if (flags & NORM_IGNORESYMBOLS) break;
        append_sortkey( &s->key_primary, weights.script );
        append_sortkey( &s->key_primary, weights.primary );
        append_sortkey( &s->key_diacritic, weights.diacritic );
        append_sortkey( &s->key_case, weights._case );
        break;
 
    case SCRIPT_DIGIT:
        if (flags & SORT_DIGITSASNUMBERS)
        {
            int len = append_digit_weights( &s->key_primary, src + pos, srclen - pos );
            if (len >= 0)
            {
                ret += len;
                append_sortkey( &s->key_diacritic, weights.diacritic );
                append_sortkey( &s->key_case, weights._case );
                break;
            }
        }
        /* fall through */
    default:
        append_normal_weights( sortid, &s->key_primary, &s->key_diacritic, &s->key_case, weights, flags );
        break;
    }
 
    return ret;
}

Referenced by compare_string(), find_substring(), and get_sortkey().

◆ cal_return_number()

static int cal_return_number	(	UINT	val,
		CALTYPE	type,
		WCHAR *	buffer,
		int	len,
		DWORD *	value
	)

static

Definition at line 977 of file locale.c.

{
    WCHAR tmp[12];
    int ret;
 
    if (type & CAL_RETURN_NUMBER)
    {
        *value = val;
        return sizeof(UINT) / sizeof(WCHAR);
    }
    ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%u", val );
    return locale_return_data( tmp, ret + 1, 0, buffer, len );
}

Referenced by get_calendar_info().

◆ call_enum_date_func()

static BOOL call_enum_date_func	(	DATEFMT_ENUMPROCW	proc,
		const NLS_LOCALE_DATA *	locale,
		DWORD	flags,
		DWORD	str,
		WCHAR *	buffer,
		CALID	id,
		BOOL	unicode,
		BOOL	ex,
		BOOL	exex,
		LPARAM	lparam
	)

static

Definition at line 4379 of file locale.c.

{
    char buffA[256];
 
    if (str) memcpy( buffer, locale_strings + str + 1, (locale_strings[str] + 1) * sizeof(WCHAR) );
    if (exex) return ((DATEFMT_ENUMPROCEXEX)proc)( buffer, id, lparam );
    if (ex) return ((DATEFMT_ENUMPROCEXW)proc)( buffer, id );
    if (unicode) return proc( buffer );
    WideCharToMultiByte( get_locale_codepage( locale, flags ), 0, buffer, -1,
                         buffA, ARRAY_SIZE(buffA), NULL, NULL );
    return proc( (WCHAR *)buffA );
}

Referenced by Internal_EnumDateFormats().

◆ casemap()

static WCHAR casemap	(	const USHORT *	table,
		WCHAR	ch
	)

inlinestatic

Definition at line 2000 of file locale.c.

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

◆ casemap_high()

static unsigned int casemap_high	(	const USHORT *	table,
		WCHAR	high,
		WCHAR	low
	)

inlinestatic

Definition at line 2006 of file locale.c.

{
    unsigned int off = table[table[256 + (high - 0xd800)] + ((low >> 5) & 0x1f)] + 2 * (low & 0x1f);
    return 0x10000 + ((high - 0xd800) << 10) + (low - 0xdc00) + MAKELONG( table[off], table[off+1] );
}

Referenced by casemap_string(), and map_to_fullwidth().

◆ casemap_string()

static int casemap_string	(	const USHORT *	table,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2050 of file locale.c.

{
    if (table_has_high_planes( table ))
    {
        unsigned int ch;
        int pos = 0;
 
        while (srclen)
        {
            if (srclen > 1 && IS_SURROGATE_PAIR( src[0], src[1] ))
            {
                ch = casemap_high( table, src[0], src[1] );
                src += 2;
                srclen -= 2;
            }
            else
            {
                ch = casemap( table, *src );
                src++;
                srclen--;
            }
            pos += put_utf16( dst, pos, dstlen, ch );
        }
        return pos;
    }
    else
    {
        int pos, ret = srclen;
 
        for (pos = 0; pos < dstlen && srclen; pos++, src++, srclen--)
            dst[pos] = casemap( table, *src );
        return ret;
    }
}

Referenced by fold_digits(), and lcmap_string().

◆ check_invalid_chars()

static int check_invalid_chars	(	const CPTABLEINFO *	info,
		const unsigned char *	src,
		int	srclen
	)

static

Definition at line 2515 of file locale.c.

{
    if (info->DBCSOffsets)
    {
        for ( ; srclen; src++, srclen-- )
        {
            USHORT off = info->DBCSOffsets[*src];
            if (off)
            {
                if (srclen == 1) break;  /* partial char, error */
                if (info->DBCSOffsets[off + src[1]] == info->UniDefaultChar &&
                    ((src[0] << 8) | src[1]) != info->TransUniDefaultChar) break;
                src++;
                srclen--;
                continue;
            }
            if (info->MultiByteTable[*src] == info->UniDefaultChar && *src != info->TransUniDefaultChar)
                break;
            if (is_private_use_area_char( info->MultiByteTable[*src] )) break;
        }
    }
    else
    {
        for ( ; srclen; src++, srclen-- )
        {
            if (info->MultiByteTable[*src] == info->UniDefaultChar && *src != info->TransUniDefaultChar)
                break;
            if (is_private_use_area_char( info->MultiByteTable[*src] )) break;
        }
    }
    return !!srclen;
 
}

Referenced by mbstowcs_codepage().

◆ compare_locale_names()

static int compare_locale_names	(	const WCHAR *	n1,
		const WCHAR *	n2
	)

static

Definition at line 566 of file locale.c.

{
    for (;;)
    {
        WCHAR ch1 = *n1++;
        WCHAR ch2 = *n2++;
        if (ch1 >= 'a' && ch1 <= 'z') ch1 -= 'a' - 'A';
        else if (ch1 == '_') ch1 = '-';
        if (ch2 >= 'a' && ch2 <= 'z') ch2 -= 'a' - 'A';
        else if (ch2 == '_') ch2 = '-';
        if (!ch1 || ch1 != ch2) return ch1 - ch2;
    }
}

Referenced by find_lcname_entry(), get_language_sort(), and get_locale_by_name().

◆ compare_sortkeys()

static int compare_sortkeys	(	const struct sortkey *	key1,
		const struct sortkey *	key2,
		BOOL	shorter_wins
	)

static

Definition at line 3308 of file locale.c.

{
    int ret = memcmp( key1->buf, key2->buf, min( key1->len, key2->len ));
    if (!ret) ret = shorter_wins ? key2->len - key1->len : key1->len - key2->len;
    return ret;
}

Referenced by compare_string(), and find_substring().

◆ compare_string()

static int compare_string	(	const struct sortguid *	sortid,
		DWORD	flags,
		const WCHAR *	src1,
		int	srclen1,
		const WCHAR *	src2,
		int	srclen2
	)

static

Definition at line 3832 of file locale.c.

{
    struct sortkey_state s1;
    struct sortkey_state s2;
    BYTE primary1[32];
    BYTE primary2[32];
    int i, ret, len, pos1 = 0, pos2 = 0;
    BOOL have_extra1, have_extra2;
    BYTE case_mask = 0x3f;
    UINT except = sortid->except;
    const WCHAR *compr_tables[8];
 
    compr_tables[0] = NULL;
    if (flags & NORM_IGNORECASE) case_mask &= ~(CASE_UPPER | CASE_SUBSCRIPT);
    if (flags & NORM_IGNOREWIDTH) case_mask &= ~CASE_FULLWIDTH;
    if (flags & NORM_IGNOREKANATYPE) case_mask &= ~CASE_KATAKANA;
    if ((flags & NORM_LINGUISTIC_CASING) && except && sortid->ling_except) except = sortid->ling_except;
 
    init_sortkey_state( &s1, flags, srclen1, primary1, sizeof(primary1) );
    init_sortkey_state( &s2, flags, srclen2, primary2, sizeof(primary2) );
 
    while (pos1 < srclen1 || pos2 < srclen2)
    {
        while (pos1 < srclen1 && !s1.key_primary.len)
            pos1 += append_weights( sortid, flags, src1, srclen1, pos1,
                                    case_mask, except, compr_tables, &s1, TRUE );
 
        while (pos2 < srclen2 && !s2.key_primary.len)
            pos2 += append_weights( sortid, flags, src2, srclen2, pos2,
                                    case_mask, except, compr_tables, &s2, TRUE );
 
        if (!(len = min( s1.key_primary.len, s2.key_primary.len ))) break;
        if ((ret = memcmp( primary1, primary2, len ))) goto done;
        memmove( primary1, primary1 + len, s1.key_primary.len - len );
        memmove( primary2, primary2 + len, s2.key_primary.len - len );
        s1.key_primary.len -= len;
        s2.key_primary.len -= len;
        s1.primary_pos += len;
        s2.primary_pos += len;
    }
 
    if ((ret = s1.key_primary.len - s2.key_primary.len)) goto done;
 
    have_extra1 = remove_unneeded_weights( sortid, &s1 );
    have_extra2 = remove_unneeded_weights( sortid, &s2 );
 
    if ((ret = compare_sortkeys( &s1.key_diacritic, &s2.key_diacritic, FALSE ))) goto done;
    if ((ret = compare_sortkeys( &s1.key_case, &s2.key_case, FALSE ))) goto done;
 
    if (have_extra1 && have_extra2)
    {
        for (i = 0; i < 4; i++)
            if ((ret = compare_sortkeys( &s1.key_extra[i], &s2.key_extra[i], i != 1 ))) goto done;
    }
    else if ((ret = have_extra1 - have_extra2)) goto done;
 
    ret = compare_sortkeys( &s1.key_special, &s2.key_special, FALSE );
 
done:
    free_sortkey_state( &s1 );
    free_sortkey_state( &s2 );
    return ret;
}

Referenced by CompareStringEx().

◆ compare_tzdate()

static int compare_tzdate	(	const TIME_FIELDS *	tf,
		const SYSTEMTIME *	compare
	)

static

Definition at line 4226 of file locale.c.

{
    static const int month_lengths[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    int first, last, limit, dayinsecs;
 
    if (tf->Month < compare->wMonth) return -1; /* We are in a month before the date limit. */
    if (tf->Month > compare->wMonth) return 1; /* We are in a month after the date limit. */
 
    /* if year is 0 then date is in day-of-week format, otherwise
     * it's absolute date.
     */
    if (!compare->wYear)
    {
        /* wDay is interpreted as number of the week in the month
         * 5 means: the last week in the month */
        /* calculate the day of the first DayOfWeek in the month */
        first = (6 + compare->wDayOfWeek - tf->Weekday + tf->Day) % 7 + 1;
        /* check needed for the 5th weekday of the month */
        last = month_lengths[tf->Month - 1] +
            (tf->Month == 2 && (!(tf->Year % 4) && (tf->Year % 100 || !(tf->Year % 400))));
        limit = first + 7 * (compare->wDay - 1);
        if (limit > last) limit -= 7;
    }
    else limit = compare->wDay;
 
    limit = ((limit * 24 + compare->wHour) * 60 + compare->wMinute) * 60;
    dayinsecs = ((tf->Day * 24  + tf->Hour) * 60 + tf->Minute) * 60 + tf->Second;
    return dayinsecs - limit;
}

Referenced by get_timezone_id().

◆ CompareStringA()

INT WINAPI DECLSPEC_HOTPATCH CompareStringA	(	LCID	lcid,
		DWORD	flags,
		const char *	str1,
		int	len1,
		const char *	str2,
		int	len2
	)

Definition at line 4773 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 (flags & SORT_DIGITSASNUMBERS)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (len1 < 0) len1 = strlen(str1);
    if (len2 < 0) len2 = strlen(str2);
 
    locale_cp = get_lcid_codepage( lcid, flags );
    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 = CompareStringW( lcid, flags, str1W, len1W, str2W, len2W );
 
    if (str1W != buf1W) HeapFree( GetProcessHeap(), 0, str1W );
    if (str2W != buf2W) HeapFree( GetProcessHeap(), 0, str2W );
    return ret;
}

◆ CompareStringEx()

INT WINAPI CompareStringEx	(	const WCHAR *	locale,
		DWORD	flags,
		const WCHAR *	str1,
		int	len1,
		const WCHAR *	str2,
		int	len2,
		NLSVERSIONINFO *	version,
		void *	reserved,
		LPARAM	handle
	)

Definition at line 4729 of file locale.c.

{
    const struct sortguid *sortid;
    const DWORD supported_flags = NORM_IGNORECASE | NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS |
                                  SORT_STRINGSORT | NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH |
                                  NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE |
                                  LINGUISTIC_IGNOREDIACRITIC | SORT_DIGITSASNUMBERS |
                                  0x10000000 | LOCALE_USE_CP_ACP;
    /* 0x10000000 is related to diacritics in Arabic, Japanese, and Hebrew */
    int ret;
 
    if (version) FIXME( "unexpected version parameter\n" );
    if (reserved) FIXME( "unexpected reserved value\n" );
    if (handle) FIXME( "unexpected handle\n" );
 
    if (flags & ~supported_flags)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (!(sortid = get_language_sort( locale ))) return 0;
 
    if (!str1 || !str2)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (len1 < 0) len1 = lstrlenW(str1);
    if (len2 < 0) len2 = lstrlenW(str2);
 
    ret = compare_string( sortid, flags, str1, len1, str2, len2 );
    if (ret < 0) return CSTR_LESS_THAN;
    if (ret > 0) return CSTR_GREATER_THAN;
    return CSTR_EQUAL;
}

◆ CompareStringOrdinal()

INT WINAPI DECLSPEC_HOTPATCH CompareStringOrdinal	(	const WCHAR *	str1,
		INT	len1,
		const WCHAR *	str2,
		INT	len2,
		BOOL	ignore_case
	)

Definition at line 4888 of file locale.c.

{
    int ret;
 
    if (!str1 || !str2)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (len1 < 0) len1 = lstrlenW( str1 );
    if (len2 < 0) len2 = lstrlenW( str2 );
 
    ret = RtlCompareUnicodeStrings( str1, len1, str2, len2, ignore_case );
    if (ret < 0) return CSTR_LESS_THAN;
    if (ret > 0) return CSTR_GREATER_THAN;
    return CSTR_EQUAL;
}

Referenced by FindStringOrdinal(), and InitFunctionPointers().

◆ CompareStringW()

INT WINAPI DECLSPEC_HOTPATCH CompareStringW	(	LCID	lcid,
		DWORD	flags,
		const WCHAR *	str1,
		int	len1,
		const WCHAR *	str2,
		int	len2
	)

Definition at line 4854 of file locale.c.

{
    const WCHAR *locale = LOCALE_NAME_USER_DEFAULT;
    const NLS_LOCALE_LCID_INDEX *entry;
 
    switch (lcid)
    {
    case LOCALE_NEUTRAL:
    case LOCALE_USER_DEFAULT:
    case LOCALE_SYSTEM_DEFAULT:
    case LOCALE_CUSTOM_DEFAULT:
    case LOCALE_CUSTOM_UNSPECIFIED:
    case LOCALE_CUSTOM_UI_DEFAULT:
        break;
    default:
        if (lcid == user_lcid || lcid == system_lcid) break;
        if (!(entry = find_lcid_entry( lcid )))
        {
            WARN( "unknown locale %04lx\n", lcid );
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        locale = locale_strings + entry->name + 1;
        break;
    }
 
    return CompareStringEx( locale, flags, str1, len1, str2, len2, NULL, NULL, 0 );
}

◆ compose_chars()

static WCHAR compose_chars	(	WCHAR	ch1,
		WCHAR	ch2
	)

static

Definition at line 2154 of file locale.c.

{
    const USHORT *table = (const USHORT *)norm_info + norm_info->comp_hash;
    const WCHAR *chars = (const USHORT *)norm_info + norm_info->comp_seq;
    unsigned int hash, start, end, i;
    WCHAR ch[3];
 
    hash = (ch1 + 95 * ch2) % norm_info->comp_size;
    start = table[hash];
    end = table[hash + 1];
    while (start < end)
    {
        for (i = 0; i < 3; i++, start++)
        {
            ch[i] = chars[start];
            if (IS_HIGH_SURROGATE( ch[i] )) start++;
        }
        if (ch[0] == ch1 && ch[1] == ch2) return ch[2];
    }
    return 0;
}

Referenced by wcstombs_dbcs_slow(), and wcstombs_sbcs_slow().

◆ compression_size()

static int compression_size ( int len )

inlinestatic

Definition at line 363 of file locale.c.

363{ return 2 + len + (len & 1); }

Referenced by find_compression(), and get_compression_weights().

◆ ConvertDefaultLocale()

LCID WINAPI DECLSPEC_HOTPATCH ConvertDefaultLocale ( LCID lcid )

Definition at line 4911 of file locale.c.

{
    const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, 0 );
    if (locale) lcid = locale->ilanguage;
    return lcid;
}

◆ EnumCalendarInfoExEx()

BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoExEx	(	CALINFO_ENUMPROCEXEX	proc,
		LPCWSTR	locale,
		CALID	id,
		LPCWSTR	reserved,
		CALTYPE	type,
		LPARAM	lparam
	)

Definition at line 4943 of file locale.c.

{
    LCID lcid;
    return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, get_locale_by_name( locale, &lcid ),
                                      id, type, TRUE, TRUE, TRUE, lparam );
}

◆ EnumCalendarInfoExW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoExW	(	CALINFO_ENUMPROCEXW	proc,
		LCID	lcid,
		CALID	id,
		CALTYPE	type
	)

Definition at line 4933 of file locale.c.

{
    return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, NlsValidateLocale( &lcid, 0 ),
                                      id, type, TRUE, TRUE, FALSE, 0 );
}

Referenced by test_EnumCalendarInfoExW().

◆ EnumCalendarInfoW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoW	(	CALINFO_ENUMPROCW	proc,
		LCID	lcid,
		CALID	id,
		CALTYPE	type
	)

Definition at line 4922 of file locale.c.

{
    return Internal_EnumCalendarInfo( proc, NlsValidateLocale( &lcid, 0 ),
                                      id, type, TRUE, FALSE, FALSE, 0 );
}

Referenced by test_EnumCalendarInfoW().

◆ EnumDateFormatsExEx()

BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsExEx	(	DATEFMT_ENUMPROCEXEX	proc,
		const WCHAR *	locale,
		DWORD	flags,
		LPARAM	lparam
	)

Definition at line 4975 of file locale.c.

{
    LCID lcid;
    return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, get_locale_by_name( locale, &lcid ),
                                     flags, TRUE, TRUE, TRUE, lparam );
}

Referenced by test_EnumDateFormatsExEx().

◆ EnumDateFormatsExW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsExW	(	DATEFMT_ENUMPROCEXW	proc,
		LCID	lcid,
		DWORD	flags
	)

Definition at line 4965 of file locale.c.

{
    return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, NlsValidateLocale( &lcid, 0 ),
                                     flags, TRUE, TRUE, FALSE, 0 );
}

◆ EnumDateFormatsW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsW	(	DATEFMT_ENUMPROCW	proc,
		LCID	lcid,
		DWORD	flags
	)

Definition at line 4955 of file locale.c.

{
    return Internal_EnumDateFormats( proc, NlsValidateLocale( &lcid, 0 ),
                                     flags, TRUE, FALSE, FALSE, 0 );
}

◆ EnumDynamicTimeZoneInformation()

DWORD WINAPI DECLSPEC_HOTPATCH EnumDynamicTimeZoneInformation	(	DWORD	index,
		DYNAMIC_TIME_ZONE_INFORMATION *	info
	)

Definition at line 4988 of file locale.c.

{
    DYNAMIC_TIME_ZONE_INFORMATION tz;
    LSTATUS ret;
    DWORD size;
 
    if (!info) return ERROR_INVALID_PARAMETER;
 
    size = ARRAY_SIZE(tz.TimeZoneKeyName);
    ret = RegEnumKeyExW( tz_key, index, tz.TimeZoneKeyName, &size, NULL, NULL, NULL, NULL );
    if (ret) return ret;
 
    tz.DynamicDaylightTimeDisabled = TRUE;
    if (!GetTimeZoneInformationForYear( 0, &tz, (TIME_ZONE_INFORMATION *)info )) return GetLastError();
 
    lstrcpyW( info->TimeZoneKeyName, tz.TimeZoneKeyName );
    info->DynamicDaylightTimeDisabled = FALSE;
    return 0;
}

Referenced by InitFunctionPtrs().

◆ EnumLanguageGroupLocalesW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumLanguageGroupLocalesW	(	LANGGROUPLOCALE_ENUMPROCW	proc,
		LGRPID	id,
		DWORD	flags,
		LONG_PTR	param
	)

Definition at line 5013 of file locale.c.

{
    return Internal_EnumLanguageGroupLocales( proc, id, flags, param, TRUE );
}

◆ EnumSystemCodePagesW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemCodePagesW	(	CODEPAGE_ENUMPROCW	proc,
		DWORD	flags
	)

Definition at line 5032 of file locale.c.

{
    return Internal_EnumSystemCodePages( proc, flags, TRUE );
}

◆ EnumSystemGeoID()

BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemGeoID	(	GEOCLASS	class,
		GEOID	parent,
		GEO_ENUMPROC	proc
	)

Definition at line 5041 of file locale.c.

{
    INT i;
 
    TRACE( "(%ld, %ld, %p)\n", class, parent, proc );
 
    if (!proc)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (class != GEOCLASS_NATION && class != GEOCLASS_REGION && class != GEOCLASS_ALL)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return FALSE;
    }
 
    for (i = 0; i < geo_ids_count; i++)
    {
        if (class != GEOCLASS_ALL && geo_ids[i].class != class) continue;
        if (parent && geo_ids[i].parent != parent) continue;
        if (!proc( geo_ids[i].id )) break;
    }
    return TRUE;
}

◆ EnumSystemLanguageGroupsW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLanguageGroupsW	(	LANGUAGEGROUP_ENUMPROCW	proc,
		DWORD	flags,
		LONG_PTR	param
	)

Definition at line 5071 of file locale.c.

{
    return Internal_EnumSystemLanguageGroups( proc, flags, param, TRUE );
}

◆ EnumSystemLocalesA()

BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesA	(	LOCALE_ENUMPROCA	proc,
		DWORD	flags
	)

Definition at line 5081 of file locale.c.

{
    char name[10];
    DWORD i;
 
    if (!flags)
        flags = LCID_SUPPORTED;
 
    for (i = 0; i < locale_table->nb_lcnames; i++)
    {
        if (!lcnames_index[i].name) continue;  /* skip invariant locale */
        if (lcnames_index[i].id == LOCALE_CUSTOM_UNSPECIFIED) continue;  /* skip locales with no lcid */
        if (lcnames_index[i].id & 0x80000000) continue;  /* skip aliases */
        if (!get_locale_data( lcnames_index[i].idx )->inotneutral) continue;  /* skip neutral locales */
        if (SORTIDFROMLCID( lcnames_index[i].id ) != SORT_DEFAULT && !(flags & LCID_ALTERNATE_SORTS))
            continue; /* skip alternate sorts if not requested */
        if (SORTIDFROMLCID( lcnames_index[i].id ) == SORT_DEFAULT && !(flags & (LCID_INSTALLED | LCID_SUPPORTED)))
            continue;  /* skip default sorts if not requested */
        sprintf( name, "%08x", lcnames_index[i].id );
        if (!proc( name )) break;
    }
    return TRUE;
}

◆ EnumSystemLocalesEx()

BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesEx	(	LOCALE_ENUMPROCEX	proc,
		DWORD	wanted_flags,
		LPARAM	param,
		void *	reserved
	)

Definition at line 5137 of file locale.c.

{
    WCHAR buffer[LOCALE_NAME_MAX_LENGTH];
    DWORD i, flags;
 
    if (reserved)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    for (i = 0; i < locale_table->nb_lcnames; i++)
    {
        const NLS_LOCALE_DATA *locale = get_locale_data( lcnames_index[i].idx );
        const WCHAR *str = locale_strings + lcnames_index[i].name;
 
        if (lcnames_index[i].id & 0x80000000) continue;  /* skip aliases */
        memcpy( buffer, str + 1, (*str + 1) * sizeof(WCHAR) );
        if (SORTIDFROMLCID( lcnames_index[i].id ) || wcschr( str + 1, '_' ))
            flags = LOCALE_ALTERNATE_SORTS;
        else
            flags = LOCALE_WINDOWS | (locale->inotneutral ? LOCALE_SPECIFICDATA : LOCALE_NEUTRALDATA);
        if (wanted_flags && !(flags & wanted_flags)) continue;
        if (!proc( buffer, flags, param )) break;
    }
    return TRUE;
}

◆ EnumSystemLocalesW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesW	(	LOCALE_ENUMPROCW	proc,
		DWORD	flags
	)

Definition at line 5109 of file locale.c.

{
    WCHAR name[10];
    DWORD i;
 
    if (!flags)
        flags = LCID_SUPPORTED;
 
    for (i = 0; i < locale_table->nb_lcnames; i++)
    {
        if (!lcnames_index[i].name) continue;  /* skip invariant locale */
        if (lcnames_index[i].id == LOCALE_CUSTOM_UNSPECIFIED) continue;  /* skip locales with no lcid */
        if (lcnames_index[i].id & 0x80000000) continue;  /* skip aliases */
        if (!get_locale_data( lcnames_index[i].idx )->inotneutral) continue;  /* skip neutral locales */
        if (SORTIDFROMLCID( lcnames_index[i].id ) != SORT_DEFAULT && !(flags & LCID_ALTERNATE_SORTS))
            continue; /* skip alternate sorts if not requested */
        if (SORTIDFROMLCID( lcnames_index[i].id ) == SORT_DEFAULT && !(flags & (LCID_INSTALLED | LCID_SUPPORTED)))
            continue;  /* skip default sorts if not requested */
        swprintf( name, ARRAY_SIZE(name), L"%08lx", lcnames_index[i].id );
        if (!proc( name )) break;
    }
    return TRUE;
}

◆ EnumTimeFormatsEx()

BOOL WINAPI DECLSPEC_HOTPATCH EnumTimeFormatsEx	(	TIMEFMT_ENUMPROCEX	proc,
		const WCHAR *	locale,
		DWORD	flags,
		LPARAM	lparam
	)

Definition at line 5179 of file locale.c.

{
    LCID lcid;
    return Internal_EnumTimeFormats( (TIMEFMT_ENUMPROCW)proc, get_locale_by_name( locale, &lcid ),
                                     flags, TRUE, TRUE, lparam );
}

◆ EnumTimeFormatsW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumTimeFormatsW	(	TIMEFMT_ENUMPROCW	proc,
		LCID	lcid,
		DWORD	flags
	)

Definition at line 5170 of file locale.c.

{
    return Internal_EnumTimeFormats( proc, NlsValidateLocale( &lcid, 0 ), flags, TRUE, FALSE, 0 );
}

Referenced by test_EnumTimeFormatsW().

◆ EnumUILanguagesW()

BOOL WINAPI DECLSPEC_HOTPATCH EnumUILanguagesW	(	UILANGUAGE_ENUMPROCW	proc,
		DWORD	flags,
		LONG_PTR	param
	)

Definition at line 5023 of file locale.c.

{
    return Internal_EnumUILanguages( proc, flags, param, TRUE );
}

◆ expand_ligatures()

static NTSTATUS expand_ligatures	(	const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int *	dstlen
	)

static

Definition at line 2262 of file locale.c.

{
    int i, len, pos = 0;
    NTSTATUS ret = STATUS_SUCCESS;
    const WCHAR *expand;
 
    for (i = 0; i < srclen; i++)
    {
        if (!(expand = get_ligature( src[i] )))
        {
            expand = src + i;
            len = 1;
        }
        else len = lstrlenW( expand );
 
        if (*dstlen && ret == STATUS_SUCCESS)
        {
            if (pos + len <= *dstlen) memcpy( dst + pos, expand, len * sizeof(WCHAR) );
            else ret = STATUS_BUFFER_TOO_SMALL;
        }
        pos += len;
    }
    *dstlen = pos;
    return ret;
}

Referenced by fold_string().

◆ find_compression()

static const UINT * find_compression	(	const WCHAR *	src,
		const WCHAR *	table,
		int	count,
		int	len
	)

static

Definition at line 3363 of file locale.c.

{
    int elem_size = compression_size( len ), min = 0, max = count - 1;
 
    while (min <= max)
    {
        int pos = (min + max) / 2;
        int res = wcsncmp( src, table + pos * elem_size, len );
        if (!res) return (UINT *)(table + (pos + 1) * elem_size) - 1;
        if (res > 0) min = pos + 1;
        else max = pos - 1;
    }
    return NULL;
}

Referenced by get_compression_weights().

◆ find_format()

static WCHAR * find_format	(	WCHAR *	str,
		const WCHAR *	accept
	)

static

Definition at line 993 of file locale.c.

{
    for ( ; *str; str++)
    {
        if (*str == '\'')
        {
            if (!(str = wcschr( str + 1, '\'' ))) return NULL;
        }
        else if (wcschr( accept, *str ))
        {
            /* ignore "ddd" and "dddd" */
            if (str[0] != 'd' || str[1] != 'd' || str[2] != 'd') return str;
            str += 2;
            while (str[1] == 'd') str++;
        }
    }
    return NULL;
}

Referenced by get_locale_info(), locale_replace_separator(), and SetLocaleInfoW().

◆ find_geo_id_entry()

static const struct geo_id * find_geo_id_entry ( GEOID id )

static

Definition at line 613 of file locale.c.

{
    int min = 0, max = geo_ids_count - 1;
 
    while (min <= max)
    {
        int pos = (min + max) / 2;
        if (id < geo_ids[pos].id) max = pos - 1;
        else if (id > geo_ids[pos].id) min = pos + 1;
        else return &geo_ids[pos];
    }
    return NULL;
}

Referenced by GetGeoInfoW(), GetUserDefaultGeoName(), and SetUserGeoID().

◆ find_geo_name_entry()

static const struct geo_id * find_geo_name_entry ( const WCHAR * name )

static

Definition at line 628 of file locale.c.

{
    int min = 0, max = geo_index_count - 1;
 
    while (min <= max)
    {
        int res, pos = (min + max) / 2;
        res = wcsicmp( name, geo_index[pos].name );
        if (res < 0) max = pos - 1;
        else if (res > 0) min = pos + 1;
        else return &geo_ids[geo_index[pos].idx];
    }
    return NULL;
}

Referenced by GetGeoInfoEx(), and SetUserGeoName().

◆ find_lcid_entry()

static const NLS_LOCALE_LCID_INDEX * find_lcid_entry ( LCID lcid )

static

Definition at line 598 of file locale.c.

{
    int min = 0, max = locale_table->nb_lcids - 1;
 
    while (min <= max)
    {
        int pos = (min + max) / 2;
        if (lcid < lcids_index[pos].id) max = pos - 1;
        else if (lcid > lcids_index[pos].id) min = pos + 1;
        else return &lcids_index[pos];
    }
    return NULL;
}

Referenced by CompareStringW(), FindNLSString(), get_locale_info(), LCMapStringW(), and NlsValidateLocale().

◆ find_lcname_entry()

static const NLS_LOCALE_LCNAME_INDEX * find_lcname_entry ( const WCHAR * name )

static

Definition at line 581 of file locale.c.

{
    int min = 0, max = locale_table->nb_lcnames - 1;
 
    while (min <= max)
    {
        int res, pos = (min + max) / 2;
        const WCHAR *str = locale_strings + lcnames_index[pos].name;
        res = compare_locale_names( name, str + 1 );
        if (res < 0) max = pos - 1;
        else if (res > 0) min = pos + 1;
        else return &lcnames_index[pos];
    }
    return NULL;
}

Referenced by get_language_sort(), get_locale_by_name(), IsValidLocaleName(), and NlsValidateLocale().

◆ find_sortguid()

static const struct sortguid * find_sortguid ( const GUID * guid )

static

Definition at line 531 of file locale.c.

{
    int pos, ret, min = 0, max = sort.guid_count - 1;
 
    while (min <= max)
    {
        pos = (min + max) / 2;
        ret = memcmp( guid, &sort.guids[pos].id, sizeof(*guid) );
        if (!ret) return &sort.guids[pos];
        if (ret > 0) min = pos + 1;
        else max = pos - 1;
    }
    ERR( "no sort found for %s\n", debugstr_guid( guid ));
    return NULL;
}

Referenced by get_language_sort(), and IsValidNLSVersion().

◆ find_substring()

static int find_substring	(	const struct sortguid *	sortid,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		const WCHAR *	value,
		int	valuelen,
		int *	reslen
	)

static

Definition at line 3899 of file locale.c.

{
    struct sortkey_state s;
    struct sortkey_state val;
    BYTE primary[32];
    BYTE primary_val[256];
    int i, start, len, found = -1, foundlen = 0, pos = 0;
    BOOL have_extra, have_extra_val;
    BYTE case_mask = 0x3f;
    UINT except = sortid->except;
    const WCHAR *compr_tables[8];
 
    compr_tables[0] = NULL;
    if (flags & NORM_IGNORECASE) case_mask &= ~(CASE_UPPER | CASE_SUBSCRIPT);
    if (flags & NORM_IGNOREWIDTH) case_mask &= ~CASE_FULLWIDTH;
    if (flags & NORM_IGNOREKANATYPE) case_mask &= ~CASE_KATAKANA;
    if ((flags & NORM_LINGUISTIC_CASING) && except && sortid->ling_except) except = sortid->ling_except;
 
    init_sortkey_state( &s, flags, srclen, primary, sizeof(primary) );
 
    /* build the value sortkey just once */
    init_sortkey_state( &val, flags, valuelen, primary_val, sizeof(primary_val) );
    while (pos < valuelen)
        pos += append_weights( sortid, flags, value, valuelen, pos,
                               case_mask, except, compr_tables, &val, TRUE );
    have_extra_val = remove_unneeded_weights( sortid, &val );
 
    for (start = 0; start < srclen; start++)
    {
        pos = start;
        for (len = start + 1; len <= srclen; len++)
        {
            while (pos < len && s.primary_pos <= val.key_primary.len)
            {
                while (pos < len && !s.key_primary.len)
                    pos += append_weights( sortid, flags, src, srclen, pos,
                                           case_mask, except, compr_tables, &s, TRUE );
 
                if (s.primary_pos + s.key_primary.len > val.key_primary.len ||
                    memcmp( primary, val.key_primary.buf + s.primary_pos, s.key_primary.len ))
                {
                    len = srclen + 1;
                    goto next;
                }
                s.primary_pos += s.key_primary.len;
                s.key_primary.len = 0;
            }
            if (s.primary_pos < val.key_primary.len) continue;
 
            have_extra = remove_unneeded_weights( sortid, &s );
            if (compare_sortkeys( &s.key_diacritic, &val.key_diacritic, FALSE )) goto next;
            if (compare_sortkeys( &s.key_case, &val.key_case, FALSE )) goto next;
 
            if (have_extra && have_extra_val)
            {
                for (i = 0; i < 4; i++)
                    if (compare_sortkeys( &s.key_extra[i], &val.key_extra[i], i != 1 )) goto next;
            }
            else if (have_extra || have_extra_val) goto next;
 
            if (compare_sortkeys( &s.key_special, &val.key_special, FALSE )) goto next;
 
            found = start;
            foundlen = pos - start;
            len = srclen;  /* no need to continue checking longer strings */
 
        next:
            /* reset state */
            s.key_primary.len = s.key_diacritic.len = s.key_case.len = s.key_special.len = 0;
            s.key_extra[0].len = s.key_extra[1].len = s.key_extra[2].len = s.key_extra[3].len = 0;
            s.primary_pos = 0;
            pos = start;
        }
        if (flags & FIND_STARTSWITH) break;
        if (flags & FIND_FROMSTART && found != -1) break;
    }
 
    if (found != -1)
    {
        if ((flags & FIND_ENDSWITH) && found + foundlen != srclen) found = -1;
        else if (reslen) *reslen = foundlen;
    }
    free_sortkey_state( &s );
    free_sortkey_state( &val );
    return found;
}

Referenced by FindNLSStringEx().

◆ FindNLSString()

INT WINAPI DECLSPEC_HOTPATCH FindNLSString	(	LCID	lcid,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		const WCHAR *	value,
		int	valuelen,
		int *	found
	)

Definition at line 5191 of file locale.c.

{
    const WCHAR *locale = LOCALE_NAME_USER_DEFAULT;
    const NLS_LOCALE_LCID_INDEX *entry;
 
    switch (lcid)
    {
    case LOCALE_NEUTRAL:
    case LOCALE_USER_DEFAULT:
    case LOCALE_SYSTEM_DEFAULT:
    case LOCALE_CUSTOM_DEFAULT:
    case LOCALE_CUSTOM_UNSPECIFIED:
    case LOCALE_CUSTOM_UI_DEFAULT:
        break;
    default:
        if (lcid == user_lcid || lcid == system_lcid) break;
        if (!(entry = find_lcid_entry( lcid )))
        {
            WARN( "unknown locale %04lx\n", lcid );
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        locale = locale_strings + entry->name + 1;
        break;
    }
 
    return FindNLSStringEx( locale, flags, src, srclen, value, valuelen, found, NULL, NULL, 0 );
}

◆ FindNLSStringEx()

INT WINAPI DECLSPEC_HOTPATCH FindNLSStringEx	(	const WCHAR *	locale,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		const WCHAR *	value,
		int	valuelen,
		int *	found,
		NLSVERSIONINFO *	version,
		void *	reserved,
		LPARAM	handle
	)

Definition at line 5225 of file locale.c.

{
    const struct sortguid *sortid;
 
    TRACE( "%s %lx %s %d %s %d %p %p %p %Id\n", wine_dbgstr_w(locale), flags,
           wine_dbgstr_w(src), srclen, wine_dbgstr_w(value), valuelen, found,
           version, reserved, handle );
 
    if (version) FIXME( "unexpected version parameter\n" );
    if (reserved) FIXME( "unexpected reserved value\n" );
    if (handle) FIXME( "unexpected handle\n" );
 
    if (!src || !srclen || srclen < -1 || !value || !valuelen || valuelen < -1)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return -1;
    }
    if (!(sortid = get_language_sort( locale ))) return -1;
 
    if (srclen == -1) srclen = lstrlenW(src);
    if (valuelen == -1) valuelen = lstrlenW(value);
 
    return find_substring( sortid, flags, src, srclen, value, valuelen, found );
}

Referenced by FindNLSString(), and InitFunctionPointers().

◆ FindStringOrdinal()

INT WINAPI DECLSPEC_HOTPATCH FindStringOrdinal	(	DWORD	flag,
		const WCHAR *	src,
		INT	src_size,
		const WCHAR *	val,
		INT	val_size,
		BOOL	ignore_case
	)

Definition at line 5257 of file locale.c.

{
    INT offset, inc, count;
 
    TRACE( "%#lx %s %d %s %d %d\n", flag, wine_dbgstr_w(src), src_size,
           wine_dbgstr_w(val), val_size, ignore_case );
 
    if (!src || !val)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return -1;
    }
 
    if (flag != FIND_FROMSTART && flag != FIND_FROMEND && flag != FIND_STARTSWITH && flag != FIND_ENDSWITH)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return -1;
    }
 
    if (src_size == -1) src_size = lstrlenW( src );
    if (val_size == -1) val_size = lstrlenW( val );
 
    SetLastError( ERROR_SUCCESS );
    src_size -= val_size;
    if (src_size < 0) return -1;
 
    count = flag & (FIND_FROMSTART | FIND_FROMEND) ? src_size + 1 : 1;
    offset = flag & (FIND_FROMSTART | FIND_STARTSWITH) ? 0 : src_size;
    inc = flag & (FIND_FROMSTART | FIND_STARTSWITH) ? 1 : -1;
    while (count--)
    {
        if (CompareStringOrdinal( src + offset, val_size, val, val_size, ignore_case ) == CSTR_EQUAL)
            return offset;
        offset += inc;
    }
    return -1;
}

Referenced by Global_InStr(), Global_InStrRev(), Global_Split(), InitFunctionPointers(), and string_replace().

◆ fold_digits()

static NTSTATUS fold_digits	(	const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int *	dstlen
	)

static

Definition at line 2289 of file locale.c.

{
    NTSTATUS ret = STATUS_SUCCESS;
    int len = casemap_string( charmaps[CHARMAP_FOLDDIGITS], src, srclen, dst, *dstlen );
 
    if (*dstlen && *dstlen < len) ret = STATUS_BUFFER_TOO_SMALL;
    *dstlen = len;
    return ret;
}

Referenced by fold_string().

◆ fold_string()

static NTSTATUS fold_string	(	DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int *	dstlen
	)

static

Definition at line 2300 of file locale.c.

{
    NTSTATUS ret;
    WCHAR *tmp;
 
    switch (flags)
    {
    case MAP_PRECOMPOSED:
        return RtlNormalizeString( NormalizationC, src, srclen, dst, dstlen );
    case MAP_FOLDCZONE:
    case MAP_PRECOMPOSED | MAP_FOLDCZONE:
        return RtlNormalizeString( NormalizationKC, src, srclen, dst, dstlen );
    case MAP_COMPOSITE:
        return RtlNormalizeString( NormalizationD, src, srclen, dst, dstlen );
    case MAP_COMPOSITE | MAP_FOLDCZONE:
        return RtlNormalizeString( NormalizationKD, src, srclen, dst, dstlen );
    case MAP_FOLDDIGITS:
        return fold_digits( src, srclen, dst, dstlen );
    case MAP_EXPAND_LIGATURES:
    case MAP_EXPAND_LIGATURES | MAP_FOLDCZONE:
        return expand_ligatures( src, srclen, dst, dstlen );
    case MAP_FOLDDIGITS | MAP_PRECOMPOSED:
        if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
            return STATUS_NO_MEMORY;
        fold_digits( src, srclen, tmp, &srclen );
        ret = RtlNormalizeString( NormalizationC, tmp, srclen, dst, dstlen );
        break;
    case MAP_FOLDDIGITS | MAP_FOLDCZONE:
    case MAP_FOLDDIGITS | MAP_PRECOMPOSED | MAP_FOLDCZONE:
        if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
            return STATUS_NO_MEMORY;
        fold_digits( src, srclen, tmp, &srclen );
        ret = RtlNormalizeString( NormalizationKC, tmp, srclen, dst, dstlen );
        break;
    case MAP_FOLDDIGITS | MAP_COMPOSITE:
        if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
            return STATUS_NO_MEMORY;
        fold_digits( src, srclen, tmp, &srclen );
        ret = RtlNormalizeString( NormalizationD, tmp, srclen, dst, dstlen );
        break;
    case MAP_FOLDDIGITS | MAP_COMPOSITE | MAP_FOLDCZONE:
        if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
            return STATUS_NO_MEMORY;
        fold_digits( src, srclen, tmp, &srclen );
        ret = RtlNormalizeString( NormalizationKD, tmp, srclen, dst, dstlen );
        break;
    case MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS:
    case MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS | MAP_FOLDCZONE:
        if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
            return STATUS_NO_MEMORY;
        fold_digits( src, srclen, tmp, &srclen );
        ret = expand_ligatures( tmp, srclen, dst, dstlen );
        break;
    default:
        return STATUS_INVALID_PARAMETER_1;
    }
    RtlFreeHeap( GetProcessHeap(), 0, tmp );
    return ret;
}

Referenced by FoldStringW().

◆ FoldStringW()

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

Definition at line 5301 of file locale.c.

{
    NTSTATUS status;
    WCHAR *buf = dst;
    int len = dstlen;
 
    if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (srclen == -1) srclen = lstrlenW(src) + 1;
 
    if (!dstlen && (flags & (MAP_PRECOMPOSED | MAP_FOLDCZONE | MAP_COMPOSITE)))
    {
        len = srclen * 4;
        if (!(buf = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
        {
            SetLastError( ERROR_OUTOFMEMORY );
            return 0;
        }
    }
 
    for (;;)
    {
        status = fold_string( flags, src, srclen, buf, &len );
        if (buf != dst) RtlFreeHeap( GetProcessHeap(), 0, buf );
        if (status != STATUS_BUFFER_TOO_SMALL) break;
        if (!(buf = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
        {
            SetLastError( ERROR_OUTOFMEMORY );
            return 0;
        }
    }
    if (status == STATUS_INVALID_PARAMETER_1)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
    if (!set_ntstatus( status )) return 0;
 
    if (dstlen && dstlen < len) SetLastError( ERROR_INSUFFICIENT_BUFFER );
    return len;
}

◆ format_number()

static WCHAR * format_number	(	WCHAR *	end,
		const WCHAR *	value,
		const WCHAR *	decimal_sep,
		const WCHAR *	thousand_sep,
		const WCHAR *	grouping,
		UINT	digits,
		BOOL	lzero
	)

static

Definition at line 7533 of file locale.c.

{
    BOOL round = FALSE, repeat = FALSE;
    UINT i, len = 0, prev = ~0;
    const WCHAR *frac = NULL;
 
    *(--end) = 0;
 
    for (i = 0; value[i]; i++)
    {
        if (value[i] >= '0' && value[i] <= '9') continue;
        if (value[i] != '.') return NULL;
        if (frac) return NULL;
        frac = value + i + 1;
    }
 
    /* format fractional part */
 
    len = frac ? wcslen( frac ) : 0;
 
    if (len > digits)
    {
        round = frac[digits] >= '5';
        len = digits;
    }
    while (digits > len)
    {
        (*--end) = '0';
        digits--;
    }
    while (len)
    {
        WCHAR ch = frac[--len];
        if (round)
        {
            if (ch != '9')
            {
                ch++;
                round = FALSE;
            }
            else ch = '0';
        }
        *(--end) = ch;
    }
    if (*end) end = prepend_str( end, decimal_sep );
 
    /* format integer part */
 
    len = frac ? frac - value - 1 : wcslen( value );
 
    while (len && *value == '0')
    {
        value++;
        len--;
    }
    if (len) lzero = FALSE;
 
    /* leading 0s are ignored */
    while (grouping[0] == '0' && grouping[1] == ';')
        grouping += 2;
 
    while (len)
    {
        UINT limit = prev;
 
        if (!repeat)
        {
            limit = *grouping - '0';
            if (grouping[1] == ';')
            {
                grouping += 2;
                if (limit)
                    prev = limit;
                else
                {
                    /* Trailing 0;0 is a special case */
                    prev = ~0;
                    if (grouping[0] == '0' && grouping[1] != ';')
                    {
                        repeat = TRUE;
                        limit = prev;
                    }
                }
            }
            else
            {
                repeat = TRUE;
                if (!limit)
                    limit = prev;
                else
                    prev = ~0;
            }
        }
 
        while (len && limit--)
        {
            WCHAR ch = value[--len];
            if (round)
            {
                if (ch != '9')
                {
                    ch++;
                    round = FALSE;
                }
                else ch = '0';
            }
            *(--end) = ch;
        }
        if (len) end = prepend_str( end, thousand_sep );
    }
    if (round) *(--end) = '1';
    else if (lzero) *(--end) = '0';
    return end;
}

Referenced by get_currency_format(), and get_number_format().

◆ FormatMessageA()

DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageA	(	DWORD	flags,
		const void *	source,
		DWORD	msgid,
		DWORD	langid,
		char *	buffer,
		DWORD	size,
		va_list *	args
	)

Definition at line 5387 of file locale.c.

{
    DWORD ret = 0;
    ULONG len, retsize = 0;
    ULONG width = (flags & FORMAT_MESSAGE_MAX_WIDTH_MASK);
    const WCHAR *src;
    WCHAR *result, *message = NULL;
    NTSTATUS status;
 
    TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
 
    if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
    {
        if (!buffer)
        {
            SetLastError( ERROR_NOT_ENOUGH_MEMORY );
            return 0;
        }
        *(char **)buffer = NULL;
    }
    if (size >= 32768)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (width == 0xff) width = ~0u;
 
    if (!(src = get_message( flags, source, msgid, langid, TRUE, &message ))) return 0;
 
    if (!(result = HeapAlloc( GetProcessHeap(), 0, 65536 )))
        status = STATUS_NO_MEMORY;
    else
        status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
                                   TRUE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
                                   result, 65536, &retsize );
 
    HeapFree( GetProcessHeap(), 0, message );
 
    if (status == STATUS_BUFFER_OVERFLOW)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        goto done;
    }
    if (!set_ntstatus( status )) goto done;
 
    len = WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), NULL, 0, NULL, NULL );
    if (len <= 1)
    {
        SetLastError( ERROR_NO_WORK_DONE );
        goto done;
    }
 
    if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
    {
        char *buf = LocalAlloc( LMEM_ZEROINIT, max( size, len ));
        if (!buf)
        {
            SetLastError( ERROR_NOT_ENOUGH_MEMORY );
            goto done;
        }
        *(char **)buffer = buf;
        WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), buf, max( size, len ), NULL, NULL );
    }
    else if (len > size)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        goto done;
    }
    else WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), buffer, size, NULL, NULL );
 
    ret = len - 1;
 
done:
    HeapFree( GetProcessHeap(), 0, result );
    return ret;
}

◆ FormatMessageW()

DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageW	(	DWORD	flags,
		const void *	source,
		DWORD	msgid,
		DWORD	langid,
		WCHAR *	buffer,
		DWORD	size,
		va_list *	args
	)

Definition at line 5470 of file locale.c.

{
    ULONG retsize = 0;
    ULONG width = (flags & FORMAT_MESSAGE_MAX_WIDTH_MASK);
    const WCHAR *src;
    WCHAR *message = NULL;
    NTSTATUS status;
 
    TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
 
    if (!buffer)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (width == 0xff) width = ~0u;
 
    if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER) *(LPWSTR *)buffer = NULL;
 
    if (!(src = get_message( flags, source, msgid, langid, FALSE, &message ))) return 0;
 
    if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
    {
        WCHAR *result;
        va_list args_copy;
        ULONG alloc = max( size * sizeof(WCHAR), 65536 );
 
        for (;;)
        {
            if (!(result = HeapAlloc( GetProcessHeap(), 0, alloc )))
            {
                status = STATUS_NO_MEMORY;
                break;
            }
            if (args && !(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY))
            {
                va_copy( args_copy, *args );
                status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
                                           FALSE, FALSE, &args_copy, result, alloc, &retsize );
                va_end( args_copy );
            }
            else
                status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
                                           FALSE, TRUE, args, result, alloc, &retsize );
 
            if (!status)
            {
                if (retsize <= sizeof(WCHAR)) HeapFree( GetProcessHeap(), 0, result );
                else *(WCHAR **)buffer = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY,
                                                      result, max( retsize, size * sizeof(WCHAR) ));
                break;
            }
            HeapFree( GetProcessHeap(), 0, result );
            if (status != STATUS_BUFFER_OVERFLOW) break;
            alloc *= 2;
        }
    }
    else status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
                                    FALSE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
                                    buffer, size * sizeof(WCHAR), &retsize );
 
    HeapFree( GetProcessHeap(), 0, message );
 
    if (status == STATUS_BUFFER_OVERFLOW)
    {
        if (size) buffer[size - 1] = 0;
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    if (!set_ntstatus( status )) return 0;
    if (retsize <= sizeof(WCHAR)) SetLastError( ERROR_NO_WORK_DONE );
    return retsize / sizeof(WCHAR) - 1;
}

◆ free_sortkey_state()

static void free_sortkey_state ( struct sortkey_state * s )

static

Definition at line 3654 of file locale.c.

{
    RtlFreeHeap( GetProcessHeap(), 0, s->key_primary.new_buf );
    RtlFreeHeap( GetProcessHeap(), 0, s->key_diacritic.new_buf );
    RtlFreeHeap( GetProcessHeap(), 0, s->key_case.new_buf );
    RtlFreeHeap( GetProcessHeap(), 0, s->key_special.new_buf );
    RtlFreeHeap( GetProcessHeap(), 0, s->key_extra[0].new_buf );
    RtlFreeHeap( GetProcessHeap(), 0, s->key_extra[1].new_buf );
    RtlFreeHeap( GetProcessHeap(), 0, s->key_extra[2].new_buf );
    RtlFreeHeap( GetProcessHeap(), 0, s->key_extra[3].new_buf );
}

Referenced by compare_string(), find_substring(), and get_sortkey().

◆ get_calendar_data()

static const struct calendar * get_calendar_data	(	const NLS_LOCALE_DATA *	locale,
		UINT	id
	)

static

Definition at line 555 of file locale.c.

{
    if (id == CAL_HIJRI && locale->islamic_cal[0]) id = locale->islamic_cal[0];
    else if (id == CAL_PERSIAN && locale->islamic_cal[1]) id = locale->islamic_cal[1];
 
    if (!id || id > locale_table->nb_calendars) return NULL;
    return (const struct calendar *)((const char *)locale_table + locale_table->calendars_offset +
                                     (id - 1) * locale_table->calendar_size);
}

Referenced by get_calendar_info(), and Internal_EnumDateFormats().

◆ get_calendar_info()

static int get_calendar_info	(	const NLS_LOCALE_DATA *	locale,
		CALID	id,
		CALTYPE	type,
		WCHAR *	buffer,
		int	len,
		DWORD *	value
	)

static

Definition at line 1619 of file locale.c.

{
    unsigned int i, val = 0;
    const struct calendar *cal;
 
    if (type & CAL_RETURN_NUMBER)
    {
        if (buffer || len || !value) goto invalid;
    }
    else if (len < 0 || value) goto invalid;
 
    if (id != CAL_GREGORIAN && type != CAL_ITWODIGITYEARMAX)
    {
        const USHORT *ids = locale_strings + locale->scalendartype;
        for (i = 0; i < ids[0]; i++) if (ids[1 + i] == id) break;
        if (i == ids[0]) goto invalid;
    }
    if (!(cal = get_calendar_data( locale, id ))) goto invalid;
 
    switch (LOWORD(type))
    {
    case CAL_ICALINTVALUE:
        return cal_return_number( cal->icalintvalue, type, buffer, len, value );
 
    case CAL_SCALNAME:
        return locale_return_strarray( locale->calnames, id - 1, type, buffer, len );
 
    case CAL_IYEAROFFSETRANGE:
        if (cal->iyearoffsetrange)
        {
            const DWORD *array = (const DWORD *)(locale_strings + cal->iyearoffsetrange + 1);
            const short *info = (const short *)locale_strings + array[0];
            val = (info[5] < 0) ? -info[5] : info[5] + 1;  /* year zero */
        }
        return cal_return_number( val, type, buffer, len, value );
 
    case CAL_SERASTRING:
        if (id == CAL_GREGORIAN) return locale_return_string( locale->serastring, type, buffer, len );
        if (cal->iyearoffsetrange)
        {
            const DWORD *array = (const DWORD *)(locale_strings + cal->iyearoffsetrange + 1);
            const short *info = (const short *)locale_strings + array[0];
            val = info[1] - 1;
        }
        return locale_return_strarray( cal->serastring, val, type, buffer, len );
 
    case CAL_SSHORTDATE:
        val = (id == CAL_GREGORIAN) ? locale->sshortdate : cal->sshortdate;
        return locale_return_strarray( val, 0, type, buffer, len );
 
    case CAL_SLONGDATE:
        val = (id == CAL_GREGORIAN) ? locale->slongdate : cal->slongdate;
        return locale_return_strarray( val, 0, type, buffer, len );
 
    case CAL_SDAYNAME1:
    case CAL_SDAYNAME2:
    case CAL_SDAYNAME3:
    case CAL_SDAYNAME4:
    case CAL_SDAYNAME5:
    case CAL_SDAYNAME6:
    case CAL_SDAYNAME7:
        val = (id == CAL_GREGORIAN) ? locale->sdayname : cal->sdayname;
        return locale_return_strarray( val, (LOWORD(type) - CAL_SDAYNAME1 + 1) % 7, type, buffer, len );
 
    case CAL_SABBREVDAYNAME1:
    case CAL_SABBREVDAYNAME2:
    case CAL_SABBREVDAYNAME3:
    case CAL_SABBREVDAYNAME4:
    case CAL_SABBREVDAYNAME5:
    case CAL_SABBREVDAYNAME6:
    case CAL_SABBREVDAYNAME7:
        val = (id == CAL_GREGORIAN) ? locale->sabbrevdayname : cal->sabbrevdayname;
        return locale_return_strarray( val, (LOWORD(type) - CAL_SABBREVDAYNAME1 + 1) % 7, type, buffer, len );
    case CAL_SMONTHNAME1:
    case CAL_SMONTHNAME2:
    case CAL_SMONTHNAME3:
    case CAL_SMONTHNAME4:
    case CAL_SMONTHNAME5:
    case CAL_SMONTHNAME6:
    case CAL_SMONTHNAME7:
    case CAL_SMONTHNAME8:
    case CAL_SMONTHNAME9:
    case CAL_SMONTHNAME10:
    case CAL_SMONTHNAME11:
    case CAL_SMONTHNAME12:
    case CAL_SMONTHNAME13:
        if (id != CAL_GREGORIAN) val = cal->smonthname;
        else if ((type & CAL_RETURN_GENITIVE_NAMES) && locale->sgenitivemonth) val = locale->sgenitivemonth;
        else val = locale->smonthname;
        return locale_return_strarray( val, LOWORD(type) - CAL_SMONTHNAME1, type, buffer, len );
 
    case CAL_SABBREVMONTHNAME1:
    case CAL_SABBREVMONTHNAME2:
    case CAL_SABBREVMONTHNAME3:
    case CAL_SABBREVMONTHNAME4:
    case CAL_SABBREVMONTHNAME5:
    case CAL_SABBREVMONTHNAME6:
    case CAL_SABBREVMONTHNAME7:
    case CAL_SABBREVMONTHNAME8:
    case CAL_SABBREVMONTHNAME9:
    case CAL_SABBREVMONTHNAME10:
    case CAL_SABBREVMONTHNAME11:
    case CAL_SABBREVMONTHNAME12:
    case CAL_SABBREVMONTHNAME13:
        if (id != CAL_GREGORIAN) val = cal->sabbrevmonthname;
        else if ((type & CAL_RETURN_GENITIVE_NAMES) && locale->sabbrevgenitivemonth) val = locale->sabbrevgenitivemonth;
        else val = locale->sabbrevmonthname;
        return locale_return_strarray( val, LOWORD(type) - CAL_SABBREVMONTHNAME1, type, buffer, len );
 
    case CAL_SYEARMONTH:
        val = (id == CAL_GREGORIAN) ? locale->syearmonth : cal->syearmonth;
        return locale_return_strarray( val, 0, type, buffer, len );
 
    case CAL_ITWODIGITYEARMAX:
        return cal_return_number( cal->itwodigityearmax, type, buffer, len, value );
 
    case CAL_SSHORTESTDAYNAME1:
    case CAL_SSHORTESTDAYNAME2:
    case CAL_SSHORTESTDAYNAME3:
    case CAL_SSHORTESTDAYNAME4:
    case CAL_SSHORTESTDAYNAME5:
    case CAL_SSHORTESTDAYNAME6:
    case CAL_SSHORTESTDAYNAME7:
        val = (id == CAL_GREGORIAN) ? locale->sshortestdayname : cal->sshortestdayname;
        return locale_return_strarray( val, (LOWORD(type) - CAL_SSHORTESTDAYNAME1 + 1) % 7, type, buffer, len );
 
    case CAL_SMONTHDAY:
        val = (id == CAL_GREGORIAN) ? locale->smonthday : cal->smonthday;
        return locale_return_strarray( val, 0, type, buffer, len );
 
    case CAL_SABBREVERASTRING:
        if (id == CAL_GREGORIAN) return locale_return_string( locale->sabbreverastring, type, buffer, len );
        if (cal->iyearoffsetrange)
        {
            const DWORD *array = (const DWORD *)(locale_strings + cal->iyearoffsetrange + 1);
            const short *info = (const short *)locale_strings + array[0];
            val = info[1] - 1;
        }
        return locale_return_strarray( cal->sabbreverastring, val, type, buffer, len );
 
    case CAL_SRELATIVELONGDATE:
        val = (id == CAL_GREGORIAN) ? locale->srelativelongdate : cal->srelativelongdate;
        return locale_return_string( val, type, buffer, len );
 
    case CAL_SENGLISHERANAME:
    case CAL_SENGLISHABBREVERANAME:
        /* not supported on Windows */
        break;
    }
    SetLastError( ERROR_INVALID_FLAGS );
    return 0;
 
invalid:
    SetLastError( ERROR_INVALID_PARAMETER );
    return 0;
}

Referenced by GetCalendarInfoEx(), GetCalendarInfoW(), and Internal_EnumCalendarInfo().

◆ get_char_props()

static BYTE get_char_props	(	const struct norm_table *	info,
		unsigned int	ch
	)

static

Definition at line 2101 of file locale.c.

{
    const BYTE *level1 = (const BYTE *)((const USHORT *)info + info->props_level1);
    const BYTE *level2 = (const BYTE *)((const USHORT *)info + info->props_level2);
    BYTE off = level1[ch / 128];
 
    if (!off || off >= 0xfb) return rol( off, 5 );
    return level2[(off - 1) * 128 + ch % 128];
}

Referenced by get_decomposition().

◆ get_char_type()

static WORD get_char_type	(	DWORD	type,
		WCHAR	ch
	)

inlinestatic

Definition at line 2036 of file locale.c.

{
    const BYTE *ptr = sort.ctype_idx + ((const WORD *)sort.ctype_idx)[ch >> 8];
    ptr = sort.ctype_idx + ((const WORD *)ptr)[(ch >> 4) & 0x0f] + (ch & 0x0f);
    return sort.ctypes[*ptr * 3 + type / 2];
}

Referenced by GetStringTypeW(), IsCharAlphaA(), IsCharAlphaNumericA(), IsCharAlphaNumericW(), IsCharAlphaW(), IsCharBlankW(), IsCharCntrlW(), IsCharDigitW(), IsCharLowerA(), IsCharLowerW(), IsCharPunctW(), IsCharSpaceA(), IsCharSpaceW(), IsCharUpperA(), IsCharUpperW(), IsCharXDigitW(), IsNLSDefinedString(), map_remove_ignored(), and nonspace_ignored().

◆ get_char_weights()

static union char_weights get_char_weights	(	WCHAR	c,
		UINT	except
	)

static

Definition at line 2086 of file locale.c.

{
    union char_weights ret;
 
    ret.val = except ? sort.keys[sort.keys[except + (c >> 8)] + (c & 0xff)] : sort.keys[c];
    return ret;
}

Referenced by append_extra_kana_weights(), append_hangul_weights(), and append_weights().

◆ get_codepage_table()

static const CPTABLEINFO * get_codepage_table ( UINT codepage )

static

Definition at line 2198 of file locale.c.

{
    static const CPTABLEINFO utf7_cpinfo = { CP_UTF7, 5, '?', 0xfffd, '?', '?' };
    static const CPTABLEINFO utf8_cpinfo = { CP_UTF8, 4, '?', 0xfffd, '?', '?' };
    unsigned int i;
    USHORT *ptr;
    SIZE_T size;
 
    switch (codepage)
    {
    case CP_ACP:
        return &ansi_cpinfo;
    case CP_OEMCP:
        return &oem_cpinfo;
    case CP_MACCP:
        codepage = system_locale->idefaultmaccodepage;
        break;
    case CP_THREAD_ACP:
        codepage = get_lcid_codepage( NtCurrentTeb()->CurrentLocale, 0 );
        break;
    }
    if (codepage == ansi_cpinfo.CodePage) return &ansi_cpinfo;
    if (codepage == oem_cpinfo.CodePage) return &oem_cpinfo;
    if (codepage == CP_UTF8) return &utf8_cpinfo;
    if (codepage == CP_UTF7) return &utf7_cpinfo;
 
    RtlEnterCriticalSection( &locale_section );
 
    for (i = 0; i < nb_codepages; i++) if (codepages[i].CodePage == codepage) goto done;
 
    if (i == ARRAY_SIZE( codepages ))
    {
        RtlLeaveCriticalSection( &locale_section );
        ERR( "too many codepages\n" );
        return NULL;
    }
    if (NtGetNlsSectionPtr( 11, codepage, NULL, (void **)&ptr, &size ))
    {
        RtlLeaveCriticalSection( &locale_section );
        SetLastError( ERROR_INVALID_PARAMETER );
        return NULL;
    }
    RtlInitCodePageTable( ptr, &codepages[i] );
    nb_codepages++;
done:
    RtlLeaveCriticalSection( &locale_section );
    return &codepages[i];
}

◆ get_compression_weights()

static int get_compression_weights	(	UINT	compression,
		const WCHAR *	compr_tables[8],
		const WCHAR *	src,
		int	srclen,
		union char_weights *	weights
	)

static

Definition at line 3380 of file locale.c.

{
    const struct sort_compression *compr = sort.compressions + compression;
    const UINT *ret;
    BYTE size = weights->_case & CASE_COMPR_6;
    int i, maxlen = 1;
 
    if (compression >= sort.compr_count) return 0;
    if (size == CASE_COMPR_6) maxlen = 8;
    else if (size == CASE_COMPR_4) maxlen = 5;
    else if (size == CASE_COMPR_2) maxlen = 3;
    maxlen = min( maxlen, srclen );
    for (i = 0; i < maxlen; i++) if (src[i] < compr->minchar || src[i] > compr->maxchar) break;
    maxlen = i;
    if (!compr_tables[0])
    {
        compr_tables[0] = sort.compr_data + compr->offset;
        for (i = 1; i < 8; i++)
            compr_tables[i] = compr_tables[i - 1] + compr->len[i - 1] * compression_size( i + 1 );
    }
    for (i = maxlen - 2; i >= 0; i--)
    {
        if (!(ret = find_compression( src, compr_tables[i], compr->len[i], i + 2 ))) continue;
        weights->val = *ret;
        return i + 1;
    }
    return 0;
}

Referenced by append_weights().

◆ get_currency_format()

static int get_currency_format	(	const NLS_LOCALE_DATA *	locale,
		DWORD	flags,
		const WCHAR *	value,
		const CURRENCYFMTW *	format,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 7744 of file locale.c.

{
    WCHAR *num, fmt_decimal[4], fmt_thousand[4], fmt_symbol[13], fmt_neg[5], grouping[20], output[256];
    const WCHAR *decimal_sep = fmt_decimal, *thousand_sep = fmt_thousand, *symbol = fmt_symbol;
    DWORD digits, lzero, pos_order, neg_order;
    int ret = 0;
    BOOL negative = (*value == '-');
 
    flags &= LOCALE_NOUSEROVERRIDE;
 
    if (!format)
    {
        get_locale_info( locale, 0, LOCALE_SCURRENCY | flags, fmt_symbol, ARRAY_SIZE(fmt_symbol) );
        get_locale_info( locale, 0, LOCALE_SMONGROUPING | flags, grouping, ARRAY_SIZE(grouping) );
        get_locale_info( locale, 0, LOCALE_SMONDECIMALSEP | flags, fmt_decimal, ARRAY_SIZE(fmt_decimal) );
        get_locale_info( locale, 0, LOCALE_SMONTHOUSANDSEP | flags, fmt_thousand, ARRAY_SIZE(fmt_thousand) );
        get_locale_info( locale, 0, LOCALE_ICURRDIGITS | LOCALE_RETURN_NUMBER | flags,
                         (WCHAR *)&digits, sizeof(DWORD)/sizeof(WCHAR) );
        get_locale_info( locale, 0, LOCALE_ILZERO | LOCALE_RETURN_NUMBER | flags,
                         (WCHAR *)&lzero, sizeof(DWORD)/sizeof(WCHAR) );
        get_locale_info( locale, 0, LOCALE_ICURRENCY | LOCALE_RETURN_NUMBER | flags,
                         (WCHAR *)&pos_order, sizeof(DWORD)/sizeof(WCHAR) );
        get_locale_info( locale, 0, LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | flags,
                         (WCHAR *)&neg_order, sizeof(DWORD)/sizeof(WCHAR) );
    }
    else
    {
        if (flags)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        decimal_sep = format->lpDecimalSep;
        thousand_sep = format->lpThousandSep;
        symbol = format->lpCurrencySymbol;
        grouping_to_string( format->Grouping, grouping );
        digits = format->NumDigits;
        lzero = format->LeadingZero;
        pos_order = format->PositiveOrder;
        neg_order = format->NegativeOrder;
        if (!decimal_sep || !thousand_sep || !symbol)
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
    }
 
    if (negative)
    {
        value++;
        get_locale_info( locale, 0, LOCALE_SNEGATIVESIGN | flags, fmt_neg, ARRAY_SIZE(fmt_neg) );
    }
 
    if (!(num = format_number( output + ARRAY_SIZE(output) - 20, value,
                               decimal_sep, thousand_sep, grouping, digits, lzero )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (negative)
    {
        switch (neg_order)
        {
        case 14:  /* ($ 1.1) */
            num = prepend_str( num, L" " );
            /* fall through */
        case 0:  /* ($1.1) */
            num = prepend_str( num, symbol );
            num = prepend_str( num, L"(" );
            wcscat( num, L")" );
            break;
        case 9:  /* -$ 1.1 */
            num = prepend_str( num, L" " );
            /* fall through */
        case 1:  /* -$1.1 */
            num = prepend_str( num, symbol );
            num = prepend_str( num, fmt_neg );
            break;
        case 2:  /* $-1.1 */
            num = prepend_str( num, fmt_neg );
            num = prepend_str( num, symbol );
            break;
        case 11:  /* $ 1.1- */
            num = prepend_str( num, L" " );
            /* fall through */
        case 3:  /* $1.1- */
            num = prepend_str( num, symbol );
            wcscat( num, fmt_neg );
            break;
        case 15:  /* (1.1 $) */
            wcscat( num, L" " );
            /* fall through */
        case 4:  /* (1.1$) */
            wcscat( num, symbol );
            num = prepend_str( num, L"(" );
            wcscat( num, L")" );
            break;
        case 8:  /* -1.1 $ */
            wcscat( num, L" " );
            /* fall through */
        case 5:  /* -1.1$ */
            num = prepend_str( num, fmt_neg );
            wcscat( num, symbol );
            break;
        case 6:  /* 1.1-$ */
            wcscat( num, fmt_neg );
            wcscat( num, symbol );
            break;
        case 10:  /* 1.1 $- */
            wcscat( num, L" " );
            /* fall through */
        case 7:  /* 1.1$- */
            wcscat( num, symbol );
            wcscat( num, fmt_neg );
            break;
        case 12:  /* $ -1.1 */
            num = prepend_str( num, fmt_neg );
            num = prepend_str( num, L" " );
            num = prepend_str( num, symbol );
            break;
        case 13:  /* 1.1- $ */
            wcscat( num, fmt_neg );
            wcscat( num, L" " );
            wcscat( num, symbol );
            break;
        default:
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
    }
    else
    {
        switch (pos_order)
        {
        case 2: /* $ 1.1 */
            num = prepend_str( num, L" " );
            /* fall through */
        case 0: /* $1.1 */
            num = prepend_str( num, symbol );
            break;
        case 3: /* 1.1 $ */
            wcscat( num, L" " );
            /* fall through */
        case 1: /* 1.1$ */
            wcscat( num, symbol );
            break;
        default:
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
    }
 
    ret = wcslen( num ) + 1;
    if (!len) return ret;
    lstrcpynW( buffer, num, len );
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return ret;
}

Referenced by GetCurrencyFormatEx(), and GetCurrencyFormatW().

◆ get_date_format()

static int get_date_format	(	const NLS_LOCALE_DATA *	locale,
		DWORD	flags,
		const SYSTEMTIME *	systime,
		const WCHAR *	format,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 7930 of file locale.c.

{
    DWORD override = flags & LOCALE_NOUSEROVERRIDE;
    DWORD genitive = 0;
    WCHAR *p, fmt[80], output[256];
    SYSTEMTIME time;
    int ret, val, count, i;
 
    if (!format)
    {
        if (flags & DATE_USE_ALT_CALENDAR) FIXME( "alt calendar not supported\n" );
        switch (flags & (DATE_SHORTDATE | DATE_LONGDATE | DATE_YEARMONTH | DATE_MONTHDAY))
        {
        case 0:
        case DATE_SHORTDATE:
            get_locale_info( locale, 0, LOCALE_SSHORTDATE | override, fmt, ARRAY_SIZE(fmt) );
            break;
        case DATE_LONGDATE:
            get_locale_info( locale, 0, LOCALE_SLONGDATE | override, fmt, ARRAY_SIZE(fmt) );
            break;
        case DATE_YEARMONTH:
            get_locale_info( locale, 0, LOCALE_SYEARMONTH | override, fmt, ARRAY_SIZE(fmt) );
            break;
        case DATE_MONTHDAY:
            get_locale_info( locale, 0, LOCALE_SMONTHDAY | override, fmt, ARRAY_SIZE(fmt) );
            break;
        default:
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        format = fmt;
    }
    else if (override || (flags & (DATE_SHORTDATE | DATE_LONGDATE | DATE_YEARMONTH | DATE_MONTHDAY)))
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (systime)
    {
        FILETIME ft;
 
        time = *systime;
        time.wHour = time.wMinute = time.wSecond = time.wMilliseconds = 0;
        if (!SystemTimeToFileTime( &time, &ft ) || !FileTimeToSystemTime( &ft, &time )) return 0;
    }
    else GetLocalTime( &time );
 
    for (p = output; *format; format += count)
    {
        count = get_pattern_len( format, L"yMd" );
 
        switch (*format)
        {
        case '\'':
            for (i = 1; i < count; i++)
            {
                if (format[i] == '\'') i++;
                if (i < count) *p++ = format[i];
            }
            break;
 
        case 'y':
            p += swprintf( p, output + ARRAY_SIZE(output) - p, L"%02u",
                           (count <= 2) ? time.wYear % 100 : time.wYear );
            break;
 
        case 'M':
            if (count <= 2)
            {
                p += swprintf( p, output + ARRAY_SIZE(output) - p, L"%.*u", count, time.wMonth );
                break;
            }
            val = (count == 3 ? LOCALE_SABBREVMONTHNAME1 : LOCALE_SMONTHNAME1) + time.wMonth - 1;
            if (!genitive)
            {
                for (i = count; format[i]; i += get_pattern_len( format + i, L"yMd" ))
                {
                    if (format[i] != 'd') continue;
                    if (format[i + 1] != 'd' || format[i + 2] != 'd')
                        genitive = LOCALE_RETURN_GENITIVE_NAMES;
                    break;
                }
            }
            p += get_locale_info( locale, 0, val | override | genitive,
                                  p, output + ARRAY_SIZE(output) - p ) - 1;
            break;
 
        case 'd':
            if (count <= 2)
            {
                genitive = LOCALE_RETURN_GENITIVE_NAMES;
                p += swprintf( p, output + ARRAY_SIZE(output) - p, L"%.*u", count, time.wDay );
                break;
            }
            genitive = 0;
            val = (count == 3 ? LOCALE_SABBREVDAYNAME1 : LOCALE_SDAYNAME1) + (time.wDayOfWeek + 6) % 7;
            p += get_locale_info( locale, 0, val | override, p, output + ARRAY_SIZE(output) - p ) - 1;
            break;
 
        case 'g':
            p += locale_return_string( count >= 2 ? locale->serastring : locale->sabbreverastring,
                                       override, p, output + ARRAY_SIZE(output) - p ) - 1;
            break;
 
        default:
            *p++ = *format;
            break;
        }
    }
    *p++ = 0;
    ret = p - output;
 
    if (!len) return ret;
    lstrcpynW( buffer, output, len );
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return ret;
}

Referenced by GetDateFormatEx(), GetDateFormatW(), and VARIANT_FormatDate().

◆ get_decomposition()

static const WCHAR * get_decomposition	(	WCHAR	ch,
		unsigned int *	ret_len
	)

static

Definition at line 2112 of file locale.c.

{
    const struct pair { WCHAR src; USHORT dst; } *pairs;
    const USHORT *hash_table = (const USHORT *)norm_info + norm_info->decomp_hash;
    const WCHAR *ret;
    unsigned int i, pos, end, len, hash;
 
    *ret_len = 1;
    hash = ch % norm_info->decomp_size;
    pos = hash_table[hash];
    if (pos >> 13)
    {
        if (get_char_props( norm_info, ch ) != 0xbf) return NULL;
        ret = (const USHORT *)norm_info + norm_info->decomp_seq + (pos & 0x1fff);
        len = pos >> 13;
    }
    else
    {
        pairs = (const struct pair *)((const USHORT *)norm_info + norm_info->decomp_map);
 
        /* find the end of the hash bucket */
        for (i = hash + 1; i < norm_info->decomp_size; i++) if (!(hash_table[i] >> 13)) break;
        if (i < norm_info->decomp_size) end = hash_table[i];
        else for (end = pos; pairs[end].src; end++) ;
 
        for ( ; pos < end; pos++)
        {
            if (pairs[pos].src != (WCHAR)ch) continue;
            ret = (const USHORT *)norm_info + norm_info->decomp_seq + (pairs[pos].dst & 0x1fff);
            len = pairs[pos].dst >> 13;
            break;
        }
        if (pos >= end) return NULL;
    }
 
    if (len == 7) while (ret[len]) len++;
    if (!ret[0]) len = 0;  /* ignored char */
    *ret_len = len;
    return ret;
}

Referenced by map_remove_ignored(), and mbstowcs_decompose().

◆ get_digit_zero_char()

static WCHAR get_digit_zero_char ( WCHAR ch )

static

Definition at line 3411 of file locale.c.

{
    static const WCHAR zeroes[] =
    {
        0x0030, 0x0660, 0x06f0, 0x0966, 0x09e6, 0x0a66, 0x0ae6, 0x0b66, 0x0be6, 0x0c66,
        0x0ce6, 0x0d66, 0x0e50, 0x0ed0, 0x0f20, 0x1040, 0x1090, 0x17e0, 0x1810, 0x1946,
        0x1bb0, 0x1c40, 0x1c50, 0xa620, 0xa8d0, 0xa900, 0xaa50, 0xff10
    };
    int min = 0, max = ARRAY_SIZE( zeroes ) - 1;
 
    while (min <= max)
    {
        int pos = (min + max) / 2;
        if (zeroes[pos] <= ch && zeroes[pos] + 9 >= ch) return zeroes[pos];
        if (zeroes[pos] < ch) min = pos + 1;
        else max = pos - 1;
    }
    return 0;
}

Referenced by append_digit_weights().

◆ get_geo_info()

static int get_geo_info	(	const struct geo_id *	geo,
		enum SYSGEOTYPE	type,
		WCHAR *	buffer,
		int	len,
		LANGID	lang
	)

static

Definition at line 1779 of file locale.c.

{
    WCHAR tmp[12];
    const WCHAR *str = tmp;
    int ret;
 
    switch (type)
    {
    case GEO_NATION:
        if (geo->class != GEOCLASS_NATION) return 0;
        /* fall through */
    case GEO_ID:
        swprintf( tmp, ARRAY_SIZE(tmp), L"%u", geo->id );
        break;
    case GEO_ISO_UN_NUMBER:
        swprintf( tmp, ARRAY_SIZE(tmp), L"%03u", geo->uncode );
        break;
    case GEO_PARENT:
        swprintf( tmp, ARRAY_SIZE(tmp), L"%u", geo->parent );
        break;
    case GEO_DIALINGCODE:
        swprintf( tmp, ARRAY_SIZE(tmp), L"%u", geo->dialcode );
        break;
    case GEO_ISO2:
        str = geo->iso2;
        break;
    case GEO_ISO3:
        str = geo->iso3;
        break;
    case GEO_LATITUDE:
        str = geo->latitude;
        break;
    case GEO_LONGITUDE:
        str = geo->longitude;
        break;
    case GEO_CURRENCYCODE:
        str = geo->currcode;
        break;
    case GEO_CURRENCYSYMBOL:
        str = geo->currsymbol;
        break;
    case GEO_RFC1766:
    case GEO_LCID:
    case GEO_FRIENDLYNAME:
    case GEO_OFFICIALNAME:
    case GEO_TIMEZONES:
    case GEO_OFFICIALLANGUAGES:
    case GEO_NAME:
        FIXME( "type %u is not supported\n", type );
        SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
        return 0;
    default:
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    ret = lstrlenW(str) + 1;
    if (!buffer || !len) return ret;
 
    memcpy( buffer, str, min( ret, len ) * sizeof(WCHAR) );
    if (len < ret) SetLastError( ERROR_INSUFFICIENT_BUFFER );
    return len < ret ? 0 : ret;
}

Referenced by GetGeoInfoEx(), and GetGeoInfoW().

◆ get_language_sort()

static const struct sortguid * get_language_sort ( const WCHAR * name )

static

Definition at line 664 of file locale.c.

{
    const NLS_LOCALE_LCNAME_INDEX *entry;
    const NLS_LOCALE_DATA *locale;
    WCHAR guidstr[39];
    const struct sortguid *ret;
    UNICODE_STRING str;
    LCID lcid;
    GUID guid;
    HKEY key = 0;
    DWORD size, type;
 
    if (name == LOCALE_NAME_USER_DEFAULT)
    {
        if (current_locale_sort) return current_locale_sort;
        name = locale_strings + user_locale->sname + 1;
    }
    else if (name[0] == '!' && !compare_locale_names( name, LOCALE_NAME_SYSTEM_DEFAULT ))
    {
        name = locale_strings + system_locale->sname + 1;
    }
 
    if (!(entry = find_lcname_entry( name )))
    {
        WARN( "unknown locale %s\n", debugstr_w(name) );
        SetLastError( ERROR_INVALID_PARAMETER );
        return NULL;
    }
    if ((ret = locale_sorts[entry - lcnames_index])) return ret;
 
    lcid = entry->id;
    name = locale_strings + entry->name + 1;
    locale = get_locale_data( entry->idx );
    if (!RegOpenKeyExW( nls_key, L"Sorting\\Ids", 0, KEY_READ, &key ))
    {
        for (;;)
        {
            size = sizeof(guidstr);
            if (!RegQueryValueExW( key, name, NULL, &type, (BYTE *)guidstr, &size ) && type == REG_SZ)
            {
                RtlInitUnicodeString( &str, guidstr );
                if (!RtlGUIDFromString( &str, &guid )) ret = find_sortguid( &guid );
                break;
            }
            if (!name[0]) break;
            name = locale_strings + (SORTIDFROMLCID( lcid ) ? locale->sname : locale->sparent) + 1;
            if (!(locale = get_locale_by_name( name, &lcid ))) break;
        }
        RegCloseKey( key );
    }
    if (!ret) ret = &sort.guids[0];
    locale_sorts[entry - lcnames_index] = ret;
    return ret;
}

Referenced by CompareStringEx(), FindNLSStringEx(), GetNLSVersionEx(), init_locale(), and LCMapStringEx().

◆ get_lcid_codepage()

static UINT get_lcid_codepage	(	LCID	lcid,
		ULONG	flags
	)

static

Definition at line 2185 of file locale.c.

{
    UINT ret = ansi_cpinfo.CodePage;
 
    if (!(flags & LOCALE_USE_CP_ACP) && lcid != system_lcid)
    {
        const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, 0 );
        if (locale) ret = locale->idefaultansicodepage;
    }
    return ret;
}

◆ get_ligature()

static const WCHAR * get_ligature ( WCHAR wc )

static

Definition at line 2248 of file locale.c.

{
    int low = 0, high = ARRAY_SIZE( ligatures ) -1;
    while (low <= high)
    {
        int pos = (low + high) / 2;
        if (ligatures[pos][0] < wc) low = pos + 1;
        else if (ligatures[pos][0] > wc) high = pos - 1;
        else return ligatures[pos] + 1;
    }
    return NULL;
}

Referenced by expand_ligatures().

◆ get_locale_by_name()

static const NLS_LOCALE_DATA * get_locale_by_name	(	const WCHAR *	name,
		LCID *	lcid
	)

static

Definition at line 644 of file locale.c.

{
    const NLS_LOCALE_LCNAME_INDEX *entry;
 
    if (name == LOCALE_NAME_USER_DEFAULT)
    {
        *lcid = user_lcid;
        return user_locale;
    }
    if (name[0] == '!' && !compare_locale_names( name, LOCALE_NAME_SYSTEM_DEFAULT ))
    {
        *lcid = system_lcid;
        return system_locale;
    }
    if (!(entry = find_lcname_entry( name ))) return NULL;
    *lcid = entry->id;
    return get_locale_data( entry->idx );
}

Referenced by EnumCalendarInfoExEx(), EnumDateFormatsExEx(), EnumTimeFormatsEx(), get_language_sort(), GetCalendarInfoEx(), GetCurrencyFormatEx(), GetDateFormatEx(), GetLocaleInfoEx(), GetNumberFormatEx(), GetTimeFormatEx(), init_locale(), LocaleNameToLCID(), and ResolveLocaleName().

◆ get_locale_codepage()

static UINT get_locale_codepage	(	const NLS_LOCALE_DATA *	locale,
		ULONG	flags
	)

static

Definition at line 2177 of file locale.c.

{
    UINT ret = locale->idefaultansicodepage;
    if ((flags & LOCALE_USE_CP_ACP) || ret == CP_UTF8) ret = ansi_cpinfo.CodePage;
    return ret;
}

Referenced by call_enum_date_func(), GetLocaleInfoA(), Internal_EnumCalendarInfo(), and Internal_EnumTimeFormats().

◆ get_locale_data()

static const NLS_LOCALE_DATA * get_locale_data ( UINT idx )

static

Definition at line 548 of file locale.c.

{
    ULONG offset = locale_table->locales_offset + idx * locale_table->locale_size;
    return (const NLS_LOCALE_DATA *)((const char *)locale_table + offset);
}

Referenced by EnumSystemLocalesA(), EnumSystemLocalesEx(), EnumSystemLocalesW(), get_language_sort(), get_locale_by_name(), Internal_EnumUILanguages(), and NlsValidateLocale().

◆ get_locale_info()

static int get_locale_info	(	const NLS_LOCALE_DATA *	locale,
		LCID	lcid,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 1114 of file locale.c.

{
    static const WCHAR spermille[] = { 0x2030, 0 };  /* this one seems hardcoded */
    static const BYTE ipossignposn[]    = { 3, 3, 4, 2, 1, 1, 3, 4, 1, 3, 4, 2, 4, 3, 3, 1 };
    static const BYTE inegsignposn[]    = { 0, 3, 4, 2, 0, 1, 3, 4, 1, 3, 4, 2, 4, 3, 0, 0 };
    static const BYTE inegsymprecedes[] = { 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, };
    const WCHAR *sort;
    WCHAR *str, *end, tmp[80];
    UINT val;
    int ret;
 
    if (locale != user_locale) type |= LOCALE_NOUSEROVERRIDE;
 
    switch (LOWORD(type))
    {
    case LOCALE_ILANGUAGE:
        /* return default language for neutral locales */
        val = locale->inotneutral ? locale->ilanguage : locale->idefaultlanguage;
        return locale_return_number( val, type, buffer, len );
 
    case LOCALE_SLOCALIZEDDISPLAYNAME:
        /* FIXME: localization */
        return locale_return_string( locale->sengdisplayname, type, buffer, len );
 
    case LOCALE_SABBREVLANGNAME:
        return locale_return_string( locale->sabbrevlangname, type, buffer, len );
 
    case LOCALE_SNATIVELANGNAME:
        return locale_return_string( locale->snativelangname, type, buffer, len );
 
    case LOCALE_ICOUNTRY:
        if ((ret = locale_return_reg_number( &entry_icountry, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->icountry, type, buffer, len );
 
    case LOCALE_SLOCALIZEDCOUNTRYNAME:
        /* FIXME: localization */
        return locale_return_string( locale->sengcountry, type, buffer, len );
 
    case LOCALE_SABBREVCTRYNAME:
        return locale_return_string( locale->sabbrevctryname, type, buffer, len );
 
    case LOCALE_SNATIVECTRYNAME:
        return locale_return_string( locale->snativectryname, type, buffer, len );
 
    case LOCALE_IDEFAULTLANGUAGE:
        return locale_return_number( locale->idefaultlanguage, type, buffer, len );
 
    case LOCALE_IDEFAULTCOUNTRY:
        return locale_return_number( locale->icountry, type, buffer, len );
 
    case LOCALE_IDEFAULTCODEPAGE:
        val = locale->idefaultcodepage == CP_UTF8 ? CP_OEMCP : locale->idefaultcodepage;
        return locale_return_number( val, type, buffer, len );
 
    case LOCALE_SLIST:
        if ((ret = locale_return_reg_string( &entry_slist, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->slist, type, buffer, len );
 
    case LOCALE_IMEASURE:
        if ((ret = locale_return_reg_number( &entry_imeasure, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->imeasure, type, buffer, len );
 
    case LOCALE_SDECIMAL:
        if ((ret = locale_return_reg_string( &entry_sdecimal, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->sdecimal, type, buffer, len );
 
    case LOCALE_STHOUSAND:
        if ((ret = locale_return_reg_string( &entry_sthousand, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->sthousand, type, buffer, len );
 
    case LOCALE_SGROUPING:
        if ((ret = locale_return_reg_string( &entry_sgrouping, type, buffer, len )) != -1) return ret;
        return locale_return_grouping( locale->sgrouping, type, buffer, len );
 
    case LOCALE_IDIGITS:
        if ((ret = locale_return_reg_number( &entry_idigits, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->idigits, type, buffer, len );
 
    case LOCALE_ILZERO:
        if ((ret = locale_return_reg_number( &entry_ilzero, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->ilzero, type, buffer, len );
 
    case LOCALE_SNATIVEDIGITS:
        if ((ret = locale_return_reg_string( &entry_snativedigits, type, buffer, len )) != -1) return ret;
        return locale_return_strarray_concat( locale->snativedigits, type, buffer, len );
 
    case LOCALE_SCURRENCY:
        if ((ret = locale_return_reg_string( &entry_scurrency, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->scurrency, type, buffer, len );
 
    case LOCALE_SINTLSYMBOL:
        if ((ret = locale_return_reg_string( &entry_sintlsymbol, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->sintlsymbol, type, buffer, len );
 
    case LOCALE_SMONDECIMALSEP:
        if ((ret = locale_return_reg_string( &entry_smondecimalsep, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->smondecimalsep, type, buffer, len );
 
    case LOCALE_SMONTHOUSANDSEP:
        if ((ret = locale_return_reg_string( &entry_smonthousandsep, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->smonthousandsep, type, buffer, len );
 
    case LOCALE_SMONGROUPING:
        if ((ret = locale_return_reg_string( &entry_smongrouping, type, buffer, len )) != -1) return ret;
        return locale_return_grouping( locale->smongrouping, type, buffer, len );
 
    case LOCALE_ICURRDIGITS:
    case LOCALE_IINTLCURRDIGITS:
        if ((ret = locale_return_reg_number( &entry_icurrdigits, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->icurrdigits, type, buffer, len );
 
    case LOCALE_ICURRENCY:
        if ((ret = locale_return_reg_number( &entry_icurrency, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->icurrency, type, buffer, len );
 
    case LOCALE_INEGCURR:
        if ((ret = locale_return_reg_number( &entry_inegcurr, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->inegcurr, type, buffer, len );
 
    case LOCALE_SDATE:
        if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"dMy" ))) break;
        while (str[1] == str[0]) str++;  /* skip repeated chars */
        if (!(end = find_format( ++str, L"dMy" ))) break;
        *end++ = 0;
        return locale_return_data( str, end - str, type, buffer, len );
 
    case LOCALE_STIME:
        if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"Hhms" ))) break;
        while (str[1] == str[0]) str++;  /* skip repeated chars */
        if (!(end = find_format( ++str, L"Hhms" ))) break;
        *end++ = 0;
        return locale_return_data( str, end - str, type, buffer, len );
 
    case LOCALE_SSHORTDATE:
        if ((ret = locale_return_reg_string( &entry_sshortdate, type, buffer, len )) != -1) return ret;
        return locale_return_strarray( locale->sshortdate, 0, type, buffer, len );
 
    case LOCALE_SLONGDATE:
        if ((ret = locale_return_reg_string( &entry_slongdate, type, buffer, len )) != -1) return ret;
        return locale_return_strarray( locale->slongdate, 0, type, buffer, len );
 
    case LOCALE_IDATE:
        if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        /* if both year and day are found before month, the last one takes precedence */
        for (val = 0, str = find_format( tmp, L"dMy" ); str; str = find_format( str + 1, L"dMy" ))
        {
            if (*str == 'M') break;
            val = (*str == 'y' ? 2 : 1);
        }
        return locale_return_number( val, type, buffer, len );
 
    case LOCALE_ILDATE:
        if (!get_locale_info( locale, lcid, LOCALE_SLONGDATE | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        /* if both year and day are found before month, the last one takes precedence */
        for (val = 0, str = find_format( tmp, L"dMy" ); str; str = find_format( str + 1, L"dMy" ))
        {
            if (*str == 'M') break;
            val = (*str == 'y' ? 2 : 1);
        }
        return locale_return_number( val, type, buffer, len );
 
    case LOCALE_ITIME:
        if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"Hh" ))) break;
        return locale_return_number( *str == 'H', type, buffer, len );
 
    case LOCALE_ICENTURY:
        if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"y" ))) break;
        return locale_return_number( !wcsncmp( str, L"yyyy", 4 ), type, buffer, len );
 
    case LOCALE_ITLZERO:
        if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"Hh" ))) break;
        return locale_return_number( str[1] == str[0], type, buffer, len );
 
    case LOCALE_IDAYLZERO:
        if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"d" ))) break;
        return locale_return_number( str[1] == 'd', type, buffer, len );
 
    case LOCALE_IMONLZERO:
        if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"M" ))) break;
        return locale_return_number( str[1] == 'M', type, buffer, len );
 
    case LOCALE_S1159:
        if ((ret = locale_return_reg_string( &entry_s1159, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->s1159, type, buffer, len );
 
    case LOCALE_S2359:
        if ((ret = locale_return_reg_string( &entry_s2359, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->s2359, type, buffer, len );
 
    case LOCALE_SDAYNAME1:
    case LOCALE_SDAYNAME2:
    case LOCALE_SDAYNAME3:
    case LOCALE_SDAYNAME4:
    case LOCALE_SDAYNAME5:
    case LOCALE_SDAYNAME6:
    case LOCALE_SDAYNAME7:
        return locale_return_strarray( locale->sdayname,
                                       LOWORD(type - LOCALE_SDAYNAME1 + 1) % 7, type, buffer, len );
 
    case LOCALE_SABBREVDAYNAME1:
    case LOCALE_SABBREVDAYNAME2:
    case LOCALE_SABBREVDAYNAME3:
    case LOCALE_SABBREVDAYNAME4:
    case LOCALE_SABBREVDAYNAME5:
    case LOCALE_SABBREVDAYNAME6:
    case LOCALE_SABBREVDAYNAME7:
        return locale_return_strarray( locale->sabbrevdayname,
                                       LOWORD(type - LOCALE_SABBREVDAYNAME1 + 1) % 7, type, buffer, len );
 
    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:
        return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sgenitivemonth) ?
                                       locale->sgenitivemonth : locale->smonthname,
                                       type - LOCALE_SMONTHNAME1, type, buffer, len );
 
    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:
        return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sabbrevgenitivemonth) ?
                                       locale->sabbrevgenitivemonth : locale->sabbrevmonthname,
                                       type - LOCALE_SABBREVMONTHNAME1, type, buffer, len );
 
    case LOCALE_SPOSITIVESIGN:
        if ((ret = locale_return_reg_string( &entry_spositivesign, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->spositivesign, type, buffer, len );
 
    case LOCALE_SNEGATIVESIGN:
        if ((ret = locale_return_reg_string( &entry_snegativesign, type, buffer, len )) != -1) return ret;
        return locale_return_string( locale->snegativesign, type, buffer, len );
 
    case LOCALE_IPOSSIGNPOSN:
        if (!get_locale_info( locale, lcid,
                              LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
                              (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
        return locale_return_number( ipossignposn[val], type, buffer, len );
 
    case LOCALE_INEGSIGNPOSN:
        if (!get_locale_info( locale, lcid,
                              LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
                              (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
        return locale_return_number( inegsignposn[val], type, buffer, len );
 
    case LOCALE_IPOSSYMPRECEDES:
        if (!get_locale_info( locale, lcid,
                              LOCALE_ICURRENCY | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
                              (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
        return locale_return_number( !(val & 1), type, buffer, len );
 
    case LOCALE_IPOSSEPBYSPACE:
        if (!get_locale_info( locale, lcid,
                              LOCALE_ICURRENCY | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
                              (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
        return locale_return_number( !!(val & 2), type, buffer, len );
 
    case LOCALE_INEGSYMPRECEDES:
        if (!get_locale_info( locale, lcid,
                              LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
                              (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
        return locale_return_number( inegsymprecedes[val], type, buffer, len );
 
    case LOCALE_INEGSEPBYSPACE:
        if (!get_locale_info( locale, lcid,
                              LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
                              (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
        return locale_return_number( (val >= 8), type, buffer, len );
 
    case LOCALE_FONTSIGNATURE:
        return locale_return_data( locale_strings + locale->fontsignature + 1,
                                   locale_strings[locale->fontsignature], type, buffer, len );
 
    case LOCALE_SISO639LANGNAME:
        return locale_return_string( locale->siso639langname, type, buffer, len );
 
    case LOCALE_SISO3166CTRYNAME:
        return locale_return_string( locale->siso3166ctryname, type, buffer, len );
 
    case LOCALE_IGEOID:
        return locale_return_number( locale->igeoid, type, buffer, len );
 
    case LOCALE_SNAME:
        if (SORTIDFROMLCID(lcid))  /* custom sort locale */
        {
            const NLS_LOCALE_LCID_INDEX *entry = find_lcid_entry( lcid & ~0x80000000 );
            if (entry) return locale_return_string( entry->name, type, buffer, len );
        }
        return locale_return_string( locale->sname, type, buffer, len );
 
    case LOCALE_SDURATION:
        return locale_return_strarray( locale->sduration, 0, type, buffer, len );
 
    case LOCALE_SKEYBOARDSTOINSTALL:
        return locale_return_string( locale->skeyboardstoinstall, type, buffer, len );
 
    case LOCALE_SSHORTESTDAYNAME1:
    case LOCALE_SSHORTESTDAYNAME2:
    case LOCALE_SSHORTESTDAYNAME3:
    case LOCALE_SSHORTESTDAYNAME4:
    case LOCALE_SSHORTESTDAYNAME5:
    case LOCALE_SSHORTESTDAYNAME6:
    case LOCALE_SSHORTESTDAYNAME7:
        return locale_return_strarray( locale->sshortestdayname,
                                       LOWORD(type - LOCALE_SSHORTESTDAYNAME1 + 1) % 7, type, buffer, len );
 
    case LOCALE_SISO639LANGNAME2:
        return locale_return_string( locale->siso639langname2, type, buffer, len );
 
    case LOCALE_SISO3166CTRYNAME2:
        return locale_return_string( locale->siso3166ctryname2, type, buffer, len );
 
    case LOCALE_SNAN:
        return locale_return_string( locale->snan, type, buffer, len );
 
    case LOCALE_SPOSINFINITY:
        return locale_return_string( locale->sposinfinity, type, buffer, len );
 
    case LOCALE_SNEGINFINITY:
        return locale_return_string( locale->sneginfinity, type, buffer, len );
 
    case LOCALE_SSCRIPTS:
        return locale_return_string( locale->sscripts, type, buffer, len );
 
    case LOCALE_SPARENT:
        return locale_return_string( locale->sparent, type, buffer, len );
 
    case LOCALE_SCONSOLEFALLBACKNAME:
        return locale_return_string( locale->sconsolefallbackname, type, buffer, len );
 
    case LOCALE_SLOCALIZEDLANGUAGENAME:
        /* FIXME: localization */
        return locale_return_string( locale->senglanguage, type, buffer, len );
 
    case LOCALE_IREADINGLAYOUT:
        return locale_return_number( locale->ireadinglayout, type, buffer, len );
 
    case LOCALE_INEUTRAL:
        return locale_return_number( !locale->inotneutral, type, buffer, len );
 
    case LOCALE_SENGLISHDISPLAYNAME:
        return locale_return_string( locale->sengdisplayname, type, buffer, len );
 
    case LOCALE_SNATIVEDISPLAYNAME:
        return locale_return_string( locale->snativedisplayname, type, buffer, len );
 
    case LOCALE_INEGATIVEPERCENT:
        return locale_return_number( locale->inegativepercent, type, buffer, len );
 
    case LOCALE_IPOSITIVEPERCENT:
        return locale_return_number( locale->ipositivepercent, type, buffer, len );
 
    case LOCALE_SPERCENT:
        return locale_return_string( locale->spercent, type, buffer, len );
 
    case LOCALE_SPERMILLE:
        return locale_return_data( spermille, ARRAY_SIZE(spermille), type, buffer, len );
 
    case LOCALE_SMONTHDAY:
        return locale_return_strarray( locale->smonthday, 0, type, buffer, len );
 
    case LOCALE_SSHORTTIME:
        if ((ret = locale_return_reg_string( &entry_sshorttime, type, buffer, len )) != -1) return ret;
        return locale_return_strarray( locale->sshorttime, 0, type, buffer, len );
 
    case LOCALE_SOPENTYPELANGUAGETAG:
        return locale_return_string( locale->sopentypelanguagetag, type, buffer, len );
 
    case LOCALE_SSORTLOCALE:
        if (SORTIDFROMLCID(lcid))  /* custom sort locale */
        {
            const NLS_LOCALE_LCID_INDEX *entry = find_lcid_entry( lcid & ~0x80000000 );
            if (entry) return locale_return_string( entry->name, type, buffer, len );
        }
        return locale_return_string( locale->ssortlocale, type, buffer, len );
 
    case LOCALE_SRELATIVELONGDATE:
        return locale_return_string( locale->srelativelongdate, type, buffer, len );
 
    case 0x007d: /* undocumented */
        return locale_return_number( 0, type, buffer, len );
 
    case LOCALE_SSHORTESTAM:
        return locale_return_string( locale->sshortestam, type, buffer, len );
 
    case LOCALE_SSHORTESTPM:
        return locale_return_string( locale->sshortestpm, type, buffer, len );
 
    case LOCALE_SENGLANGUAGE:
        return locale_return_string( locale->senglanguage, type, buffer, len );
 
    case LOCALE_SENGCOUNTRY:
        return locale_return_string( locale->sengcountry, type, buffer, len );
 
    case LOCALE_STIMEFORMAT:
        if ((ret = locale_return_reg_string( &entry_stimeformat, type, buffer, len )) != -1) return ret;
        return locale_return_strarray( locale->stimeformat, 0, type, buffer, len );
 
    case LOCALE_IDEFAULTANSICODEPAGE:
        val = locale->idefaultansicodepage == CP_UTF8 ? CP_ACP : locale->idefaultansicodepage;
        return locale_return_number( val, type, buffer, len );
 
    case LOCALE_ITIMEMARKPOSN:
        if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
                              tmp, ARRAY_SIZE( tmp ))) break;
        if (!(str = find_format( tmp, L"Hhmst" ))) break;
        return locale_return_number( *str == 't', type, buffer, len );
 
    case LOCALE_SYEARMONTH:
        if ((ret = locale_return_reg_string( &entry_syearmonth, type, buffer, len )) != -1) return ret;
        return locale_return_strarray( locale->syearmonth, 0, type, buffer, len );
 
    case LOCALE_SENGCURRNAME:
        return locale_return_string( locale->sengcurrname, type, buffer, len );
 
    case LOCALE_SNATIVECURRNAME:
        return locale_return_string( locale->snativecurrname, type, buffer, len );
 
    case LOCALE_ICALENDARTYPE:
        if ((ret = locale_return_reg_number( &entry_icalendartype, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale_strings[locale->scalendartype + 1], type, buffer, len );
 
    case LOCALE_IPAPERSIZE:
        if ((ret = locale_return_reg_number( &entry_ipapersize, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->ipapersize, type, buffer, len );
 
    case LOCALE_IOPTIONALCALENDAR:
        return locale_return_number( locale_strings[locale->scalendartype + 2], type, buffer, len );
 
    case LOCALE_IFIRSTDAYOFWEEK:
        if ((ret = locale_return_reg_number( &entry_ifirstdayofweek, type, buffer, len )) != -1) return ret;
        return locale_return_number( (locale->ifirstdayofweek + 6) % 7, type, buffer, len );
 
    case LOCALE_IFIRSTWEEKOFYEAR:
        if ((ret = locale_return_reg_number( &entry_ifirstweekofyear, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->ifirstweekofyear, type, buffer, len );
 
    case LOCALE_SMONTHNAME13:
        return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sgenitivemonth) ?
                                       locale->sgenitivemonth : locale->smonthname,
                                       12, type, buffer, len );
 
    case LOCALE_SABBREVMONTHNAME13:
        return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sabbrevgenitivemonth) ?
                                       locale->sabbrevgenitivemonth : locale->sabbrevmonthname,
                                       12, type, buffer, len );
 
    case LOCALE_INEGNUMBER:
        if ((ret = locale_return_reg_number( &entry_inegnumber, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->inegnumber, type, buffer, len );
 
    case LOCALE_IDEFAULTMACCODEPAGE:
        val = locale->idefaultmaccodepage == CP_UTF8 ? CP_MACCP : locale->idefaultmaccodepage;
        return locale_return_number( val, type, buffer, len );
 
    case LOCALE_IDEFAULTEBCDICCODEPAGE:
        return locale_return_number( locale->idefaultebcdiccodepage, type, buffer, len );
 
    case LOCALE_SSORTNAME:
        sort = get_locale_sortname( lcid );
        return locale_return_data( sort, wcslen(sort) + 1, type, buffer, len );
 
    case LOCALE_IDIGITSUBSTITUTION:
        if ((ret = locale_return_reg_number( &entry_idigitsubstitution, type, buffer, len )) != -1) return ret;
        return locale_return_number( locale->idigitsubstitution, type, buffer, len );
    }
    SetLastError( ERROR_INVALID_FLAGS );
    return 0;
}

Referenced by get_currency_format(), get_date_format(), get_locale_info(), get_number_format(), get_time_format(), GetLocaleInfoA(), GetLocaleInfoEx(), GetLocaleInfoW(), GetSystemDefaultLocaleName(), GetUserDefaultLocaleName(), Internal_EnumDateFormats(), Internal_EnumTimeFormats(), LCIDToLocaleName(), SetLocaleInfoW(), and update_registry_value().

◆ get_locale_sortname()

static const WCHAR * get_locale_sortname ( LCID lcid )

static

Definition at line 1038 of file locale.c.

{
    switch (PRIMARYLANGID( lcid ))
    {
    case LANG_CHINESE:
        switch (SORTIDFROMLCID( lcid ))
        {
        case SORT_CHINESE_PRCP:
            switch (SUBLANGID( lcid ))
            {
            case SUBLANG_CHINESE_TRADITIONAL:
            case SUBLANG_CHINESE_HONGKONG:
            case 0x1f:
                return L"Stroke Count";
            default:
                return L"Pronunciation";
            }
        case SORT_CHINESE_UNICODE: return L"Unicode";
        case SORT_CHINESE_PRC: return L"Stroke Count";
        case SORT_CHINESE_BOPOMOFO: return L"Bopomofo";
        case SORT_CHINESE_RADICALSTROKE: return L"Radical/Stroke";
        case 5: return L"Surname";
        }
        break;
 
    case LANG_GEORGIAN:
        if (SORTIDFROMLCID( lcid ) == SORT_GEORGIAN_MODERN) return L"Modern";
        return L"Traditional";
 
    case LANG_GERMAN:
        switch (SUBLANGID( lcid ))
        {
        case SUBLANG_NEUTRAL:
        case SUBLANG_DEFAULT:
            if (SORTIDFROMLCID( lcid ) == SORT_GERMAN_PHONE_BOOK) return L"Phone Book (DIN)";
            return L"Dictionary";
        }
        break;
 
    case LANG_HUNGARIAN:
        if (SORTIDFROMLCID( lcid ) == SORT_HUNGARIAN_TECHNICAL) return L"Technical";
        break;
 
    case LANG_INVARIANT:
        if (SORTIDFROMLCID( lcid ) == SORT_INVARIANT_MATH) return L"Default";
        return L"Maths Alphanumerics";
 
    case LANG_JAPANESE:
        switch (SORTIDFROMLCID( lcid ))
        {
        case SORT_JAPANESE_XJIS: return L"XJIS";
        case SORT_JAPANESE_UNICODE: return L"Unicode";
        case SORT_JAPANESE_RADICALSTROKE: return L"Radical/Stroke";
        }
        break;
 
    case LANG_KOREAN:
        if (SORTIDFROMLCID( lcid ) == SORT_KOREAN_UNICODE) return L"Unicode";
        return L"Dictionary";
 
    case LANG_SPANISH:
        switch (SUBLANGID( lcid ))
        {
        case SUBLANG_NEUTRAL:
        case SUBLANG_SPANISH_MODERN:
            return L"International";
        case SUBLANG_DEFAULT:
            return L"Traditional";
        }
        break;
    }
    return L"Default";
}

Referenced by get_locale_info().

◆ get_message()

static const WCHAR * get_message	(	DWORD	flags,
		const void *	src,
		UINT	id,
		UINT	lang,
		BOOL	ansi,
		WCHAR **	buffer
	)

static

Definition at line 5347 of file locale.c.

{
    DWORD len;
 
    if (!(flags & FORMAT_MESSAGE_FROM_STRING))
    {
        const MESSAGE_RESOURCE_ENTRY *entry;
        NTSTATUS status = STATUS_INVALID_PARAMETER;
 
        if (flags & FORMAT_MESSAGE_FROM_HMODULE)
        {
            HMODULE module = (HMODULE)src;
            if (!module) module = GetModuleHandleW( 0 );
            status = RtlFindMessage( module, RT_MESSAGETABLE, lang, id, &entry );
        }
        if (status && (flags & FORMAT_MESSAGE_FROM_SYSTEM))
        {
            /* Fold win32 hresult to its embedded error code. */
            if (HRESULT_SEVERITY(id) == SEVERITY_ERROR && HRESULT_FACILITY(id) == FACILITY_WIN32)
                id = HRESULT_CODE( id );
            status = RtlFindMessage( kernelbase_handle, RT_MESSAGETABLE, lang, id, &entry );
        }
        if (!set_ntstatus( status )) return NULL;
 
        src = entry->Text;
        ansi = !(entry->Flags & MESSAGE_RESOURCE_UNICODE);
    }
 
    if (!ansi) return src;
    len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
    if (!(*buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
    MultiByteToWideChar( CP_ACP, 0, src, -1, *buffer, len );
    return *buffer;
}

Referenced by FormatMessageA(), and FormatMessageW().

◆ get_number_format()

static int get_number_format	(	const NLS_LOCALE_DATA *	locale,
		DWORD	flags,
		const WCHAR *	value,
		const NUMBERFMTW *	format,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 7650 of file locale.c.

{
    WCHAR *num, fmt_decimal[4], fmt_thousand[4], fmt_neg[5], grouping[24], output[256];
    const WCHAR *decimal_sep = fmt_decimal, *thousand_sep = fmt_thousand;
    DWORD digits, lzero, order;
    int ret = 0;
    BOOL negative = (*value == '-');
 
    flags &= LOCALE_NOUSEROVERRIDE;
 
    if (!format)
    {
        get_locale_info( locale, 0, LOCALE_SGROUPING | flags, grouping, ARRAY_SIZE(grouping) );
        get_locale_info( locale, 0, LOCALE_SDECIMAL | flags, fmt_decimal, ARRAY_SIZE(fmt_decimal) );
        get_locale_info( locale, 0, LOCALE_STHOUSAND | flags, fmt_thousand, ARRAY_SIZE(fmt_thousand) );
        get_locale_info( locale, 0, LOCALE_IDIGITS | LOCALE_RETURN_NUMBER | flags,
                         (WCHAR *)&digits, sizeof(DWORD)/sizeof(WCHAR) );
        get_locale_info( locale, 0, LOCALE_ILZERO | LOCALE_RETURN_NUMBER | flags,
                         (WCHAR *)&lzero, sizeof(DWORD)/sizeof(WCHAR) );
        get_locale_info( locale, 0, LOCALE_INEGNUMBER | LOCALE_RETURN_NUMBER | flags,
                         (WCHAR *)&order, sizeof(DWORD)/sizeof(WCHAR) );
    }
    else
    {
        if (flags)
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        decimal_sep = format->lpDecimalSep;
        thousand_sep = format->lpThousandSep;
        grouping_to_string( format->Grouping, grouping );
        digits = format->NumDigits;
        lzero = format->LeadingZero;
        order = format->NegativeOrder;
        if (!decimal_sep || !thousand_sep)
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
    }
 
    if (negative)
    {
        value++;
        get_locale_info( locale, 0, LOCALE_SNEGATIVESIGN | flags, fmt_neg, ARRAY_SIZE(fmt_neg) );
    }
 
    if (!(num = format_number( output + ARRAY_SIZE(output) - 6, value,
                               decimal_sep, thousand_sep, grouping, digits, lzero )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (negative)
    {
        switch (order)
        {
        case 0:  /* (1.1) */
            num = prepend_str( num, L"(" );
            wcscat( num, L")" );
            break;
        case 2:  /* - 1.1 */
            num = prepend_str( num, L" " );
            /* fall through */
        case 1:  /* -1.1 */
            num = prepend_str( num, fmt_neg );
            break;
        case 4:  /* 1.1 - */
            wcscat( num, L" " );
            /* fall through */
        case 3:  /* 1.1- */
            wcscat( num, fmt_neg );
            break;
        default:
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
    }
 
    ret = wcslen( num ) + 1;
    if (!len) return ret;
    lstrcpynW( buffer, num, len );
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return ret;
}

Referenced by GetNumberFormatEx(), and GetNumberFormatW().

◆ get_pattern_len()

static int get_pattern_len	(	const WCHAR *	pattern,
		const WCHAR *	accept
	)

static

Definition at line 7911 of file locale.c.

{
    int i;
 
    if (*pattern == '\'')
    {
        for (i = 1; pattern[i]; i++)
        {
            if (pattern[i] != '\'') continue;
            if (pattern[++i] != '\'') return i;
        }
        return i;
    }
    if (!wcschr( accept, *pattern )) return 1;
    for (i = 1; pattern[i]; i++) if (pattern[i] != pattern[0]) break;
    return i;
}

Referenced by get_date_format(), and get_time_format().

◆ get_sortkey()

static int get_sortkey	(	const struct sortguid *	sortid,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		BYTE *	dst,
		int	dstlen
	)

static

Definition at line 3778 of file locale.c.

{
    struct sortkey_state s;
    BYTE primary_buf[256];
    int ret = 0, pos = 0;
    BOOL have_extra;
    BYTE case_mask = 0x3f;
    UINT except = sortid->except;
    const WCHAR *compr_tables[8];
 
    compr_tables[0] = NULL;
    if (flags & NORM_IGNORECASE) case_mask &= ~(CASE_UPPER | CASE_SUBSCRIPT);
    if (flags & NORM_IGNOREWIDTH) case_mask &= ~CASE_FULLWIDTH;
    if (flags & NORM_IGNOREKANATYPE) case_mask &= ~CASE_KATAKANA;
    if ((flags & NORM_LINGUISTIC_CASING) && except && sortid->ling_except) except = sortid->ling_except;
 
    init_sortkey_state( &s, flags, srclen, primary_buf, sizeof(primary_buf) );
 
    while (pos < srclen)
        pos += append_weights( sortid, flags, src, srclen, pos, case_mask, except, compr_tables, &s, FALSE );
 
    have_extra = remove_unneeded_weights( sortid, &s );
 
    ret = put_sortkey( dst, dstlen, ret, &s.key_primary, 0x01 );
    ret = put_sortkey( dst, dstlen, ret, &s.key_diacritic, 0x01 );
    ret = put_sortkey( dst, dstlen, ret, &s.key_case, 0x01 );
 
    if (have_extra)
    {
        ret = put_sortkey( dst, dstlen, ret, &s.key_extra[0], 0xff );
        ret = put_sortkey( dst, dstlen, ret, &s.key_extra[1], 0x02 );
        ret = put_sortkey( dst, dstlen, ret, &s.key_extra[2], 0xff );
        ret = put_sortkey( dst, dstlen, ret, &s.key_extra[3], 0xff );
    }
    if (dstlen > ret) dst[ret] = 0x01;
    ret++;
 
    ret = put_sortkey( dst, dstlen, ret, &s.key_special, 0 );
 
    free_sortkey_state( &s );
 
    if (dstlen && dstlen < ret)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    if (flags & LCMAP_BYTEREV)
        map_byterev( (WCHAR *)dst, min( ret, dstlen ) / sizeof(WCHAR), (WCHAR *)dst );
    return ret;
}

Referenced by LCMapStringEx().

◆ get_time_format()

static int get_time_format	(	const NLS_LOCALE_DATA *	locale,
		DWORD	flags,
		const SYSTEMTIME *	systime,
		const WCHAR *	format,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 8055 of file locale.c.

{
    DWORD override = flags & LOCALE_NOUSEROVERRIDE;
    WCHAR *p, *last, fmt[80], output[256];
    SYSTEMTIME time;
    int i, ret, val, count;
    BOOL skip = FALSE;
 
    if (!format)
    {
        get_locale_info( locale, 0, LOCALE_STIMEFORMAT | override, fmt, ARRAY_SIZE(fmt) );
        format = fmt;
    }
    else if (override)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (systime)
    {
        time = *systime;
        if (time.wMilliseconds > 999 || time.wSecond > 59 || time.wMinute > 59 || time.wHour > 23)
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
    }
    else GetLocalTime( &time );
 
    for (p = last = output; *format; format += count)
    {
        count = get_pattern_len( format, L"Hhmst" );
 
        switch (*format)
        {
        case '\'':
            for (i = 1; i < count; i++)
            {
                if (format[i] == '\'') i++;
                if (!skip && i < count) *p++ = format[i];
            }
            continue;
 
        case 'H':
            val = time.wHour;
            break;
 
        case 'h':
            val = time.wHour;
            if (!(flags & TIME_FORCE24HOURFORMAT))
            {
                val %= 12;
                if (!val) val = 12;
            }
            break;
 
        case 'm':
            if (flags & TIME_NOMINUTESORSECONDS)
            {
                p = last;
                skip = TRUE;
                continue;
            }
            val = time.wMinute;
            break;
 
        case 's':
            if (flags & (TIME_NOMINUTESORSECONDS | TIME_NOSECONDS))
            {
                p = last;
                skip = TRUE;
                continue;
            }
            val = time.wSecond;
            break;
 
        case 't':
            if (flags & TIME_NOTIMEMARKER)
            {
                p = last;
                skip = TRUE;
                continue;
            }
            val = time.wHour < 12 ? LOCALE_S1159 : LOCALE_S2359;
            ret = get_locale_info( locale, 0, val | override, p, output + ARRAY_SIZE(output) - p );
            p += (count > 1) ? ret - 1 : 1;
            skip = FALSE;
            continue;
 
        default:
            if (!skip || *format == ' ') *p++ = *format;
            continue;
        }
 
        p += swprintf( p, output + ARRAY_SIZE(output) - p, L"%.*u", min( 2, count ), val );
        last = p;
        skip = FALSE;
    }
    *p++ = 0;
    ret = p - output;
 
    if (!len) return ret;
    lstrcpynW( buffer, output, len );
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return ret;
}

Referenced by GetTimeFormatEx(), and GetTimeFormatW().

◆ get_timezone_id()

static DWORD get_timezone_id	(	const TIME_ZONE_INFORMATION *	info,
		LARGE_INTEGER	time,
		BOOL	is_local
	)

static

Definition at line 4257 of file locale.c.

{
    int year;
    BOOL before_standard_date, after_daylight_date;
    LARGE_INTEGER t2;
    TIME_FIELDS tf;
 
    if (!info->DaylightDate.wMonth) return TIME_ZONE_ID_UNKNOWN;
 
    /* if year is 0 then date is in day-of-week format, otherwise it's absolute date */
    if (info->StandardDate.wMonth == 0 ||
        (info->StandardDate.wYear == 0 &&
         (info->StandardDate.wDay < 1 || info->StandardDate.wDay > 5 ||
          info->DaylightDate.wDay < 1 || info->DaylightDate.wDay > 5)))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return TIME_ZONE_ID_INVALID;
    }
 
    if (!is_local) time.QuadPart -= info->Bias * (LONGLONG)600000000;
    RtlTimeToTimeFields( &time, &tf );
    year = tf.Year;
    if (!is_local)
    {
        t2.QuadPart = time.QuadPart - info->DaylightBias * (LONGLONG)600000000;
        RtlTimeToTimeFields( &t2, &tf );
    }
    if (tf.Year == year)
        before_standard_date = compare_tzdate( &tf, &info->StandardDate ) < 0;
    else
        before_standard_date = tf.Year < year;
 
    if (!is_local)
    {
        t2.QuadPart = time.QuadPart - info->StandardBias * (LONGLONG)600000000;
        RtlTimeToTimeFields( &t2, &tf );
    }
    if (tf.Year == year)
        after_daylight_date = compare_tzdate( &tf, &info->DaylightDate ) >= 0;
    else
        after_daylight_date = tf.Year > year;
 
    if (info->DaylightDate.wMonth < info->StandardDate.wMonth) /* Northern hemisphere */
    {
        if (before_standard_date && after_daylight_date) return TIME_ZONE_ID_DAYLIGHT;
    }
    else /* Down south */
    {
        if (before_standard_date || after_daylight_date) return TIME_ZONE_ID_DAYLIGHT;
    }
    return TIME_ZONE_ID_STANDARD;
}

Referenced by GetDynamicTimeZoneInformation(), SystemTimeToTzSpecificLocalTime(), and TzSpecificLocalTimeToSystemTime().

◆ GetACP()

UINT WINAPI GetACP ( void )

Definition at line 5550 of file locale.c.

{
    return ansi_cpinfo.CodePage;
}

◆ GetCalendarInfoEx()

INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoEx	(	const WCHAR *	name,
		CALID	calendar,
		const WCHAR *	reserved,
		CALTYPE	type,
		WCHAR *	buffer,
		INT	len,
		DWORD *	value
	)

Definition at line 5634 of file locale.c.

{
    LCID lcid;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    TRACE( "%s %lu 0x%lx %p %d %p\n", debugstr_w(name), calendar, type, buffer, len, value );
 
    if (!locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    return get_calendar_info( locale, calendar, type, buffer, len, value );
}

◆ GetCalendarInfoW()

INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoW	(	LCID	lcid,
		CALID	calendar,
		CALTYPE	type,
		WCHAR *	buffer,
		INT	len,
		DWORD *	value
	)

Definition at line 5615 of file locale.c.

{
    const NLS_LOCALE_DATA *locale;
 
    TRACE( "%04lx %lu 0x%lx %p %d %p\n", lcid, calendar, type, buffer, len, value );
 
    if (!(locale = NlsValidateLocale( &lcid, 0 )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    return get_calendar_info( locale, calendar, type, buffer, len, value );
}

◆ GetCPInfo()

BOOL WINAPI DECLSPEC_HOTPATCH GetCPInfo	(	UINT	codepage,
		CPINFO *	cpinfo
	)

Definition at line 5559 of file locale.c.

{
    const CPTABLEINFO *table;
 
    if (!cpinfo || !(table = get_codepage_table( codepage )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    cpinfo->MaxCharSize = table->MaximumCharacterSize;
    memcpy( cpinfo->DefaultChar, &table->DefaultChar, sizeof(cpinfo->DefaultChar) );
    memcpy( cpinfo->LeadByte, table->LeadByte, sizeof(cpinfo->LeadByte) );
    return TRUE;
}

◆ GetCPInfoExW()

BOOL WINAPI GetCPInfoExW	(	UINT	codepage,
		DWORD	flags,
		CPINFOEXW *	cpinfo
	)

Definition at line 5578 of file locale.c.

{
    const CPTABLEINFO *table;
    int min, max, pos;
 
    if (!cpinfo || !(table = get_codepage_table( codepage )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    cpinfo->MaxCharSize = table->MaximumCharacterSize;
    memcpy( cpinfo->DefaultChar, &table->DefaultChar, sizeof(cpinfo->DefaultChar) );
    memcpy( cpinfo->LeadByte, table->LeadByte, sizeof(cpinfo->LeadByte) );
    cpinfo->CodePage = table->CodePage;
    cpinfo->UnicodeDefaultChar = table->UniDefaultChar;
 
    min = 0;
    max = ARRAY_SIZE(codepage_names) - 1;
    cpinfo->CodePageName[0] = 0;
    while (min <= max)
    {
        pos = (min + max) / 2;
        if (codepage_names[pos].cp < cpinfo->CodePage) min = pos + 1;
        else if (codepage_names[pos].cp > cpinfo->CodePage) max = pos - 1;
        else
        {
            wcscpy( cpinfo->CodePageName, codepage_names[pos].name );
            break;
        }
    }
    return TRUE;
}

◆ GetCurrencyFormatEx()

int WINAPI GetCurrencyFormatEx	(	const WCHAR *	name,
		DWORD	flags,
		const WCHAR *	value,
		const CURRENCYFMTW *	format,
		WCHAR *	buffer,
		int	len
	)

Definition at line 8230 of file locale.c.

{
    LCID lcid;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    if (len < 0 || (len && !buffer) || !value || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%s,%lx,%s,%p,%p,%d)\n", debugstr_w(name), flags, debugstr_w(value), format, buffer, len );
    return get_currency_format( locale, flags, value, format, buffer, len );
}

◆ GetCurrencyFormatW()

int WINAPI GetCurrencyFormatW	(	LCID	lcid,
		DWORD	flags,
		const WCHAR *	value,
		const CURRENCYFMTW *	format,
		WCHAR *	buffer,
		int	len
	)

Definition at line 8211 of file locale.c.

{
    const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, 0 );
 
    if (len < 0 || (len && !buffer) || !value || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%04lx,%lx,%s,%p,%p,%d)\n", lcid, flags, debugstr_w(value), format, buffer, len );
    return get_currency_format( locale, flags, value, format, buffer, len );
}

◆ GetDateFormatA()

int WINAPI GetDateFormatA	(	LCID	lcid,
		DWORD	flags,
		const SYSTEMTIME *	time,
		const char *	format,
		char *	buffer,
		int	len
	)

Definition at line 8250 of file locale.c.

{
    UINT cp = get_lcid_codepage( lcid, flags );
    WCHAR formatW[128], output[128];
    int ret;
 
    TRACE( "(0x%04lx,0x%08lx,%p,%s,%p,%d)\n", lcid, flags, time, debugstr_a(format), buffer, len );
 
    if (len < 0 || (len && !buffer))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (format)
    {
        MultiByteToWideChar( cp, 0, format, -1, formatW, ARRAY_SIZE(formatW) );
        ret = GetDateFormatW( lcid, flags, time, formatW, output, ARRAY_SIZE(output) );
    }
    else ret = GetDateFormatW( lcid, flags, time, NULL, output, ARRAY_SIZE(output) );
 
    if (ret) ret = WideCharToMultiByte( cp, 0, output, -1, buffer, len, 0, 0 );
    return ret;
}

Referenced by test_GetDateFormatA().

◆ GetDateFormatEx()

int WINAPI GetDateFormatEx	(	const WCHAR *	name,
		DWORD	flags,
		const SYSTEMTIME *	systime,
		const WCHAR *	format,
		WCHAR *	buffer,
		int	len,
		const WCHAR *	calendar
	)

Definition at line 8298 of file locale.c.

{
    LCID lcid;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    if (len < 0 || (len && !buffer) || !locale || calendar)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%s,%lx,%p,%s,%p,%d)\n", debugstr_w(name), flags, systime, debugstr_w(format), buffer, len );
    return get_date_format( locale, flags, systime, format, buffer, len );
}

Referenced by InitFunctionPointers().

◆ GetDateFormatW()

int WINAPI GetDateFormatW	(	LCID	lcid,
		DWORD	flags,
		const SYSTEMTIME *	systime,
		const WCHAR *	format,
		WCHAR *	buffer,
		int	len
	)

Definition at line 8279 of file locale.c.

{
    const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, 0 );
 
    if (len < 0 || (len && !buffer) || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%04lx,%lx,%p,%s,%p,%d)\n", lcid, flags, systime, debugstr_w(format), buffer, len );
    return get_date_format( locale, flags, systime, format, buffer, len );
}

Referenced by GetDateFormatA(), and test_GetDateFormatW().

◆ GetDynamicTimeZoneInformation()

DWORD WINAPI DECLSPEC_HOTPATCH GetDynamicTimeZoneInformation ( DYNAMIC_TIME_ZONE_INFORMATION * info )

Definition at line 5669 of file locale.c.

{
    HKEY key;
    LARGE_INTEGER now;
 
    if (!set_ntstatus( RtlQueryDynamicTimeZoneInformation( (RTL_DYNAMIC_TIME_ZONE_INFORMATION *)info )))
        return TIME_ZONE_ID_INVALID;
 
    RtlEnterCriticalSection( &tzname_section );
    if (cached_tzname.lcid == GetThreadLocale() &&
        !wcscmp( info->TimeZoneKeyName, cached_tzname.key_name ))
    {
        wcscpy( info->StandardName, cached_tzname.standard_name );
        wcscpy( info->DaylightName, cached_tzname.daylight_name );
        RtlLeaveCriticalSection( &tzname_section );
    }
    else
    {
        RtlLeaveCriticalSection( &tzname_section );
        if (!RegOpenKeyExW( tz_key, info->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key ))
        {
            RegLoadMUIStringW( key, L"MUI_Std", info->StandardName,
                               sizeof(info->StandardName), NULL, 0, system_dir );
            RegLoadMUIStringW( key, L"MUI_Dlt", info->DaylightName,
                               sizeof(info->DaylightName), NULL, 0, system_dir );
            RegCloseKey( key );
        }
        else return TIME_ZONE_ID_INVALID;
 
        RtlEnterCriticalSection( &tzname_section );
        cached_tzname.lcid = GetThreadLocale();
        wcscpy( cached_tzname.key_name, info->TimeZoneKeyName );
        wcscpy( cached_tzname.standard_name, info->StandardName );
        wcscpy( cached_tzname.daylight_name, info->DaylightName );
        RtlLeaveCriticalSection( &tzname_section );
    }
 
    NtQuerySystemTime( &now );
    return get_timezone_id( (TIME_ZONE_INFORMATION *)info, now, FALSE );
}

Referenced by GetTimeZoneInformation(), GetTimeZoneInformationForYear(), and init_locale().

◆ GetDynamicTimeZoneInformationEffectiveYears()

DWORD WINAPI DECLSPEC_HOTPATCH GetDynamicTimeZoneInformationEffectiveYears	(	const DYNAMIC_TIME_ZONE_INFORMATION *	info,
		DWORD *	first,
		DWORD *	last
	)

Definition at line 5714 of file locale.c.

{
    HKEY key, dst_key = 0;
    DWORD type, count, ret = ERROR_FILE_NOT_FOUND;
 
    if (RegOpenKeyExW( tz_key, info->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key )) return ret;
 
    if (RegOpenKeyExW( key, L"Dynamic DST", 0, KEY_ALL_ACCESS, &dst_key )) goto done;
    count = sizeof(DWORD);
    if (RegQueryValueExW( dst_key, L"FirstEntry", NULL, &type, (BYTE *)first, &count )) goto done;
    if (type != REG_DWORD) goto done;
    count = sizeof(DWORD);
    if (RegQueryValueExW( dst_key, L"LastEntry", NULL, &type, (BYTE *)last, &count )) goto done;
    if (type != REG_DWORD) goto done;
    ret = 0;
 
done:
    RegCloseKey( dst_key );
    RegCloseKey( key );
    return ret;
}

◆ GetFileMUIInfo()

BOOL WINAPI DECLSPEC_HOTPATCH GetFileMUIInfo	(	DWORD	flags,
		const WCHAR *	path,
		FILEMUIINFO *	info,
		DWORD *	size
	)

Definition at line 5796 of file locale.c.

{
    DWORD off, mui_size, type = MUI_FILETYPE_NOT_LANGUAGE_NEUTRAL;
    struct mui_resource *mui = NULL;
    HMODULE hmod;
    HRSRC hrsrc;
 
    TRACE( "%lu, %s, %p, %p\n", flags, debugstr_w(path), info, size );
 
    if (!path || !size || (*size && !info) ||
            (info && (*size < sizeof(*info) || info->dwSize != *size ||
                      info->dwVersion != MUI_FILEINFO_VERSION)))
    {
        if (size) *size = 0;
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (!flags) flags = MUI_QUERY_TYPE | MUI_QUERY_CHECKSUM;
 
    hmod = LoadLibraryExW( path, NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE );
    if (!hmod) return FALSE;
 
    hrsrc = FindResourceW( hmod, MAKEINTRESOURCEW(1), L"MUI" );
    if (hrsrc)
    {
        mui = LockResource( LoadResource(hmod, hrsrc) );
        if (mui) mui_size = SizeofResource( hmod, hrsrc );
        if (!mui || !validate_mui_resource( mui, mui_size ))
        {
            FreeLibrary( hmod );
            return FALSE;
        }
        if (mui->file_type & (MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN >> 1))
            type = MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN;
        else if (mui->file_type & (MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI >> 1))
            type = MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI;
    }
    if (type == MUI_FILETYPE_NOT_LANGUAGE_NEUTRAL)
    {
        FreeLibrary( hmod );
 
        if (!info)
        {
            *size = sizeof(*info);
            return TRUE;
        }
        if (info->dwSize < sizeof(*info))
        {
            SetLastError( ERROR_INSUFFICIENT_BUFFER );
            return FALSE;
        }
 
        memset( info, 0, sizeof(*info) );
        info->dwSize = *size;
        info->dwVersion = MUI_FILEINFO_VERSION;
        if (flags & MUI_QUERY_TYPE) info->dwFileType = type;
        return TRUE;
    }
 
    off = offsetof(FILEMUIINFO, abBuffer);
    if (flags & MUI_QUERY_LANGUAGE_NAME)
    {
        off += type == MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN ?
            mui->fallback_lang_size : mui->lang_size;
    }
    if (flags & MUI_QUERY_RESOURCE_TYPES)
    {
        if (type == MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN)
            off += mui->ln_type_name_size + mui->ln_type_id_size;
        off += mui->mui_type_name_size + mui->mui_type_id_size;
    }
    if (off < sizeof(*info)) off = sizeof(*info);
 
    if (!info || info->dwSize < off)
    {
        FreeLibrary( hmod );
        *size = off;
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return FALSE;
    }
 
    off = 0;
    memset( info, 0, sizeof(*info) );
    info->dwSize = *size;
    info->dwVersion = MUI_FILEINFO_VERSION;
    if (flags & MUI_QUERY_TYPE) info->dwFileType = type;
    if (flags & MUI_QUERY_CHECKSUM)
    {
        memcpy( info->pChecksum, mui->checksum, sizeof(info->pChecksum) );
        memcpy( info->pServiceChecksum, mui->service_checksum, sizeof(info->pServiceChecksum) );
    }
    if (flags & MUI_QUERY_LANGUAGE_NAME)
    {
        if (type == MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN && mui->fallback_lang_off)
        {
            info->dwLanguageNameOffset = offsetof(FILEMUIINFO, abBuffer);
            memcpy(info->abBuffer, ((BYTE *)mui) + mui->fallback_lang_off,
                    mui->fallback_lang_size);
            off += mui->fallback_lang_size;
        }
        if (type == MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI && mui->lang_off)
        {
            info->dwLanguageNameOffset = offsetof(FILEMUIINFO, abBuffer);
            memcpy(info->abBuffer, ((BYTE *)mui) + mui->lang_off, mui->lang_size);
            off += mui->lang_size;
        }
    }
    if (flags & MUI_QUERY_RESOURCE_TYPES && type & MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN)
    {
        if (mui->ln_type_id_size && mui->ln_type_id_off)
        {
            info->dwTypeIDMainSize = mui->ln_type_id_size / sizeof(DWORD);
            info->dwTypeIDMainOffset = offsetof(FILEMUIINFO, abBuffer[off]);
            memcpy(info->abBuffer + off, ((BYTE *)mui) + mui->ln_type_id_off, mui->ln_type_id_size);
            off += mui->ln_type_id_size;
        }
        if (mui->ln_type_name_off)
        {
            info->dwTypeNameMainOffset = offsetof(FILEMUIINFO, abBuffer[off]);
            memcpy(info->abBuffer + off, ((BYTE *)mui) + mui->ln_type_name_off, mui->ln_type_name_size);
            off += mui->ln_type_name_size;
        }
        if (mui->mui_type_id_size && mui->mui_type_id_off)
        {
            info->dwTypeIDMUISize = mui->mui_type_id_size / sizeof(DWORD);
            info->dwTypeIDMUIOffset = offsetof(FILEMUIINFO, abBuffer[off]);
            memcpy(info->abBuffer + off, ((BYTE *)mui) + mui->mui_type_id_off, mui->mui_type_id_size);
            off += mui->mui_type_id_size;
        }
        if (mui->mui_type_name_off)
        {
            info->dwTypeNameMUIOffset = offsetof(FILEMUIINFO, abBuffer[off]);
            memcpy(info->abBuffer + off, ((BYTE *)mui) + mui->mui_type_name_off, mui->mui_type_name_size);
            off += mui->mui_type_name_size;
        }
    }
    else if(flags & MUI_QUERY_RESOURCE_TYPES)
    {
        if (mui->ln_type_id_size && mui->ln_type_id_off)
        {
            info->dwTypeIDMUISize = mui->ln_type_id_size / sizeof(DWORD);
            info->dwTypeIDMUIOffset = offsetof(FILEMUIINFO, abBuffer[off]);
            memcpy(info->abBuffer + off, ((BYTE *)mui) + mui->ln_type_id_off, mui->ln_type_id_size);
            off += mui->ln_type_id_size;
        }
        if (mui->ln_type_name_off)
        {
            info->dwTypeNameMUIOffset = offsetof(FILEMUIINFO, abBuffer[off]);
            memcpy(info->abBuffer + off, ((BYTE *)mui) + mui->ln_type_name_off, mui->ln_type_name_size);
            off += mui->ln_type_name_size;
        }
    }
 
    FreeLibrary( hmod );
    return TRUE;
}

◆ GetFileMUIPath()

BOOL WINAPI GetFileMUIPath	(	DWORD	flags,
		const WCHAR *	filepath,
		WCHAR *	language,
		ULONG *	languagelen,
		WCHAR *	muipath,
		ULONG *	muipathlen,
		ULONGLONG *	enumerator
	)

Definition at line 5959 of file locale.c.

{
    FIXME( "stub: 0x%lx, %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;
}

◆ GetGeoInfoEx()

INT WINAPI DECLSPEC_HOTPATCH GetGeoInfoEx	(	WCHAR *	location,
		GEOTYPE	type,
		WCHAR *	data,
		int	data_count
	)

Definition at line 5989 of file locale.c.

{
    const struct geo_id *ptr = find_geo_name_entry( location );
 
    TRACE( "%s %lx %p %d\n", wine_dbgstr_w(location), type, data, data_count );
 
    if (!ptr)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (type == GEO_LCID || type == GEO_NATION || type == GEO_RFC1766)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    return get_geo_info( ptr, type, data, data_count, 0 );
}

Referenced by InitFunctionPointers().

◆ GetGeoInfoW()

INT WINAPI DECLSPEC_HOTPATCH GetGeoInfoW	(	GEOID	id,
		GEOTYPE	type,
		WCHAR *	data,
		int	count,
		LANGID	lang
	)

Definition at line 5974 of file locale.c.

{
    const struct geo_id *ptr = find_geo_id_entry( id );
 
    TRACE( "%ld %ld %p %d %d\n", id, type, data, count, lang );
 
    if (!ptr)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    return get_geo_info( ptr, type, data, count, lang );
}

◆ GetLocaleInfoA()

INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoA	(	LCID	lcid,
		LCTYPE	lctype,
		char *	buffer,
		INT	len
	)

Definition at line 6014 of file locale.c.

{
    const NLS_LOCALE_DATA *locale;
    WCHAR *bufferW;
    INT lenW, ret;
 
    TRACE( "lcid=0x%lx lctype=0x%lx %p %d\n", lcid, lctype, buffer, len );
 
    if (len < 0 || (len && !buffer))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (LOWORD(lctype) == LOCALE_SSHORTTIME || (lctype & LOCALE_RETURN_GENITIVE_NAMES))
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
    if (!(locale = NlsValidateLocale( &lcid, 0 )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (LOWORD(lctype) == LOCALE_FONTSIGNATURE || (lctype & LOCALE_RETURN_NUMBER))
    {
        ret = get_locale_info( locale, lcid, lctype, (WCHAR *)buffer, len / sizeof(WCHAR) );
        return ret * sizeof(WCHAR);
    }
 
    if (!(lenW = get_locale_info( locale, lcid, lctype, NULL, 0 ))) return 0;
 
    if (!(bufferW = RtlAllocateHeap( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return 0;
    }
    ret = get_locale_info( locale, lcid, lctype, bufferW, lenW );
    if (ret) ret = WideCharToMultiByte( get_locale_codepage( locale, lctype ), 0,
                                        bufferW, ret, buffer, len, NULL, NULL );
    RtlFreeHeap( GetProcessHeap(), 0, bufferW );
    return ret;
}

◆ GetLocaleInfoEx()

INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoEx	(	const WCHAR *	name,
		LCTYPE	info,
		WCHAR *	buffer,
		INT	len
	)

Definition at line 6085 of file locale.c.

{
    LCID lcid;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    TRACE( "%s 0x%lx %p %d\n", debugstr_w(name), info, buffer, len );
 
    if (!locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    return get_locale_info( locale, lcid, info, buffer, len );
}

◆ GetLocaleInfoW()

INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoW	(	LCID	lcid,
		LCTYPE	lctype,
		WCHAR *	buffer,
		INT	len
	)

Definition at line 6061 of file locale.c.

{
    const NLS_LOCALE_DATA *locale;
 
    if (len < 0 || (len && !buffer))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d)\n", lcid, lctype, buffer, len );
 
    if (!(locale = NlsValidateLocale( &lcid, 0 )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    return get_locale_info( locale, lcid, lctype, buffer, len );
}

◆ GetNLSVersion()

BOOL WINAPI DECLSPEC_HOTPATCH GetNLSVersion	(	NLS_FUNCTION	func,
		LCID	lcid,
		NLSVERSIONINFO *	info
	)

Definition at line 6104 of file locale.c.

{
    WCHAR locale[LOCALE_NAME_MAX_LENGTH];
 
    if (info->dwNLSVersionInfoSize < offsetof( NLSVERSIONINFO, dwEffectiveId ))
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return FALSE;
    }
    if (!LCIDToLocaleName( lcid, locale, LOCALE_NAME_MAX_LENGTH, LOCALE_ALLOW_NEUTRAL_NAMES ))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    return GetNLSVersionEx( func, locale, (NLSVERSIONINFOEX *)info );
}

Referenced by InitFunctionPointers().

◆ GetNLSVersionEx()

BOOL WINAPI DECLSPEC_HOTPATCH GetNLSVersionEx	(	NLS_FUNCTION	func,
		const WCHAR *	locale,
		NLSVERSIONINFOEX *	info
	)

Definition at line 6125 of file locale.c.

{
    const struct sortguid *sortid;
 
    if (func != COMPARE_STRING)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return FALSE;
    }
    if (info->dwNLSVersionInfoSize < sizeof(*info) &&
        (info->dwNLSVersionInfoSize != offsetof( NLSVERSIONINFO, dwEffectiveId )))
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return FALSE;
    }
 
    if (!(sortid = get_language_sort( locale ))) return FALSE;
 
    info->dwNLSVersion = info->dwDefinedVersion = sort.version;
    if (info->dwNLSVersionInfoSize >= sizeof(*info))
    {
        info->dwEffectiveId = LocaleNameToLCID( locale, 0 );
        info->guidCustomVersion = sortid->id;
    }
    return TRUE;
}

Referenced by GetNLSVersion(), InitFunctionPointers(), and IsValidNLSVersion().

◆ GetNumberFormatEx()

int WINAPI GetNumberFormatEx	(	const WCHAR *	name,
		DWORD	flags,
		const WCHAR *	value,
		const NUMBERFMTW *	format,
		WCHAR *	buffer,
		int	len
	)

Definition at line 8191 of file locale.c.

{
    LCID lcid;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    if (len < 0 || (len && !buffer) || !value || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%s,%lx,%s,%p,%p,%d)\n", debugstr_w(name), flags, debugstr_w(value), format, buffer, len );
    return get_number_format( locale, flags, value, format, buffer, len );
}

Referenced by InitFunctionPointers().

◆ GetNumberFormatW()

int WINAPI GetNumberFormatW	(	LCID	lcid,
		DWORD	flags,
		const WCHAR *	value,
		const NUMBERFMTW *	format,
		WCHAR *	buffer,
		int	len
	)

Definition at line 8172 of file locale.c.

{
    const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, 0 );
 
    if (len < 0 || (len && !buffer) || !value || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%04lx,%lx,%s,%p,%p,%d)\n", lcid, flags, debugstr_w(value), format, buffer, len );
    return get_number_format( locale, flags, value, format, buffer, len );
}

◆ GetOEMCP()

UINT WINAPI GetOEMCP ( void )

Definition at line 6157 of file locale.c.

{
    return oem_cpinfo.CodePage;
}

◆ GetProcessPreferredUILanguages()

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

Definition at line 6166 of file locale.c.

{
    return set_ntstatus( RtlGetProcessPreferredUILanguages( flags, count, buffer, size ));
}

◆ GetStringTypeA()

BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeA	(	LCID	locale,
		DWORD	type,
		const char *	src,
		int	count,
		WORD *	chartype
	)

Definition at line 6176 of file locale.c.

{
    UINT cp;
    INT countW;
    LPWSTR srcW;
    BOOL ret = FALSE;
 
    if (count == -1) count = strlen(src) + 1;
 
    cp = get_lcid_codepage( locale, 0 );
    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;
}

◆ GetStringTypeExW()

BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeExW	(	LCID	locale,
		DWORD	type,
		const WCHAR *	src,
		int	count,
		WORD *	chartype
	)

Definition at line 6230 of file locale.c.

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

◆ GetStringTypeW()

BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeW	(	DWORD	type,
		const WCHAR *	src,
		INT	count,
		WORD *	chartype
	)

Definition at line 6206 of file locale.c.

{
    if (!src)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (type != CT_CTYPE1 && type != CT_CTYPE2 && type != CT_CTYPE3)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (count == -1) count = lstrlenW(src) + 1;
 
    while (count--) *chartype++ = get_char_type( type, *src++ );
 
    return TRUE;
}

◆ GetSystemDefaultLangID()

LANGID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLangID ( void )

Definition at line 6250 of file locale.c.

{
    return LANGIDFROMLCID( GetSystemDefaultLCID() );
}

◆ GetSystemDefaultLCID()

LCID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLCID ( void )

Definition at line 6241 of file locale.c.

{
    return system_lcid;
}

◆ GetSystemDefaultLocaleName()

INT WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLocaleName	(	LPWSTR	name,
		INT	count
	)

Definition at line 6259 of file locale.c.

{
    return get_locale_info( system_locale, system_lcid, LOCALE_SNAME, name, count );
}

◆ GetSystemDefaultUILanguage()

LANGID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultUILanguage ( void )

Definition at line 6268 of file locale.c.

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

◆ GetSystemPreferredUILanguages()

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

Definition at line 6279 of file locale.c.

{
    return set_ntstatus( RtlGetSystemPreferredUILanguages( flags, 0, count, buffer, size ));
}

◆ GetThreadPreferredUILanguages()

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

Definition at line 6289 of file locale.c.

{
    return set_ntstatus( RtlGetThreadPreferredUILanguages( flags, count, buffer, size ));
}

◆ GetTimeFormatA()

int WINAPI GetTimeFormatA	(	LCID	lcid,
		DWORD	flags,
		const SYSTEMTIME *	time,
		const char *	format,
		char *	buffer,
		int	len
	)

Definition at line 8318 of file locale.c.

{
    UINT cp = get_lcid_codepage( lcid, flags );
    WCHAR formatW[128], output[128];
    int ret;
 
    TRACE( "(0x%04lx,0x%08lx,%p,%s,%p,%d)\n", lcid, flags, time, debugstr_a(format), buffer, len );
 
    if (len < 0 || (len && !buffer))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (format)
    {
        MultiByteToWideChar( cp, 0, format, -1, formatW, ARRAY_SIZE(formatW) );
        ret = GetTimeFormatW( lcid, flags, time, formatW, output, ARRAY_SIZE(output) );
    }
    else ret = GetTimeFormatW( lcid, flags, time, NULL, output, ARRAY_SIZE(output) );
 
    if (ret) ret = WideCharToMultiByte( cp, 0, output, -1, buffer, len, 0, 0 );
    return ret;
}

Referenced by test_GetTimeFormatA().

◆ GetTimeFormatEx()

int WINAPI GetTimeFormatEx	(	const WCHAR *	name,
		DWORD	flags,
		const SYSTEMTIME *	systime,
		const WCHAR *	format,
		WCHAR *	buffer,
		int	len
	)

Definition at line 8366 of file locale.c.

{
    LCID lcid;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    if (len < 0 || (len && !buffer) || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%s,%lx,%p,%s,%p,%d)\n", debugstr_w(name), flags, systime, debugstr_w(format), buffer, len );
    return get_time_format( locale, flags, systime, format, buffer, len );
}

Referenced by InitFunctionPointers().

◆ GetTimeFormatW()

int WINAPI GetTimeFormatW	(	LCID	lcid,
		DWORD	flags,
		const SYSTEMTIME *	systime,
		const WCHAR *	format,
		WCHAR *	buffer,
		int	len
	)

Definition at line 8347 of file locale.c.

{
    const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, 0 );
 
    if (len < 0 || (len && !buffer) || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    TRACE( "(%04lx,%lx,%p,%s,%p,%d)\n", lcid, flags, systime, debugstr_w(format), buffer, len );
    return get_time_format( locale, flags, systime, format, buffer, len );
}

Referenced by GetTimeFormatA().

◆ GetTimeZoneInformation()

DWORD WINAPI DECLSPEC_HOTPATCH GetTimeZoneInformation ( TIME_ZONE_INFORMATION * info )

Definition at line 6299 of file locale.c.

{
    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
    DWORD ret = GetDynamicTimeZoneInformation( &tzinfo );
 
    memcpy( info, &tzinfo, sizeof(*info) );
    return ret;
}

◆ GetTimeZoneInformationForYear()

BOOL WINAPI DECLSPEC_HOTPATCH GetTimeZoneInformationForYear	(	USHORT	year,
		DYNAMIC_TIME_ZONE_INFORMATION *	dynamic,
		TIME_ZONE_INFORMATION *	info
	)

Definition at line 6312 of file locale.c.

{
    DYNAMIC_TIME_ZONE_INFORMATION local_info;
    HKEY key = 0, dst_key;
    DWORD count;
    LRESULT ret;
    struct
    {
        LONG bias;
        LONG std_bias;
        LONG dlt_bias;
        SYSTEMTIME std_date;
        SYSTEMTIME dlt_date;
    } data;
 
    TRACE( "(%u,%p)\n", year, info );
 
    if (!dynamic)
    {
        if (GetDynamicTimeZoneInformation( &local_info ) == TIME_ZONE_ID_INVALID) return FALSE;
        dynamic = &local_info;
    }
 
    if ((ret = RegOpenKeyExW( tz_key, dynamic->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key ))) goto done;
    if (RegLoadMUIStringW( key, L"MUI_Std", info->StandardName,
                           sizeof(info->StandardName), NULL, 0, system_dir ))
    {
        count = sizeof(info->StandardName);
        if ((ret = RegQueryValueExW( key, L"Std", NULL, NULL, (BYTE *)info->StandardName, &count )))
            goto done;
    }
    if (RegLoadMUIStringW( key, L"MUI_Dlt", info->DaylightName,
                           sizeof(info->DaylightName), NULL, 0, system_dir ))
    {
        count = sizeof(info->DaylightName);
        if ((ret = RegQueryValueExW( key, L"Dlt", NULL, NULL, (BYTE *)info->DaylightName, &count )))
            goto done;
    }
 
    ret = ERROR_FILE_NOT_FOUND;
    if (!dynamic->DynamicDaylightTimeDisabled &&
        !RegOpenKeyExW( key, L"Dynamic DST", 0, KEY_ALL_ACCESS, &dst_key ))
    {
        WCHAR yearW[16];
        swprintf( yearW, ARRAY_SIZE(yearW), L"%u", year );
        count = sizeof(data);
        ret = RegQueryValueExW( dst_key, yearW, NULL, NULL, (BYTE *)&data, &count );
        RegCloseKey( dst_key );
    }
    if (ret)
    {
        count = sizeof(data);
        ret = RegQueryValueExW( key, L"TZI", NULL, NULL, (BYTE *)&data, &count );
    }
 
    if (!ret)
    {
        info->Bias = data.bias;
        info->StandardBias = data.std_bias;
        info->DaylightBias = data.dlt_bias;
        info->StandardDate = data.std_date;
        info->DaylightDate = data.dlt_date;
    }
 
done:
    RegCloseKey( key );
    if (ret) SetLastError( ret );
    return !ret;
}

Referenced by EnumDynamicTimeZoneInformation().

◆ GetUserDefaultGeoName()

INT WINAPI GetUserDefaultGeoName	(	LPWSTR	geo_name,
		int	count
	)

Definition at line 7425 of file locale.c.

{
    WCHAR buffer[32];
    LSTATUS status;
    DWORD size;
    HKEY key;
 
    TRACE( "geo_name %p, count %d.\n", geo_name, count );
 
    if (count && !geo_name)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (!(status = RegOpenKeyExW( intl_key, L"Geo", 0, KEY_ALL_ACCESS, &key )))
    {
        size = sizeof(buffer);
        status = RegQueryValueExW( key, L"Name", NULL, NULL, (BYTE *)buffer, &size );
        RegCloseKey( key );
    }
    if (status)
    {
        const struct geo_id *geo = find_geo_id_entry( GetUserGeoID( GEOCLASS_NATION ));
        if (geo && geo->id != 39070)
            lstrcpyW( buffer, geo->iso2 );
        else
            lstrcpyW( buffer, L"001" );
    }
    size = lstrlenW( buffer ) + 1;
    if (count < size)
    {
        if (!count)
            return size;
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    lstrcpyW( geo_name, buffer );
    return size;
}

Referenced by InitFunctionPointers().

◆ GetUserDefaultLangID()

LANGID WINAPI DECLSPEC_HOTPATCH GetUserDefaultLangID ( void )

Definition at line 6397 of file locale.c.

{
    return LANGIDFROMLCID( GetUserDefaultLCID() );
}

◆ GetUserDefaultLCID()

LCID WINAPI DECLSPEC_HOTPATCH GetUserDefaultLCID ( void )

Definition at line 6388 of file locale.c.

{
    return user_lcid;
}

◆ GetUserDefaultLocaleName()

INT WINAPI DECLSPEC_HOTPATCH GetUserDefaultLocaleName	(	LPWSTR	name,
		INT	len
	)

Definition at line 6406 of file locale.c.

{
    return get_locale_info( user_locale, user_lcid, LOCALE_SNAME, name, len );
}

◆ GetUserDefaultUILanguage()

LANGID WINAPI DECLSPEC_HOTPATCH GetUserDefaultUILanguage ( void )

Definition at line 6415 of file locale.c.

{
    return LANGIDFROMLCID( GetUserDefaultLCID() );
}

◆ GetUserGeoID()

GEOID WINAPI DECLSPEC_HOTPATCH GetUserGeoID ( GEOCLASS geoclass )

Definition at line 6424 of file locale.c.

{
    GEOID ret = 39070;
    const WCHAR *name;
    WCHAR bufferW[40];
    HKEY hkey;
 
    switch (geoclass)
    {
    case GEOCLASS_NATION:
        name = L"Nation";
        break;
    case GEOCLASS_REGION:
        name = L"Region";
        break;
    default:
        WARN("Unknown geoclass %ld\n", geoclass);
        return GEOID_NOT_AVAILABLE;
    }
    if (!RegOpenKeyExW( intl_key, L"Geo", 0, KEY_ALL_ACCESS, &hkey ))
    {
        DWORD count = sizeof(bufferW);
        if (!RegQueryValueExW( hkey, name, NULL, NULL, (BYTE *)bufferW, &count ))
            ret = wcstol( bufferW, NULL, 10 );
        RegCloseKey( hkey );
    }
    return ret;
}

◆ GetUserPreferredUILanguages()

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

Definition at line 6457 of file locale.c.

{
    return set_ntstatus( RtlGetUserPreferredUILanguages( flags, 0, count, buffer, size ));
}

◆ grouping_to_string()

static void grouping_to_string	(	UINT	grouping,
		WCHAR *	buffer
	)

static

Definition at line 7484 of file locale.c.

{
    UINT last_digit = grouping % 10;
    WCHAR tmp[10], *p = tmp;
 
    /* The string is confusingly different when it comes to repetitions (trailing zeros). For a string,
     * a 0 signals that the format needs to be repeated, which is the opposite of the grouping integer. */
    if (last_digit == 0)
    {
        grouping /= 10;
 
        /* Special case: two or more trailing zeros result in zero-sided groupings, with no repeats */
        if (grouping % 10 == 0)
            last_digit = ~0;
    }
 
    while (grouping)
    {
        *p++ = '0' + grouping % 10;
        grouping /= 10;
    }
    while (p > tmp)
    {
        *buffer++ = *(--p);
        if (p > tmp) *buffer++ = ';';
    }
    if (last_digit != 0)
    {
        *buffer++ = ';';
        *buffer++ = '0';
        if (last_digit == ~0)
        {
            /* Add another trailing zero due to the weird way trailing zeros work in grouping string */
            *buffer++ = ';';
            *buffer++ = '0';
        }
    }
    *buffer = 0;
}

Referenced by get_currency_format(), and get_number_format().

◆ IdnToAscii()

INT WINAPI DECLSPEC_HOTPATCH IdnToAscii	(	DWORD	flags,
		const WCHAR *	src,
		INT	srclen,
		WCHAR *	dst,
		INT	dstlen
	)

Definition at line 6467 of file locale.c.

{
    NTSTATUS status = RtlIdnToAscii( flags, src, srclen, dst, &dstlen );
    if (!set_ntstatus( status )) return 0;
    return dstlen;
}

◆ IdnToNameprepUnicode()

INT WINAPI DECLSPEC_HOTPATCH IdnToNameprepUnicode	(	DWORD	flags,
		const WCHAR *	src,
		INT	srclen,
		WCHAR *	dst,
		INT	dstlen
	)

Definition at line 6479 of file locale.c.

{
    NTSTATUS status = RtlIdnToNameprepUnicode( flags, src, srclen, dst, &dstlen );
    if (!set_ntstatus( status )) return 0;
    return dstlen;
}

◆ IdnToUnicode()

INT WINAPI DECLSPEC_HOTPATCH IdnToUnicode	(	DWORD	flags,
		const WCHAR *	src,
		INT	srclen,
		WCHAR *	dst,
		INT	dstlen
	)

Definition at line 6491 of file locale.c.

{
    NTSTATUS status = RtlIdnToUnicode( flags, src, srclen, dst, &dstlen );
    if (!set_ntstatus( status )) return 0;
    return dstlen;
}

◆ init_locale()

void init_locale ( HMODULE module )

Definition at line 1913 of file locale.c.

{
    USHORT utf8[2] = { 0, CP_UTF8 };
    USHORT *ansi_ptr, *oem_ptr;
    WCHAR bufferW[LOCALE_NAME_MAX_LENGTH];
    DYNAMIC_TIME_ZONE_INFORMATION timezone;
    const WCHAR *user_locale_name;
    DWORD count;
    SIZE_T size;
    HKEY hkey;
 
    kernelbase_handle = module;
    load_locale_nls();
    load_sortdefault_nls();
 
    if (system_lcid == LOCALE_CUSTOM_UNSPECIFIED) system_lcid = MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT );
    system_locale = NlsValidateLocale( &system_lcid, 0 );
 
    NtQueryDefaultLocale( TRUE, &user_lcid );
    if (!(user_locale = NlsValidateLocale( &user_lcid, 0 )))
    {
        if (GetEnvironmentVariableW( L"WINEUSERLOCALE", bufferW, ARRAY_SIZE(bufferW) ))
            user_locale = get_locale_by_name( bufferW, &user_lcid );
        if (!user_locale) user_locale = system_locale;
    }
    user_lcid = user_locale->ilanguage;
    if (user_lcid == LOCALE_CUSTOM_UNSPECIFIED) user_lcid = LOCALE_CUSTOM_DEFAULT;
 
    if (GetEnvironmentVariableW( L"WINEUNIXCP", bufferW, ARRAY_SIZE(bufferW) ))
        unix_cp = wcstoul( bufferW, NULL, 10 );
 
    NtGetNlsSectionPtr( 12, NormalizationC, NULL, (void **)&norm_info, &size );
 
    ansi_ptr = NtCurrentTeb()->Peb->AnsiCodePageData ? NtCurrentTeb()->Peb->AnsiCodePageData : utf8;
    oem_ptr = NtCurrentTeb()->Peb->OemCodePageData ? NtCurrentTeb()->Peb->OemCodePageData : utf8;
    RtlInitCodePageTable( ansi_ptr, &ansi_cpinfo );
    RtlInitCodePageTable( oem_ptr, &oem_cpinfo );
 
    RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\Nls",
                     0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &nls_key, NULL );
    RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones",
                     0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tz_key, NULL );
    RegCreateKeyExW( HKEY_CURRENT_USER, L"Control Panel\\International",
                     0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &intl_key, NULL );
 
    current_locale_sort = get_language_sort( LOCALE_NAME_USER_DEFAULT );
 
    if (GetDynamicTimeZoneInformation( &timezone ) != TIME_ZONE_ID_INVALID &&
        !RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\TimeZoneInformation",
                          0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
    {
        RegSetValueExW( hkey, L"StandardName", 0, REG_SZ, (BYTE *)timezone.StandardName,
                        (lstrlenW(timezone.StandardName) + 1) * sizeof(WCHAR) );
        RegSetValueExW( hkey, L"TimeZoneKeyName", 0, REG_SZ, (BYTE *)timezone.TimeZoneKeyName,
                        (lstrlenW(timezone.TimeZoneKeyName) + 1) * sizeof(WCHAR) );
        RegCloseKey( hkey );
    }
 
    /* Update registry contents if the user locale has changed.
     * This simulates the action of the Windows control panel. */
 
    user_locale_name = locale_strings + user_locale->sname + 1;
    count = sizeof(bufferW);
    if (!RegQueryValueExW( intl_key, L"LocaleName", NULL, NULL, (BYTE *)bufferW, &count ))
    {
        if (!wcscmp( bufferW, user_locale_name )) return; /* unchanged */
        TRACE( "updating registry, locale changed %s -> %s\n",
               debugstr_w(bufferW), debugstr_w(user_locale_name) );
    }
    else TRACE( "updating registry, locale changed none -> %s\n", debugstr_w(user_locale_name) );
 
    update_locale_registry();
 
    if (!RegCreateKeyExW( nls_key, L"Codepage",
                          0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
    {
        count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", GetACP() );
        RegSetValueExW( hkey, L"ACP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
        count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", GetOEMCP() );
        RegSetValueExW( hkey, L"OEMCP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
        count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", system_locale->idefaultmaccodepage );
        RegSetValueExW( hkey, L"MACCP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
        RegCloseKey( hkey );
    }
}

Referenced by DllMain().

◆ init_sortkey_state()

static void init_sortkey_state	(	struct sortkey_state *	s,
		DWORD	flags,
		UINT	srclen,
		BYTE *	primary_buf,
		UINT	primary_size
	)

static

Definition at line 3594 of file locale.c.

{
    /* buffer for secondary weights */
    BYTE *secondary_buf = s->buffer;
    UINT secondary_size;
 
    memset( s, 0, offsetof( struct sortkey_state, buffer ));
 
    s->key_primary.buf  = primary_buf;
    s->key_primary.size = primary_size;
 
    if (!(flags & NORM_IGNORENONSPACE))  /* reserve space for diacritics */
    {
        secondary_size = sizeof(s->buffer) / 3;
        s->key_diacritic.buf = secondary_buf;
        s->key_diacritic.size = secondary_size;
        secondary_buf += secondary_size;
    }
    else secondary_size = sizeof(s->buffer) / 2;
 
    s->key_case.buf = secondary_buf;
    s->key_case.size = secondary_size;
    s->key_special.buf = secondary_buf + secondary_size;
    s->key_special.size = secondary_size;
 
    s->key_primary.max = srclen * 8;
    s->key_case.max = srclen * 3;
    s->key_special.max = srclen * 4;
    s->key_extra[2].max = s->key_extra[3].max = srclen;
    if (!(flags & NORM_IGNORENONSPACE))
    {
        s->key_diacritic.max = srclen * 3;
        s->key_extra[0].max = s->key_extra[1].max = srclen;
    }
}

Referenced by compare_string(), find_substring(), and get_sortkey().

◆ Internal_EnumCalendarInfo()

BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumCalendarInfo	(	CALINFO_ENUMPROCW	proc,
		const NLS_LOCALE_DATA *	locale,
		CALID	id,
		CALTYPE	type,
		BOOL	unicode,
		BOOL	ex,
		BOOL	exex,
		LPARAM	lparam
	)

Definition at line 4318 of file locale.c.

{
    const USHORT *calendars;
    USHORT cal = id;
    WCHAR buffer[256];
    INT ret, i, count = 1;
 
    if (!proc || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (id == ENUM_ALL_CALENDARS)
    {
        count = locale_strings[locale->scalendartype];
        calendars = locale_strings + locale->scalendartype + 1;
    }
    else if (id <= CAL_UMALQURA)
    {
        calendars = &cal;
        count = 1;
    }
    else
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    type &= ~CAL_RETURN_NUMBER;
 
    for (i = 0; i < count; i++)
    {
        id = calendars[i];
        if (unicode)
        {
            ret = get_calendar_info( locale, id, type, buffer, ARRAY_SIZE(buffer), NULL );
        }
        else
        {
            WCHAR bufW[256];
            ret = get_calendar_info( locale, id, type, bufW, ARRAY_SIZE(bufW), NULL );
            if (ret) WideCharToMultiByte( get_locale_codepage( locale, type ), 0,
                                          bufW, -1, (char *)buffer, sizeof(buffer), NULL, NULL );
        }
 
        if (ret)
        {
            if (exex) ret = ((CALINFO_ENUMPROCEXEX)proc)( buffer, id, NULL, lparam );
            else if (ex) ret = ((CALINFO_ENUMPROCEXW)proc)( buffer, id );
            else ret = proc( buffer );
        }
        if (!ret) break;
    }
    return TRUE;
}

Referenced by EnumCalendarInfoExEx(), EnumCalendarInfoExW(), and EnumCalendarInfoW().

◆ Internal_EnumDateFormats()

BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumDateFormats	(	DATEFMT_ENUMPROCW	proc,
		const NLS_LOCALE_DATA *	locale,
		DWORD	flags,
		BOOL	unicode,
		BOOL	ex,
		BOOL	exex,
		LPARAM	lparam
	)

Definition at line 4398 of file locale.c.

{
    WCHAR buffer[256];
    INT i, j, ret;
    DWORD pos;
    const struct calendar *cal;
    const USHORT *calendars;
    const DWORD *array;
 
    if (!proc || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    calendars = locale_strings + locale->scalendartype;
 
    switch (flags & ~LOCALE_USE_CP_ACP)
    {
    case 0:
    case DATE_SHORTDATE:
        if (!get_locale_info( locale, 0, LOCALE_SSHORTDATE, buffer, ARRAY_SIZE(buffer) )) return FALSE;
        pos = locale->sshortdate;
        break;
    case DATE_LONGDATE:
        if (!get_locale_info( locale, 0, LOCALE_SLONGDATE, buffer, ARRAY_SIZE(buffer) )) return FALSE;
        pos = locale->slongdate;
        break;
    case DATE_YEARMONTH:
        if (!get_locale_info( locale, 0, LOCALE_SYEARMONTH, buffer, ARRAY_SIZE(buffer) )) return FALSE;
        pos = locale->syearmonth;
        break;
    default:
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    /* first the user override data */
 
    ret = call_enum_date_func( proc, locale, flags, 0, buffer, 1, unicode, ex, exex, lparam );
 
    /* then the remaining locale data */
 
    array = (const DWORD *)(locale_strings + pos + 1);
    for (i = 1; ret && i < locale_strings[pos]; i++)
        ret = call_enum_date_func( proc, locale, flags, array[i], buffer, 1, unicode, ex, exex, lparam );
 
    /* then the extra calendars */
 
    for (i = 0; ret && i < calendars[0]; i++)
    {
        if (calendars[i + 1] == 1) continue;
        if (!(cal = get_calendar_data( locale, calendars[i + 1] ))) continue;
        switch (flags & ~LOCALE_USE_CP_ACP)
        {
        case 0:
        case DATE_SHORTDATE:
            pos = cal->sshortdate;
            break;
        case DATE_LONGDATE:
            pos = cal->slongdate;
            break;
        case DATE_YEARMONTH:
            pos = cal->syearmonth;
            break;
        }
        array = (const DWORD *)(locale_strings + pos + 1);
        for (j = 0; ret && j < locale_strings[pos]; j++)
            ret = call_enum_date_func( proc, locale, flags, array[j], buffer,
                                       calendars[i + 1], unicode, ex, exex, lparam );
    }
    return TRUE;
}

Referenced by EnumDateFormatsExEx(), EnumDateFormatsExW(), and EnumDateFormatsW().

◆ Internal_EnumLanguageGroupLocales()

BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumLanguageGroupLocales	(	LANGGROUPLOCALE_ENUMPROCW	proc,
		LGRPID	id,
		DWORD	flags,
		LONG_PTR	param,
		BOOL	unicode
	)

Definition at line 4478 of file locale.c.

{
    WCHAR name[10], value[10];
    DWORD name_len, value_len, type, index = 0, alt = 0;
    HKEY key, altkey;
    LCID lcid;
 
    if (!proc || id < LGRPID_WESTERN_EUROPE || id > LGRPID_ARMENIAN)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    if (RegOpenKeyExW( nls_key, L"Locale", 0, KEY_READ, &key )) return FALSE;
    if (RegOpenKeyExW( key, L"Alternate Sorts", 0, KEY_READ, &altkey )) altkey = 0;
 
    for (;;)
    {
        name_len = ARRAY_SIZE(name);
        value_len = sizeof(value);
        if (RegEnumValueW( alt ? altkey : key, index++, name, &name_len, NULL,
                           &type, (BYTE *)value, &value_len ))
        {
            if (alt++) break;
            index = 0;
            continue;
        }
        if (type != REG_SZ) continue;
        if (id != wcstoul( value, NULL, 16 )) continue;
        lcid = wcstoul( name, NULL, 16 );
        if (!unicode)
        {
            char nameA[10];
            WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
            if (!((LANGGROUPLOCALE_ENUMPROCA)proc)( id, lcid, nameA, param )) break;
        }
        else if (!proc( id, lcid, name, param )) break;
    }
    RegCloseKey( altkey );
    RegCloseKey( key );
    return TRUE;
}

Referenced by EnumLanguageGroupLocalesW().

◆ Internal_EnumSystemCodePages()

BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumSystemCodePages	(	CODEPAGE_ENUMPROCW	proc,
		DWORD	flags,
		BOOL	unicode
	)

Definition at line 4526 of file locale.c.

{
    WCHAR name[10];
    DWORD name_len, type, index = 0;
    HKEY key;
 
    if (RegOpenKeyExW( nls_key, L"Codepage", 0, KEY_READ, &key )) return FALSE;
 
    for (;;)
    {
        name_len = ARRAY_SIZE(name);
        if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, NULL, NULL )) break;
        if (type != REG_SZ) continue;
        if (!wcstoul( name, NULL, 10 )) continue;
        if (!unicode)
        {
            char nameA[10];
            WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
            if (!((CODEPAGE_ENUMPROCA)proc)( nameA )) break;
        }
        else if (!proc( name )) break;
    }
    RegCloseKey( key );
    return TRUE;
}

Referenced by EnumSystemCodePagesW().

◆ Internal_EnumSystemLanguageGroups()

BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumSystemLanguageGroups	(	LANGUAGEGROUP_ENUMPROCW	proc,
		DWORD	flags,
		LONG_PTR	param,
		BOOL	unicode
	)

Definition at line 4557 of file locale.c.

{
    WCHAR name[10], value[10], descr[80];
    DWORD name_len, value_len, type, index = 0;
    HKEY key;
    LGRPID id;
 
    if (!proc)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    switch (flags)
    {
    case 0:
        flags = LGRPID_INSTALLED;
        break;
    case LGRPID_INSTALLED:
    case LGRPID_SUPPORTED:
        break;
    default:
        SetLastError( ERROR_INVALID_FLAGS );
        return FALSE;
    }
 
    if (RegOpenKeyExW( nls_key, L"Language Groups", 0, KEY_READ, &key )) return FALSE;
 
    for (;;)
    {
        name_len = ARRAY_SIZE(name);
        value_len = sizeof(value);
        if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, (BYTE *)value, &value_len )) break;
        if (type != REG_SZ) continue;
 
        id = wcstoul( name, NULL, 16 );
 
        if (!(flags & LGRPID_SUPPORTED) && !wcstoul( value, NULL, 10 )) continue;
        if (!LoadStringW( kernelbase_handle, id, descr, ARRAY_SIZE(descr) )) descr[0] = 0;
        TRACE( "%p: %lu %s %s %lx %Ix\n", proc, id, debugstr_w(name), debugstr_w(descr), flags, param );
        if (!unicode)
        {
            char nameA[10], descrA[80];
            WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
            WideCharToMultiByte( CP_ACP, 0, descr, -1, descrA, sizeof(descrA), NULL, NULL );
            if (!((LANGUAGEGROUP_ENUMPROCA)proc)( id, nameA, descrA, flags, param )) break;
        }
        else if (!proc( id, name, descr, flags, param )) break;
    }
    RegCloseKey( key );
    return TRUE;
}

Referenced by EnumSystemLanguageGroupsW().

◆ Internal_EnumTimeFormats()

BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumTimeFormats	(	TIMEFMT_ENUMPROCW	proc,
		const NLS_LOCALE_DATA *	locale,
		DWORD	flags,
		BOOL	unicode,
		BOOL	ex,
		LPARAM	lparam
	)

Definition at line 4615 of file locale.c.

{
    WCHAR buffer[256];
    INT ret = TRUE;
    const DWORD *array;
    DWORD pos, i;
 
    if (!proc || !locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    switch (flags & ~LOCALE_USE_CP_ACP)
    {
    case 0:
        if (!get_locale_info( locale, 0, LOCALE_STIMEFORMAT, buffer, ARRAY_SIZE(buffer) )) return FALSE;
        pos = locale->stimeformat;
        break;
    case TIME_NOSECONDS:
        if (!get_locale_info( locale, 0, LOCALE_SSHORTTIME, buffer, ARRAY_SIZE(buffer) )) return FALSE;
        pos = locale->sshorttime;
        break;
    default:
        FIXME( "Unknown time format %lx\n", flags );
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    array = (const DWORD *)(locale_strings + pos + 1);
    for (i = 0; ret && i < locale_strings[pos]; i++)
    {
        if (i) memcpy( buffer, locale_strings + array[i] + 1,
                       (locale_strings[array[i]] + 1) * sizeof(WCHAR) );
 
        if (ex) ret = ((TIMEFMT_ENUMPROCEX)proc)( buffer, lparam );
        else if (unicode) ret = proc( buffer );
        else
        {
            char buffA[256];
            WideCharToMultiByte( get_locale_codepage( locale, flags ), 0, buffer, -1,
                                 buffA, ARRAY_SIZE(buffA), NULL, NULL );
            ret = proc( (WCHAR *)buffA );
        }
    }
    return TRUE;
}

Referenced by EnumTimeFormatsEx(), and EnumTimeFormatsW().

◆ Internal_EnumUILanguages()

BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumUILanguages	(	UILANGUAGE_ENUMPROCW	proc,
		DWORD	flags,
		LONG_PTR	param,
		BOOL	unicode
	)

Definition at line 4668 of file locale.c.

{
    WCHAR nameW[LOCALE_NAME_MAX_LENGTH];
    char nameA[LOCALE_NAME_MAX_LENGTH];
    DWORD i;
 
    if (!proc)
    {
    SetLastError( ERROR_INVALID_PARAMETER );
    return FALSE;
    }
    if (flags & ~(MUI_LANGUAGE_ID | MUI_LANGUAGE_NAME))
    {
    SetLastError( ERROR_INVALID_FLAGS );
    return FALSE;
    }
 
    for (i = 0; i < locale_table->nb_lcnames; i++)
    {
        if (!lcnames_index[i].name) continue;  /* skip invariant locale */
        if (lcnames_index[i].id & 0x80000000) continue;  /* skip aliases */
        if (!get_locale_data( lcnames_index[i].idx )->inotneutral) continue;  /* skip neutral locales */
        if (SORTIDFROMLCID( lcnames_index[i].id )) continue;  /* skip alternate sorts */
        if (flags & MUI_LANGUAGE_NAME)
        {
            const WCHAR *str = locale_strings + lcnames_index[i].name;
 
            if (unicode)
            {
                memcpy( nameW, str + 1, (*str + 1) * sizeof(WCHAR) );
                if (!proc( nameW, param )) break;
            }
            else
            {
                WideCharToMultiByte( CP_ACP, 0, str + 1, -1, nameA, sizeof(nameA), NULL, NULL );
                if (!((UILANGUAGE_ENUMPROCA)proc)( nameA, param )) break;
            }
        }
        else
        {
            if (lcnames_index[i].id == LOCALE_CUSTOM_UNSPECIFIED) continue;  /* skip locales with no lcid */
            if (unicode)
            {
                swprintf( nameW, ARRAY_SIZE(nameW), L"%04lx", lcnames_index[i].id );
                if (!proc( nameW, param )) break;
            }
            else
            {
                sprintf( nameA, "%04x", lcnames_index[i].id );
                if (!((UILANGUAGE_ENUMPROCA)proc)( nameA, param )) break;
            }
        }
    }
    return TRUE;
}

Referenced by EnumUILanguagesW().

◆ is_private_use_area_char()

static int is_private_use_area_char ( WCHAR code )

inlinestatic

Definition at line 2509 of file locale.c.

{
    return (code >= 0xe000 && code <= 0xf8ff);
}

Referenced by check_invalid_chars(), and IsNLSDefinedString().

◆ is_valid_dbcs_mapping()

static int is_valid_dbcs_mapping	(	const CPTABLEINFO *	info,
		DWORD	flags,
		unsigned int	wch
	)

inlinestatic

Definition at line 3021 of file locale.c.

{
    const unsigned short *table = info->WideCharTable;
    unsigned short ch;
 
    if (wch >= 0x10000) return 0;
    ch = table[wch];
    if ((flags & WC_NO_BEST_FIT_CHARS) || ch == info->DefaultChar)
    {
        if (ch >> 8) return info->DBCSOffsets[info->DBCSOffsets[ch >> 8] + (ch & 0xff)] == wch;
        return info->MultiByteTable[ch] == wch;
    }
    return 1;
}

Referenced by wcstombs_dbcs_slow().

◆ is_valid_sbcs_mapping()

static int is_valid_sbcs_mapping	(	const CPTABLEINFO *	info,
		DWORD	flags,
		unsigned int	wch
	)

inlinestatic

Definition at line 3010 of file locale.c.

{
    const unsigned char *table = info->WideCharTable;
 
    if (wch >= 0x10000) return 0;
    if ((flags & WC_NO_BEST_FIT_CHARS) || table[wch] == info->DefaultChar)
        return (info->MultiByteTable[table[wch]] == wch);
    return 1;
}

Referenced by wcstombs_sbcs_slow().

◆ IsCharAlphaA()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaA ( CHAR c )

Definition at line 6503 of file locale.c.

{
    WCHAR wc;
    DWORD reslen;
    RtlMultiByteToUnicodeN( &wc, sizeof(WCHAR), &reslen, &c, 1 );
    return reslen && (get_char_type( CT_CTYPE1, wc ) & C1_ALPHA);
}

◆ IsCharAlphaNumericA()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaNumericA ( CHAR c )

Definition at line 6524 of file locale.c.

{
    WCHAR wc;
    DWORD reslen;
    RtlMultiByteToUnicodeN( &wc, sizeof(WCHAR), &reslen, &c, 1 );
    return reslen && (get_char_type( CT_CTYPE1, wc ) & (C1_ALPHA | C1_DIGIT));
}

◆ IsCharAlphaNumericW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaNumericW ( WCHAR wc )

Definition at line 6536 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & (C1_ALPHA | C1_DIGIT));
}

Referenced by txt_export_binary().

◆ IsCharAlphaW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaW ( WCHAR wc )

Definition at line 6515 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_ALPHA);
}

◆ IsCharBlankW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharBlankW ( WCHAR wc )

Definition at line 6545 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_BLANK);
}

◆ IsCharCntrlW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharCntrlW ( WCHAR wc )

Definition at line 6554 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_CNTRL);
}

◆ IsCharDigitW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharDigitW ( WCHAR wc )

Definition at line 6563 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_DIGIT);
}

◆ IsCharLowerA()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharLowerA ( CHAR c )

Definition at line 6572 of file locale.c.

{
    WCHAR wc;
    DWORD reslen;
    RtlMultiByteToUnicodeN( &wc, sizeof(WCHAR), &reslen, &c, 1 );
    return reslen && (get_char_type( CT_CTYPE1, wc ) & C1_LOWER);
}

◆ IsCharLowerW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharLowerW ( WCHAR wc )

Definition at line 6584 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_LOWER);
}

◆ IsCharPunctW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharPunctW ( WCHAR wc )

Definition at line 6593 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_PUNCT);
}

◆ IsCharSpaceA()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharSpaceA ( CHAR c )

Definition at line 6602 of file locale.c.

{
    WCHAR wc;
    DWORD reslen;
    RtlMultiByteToUnicodeN( &wc, sizeof(WCHAR), &reslen, &c, 1 );
    return reslen && (get_char_type( CT_CTYPE1, wc ) & C1_SPACE);
}

◆ IsCharSpaceW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharSpaceW ( WCHAR wc )

Definition at line 6614 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_SPACE);
}

◆ IsCharUpperA()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharUpperA ( CHAR c )

Definition at line 6623 of file locale.c.

{
    WCHAR wc;
    DWORD reslen;
    RtlMultiByteToUnicodeN( &wc, sizeof(WCHAR), &reslen, &c, 1 );
    return reslen && (get_char_type( CT_CTYPE1, wc ) & C1_UPPER);
}

◆ IsCharUpperW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharUpperW ( WCHAR wc )

Definition at line 6635 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_UPPER);
}

◆ IsCharXDigitW()

BOOL WINAPI DECLSPEC_HOTPATCH IsCharXDigitW ( WCHAR wc )

Definition at line 6644 of file locale.c.

{
    return !!(get_char_type( CT_CTYPE1, wc ) & C1_XDIGIT);
}

◆ IsDBCSLeadByte()

BOOL WINAPI DECLSPEC_HOTPATCH IsDBCSLeadByte ( BYTE testchar )

Definition at line 6653 of file locale.c.

{
    return ansi_cpinfo.DBCSCodePage && ansi_cpinfo.DBCSOffsets[testchar];
}

◆ IsDBCSLeadByteEx()

BOOL WINAPI DECLSPEC_HOTPATCH IsDBCSLeadByteEx	(	UINT	codepage,
		BYTE	testchar
	)

Definition at line 6662 of file locale.c.

{
    const CPTABLEINFO *table = get_codepage_table( codepage );
    return table && table->DBCSCodePage && table->DBCSOffsets[testchar];
}

◆ IsNLSDefinedString()

BOOL WINAPI DECLSPEC_HOTPATCH IsNLSDefinedString	(	NLS_FUNCTION	func,
		DWORD	flags,
		NLSVERSIONINFO *	info,
		const WCHAR *	str,
		int	len
	)

Definition at line 6749 of file locale.c.

{
    int i;
 
    if (func != COMPARE_STRING)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return FALSE;
    }
    if (info)
    {
        if (info->dwNLSVersionInfoSize != sizeof(*info) &&
            (info->dwNLSVersionInfoSize != offsetof( NLSVERSIONINFO, dwEffectiveId )))
        {
            SetLastError( ERROR_INSUFFICIENT_BUFFER );
            return FALSE;
        }
    }
 
    if (len < 0) len = lstrlenW( str ) + 1;
 
    for (i = 0; i < len; i++)
    {
        if (is_private_use_area_char( str[i] )) return FALSE;
        if (IS_LOW_SURROGATE( str[i] )) return FALSE;
        if (IS_HIGH_SURROGATE( str[i] ))
        {
            if (++i == len) return FALSE;
            if (!IS_LOW_SURROGATE( str[i] )) return FALSE;
            continue;
        }
        if (!(get_char_type( CT_CTYPE1, str[i] ) & C1_DEFINED)) return FALSE;
    }
    return TRUE;
}

Referenced by InitFunctionPointers().

◆ IsNormalizedString()

BOOL WINAPI DECLSPEC_HOTPATCH IsNormalizedString	(	NORM_FORM	form,
		const WCHAR *	str,
		INT	len
	)

Definition at line 6672 of file locale.c.

{
    BOOLEAN res;
    if (!set_ntstatus( RtlIsNormalizedString( form, str, len, &res ))) res = FALSE;
    return res;
}

◆ IsValidCodePage()

BOOL WINAPI DECLSPEC_HOTPATCH IsValidCodePage ( UINT codepage )

Definition at line 6683 of file locale.c.

{
    switch (codepage)
    {
    case CP_ACP:
    case CP_OEMCP:
    case CP_MACCP:
    case CP_THREAD_ACP:
        return FALSE;
    default:
        return get_codepage_table( codepage ) != NULL;
    }
}

◆ IsValidLanguageGroup()

BOOL WINAPI DECLSPEC_HOTPATCH IsValidLanguageGroup	(	LGRPID	id,
		DWORD	flags
	)

Definition at line 6701 of file locale.c.

{
    WCHAR name[10], value[10];
    DWORD type, value_len = sizeof(value);
    BOOL ret = FALSE;
    HKEY key;
 
    if (RegOpenKeyExW( nls_key, L"Language Groups", 0, KEY_READ, &key )) return FALSE;
 
    swprintf( name, ARRAY_SIZE(name), L"%x", id );
    if (!RegQueryValueExW( key, name, NULL, &type, (BYTE *)value, &value_len ) && type == REG_SZ)
        ret = (flags & LGRPID_SUPPORTED) || wcstoul( value, NULL, 10 );
 
    RegCloseKey( key );
    return ret;
}

◆ IsValidLocale()

BOOL WINAPI DECLSPEC_HOTPATCH IsValidLocale	(	LCID	lcid,
		DWORD	flags
	)

Definition at line 6722 of file locale.c.

{
    switch (lcid)
    {
    case LOCALE_NEUTRAL:
    case LOCALE_USER_DEFAULT:
    case LOCALE_SYSTEM_DEFAULT:
        return FALSE;
    default:
        return !!NlsValidateLocale( &lcid, LOCALE_ALLOW_NEUTRAL_NAMES );
    }
}

◆ IsValidLocaleName()

BOOL WINAPI DECLSPEC_HOTPATCH IsValidLocaleName ( const WCHAR * locale )

Definition at line 6739 of file locale.c.

{
    if (locale == LOCALE_NAME_USER_DEFAULT) return FALSE;
    return !!find_lcname_entry( locale );
}

◆ IsValidNLSVersion()

DWORD WINAPI DECLSPEC_HOTPATCH IsValidNLSVersion	(	NLS_FUNCTION	func,
		const WCHAR *	locale,
		NLSVERSIONINFOEX *	info
	)

Definition at line 6790 of file locale.c.

{
    static const GUID GUID_NULL;
    NLSVERSIONINFOEX infoex;
    DWORD ret;
 
    if (func != COMPARE_STRING)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (info->dwNLSVersionInfoSize < sizeof(*info) &&
        (info->dwNLSVersionInfoSize != offsetof( NLSVERSIONINFO, dwEffectiveId )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    infoex.dwNLSVersionInfoSize = sizeof(infoex);
    if (!GetNLSVersionEx( func, locale, &infoex )) return FALSE;
 
    ret = (infoex.dwNLSVersion & ~0xff) == (info->dwNLSVersion & ~0xff);
    if (ret && !IsEqualGUID( &info->guidCustomVersion, &GUID_NULL ))
        ret = find_sortguid( &info->guidCustomVersion ) != NULL;
 
    if (!ret) SetLastError( ERROR_SUCCESS );
    return ret;
}

Referenced by InitFunctionPointers().

◆ LCIDToLocaleName()

INT WINAPI DECLSPEC_HOTPATCH LCIDToLocaleName	(	LCID	lcid,
		WCHAR *	name,
		INT	count,
		DWORD	flags
	)

Definition at line 6823 of file locale.c.

{
    const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, flags );
 
    if (!locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    return get_locale_info( locale, lcid, LOCALE_SNAME, name, count );
}

◆ lcmap_string()

static int lcmap_string	(	const struct sortguid *	sortid,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 4136 of file locale.c.

{
    const USHORT *case_table = NULL;
    int ret;
 
    if (flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE))
    {
        if ((flags & LCMAP_TITLECASE) == LCMAP_TITLECASE)  /* FIXME */
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        case_table = sort.casemap + (flags & LCMAP_LINGUISTIC_CASING ? sortid->casemap : 0);
        case_table = case_table + 2 + (flags & LCMAP_LOWERCASE ? case_table[1] : 0);
    }
 
    switch (flags & ~(LCMAP_BYTEREV | LCMAP_LOWERCASE | LCMAP_UPPERCASE | LCMAP_LINGUISTIC_CASING))
    {
    case LCMAP_HIRAGANA:
        ret = casemap_string( charmaps[CHARMAP_HIRAGANA], src, srclen, dst, dstlen );
        break;
    case LCMAP_KATAKANA:
        ret = casemap_string( charmaps[CHARMAP_KATAKANA], src, srclen, dst, dstlen );
        break;
    case LCMAP_HALFWIDTH:
        ret = map_to_halfwidth( NULL, src, srclen, dst, dstlen );
        break;
    case LCMAP_HIRAGANA | LCMAP_HALFWIDTH:
        ret = map_to_halfwidth( charmaps[CHARMAP_HIRAGANA], src, srclen, dst, dstlen );
        break;
    case LCMAP_KATAKANA | LCMAP_HALFWIDTH:
        ret = map_to_halfwidth( charmaps[CHARMAP_KATAKANA], src, srclen, dst, dstlen );
        break;
    case LCMAP_FULLWIDTH:
        ret = map_to_fullwidth( NULL, src, srclen, dst, dstlen );
        break;
    case LCMAP_HIRAGANA | LCMAP_FULLWIDTH:
        ret = map_to_fullwidth( charmaps[CHARMAP_HIRAGANA], src, srclen, dst, dstlen );
        break;
    case LCMAP_KATAKANA | LCMAP_FULLWIDTH:
        ret = map_to_fullwidth( charmaps[CHARMAP_KATAKANA], src, srclen, dst, dstlen );
        break;
    case LCMAP_SIMPLIFIED_CHINESE:
        ret = casemap_string( charmaps[CHARMAP_SIMPLIFIED], src, srclen, dst, dstlen );
        break;
    case LCMAP_TRADITIONAL_CHINESE:
        ret = casemap_string( charmaps[CHARMAP_TRADITIONAL], src, srclen, dst, dstlen );
        break;
    case NORM_IGNORENONSPACE:
    case NORM_IGNORESYMBOLS:
    case NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS:
        if (flags & ~(NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS | LCMAP_BYTEREV))
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        ret = map_remove_ignored( flags, src, srclen, dst, dstlen );
        break;
    case 0:
        if (case_table)
        {
            ret = casemap_string( case_table, src, srclen, dst, dstlen );
            case_table = NULL;
            break;
        }
        if (flags & LCMAP_BYTEREV)
        {
            ret = min( srclen, dstlen );
            memcpy( dst, src, ret * sizeof(WCHAR) );
            break;
        }
        /* fall through */
    default:
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (dstlen && case_table) ret = casemap_string( case_table, dst, ret, dst, dstlen );
    if (flags & LCMAP_BYTEREV) map_byterev( dst, min( dstlen, ret ), dst );
 
    if (dstlen && dstlen < ret)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return ret;
}

Referenced by LCMapStringEx().

◆ LCMapStringA()

INT WINAPI DECLSPEC_HOTPATCH LCMapStringA	(	LCID	lcid,
		DWORD	flags,
		const char *	src,
		int	srclen,
		char *	dst,
		int	dstlen
	)

Definition at line 6894 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;
    }
 
    locale_cp = get_lcid_codepage( lcid, flags );
 
    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 done;
        }
        ret = LCMapStringW( lcid, flags, srcW, srclenW, (WCHAR *)dst, dstlen );
        goto done;
    }
 
    if (flags & SORT_STRINGSORT)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        goto done;
    }
 
    dstlenW = LCMapStringW( lcid, flags, srcW, srclenW, NULL, 0 );
    if (!dstlenW) goto done;
 
    dstW = HeapAlloc( GetProcessHeap(), 0, dstlenW * sizeof(WCHAR) );
    if (!dstW)
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        goto done;
    }
    LCMapStringW( lcid, flags, srcW, srclenW, dstW, dstlenW );
    ret = WideCharToMultiByte( locale_cp, 0, dstW, dstlenW, dst, dstlen, NULL, NULL );
    HeapFree( GetProcessHeap(), 0, dstW );
 
done:
    if (srcW != bufW) HeapFree( GetProcessHeap(), 0, srcW );
    return ret;
}

◆ LCMapStringEx()

INT WINAPI DECLSPEC_HOTPATCH LCMapStringEx	(	const WCHAR *	locale,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen,
		NLSVERSIONINFO *	version,
		void *	reserved,
		LPARAM	handle
	)

Definition at line 6839 of file locale.c.

{
    const struct sortguid *sortid = NULL;
 
    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 (flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE | LCMAP_SORTKEY))
    {
        if (!(sortid = get_language_sort( locale ))) return 0;
    }
    if (flags & LCMAP_HASH)
    {
        FIXME( "LCMAP_HASH %s not supported\n", debugstr_wn( src, srclen ));
        return 0;
    }
    if (flags & LCMAP_SORTHANDLE)
    {
        FIXME( "LCMAP_SORTHANDLE not supported\n" );
        return 0;
    }
    if (flags & LCMAP_SORTKEY) return get_sortkey( sortid, flags, src, srclen, (BYTE *)dst, dstlen );
 
    return lcmap_string( sortid, flags, src, srclen, dst, dstlen );
}

◆ LCMapStringW()

INT WINAPI DECLSPEC_HOTPATCH LCMapStringW	(	LCID	lcid,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

Definition at line 6963 of file locale.c.

{
    const WCHAR *locale = LOCALE_NAME_USER_DEFAULT;
    const NLS_LOCALE_LCID_INDEX *entry;
 
    switch (lcid)
    {
    case LOCALE_NEUTRAL:
    case LOCALE_USER_DEFAULT:
    case LOCALE_SYSTEM_DEFAULT:
    case LOCALE_CUSTOM_DEFAULT:
    case LOCALE_CUSTOM_UNSPECIFIED:
    case LOCALE_CUSTOM_UI_DEFAULT:
        break;
    default:
        if (lcid == user_lcid || lcid == system_lcid) break;
        if (!(entry = find_lcid_entry( lcid )))
        {
            WARN( "unknown locale %04lx\n", lcid );
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        locale = locale_strings + entry->name + 1;
        break;
    }
 
    return LCMapStringEx( locale, flags, src, srclen, dst, dstlen, NULL, NULL, 0 );
}

◆ load_locale_nls()

static void load_locale_nls ( void )

static

Definition at line 439 of file locale.c.

{
    struct
    {
        UINT ctypes;
        UINT unknown1;
        UINT unknown2;
        UINT unknown3;
        UINT locales;
        UINT charmaps;
        UINT geoids;
        UINT scripts;
    } *header;
    struct geo_header
    {
        WCHAR signature[4];  /* L"geo" */
        UINT  total_size;
        UINT  ids_offset;
        UINT  ids_count;
        UINT  index_offset;
        UINT  index_count;
    } *geo_header;
 
    LARGE_INTEGER dummy;
    const USHORT *map_ptr;
    unsigned int i;
 
    RtlGetLocaleFileMappingAddress( (void **)&header, &system_lcid, &dummy );
    locale_table = (const NLS_LOCALE_HEADER *)((char *)header + header->locales);
    lcids_index = (const NLS_LOCALE_LCID_INDEX *)((char *)locale_table + locale_table->lcids_offset);
    lcnames_index = (const NLS_LOCALE_LCNAME_INDEX *)((char *)locale_table + locale_table->lcnames_offset);
    locale_strings = (const WCHAR *)((char *)locale_table + locale_table->strings_offset);
    geo_header = (struct geo_header *)((char *)header + header->geoids);
    geo_ids = (const struct geo_id *)((char *)geo_header + geo_header->ids_offset);
    geo_index = (const struct geo_index *)((char *)geo_header + geo_header->index_offset);
    geo_ids_count = geo_header->ids_count;
    geo_index_count = geo_header->index_count;
    map_ptr = (const USHORT *)((char *)header + header->charmaps);
    for (i = 0; i < NB_CHARMAPS; i++, map_ptr += *map_ptr) charmaps[i] = map_ptr + 1;
}

Referenced by init_locale().

◆ load_sortdefault_nls()

static void load_sortdefault_nls ( void )

static

Definition at line 481 of file locale.c.

{
    const struct
    {
        UINT sortkeys;
        UINT casemaps;
        UINT ctypes;
        UINT sortids;
    } *header;
 
    const WORD *ctype;
    const UINT *table;
    UINT i;
    SIZE_T size;
    const struct sort_compression *last_compr;
 
    NtGetNlsSectionPtr( 9, 0, NULL, (void **)&header, &size );
 
    sort.keys = (UINT *)((char *)header + header->sortkeys);
    sort.casemap = (USHORT *)((char *)header + header->casemaps);
 
    ctype = (WORD *)((char *)header + header->ctypes);
    sort.ctypes = ctype + 2;
    sort.ctype_idx = (BYTE *)ctype + ctype[1] + 2;
 
    table = (UINT *)((char *)header + header->sortids);
    sort.version = table[0];
    sort.guid_count = table[1];
    sort.guids = (struct sortguid *)(table + 2);
 
    table = (UINT *)(sort.guids + sort.guid_count);
    sort.exp_count = table[0];
    sort.expansions = (struct sort_expansion *)(table + 1);
 
    table = (UINT *)(sort.expansions + sort.exp_count);
    sort.compr_count = table[0];
    sort.compressions = (struct sort_compression *)(table + 1);
    sort.compr_data = (WCHAR *)(sort.compressions + sort.compr_count);
 
    last_compr = sort.compressions + sort.compr_count - 1;
    table = (UINT *)(sort.compr_data + last_compr->offset);
    for (i = 0; i < 7; i++) table += last_compr->len[i] * ((i + 5) / 2);
    table += 1 + table[0] / 2;  /* skip multiple weights */
    sort.jamo = (struct jamo_sort *)(table + 1);
 
    locale_sorts = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                    locale_table->nb_lcnames * sizeof(*locale_sorts) );
}

Referenced by init_locale().

◆ locale_replace_separator()

static WCHAR * locale_replace_separator	(	WCHAR *	buffer,
		const WCHAR *	sep
	)

static

Definition at line 1014 of file locale.c.

{
    UINT pos = 0;
    WCHAR res[80];
    WCHAR *next, *str = find_format( buffer, L"dMyHhms" );
 
    if (!str) return buffer;
    pos = str - buffer;
    memcpy( res, buffer, pos * sizeof(WCHAR) );
    for (;;)
    {
        res[pos++] = *str++;
        while (str[0] == str[-1]) res[pos++] = *str++;  /* copy repeated chars */
        if (!(next = find_format( str, L"dMyHhms" ))) break;
        wcscpy( res + pos, sep );
        pos += wcslen(sep);
        str = next;
    }
    wcscpy( res + pos, str );
    return wcscpy( buffer, res );
}

Referenced by SetLocaleInfoW().

◆ locale_return_data()

static int locale_return_data	(	const WCHAR *	data,
		int	datalen,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 754 of file locale.c.

{
    if (type & LOCALE_RETURN_NUMBER)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
    if (!len) return datalen;
    if (datalen > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    memcpy( buffer, data, datalen * sizeof(WCHAR) );
    return datalen;
}

Referenced by cal_return_number(), get_locale_info(), locale_return_reg_string(), and locale_return_string().

◆ locale_return_grouping()

static int locale_return_grouping	(	DWORD	pos,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 903 of file locale.c.

{
    WORD i, count = locale_strings[pos];
    const WCHAR *str = locale_strings + pos + 1;
    int ret;
 
    if (type & LOCALE_RETURN_NUMBER)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
    ret = 2 * count;
    if (str[count - 1]) ret += 2;  /* for final zero */
 
    if (!len) return ret;
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    for (i = 0; i < count; i++)
    {
        if (!str[i])  /* explicit null termination */
        {
            buffer[-1] = 0;
            return ret;
        }
        *buffer++ = '0' + str[i];
        *buffer++ = ';';
    }
    *buffer++ = '0';
    *buffer = 0;
    return ret;
}

Referenced by get_locale_info().

◆ locale_return_number()

static int locale_return_number	(	UINT	val,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 845 of file locale.c.

{
    int ret;
    WCHAR tmp[80];
 
    if (!(type & LOCALE_RETURN_NUMBER))
    {
        switch (LOWORD(type))
        {
        case LOCALE_ILANGUAGE:
        case LOCALE_IDEFAULTLANGUAGE:
            ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%04x", val ) + 1;
            break;
        case LOCALE_IDEFAULTEBCDICCODEPAGE:
            ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%03u", val ) + 1;
            break;
        default:
            ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%u", val ) + 1;
            break;
        }
    }
    else ret = sizeof(UINT) / sizeof(WCHAR);
 
    if (!len) return ret;
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
 
    if (type & LOCALE_RETURN_NUMBER) memcpy( buffer, &val, sizeof(val) );
    else wcscpy( buffer, tmp );
 
    return ret;
}

Referenced by get_locale_info(), and locale_return_reg_number().

◆ locale_return_reg_number()

static int locale_return_reg_number	(	struct registry_entry *	entry,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 882 of file locale.c.

{
    int ret, val;
    WCHAR *end, tmp[80];
 
    if (type & LOCALE_RETURN_NUMBER)
    {
        ret = locale_return_reg_string( entry, type & ~LOCALE_RETURN_NUMBER, tmp, ARRAY_SIZE( tmp ));
        if (ret == -1) return ret;
        val = wcstol( tmp, &end, 10 );
        if (*end)  /* invalid number */
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        return locale_return_number( val, type, buffer, len );
    }
    return locale_return_reg_string( entry, type, buffer, len );
}

Referenced by get_locale_info().

◆ locale_return_reg_string()

static int locale_return_reg_string	(	struct registry_entry *	entry,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 797 of file locale.c.

{
    DWORD size;
    LRESULT res;
    int ret = -1;
 
    if (type & LOCALE_NOUSEROVERRIDE) return -1;
 
    RtlEnterCriticalSection( &locale_section );
    switch (entry->status)
    {
    case NOT_CACHED:
        size = sizeof(entry->data);
        if (entry->subkey)
        {
            HKEY key;
            if (!(res = RegOpenKeyExW( intl_key, entry->subkey, 0, KEY_READ, &key )))
            {
                res = RegQueryValueExW( key, entry->value, NULL, NULL, (BYTE *)entry->data, &size );
                RegCloseKey( key );
            }
        }
        else res = RegQueryValueExW( intl_key, entry->value, NULL, NULL, (BYTE *)entry->data, &size );
 
        if (res)
        {
            entry->status = MISSING;
            break;
        }
        entry->status = CACHED;
        /* fall through */
    case CACHED:
        ret = locale_return_data( entry->data, wcslen(entry->data) + 1, type, buffer, len );
        break;
    case MISSING:
        break;
    }
    RtlLeaveCriticalSection( &locale_section );
    return ret;
}

Referenced by get_locale_info(), and locale_return_reg_number().

◆ locale_return_strarray()

static int locale_return_strarray	(	DWORD	pos,
		WORD	idx,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 939 of file locale.c.

{
    const DWORD *array = (const DWORD *)(locale_strings + pos + 1);
    WORD count = locale_strings[pos];
 
    return locale_return_string( idx < count ? array[idx] : 0, type, buffer, len );
}

Referenced by get_calendar_info(), and get_locale_info().

◆ locale_return_strarray_concat()

static int locale_return_strarray_concat	(	DWORD	pos,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 948 of file locale.c.

{
    WORD i, count = locale_strings[pos];
    const DWORD *array = (const DWORD *)(locale_strings + pos + 1);
    int ret;
 
    if (type & LOCALE_RETURN_NUMBER)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
    for (i = 0, ret = 1; i < count; i++) ret += locale_strings[array[i]];
 
    if (!len) return ret;
    if (ret > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    for (i = 0; i < count; i++)
    {
        memcpy( buffer, locale_strings + array[i] + 1, locale_strings[array[i]] * sizeof(WCHAR) );
        buffer += locale_strings[array[i]];
    }
    *buffer = 0;
    return ret;
}

Referenced by get_locale_info().

◆ locale_return_string()

static int locale_return_string	(	DWORD	pos,
		LCTYPE	type,
		WCHAR *	buffer,
		int	len
	)

static

Definition at line 839 of file locale.c.

{
    return locale_return_data( locale_strings + pos + 1, locale_strings[pos] + 1, type, buffer, len );
}

Referenced by get_calendar_info(), get_date_format(), get_locale_info(), and locale_return_strarray().

◆ LocaleNameToLCID()

LCID WINAPI DECLSPEC_HOTPATCH LocaleNameToLCID	(	const WCHAR *	name,
		DWORD	flags
	)

Definition at line 6997 of file locale.c.

{
    LCID lcid;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    if (!locale)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (!(flags & LOCALE_ALLOW_NEUTRAL_NAMES) && !locale->inotneutral)
        lcid = locale->idefaultlanguage;
    return lcid;
}

◆ map_byterev()

static void map_byterev	(	const WCHAR *	src,
		int	len,
		WCHAR *	dst
	)

inlinestatic

Definition at line 2044 of file locale.c.

{
    while (len--) *dst++ = RtlUshortByteSwap( *src++ );
}

Referenced by get_sortkey(), and lcmap_string().

◆ map_remove_ignored()

static int map_remove_ignored	(	DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 4054 of file locale.c.

{
    int pos;
 
    for (pos = 0; srclen; src++, srclen--)
    {
        if (flags & NORM_IGNORESYMBOLS)
        {
            if (get_char_type( CT_CTYPE1, *src ) & C1_PUNCT) continue;
            if (get_char_type( CT_CTYPE3, *src ) & C3_SYMBOL) continue;
        }
        if (flags & NORM_IGNORENONSPACE)
        {
            WCHAR buffer[8];
            const WCHAR *decomp;
            unsigned int i, j, len;
 
            if ((decomp = get_decomposition( *src, &len )) && len > 1)
            {
                for (i = j = 0; i < len; i++)
                    if (!nonspace_ignored( decomp[i] )) buffer[j++] = decomp[i];
 
                if (i > j)  /* something was removed */
                {
                    if (pos + j <= dstlen) memcpy( dst + pos, buffer, j * sizeof(WCHAR) );
                    pos += j;
                    continue;
                }
            }
            else if (nonspace_ignored( *src )) continue;
        }
        if (pos < dstlen) dst[pos] = *src;
        pos++;
    }
    return pos;
}

Referenced by lcmap_string().

◆ map_to_fullwidth()

static int map_to_fullwidth	(	const USHORT *	table,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 3989 of file locale.c.

{
    int pos, len;
 
    for (pos = 0; srclen; pos++, src += len, srclen -= len)
    {
        unsigned int wch = casemap( charmaps[CHARMAP_FULLWIDTH], *src );
 
        len = 1;
        if (srclen > 1)
        {
            if (table_has_high_planes( charmaps[CHARMAP_FULLWIDTH] ) && IS_SURROGATE_PAIR( src[0], src[1] ))
            {
                len = 2;
                wch = casemap_high( charmaps[CHARMAP_FULLWIDTH], src[0], src[1] );
                if (wch >= 0x10000)
                {
                    put_utf16( dst, pos, dstlen, wch );
                    pos++;
                    continue;
                }
            }
            else if (src[1] == 0xff9e)  /* dakuten (voiced sound) */
            {
                len = 2;
                if ((*src >= 0xff76 && *src <= 0xff84) ||
                    (*src >= 0xff8a && *src <= 0xff8e) ||
                    *src == 0x30fd)
                    wch++;
                else if (*src == 0xff73)
                    wch = 0x30f4; /* KATAKANA LETTER VU */
                else if (*src == 0xff9c)
                    wch = 0x30f7; /* KATAKANA LETTER VA */
                else if (*src == 0x30f0)
                    wch = 0x30f8; /* KATAKANA LETTER VI */
                else if (*src == 0x30f1)
                    wch = 0x30f9; /* KATAKANA LETTER VE */
                else if (*src == 0xff66)
                    wch = 0x30fa; /* KATAKANA LETTER VO */
                else
                    len = 1;
            }
            else if (src[1] == 0xff9f)  /* handakuten (semi-voiced sound) */
            {
                if (*src >= 0xff8a && *src <= 0xff8e)
                {
                    wch += 2;
                    len = 2;
                }
            }
        }
 
        if (pos < dstlen) dst[pos] = table ? casemap( table, wch ) : wch;
    }
    return pos;
}

Referenced by lcmap_string().

◆ map_to_halfwidth()

static int map_to_halfwidth	(	const USHORT *	table,
		const WCHAR *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 4093 of file locale.c.

{
    static const BYTE katakana_map[] =
    {
                                0x01, 0x00, 0x01, 0x00, /* U+30a8- */
        0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, /* U+30b0- */
        0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, /* U+30b8- */
        0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, /* U+30c0- */
        0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* U+30c8- */
        0x01, 0x02, 0x00, 0x01, 0x02, 0x00, 0x01, 0x02, /* U+30d0- */
        0x00, 0x01, 0x02, 0x00, 0x01, 0x02, 0x00, 0x00, /* U+30d8- */
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* U+30e0- */
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* U+30e8- */
        0x00, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x08, /* U+30f0- */
        0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x01        /* U+30f8- */
    };
    int pos;
 
    for (pos = 0; srclen; src++, srclen--)
    {
        WCHAR ch = table ? casemap( table, *src ) : *src;
        USHORT shift = ch - 0x30ac;
        BYTE k;
 
        if (shift < ARRAY_SIZE(katakana_map) && (k = katakana_map[shift]))
        {
            if (pos < dstlen - 1)
            {
                dst[pos] = casemap( charmaps[CHARMAP_HALFWIDTH], ch - k );
                dst[pos + 1] = (k == 2) ? 0xff9f : 0xff9e;
            }
            pos += 2;
        }
        else
        {
            if (pos < dstlen) dst[pos] = casemap( charmaps[CHARMAP_HALFWIDTH], ch );
            pos++;
        }
    }
    return pos;
}

Referenced by lcmap_string().

◆ mbstowcs_codepage()

static int mbstowcs_codepage	(	const CPTABLEINFO *	info,
		DWORD	flags,
		const char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2733 of file locale.c.

{
    CPTABLEINFO local_info;
    const unsigned char *str = (const unsigned char *)src;
 
    if ((flags & MB_USEGLYPHCHARS) && info->MultiByteTable[256] == 256)
    {
        local_info = *info;
        local_info.MultiByteTable += 257;
        info = &local_info;
    }
    if ((flags & MB_ERR_INVALID_CHARS) && check_invalid_chars( info, str, srclen ))
    {
        SetLastError( ERROR_NO_UNICODE_TRANSLATION );
        return 0;
    }
 
    if (flags & MB_COMPOSITE) return mbstowcs_decompose( info, str, srclen, dst, dstlen );
 
    if (info->DBCSOffsets)
        return mbstowcs_dbcs( info, str, srclen, dst, dstlen );
    else
        return mbstowcs_sbcs( info, str, srclen, dst, dstlen );
}

Referenced by MultiByteToWideChar().

◆ mbstowcs_cpsymbol()

static int mbstowcs_cpsymbol	(	DWORD	flags,
		const char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2361 of file locale.c.

{
    int len, i;
 
    if (flags)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
    if (!dstlen) return srclen;
    len = min( srclen, dstlen );
    for (i = 0; i < len; i++)
    {
        unsigned char c = src[i];
        dst[i] = (c < 0x20) ? c : c + 0xf000;
    }
    if (len < srclen)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return len;
}

Referenced by MultiByteToWideChar().

◆ mbstowcs_dbcs()

static int mbstowcs_dbcs	(	const CPTABLEINFO *	info,
		const unsigned char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2697 of file locale.c.

{
    USHORT off;
    int i;
 
    if (!dstlen)
    {
        for (i = 0; srclen; i++, src++, srclen--)
            if (info->DBCSOffsets[*src] && srclen > 1 && src[1]) { src++; srclen--; }
        return i;
    }
 
    for (i = dstlen; srclen && i; i--, srclen--, src++, dst++)
    {
        if ((off = info->DBCSOffsets[*src]))
        {
            if (srclen > 1 && src[1])
            {
                src++;
                srclen--;
                *dst = info->DBCSOffsets[off + *src];
            }
            else *dst = info->UniDefaultChar;
        }
        else *dst = info->MultiByteTable[*src];
    }
    if (srclen)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return dstlen - i;
}

Referenced by mbstowcs_codepage().

◆ mbstowcs_decompose()

static int mbstowcs_decompose	(	const CPTABLEINFO *	info,
		const unsigned char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2550 of file locale.c.

{
    WCHAR ch;
    USHORT off;
    int len;
    const WCHAR *decomp;
    unsigned int decomp_len;
 
    if (info->DBCSOffsets)
    {
        if (!dstlen)  /* compute length */
        {
            for (len = 0; srclen; srclen--, src++, len += decomp_len)
            {
                if ((off = info->DBCSOffsets[*src]))
                {
                    if (srclen > 1 && src[1])
                    {
                        src++;
                        srclen--;
                        ch = info->DBCSOffsets[off + *src];
                    }
                    else ch = info->UniDefaultChar;
                }
                else ch = info->MultiByteTable[*src];
                get_decomposition( ch, &decomp_len );
            }
            return len;
        }
 
        for (len = dstlen; srclen && len; srclen--, src++, dst += decomp_len, len -= decomp_len)
        {
            if ((off = info->DBCSOffsets[*src]))
            {
                if (srclen > 1 && src[1])
                {
                    src++;
                    srclen--;
                    ch = info->DBCSOffsets[off + *src];
                }
                else ch = info->UniDefaultChar;
            }
            else ch = info->MultiByteTable[*src];
 
            if ((decomp = get_decomposition( ch, &decomp_len )))
            {
                if (len < decomp_len) break;
                memcpy( dst, decomp, decomp_len * sizeof(WCHAR) );
            }
            else *dst = ch;
        }
    }
    else
    {
        if (!dstlen)  /* compute length */
        {
            for (len = 0; srclen; srclen--, src++, len += decomp_len)
                get_decomposition( info->MultiByteTable[*src], &decomp_len );
            return len;
        }
 
        for (len = dstlen; srclen && len; srclen--, src++, dst += decomp_len, len -= decomp_len)
        {
            ch = info->MultiByteTable[*src];
            if ((decomp = get_decomposition( ch, &decomp_len )))
            {
                if (len < decomp_len) break;
                memcpy( dst, decomp, decomp_len * sizeof(WCHAR) );
            }
            else *dst = ch;
        }
    }
 
    if (srclen)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return dstlen - len;
}

Referenced by mbstowcs_codepage().

◆ mbstowcs_sbcs()

static int mbstowcs_sbcs	(	const CPTABLEINFO *	info,
		const unsigned char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2633 of file locale.c.

{
    const USHORT *table = info->MultiByteTable;
    int ret = srclen;
 
    if (!dstlen) return srclen;
 
    if (dstlen < srclen)  /* buffer too small: fill it up to dstlen and return error */
    {
        srclen = dstlen;
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        ret = 0;
    }
 
    while (srclen >= 16)
    {
        dst[0]  = table[src[0]];
        dst[1]  = table[src[1]];
        dst[2]  = table[src[2]];
        dst[3]  = table[src[3]];
        dst[4]  = table[src[4]];
        dst[5]  = table[src[5]];
        dst[6]  = table[src[6]];
        dst[7]  = table[src[7]];
        dst[8]  = table[src[8]];
        dst[9]  = table[src[9]];
        dst[10] = table[src[10]];
        dst[11] = table[src[11]];
        dst[12] = table[src[12]];
        dst[13] = table[src[13]];
        dst[14] = table[src[14]];
        dst[15] = table[src[15]];
        src += 16;
        dst += 16;
        srclen -= 16;
    }
 
    /* now handle the remaining characters */
    src += srclen;
    dst += srclen;
    switch (srclen)
    {
    case 15: dst[-15] = table[src[-15]];
    case 14: dst[-14] = table[src[-14]];
    case 13: dst[-13] = table[src[-13]];
    case 12: dst[-12] = table[src[-12]];
    case 11: dst[-11] = table[src[-11]];
    case 10: dst[-10] = table[src[-10]];
    case 9:  dst[-9]  = table[src[-9]];
    case 8:  dst[-8]  = table[src[-8]];
    case 7:  dst[-7]  = table[src[-7]];
    case 6:  dst[-6]  = table[src[-6]];
    case 5:  dst[-5]  = table[src[-5]];
    case 4:  dst[-4]  = table[src[-4]];
    case 3:  dst[-3]  = table[src[-3]];
    case 2:  dst[-2]  = table[src[-2]];
    case 1:  dst[-1]  = table[src[-1]];
    case 0: break;
    }
    return ret;
}

Referenced by mbstowcs_codepage().

◆ mbstowcs_utf7()

static int mbstowcs_utf7	(	DWORD	flags,
		const char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2386 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 offset = 0, pos = 0;
    DWORD byte_pair = 0;
 
    if (flags)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
#define OUTPUT(ch) \
    do { \
        if (dstlen > 0) \
        { \
            if (pos >= dstlen) goto overflow; \
            dst[pos] = (ch); \
        } \
        pos++; \
    } while(0)
 
    while (src < source_end)
    {
        if (*src == '+')
        {
            src++;
            if (src >= source_end) break;
            if (*src == '-')
            {
                /* just a plus sign escaped as +- */
                OUTPUT( '+' );
                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 */
                    OUTPUT( byte_pair >> (offset - 16) );
                    offset -= 16;
                }
                src++;
            }
            while (src < source_end);
        }
        else
        {
            OUTPUT( (unsigned char)*src );
            src++;
        }
    }
    return pos;
 
overflow:
    SetLastError( ERROR_INSUFFICIENT_BUFFER );
    return 0;
#undef OUTPUT
}

Referenced by MultiByteToWideChar().

◆ mbstowcs_utf8()

static int mbstowcs_utf8	(	DWORD	flags,
		const char *	src,
		int	srclen,
		WCHAR *	dst,
		int	dstlen
	)

static

Definition at line 2488 of file locale.c.

{
    DWORD reslen;
    NTSTATUS status;
 
    if (!dstlen) dst = NULL;
    status = RtlUTF8ToUnicodeN( dst, dstlen * sizeof(WCHAR), &reslen, src, srclen );
    if (status == STATUS_SOME_NOT_MAPPED)
    {
        if (flags & MB_ERR_INVALID_CHARS)
        {
            SetLastError( ERROR_NO_UNICODE_TRANSLATION );
            return 0;
        }
    }
    else if (!set_ntstatus( status )) reslen = 0;
 
    return reslen / sizeof(WCHAR);
}

Referenced by MultiByteToWideChar().

◆ MultiByteToWideChar()

INT WINAPI DECLSPEC_HOTPATCH MultiByteToWideChar	(	UINT	codepage,
		DWORD	flags,
		const char *	src,
		INT	srclen,
		WCHAR *	dst,
		INT	dstlen
	)

Definition at line 7016 of file locale.c.

{
    const CPTABLEINFO *info;
    int ret;
 
    if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (srclen < 0) srclen = strlen(src) + 1;
 
    switch (codepage)
    {
    case CP_SYMBOL:
        ret = mbstowcs_cpsymbol( flags, src, srclen, dst, dstlen );
        break;
    case CP_UTF7:
        ret = mbstowcs_utf7( flags, src, srclen, dst, dstlen );
        break;
    case CP_UNIXCP:
        codepage = unix_cp;
        /* fall through */
    default:
        if (!(info = get_codepage_table( codepage )))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        if (flags & ~(MB_PRECOMPOSED | MB_COMPOSITE | MB_USEGLYPHCHARS | MB_ERR_INVALID_CHARS))
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        if (info->CodePage == CP_UTF8)
            ret = mbstowcs_utf8( flags, src, srclen, dst, dstlen );
        else
            ret = mbstowcs_codepage( info, flags, src, srclen, dst, dstlen );
        break;
    }
    TRACE( "cp %d %s -> %s, ret = %d\n", codepage, debugstr_an(src, srclen), debugstr_wn(dst, ret), ret );
    return ret;
}

◆ NlsValidateLocale()

const NLS_LOCALE_DATA *WINAPI NlsValidateLocale	(	LCID *	lcid,
		ULONG	flags
	)

Definition at line 725 of file locale.c.

{
    const NLS_LOCALE_LCNAME_INDEX *name_entry;
    const NLS_LOCALE_LCID_INDEX *entry;
    const NLS_LOCALE_DATA *locale;
 
    switch (*lcid)
    {
    case LOCALE_SYSTEM_DEFAULT:
        *lcid = system_lcid;
        return system_locale;
    case LOCALE_NEUTRAL:
    case LOCALE_USER_DEFAULT:
    case LOCALE_CUSTOM_DEFAULT:
    case LOCALE_CUSTOM_UNSPECIFIED:
    case LOCALE_CUSTOM_UI_DEFAULT:
        *lcid = user_lcid;
        return user_locale;
    default:
        if (!(entry = find_lcid_entry( *lcid ))) return NULL;
        locale = get_locale_data( entry->idx );
        if ((flags & LOCALE_ALLOW_NEUTRAL_NAMES) || locale->inotneutral) return locale;
        if ((name_entry = find_lcname_entry( locale_strings + locale->ssortlocale + 1 )))
            locale = get_locale_data( name_entry->idx );
        return locale;
    }
}

Referenced by ConvertDefaultLocale(), EnumCalendarInfoExW(), EnumCalendarInfoW(), EnumDateFormatsExW(), EnumDateFormatsW(), EnumTimeFormatsW(), get_lcid_codepage(), GetCalendarInfoW(), GetCurrencyFormatW(), GetDateFormatW(), GetLocaleInfoA(), GetLocaleInfoW(), GetNumberFormatW(), GetTimeFormatW(), init_locale(), InitFunctionPointers(), IsValidLocale(), and LCIDToLocaleName().

◆ nonspace_ignored()

static int nonspace_ignored ( WCHAR ch )

inlinestatic

Definition at line 4047 of file locale.c.

{
    if (get_char_type( CT_CTYPE2, ch ) != C2_OTHERNEUTRAL) return FALSE;
    return (get_char_type( CT_CTYPE3, ch ) & (C3_NONSPACING | C3_DIACRITIC));
}

Referenced by map_remove_ignored().

◆ NormalizeString()

INT WINAPI DECLSPEC_HOTPATCH NormalizeString	(	NORM_FORM	form,
		const WCHAR *	src,
		INT	src_len,
		WCHAR *	dst,
		INT	dst_len
	)

Definition at line 7065 of file locale.c.

{
    NTSTATUS status = RtlNormalizeString( form, src, src_len, dst, &dst_len );
 
    switch (status)
    {
    case STATUS_OBJECT_NAME_NOT_FOUND:
        status = STATUS_INVALID_PARAMETER;
        break;
    case STATUS_BUFFER_TOO_SMALL:
    case STATUS_NO_UNICODE_TRANSLATION:
        dst_len = -dst_len;
        break;
    }
    SetLastError( RtlNtStatusToDosError( status ));
    return dst_len;
}

◆ prepend_str()

static WCHAR * prepend_str	(	WCHAR *	end,
		const WCHAR *	str
	)

static

Definition at line 7525 of file locale.c.

{
    UINT len = wcslen( str );
    return memcpy( end - len, str, len * sizeof(WCHAR) );
}

Referenced by format_number(), get_currency_format(), and get_number_format().

◆ put_sortkey()

static int put_sortkey	(	BYTE *	dst,
		int	dstlen,
		int	pos,
		const struct sortkey *	key,
		BYTE	terminator
	)

static

Definition at line 3572 of file locale.c.

{
    if (dstlen > pos + key->len)
    {
        memcpy( dst + pos, key->buf, key->len );
        dst[pos + key->len] = terminator;
    }
    return pos + key->len + 1;
}

Referenced by get_sortkey().

◆ put_utf16()

static int put_utf16	(	WCHAR *	dst,
		int	pos,
		int	dstlen,
		unsigned int	ch
	)

inlinestatic

Definition at line 2019 of file locale.c.

{
    if (ch >= 0x10000)
    {
        if (pos < dstlen - 1)
        {
            ch -= 0x10000;
            dst[pos] = 0xd800 | (ch >> 10);
            dst[pos + 1] = 0xdc00 | (ch & 0x3ff);
        }
        return 2;
    }
    if (pos < dstlen) dst[pos] = ch;
    return 1;
}

Referenced by casemap_string(), map_to_fullwidth(), and test_FoldStringW().

◆ remove_unneeded_weights()

static BOOL remove_unneeded_weights	(	const struct sortguid *	sortid,
		struct sortkey_state *	s
	)

static

Definition at line 3631 of file locale.c.

{
    const BYTE ignore[4] = { 0xc4 | CASE_FULLSIZE, 0x03, 0xc4 | CASE_KATAKANA, 0xc4 | CASE_FULLWIDTH };
    int i, j;
 
    if (sortid->flags & FLAG_REVERSEDIACRITICS) reverse_sortkey( &s->key_diacritic );
 
    for (i = s->key_diacritic.len; i > 0; i--) if (s->key_diacritic.buf[i - 1] > 2) break;
    s->key_diacritic.len = i;
 
    for (i = s->key_case.len; i > 0; i--) if (s->key_case.buf[i - 1] > 2) break;
    s->key_case.len = i;
 
    if (!s->key_extra[2].len) return FALSE;
 
    for (i = 0; i < 4; i++)
    {
        for (j = s->key_extra[i].len; j > 0; j--) if (s->key_extra[i].buf[j - 1] != ignore[i]) break;
        s->key_extra[i].len = j;
    }
    return TRUE;
}

Referenced by compare_string(), find_substring(), and get_sortkey().

◆ ResolveLocaleName()

INT WINAPI DECLSPEC_HOTPATCH ResolveLocaleName	(	LPCWSTR	name,
		LPWSTR	buffer,
		INT	len
	)

Definition at line 7088 of file locale.c.

{
    LCID lcid;
    UINT pos, datalen;
    const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
 
    if (!locale)
    {
        static const WCHAR valid[] = L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
        WCHAR *p, tmp[LOCALE_NAME_MAX_LENGTH];
 
        if (wcsspn( name, valid ) < wcslen( name ))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        lstrcpynW( tmp, name, LOCALE_NAME_MAX_LENGTH );
        while (!locale)
        {
            for (p = tmp + wcslen(tmp) - 1; p >= tmp; p--) if (*p == '-' || *p == '_') break;
            if (p <= tmp) break;
            *p = 0;
            locale = get_locale_by_name( tmp, &lcid );
        }
    }
 
    pos = locale ? (locale->inotneutral ? locale->sname : locale->ssortlocale) : 0;
    datalen = locale_strings[pos] + 1;
 
    if (!len) return datalen;
    lstrcpynW( buffer, locale_strings + pos + 1, len );
    if (datalen > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return datalen;
}

◆ reverse_sortkey()

static void reverse_sortkey ( struct sortkey * key )

static

Definition at line 3296 of file locale.c.

{
    int i;
 
    for (i = 0; i < key->len / 2; i++)
    {
        BYTE tmp = key->buf[key->len - i - 1];
        key->buf[key->len - i - 1] = key->buf[i];
        key->buf[i] = tmp;
    }
}

Referenced by remove_unneeded_weights().

◆ rol()

static BYTE rol	(	BYTE	val,
		BYTE	count
	)

static

Definition at line 2095 of file locale.c.

{
    return (val << count) | (val >> (8 - count));
}

◆ set_registry_entry()

static BOOL set_registry_entry	(	struct registry_entry *	entry,
		const WCHAR *	data
	)

static

Definition at line 773 of file locale.c.

{
    DWORD size = (wcslen(data) + 1) * sizeof(WCHAR);
    LSTATUS ret;
 
    if (size > sizeof(entry->data))
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return FALSE;
    }
    TRACE( "setting %s to %s\n", debugstr_w(entry->value), debugstr_w(data) );
 
    RtlEnterCriticalSection( &locale_section );
    if (!(ret = RegSetKeyValueW( intl_key, entry->subkey, entry->value, REG_SZ, (BYTE *)data, size )))
    {
        wcscpy( entry->data, data );
        entry->status = CACHED;
    }
    RtlLeaveCriticalSection( &locale_section );
    if (ret) SetLastError( ret );
    return !ret;
}

Referenced by SetLocaleInfoW().

◆ SetCalendarInfoW()

INT WINAPI SetCalendarInfoW	(	LCID	lcid,
		CALID	calendar,
		CALTYPE	type,
		const WCHAR *	data
	)

Definition at line 7218 of file locale.c.

{
    FIXME( "(%08lx,%08lx,%08lx,%s): stub\n", lcid, calendar, type, debugstr_w(data) );
    return 0;
}

◆ SetLocaleInfoW()

BOOL WINAPI DECLSPEC_HOTPATCH SetLocaleInfoW	(	LCID	lcid,
		LCTYPE	lctype,
		const WCHAR *	data
	)

Definition at line 7131 of file locale.c.

{
    WCHAR *str, tmp[80];
 
    if (!data)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    switch (LOWORD(lctype))
    {
    case LOCALE_ICALENDARTYPE:      return set_registry_entry( &entry_icalendartype, data );
    case LOCALE_ICURRDIGITS:        return set_registry_entry( &entry_icurrdigits, data );
    case LOCALE_ICURRENCY:          return set_registry_entry( &entry_icurrency, data );
    case LOCALE_IDIGITS:            return set_registry_entry( &entry_idigits, data );
    case LOCALE_IDIGITSUBSTITUTION: return set_registry_entry( &entry_idigitsubstitution, data );
    case LOCALE_IFIRSTDAYOFWEEK:    return set_registry_entry( &entry_ifirstdayofweek, data );
    case LOCALE_IFIRSTWEEKOFYEAR:   return set_registry_entry( &entry_ifirstweekofyear, data );
    case LOCALE_ILZERO:             return set_registry_entry( &entry_ilzero, data );
    case LOCALE_IMEASURE:           return set_registry_entry( &entry_imeasure, data );
    case LOCALE_INEGCURR:           return set_registry_entry( &entry_inegcurr, data );
    case LOCALE_INEGNUMBER:         return set_registry_entry( &entry_inegnumber, data );
    case LOCALE_IPAPERSIZE:         return set_registry_entry( &entry_ipapersize, data );
    case LOCALE_S1159:              return set_registry_entry( &entry_s1159, data );
    case LOCALE_S2359:              return set_registry_entry( &entry_s2359, data );
    case LOCALE_SCURRENCY:          return set_registry_entry( &entry_scurrency, data );
    case LOCALE_SDECIMAL:           return set_registry_entry( &entry_sdecimal, data );
    case LOCALE_SGROUPING:          return set_registry_entry( &entry_sgrouping, data );
    case LOCALE_SLIST:              return set_registry_entry( &entry_slist, data );
    case LOCALE_SLONGDATE:          return set_registry_entry( &entry_slongdate, data );
    case LOCALE_SMONDECIMALSEP:     return set_registry_entry( &entry_smondecimalsep, data );
    case LOCALE_SMONGROUPING:       return set_registry_entry( &entry_smongrouping, data );
    case LOCALE_SMONTHOUSANDSEP:    return set_registry_entry( &entry_smonthousandsep, data );
    case LOCALE_SNATIVEDIGITS:      return set_registry_entry( &entry_snativedigits, data );
    case LOCALE_SNEGATIVESIGN:      return set_registry_entry( &entry_snegativesign, data );
    case LOCALE_SPOSITIVESIGN:      return set_registry_entry( &entry_spositivesign, data );
    case LOCALE_SSHORTTIME:         return set_registry_entry( &entry_sshorttime, data );
    case LOCALE_STHOUSAND:          return set_registry_entry( &entry_sthousand, data );
    case LOCALE_SYEARMONTH:         return set_registry_entry( &entry_syearmonth, data );
 
    case LOCALE_SDATE:
        if (!get_locale_info( user_locale, user_lcid, LOCALE_SSHORTDATE, tmp, ARRAY_SIZE(tmp) )) break;
        data = locale_replace_separator( tmp, data );
        /* fall through */
    case LOCALE_SSHORTDATE:
        if (!set_registry_entry( &entry_sshortdate, data )) return FALSE;
        update_registry_value( LOCALE_IDATE, NULL, L"iDate" );
        update_registry_value( LOCALE_SDATE, NULL, L"sDate" );
        return TRUE;
 
    case LOCALE_STIME:
        if (!get_locale_info( user_locale, user_lcid, LOCALE_STIMEFORMAT, tmp, ARRAY_SIZE(tmp) )) break;
        data = locale_replace_separator( tmp, data );
        /* fall through */
    case LOCALE_STIMEFORMAT:
        if (!set_registry_entry( &entry_stimeformat, data )) return FALSE;
        update_registry_value( LOCALE_ITIME, NULL, L"iTime" );
        update_registry_value( LOCALE_ITIMEMARKPOSN, NULL, L"iTimePrefix" );
        update_registry_value( LOCALE_ITLZERO, NULL, L"iTLZero" );
        update_registry_value( LOCALE_STIME, NULL, L"sTime" );
        return TRUE;
 
    case LOCALE_ITIME:
        if (!get_locale_info( user_locale, user_lcid, LOCALE_STIMEFORMAT, tmp, ARRAY_SIZE(tmp) )) break;
        if (!(str = find_format( tmp, L"Hh" ))) break;
        while (*str == 'h' || *str == 'H') *str++ = (*data == '0' ? 'h' : 'H');
        if (!set_registry_entry( &entry_stimeformat, tmp )) break;
        update_registry_value( LOCALE_ITIME, NULL, L"iTime" );
        return TRUE;
 
    case LOCALE_SINTLSYMBOL:
        if (!set_registry_entry( &entry_sintlsymbol, data )) return FALSE;
        /* if restoring the original value, restore the original LOCALE_SCURRENCY as well */
        if (!wcsicmp( data, locale_strings + user_locale->sintlsymbol + 1 ))
            data = locale_strings + user_locale->scurrency + 1;
        set_registry_entry( &entry_scurrency, data );
        return TRUE;
    }
    SetLastError( ERROR_INVALID_FLAGS );
    return FALSE;
}

◆ SetProcessPreferredUILanguages()

BOOL WINAPI DECLSPEC_HOTPATCH SetProcessPreferredUILanguages	(	DWORD	flags,
		PCZZWSTR	buffer,
		ULONG *	count
	)

Definition at line 7228 of file locale.c.

{
    return set_ntstatus( RtlSetProcessPreferredUILanguages( flags, buffer, count ));
}

◆ SetThreadPreferredUILanguages()

BOOL WINAPI DECLSPEC_HOTPATCH SetThreadPreferredUILanguages	(	DWORD	flags,
		PCZZWSTR	buffer,
		ULONG *	count
	)

Definition at line 7237 of file locale.c.

{
    return set_ntstatus( RtlSetThreadPreferredUILanguages( flags, buffer, count ));
}

◆ SetTimeZoneInformation()

BOOL WINAPI DECLSPEC_HOTPATCH SetTimeZoneInformation ( const TIME_ZONE_INFORMATION * info )

Definition at line 7246 of file locale.c.

{
    return set_ntstatus( RtlSetTimeZoneInformation( (const RTL_TIME_ZONE_INFORMATION *)info ));
}

◆ SetUserGeoID()

BOOL WINAPI DECLSPEC_HOTPATCH SetUserGeoID ( GEOID id )

Definition at line 7255 of file locale.c.

{
    const struct geo_id *geo = find_geo_id_entry( id );
    WCHAR bufferW[10];
    HKEY hkey;
 
    if (!geo)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if (!RegCreateKeyExW( intl_key, L"Geo", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
    {
        const WCHAR *name = geo->class == GEOCLASS_NATION ? L"Nation" : L"Region";
        swprintf( bufferW, ARRAY_SIZE(bufferW), L"%u", geo->id );
        RegSetValueExW( hkey, name, 0, REG_SZ, (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
 
        if (geo->class == GEOCLASS_NATION || wcscmp( geo->iso2, L"XX" ))
            lstrcpyW( bufferW, geo->iso2 );
        else
            swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03u", geo->uncode );
        RegSetValueExW( hkey, L"Name", 0, REG_SZ, (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
        RegCloseKey( hkey );
    }
    return TRUE;
}

◆ SetUserGeoName()

BOOL WINAPI SetUserGeoName ( PWSTR geo_name )

Definition at line 7469 of file locale.c.

{
    const struct geo_id *geo;
 
    TRACE( "geo_name %s.\n", debugstr_w( geo_name ));
 
    if (!geo_name || !(geo = find_geo_name_entry( geo_name )))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    return SetUserGeoID( geo->id );
}

Referenced by InitFunctionPointers().

◆ SystemTimeToTzSpecificLocalTime()

BOOL WINAPI DECLSPEC_HOTPATCH SystemTimeToTzSpecificLocalTime	(	const TIME_ZONE_INFORMATION *	info,
		const SYSTEMTIME *	system,
		SYSTEMTIME *	local
	)

Definition at line 7286 of file locale.c.

{
    TIME_ZONE_INFORMATION tzinfo;
    LARGE_INTEGER ft;
 
    if (!info)
    {
        RtlQueryTimeZoneInformation( (RTL_TIME_ZONE_INFORMATION *)&tzinfo );
        info = &tzinfo;
    }
 
    if (!SystemTimeToFileTime( system, (FILETIME *)&ft )) return FALSE;
    switch (get_timezone_id( info, ft, FALSE ))
    {
    case TIME_ZONE_ID_UNKNOWN:
        ft.QuadPart -= info->Bias * (LONGLONG)600000000;
        break;
    case TIME_ZONE_ID_STANDARD:
        ft.QuadPart -= (info->Bias + info->StandardBias) * (LONGLONG)600000000;
        break;
    case TIME_ZONE_ID_DAYLIGHT:
        ft.QuadPart -= (info->Bias + info->DaylightBias) * (LONGLONG)600000000;
        break;
    default:
        return FALSE;
    }
    return FileTimeToSystemTime( (FILETIME *)&ft, local );
}

◆ table_has_high_planes()

static BOOL table_has_high_planes ( const USHORT * table )

inlinestatic

Definition at line 2013 of file locale.c.

{
    return table[0] >= 0x500;
}

Referenced by casemap_string(), and map_to_fullwidth().

◆ TzSpecificLocalTimeToSystemTime()

BOOL WINAPI DECLSPEC_HOTPATCH TzSpecificLocalTimeToSystemTime	(	const TIME_ZONE_INFORMATION *	info,
		const SYSTEMTIME *	local,
		SYSTEMTIME *	system
	)

Definition at line 7321 of file locale.c.

{
    TIME_ZONE_INFORMATION tzinfo;
    LARGE_INTEGER ft;
 
    if (!info)
    {
        RtlQueryTimeZoneInformation( (RTL_TIME_ZONE_INFORMATION *)&tzinfo );
        info = &tzinfo;
    }
 
    if (!SystemTimeToFileTime( local, (FILETIME *)&ft )) return FALSE;
    switch (get_timezone_id( info, ft, TRUE ))
    {
    case TIME_ZONE_ID_UNKNOWN:
        ft.QuadPart += info->Bias * (LONGLONG)600000000;
        break;
    case TIME_ZONE_ID_STANDARD:
        ft.QuadPart += (info->Bias + info->StandardBias) * (LONGLONG)600000000;
        break;
    case TIME_ZONE_ID_DAYLIGHT:
        ft.QuadPart += (info->Bias + info->DaylightBias) * (LONGLONG)600000000;
        break;
    default:
        return FALSE;
    }
    return FileTimeToSystemTime( (FILETIME *)&ft, system );
}

◆ update_locale_registry()

static void update_locale_registry ( void )

static

Definition at line 1855 of file locale.c.

{
    WCHAR buffer[80];
    UINT len;
 
    len = swprintf( buffer, ARRAY_SIZE(buffer), L"%08x", GetUserDefaultLCID() );
    RegSetValueExW( intl_key, L"Locale", 0, REG_SZ, (BYTE *)buffer, (len + 1) * sizeof(WCHAR) );
 
#define UPDATE(val,entry) update_registry_value( LOCALE_NOUSEROVERRIDE | (val), (entry).subkey, (entry).value )
    UPDATE( LOCALE_ICALENDARTYPE, entry_icalendartype );
    UPDATE( LOCALE_ICOUNTRY, entry_icountry );
    UPDATE( LOCALE_ICURRDIGITS, entry_icurrdigits );
    UPDATE( LOCALE_ICURRENCY, entry_icurrency );
    UPDATE( LOCALE_IDIGITS, entry_idigits );
    UPDATE( LOCALE_IDIGITSUBSTITUTION, entry_idigitsubstitution );
    UPDATE( LOCALE_IFIRSTDAYOFWEEK, entry_ifirstdayofweek );
    UPDATE( LOCALE_IFIRSTWEEKOFYEAR, entry_ifirstweekofyear );
    UPDATE( LOCALE_ILZERO, entry_ilzero );
    UPDATE( LOCALE_IMEASURE, entry_imeasure );
    UPDATE( LOCALE_INEGCURR, entry_inegcurr );
    UPDATE( LOCALE_INEGNUMBER, entry_inegnumber );
    UPDATE( LOCALE_IPAPERSIZE, entry_ipapersize );
    UPDATE( LOCALE_S1159, entry_s1159 );
    UPDATE( LOCALE_S2359, entry_s2359 );
    UPDATE( LOCALE_SCURRENCY, entry_scurrency );
    UPDATE( LOCALE_SDECIMAL, entry_sdecimal );
    UPDATE( LOCALE_SGROUPING, entry_sgrouping );
    UPDATE( LOCALE_SINTLSYMBOL, entry_sintlsymbol );
    UPDATE( LOCALE_SLIST, entry_slist );
    UPDATE( LOCALE_SLONGDATE, entry_slongdate );
    UPDATE( LOCALE_SMONDECIMALSEP, entry_smondecimalsep );
    UPDATE( LOCALE_SMONGROUPING, entry_smongrouping );
    UPDATE( LOCALE_SMONTHOUSANDSEP, entry_smonthousandsep );
    UPDATE( LOCALE_SNATIVEDIGITS, entry_snativedigits );
    UPDATE( LOCALE_SNEGATIVESIGN, entry_snegativesign );
    UPDATE( LOCALE_SPOSITIVESIGN, entry_spositivesign );
    UPDATE( LOCALE_SSHORTDATE, entry_sshortdate );
    UPDATE( LOCALE_SSHORTTIME, entry_sshorttime );
    UPDATE( LOCALE_STHOUSAND, entry_sthousand );
    UPDATE( LOCALE_STIMEFORMAT, entry_stimeformat );
    UPDATE( LOCALE_SYEARMONTH, entry_syearmonth );
#undef UPDATE
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IDATE, NULL, L"iDate" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ITIME, NULL, L"iTime" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ITIMEMARKPOSN, NULL, L"iTimePrefix" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ITLZERO, NULL, L"iTLZero" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SDATE, NULL, L"sDate" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_STIME, NULL, L"sTime" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SABBREVLANGNAME, NULL, L"sLanguage" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SCOUNTRY, NULL, L"sCountry" );
    update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SNAME, NULL, L"LocaleName" );
    SetUserGeoID( user_locale->igeoid );
}

Referenced by init_locale().

◆ update_registry_value()

static void update_registry_value	(	UINT	type,
		const WCHAR *	subkey,
		const WCHAR *	value
	)

static

Definition at line 1846 of file locale.c.

{
    WCHAR buffer[80];
    UINT len = get_locale_info( user_locale, user_lcid, type, buffer, ARRAY_SIZE(buffer) );
    if (len) RegSetKeyValueW( intl_key, subkey, value, REG_SZ, (BYTE *)buffer, len * sizeof(WCHAR) );
}

Referenced by SetLocaleInfoW(), and update_locale_registry().

◆ validate_mui_resource()

static BOOL validate_mui_resource	(	struct mui_resource *	mui,
		DWORD	size
	)

static

Definition at line 5769 of file locale.c.

{
    if (size >= sizeof(DWORD) && mui->signature != MUI_SIGNATURE)
    {
        SetLastError(ERROR_MUI_INVALID_RC_CONFIG);
        return FALSE;
    }
 
    size = min( size, mui->size );
    if (size < sizeof(*mui) ||
        mui->ln_type_name_off >= size || mui->ln_type_name_size > size - mui->ln_type_name_off ||
        mui->ln_type_id_off >= size || mui->ln_type_id_size > size - mui->ln_type_id_off ||
        mui->mui_type_name_off >= size || mui->mui_type_name_size > size - mui->mui_type_name_off ||
        mui->mui_type_id_off >= size || mui->mui_type_id_size > size - mui->mui_type_id_off ||
        mui->lang_off >= size || mui->lang_size > size - mui->lang_off ||
        mui->fallback_lang_off >= size || mui->fallback_lang_size > size - mui->fallback_lang_off)
    {
        SetLastError(ERROR_BAD_EXE_FORMAT);
        return FALSE;
    }
    return TRUE;
}

Referenced by GetFileMUIInfo().

◆ VerLanguageNameA()

DWORD WINAPI DECLSPEC_HOTPATCH VerLanguageNameA	(	DWORD	lang,
		LPSTR	buffer,
		DWORD	size
	)

Definition at line 7356 of file locale.c.

{
    return GetLocaleInfoA( MAKELCID( lang, SORT_DEFAULT ), LOCALE_SENGLANGUAGE, buffer, size );
}

◆ VerLanguageNameW()

DWORD WINAPI DECLSPEC_HOTPATCH VerLanguageNameW	(	DWORD	lang,
		LPWSTR	buffer,
		DWORD	size
	)

Definition at line 7365 of file locale.c.

{
    return GetLocaleInfoW( MAKELCID( lang, SORT_DEFAULT ), LOCALE_SENGLANGUAGE, buffer, size );
}

◆ wcstombs_codepage()

static int wcstombs_codepage	(	const CPTABLEINFO *	info,
		DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		char *	dst,
		int	dstlen,
		const char *	defchar,
		BOOL *	used
	)

static

Definition at line 3255 of file locale.c.

{
    if (flags || defchar || used)
    {
        if (!defchar) defchar = (const char *)&info->DefaultChar;
        if (info->DBCSOffsets)
            return wcstombs_dbcs_slow( info, flags, src, srclen, dst, dstlen, defchar, used );
        else
            return wcstombs_sbcs_slow( info, flags, src, srclen, dst, dstlen, defchar, used );
    }
    if (info->DBCSOffsets)
        return wcstombs_dbcs( info, src, srclen, dst, dstlen );
    else
        return wcstombs_sbcs( info, src, srclen, dst, dstlen );
}

Referenced by WideCharToMultiByte().

◆ wcstombs_cpsymbol()

static int wcstombs_cpsymbol	(	DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		char *	dst,
		int	dstlen,
		const char *	defchar,
		BOOL *	used
	)

static

Definition at line 2760 of file locale.c.

{
    int len, i;
 
    if (flags)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
    if (defchar || used)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (!dstlen) return srclen;
    len = min( srclen, dstlen );
    for (i = 0; i < len; i++)
    {
        if (src[i] < 0x20) dst[i] = src[i];
        else if (src[i] >= 0xf020 && src[i] < 0xf100) dst[i] = src[i] - 0xf000;
        else
        {
            SetLastError( ERROR_NO_UNICODE_TRANSLATION );
            return 0;
        }
    }
    if (srclen > len)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return len;
}

Referenced by WideCharToMultiByte().

◆ wcstombs_dbcs()

static int wcstombs_dbcs	(	const CPTABLEINFO *	info,
		const WCHAR *	src,
		unsigned int	srclen,
		char *	dst,
		unsigned int	dstlen
	)

static

Definition at line 2979 of file locale.c.

{
    const USHORT *table = info->WideCharTable;
    int i;
 
    if (!dstlen)
    {
        for (i = 0; srclen; src++, srclen--, i++) if (table[*src] & 0xff00) i++;
        return i;
    }
 
    for (i = dstlen; srclen && i; i--, srclen--, src++)
    {
        if (table[*src] & 0xff00)
        {
            if (i == 1) break;  /* do not output a partial char */
            i--;
            *dst++ = table[*src] >> 8;
        }
        *dst++ = (char)table[*src];
    }
    if (srclen)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return dstlen - i;
}

Referenced by wcstombs_codepage().

◆ wcstombs_dbcs_slow()

static int wcstombs_dbcs_slow	(	const CPTABLEINFO *	info,
		DWORD	flags,
		const WCHAR *	src,
		unsigned int	srclen,
		char *	dst,
		unsigned int	dstlen,
		const char *	defchar,
		BOOL *	used
	)

static

Definition at line 3132 of file locale.c.

{
    const USHORT *table = info->WideCharTable;
    WCHAR wch, defchar_value;
    unsigned int composed;
    unsigned short res;
    BOOL tmp;
    int i;
 
    if (!defchar[1]) defchar_value = (unsigned char)defchar[0];
    else defchar_value = ((unsigned char)defchar[0] << 8) | (unsigned char)defchar[1];
 
    if (!used) used = &tmp;  /* avoid checking on every char */
    *used = FALSE;
 
    if (!dstlen)
    {
        if (!defchar && !used && !(flags & WC_COMPOSITECHECK))
        {
            for (i = 0; srclen; srclen--, src++, i++) if (table[*src] & 0xff00) i++;
            return i;
        }
        for (i = 0; srclen; srclen--, src++, i++)
        {
            wch = *src;
            if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
            {
                /* now check if we can use the composed char */
                if (is_valid_dbcs_mapping( info, flags, composed ))
                {
                    /* we have a good mapping for the composed char, use it */
                    res = table[composed];
                    if (res & 0xff00) i++;
                    src++;
                    srclen--;
                    continue;
                }
                /* no mapping for the composed char, check the other flags */
                if (flags & WC_DEFAULTCHAR) /* use the default char instead */
                {
                    if (defchar_value & 0xff00) i++;
                    *used = TRUE;
                    src++;  /* skip the non-spacing char */
                    srclen--;
                    continue;
                }
                if (flags & WC_DISCARDNS) /* skip the second char of the composition */
                {
                    src++;
                    srclen--;
                }
                /* WC_SEPCHARS is the default */
            }
 
            res = table[wch];
            if (!is_valid_dbcs_mapping( info, flags, wch ))
            {
                res = defchar_value;
                *used = TRUE;
            }
            if (res & 0xff00) i++;
        }
        return i;
    }
 
 
    for (i = dstlen; srclen && i; i--, srclen--, src++)
    {
        wch = *src;
        if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
        {
            /* now check if we can use the composed char */
            if (is_valid_dbcs_mapping( info, flags, composed ))
            {
                /* we have a good mapping for the composed char, use it */
                res = table[composed];
                src++;
                srclen--;
                goto output_char;
            }
            /* no mapping for the composed char, check the other flags */
            if (flags & WC_DEFAULTCHAR) /* use the default char instead */
            {
                res = defchar_value;
                *used = TRUE;
                src++;  /* skip the non-spacing char */
                srclen--;
                goto output_char;
            }
            if (flags & WC_DISCARDNS) /* skip the second char of the composition */
            {
                src++;
                srclen--;
            }
            /* WC_SEPCHARS is the default */
        }
 
        res = table[wch];
        if (!is_valid_dbcs_mapping( info, flags, wch ))
        {
            res = defchar_value;
            *used = TRUE;
        }
 
    output_char:
        if (res & 0xff00)
        {
            if (i == 1) break;  /* do not output a partial char */
            i--;
            *dst++ = res >> 8;
        }
        *dst++ = (char)res;
    }
    if (srclen)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return dstlen - i;
}

Referenced by wcstombs_codepage().

◆ wcstombs_sbcs()

static int wcstombs_sbcs	(	const CPTABLEINFO *	info,
		const WCHAR *	src,
		unsigned int	srclen,
		char *	dst,
		unsigned int	dstlen
	)

static

Definition at line 2914 of file locale.c.

{
    const char *table = info->WideCharTable;
    int ret = srclen;
 
    if (!dstlen) return srclen;
 
    if (dstlen < srclen)
    {
        /* buffer too small: fill it up to dstlen and return error */
        srclen = dstlen;
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        ret = 0;
    }
 
    while (srclen >= 16)
    {
        dst[0]  = table[src[0]];
        dst[1]  = table[src[1]];
        dst[2]  = table[src[2]];
        dst[3]  = table[src[3]];
        dst[4]  = table[src[4]];
        dst[5]  = table[src[5]];
        dst[6]  = table[src[6]];
        dst[7]  = table[src[7]];
        dst[8]  = table[src[8]];
        dst[9]  = table[src[9]];
        dst[10] = table[src[10]];
        dst[11] = table[src[11]];
        dst[12] = table[src[12]];
        dst[13] = table[src[13]];
        dst[14] = table[src[14]];
        dst[15] = table[src[15]];
        src += 16;
        dst += 16;
        srclen -= 16;
    }
 
    /* now handle remaining characters */
    src += srclen;
    dst += srclen;
    switch(srclen)
    {
    case 15: dst[-15] = table[src[-15]];
    case 14: dst[-14] = table[src[-14]];
    case 13: dst[-13] = table[src[-13]];
    case 12: dst[-12] = table[src[-12]];
    case 11: dst[-11] = table[src[-11]];
    case 10: dst[-10] = table[src[-10]];
    case 9:  dst[-9]  = table[src[-9]];
    case 8:  dst[-8]  = table[src[-8]];
    case 7:  dst[-7]  = table[src[-7]];
    case 6:  dst[-6]  = table[src[-6]];
    case 5:  dst[-5]  = table[src[-5]];
    case 4:  dst[-4]  = table[src[-4]];
    case 3:  dst[-3]  = table[src[-3]];
    case 2:  dst[-2]  = table[src[-2]];
    case 1:  dst[-1]  = table[src[-1]];
    case 0: break;
    }
    return ret;
}

Referenced by wcstombs_codepage().

◆ wcstombs_sbcs_slow()

static int wcstombs_sbcs_slow	(	const CPTABLEINFO *	info,
		DWORD	flags,
		const WCHAR *	src,
		unsigned int	srclen,
		char *	dst,
		unsigned int	dstlen,
		const char *	defchar,
		BOOL *	used
	)

static

Definition at line 3037 of file locale.c.

{
    const char *table = info->WideCharTable;
    const char def = defchar ? *defchar : (char)info->DefaultChar;
    int i;
    BOOL tmp;
    WCHAR wch;
    unsigned int composed;
 
    if (!used) used = &tmp;  /* avoid checking on every char */
    *used = FALSE;
 
    if (!dstlen)
    {
        for (i = 0; srclen; i++, src++, srclen--)
        {
            wch = *src;
            if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
            {
                /* now check if we can use the composed char */
                if (is_valid_sbcs_mapping( info, flags, composed ))
                {
                    /* we have a good mapping, use it */
                    src++;
                    srclen--;
                    continue;
                }
                /* no mapping for the composed char, check the other flags */
                if (flags & WC_DEFAULTCHAR) /* use the default char instead */
                {
                    *used = TRUE;
                    src++;  /* skip the non-spacing char */
                    srclen--;
                    continue;
                }
                if (flags & WC_DISCARDNS) /* skip the second char of the composition */
                {
                    src++;
                    srclen--;
                }
                /* WC_SEPCHARS is the default */
            }
            if (!*used) *used = !is_valid_sbcs_mapping( info, flags, wch );
        }
        return i;
    }
 
    for (i = dstlen; srclen && i; dst++, i--, src++, srclen--)
    {
        wch = *src;
        if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
        {
            /* now check if we can use the composed char */
            if (is_valid_sbcs_mapping( info, flags, composed ))
            {
                /* we have a good mapping, use it */
                *dst = table[composed];
                src++;
                srclen--;
                continue;
            }
            /* no mapping for the composed char, check the other flags */
            if (flags & WC_DEFAULTCHAR) /* use the default char instead */
            {
                *dst = def;
                *used = TRUE;
                src++;  /* skip the non-spacing char */
                srclen--;
                continue;
            }
            if (flags & WC_DISCARDNS) /* skip the second char of the composition */
            {
                src++;
                srclen--;
            }
            /* WC_SEPCHARS is the default */
        }
 
        *dst = table[wch];
        if (!is_valid_sbcs_mapping( info, flags, wch ))
        {
            *dst = def;
            *used = TRUE;
        }
    }
    if (srclen)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return 0;
    }
    return dstlen - i;
}

Referenced by wcstombs_codepage().

◆ wcstombs_utf7()

static int wcstombs_utf7	(	DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		char *	dst,
		int	dstlen,
		const char *	defchar,
		BOOL *	used
	)

static

Definition at line 2796 of file locale.c.

{
    static const char directly_encodable[] =
    {
        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 */
    };
#define ENCODABLE(ch) ((ch) <= 0x7a && directly_encodable[(ch)])
 
    static const char base64_encoding_table[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
    const WCHAR *source_end = src + srclen;
    int pos = 0;
 
    if (defchar || used)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
    if (flags)
    {
        SetLastError( ERROR_INVALID_FLAGS );
        return 0;
    }
 
#define OUTPUT(ch) \
    do { \
        if (dstlen > 0) \
        { \
            if (pos >= dstlen) goto overflow; \
            dst[pos] = (ch); \
        } \
        pos++; \
    } while (0)
 
    while (src < source_end)
    {
        if (*src == '+')
        {
            OUTPUT( '+' );
            OUTPUT( '-' );
            src++;
        }
        else if (ENCODABLE(*src))
        {
            OUTPUT( *src );
            src++;
        }
        else
        {
            unsigned int offset = 0, byte_pair = 0;
 
            OUTPUT( '+' );
            while (src < source_end && !ENCODABLE(*src))
            {
                byte_pair = (byte_pair << 16) | *src;
                offset += 16;
                while (offset >= 6)
                {
                    offset -= 6;
                    OUTPUT( base64_encoding_table[(byte_pair >> offset) & 0x3f] );
                }
                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 && pos + 1 >= dstlen) goto overflow;
                byte_pair <<= (6 - offset);
                OUTPUT( base64_encoding_table[byte_pair & 0x3f] );
            }
            /* Windows always explicitly terminates the base64 sequence
               even though RFC 2152 (page 3, rule 2) does not require this */
            OUTPUT( '-' );
        }
    }
    return pos;
 
overflow:
    SetLastError( ERROR_INSUFFICIENT_BUFFER );
    return 0;
#undef OUTPUT
#undef ENCODABLE
}

Referenced by WideCharToMultiByte().

◆ wcstombs_utf8()

static int wcstombs_utf8	(	DWORD	flags,
		const WCHAR *	src,
		int	srclen,
		char *	dst,
		int	dstlen,
		const char *	defchar,
		BOOL *	used
	)

static

Definition at line 2891 of file locale.c.

{
    DWORD reslen;
    NTSTATUS status;
 
    if (used) *used = FALSE;
    if (!dstlen) dst = NULL;
    status = RtlUnicodeToUTF8N( dst, dstlen, &reslen, src, srclen * sizeof(WCHAR) );
    if (status == STATUS_SOME_NOT_MAPPED)
    {
        if (flags & WC_ERR_INVALID_CHARS)
        {
            SetLastError( ERROR_NO_UNICODE_TRANSLATION );
            return 0;
        }
        if (used) *used = TRUE;
    }
    else if (!set_ntstatus( status )) reslen = 0;
    return reslen;
}

Referenced by WideCharToMultiByte().

◆ WideCharToMultiByte()

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

Definition at line 7374 of file locale.c.

{
    const CPTABLEINFO *info;
    int ret;
 
    if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (srclen < 0) srclen = lstrlenW(src) + 1;
 
    switch (codepage)
    {
    case CP_SYMBOL:
        ret = wcstombs_cpsymbol( flags, src, srclen, dst, dstlen, defchar, used );
        break;
    case CP_UTF7:
        ret = wcstombs_utf7( flags, src, srclen, dst, dstlen, defchar, used );
        break;
    case CP_UNIXCP:
        codepage = unix_cp;
        /* fall through */
    default:
        if (!(info = get_codepage_table( codepage )))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return 0;
        }
        if (flags & ~(WC_DISCARDNS | WC_SEPCHARS | WC_DEFAULTCHAR | WC_ERR_INVALID_CHARS |
                      WC_COMPOSITECHECK | WC_NO_BEST_FIT_CHARS))
        {
            SetLastError( ERROR_INVALID_FLAGS );
            return 0;
        }
        if (info->CodePage == CP_UTF8)
            ret = wcstombs_utf8( flags, src, srclen, dst, dstlen, defchar, used );
        else
            ret = wcstombs_codepage( info, flags, src, srclen, dst, dstlen, defchar, used );
        break;
    }
    TRACE( "cp %d %s -> %s, ret = %d\n", codepage, debugstr_wn(src, srclen), debugstr_an(dst, ret), ret );
    return ret;
}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( nls )

Variable Documentation

◆ ansi_cpinfo

CPTABLEINFO ansi_cpinfo

static

Definition at line 305 of file locale.c.

Referenced by get_codepage_table(), get_lcid_codepage(), get_locale_codepage(), GetACP(), init_locale(), and IsDBCSLeadByte().

◆

struct { ... } cached_tzname

Referenced by GetDynamicTimeZoneInformation().

◆ casemap

const USHORT* casemap

Definition at line 419 of file locale.c.

Referenced by casemap_string(), map_to_fullwidth(), and map_to_halfwidth().

◆ charmaps

const USHORT* charmaps[NB_CHARMAPS]

static

Definition at line 273 of file locale.c.

◆

const struct { ... } codepage_names[]

Referenced by GetCPInfoExW().

◆ codepages

CPTABLEINFO codepages[128]

static

Definition at line 320 of file locale.c.

Referenced by fnIMLangFontLink2_CodePagesToCodePage(), fnIMLangFontLink2_CodePageToCodePages(), fnIMLangFontLink2_GetCharCodePages(), fnIMLangFontLink2_GetFontCodePages(), fnIMLangFontLink2_GetStrCodePages(), fnIMLangFontLink_CodePagesToCodePage(), fnIMLangFontLink_CodePageToCodePages(), fnIMLangFontLink_GetCharCodePages(), fnIMLangFontLink_GetFontCodePages(), fnIMLangFontLink_GetStrCodePages(), get_codepage_table(), map_font(), and test_MapFont().

◆ compr_count

UINT compr_count

Definition at line 417 of file locale.c.

◆ compr_data

const WCHAR* compr_data

Definition at line 425 of file locale.c.

◆ compressions

const struct sort_compression* compressions

Definition at line 424 of file locale.c.

◆ cp

UINT cp

Definition at line 93 of file locale.c.

◆ critsect_debug

CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

=
{
    0, 0, &locale_section,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": locale_section") }
}

Definition at line 430 of file locale.c.

◆ ctype_idx

const BYTE* ctype_idx

Definition at line 421 of file locale.c.

◆ ctypes

const WORD* ctypes

Definition at line 420 of file locale.c.

Referenced by load_locale_nls(), and load_sortdefault_nls().

◆ current_locale_sort

const struct sortguid* current_locale_sort

static

Definition at line 410 of file locale.c.

Referenced by get_language_sort(), and init_locale().

◆ daylight_name

WCHAR daylight_name[32]

Definition at line 5663 of file locale.c.

◆ entry_icalendartype

struct registry_entry entry_icalendartype = { L"iCalendarType" }

static

Definition at line 59 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_icountry

struct registry_entry entry_icountry = { L"iCountry" }

static

Definition at line 60 of file locale.c.

Referenced by get_locale_info(), and update_locale_registry().

◆ entry_icurrdigits

struct registry_entry entry_icurrdigits = { L"iCurrDigits" }

static

Definition at line 61 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_icurrency

struct registry_entry entry_icurrency = { L"iCurrency" }

static

Definition at line 62 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_idigits

struct registry_entry entry_idigits = { L"iDigits" }

static

Definition at line 63 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_idigitsubstitution

struct registry_entry entry_idigitsubstitution = { L"NumShape" }

static

Definition at line 64 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_ifirstdayofweek

struct registry_entry entry_ifirstdayofweek = { L"iFirstDayOfWeek" }

static

Definition at line 65 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_ifirstweekofyear

struct registry_entry entry_ifirstweekofyear = { L"iFirstWeekOfYear" }

static

Definition at line 66 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_ilzero

struct registry_entry entry_ilzero = { L"iLZero" }

static

Definition at line 67 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_imeasure

struct registry_entry entry_imeasure = { L"iMeasure" }

static

Definition at line 68 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_inegcurr

struct registry_entry entry_inegcurr = { L"iNegCurr" }

static

Definition at line 69 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_inegnumber

struct registry_entry entry_inegnumber = { L"iNegNumber" }

static

Definition at line 70 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_ipapersize

struct registry_entry entry_ipapersize = { L"iPaperSize" }

static

Definition at line 71 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_s1159

struct registry_entry entry_s1159 = { L"s1159" }

static

Definition at line 72 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_s2359

struct registry_entry entry_s2359 = { L"s2359" }

static

Definition at line 73 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_scurrency

struct registry_entry entry_scurrency = { L"sCurrency" }

static

Definition at line 74 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_sdecimal

struct registry_entry entry_sdecimal = { L"sDecimal" }

static

Definition at line 75 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_sgrouping

struct registry_entry entry_sgrouping = { L"sGrouping" }

static

Definition at line 76 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_sintlsymbol

struct registry_entry entry_sintlsymbol = { L"Currencies", world_subkey }

static

Definition at line 77 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_slist

struct registry_entry entry_slist = { L"sList" }

static

Definition at line 78 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_slongdate

struct registry_entry entry_slongdate = { L"sLongDate" }

static

Definition at line 79 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_smondecimalsep

struct registry_entry entry_smondecimalsep = { L"sMonDecimalSep" }

static

Definition at line 80 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_smongrouping

struct registry_entry entry_smongrouping = { L"sMonGrouping" }

static

Definition at line 81 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_smonthousandsep

struct registry_entry entry_smonthousandsep = { L"sMonThousandSep" }

static

Definition at line 82 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_snativedigits

struct registry_entry entry_snativedigits = { L"sNativeDigits" }

static

Definition at line 83 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_snegativesign

struct registry_entry entry_snegativesign = { L"sNegativeSign" }

static

Definition at line 84 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_spositivesign

struct registry_entry entry_spositivesign = { L"sPositiveSign" }

static

Definition at line 85 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_sshortdate

struct registry_entry entry_sshortdate = { L"sShortDate" }

static

Definition at line 86 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_sshorttime

struct registry_entry entry_sshorttime = { L"sShortTime" }

static

Definition at line 87 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_sthousand

struct registry_entry entry_sthousand = { L"sThousand" }

static

Definition at line 88 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_stimeformat

struct registry_entry entry_stimeformat = { L"sTimeFormat" }

static

Definition at line 89 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ entry_syearmonth

struct registry_entry entry_syearmonth = { L"sYearMonth" }

static

Definition at line 90 of file locale.c.

Referenced by get_locale_info(), SetLocaleInfoW(), and update_locale_registry().

◆ exp_count

UINT exp_count

Definition at line 416 of file locale.c.

◆ expansions

const struct sort_expansion* expansions

Definition at line 423 of file locale.c.

◆ geo_ids

const struct geo_id * geo_ids

static

Referenced by EnumSystemGeoID(), find_geo_id_entry(), find_geo_name_entry(), and load_locale_nls().

◆ geo_ids_count

unsigned int geo_ids_count

static

Definition at line 257 of file locale.c.

Referenced by EnumSystemGeoID(), find_geo_id_entry(), and load_locale_nls().

◆ geo_index

const struct geo_index * geo_index

static

◆ geo_index_count

unsigned int geo_index_count

static

Definition at line 258 of file locale.c.

Referenced by find_geo_name_entry(), and load_locale_nls().

◆ guid_count

UINT guid_count

Definition at line 415 of file locale.c.

◆ guids

const struct sortguid* guids

Definition at line 422 of file locale.c.

Referenced by _dump_dinput_GUID(), debugstr_dmguid(), FindGUID(), IDirectInput8AImpl_EnumDevicesBySemantics(), IDirectInput8WImpl_EnumDevicesBySemantics(), load_driver_devices(), msi_check_patch_applicable(), publish_product_properties(), and test_ClassIDs().

◆ intl_key

HKEY intl_key

static

Definition at line 310 of file locale.c.

Referenced by GetUserDefaultGeoName(), GetUserGeoID(), init_locale(), locale_return_reg_string(), set_registry_entry(), SetUserGeoID(), update_locale_registry(), and update_registry_value().

◆ jamo

const struct jamo_sort* jamo

Definition at line 426 of file locale.c.

◆ kernelbase_handle

HMODULE kernelbase_handle

static

Definition at line 47 of file locale.c.

Referenced by get_message(), init_locale(), and Internal_EnumSystemLanguageGroups().

◆ key_name

WCHAR key_name[128]

Definition at line 5661 of file locale.c.

◆ keys

const UINT* keys

Definition at line 418 of file locale.c.

Referenced by CFSDropTarget::_GetEffectFromMenu(), append_extra_kana_weights(), build_createsql_postlude(), CDrivesContextMenu_CreateInstance(), CountUniqueItems_Aux(), create_diff_row_query(), CDesktopFolder::CreateViewObject(), CFSFolder::CreateViewObject(), CRegItemContextMenu_CreateInstance(), d3drm_animation2_AddKey(), d3drm_animation2_GetKeys(), d3drm_animation_delete_key(), d3drm_animation_get_index_max(), d3drm_animation_get_index_min(), d3drm_animation_get_insert_position(), d3drm_animation_get_range(), d3drm_animation_lookup_key(), d3dx9_keyframed_animation_GetNumScaleKeys(), DECLARE_INTERFACE_(), desfunc(), dict_enum_Next(), dictionary_Keys(), EDIT_WM_LButtonDown(), FindTest::findif0(), free_keys(), CZipFolder::GetUIObjectOf(), CDesktopFolder::GetUIObjectOf(), CFSFolder::GetUIObjectOf(), CNetFolder::GetUIObjectOf(), CCommonFolder< TSelf, TItemId, TExtractIcon >::GetUIObjectOf(), CIMEUIWindowHandler::ImeUIMsImeMouseHandler(), LISTBOX_HandleLButtonDown(), LISTBOX_HandleLButtonDownCombo(), LISTVIEW_KeyDown(), LISTVIEW_KeySelection(), register_keys(), ShellPropSheetDialog::Show(), test_animation(), test_Keys(), test_performance_keys(), test_primary_keys(), test_pseudo_handle_security(), test_SetupGetIntField(), test_SHCreateDefaultContextMenu(), test_SHSearchMapInt(), and unregister_keys().

◆ lcid

LCID lcid

Definition at line 5660 of file locale.c.

◆ lcids_index

const NLS_LOCALE_LCID_INDEX* lcids_index

static

Definition at line 313 of file locale.c.

Referenced by find_lcid_entry(), and load_locale_nls().

◆ lcnames_index

const NLS_LOCALE_LCNAME_INDEX* lcnames_index

static

Definition at line 314 of file locale.c.

Referenced by EnumSystemLocalesA(), EnumSystemLocalesEx(), EnumSystemLocalesW(), find_lcname_entry(), get_language_sort(), Internal_EnumUILanguages(), and load_locale_nls().

◆ ligatures

const WCHAR ligatures[][5]

static

Definition at line 176 of file locale.c.

Referenced by get_ligature().

◆ locale_section

static CRITICAL_SECTION locale_section = { &critsect_debug, -1, 0, 0, 0, 0 }

static

Definition at line 429 of file locale.c.

Referenced by get_codepage_table(), locale_return_reg_string(), and set_registry_entry().

◆ locale_sorts

const struct sortguid** locale_sorts

static

Definition at line 409 of file locale.c.

Referenced by get_language_sort(), and load_sortdefault_nls().

◆ locale_strings

const WCHAR* locale_strings

static

◆ locale_table

const NLS_LOCALE_HEADER* locale_table

static

Definition at line 315 of file locale.c.

Referenced by EnumSystemLocalesA(), EnumSystemLocalesEx(), EnumSystemLocalesW(), find_lcid_entry(), find_lcname_entry(), get_calendar_data(), get_locale_data(), Internal_EnumUILanguages(), load_locale_nls(), and load_sortdefault_nls().

◆ name

const WCHAR* name

Definition at line 93 of file locale.c.

Referenced by GetUserGeoID().

◆ nb_codepages

unsigned int nb_codepages

static

Definition at line 321 of file locale.c.

Referenced by get_codepage_table().

◆ nls_key

HKEY nls_key

static

Definition at line 311 of file locale.c.

Referenced by get_language_sort(), init_locale(), Internal_EnumLanguageGroupLocales(), Internal_EnumSystemCodePages(), Internal_EnumSystemLanguageGroups(), IsValidLanguageGroup(), and LOCALE_InitRegistry().

◆ norm_info

struct norm_table* norm_info

static

Definition at line 323 of file locale.c.

Referenced by compose_chars(), get_decomposition(), and init_locale().

◆ oem_cpinfo

CPTABLEINFO oem_cpinfo

static

Definition at line 306 of file locale.c.

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

◆

struct { ... } sort

Referenced by _Function_class_(), append_hangul_weights(), append_weights(), BnegateTest::bnegate1(), BnegateTest::bnegate2(), LocaleTest::collate_by_name(), LocaleTest::collate_facet(), find_sortguid(), FuncTest::func2(), FuncTest::func3(), get_char_type(), get_char_weights(), get_compression_weights(), get_language_sort(), get_locale_info(), CDefView::GetArrangeParam(), GetNLSVersionEx(), GreaterTest::greatereq(), GreaterTest::greatert(), IncludesTest::incl2(), lcmap_string(), LessTest::lesseqt(), LessTest::lesst(), ListView_SortEx(), load_sortdefault_nls(), BtrfsDeviceAdd::populate_device_tree(), psh_hint_table_activate_mask(), psh_hint_table_find_strong_points(), CDefView::Rearrange(), should_balance_chunk(), SortTest::sort1(), SortTest::sort2(), SortTest::sort3(), AlgTest::sort_test(), test_GetDefaultColumn(), test_ldap_parse_sort_control(), UnorderedTest::umap(), UnorderedTest::umultimap(), UnorderedTest::umultiset(), UnorderedTest::uset(), xsltComputeSortResult(), and xsltComputeSortResultInternal().

◆ standard_name

WCHAR standard_name[32]

Definition at line 5662 of file locale.c.

◆ system_lcid

LCID system_lcid

static

Definition at line 308 of file locale.c.

Referenced by CompareStringW(), find_entry(), FindNLSString(), get_lcid_codepage(), get_locale_by_name(), GetSystemDefaultLCID(), GetSystemDefaultLocaleName(), init_locale(), LCMapStringW(), load_locale_nls(), and NlsValidateLocale().

◆ system_locale

const NLS_LOCALE_DATA* system_locale

static

Definition at line 317 of file locale.c.

Referenced by get_codepage_table(), get_language_sort(), get_locale_by_name(), GetSystemDefaultLocaleName(), init_locale(), and NlsValidateLocale().

◆ tz_key

HKEY tz_key

static

Definition at line 312 of file locale.c.

Referenced by EnumDynamicTimeZoneInformation(), GetDynamicTimeZoneInformation(), GetDynamicTimeZoneInformationEffectiveYears(), GetTimeZoneInformationForYear(), and init_locale().

◆ tzname_section

static CRITICAL_SECTION tzname_section = { &tzname_section_debug, -1, 0, 0, 0, 0 }

static

Definition at line 5651 of file locale.c.

Referenced by GetDynamicTimeZoneInformation().

◆ tzname_section_debug

CRITICAL_SECTION_DEBUG tzname_section_debug

static

Initial value:

=
{
    0, 0, &tzname_section,
    { &tzname_section_debug.ProcessLocksList, &tzname_section_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": tzname_section") }
}

Definition at line 5652 of file locale.c.

◆ unix_cp

UINT unix_cp = CP_UTF8

static

Definition at line 307 of file locale.c.

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

◆ user_lcid

LCID user_lcid

static

Definition at line 309 of file locale.c.

Referenced by CompareStringW(), find_entry(), FindNLSString(), get_locale_by_name(), GetUserDefaultLCID(), GetUserDefaultLocaleName(), init_locale(), LCMapStringW(), NlsValidateLocale(), SetLocaleInfoW(), and update_registry_value().

◆ user_locale

const NLS_LOCALE_DATA* user_locale

static

Definition at line 318 of file locale.c.

Referenced by get_language_sort(), get_locale_by_name(), get_locale_info(), GetUserDefaultLocaleName(), init_locale(), NlsValidateLocale(), SetLocaleInfoW(), update_locale_registry(), and update_registry_value().

◆ version

int version

Definition at line 414 of file locale.c.

◆ world_subkey

const WCHAR world_subkey[] = { 0xd83c, 0xdf0e, 0xd83c, 0xdf0f, 0xd83c, 0xdf0d, 0 }

static

Definition at line 57 of file locale.c.

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CALINFO_MAX_YEAR

◆ CASE_COMPR_2

◆ CASE_COMPR_4

◆ CASE_COMPR_6

◆ CASE_FULLSIZE

◆ CASE_FULLWIDTH

◆ CASE_KATAKANA

◆ CASE_SUBSCRIPT

◆ CASE_UPPER

◆ ENCODABLE

◆ FLAG_DOUBLECOMPRESSION

◆ FLAG_HAS_3_BYTE_WEIGHTS

◆ FLAG_INVERSECASING

◆ FLAG_REVERSEDIACRITICS

◆ HANGUL_LCOUNT

◆ HANGUL_SBASE

◆ HANGUL_TCOUNT

◆ HANGUL_VCOUNT

◆ MUI_SIGNATURE

◆ OUTPUT [1/2]

◆ OUTPUT [2/2]

◆ UPDATE

◆ WIN32_NO_STATUS

◆ WINNORMALIZEAPI

Enumeration Type Documentation

◆ charmaps

◆ sortkey_script

Function Documentation

◆ append_digit_weights()

◆ append_expansion_weights()

◆ append_extra_kana_weights()

◆ append_hangul_weights()

◆ append_nonspace_weights()

◆ append_normal_weights()

◆ append_sortkey()

◆ append_weights()

◆ cal_return_number()

◆ call_enum_date_func()

◆ casemap()

◆ casemap_high()

◆ casemap_string()

◆ check_invalid_chars()

◆ compare_locale_names()

◆ compare_sortkeys()

◆ compare_string()

◆ compare_tzdate()

◆ CompareStringA()

◆ CompareStringEx()

◆ CompareStringOrdinal()

◆ CompareStringW()

◆ compose_chars()

◆ compression_size()

◆ ConvertDefaultLocale()

◆ EnumCalendarInfoExEx()

◆ EnumCalendarInfoExW()

◆ EnumCalendarInfoW()

◆ EnumDateFormatsExEx()

◆ EnumDateFormatsExW()

◆ EnumDateFormatsW()

◆ EnumDynamicTimeZoneInformation()

◆ EnumLanguageGroupLocalesW()

◆ EnumSystemCodePagesW()

◆ EnumSystemGeoID()

◆ EnumSystemLanguageGroupsW()

◆ EnumSystemLocalesA()

◆ EnumSystemLocalesEx()

◆ EnumSystemLocalesW()

◆ EnumTimeFormatsEx()

◆ EnumTimeFormatsW()

◆ EnumUILanguagesW()

◆ expand_ligatures()

◆ find_compression()

◆ find_format()

◆ find_geo_id_entry()