?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernelbase: Implement NlsValidateLocale().
[wine.git] / dlls / kernelbase / locale.c
blob2c2a47a08b8555937919abd1fc8be223867c62c9
1 /*
2 * Locale support
3 *
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1998 David Lee Lambert
6 * Copyright 2000 Julio César Gázquez
7 * Copyright 2003 Jon Griffiths
8 * Copyright 2005 Dmitry Timoshkov
9 * Copyright 2002, 2019 Alexandre Julliard
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include <stdarg.h>
27 #include <stdlib.h>
28
29 #include "ntstatus.h"
30 #define WIN32_NO_STATUS
31 #define WINNORMALIZEAPI
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winreg.h"
35 #include "winnls.h"
36 #include "winuser.h"
37 #include "winternl.h"
38 #include "kernelbase.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(nls);
42
43 #define CALINFO_MAX_YEAR 2029
44
45 extern const unsigned int collation_table[] DECLSPEC_HIDDEN;
46
47 static HMODULE kernelbase_handle;
48
49 struct registry_entry
50 {
51 const WCHAR *value;
52 enum { NOT_CACHED, CACHED, MISSING } status;
53 WCHAR data[80];
54 };
55
56 static struct registry_entry entry_icalendartype = { L"iCalendarType" };
57 static struct registry_entry entry_icountry = { L"iCountry" };
58 static struct registry_entry entry_icurrdigits = { L"iCurrDigits" };
59 static struct registry_entry entry_icurrency = { L"iCurrency" };
60 static struct registry_entry entry_idigits = { L"iDigits" };
61 static struct registry_entry entry_idigitsubstitution = { L"NumShape" };
62 static struct registry_entry entry_ifirstdayofweek = { L"iFirstDayOfWeek" };
63 static struct registry_entry entry_ifirstweekofyear = { L"iFirstWeekOfYear" };
64 static struct registry_entry entry_ilzero = { L"iLZero" };
65 static struct registry_entry entry_imeasure = { L"iMeasure" };
66 static struct registry_entry entry_inegcurr = { L"iNegCurr" };
67 static struct registry_entry entry_inegnumber = { L"iNegNumber" };
68 static struct registry_entry entry_ipapersize = { L"iPaperSize" };
69 static struct registry_entry entry_s1159 = { L"s1159" };
70 static struct registry_entry entry_s2359 = { L"s2359" };
71 static struct registry_entry entry_scurrency = { L"sCurrency" };
72 static struct registry_entry entry_sdecimal = { L"sDecimal" };
73 static struct registry_entry entry_sgrouping = { L"sGrouping" };
74 static struct registry_entry entry_slist = { L"sList" };
75 static struct registry_entry entry_slongdate = { L"sLongDate" };
76 static struct registry_entry entry_smondecimalsep = { L"sMonDecimalSep" };
77 static struct registry_entry entry_smongrouping = { L"sMonGrouping" };
78 static struct registry_entry entry_smonthousandsep = { L"sMonThousandSep" };
79 static struct registry_entry entry_snativedigits = { L"sNativeDigits" };
80 static struct registry_entry entry_snegativesign = { L"sNegativeSign" };
81 static struct registry_entry entry_spositivesign = { L"sPositiveSign" };
82 static struct registry_entry entry_sshortdate = { L"sShortDate" };
83 static struct registry_entry entry_sshorttime = { L"sShortTime" };
84 static struct registry_entry entry_sthousand = { L"sThousand" };
85 static struct registry_entry entry_stimeformat = { L"sTimeFormat" };
86 static struct registry_entry entry_syearmonth = { L"sYearMonth" };
87
88
89 static const struct { UINT cp; const WCHAR *name; } codepage_names[] =
90 {
91 { 37, L"IBM EBCDIC US Canada" },
92 { 424, L"IBM EBCDIC Hebrew" },
93 { 437, L"OEM United States" },
94 { 500, L"IBM EBCDIC International" },
95 { 708, L"Arabic ASMO" },
96 { 720, L"Arabic (Transparent ASMO)" },
97 { 737, L"OEM Greek 437G" },
98 { 775, L"OEM Baltic" },
99 { 850, L"OEM Multilingual Latin 1" },
100 { 852, L"OEM Slovak Latin 2" },
101 { 855, L"OEM Cyrillic" },
102 { 856, L"Hebrew PC" },
103 { 857, L"OEM Turkish" },
104 { 860, L"OEM Portuguese" },
105 { 861, L"OEM Icelandic" },
106 { 862, L"OEM Hebrew" },
107 { 863, L"OEM Canadian French" },
108 { 864, L"OEM Arabic" },
109 { 865, L"OEM Nordic" },
110 { 866, L"OEM Russian" },
111 { 869, L"OEM Greek" },
112 { 874, L"ANSI/OEM Thai" },
113 { 875, L"IBM EBCDIC Greek" },
114 { 878, L"Russian KOI8" },
115 { 932, L"ANSI/OEM Japanese Shift-JIS" },
116 { 936, L"ANSI/OEM Simplified Chinese GBK" },
117 { 949, L"ANSI/OEM Korean Unified Hangul" },
118 { 950, L"ANSI/OEM Traditional Chinese Big5" },
119 { 1006, L"IBM Arabic" },
120 { 1026, L"IBM EBCDIC Latin 5 Turkish" },
121 { 1250, L"ANSI Eastern Europe" },
122 { 1251, L"ANSI Cyrillic" },
123 { 1252, L"ANSI Latin 1" },
124 { 1253, L"ANSI Greek" },
125 { 1254, L"ANSI Turkish" },
126 { 1255, L"ANSI Hebrew" },
127 { 1256, L"ANSI Arabic" },
128 { 1257, L"ANSI Baltic" },
129 { 1258, L"ANSI/OEM Viet Nam" },
130 { 1361, L"Korean Johab" },
131 { 10000, L"Mac Roman" },
132 { 10001, L"Mac Japanese" },
133 { 10002, L"Mac Traditional Chinese" },
134 { 10003, L"Mac Korean" },
135 { 10004, L"Mac Arabic" },
136 { 10005, L"Mac Hebrew" },
137 { 10006, L"Mac Greek" },
138 { 10007, L"Mac Cyrillic" },
139 { 10008, L"Mac Simplified Chinese" },
140 { 10010, L"Mac Romanian" },
141 { 10017, L"Mac Ukrainian" },
142 { 10021, L"Mac Thai" },
143 { 10029, L"Mac Latin 2" },
144 { 10079, L"Mac Icelandic" },
145 { 10081, L"Mac Turkish" },
146 { 10082, L"Mac Croatian" },
147 { 20127, L"US-ASCII (7bit)" },
148 { 20866, L"Russian KOI8" },
149 { 20932, L"EUC-JP" },
150 { 20949, L"Korean Wansung" },
151 { 21866, L"Ukrainian KOI8" },
152 { 28591, L"ISO 8859-1 Latin 1" },
153 { 28592, L"ISO 8859-2 Latin 2 (East European)" },
154 { 28593, L"ISO 8859-3 Latin 3 (South European)" },
155 { 28594, L"ISO 8859-4 Latin 4 (Baltic old)" },
156 { 28595, L"ISO 8859-5 Cyrillic" },
157 { 28596, L"ISO 8859-6 Arabic" },
158 { 28597, L"ISO 8859-7 Greek" },
159 { 28598, L"ISO 8859-8 Hebrew" },
160 { 28599, L"ISO 8859-9 Latin 5 (Turkish)" },
161 { 28600, L"ISO 8859-10 Latin 6 (Nordic)" },
162 { 28601, L"ISO 8859-11 Latin (Thai)" },
163 { 28603, L"ISO 8859-13 Latin 7 (Baltic)" },
164 { 28604, L"ISO 8859-14 Latin 8 (Celtic)" },
165 { 28605, L"ISO 8859-15 Latin 9 (Euro)" },
166 { 28606, L"ISO 8859-16 Latin 10 (Balkan)" },
167 { 65000, L"Unicode (UTF-7)" },
168 { 65001, L"Unicode (UTF-8)" }
169 };
170
171 /* Unicode expanded ligatures */
172 static const WCHAR ligatures[][5] =
173 {
174 { 0x00c6, 'A','E',0 },
175 { 0x00de, 'T','H',0 },
176 { 0x00df, 's','s',0 },
177 { 0x00e6, 'a','e',0 },
178 { 0x00fe, 't','h',0 },
179 { 0x0132, 'I','J',0 },
180 { 0x0133, 'i','j',0 },
181 { 0x0152, 'O','E',0 },
182 { 0x0153, 'o','e',0 },
183 { 0x01c4, 'D',0x017d,0 },
184 { 0x01c5, 'D',0x017e,0 },
185 { 0x01c6, 'd',0x017e,0 },
186 { 0x01c7, 'L','J',0 },
187 { 0x01c8, 'L','j',0 },
188 { 0x01c9, 'l','j',0 },
189 { 0x01ca, 'N','J',0 },
190 { 0x01cb, 'N','j',0 },
191 { 0x01cc, 'n','j',0 },
192 { 0x01e2, 0x0100,0x0112,0 },
193 { 0x01e3, 0x0101,0x0113,0 },
194 { 0x01f1, 'D','Z',0 },
195 { 0x01f2, 'D','z',0 },
196 { 0x01f3, 'd','z',0 },
197 { 0x01fc, 0x00c1,0x00c9,0 },
198 { 0x01fd, 0x00e1,0x00e9,0 },
199 { 0x05f0, 0x05d5,0x05d5,0 },
200 { 0x05f1, 0x05d5,0x05d9,0 },
201 { 0x05f2, 0x05d9,0x05d9,0 },
202 { 0xfb00, 'f','f',0 },
203 { 0xfb01, 'f','i',0 },
204 { 0xfb02, 'f','l',0 },
205 { 0xfb03, 'f','f','i',0 },
206 { 0xfb04, 'f','f','l',0 },
207 { 0xfb05, 0x017f,'t',0 },
208 { 0xfb06, 's','t',0 },
209 };
210
211 struct calendar
212 {
213 USHORT icalintvalue; /* 00 */
214 USHORT itwodigityearmax; /* 02 */
215 UINT sshortdate; /* 04 */
216 UINT syearmonth; /* 08 */
217 UINT slongdate; /* 0c */
218 UINT serastring; /* 10 */
219 UINT iyearoffsetrange; /* 14 */
220 UINT sdayname; /* 18 */
221 UINT sabbrevdayname; /* 1c */
222 UINT smonthname; /* 20 */
223 UINT sabbrevmonthname; /* 24 */
224 UINT scalname; /* 28 */
225 UINT smonthday; /* 2c */
226 UINT sabbreverastring; /* 30 */
227 UINT sshortestdayname; /* 34 */
228 UINT srelativelongdate; /* 38 */
229 UINT unused[3]; /* 3c */
230 };
231
232 static const struct geo_id
233 {
234 GEOID id;
235 WCHAR latitude[12];
236 WCHAR longitude[12];
237 GEOCLASS class;
238 GEOID parent;
239 WCHAR iso2[4];
240 WCHAR iso3[4];
241 USHORT uncode;
242 USHORT dialcode;
243 WCHAR currcode[4];
244 WCHAR currsymbol[8];
245 } *geo_ids;
246
247 static const struct geo_index
248 {
249 WCHAR name[4];
250 UINT idx;
251 } *geo_index;
252
253 static unsigned int geo_ids_count;
254 static unsigned int geo_index_count;
255
256 /* NLS normalization file */
257 struct norm_table
258 {
259 WCHAR name[13]; /* 00 file name */
260 USHORT checksum[3]; /* 1a checksum? */
261 USHORT version[4]; /* 20 Unicode version */
262 USHORT form; /* 28 normalization form */
263 USHORT len_factor; /* 2a factor for length estimates */
264 USHORT unknown1; /* 2c */
265 USHORT decomp_size; /* 2e decomposition hash size */
266 USHORT comp_size; /* 30 composition hash size */
267 USHORT unknown2; /* 32 */
268 USHORT classes; /* 34 combining classes table offset */
269 USHORT props_level1; /* 36 char properties table level 1 offset */
270 USHORT props_level2; /* 38 char properties table level 2 offset */
271 USHORT decomp_hash; /* 3a decomposition hash table offset */
272 USHORT decomp_map; /* 3c decomposition character map table offset */
273 USHORT decomp_seq; /* 3e decomposition character sequences offset */
274 USHORT comp_hash; /* 40 composition hash table offset */
275 USHORT comp_seq; /* 42 composition character sequences offset */
276 /* BYTE[] combining class values */
277 /* BYTE[0x2200] char properties index level 1 */
278 /* BYTE[] char properties index level 2 */
279 /* WORD[] decomposition hash table */
280 /* WORD[] decomposition character map */
281 /* WORD[] decomposition character sequences */
282 /* WORD[] composition hash table */
283 /* WORD[] composition character sequences */
284 };
285
286 static NLSTABLEINFO nls_info;
287 static UINT unix_cp = CP_UTF8;
288 static UINT mac_cp = 10000;
289 static LCID system_lcid;
290 static LCID user_lcid;
291 static HKEY intl_key;
292 static HKEY nls_key;
293 static HKEY tz_key;
294 static const NLS_LOCALE_LCID_INDEX *lcids_index;
295 static const NLS_LOCALE_LCNAME_INDEX *lcnames_index;
296 static const NLS_LOCALE_HEADER *locale_table;
297 static const WCHAR *locale_strings;
298 static const NLS_LOCALE_DATA *system_locale;
299 static const NLS_LOCALE_DATA *user_locale;
300
301 static CPTABLEINFO codepages[128];
302 static unsigned int nb_codepages;
303
304 static struct norm_table *norm_info;
305
306 struct sortguid
307 {
308 GUID id; /* sort GUID */
309 DWORD flags; /* flags */
310 DWORD compr; /* offset to compression table */
311 DWORD except; /* exception table offset in sortkey table */
312 DWORD ling_except; /* exception table offset for linguistic casing */
313 DWORD casemap; /* linguistic casemap table offset */
314 };
315
316 #define FLAG_HAS_3_BYTE_WEIGHTS 0x01
317 #define FLAG_REVERSEDIACRITICS 0x10
318 #define FLAG_DOUBLECOMPRESSION 0x20
319 #define FLAG_INVERSECASING 0x40
320
321 static const struct sortguid *current_locale_sort;
322
323 static const GUID default_sort_guid = { 0x00000001, 0x57ee, 0x1e5c, { 0x00, 0xb4, 0xd0, 0x00, 0x0b, 0xb1, 0xe1, 0x1e }};
324
325 static struct
326 {
327 DWORD *keys; /* sortkey table, indexed by char */
328 USHORT *casemap; /* casemap table, in l_intl.nls format */
329 WORD *ctypes; /* CT_CTYPE1,2,3 values */
330 BYTE *ctype_idx; /* index to map char to ctypes array entry */
331 DWORD version; /* NLS version */
332 DWORD guid_count; /* number of sort GUIDs */
333 struct sortguid *guids; /* table of sort GUIDs */
334 } sort;
335
336 static CRITICAL_SECTION locale_section;
337 static CRITICAL_SECTION_DEBUG critsect_debug =
338 {
339 0, 0, &locale_section,
340 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
341 0, 0, { (DWORD_PTR)(__FILE__ ": locale_section") }
342 };
343 static CRITICAL_SECTION locale_section = { &critsect_debug, -1, 0, 0, 0, 0 };
344
345
346 static void load_locale_nls(void)
347 {
348 struct
349 {
350 UINT ctypes;
351 UINT unknown1;
352 UINT unknown2;
353 UINT unknown3;
354 UINT locales;
355 UINT charmaps;
356 UINT geoids;
357 UINT scripts;
358 } *header;
359 struct geo_header
360 {
361 WCHAR signature[4]; /* L"geo" */
362 UINT total_size;
363 UINT ids_offset;
364 UINT ids_count;
365 UINT index_offset;
366 UINT index_count;
367 } *geo_header;
368
369 LCID lcid;
370 LARGE_INTEGER dummy;
371
372 RtlGetLocaleFileMappingAddress( (void **)&header, &lcid, &dummy );
373 locale_table = (const NLS_LOCALE_HEADER *)((char *)header + header->locales);
374 lcids_index = (const NLS_LOCALE_LCID_INDEX *)((char *)locale_table + locale_table->lcids_offset);
375 lcnames_index = (const NLS_LOCALE_LCNAME_INDEX *)((char *)locale_table + locale_table->lcnames_offset);
376 locale_strings = (const WCHAR *)((char *)locale_table + locale_table->strings_offset);
377 geo_header = (struct geo_header *)((char *)header + header->geoids);
378 geo_ids = (const struct geo_id *)((char *)geo_header + geo_header->ids_offset);
379 geo_index = (const struct geo_index *)((char *)geo_header + geo_header->index_offset);
380 geo_ids_count = geo_header->ids_count;
381 geo_index_count = geo_header->index_count;
382 }
383
384
385 static void init_sortkeys( DWORD *ptr )
386 {
387 WORD *ctype;
388 DWORD *table;
389
390 sort.keys = (DWORD *)((char *)ptr + ptr[0]);
391 sort.casemap = (USHORT *)((char *)ptr + ptr[1]);
392
393 ctype = (WORD *)((char *)ptr + ptr[2]);
394 sort.ctypes = ctype + 2;
395 sort.ctype_idx = (BYTE *)ctype + ctype[1] + 2;
396
397 table = (DWORD *)((char *)ptr + ptr[3]);
398 sort.version = table[0];
399 sort.guid_count = table[1];
400 sort.guids = (struct sortguid *)(table + 2);
401 }
402
403
404 static const struct sortguid *find_sortguid( const GUID *guid )
405 {
406 int pos, ret, min = 0, max = sort.guid_count - 1;
407
408 while (min <= max)
409 {
410 pos = (min + max) / 2;
411 ret = memcmp( guid, &sort.guids[pos].id, sizeof(*guid) );
412 if (!ret) return &sort.guids[pos];
413 if (ret > 0) min = pos + 1;
414 else max = pos - 1;
415 }
416 ERR( "no sort found for %s\n", debugstr_guid( guid ));
417 return NULL;
418 }
419
420
421 static const struct sortguid *get_language_sort( const WCHAR *locale )
422 {
423 WCHAR *p, *end, buffer[LOCALE_NAME_MAX_LENGTH], guidstr[39];
424 const struct sortguid *ret;
425 UNICODE_STRING str;
426 GUID guid;
427 HKEY key = 0;
428 DWORD size, type;
429
430 if (locale == LOCALE_NAME_USER_DEFAULT)
431 {
432 if (current_locale_sort) return current_locale_sort;
433 GetUserDefaultLocaleName( buffer, ARRAY_SIZE( buffer ));
434 }
435 else lstrcpynW( buffer, locale, LOCALE_NAME_MAX_LENGTH );
436
437 if (buffer[0] && !RegOpenKeyExW( nls_key, L"Sorting\\Ids", 0, KEY_READ, &key ))
438 {
439 for (;;)
440 {
441 size = sizeof(guidstr);
442 if (!RegQueryValueExW( key, buffer, NULL, &type, (BYTE *)guidstr, &size ) && type == REG_SZ)
443 {
444 RtlInitUnicodeString( &str, guidstr );
445 if (!RtlGUIDFromString( &str, &guid ))
446 {
447 ret = find_sortguid( &guid );
448 goto done;
449 }
450 break;
451 }
452 for (p = end = buffer; *p; p++) if (*p == '-' || *p == '_') end = p;
453 if (end == buffer) break;
454 *end = 0;
455 }
456 }
457 ret = find_sortguid( &default_sort_guid );
458 done:
459 RegCloseKey( key );
460 return ret;
461 }
462
463
464 static const NLS_LOCALE_DATA *get_locale_data( UINT idx )
465 {
466 ULONG offset = locale_table->locales_offset + idx * locale_table->locale_size;
467 return (const NLS_LOCALE_DATA *)((const char *)locale_table + offset);
468 }
469
470
471 static int compare_locale_names( const WCHAR *n1, const WCHAR *n2 )
472 {
473 for (;;)
474 {
475 WCHAR ch1 = *n1++;
476 WCHAR ch2 = *n2++;
477 if (ch1 >= 'a' && ch1 <= 'z') ch1 -= 'a' - 'A';
478 else if (ch1 == '_') ch1 = '-';
479 if (ch2 >= 'a' && ch2 <= 'z') ch2 -= 'a' - 'A';
480 else if (ch2 == '_') ch2 = '-';
481 if (!ch1 || ch1 != ch2) return ch1 - ch2;
482 }
483 }
484
485
486 static const NLS_LOCALE_LCNAME_INDEX *find_lcname_entry( const WCHAR *name )
487 {
488 int min = 0, max = locale_table->nb_lcnames - 1;
489
490 while (min <= max)
491 {
492 int res, pos = (min + max) / 2;
493 const WCHAR *str = locale_strings + lcnames_index[pos].name;
494 res = compare_locale_names( name, str + 1 );
495 if (res < 0) max = pos - 1;
496 else if (res > 0) min = pos + 1;
497 else return &lcnames_index[pos];
498 }
499 return NULL;
500 }
501
502
503 static const NLS_LOCALE_LCID_INDEX *find_lcid_entry( LCID lcid )
504 {
505 int min = 0, max = locale_table->nb_lcids - 1;
506
507 while (min <= max)
508 {
509 int pos = (min + max) / 2;
510 if (lcid < lcids_index[pos].id) max = pos - 1;
511 else if (lcid > lcids_index[pos].id) min = pos + 1;
512 else return &lcids_index[pos];
513 }
514 return NULL;
515 }
516
517
518 static const struct geo_id *find_geo_id_entry( GEOID id )
519 {
520 int min = 0, max = geo_ids_count - 1;
521
522 while (min <= max)
523 {
524 int pos = (min + max) / 2;
525 if (id < geo_ids[pos].id) max = pos - 1;
526 else if (id > geo_ids[pos].id) min = pos + 1;
527 else return &geo_ids[pos];
528 }
529 return NULL;
530 }
531
532
533 static const struct geo_id *find_geo_name_entry( const WCHAR *name )
534 {
535 int min = 0, max = geo_index_count - 1;
536
537 while (min <= max)
538 {
539 int res, pos = (min + max) / 2;
540 res = wcsicmp( name, geo_index[pos].name );
541 if (res < 0) max = pos - 1;
542 else if (res > 0) min = pos + 1;
543 else return &geo_ids[geo_index[pos].idx];
544 }
545 return NULL;
546 }
547
548
549 static const NLS_LOCALE_DATA *get_locale_by_name( const WCHAR *name, LCID *lcid )
550 {
551 const NLS_LOCALE_LCNAME_INDEX *entry;
552
553 if (name == LOCALE_NAME_USER_DEFAULT)
554 {
555 *lcid = user_lcid;
556 return user_locale;
557 }
558 if (!(entry = find_lcname_entry( name ))) return NULL;
559 *lcid = entry->id;
560 return get_locale_data( entry->idx );
561 }
562
563
564 /******************************************************************************
565 * NlsValidateLocale (kernelbase.@)
566 *
567 * Note: it seems to return some internal data on Windows, we simply return the locale.nls data pointer.
568 */
569 const NLS_LOCALE_DATA * WINAPI NlsValidateLocale( LCID *lcid, ULONG flags )
570 {
571 const NLS_LOCALE_LCNAME_INDEX *name_entry;
572 const NLS_LOCALE_LCID_INDEX *entry;
573 const NLS_LOCALE_DATA *locale;
574
575 switch (*lcid)
576 {
577 case LOCALE_SYSTEM_DEFAULT:
578 *lcid = system_lcid;
579 return system_locale;
580 case LOCALE_NEUTRAL:
581 case LOCALE_USER_DEFAULT:
582 case LOCALE_CUSTOM_DEFAULT:
583 case LOCALE_CUSTOM_UNSPECIFIED:
584 case LOCALE_CUSTOM_UI_DEFAULT:
585 *lcid = user_lcid;
586 return user_locale;
587 default:
588 if (!(entry = find_lcid_entry( *lcid ))) return NULL;
589 locale = get_locale_data( entry->idx );
590 if ((flags & LOCALE_ALLOW_NEUTRAL_NAMES) || locale->inotneutral) return locale;
591 if ((name_entry = find_lcname_entry( locale_strings + locale->ssortlocale + 1 )))
592 locale = get_locale_data( name_entry->idx );
593 return locale;
594 }
595 }
596
597
598 static int locale_return_data( const WCHAR *data, int datalen, LCTYPE type, WCHAR *buffer, int len )
599 {
600 if (type & LOCALE_RETURN_NUMBER)
601 {
602 SetLastError( ERROR_INVALID_FLAGS );
603 return 0;
604 }
605
606 if (!len) return datalen;
607 if (datalen > len)
608 {
609 SetLastError( ERROR_INSUFFICIENT_BUFFER );
610 return 0;
611 }
612 memcpy( buffer, data, datalen * sizeof(WCHAR) );
613 return datalen;
614 }
615
616
617 static BOOL set_registry_entry( struct registry_entry *entry, const WCHAR *data )
618 {
619 DWORD size = (wcslen(data) + 1) * sizeof(WCHAR);
620 LSTATUS ret;
621
622 if (size > sizeof(entry->data))
623 {
624 SetLastError( ERROR_INVALID_FLAGS );
625 return FALSE;
626 }
627 TRACE( "setting %s to %s\n", debugstr_w(entry->value), debugstr_w(data) );
628
629 RtlEnterCriticalSection( &locale_section );
630 if (!(ret = RegSetValueExW( intl_key, entry->value, 0, REG_SZ, (BYTE *)data, size )))
631 {
632 wcscpy( entry->data, data );
633 entry->status = CACHED;
634 }
635 RtlLeaveCriticalSection( &locale_section );
636 if (ret) SetLastError( ret );
637 return !ret;
638 }
639
640
641 static int locale_return_reg_string( struct registry_entry *entry, LCTYPE type, WCHAR *buffer, int len )
642 {
643 DWORD size;
644 LRESULT res;
645 int ret = -1;
646
647 if (type & LOCALE_NOUSEROVERRIDE) return -1;
648
649 RtlEnterCriticalSection( &locale_section );
650 switch (entry->status)
651 {
652 case NOT_CACHED:
653 size = sizeof(entry->data);
654 res = RegQueryValueExW( intl_key, entry->value, NULL, NULL, (BYTE *)entry->data, &size );
655 if (res)
656 {
657 entry->status = MISSING;
658 break;
659 }
660 entry->status = CACHED;
661 /* fall through */
662 case CACHED:
663 ret = locale_return_data( entry->data, wcslen(entry->data) + 1, type, buffer, len );
664 break;
665 case MISSING:
666 break;
667 }
668 RtlLeaveCriticalSection( &locale_section );
669 return ret;
670 }
671
672
673 static int locale_return_string( DWORD pos, LCTYPE type, WCHAR *buffer, int len )
674 {
675 return locale_return_data( locale_strings + pos + 1, locale_strings[pos] + 1, type, buffer, len );
676 }
677
678
679 static int locale_return_number( UINT val, LCTYPE type, WCHAR *buffer, int len )
680 {
681 int ret;
682 WCHAR tmp[80];
683
684 if (!(type & LOCALE_RETURN_NUMBER))
685 {
686 switch (LOWORD(type))
687 {
688 case LOCALE_ILANGUAGE:
689 case LOCALE_IDEFAULTLANGUAGE:
690 ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%04x", val ) + 1;
691 break;
692 case LOCALE_IDEFAULTEBCDICCODEPAGE:
693 ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%03u", val ) + 1;
694 break;
695 default:
696 ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%u", val ) + 1;
697 break;
698 }
699 }
700 else ret = sizeof(UINT) / sizeof(WCHAR);
701
702 if (!len) return ret;
703 if (ret > len)
704 {
705 SetLastError( ERROR_INSUFFICIENT_BUFFER );
706 return 0;
707 }
708
709 if (type & LOCALE_RETURN_NUMBER) memcpy( buffer, &val, sizeof(val) );
710 else wcscpy( buffer, tmp );
711
712 return ret;
713 }
714
715
716 static int locale_return_reg_number( struct registry_entry *entry, LCTYPE type, WCHAR *buffer, int len )
717 {
718 int ret, val;
719 WCHAR *end, tmp[80];
720
721 if (type & LOCALE_RETURN_NUMBER)
722 {
723 ret = locale_return_reg_string( entry, type & ~LOCALE_RETURN_NUMBER, tmp, ARRAY_SIZE( tmp ));
724 if (ret == -1) return ret;
725 val = wcstol( tmp, &end, 10 );
726 if (*end) /* invalid number */
727 {
728 SetLastError( ERROR_INVALID_FLAGS );
729 return 0;
730 }
731 return locale_return_number( val, type, buffer, len );
732 }
733 return locale_return_reg_string( entry, type, buffer, len );
734 }
735
736
737 static int locale_return_grouping( DWORD pos, LCTYPE type, WCHAR *buffer, int len )
738 {
739 WORD i, count = locale_strings[pos];
740 const WCHAR *str = locale_strings + pos + 1;
741 int ret;
742
743 if (type & LOCALE_RETURN_NUMBER)
744 {
745 SetLastError( ERROR_INVALID_FLAGS );
746 return 0;
747 }
748 ret = 2 * count;
749 if (str[count - 1]) ret += 2; /* for final zero */
750
751 if (!len) return ret;
752 if (ret > len)
753 {
754 SetLastError( ERROR_INSUFFICIENT_BUFFER );
755 return 0;
756 }
757 for (i = 0; i < count; i++)
758 {
759 if (!str[i]) /* explicit null termination */
760 {
761 buffer[-1] = 0;
762 return ret;
763 }
764 *buffer++ = '0' + str[i];
765 *buffer++ = ';';
766 }
767 *buffer++ = '0';
768 *buffer = 0;
769 return ret;
770 }
771
772
773 static int locale_return_strarray( DWORD pos, WORD idx, LCTYPE type, WCHAR *buffer, int len )
774 {
775 const DWORD *array = (const DWORD *)(locale_strings + pos + 1);
776 WORD count = locale_strings[pos];
777
778 return locale_return_string( idx < count ? array[idx] : 0, type, buffer, len );
779 }
780
781
782 static int locale_return_strarray_concat( DWORD pos, LCTYPE type, WCHAR *buffer, int len )
783 {
784 WORD i, count = locale_strings[pos];
785 const DWORD *array = (const DWORD *)(locale_strings + pos + 1);
786 int ret;
787
788 if (type & LOCALE_RETURN_NUMBER)
789 {
790 SetLastError( ERROR_INVALID_FLAGS );
791 return 0;
792 }
793 for (i = 0, ret = 1; i < count; i++) ret += locale_strings[array[i]];
794
795 if (!len) return ret;
796 if (ret > len)
797 {
798 SetLastError( ERROR_INSUFFICIENT_BUFFER );
799 return 0;
800 }
801 for (i = 0; i < count; i++)
802 {
803 memcpy( buffer, locale_strings + array[i] + 1, locale_strings[array[i]] * sizeof(WCHAR) );
804 buffer += locale_strings[array[i]];
805 }
806 *buffer = 0;
807 return ret;
808 }
809
810
811 static int cal_return_number( UINT val, CALTYPE type, WCHAR *buffer, int len, DWORD *value )
812 {
813 WCHAR tmp[12];
814 int ret;
815
816 if (type & CAL_RETURN_NUMBER)
817 {
818 *value = val;
819 return sizeof(UINT) / sizeof(WCHAR);
820 }
821 ret = swprintf( tmp, ARRAY_SIZE(tmp), L"%u", val );
822 return locale_return_data( tmp, ret + 1, 0, buffer, len );
823 }
824
825
826 /* find the first format char in a format string */
827 static WCHAR *find_format( WCHAR *str, const WCHAR *accept )
828 {
829 for ( ; *str; str++)
830 {
831 if (*str == '\'')
832 {
833 if (!(str = wcschr( str + 1, '\'' ))) return NULL;
834 }
835 else if (wcschr( accept, *str ))
836 {
837 /* ignore "ddd" and "dddd" */
838 if (str[0] != 'd' || str[1] != 'd' || str[2] != 'd') return str;
839 str += 2;
840 while (str[1] == 'd') str++;
841 }
842 }
843 return NULL;
844 }
845
846
847 /* replace the separator in a date/time format string */
848 static WCHAR *locale_replace_separator( WCHAR *buffer, const WCHAR *sep )
849 {
850 UINT pos = 0;
851 WCHAR res[80];
852 WCHAR *next, *str = find_format( buffer, L"dMyHhms" );
853
854 if (!str) return buffer;
855 pos = str - buffer;
856 memcpy( res, buffer, pos * sizeof(WCHAR) );
857 for (;;)
858 {
859 res[pos++] = *str++;
860 while (str[0] == str[-1]) res[pos++] = *str++; /* copy repeated chars */
861 if (!(next = find_format( str, L"dMyHhms" ))) break;
862 wcscpy( res + pos, sep );
863 pos += wcslen(sep);
864 str = next;
865 }
866 wcscpy( res + pos, str );
867 return wcscpy( buffer, res );
868 }
869
870
871 /* FIXME: hardcoded, sortname is apparently not available in locale.nls */
872 static const WCHAR *get_locale_sortname( LCID lcid )
873 {
874 switch (PRIMARYLANGID( lcid ))
875 {
876 case LANG_CHINESE:
877 switch (SORTIDFROMLCID( lcid ))
878 {
879 case SORT_CHINESE_PRCP:
880 switch (SUBLANGID( lcid ))
881 {
882 case SUBLANG_CHINESE_TRADITIONAL:
883 case SUBLANG_CHINESE_HONGKONG:
884 case 0x1f:
885 return L"Stroke Count";
886 default:
887 return L"Pronunciation";
888 }
889 case SORT_CHINESE_UNICODE: return L"Unicode";
890 case SORT_CHINESE_PRC: return L"Stroke Count";
891 case SORT_CHINESE_BOPOMOFO: return L"Bopomofo";
892 case SORT_CHINESE_RADICALSTROKE: return L"Radical/Stroke";
893 case 5: return L"Surname";
894 }
895 break;
896
897 case LANG_GEORGIAN:
898 if (SORTIDFROMLCID( lcid ) == SORT_GEORGIAN_MODERN) return L"Modern";
899 return L"Traditional";
900
901 case LANG_GERMAN:
902 switch (SUBLANGID( lcid ))
903 {
904 case SUBLANG_NEUTRAL:
905 case SUBLANG_DEFAULT:
906 if (SORTIDFROMLCID( lcid ) == SORT_GERMAN_PHONE_BOOK) return L"Phone Book (DIN)";
907 return L"Dictionary";
908 }
909 break;
910
911 case LANG_HUNGARIAN:
912 if (SORTIDFROMLCID( lcid ) == SORT_HUNGARIAN_TECHNICAL) return L"Technical";
913 break;
914
915 case LANG_INVARIANT:
916 if (SORTIDFROMLCID( lcid ) == SORT_INVARIANT_MATH) return L"Default";
917 return L"Maths Alphanumerics";
918
919 case LANG_JAPANESE:
920 switch (SORTIDFROMLCID( lcid ))
921 {
922 case SORT_JAPANESE_XJIS: return L"XJIS";
923 case SORT_JAPANESE_UNICODE: return L"Unicode";
924 case SORT_JAPANESE_RADICALSTROKE: return L"Radical/Stroke";
925 }
926 break;
927
928 case LANG_KOREAN:
929 if (SORTIDFROMLCID( lcid ) == SORT_KOREAN_UNICODE) return L"Unicode";
930 return L"Dictionary";
931
932 case LANG_SPANISH:
933 switch (SUBLANGID( lcid ))
934 {
935 case SUBLANG_NEUTRAL:
936 case SUBLANG_SPANISH_MODERN:
937 return L"International";
938 case SUBLANG_DEFAULT:
939 return L"Traditional";
940 }
941 break;
942 }
943 return L"Default";
944 }
945
946
947 /* get locale information from the locale.nls file */
948 static int get_locale_info( const NLS_LOCALE_DATA *locale, LCID lcid, LCTYPE type,
949 WCHAR *buffer, int len )
950 {
951 static const WCHAR spermille[] = { 0x2030, 0 }; /* this one seems hardcoded */
952 static const BYTE ipossignposn[] = { 3, 3, 4, 2, 1, 1, 3, 4, 1, 3, 4, 2, 4, 3, 3, 1 };
953 static const BYTE inegsignposn[] = { 0, 3, 4, 2, 0, 1, 3, 4, 1, 3, 4, 2, 4, 3, 0, 0 };
954 static const BYTE inegsymprecedes[] = { 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, };
955 const WCHAR *sort;
956 WCHAR *str, *end, tmp[80];
957 UINT val;
958 int ret;
959
960 if (locale != user_locale) type |= LOCALE_NOUSEROVERRIDE;
961
962 switch (LOWORD(type))
963 {
964 case LOCALE_ILANGUAGE:
965 /* return default language for neutral locales */
966 val = locale->inotneutral ? locale->ilanguage : locale->idefaultlanguage;
967 return locale_return_number( val, type, buffer, len );
968
969 case LOCALE_SLOCALIZEDDISPLAYNAME:
970 /* FIXME: localization */
971 return locale_return_string( locale->sengdisplayname, type, buffer, len );
972
973 case LOCALE_SABBREVLANGNAME:
974 return locale_return_string( locale->sabbrevlangname, type, buffer, len );
975
976 case LOCALE_SNATIVELANGNAME:
977 return locale_return_string( locale->snativelangname, type, buffer, len );
978
979 case LOCALE_ICOUNTRY:
980 if ((ret = locale_return_reg_number( &entry_icountry, type, buffer, len )) != -1) return ret;
981 return locale_return_number( locale->icountry, type, buffer, len );
982
983 case LOCALE_SLOCALIZEDCOUNTRYNAME:
984 /* FIXME: localization */
985 return locale_return_string( locale->sengcountry, type, buffer, len );
986
987 case LOCALE_SABBREVCTRYNAME:
988 return locale_return_string( locale->sabbrevctryname, type, buffer, len );
989
990 case LOCALE_SNATIVECTRYNAME:
991 return locale_return_string( locale->snativectryname, type, buffer, len );
992
993 case LOCALE_IDEFAULTLANGUAGE:
994 return locale_return_number( locale->idefaultlanguage, type, buffer, len );
995
996 case LOCALE_IDEFAULTCOUNTRY:
997 return locale_return_number( locale->icountry, type, buffer, len );
998
999 case LOCALE_IDEFAULTCODEPAGE:
1000 val = locale->idefaultcodepage == CP_UTF8 ? CP_OEMCP : locale->idefaultcodepage;
1001 return locale_return_number( val, type, buffer, len );
1002
1003 case LOCALE_SLIST:
1004 if ((ret = locale_return_reg_string( &entry_slist, type, buffer, len )) != -1) return ret;
1005 return locale_return_string( locale->slist, type, buffer, len );
1006
1007 case LOCALE_IMEASURE:
1008 if ((ret = locale_return_reg_number( &entry_imeasure, type, buffer, len )) != -1) return ret;
1009 return locale_return_number( locale->imeasure, type, buffer, len );
1010
1011 case LOCALE_SDECIMAL:
1012 if ((ret = locale_return_reg_string( &entry_sdecimal, type, buffer, len )) != -1) return ret;
1013 return locale_return_string( locale->sdecimal, type, buffer, len );
1014
1015 case LOCALE_STHOUSAND:
1016 if ((ret = locale_return_reg_string( &entry_sthousand, type, buffer, len )) != -1) return ret;
1017 return locale_return_string( locale->sthousand, type, buffer, len );
1018
1019 case LOCALE_SGROUPING:
1020 if ((ret = locale_return_reg_string( &entry_sgrouping, type, buffer, len )) != -1) return ret;
1021 return locale_return_grouping( locale->sgrouping, type, buffer, len );
1022
1023 case LOCALE_IDIGITS:
1024 if ((ret = locale_return_reg_number( &entry_idigits, type, buffer, len )) != -1) return ret;
1025 return locale_return_number( locale->idigits, type, buffer, len );
1026
1027 case LOCALE_ILZERO:
1028 if ((ret = locale_return_reg_number( &entry_ilzero, type, buffer, len )) != -1) return ret;
1029 return locale_return_number( locale->ilzero, type, buffer, len );
1030
1031 case LOCALE_SNATIVEDIGITS:
1032 if ((ret = locale_return_reg_string( &entry_snativedigits, type, buffer, len )) != -1) return ret;
1033 return locale_return_strarray_concat( locale->snativedigits, type, buffer, len );
1034
1035 case LOCALE_SCURRENCY:
1036 if ((ret = locale_return_reg_string( &entry_scurrency, type, buffer, len )) != -1) return ret;
1037 return locale_return_string( locale->scurrency, type, buffer, len );
1038
1039 case LOCALE_SINTLSYMBOL:
1040 return locale_return_string( locale->sintlsymbol, type, buffer, len );
1041
1042 case LOCALE_SMONDECIMALSEP:
1043 if ((ret = locale_return_reg_string( &entry_smondecimalsep, type, buffer, len )) != -1) return ret;
1044 return locale_return_string( locale->smondecimalsep, type, buffer, len );
1045
1046 case LOCALE_SMONTHOUSANDSEP:
1047 if ((ret = locale_return_reg_string( &entry_smonthousandsep, type, buffer, len )) != -1) return ret;
1048 return locale_return_string( locale->smonthousandsep, type, buffer, len );
1049
1050 case LOCALE_SMONGROUPING:
1051 if ((ret = locale_return_reg_string( &entry_smongrouping, type, buffer, len )) != -1) return ret;
1052 return locale_return_grouping( locale->smongrouping, type, buffer, len );
1053
1054 case LOCALE_ICURRDIGITS:
1055 case LOCALE_IINTLCURRDIGITS:
1056 if ((ret = locale_return_reg_number( &entry_icurrdigits, type, buffer, len )) != -1) return ret;
1057 return locale_return_number( locale->icurrdigits, type, buffer, len );
1058
1059 case LOCALE_ICURRENCY:
1060 if ((ret = locale_return_reg_number( &entry_icurrency, type, buffer, len )) != -1) return ret;
1061 return locale_return_number( locale->icurrency, type, buffer, len );
1062
1063 case LOCALE_INEGCURR:
1064 if ((ret = locale_return_reg_number( &entry_inegcurr, type, buffer, len )) != -1) return ret;
1065 return locale_return_number( locale->inegcurr, type, buffer, len );
1066
1067 case LOCALE_SDATE:
1068 if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
1069 tmp, ARRAY_SIZE( tmp ))) break;
1070 if (!(str = find_format( tmp, L"dMy" ))) break;
1071 while (str[1] == str[0]) str++; /* skip repeated chars */
1072 if (!(end = find_format( ++str, L"dMy" ))) break;
1073 *end++ = 0;
1074 return locale_return_data( str, end - str, type, buffer, len );
1075
1076 case LOCALE_STIME:
1077 if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
1078 tmp, ARRAY_SIZE( tmp ))) break;
1079 if (!(str = find_format( tmp, L"Hhms" ))) break;
1080 while (str[1] == str[0]) str++; /* skip repeated chars */
1081 if (!(end = find_format( ++str, L"Hhms" ))) break;
1082 *end++ = 0;
1083 return locale_return_data( str, end - str, type, buffer, len );
1084
1085 case LOCALE_SSHORTDATE:
1086 if ((ret = locale_return_reg_string( &entry_sshortdate, type, buffer, len )) != -1) return ret;
1087 return locale_return_strarray( locale->sshortdate, 0, type, buffer, len );
1088
1089 case LOCALE_SLONGDATE:
1090 if ((ret = locale_return_reg_string( &entry_slongdate, type, buffer, len )) != -1) return ret;
1091 return locale_return_strarray( locale->slongdate, 0, type, buffer, len );
1092
1093 case LOCALE_IDATE:
1094 if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
1095 tmp, ARRAY_SIZE( tmp ))) break;
1096 /* if both year and day are found before month, the last one takes precedence */
1097 for (val = 0, str = find_format( tmp, L"dMy" ); str; str = find_format( str + 1, L"dMy" ))
1098 {
1099 if (*str == 'M') break;
1100 val = (*str == 'y' ? 2 : 1);
1101 }
1102 return locale_return_number( val, type, buffer, len );
1103
1104 case LOCALE_ILDATE:
1105 if (!get_locale_info( locale, lcid, LOCALE_SLONGDATE | (type & LOCALE_NOUSEROVERRIDE),
1106 tmp, ARRAY_SIZE( tmp ))) break;
1107 /* if both year and day are found before month, the last one takes precedence */
1108 for (val = 0, str = find_format( tmp, L"dMy" ); str; str = find_format( str + 1, L"dMy" ))
1109 {
1110 if (*str == 'M') break;
1111 val = (*str == 'y' ? 2 : 1);
1112 }
1113 return locale_return_number( val, type, buffer, len );
1114
1115 case LOCALE_ITIME:
1116 if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
1117 tmp, ARRAY_SIZE( tmp ))) break;
1118 if (!(str = find_format( tmp, L"Hh" ))) break;
1119 return locale_return_number( *str == 'H', type, buffer, len );
1120
1121 case LOCALE_ICENTURY:
1122 if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
1123 tmp, ARRAY_SIZE( tmp ))) break;
1124 if (!(str = find_format( tmp, L"y" ))) break;
1125 return locale_return_number( !wcsncmp( str, L"yyyy", 4 ), type, buffer, len );
1126
1127 case LOCALE_ITLZERO:
1128 if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
1129 tmp, ARRAY_SIZE( tmp ))) break;
1130 if (!(str = find_format( tmp, L"Hh" ))) break;
1131 return locale_return_number( str[1] == str[0], type, buffer, len );
1132
1133 case LOCALE_IDAYLZERO:
1134 if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
1135 tmp, ARRAY_SIZE( tmp ))) break;
1136 if (!(str = find_format( tmp, L"d" ))) break;
1137 return locale_return_number( str[1] == 'd', type, buffer, len );
1138
1139 case LOCALE_IMONLZERO:
1140 if (!get_locale_info( locale, lcid, LOCALE_SSHORTDATE | (type & LOCALE_NOUSEROVERRIDE),
1141 tmp, ARRAY_SIZE( tmp ))) break;
1142 if (!(str = find_format( tmp, L"M" ))) break;
1143 return locale_return_number( str[1] == 'M', type, buffer, len );
1144
1145 case LOCALE_S1159:
1146 if ((ret = locale_return_reg_string( &entry_s1159, type, buffer, len )) != -1) return ret;
1147 return locale_return_string( locale->s1159, type, buffer, len );
1148
1149 case LOCALE_S2359:
1150 if ((ret = locale_return_reg_string( &entry_s2359, type, buffer, len )) != -1) return ret;
1151 return locale_return_string( locale->s2359, type, buffer, len );
1152
1153 case LOCALE_SDAYNAME1:
1154 case LOCALE_SDAYNAME2:
1155 case LOCALE_SDAYNAME3:
1156 case LOCALE_SDAYNAME4:
1157 case LOCALE_SDAYNAME5:
1158 case LOCALE_SDAYNAME6:
1159 case LOCALE_SDAYNAME7:
1160 return locale_return_strarray( locale->sdayname,
1161 LOWORD(type - LOCALE_SDAYNAME1 + 1) % 7, type, buffer, len );
1162
1163 case LOCALE_SABBREVDAYNAME1:
1164 case LOCALE_SABBREVDAYNAME2:
1165 case LOCALE_SABBREVDAYNAME3:
1166 case LOCALE_SABBREVDAYNAME4:
1167 case LOCALE_SABBREVDAYNAME5:
1168 case LOCALE_SABBREVDAYNAME6:
1169 case LOCALE_SABBREVDAYNAME7:
1170 return locale_return_strarray( locale->sabbrevdayname,
1171 LOWORD(type - LOCALE_SABBREVDAYNAME1 + 1) % 7, type, buffer, len );
1172
1173 case LOCALE_SMONTHNAME1:
1174 case LOCALE_SMONTHNAME2:
1175 case LOCALE_SMONTHNAME3:
1176 case LOCALE_SMONTHNAME4:
1177 case LOCALE_SMONTHNAME5:
1178 case LOCALE_SMONTHNAME6:
1179 case LOCALE_SMONTHNAME7:
1180 case LOCALE_SMONTHNAME8:
1181 case LOCALE_SMONTHNAME9:
1182 case LOCALE_SMONTHNAME10:
1183 case LOCALE_SMONTHNAME11:
1184 case LOCALE_SMONTHNAME12:
1185 return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sgenitivemonth) ?
1186 locale->sgenitivemonth : locale->smonthname,
1187 type - LOCALE_SMONTHNAME1, type, buffer, len );
1188
1189 case LOCALE_SABBREVMONTHNAME1:
1190 case LOCALE_SABBREVMONTHNAME2:
1191 case LOCALE_SABBREVMONTHNAME3:
1192 case LOCALE_SABBREVMONTHNAME4:
1193 case LOCALE_SABBREVMONTHNAME5:
1194 case LOCALE_SABBREVMONTHNAME6:
1195 case LOCALE_SABBREVMONTHNAME7:
1196 case LOCALE_SABBREVMONTHNAME8:
1197 case LOCALE_SABBREVMONTHNAME9:
1198 case LOCALE_SABBREVMONTHNAME10:
1199 case LOCALE_SABBREVMONTHNAME11:
1200 case LOCALE_SABBREVMONTHNAME12:
1201 return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sabbrevgenitivemonth) ?
1202 locale->sabbrevgenitivemonth : locale->sabbrevmonthname,
1203 type - LOCALE_SABBREVMONTHNAME1, type, buffer, len );
1204
1205 case LOCALE_SPOSITIVESIGN:
1206 if ((ret = locale_return_reg_string( &entry_spositivesign, type, buffer, len )) != -1) return ret;
1207 return locale_return_string( locale->spositivesign, type, buffer, len );
1208
1209 case LOCALE_SNEGATIVESIGN:
1210 if ((ret = locale_return_reg_string( &entry_snegativesign, type, buffer, len )) != -1) return ret;
1211 return locale_return_string( locale->snegativesign, type, buffer, len );
1212
1213 case LOCALE_IPOSSIGNPOSN:
1214 if (!get_locale_info( locale, lcid,
1215 LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
1216 (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
1217 return locale_return_number( ipossignposn[val], type, buffer, len );
1218
1219 case LOCALE_INEGSIGNPOSN:
1220 if (!get_locale_info( locale, lcid,
1221 LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
1222 (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
1223 return locale_return_number( inegsignposn[val], type, buffer, len );
1224
1225 case LOCALE_IPOSSYMPRECEDES:
1226 if (!get_locale_info( locale, lcid,
1227 LOCALE_ICURRENCY | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
1228 (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
1229 return locale_return_number( !(val & 1), type, buffer, len );
1230
1231 case LOCALE_IPOSSEPBYSPACE:
1232 if (!get_locale_info( locale, lcid,
1233 LOCALE_ICURRENCY | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
1234 (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
1235 return locale_return_number( !!(val & 2), type, buffer, len );
1236
1237 case LOCALE_INEGSYMPRECEDES:
1238 if (!get_locale_info( locale, lcid,
1239 LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
1240 (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
1241 return locale_return_number( inegsymprecedes[val], type, buffer, len );
1242
1243 case LOCALE_INEGSEPBYSPACE:
1244 if (!get_locale_info( locale, lcid,
1245 LOCALE_INEGCURR | LOCALE_RETURN_NUMBER | (type & LOCALE_NOUSEROVERRIDE),
1246 (WCHAR *)&val, sizeof(val)/sizeof(WCHAR) )) break;
1247 return locale_return_number( (val >= 8), type, buffer, len );
1248
1249 case LOCALE_FONTSIGNATURE:
1250 return locale_return_data( locale_strings + locale->fontsignature + 1,
1251 locale_strings[locale->fontsignature], type, buffer, len );
1252
1253 case LOCALE_SISO639LANGNAME:
1254 return locale_return_string( locale->siso639langname, type, buffer, len );
1255
1256 case LOCALE_SISO3166CTRYNAME:
1257 return locale_return_string( locale->siso3166ctryname, type, buffer, len );
1258
1259 case LOCALE_IGEOID:
1260 return locale_return_number( locale->igeoid, type, buffer, len );
1261
1262 case LOCALE_SNAME:
1263 if (SORTIDFROMLCID(lcid)) /* custom sort locale */
1264 {
1265 const NLS_LOCALE_LCID_INDEX *entry = find_lcid_entry( lcid & ~0x80000000 );
1266 if (entry) return locale_return_string( entry->name, type, buffer, len );
1267 }
1268 return locale_return_string( locale->sname, type, buffer, len );
1269
1270 case LOCALE_SDURATION:
1271 return locale_return_strarray( locale->sduration, 0, type, buffer, len );
1272
1273 case LOCALE_SKEYBOARDSTOINSTALL:
1274 return locale_return_string( locale->skeyboardstoinstall, type, buffer, len );
1275
1276 case LOCALE_SSHORTESTDAYNAME1:
1277 case LOCALE_SSHORTESTDAYNAME2:
1278 case LOCALE_SSHORTESTDAYNAME3:
1279 case LOCALE_SSHORTESTDAYNAME4:
1280 case LOCALE_SSHORTESTDAYNAME5:
1281 case LOCALE_SSHORTESTDAYNAME6:
1282 case LOCALE_SSHORTESTDAYNAME7:
1283 return locale_return_strarray( locale->sshortestdayname,
1284 LOWORD(type - LOCALE_SSHORTESTDAYNAME1 + 1) % 7, type, buffer, len );
1285
1286 case LOCALE_SISO639LANGNAME2:
1287 return locale_return_string( locale->siso639langname2, type, buffer, len );
1288
1289 case LOCALE_SISO3166CTRYNAME2:
1290 return locale_return_string( locale->siso3166ctryname2, type, buffer, len );
1291
1292 case LOCALE_SNAN:
1293 return locale_return_string( locale->snan, type, buffer, len );
1294
1295 case LOCALE_SPOSINFINITY:
1296 return locale_return_string( locale->sposinfinity, type, buffer, len );
1297
1298 case LOCALE_SNEGINFINITY:
1299 return locale_return_string( locale->sneginfinity, type, buffer, len );
1300
1301 case LOCALE_SSCRIPTS:
1302 return locale_return_string( locale->sscripts, type, buffer, len );
1303
1304 case LOCALE_SPARENT:
1305 return locale_return_string( locale->sparent, type, buffer, len );
1306
1307 case LOCALE_SCONSOLEFALLBACKNAME:
1308 return locale_return_string( locale->sconsolefallbackname, type, buffer, len );
1309
1310 case LOCALE_SLOCALIZEDLANGUAGENAME:
1311 /* FIXME: localization */
1312 return locale_return_string( locale->senglanguage, type, buffer, len );
1313
1314 case LOCALE_IREADINGLAYOUT:
1315 return locale_return_number( locale->ireadinglayout, type, buffer, len );
1316
1317 case LOCALE_INEUTRAL:
1318 return locale_return_number( !locale->inotneutral, type, buffer, len );
1319
1320 case LOCALE_SENGLISHDISPLAYNAME:
1321 return locale_return_string( locale->sengdisplayname, type, buffer, len );
1322
1323 case LOCALE_SNATIVEDISPLAYNAME:
1324 return locale_return_string( locale->snativedisplayname, type, buffer, len );
1325
1326 case LOCALE_INEGATIVEPERCENT:
1327 return locale_return_number( locale->inegativepercent, type, buffer, len );
1328
1329 case LOCALE_IPOSITIVEPERCENT:
1330 return locale_return_number( locale->ipositivepercent, type, buffer, len );
1331
1332 case LOCALE_SPERCENT:
1333 return locale_return_string( locale->spercent, type, buffer, len );
1334
1335 case LOCALE_SPERMILLE:
1336 return locale_return_data( spermille, ARRAY_SIZE(spermille), type, buffer, len );
1337
1338 case LOCALE_SMONTHDAY:
1339 return locale_return_strarray( locale->smonthday, 0, type, buffer, len );
1340
1341 case LOCALE_SSHORTTIME:
1342 if ((ret = locale_return_reg_string( &entry_sshorttime, type, buffer, len )) != -1) return ret;
1343 return locale_return_strarray( locale->sshorttime, 0, type, buffer, len );
1344
1345 case LOCALE_SOPENTYPELANGUAGETAG:
1346 return locale_return_string( locale->sopentypelanguagetag, type, buffer, len );
1347
1348 case LOCALE_SSORTLOCALE:
1349 if (SORTIDFROMLCID(lcid)) /* custom sort locale */
1350 {
1351 const NLS_LOCALE_LCID_INDEX *entry = find_lcid_entry( lcid & ~0x80000000 );
1352 if (entry) return locale_return_string( entry->name, type, buffer, len );
1353 }
1354 return locale_return_string( locale->ssortlocale, type, buffer, len );
1355
1356 case LOCALE_SRELATIVELONGDATE:
1357 return locale_return_string( locale->srelativelongdate, type, buffer, len );
1358
1359 case 0x007d: /* undocumented */
1360 return locale_return_number( 0, type, buffer, len );
1361
1362 case LOCALE_SSHORTESTAM:
1363 return locale_return_string( locale->sshortestam, type, buffer, len );
1364
1365 case LOCALE_SSHORTESTPM:
1366 return locale_return_string( locale->sshortestpm, type, buffer, len );
1367
1368 case LOCALE_SENGLANGUAGE:
1369 return locale_return_string( locale->senglanguage, type, buffer, len );
1370
1371 case LOCALE_SENGCOUNTRY:
1372 return locale_return_string( locale->sengcountry, type, buffer, len );
1373
1374 case LOCALE_STIMEFORMAT:
1375 if ((ret = locale_return_reg_string( &entry_stimeformat, type, buffer, len )) != -1) return ret;
1376 return locale_return_strarray( locale->stimeformat, 0, type, buffer, len );
1377
1378 case LOCALE_IDEFAULTANSICODEPAGE:
1379 val = locale->idefaultansicodepage == CP_UTF8 ? CP_ACP : locale->idefaultansicodepage;
1380 return locale_return_number( val, type, buffer, len );
1381
1382 case LOCALE_ITIMEMARKPOSN:
1383 if (!get_locale_info( locale, lcid, LOCALE_STIMEFORMAT | (type & LOCALE_NOUSEROVERRIDE),
1384 tmp, ARRAY_SIZE( tmp ))) break;
1385 if (!(str = find_format( tmp, L"Hhmst" ))) break;
1386 return locale_return_number( *str == 't', type, buffer, len );
1387
1388 case LOCALE_SYEARMONTH:
1389 if ((ret = locale_return_reg_string( &entry_syearmonth, type, buffer, len )) != -1) return ret;
1390 return locale_return_strarray( locale->syearmonth, 0, type, buffer, len );
1391
1392 case LOCALE_SENGCURRNAME:
1393 return locale_return_string( locale->sengcurrname, type, buffer, len );
1394
1395 case LOCALE_SNATIVECURRNAME:
1396 return locale_return_string( locale->snativecurrname, type, buffer, len );
1397
1398 case LOCALE_ICALENDARTYPE:
1399 if ((ret = locale_return_reg_number( &entry_icalendartype, type, buffer, len )) != -1) return ret;
1400 return locale_return_number( locale_strings[locale->scalendartype + 1], type, buffer, len );
1401
1402 case LOCALE_IPAPERSIZE:
1403 if ((ret = locale_return_reg_number( &entry_ipapersize, type, buffer, len )) != -1) return ret;
1404 return locale_return_number( locale->ipapersize, type, buffer, len );
1405
1406 case LOCALE_IOPTIONALCALENDAR:
1407 return locale_return_number( locale_strings[locale->scalendartype + 2], type, buffer, len );
1408
1409 case LOCALE_IFIRSTDAYOFWEEK:
1410 if ((ret = locale_return_reg_number( &entry_ifirstdayofweek, type, buffer, len )) != -1) return ret;
1411 return locale_return_number( (locale->ifirstdayofweek + 6) % 7, type, buffer, len );
1412
1413 case LOCALE_IFIRSTWEEKOFYEAR:
1414 if ((ret = locale_return_reg_number( &entry_ifirstweekofyear, type, buffer, len )) != -1) return ret;
1415 return locale_return_number( locale->ifirstweekofyear, type, buffer, len );
1416
1417 case LOCALE_SMONTHNAME13:
1418 return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sgenitivemonth) ?
1419 locale->sgenitivemonth : locale->smonthname,
1420 12, type, buffer, len );
1421
1422 case LOCALE_SABBREVMONTHNAME13:
1423 return locale_return_strarray( ((type & LOCALE_RETURN_GENITIVE_NAMES) && locale->sabbrevgenitivemonth) ?
1424 locale->sabbrevgenitivemonth : locale->sabbrevmonthname,
1425 12, type, buffer, len );
1426
1427 case LOCALE_INEGNUMBER:
1428 if ((ret = locale_return_reg_number( &entry_inegnumber, type, buffer, len )) != -1) return ret;
1429 return locale_return_number( locale->inegnumber, type, buffer, len );
1430
1431 case LOCALE_IDEFAULTMACCODEPAGE:
1432 val = locale->idefaultmaccodepage == CP_UTF8 ? CP_MACCP : locale->idefaultmaccodepage;
1433 return locale_return_number( val, type, buffer, len );
1434
1435 case LOCALE_IDEFAULTEBCDICCODEPAGE:
1436 return locale_return_number( locale->idefaultebcdiccodepage, type, buffer, len );
1437
1438 case LOCALE_SSORTNAME:
1439 sort = get_locale_sortname( lcid );
1440 return locale_return_data( sort, wcslen(sort) + 1, type, buffer, len );
1441
1442 case LOCALE_IDIGITSUBSTITUTION:
1443 if ((ret = locale_return_reg_number( &entry_idigitsubstitution, type, buffer, len )) != -1) return ret;
1444 return locale_return_number( locale->idigitsubstitution, type, buffer, len );
1445 }
1446 SetLastError( ERROR_INVALID_FLAGS );
1447 return 0;
1448 }
1449
1450
1451 /* get calendar information from the locale.nls file */
1452 static int get_calendar_info( const NLS_LOCALE_DATA *locale, CALID id, CALTYPE type,
1453 WCHAR *buffer, int len, DWORD *value )
1454 {
1455 unsigned int i, idx = id, val = 0;
1456 const struct calendar *cal;
1457
1458 if (type & CAL_RETURN_NUMBER)
1459 {
1460 if (buffer || len || !value) goto invalid;
1461 }
1462 else if (len < 0 || value) goto invalid;
1463
1464 if (id != CAL_GREGORIAN)
1465 {
1466 const USHORT *ids = locale_strings + locale->scalendartype;
1467 for (i = 0; i < ids[0]; i++) if (ids[1 + i] == id) break;
1468 if (i == ids[0]) goto invalid;
1469 if (id == CAL_HIJRI) idx = locale->islamic_cal[0];
1470 else if (id == CAL_PERSIAN) idx = locale->islamic_cal[1];
1471 }
1472
1473 if (!idx || idx > locale_table->nb_calendars) goto invalid;
1474
1475 cal = (const struct calendar *)((const char *)locale_table + locale_table->calendars_offset +
1476 (idx - 1) * locale_table->calendar_size);
1477
1478 switch (LOWORD(type))
1479 {
1480 case CAL_ICALINTVALUE:
1481 return cal_return_number( cal->icalintvalue, type, buffer, len, value );
1482
1483 case CAL_SCALNAME:
1484 return locale_return_strarray( locale->calnames, id - 1, type, buffer, len );
1485
1486 case CAL_IYEAROFFSETRANGE:
1487 if (cal->iyearoffsetrange)
1488 {
1489 const DWORD *array = (const DWORD *)(locale_strings + cal->iyearoffsetrange + 1);
1490 const short *info = (const short *)locale_strings + array[0];
1491 val = (info[5] < 0) ? -info[5] : info[5] + 1; /* year zero */
1492 }
1493 return cal_return_number( val, type, buffer, len, value );
1494
1495 case CAL_SERASTRING:
1496 if (id == CAL_GREGORIAN) return locale_return_string( locale->serastring, type, buffer, len );
1497 if (cal->iyearoffsetrange)
1498 {
1499 const DWORD *array = (const DWORD *)(locale_strings + cal->iyearoffsetrange + 1);
1500 const short *info = (const short *)locale_strings + array[0];
1501 val = info[1] - 1;
1502 }
1503 return locale_return_strarray( cal->serastring, val, type, buffer, len );
1504
1505 case CAL_SSHORTDATE:
1506 val = (id == CAL_GREGORIAN) ? locale->sshortdate : cal->sshortdate;
1507 return locale_return_strarray( val, 0, type, buffer, len );
1508
1509 case CAL_SLONGDATE:
1510 val = (id == CAL_GREGORIAN) ? locale->slongdate : cal->slongdate;
1511 return locale_return_strarray( val, 0, type, buffer, len );
1512
1513 case CAL_SDAYNAME1:
1514 case CAL_SDAYNAME2:
1515 case CAL_SDAYNAME3:
1516 case CAL_SDAYNAME4:
1517 case CAL_SDAYNAME5:
1518 case CAL_SDAYNAME6:
1519 case CAL_SDAYNAME7:
1520 val = (id == CAL_GREGORIAN) ? locale->sdayname : cal->sdayname;
1521 return locale_return_strarray( val, (LOWORD(type) - CAL_SDAYNAME1 + 1) % 7, type, buffer, len );
1522
1523 case CAL_SABBREVDAYNAME1:
1524 case CAL_SABBREVDAYNAME2:
1525 case CAL_SABBREVDAYNAME3:
1526 case CAL_SABBREVDAYNAME4:
1527 case CAL_SABBREVDAYNAME5:
1528 case CAL_SABBREVDAYNAME6:
1529 case CAL_SABBREVDAYNAME7:
1530 val = (id == CAL_GREGORIAN) ? locale->sabbrevdayname : cal->sabbrevdayname;
1531 return locale_return_strarray( val, (LOWORD(type) - CAL_SABBREVDAYNAME1 + 1) % 7, type, buffer, len );
1532 case CAL_SMONTHNAME1:
1533 case CAL_SMONTHNAME2:
1534 case CAL_SMONTHNAME3:
1535 case CAL_SMONTHNAME4:
1536 case CAL_SMONTHNAME5:
1537 case CAL_SMONTHNAME6:
1538 case CAL_SMONTHNAME7:
1539 case CAL_SMONTHNAME8:
1540 case CAL_SMONTHNAME9:
1541 case CAL_SMONTHNAME10:
1542 case CAL_SMONTHNAME11:
1543 case CAL_SMONTHNAME12:
1544 case CAL_SMONTHNAME13:
1545 if (id != CAL_GREGORIAN) val = cal->smonthname;
1546 else if ((type & CAL_RETURN_GENITIVE_NAMES) && locale->sgenitivemonth) val = locale->sgenitivemonth;
1547 else val = locale->smonthname;
1548 return locale_return_strarray( val, LOWORD(type) - CAL_SMONTHNAME1, type, buffer, len );
1549
1550 case CAL_SABBREVMONTHNAME1:
1551 case CAL_SABBREVMONTHNAME2:
1552 case CAL_SABBREVMONTHNAME3:
1553 case CAL_SABBREVMONTHNAME4:
1554 case CAL_SABBREVMONTHNAME5:
1555 case CAL_SABBREVMONTHNAME6:
1556 case CAL_SABBREVMONTHNAME7:
1557 case CAL_SABBREVMONTHNAME8:
1558 case CAL_SABBREVMONTHNAME9:
1559 case CAL_SABBREVMONTHNAME10:
1560 case CAL_SABBREVMONTHNAME11:
1561 case CAL_SABBREVMONTHNAME12:
1562 case CAL_SABBREVMONTHNAME13:
1563 if (id != CAL_GREGORIAN) val = cal->sabbrevmonthname;
1564 else if ((type & CAL_RETURN_GENITIVE_NAMES) && locale->sabbrevgenitivemonth) val = locale->sabbrevgenitivemonth;
1565 else val = locale->sabbrevmonthname;
1566 return locale_return_strarray( val, LOWORD(type) - CAL_SABBREVMONTHNAME1, type, buffer, len );
1567
1568 case CAL_SYEARMONTH:
1569 val = (id == CAL_GREGORIAN) ? locale->syearmonth : cal->syearmonth;
1570 return locale_return_strarray( val, 0, type, buffer, len );
1571
1572 case CAL_ITWODIGITYEARMAX:
1573 return cal_return_number( cal->itwodigityearmax, type, buffer, len, value );
1574
1575 case CAL_SSHORTESTDAYNAME1:
1576 case CAL_SSHORTESTDAYNAME2:
1577 case CAL_SSHORTESTDAYNAME3:
1578 case CAL_SSHORTESTDAYNAME4:
1579 case CAL_SSHORTESTDAYNAME5:
1580 case CAL_SSHORTESTDAYNAME6:
1581 case CAL_SSHORTESTDAYNAME7:
1582 val = (id == CAL_GREGORIAN) ? locale->sshortestdayname : cal->sshortestdayname;
1583 return locale_return_strarray( val, (LOWORD(type) - CAL_SSHORTESTDAYNAME1 + 1) % 7, type, buffer, len );
1584
1585 case CAL_SMONTHDAY:
1586 val = (id == CAL_GREGORIAN) ? locale->smonthday : cal->smonthday;
1587 return locale_return_strarray( val, 0, type, buffer, len );
1588
1589 case CAL_SABBREVERASTRING:
1590 if (id == CAL_GREGORIAN) return locale_return_string( locale->sabbreverastring, type, buffer, len );
1591 if (cal->iyearoffsetrange)
1592 {
1593 const DWORD *array = (const DWORD *)(locale_strings + cal->iyearoffsetrange + 1);
1594 const short *info = (const short *)locale_strings + array[0];
1595 val = info[1] - 1;
1596 }
1597 return locale_return_strarray( cal->sabbreverastring, val, type, buffer, len );
1598
1599 case CAL_SRELATIVELONGDATE:
1600 val = (id == CAL_GREGORIAN) ? locale->srelativelongdate : cal->srelativelongdate;
1601 return locale_return_string( val, type, buffer, len );
1602
1603 case CAL_SENGLISHERANAME:
1604 case CAL_SENGLISHABBREVERANAME:
1605 /* not supported on Windows */
1606 break;
1607 }
1608 SetLastError( ERROR_INVALID_FLAGS );
1609 return 0;
1610
1611 invalid:
1612 SetLastError( ERROR_INVALID_PARAMETER );
1613 return 0;
1614 }
1615
1616
1617 /* get geo information from the locale.nls file */
1618 static int get_geo_info( const struct geo_id *geo, enum SYSGEOTYPE type,
1619 WCHAR *buffer, int len, LANGID lang )
1620 {
1621 WCHAR tmp[12];
1622 const WCHAR *str = tmp;
1623 int ret;
1624
1625 switch (type)
1626 {
1627 case GEO_NATION:
1628 if (geo->class != GEOCLASS_NATION) return 0;
1629 /* fall through */
1630 case GEO_ID:
1631 swprintf( tmp, ARRAY_SIZE(tmp), L"%u", geo->id );
1632 break;
1633 case GEO_ISO_UN_NUMBER:
1634 swprintf( tmp, ARRAY_SIZE(tmp), L"%03u", geo->uncode );
1635 break;
1636 case GEO_PARENT:
1637 swprintf( tmp, ARRAY_SIZE(tmp), L"%u", geo->parent );
1638 break;
1639 case GEO_DIALINGCODE:
1640 swprintf( tmp, ARRAY_SIZE(tmp), L"%u", geo->dialcode );
1641 break;
1642 case GEO_ISO2:
1643 str = geo->iso2;
1644 break;
1645 case GEO_ISO3:
1646 str = geo->iso3;
1647 break;
1648 case GEO_LATITUDE:
1649 str = geo->latitude;
1650 break;
1651 case GEO_LONGITUDE:
1652 str = geo->longitude;
1653 break;
1654 case GEO_CURRENCYCODE:
1655 str = geo->currcode;
1656 break;
1657 case GEO_CURRENCYSYMBOL:
1658 str = geo->currsymbol;
1659 break;
1660 case GEO_RFC1766:
1661 case GEO_LCID:
1662 case GEO_FRIENDLYNAME:
1663 case GEO_OFFICIALNAME:
1664 case GEO_TIMEZONES:
1665 case GEO_OFFICIALLANGUAGES:
1666 case GEO_NAME:
1667 FIXME( "type %u is not supported\n", type );
1668 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1669 return 0;
1670 default:
1671 SetLastError( ERROR_INVALID_FLAGS );
1672 return 0;
1673 }
1674
1675 ret = lstrlenW(str) + 1;
1676 if (!buffer || !len) return ret;
1677
1678 memcpy( buffer, str, min( ret, len ) * sizeof(WCHAR) );
1679 if (len < ret) SetLastError( ERROR_INSUFFICIENT_BUFFER );
1680 return len < ret ? 0 : ret;
1681 }
1682
1683
1684 /* update a registry value based on the current user locale info */
1685 static void update_registry_value( UINT type, const WCHAR *value )
1686 {
1687 WCHAR buffer[80];
1688 UINT len = get_locale_info( user_locale, user_lcid, type, buffer, ARRAY_SIZE(buffer) );
1689 if (len) RegSetValueExW( intl_key, value, 0, REG_SZ, (BYTE *)buffer, len * sizeof(WCHAR) );
1690 }
1691
1692
1693 /* update all registry values upon user locale change */
1694 static void update_locale_registry(void)
1695 {
1696 WCHAR buffer[80];
1697 UINT len;
1698
1699 len = swprintf( buffer, ARRAY_SIZE(buffer), L"%08x", GetUserDefaultLCID() );
1700 RegSetValueExW( intl_key, L"Locale", 0, REG_SZ, (BYTE *)buffer, (len + 1) * sizeof(WCHAR) );
1701
1702 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ICALENDARTYPE, entry_icalendartype.value );
1703 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ICOUNTRY, entry_icountry.value );
1704 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ICURRDIGITS, entry_icurrdigits.value );
1705 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ICURRENCY, entry_icurrency.value );
1706 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IDIGITS, entry_idigits.value );
1707 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IDIGITSUBSTITUTION, entry_idigitsubstitution.value );
1708 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IFIRSTDAYOFWEEK, entry_ifirstdayofweek.value );
1709 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IFIRSTWEEKOFYEAR, entry_ifirstweekofyear.value );
1710 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ILZERO, entry_ilzero.value );
1711 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IMEASURE, entry_imeasure.value );
1712 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_INEGCURR, entry_inegcurr.value );
1713 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_INEGNUMBER, entry_inegnumber.value );
1714 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IPAPERSIZE, entry_ipapersize.value );
1715 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_S1159, entry_s1159.value );
1716 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_S2359, entry_s2359.value );
1717 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SCURRENCY, entry_scurrency.value );
1718 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SDECIMAL, entry_sdecimal.value );
1719 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SGROUPING, entry_sgrouping.value );
1720 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SLIST, entry_slist.value );
1721 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SLONGDATE, entry_slongdate.value );
1722 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SMONDECIMALSEP, entry_smondecimalsep.value );
1723 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SMONGROUPING, entry_smongrouping.value );
1724 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SMONTHOUSANDSEP, entry_smonthousandsep.value );
1725 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SNATIVEDIGITS, entry_snativedigits.value );
1726 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SNEGATIVESIGN, entry_snegativesign.value );
1727 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SPOSITIVESIGN, entry_spositivesign.value );
1728 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SSHORTDATE, entry_sshortdate.value );
1729 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SSHORTTIME, entry_sshorttime.value );
1730 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_STHOUSAND, entry_sthousand.value );
1731 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_STIMEFORMAT, entry_stimeformat.value );
1732 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SYEARMONTH, entry_syearmonth.value );
1733 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_IDATE, L"iDate" );
1734 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ITIME, L"iTime" );
1735 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ITIMEMARKPOSN, L"iTimePrefix" );
1736 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_ITLZERO, L"iTLZero" );
1737 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SDATE, L"sDate" );
1738 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_STIME, L"sTime" );
1739 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SABBREVLANGNAME, L"sLanguage" );
1740 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SCOUNTRY, L"sCountry" );
1741 update_registry_value( LOCALE_NOUSEROVERRIDE | LOCALE_SNAME, L"LocaleName" );
1742 SetUserGeoID( user_locale->igeoid );
1743 }
1744
1745
1746 /***********************************************************************
1747 * init_locale
1748 */
1749 void init_locale( HMODULE module )
1750 {
1751 UINT ansi_cp = 0, oem_cp = 0;
1752 USHORT *ansi_ptr, *oem_ptr;
1753 void *sort_ptr;
1754 WCHAR bufferW[LOCALE_NAME_MAX_LENGTH];
1755 DYNAMIC_TIME_ZONE_INFORMATION timezone;
1756 const WCHAR *user_locale_name;
1757 DWORD count;
1758 SIZE_T size;
1759 HKEY hkey;
1760
1761 kernelbase_handle = module;
1762 load_locale_nls();
1763
1764 NtQueryDefaultLocale( FALSE, &system_lcid );
1765 NtQueryDefaultLocale( FALSE, &user_lcid );
1766 if (!(system_locale = NlsValidateLocale( &system_lcid, 0 )))
1767 {
1768 if (GetEnvironmentVariableW( L"WINELOCALE", bufferW, ARRAY_SIZE(bufferW) ))
1769 system_locale = get_locale_by_name( bufferW, &system_lcid );
1770 if (!system_locale) system_locale = get_locale_by_name( L"en-US", &system_lcid );
1771 }
1772 system_lcid = system_locale->ilanguage;
1773 if (system_lcid == LOCALE_CUSTOM_UNSPECIFIED) system_lcid = LOCALE_CUSTOM_DEFAULT;
1774
1775 if (!(user_locale = NlsValidateLocale( &user_lcid, 0 )))
1776 {
1777 if (GetEnvironmentVariableW( L"WINEUSERLOCALE", bufferW, ARRAY_SIZE(bufferW) ))
1778 user_locale = get_locale_by_name( bufferW, &user_lcid );
1779 if (!user_locale) user_locale = system_locale;
1780 }
1781 user_lcid = user_locale->ilanguage;
1782 if (user_lcid == LOCALE_CUSTOM_UNSPECIFIED) user_lcid = LOCALE_CUSTOM_DEFAULT;
1783
1784 if (GetEnvironmentVariableW( L"WINEUNIXCP", bufferW, ARRAY_SIZE(bufferW) ))
1785 unix_cp = wcstoul( bufferW, NULL, 10 );
1786
1787 GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
1788 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR) );
1789 GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT, LOCALE_IDEFAULTMACCODEPAGE | LOCALE_RETURN_NUMBER,
1790 (WCHAR *)&mac_cp, sizeof(mac_cp)/sizeof(WCHAR) );
1791 GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
1792 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR) );
1793
1794 NtGetNlsSectionPtr( 9, 0, NULL, &sort_ptr, &size );
1795 NtGetNlsSectionPtr( 12, NormalizationC, NULL, (void **)&norm_info, &size );
1796 init_sortkeys( sort_ptr );
1797
1798 if (!ansi_cp || NtGetNlsSectionPtr( 11, ansi_cp, NULL, (void **)&ansi_ptr, &size ))
1799 NtGetNlsSectionPtr( 11, 1252, NULL, (void **)&ansi_ptr, &size );
1800 if (!oem_cp || NtGetNlsSectionPtr( 11, oem_cp, 0, (void **)&oem_ptr, &size ))
1801 NtGetNlsSectionPtr( 11, 437, NULL, (void **)&oem_ptr, &size );
1802 NtCurrentTeb()->Peb->AnsiCodePageData = ansi_ptr;
1803 NtCurrentTeb()->Peb->OemCodePageData = oem_ptr;
1804 NtCurrentTeb()->Peb->UnicodeCaseTableData = sort.casemap;
1805 RtlInitNlsTables( ansi_ptr, oem_ptr, sort.casemap, &nls_info );
1806 RtlResetRtlTranslations( &nls_info );
1807
1808 RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\Nls",
1809 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &nls_key, NULL );
1810 RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones",
1811 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tz_key, NULL );
1812 RegCreateKeyExW( HKEY_CURRENT_USER, L"Control Panel\\International",
1813 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &intl_key, NULL );
1814
1815 current_locale_sort = get_language_sort( LOCALE_NAME_USER_DEFAULT );
1816
1817 if (GetDynamicTimeZoneInformation( &timezone ) != TIME_ZONE_ID_INVALID &&
1818 !RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\TimeZoneInformation",
1819 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
1820 {
1821 RegSetValueExW( hkey, L"StandardName", 0, REG_SZ, (BYTE *)timezone.StandardName,
1822 (lstrlenW(timezone.StandardName) + 1) * sizeof(WCHAR) );
1823 RegSetValueExW( hkey, L"TimeZoneKeyName", 0, REG_SZ, (BYTE *)timezone.TimeZoneKeyName,
1824 (lstrlenW(timezone.TimeZoneKeyName) + 1) * sizeof(WCHAR) );
1825 RegCloseKey( hkey );
1826 }
1827
1828 /* Update registry contents if the user locale has changed.
1829 * This simulates the action of the Windows control panel. */
1830
1831 user_locale_name = locale_strings + user_locale->sname + 1;
1832 count = sizeof(bufferW);
1833 if (!RegQueryValueExW( intl_key, L"LocaleName", NULL, NULL, (BYTE *)bufferW, &count ))
1834 {
1835 if (!wcscmp( bufferW, user_locale_name )) return; /* unchanged */
1836 TRACE( "updating registry, locale changed %s -> %s\n",
1837 debugstr_w(bufferW), debugstr_w(user_locale_name) );
1838 }
1839 else TRACE( "updating registry, locale changed none -> %s\n", debugstr_w(user_locale_name) );
1840
1841 update_locale_registry();
1842
1843 if (!RegCreateKeyExW( nls_key, L"Codepage",
1844 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
1845 {
1846 count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", ansi_cp );
1847 RegSetValueExW( hkey, L"ACP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
1848 count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", oem_cp );
1849 RegSetValueExW( hkey, L"OEMCP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
1850 count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", mac_cp );
1851 RegSetValueExW( hkey, L"MACCP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
1852 RegCloseKey( hkey );
1853 }
1854 }
1855
1856
1857 static inline USHORT get_table_entry( const USHORT *table, WCHAR ch )
1858 {
1859 return table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0xf)];
1860 }
1861
1862
1863 static inline WCHAR casemap( const USHORT *table, WCHAR ch )
1864 {
1865 return ch + table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0x0f)];
1866 }
1867
1868
1869 static inline WORD get_char_type( DWORD type, WCHAR ch )
1870 {
1871 const BYTE *ptr = sort.ctype_idx + ((const WORD *)sort.ctype_idx)[ch >> 8];
1872 ptr = sort.ctype_idx + ((const WORD *)ptr)[(ch >> 4) & 0x0f] + (ch & 0x0f);
1873 return sort.ctypes[*ptr * 3 + type / 2];
1874 }
1875
1876
1877 static BYTE rol( BYTE val, BYTE count )
1878 {
1879 return (val << count) | (val >> (8 - count));
1880 }
1881
1882
1883 static BYTE get_char_props( const struct norm_table *info, unsigned int ch )
1884 {
1885 const BYTE *level1 = (const BYTE *)((const USHORT *)info + info->props_level1);
1886 const BYTE *level2 = (const BYTE *)((const USHORT *)info + info->props_level2);
1887 BYTE off = level1[ch / 128];
1888
1889 if (!off || off >= 0xfb) return rol( off, 5 );
1890 return level2[(off - 1) * 128 + ch % 128];
1891 }
1892
1893
1894 static const WCHAR *get_decomposition( WCHAR ch, unsigned int *ret_len )
1895 {
1896 const struct pair { WCHAR src; USHORT dst; } *pairs;
1897 const USHORT *hash_table = (const USHORT *)norm_info + norm_info->decomp_hash;
1898 const WCHAR *ret;
1899 unsigned int i, pos, end, len, hash;
1900
1901 *ret_len = 1;
1902 hash = ch % norm_info->decomp_size;
1903 pos = hash_table[hash];
1904 if (pos >> 13)
1905 {
1906 if (get_char_props( norm_info, ch ) != 0xbf) return NULL;
1907 ret = (const USHORT *)norm_info + norm_info->decomp_seq + (pos & 0x1fff);
1908 len = pos >> 13;
1909 }
1910 else
1911 {
1912 pairs = (const struct pair *)((const USHORT *)norm_info + norm_info->decomp_map);
1913
1914 /* find the end of the hash bucket */
1915 for (i = hash + 1; i < norm_info->decomp_size; i++) if (!(hash_table[i] >> 13)) break;
1916 if (i < norm_info->decomp_size) end = hash_table[i];
1917 else for (end = pos; pairs[end].src; end++) ;
1918
1919 for ( ; pos < end; pos++)
1920 {
1921 if (pairs[pos].src != (WCHAR)ch) continue;
1922 ret = (const USHORT *)norm_info + norm_info->decomp_seq + (pairs[pos].dst & 0x1fff);
1923 len = pairs[pos].dst >> 13;
1924 break;
1925 }
1926 if (pos >= end) return NULL;
1927 }
1928
1929 if (len == 7) while (ret[len]) len++;
1930 if (!ret[0]) len = 0; /* ignored char */
1931 *ret_len = len;
1932 return ret;
1933 }
1934
1935
1936 static WCHAR compose_chars( WCHAR ch1, WCHAR ch2 )
1937 {
1938 const USHORT *table = (const USHORT *)norm_info + norm_info->comp_hash;
1939 const WCHAR *chars = (const USHORT *)norm_info + norm_info->comp_seq;
1940 unsigned int hash, start, end, i;
1941 WCHAR ch[3];
1942
1943 hash = (ch1 + 95 * ch2) % norm_info->comp_size;
1944 start = table[hash];
1945 end = table[hash + 1];
1946 while (start < end)
1947 {
1948 for (i = 0; i < 3; i++, start++)
1949 {
1950 ch[i] = chars[start];
1951 if (IS_HIGH_SURROGATE( ch[i] )) start++;
1952 }
1953 if (ch[0] == ch1 && ch[1] == ch2) return ch[2];
1954 }
1955 return 0;
1956 }
1957
1958
1959 static UINT get_lcid_codepage( LCID lcid, ULONG flags )
1960 {
1961 UINT ret = GetACP();
1962
1963 if (!(flags & LOCALE_USE_CP_ACP) && lcid != GetSystemDefaultLCID())
1964 GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
1965 (WCHAR *)&ret, sizeof(ret)/sizeof(WCHAR) );
1966 return ret;
1967 }
1968
1969
1970 static const CPTABLEINFO *get_codepage_table( UINT codepage )
1971 {
1972 unsigned int i;
1973 USHORT *ptr;
1974 SIZE_T size;
1975
1976 switch (codepage)
1977 {
1978 case CP_ACP:
1979 return &nls_info.AnsiTableInfo;
1980 case CP_OEMCP:
1981 return &nls_info.OemTableInfo;
1982 case CP_MACCP:
1983 codepage = mac_cp;
1984 break;
1985 case CP_THREAD_ACP:
1986 if (NtCurrentTeb()->CurrentLocale == GetUserDefaultLCID()) return &nls_info.AnsiTableInfo;
1987 codepage = get_lcid_codepage( NtCurrentTeb()->CurrentLocale, 0 );
1988 if (!codepage) return &nls_info.AnsiTableInfo;
1989 break;
1990 default:
1991 if (codepage == nls_info.AnsiTableInfo.CodePage) return &nls_info.AnsiTableInfo;
1992 if (codepage == nls_info.OemTableInfo.CodePage) return &nls_info.OemTableInfo;
1993 break;
1994 }
1995
1996 RtlEnterCriticalSection( &locale_section );
1997
1998 for (i = 0; i < nb_codepages; i++) if (codepages[i].CodePage == codepage) goto done;
1999
2000 if (i == ARRAY_SIZE( codepages ))
2001 {
2002 RtlLeaveCriticalSection( &locale_section );
2003 ERR( "too many codepages\n" );
2004 return NULL;
2005 }
2006 if (NtGetNlsSectionPtr( 11, codepage, NULL, (void **)&ptr, &size ))
2007 {
2008 RtlLeaveCriticalSection( &locale_section );
2009 SetLastError( ERROR_INVALID_PARAMETER );
2010 return NULL;
2011 }
2012 RtlInitCodePageTable( ptr, &codepages[i] );
2013 nb_codepages++;
2014 done:
2015 RtlLeaveCriticalSection( &locale_section );
2016 return &codepages[i];
2017 }
2018
2019
2020 static const WCHAR *get_ligature( WCHAR wc )
2021 {
2022 int low = 0, high = ARRAY_SIZE( ligatures ) -1;
2023 while (low <= high)
2024 {
2025 int pos = (low + high) / 2;
2026 if (ligatures[pos][0] < wc) low = pos + 1;
2027 else if (ligatures[pos][0] > wc) high = pos - 1;
2028 else return ligatures[pos] + 1;
2029 }
2030 return NULL;
2031 }
2032
2033
2034 static NTSTATUS expand_ligatures( const WCHAR *src, int srclen, WCHAR *dst, int *dstlen )
2035 {
2036 int i, len, pos = 0;
2037 NTSTATUS ret = STATUS_SUCCESS;
2038 const WCHAR *expand;
2039
2040 for (i = 0; i < srclen; i++)
2041 {
2042 if (!(expand = get_ligature( src[i] )))
2043 {
2044 expand = src + i;
2045 len = 1;
2046 }
2047 else len = lstrlenW( expand );
2048
2049 if (*dstlen && ret == STATUS_SUCCESS)
2050 {
2051 if (pos + len <= *dstlen) memcpy( dst + pos, expand, len * sizeof(WCHAR) );
2052 else ret = STATUS_BUFFER_TOO_SMALL;
2053 }
2054 pos += len;
2055 }
2056 *dstlen = pos;
2057 return ret;
2058 }
2059
2060
2061 static NTSTATUS fold_digits( const WCHAR *src, int srclen, WCHAR *dst, int *dstlen )
2062 {
2063 extern const WCHAR wine_digitmap[] DECLSPEC_HIDDEN;
2064 int i, len = *dstlen;
2065
2066 *dstlen = srclen;
2067 if (!len) return STATUS_SUCCESS;
2068 if (srclen > len) return STATUS_BUFFER_TOO_SMALL;
2069 for (i = 0; i < srclen; i++)
2070 {
2071 WCHAR digit = get_table_entry( wine_digitmap, src[i] );
2072 dst[i] = digit ? digit : src[i];
2073 }
2074 return STATUS_SUCCESS;
2075 }
2076
2077
2078 static NTSTATUS fold_string( DWORD flags, const WCHAR *src, int srclen, WCHAR *dst, int *dstlen )
2079 {
2080 NTSTATUS ret;
2081 WCHAR *tmp;
2082
2083 switch (flags)
2084 {
2085 case MAP_PRECOMPOSED:
2086 return RtlNormalizeString( NormalizationC, src, srclen, dst, dstlen );
2087 case MAP_FOLDCZONE:
2088 case MAP_PRECOMPOSED | MAP_FOLDCZONE:
2089 return RtlNormalizeString( NormalizationKC, src, srclen, dst, dstlen );
2090 case MAP_COMPOSITE:
2091 return RtlNormalizeString( NormalizationD, src, srclen, dst, dstlen );
2092 case MAP_COMPOSITE | MAP_FOLDCZONE:
2093 return RtlNormalizeString( NormalizationKD, src, srclen, dst, dstlen );
2094 case MAP_FOLDDIGITS:
2095 return fold_digits( src, srclen, dst, dstlen );
2096 case MAP_EXPAND_LIGATURES:
2097 case MAP_EXPAND_LIGATURES | MAP_FOLDCZONE:
2098 return expand_ligatures( src, srclen, dst, dstlen );
2099 case MAP_FOLDDIGITS | MAP_PRECOMPOSED:
2100 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
2101 return STATUS_NO_MEMORY;
2102 fold_digits( src, srclen, tmp, &srclen );
2103 ret = RtlNormalizeString( NormalizationC, tmp, srclen, dst, dstlen );
2104 break;
2105 case MAP_FOLDDIGITS | MAP_FOLDCZONE:
2106 case MAP_FOLDDIGITS | MAP_PRECOMPOSED | MAP_FOLDCZONE:
2107 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
2108 return STATUS_NO_MEMORY;
2109 fold_digits( src, srclen, tmp, &srclen );
2110 ret = RtlNormalizeString( NormalizationKC, tmp, srclen, dst, dstlen );
2111 break;
2112 case MAP_FOLDDIGITS | MAP_COMPOSITE:
2113 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
2114 return STATUS_NO_MEMORY;
2115 fold_digits( src, srclen, tmp, &srclen );
2116 ret = RtlNormalizeString( NormalizationD, tmp, srclen, dst, dstlen );
2117 break;
2118 case MAP_FOLDDIGITS | MAP_COMPOSITE | MAP_FOLDCZONE:
2119 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
2120 return STATUS_NO_MEMORY;
2121 fold_digits( src, srclen, tmp, &srclen );
2122 ret = RtlNormalizeString( NormalizationKD, tmp, srclen, dst, dstlen );
2123 break;
2124 case MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS:
2125 case MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS | MAP_FOLDCZONE:
2126 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
2127 return STATUS_NO_MEMORY;
2128 fold_digits( src, srclen, tmp, &srclen );
2129 ret = expand_ligatures( tmp, srclen, dst, dstlen );
2130 break;
2131 default:
2132 return STATUS_INVALID_PARAMETER_1;
2133 }
2134 RtlFreeHeap( GetProcessHeap(), 0, tmp );
2135 return ret;
2136 }
2137
2138
2139 static int mbstowcs_cpsymbol( DWORD flags, const char *src, int srclen, WCHAR *dst, int dstlen )
2140 {
2141 int len, i;
2142
2143 if (flags)
2144 {
2145 SetLastError( ERROR_INVALID_FLAGS );
2146 return 0;
2147 }
2148 if (!dstlen) return srclen;
2149 len = min( srclen, dstlen );
2150 for (i = 0; i < len; i++)
2151 {
2152 unsigned char c = src[i];
2153 dst[i] = (c < 0x20) ? c : c + 0xf000;
2154 }
2155 if (len < srclen)
2156 {
2157 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2158 return 0;
2159 }
2160 return len;
2161 }
2162
2163
2164 static int mbstowcs_utf7( DWORD flags, const char *src, int srclen, WCHAR *dst, int dstlen )
2165 {
2166 static const signed char base64_decoding_table[] =
2167 {
2168 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00-0x0F */
2169 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10-0x1F */
2170 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20-0x2F */
2171 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 0x30-0x3F */
2172 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 0x40-0x4F */
2173 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50-0x5F */
2174 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60-0x6F */
2175 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1 /* 0x70-0x7F */
2176 };
2177
2178 const char *source_end = src + srclen;
2179 int offset = 0, pos = 0;
2180 DWORD byte_pair = 0;
2181
2182 if (flags)
2183 {
2184 SetLastError( ERROR_INVALID_FLAGS );
2185 return 0;
2186 }
2187 #define OUTPUT(ch) \
2188 do { \
2189 if (dstlen > 0) \
2190 { \
2191 if (pos >= dstlen) goto overflow; \
2192 dst[pos] = (ch); \
2193 } \
2194 pos++; \
2195 } while(0)
2196
2197 while (src < source_end)
2198 {
2199 if (*src == '+')
2200 {
2201 src++;
2202 if (src >= source_end) break;
2203 if (*src == '-')
2204 {
2205 /* just a plus sign escaped as +- */
2206 OUTPUT( '+' );
2207 src++;
2208 continue;
2209 }
2210
2211 do
2212 {
2213 signed char sextet = *src;
2214 if (sextet == '-')
2215 {
2216 /* skip over the dash and end base64 decoding
2217 * the current, unfinished byte pair is discarded */
2218 src++;
2219 offset = 0;
2220 break;
2221 }
2222 if (sextet < 0)
2223 {
2224 /* the next character of src is < 0 and therefore not part of a base64 sequence
2225 * the current, unfinished byte pair is NOT discarded in this case
2226 * this is probably a bug in Windows */
2227 break;
2228 }
2229 sextet = base64_decoding_table[sextet];
2230 if (sextet == -1)
2231 {
2232 /* -1 means that the next character of src is not part of a base64 sequence
2233 * in other words, all sextets in this base64 sequence have been processed
2234 * the current, unfinished byte pair is discarded */
2235 offset = 0;
2236 break;
2237 }
2238
2239 byte_pair = (byte_pair << 6) | sextet;
2240 offset += 6;
2241 if (offset >= 16)
2242 {
2243 /* this byte pair is done */
2244 OUTPUT( byte_pair >> (offset - 16) );
2245 offset -= 16;
2246 }
2247 src++;
2248 }
2249 while (src < source_end);
2250 }
2251 else
2252 {
2253 OUTPUT( (unsigned char)*src );
2254 src++;
2255 }
2256 }
2257 return pos;
2258
2259 overflow:
2260 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2261 return 0;
2262 #undef OUTPUT
2263 }
2264
2265
2266 static int mbstowcs_utf8( DWORD flags, const char *src, int srclen, WCHAR *dst, int dstlen )
2267 {
2268 DWORD reslen;
2269 NTSTATUS status;
2270
2271 if (flags & ~(MB_PRECOMPOSED | MB_COMPOSITE | MB_USEGLYPHCHARS | MB_ERR_INVALID_CHARS))
2272 {
2273 SetLastError( ERROR_INVALID_FLAGS );
2274 return 0;
2275 }
2276 if (!dstlen) dst = NULL;
2277 status = RtlUTF8ToUnicodeN( dst, dstlen * sizeof(WCHAR), &reslen, src, srclen );
2278 if (status == STATUS_SOME_NOT_MAPPED)
2279 {
2280 if (flags & MB_ERR_INVALID_CHARS)
2281 {
2282 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
2283 return 0;
2284 }
2285 }
2286 else if (!set_ntstatus( status )) reslen = 0;
2287
2288 return reslen / sizeof(WCHAR);
2289 }
2290
2291
2292 static inline int is_private_use_area_char( WCHAR code )
2293 {
2294 return (code >= 0xe000 && code <= 0xf8ff);
2295 }
2296
2297
2298 static int check_invalid_chars( const CPTABLEINFO *info, const unsigned char *src, int srclen )
2299 {
2300 if (info->DBCSOffsets)
2301 {
2302 for ( ; srclen; src++, srclen-- )
2303 {
2304 USHORT off = info->DBCSOffsets[*src];
2305 if (off)
2306 {
2307 if (srclen == 1) break; /* partial char, error */
2308 if (info->DBCSOffsets[off + src[1]] == info->UniDefaultChar &&
2309 ((src[0] << 8) | src[1]) != info->TransUniDefaultChar) break;
2310 src++;
2311 srclen--;
2312 continue;
2313 }
2314 if (info->MultiByteTable[*src] == info->UniDefaultChar && *src != info->TransUniDefaultChar)
2315 break;
2316 if (is_private_use_area_char( info->MultiByteTable[*src] )) break;
2317 }
2318 }
2319 else
2320 {
2321 for ( ; srclen; src++, srclen-- )
2322 {
2323 if (info->MultiByteTable[*src] == info->UniDefaultChar && *src != info->TransUniDefaultChar)
2324 break;
2325 if (is_private_use_area_char( info->MultiByteTable[*src] )) break;
2326 }
2327 }
2328 return !!srclen;
2329
2330 }
2331
2332
2333 static int mbstowcs_decompose( const CPTABLEINFO *info, const unsigned char *src, int srclen,
2334 WCHAR *dst, int dstlen )
2335 {
2336 WCHAR ch;
2337 USHORT off;
2338 int len;
2339 const WCHAR *decomp;
2340 unsigned int decomp_len;
2341
2342 if (info->DBCSOffsets)
2343 {
2344 if (!dstlen) /* compute length */
2345 {
2346 for (len = 0; srclen; srclen--, src++, len += decomp_len)
2347 {
2348 if ((off = info->DBCSOffsets[*src]))
2349 {
2350 if (srclen > 1 && src[1])
2351 {
2352 src++;
2353 srclen--;
2354 ch = info->DBCSOffsets[off + *src];
2355 }
2356 else ch = info->UniDefaultChar;
2357 }
2358 else ch = info->MultiByteTable[*src];
2359 get_decomposition( ch, &decomp_len );
2360 }
2361 return len;
2362 }
2363
2364 for (len = dstlen; srclen && len; srclen--, src++, dst += decomp_len, len -= decomp_len)
2365 {
2366 if ((off = info->DBCSOffsets[*src]))
2367 {
2368 if (srclen > 1 && src[1])
2369 {
2370 src++;
2371 srclen--;
2372 ch = info->DBCSOffsets[off + *src];
2373 }
2374 else ch = info->UniDefaultChar;
2375 }
2376 else ch = info->MultiByteTable[*src];
2377
2378 if ((decomp = get_decomposition( ch, &decomp_len )))
2379 {
2380 if (len < decomp_len) break;
2381 memcpy( dst, decomp, decomp_len * sizeof(WCHAR) );
2382 }
2383 else *dst = ch;
2384 }
2385 }
2386 else
2387 {
2388 if (!dstlen) /* compute length */
2389 {
2390 for (len = 0; srclen; srclen--, src++, len += decomp_len)
2391 get_decomposition( info->MultiByteTable[*src], &decomp_len );
2392 return len;
2393 }
2394
2395 for (len = dstlen; srclen && len; srclen--, src++, dst += decomp_len, len -= decomp_len)
2396 {
2397 ch = info->MultiByteTable[*src];
2398 if ((decomp = get_decomposition( ch, &decomp_len )))
2399 {
2400 if (len < decomp_len) break;
2401 memcpy( dst, decomp, decomp_len * sizeof(WCHAR) );
2402 }
2403 else *dst = ch;
2404 }
2405 }
2406
2407 if (srclen)
2408 {
2409 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2410 return 0;
2411 }
2412 return dstlen - len;
2413 }
2414
2415
2416 static int mbstowcs_sbcs( const CPTABLEINFO *info, const unsigned char *src, int srclen,
2417 WCHAR *dst, int dstlen )
2418 {
2419 const USHORT *table = info->MultiByteTable;
2420 int ret = srclen;
2421
2422 if (!dstlen) return srclen;
2423
2424 if (dstlen < srclen) /* buffer too small: fill it up to dstlen and return error */
2425 {
2426 srclen = dstlen;
2427 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2428 ret = 0;
2429 }
2430
2431 while (srclen >= 16)
2432 {
2433 dst[0] = table[src[0]];
2434 dst[1] = table[src[1]];
2435 dst[2] = table[src[2]];
2436 dst[3] = table[src[3]];
2437 dst[4] = table[src[4]];
2438 dst[5] = table[src[5]];
2439 dst[6] = table[src[6]];
2440 dst[7] = table[src[7]];
2441 dst[8] = table[src[8]];
2442 dst[9] = table[src[9]];
2443 dst[10] = table[src[10]];
2444 dst[11] = table[src[11]];
2445 dst[12] = table[src[12]];
2446 dst[13] = table[src[13]];
2447 dst[14] = table[src[14]];
2448 dst[15] = table[src[15]];
2449 src += 16;
2450 dst += 16;
2451 srclen -= 16;
2452 }
2453
2454 /* now handle the remaining characters */
2455 src += srclen;
2456 dst += srclen;
2457 switch (srclen)
2458 {
2459 case 15: dst[-15] = table[src[-15]];
2460 case 14: dst[-14] = table[src[-14]];
2461 case 13: dst[-13] = table[src[-13]];
2462 case 12: dst[-12] = table[src[-12]];
2463 case 11: dst[-11] = table[src[-11]];
2464 case 10: dst[-10] = table[src[-10]];
2465 case 9: dst[-9] = table[src[-9]];
2466 case 8: dst[-8] = table[src[-8]];
2467 case 7: dst[-7] = table[src[-7]];
2468 case 6: dst[-6] = table[src[-6]];
2469 case 5: dst[-5] = table[src[-5]];
2470 case 4: dst[-4] = table[src[-4]];
2471 case 3: dst[-3] = table[src[-3]];
2472 case 2: dst[-2] = table[src[-2]];
2473 case 1: dst[-1] = table[src[-1]];
2474 case 0: break;
2475 }
2476 return ret;
2477 }
2478
2479
2480 static int mbstowcs_dbcs( const CPTABLEINFO *info, const unsigned char *src, int srclen,
2481 WCHAR *dst, int dstlen )
2482 {
2483 USHORT off;
2484 int i;
2485
2486 if (!dstlen)
2487 {
2488 for (i = 0; srclen; i++, src++, srclen--)
2489 if (info->DBCSOffsets[*src] && srclen > 1 && src[1]) { src++; srclen--; }
2490 return i;
2491 }
2492
2493 for (i = dstlen; srclen && i; i--, srclen--, src++, dst++)
2494 {
2495 if ((off = info->DBCSOffsets[*src]))
2496 {
2497 if (srclen > 1 && src[1])
2498 {
2499 src++;
2500 srclen--;
2501 *dst = info->DBCSOffsets[off + *src];
2502 }
2503 else *dst = info->UniDefaultChar;
2504 }
2505 else *dst = info->MultiByteTable[*src];
2506 }
2507 if (srclen)
2508 {
2509 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2510 return 0;
2511 }
2512 return dstlen - i;
2513 }
2514
2515
2516 static int mbstowcs_codepage( UINT codepage, DWORD flags, const char *src, int srclen,
2517 WCHAR *dst, int dstlen )
2518 {
2519 CPTABLEINFO local_info;
2520 const CPTABLEINFO *info = get_codepage_table( codepage );
2521 const unsigned char *str = (const unsigned char *)src;
2522
2523 if (!info)
2524 {
2525 SetLastError( ERROR_INVALID_PARAMETER );
2526 return 0;
2527 }
2528 if (flags & ~(MB_PRECOMPOSED | MB_COMPOSITE | MB_USEGLYPHCHARS | MB_ERR_INVALID_CHARS))
2529 {
2530 SetLastError( ERROR_INVALID_FLAGS );
2531 return 0;
2532 }
2533
2534 if ((flags & MB_USEGLYPHCHARS) && info->MultiByteTable[256] == 256)
2535 {
2536 local_info = *info;
2537 local_info.MultiByteTable += 257;
2538 info = &local_info;
2539 }
2540 if ((flags & MB_ERR_INVALID_CHARS) && check_invalid_chars( info, str, srclen ))
2541 {
2542 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
2543 return 0;
2544 }
2545
2546 if (flags & MB_COMPOSITE) return mbstowcs_decompose( info, str, srclen, dst, dstlen );
2547
2548 if (info->DBCSOffsets)
2549 return mbstowcs_dbcs( info, str, srclen, dst, dstlen );
2550 else
2551 return mbstowcs_sbcs( info, str, srclen, dst, dstlen );
2552 }
2553
2554
2555 static int wcstombs_cpsymbol( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen,
2556 const char *defchar, BOOL *used )
2557 {
2558 int len, i;
2559
2560 if (flags)
2561 {
2562 SetLastError( ERROR_INVALID_FLAGS );
2563 return 0;
2564 }
2565 if (defchar || used)
2566 {
2567 SetLastError( ERROR_INVALID_PARAMETER );
2568 return 0;
2569 }
2570 if (!dstlen) return srclen;
2571 len = min( srclen, dstlen );
2572 for (i = 0; i < len; i++)
2573 {
2574 if (src[i] < 0x20) dst[i] = src[i];
2575 else if (src[i] >= 0xf020 && src[i] < 0xf100) dst[i] = src[i] - 0xf000;
2576 else
2577 {
2578 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
2579 return 0;
2580 }
2581 }
2582 if (srclen > len)
2583 {
2584 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2585 return 0;
2586 }
2587 return len;
2588 }
2589
2590
2591 static int wcstombs_utf7( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen,
2592 const char *defchar, BOOL *used )
2593 {
2594 static const char directly_encodable[] =
2595 {
2596 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, /* 0x00 - 0x0f */
2597 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */
2598 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* 0x20 - 0x2f */
2599 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 0x30 - 0x3f */
2600 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */
2601 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */
2602 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */
2603 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 /* 0x70 - 0x7a */
2604 };
2605 #define ENCODABLE(ch) ((ch) <= 0x7a && directly_encodable[(ch)])
2606
2607 static const char base64_encoding_table[] =
2608 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2609
2610 const WCHAR *source_end = src + srclen;
2611 int pos = 0;
2612
2613 if (defchar || used)
2614 {
2615 SetLastError( ERROR_INVALID_PARAMETER );
2616 return 0;
2617 }
2618 if (flags)
2619 {
2620 SetLastError( ERROR_INVALID_FLAGS );
2621 return 0;
2622 }
2623
2624 #define OUTPUT(ch) \
2625 do { \
2626 if (dstlen > 0) \
2627 { \
2628 if (pos >= dstlen) goto overflow; \
2629 dst[pos] = (ch); \
2630 } \
2631 pos++; \
2632 } while (0)
2633
2634 while (src < source_end)
2635 {
2636 if (*src == '+')
2637 {
2638 OUTPUT( '+' );
2639 OUTPUT( '-' );
2640 src++;
2641 }
2642 else if (ENCODABLE(*src))
2643 {
2644 OUTPUT( *src );
2645 src++;
2646 }
2647 else
2648 {
2649 unsigned int offset = 0, byte_pair = 0;
2650
2651 OUTPUT( '+' );
2652 while (src < source_end && !ENCODABLE(*src))
2653 {
2654 byte_pair = (byte_pair << 16) | *src;
2655 offset += 16;
2656 while (offset >= 6)
2657 {
2658 offset -= 6;
2659 OUTPUT( base64_encoding_table[(byte_pair >> offset) & 0x3f] );
2660 }
2661 src++;
2662 }
2663 if (offset)
2664 {
2665 /* Windows won't create a padded base64 character if there's no room for the - sign
2666 * as well ; this is probably a bug in Windows */
2667 if (dstlen > 0 && pos + 1 >= dstlen) goto overflow;
2668 byte_pair <<= (6 - offset);
2669 OUTPUT( base64_encoding_table[byte_pair & 0x3f] );
2670 }
2671 /* Windows always explicitly terminates the base64 sequence
2672 even though RFC 2152 (page 3, rule 2) does not require this */
2673 OUTPUT( '-' );
2674 }
2675 }
2676 return pos;
2677
2678 overflow:
2679 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2680 return 0;
2681 #undef OUTPUT
2682 #undef ENCODABLE
2683 }
2684
2685
2686 static int wcstombs_utf8( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen,
2687 const char *defchar, BOOL *used )
2688 {
2689 DWORD reslen;
2690 NTSTATUS status;
2691
2692 if (defchar || used)
2693 {
2694 SetLastError( ERROR_INVALID_PARAMETER );
2695 return 0;
2696 }
2697 if (flags & ~(WC_DISCARDNS | WC_SEPCHARS | WC_DEFAULTCHAR | WC_ERR_INVALID_CHARS |
2698 WC_COMPOSITECHECK | WC_NO_BEST_FIT_CHARS))
2699 {
2700 SetLastError( ERROR_INVALID_FLAGS );
2701 return 0;
2702 }
2703 if (!dstlen) dst = NULL;
2704 status = RtlUnicodeToUTF8N( dst, dstlen, &reslen, src, srclen * sizeof(WCHAR) );
2705 if (status == STATUS_SOME_NOT_MAPPED)
2706 {
2707 if (flags & WC_ERR_INVALID_CHARS)
2708 {
2709 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
2710 return 0;
2711 }
2712 }
2713 else if (!set_ntstatus( status )) reslen = 0;
2714 return reslen;
2715 }
2716
2717
2718 static int wcstombs_sbcs( const CPTABLEINFO *info, const WCHAR *src, unsigned int srclen,
2719 char *dst, unsigned int dstlen )
2720 {
2721 const char *table = info->WideCharTable;
2722 int ret = srclen;
2723
2724 if (!dstlen) return srclen;
2725
2726 if (dstlen < srclen)
2727 {
2728 /* buffer too small: fill it up to dstlen and return error */
2729 srclen = dstlen;
2730 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2731 ret = 0;
2732 }
2733
2734 while (srclen >= 16)
2735 {
2736 dst[0] = table[src[0]];
2737 dst[1] = table[src[1]];
2738 dst[2] = table[src[2]];
2739 dst[3] = table[src[3]];
2740 dst[4] = table[src[4]];
2741 dst[5] = table[src[5]];
2742 dst[6] = table[src[6]];
2743 dst[7] = table[src[7]];
2744 dst[8] = table[src[8]];
2745 dst[9] = table[src[9]];
2746 dst[10] = table[src[10]];
2747 dst[11] = table[src[11]];
2748 dst[12] = table[src[12]];
2749 dst[13] = table[src[13]];
2750 dst[14] = table[src[14]];
2751 dst[15] = table[src[15]];
2752 src += 16;
2753 dst += 16;
2754 srclen -= 16;
2755 }
2756
2757 /* now handle remaining characters */
2758 src += srclen;
2759 dst += srclen;
2760 switch(srclen)
2761 {
2762 case 15: dst[-15] = table[src[-15]];
2763 case 14: dst[-14] = table[src[-14]];
2764 case 13: dst[-13] = table[src[-13]];
2765 case 12: dst[-12] = table[src[-12]];
2766 case 11: dst[-11] = table[src[-11]];
2767 case 10: dst[-10] = table[src[-10]];
2768 case 9: dst[-9] = table[src[-9]];
2769 case 8: dst[-8] = table[src[-8]];
2770 case 7: dst[-7] = table[src[-7]];
2771 case 6: dst[-6] = table[src[-6]];
2772 case 5: dst[-5] = table[src[-5]];
2773 case 4: dst[-4] = table[src[-4]];
2774 case 3: dst[-3] = table[src[-3]];
2775 case 2: dst[-2] = table[src[-2]];
2776 case 1: dst[-1] = table[src[-1]];
2777 case 0: break;
2778 }
2779 return ret;
2780 }
2781
2782
2783 static int wcstombs_dbcs( const CPTABLEINFO *info, const WCHAR *src, unsigned int srclen,
2784 char *dst, unsigned int dstlen )
2785 {
2786 const USHORT *table = info->WideCharTable;
2787 int i;
2788
2789 if (!dstlen)
2790 {
2791 for (i = 0; srclen; src++, srclen--, i++) if (table[*src] & 0xff00) i++;
2792 return i;
2793 }
2794
2795 for (i = dstlen; srclen && i; i--, srclen--, src++)
2796 {
2797 if (table[*src] & 0xff00)
2798 {
2799 if (i == 1) break; /* do not output a partial char */
2800 i--;
2801 *dst++ = table[*src] >> 8;
2802 }
2803 *dst++ = (char)table[*src];
2804 }
2805 if (srclen)
2806 {
2807 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2808 return 0;
2809 }
2810 return dstlen - i;
2811 }
2812
2813
2814 static inline int is_valid_sbcs_mapping( const CPTABLEINFO *info, DWORD flags, unsigned int wch )
2815 {
2816 const unsigned char *table = info->WideCharTable;
2817
2818 if (wch >= 0x10000) return 0;
2819 if ((flags & WC_NO_BEST_FIT_CHARS) || table[wch] == info->DefaultChar)
2820 return (info->MultiByteTable[table[wch]] == wch);
2821 return 1;
2822 }
2823
2824
2825 static inline int is_valid_dbcs_mapping( const CPTABLEINFO *info, DWORD flags, unsigned int wch )
2826 {
2827 const unsigned short *table = info->WideCharTable;
2828 unsigned short ch;
2829
2830 if (wch >= 0x10000) return 0;
2831 ch = table[wch];
2832 if ((flags & WC_NO_BEST_FIT_CHARS) || ch == info->DefaultChar)
2833 {
2834 if (ch >> 8) return info->DBCSOffsets[info->DBCSOffsets[ch >> 8] + (ch & 0xff)] == wch;
2835 return info->MultiByteTable[ch] == wch;
2836 }
2837 return 1;
2838 }
2839
2840
2841 static int wcstombs_sbcs_slow( const CPTABLEINFO *info, DWORD flags, const WCHAR *src, unsigned int srclen,
2842 char *dst, unsigned int dstlen, const char *defchar, BOOL *used )
2843 {
2844 const char *table = info->WideCharTable;
2845 const char def = defchar ? *defchar : (char)info->DefaultChar;
2846 int i;
2847 BOOL tmp;
2848 WCHAR wch;
2849 unsigned int composed;
2850
2851 if (!used) used = &tmp; /* avoid checking on every char */
2852 *used = FALSE;
2853
2854 if (!dstlen)
2855 {
2856 for (i = 0; srclen; i++, src++, srclen--)
2857 {
2858 wch = *src;
2859 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
2860 {
2861 /* now check if we can use the composed char */
2862 if (is_valid_sbcs_mapping( info, flags, composed ))
2863 {
2864 /* we have a good mapping, use it */
2865 src++;
2866 srclen--;
2867 continue;
2868 }
2869 /* no mapping for the composed char, check the other flags */
2870 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
2871 {
2872 *used = TRUE;
2873 src++; /* skip the non-spacing char */
2874 srclen--;
2875 continue;
2876 }
2877 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
2878 {
2879 src++;
2880 srclen--;
2881 }
2882 /* WC_SEPCHARS is the default */
2883 }
2884 if (!*used) *used = !is_valid_sbcs_mapping( info, flags, wch );
2885 }
2886 return i;
2887 }
2888
2889 for (i = dstlen; srclen && i; dst++, i--, src++, srclen--)
2890 {
2891 wch = *src;
2892 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
2893 {
2894 /* now check if we can use the composed char */
2895 if (is_valid_sbcs_mapping( info, flags, composed ))
2896 {
2897 /* we have a good mapping, use it */
2898 *dst = table[composed];
2899 src++;
2900 srclen--;
2901 continue;
2902 }
2903 /* no mapping for the composed char, check the other flags */
2904 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
2905 {
2906 *dst = def;
2907 *used = TRUE;
2908 src++; /* skip the non-spacing char */
2909 srclen--;
2910 continue;
2911 }
2912 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
2913 {
2914 src++;
2915 srclen--;
2916 }
2917 /* WC_SEPCHARS is the default */
2918 }
2919
2920 *dst = table[wch];
2921 if (!is_valid_sbcs_mapping( info, flags, wch ))
2922 {
2923 *dst = def;
2924 *used = TRUE;
2925 }
2926 }
2927 if (srclen)
2928 {
2929 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2930 return 0;
2931 }
2932 return dstlen - i;
2933 }
2934
2935
2936 static int wcstombs_dbcs_slow( const CPTABLEINFO *info, DWORD flags, const WCHAR *src, unsigned int srclen,
2937 char *dst, unsigned int dstlen, const char *defchar, BOOL *used )
2938 {
2939 const USHORT *table = info->WideCharTable;
2940 WCHAR wch, defchar_value;
2941 unsigned int composed;
2942 unsigned short res;
2943 BOOL tmp;
2944 int i;
2945
2946 if (!defchar[1]) defchar_value = (unsigned char)defchar[0];
2947 else defchar_value = ((unsigned char)defchar[0] << 8) | (unsigned char)defchar[1];
2948
2949 if (!used) used = &tmp; /* avoid checking on every char */
2950 *used = FALSE;
2951
2952 if (!dstlen)
2953 {
2954 if (!defchar && !used && !(flags & WC_COMPOSITECHECK))
2955 {
2956 for (i = 0; srclen; srclen--, src++, i++) if (table[*src] & 0xff00) i++;
2957 return i;
2958 }
2959 for (i = 0; srclen; srclen--, src++, i++)
2960 {
2961 wch = *src;
2962 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
2963 {
2964 /* now check if we can use the composed char */
2965 if (is_valid_dbcs_mapping( info, flags, composed ))
2966 {
2967 /* we have a good mapping for the composed char, use it */
2968 res = table[composed];
2969 if (res & 0xff00) i++;
2970 src++;
2971 srclen--;
2972 continue;
2973 }
2974 /* no mapping for the composed char, check the other flags */
2975 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
2976 {
2977 if (defchar_value & 0xff00) i++;
2978 *used = TRUE;
2979 src++; /* skip the non-spacing char */
2980 srclen--;
2981 continue;
2982 }
2983 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
2984 {
2985 src++;
2986 srclen--;
2987 }
2988 /* WC_SEPCHARS is the default */
2989 }
2990
2991 res = table[wch];
2992 if (!is_valid_dbcs_mapping( info, flags, wch ))
2993 {
2994 res = defchar_value;
2995 *used = TRUE;
2996 }
2997 if (res & 0xff00) i++;
2998 }
2999 return i;
3000 }
3001
3002
3003 for (i = dstlen; srclen && i; i--, srclen--, src++)
3004 {
3005 wch = *src;
3006 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
3007 {
3008 /* now check if we can use the composed char */
3009 if (is_valid_dbcs_mapping( info, flags, composed ))
3010 {
3011 /* we have a good mapping for the composed char, use it */
3012 res = table[composed];
3013 src++;
3014 srclen--;
3015 goto output_char;
3016 }
3017 /* no mapping for the composed char, check the other flags */
3018 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
3019 {
3020 res = defchar_value;
3021 *used = TRUE;
3022 src++; /* skip the non-spacing char */
3023 srclen--;
3024 goto output_char;
3025 }
3026 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
3027 {
3028 src++;
3029 srclen--;
3030 }
3031 /* WC_SEPCHARS is the default */
3032 }
3033
3034 res = table[wch];
3035 if (!is_valid_dbcs_mapping( info, flags, wch ))
3036 {
3037 res = defchar_value;
3038 *used = TRUE;
3039 }
3040
3041 output_char:
3042 if (res & 0xff00)
3043 {
3044 if (i == 1) break; /* do not output a partial char */
3045 i--;
3046 *dst++ = res >> 8;
3047 }
3048 *dst++ = (char)res;
3049 }
3050 if (srclen)
3051 {
3052 SetLastError( ERROR_INSUFFICIENT_BUFFER );
3053 return 0;
3054 }
3055 return dstlen - i;
3056 }
3057
3058
3059 static int wcstombs_codepage( UINT codepage, DWORD flags, const WCHAR *src, int srclen,
3060 char *dst, int dstlen, const char *defchar, BOOL *used )
3061 {
3062 const CPTABLEINFO *info = get_codepage_table( codepage );
3063
3064 if (!info)
3065 {
3066 SetLastError( ERROR_INVALID_PARAMETER );
3067 return 0;
3068 }
3069 if (flags & ~(WC_DISCARDNS | WC_SEPCHARS | WC_DEFAULTCHAR | WC_ERR_INVALID_CHARS |
3070 WC_COMPOSITECHECK | WC_NO_BEST_FIT_CHARS))
3071 {
3072 SetLastError( ERROR_INVALID_FLAGS );
3073 return 0;
3074 }
3075 if (flags || defchar || used)
3076 {
3077 if (!defchar) defchar = (const char *)&info->DefaultChar;
3078 if (info->DBCSOffsets)
3079 return wcstombs_dbcs_slow( info, flags, src, srclen, dst, dstlen, defchar, used );
3080 else
3081 return wcstombs_sbcs_slow( info, flags, src, srclen, dst, dstlen, defchar, used );
3082 }
3083 if (info->DBCSOffsets)
3084 return wcstombs_dbcs( info, src, srclen, dst, dstlen );
3085 else
3086 return wcstombs_sbcs( info, src, srclen, dst, dstlen );
3087 }
3088
3089
3090 static int get_sortkey( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen )
3091 {
3092 WCHAR dummy[4]; /* no decomposition is larger than 4 chars */
3093 int key_len[4];
3094 char *key_ptr[4];
3095 const WCHAR *src_save = src;
3096 int srclen_save = srclen;
3097
3098 key_len[0] = key_len[1] = key_len[2] = key_len[3] = 0;
3099 for (; srclen; srclen--, src++)
3100 {
3101 unsigned int i, decomposed_len = 1;/*wine_decompose(*src, dummy, 4);*/
3102 dummy[0] = *src;
3103 if (decomposed_len)
3104 {
3105 for (i = 0; i < decomposed_len; i++)
3106 {
3107 WCHAR wch = dummy[i];
3108 unsigned int ce;
3109
3110 if ((flags & NORM_IGNORESYMBOLS) &&
3111 (get_char_type( CT_CTYPE1, wch ) & (C1_PUNCT | C1_SPACE)))
3112 continue;
3113
3114 if (flags & NORM_IGNORECASE) wch = casemap( nls_info.LowerCaseTable, wch );
3115
3116 ce = collation_table[collation_table[collation_table[wch >> 8] + ((wch >> 4) & 0x0f)] + (wch & 0xf)];
3117 if (ce != (unsigned int)-1)
3118 {
3119 if (ce >> 16) key_len[0] += 2;
3120 if ((ce >> 8) & 0xff) key_len[1]++;
3121 if ((ce >> 4) & 0x0f) key_len[2]++;
3122 if (ce & 1)
3123 {
3124 if (wch >> 8) key_len[3]++;
3125 key_len[3]++;
3126 }
3127 }
3128 else
3129 {
3130 key_len[0] += 2;
3131 if (wch >> 8) key_len[0]++;
3132 if (wch & 0xff) key_len[0]++;
3133 }
3134 }
3135 }
3136 }
3137
3138 if (!dstlen) /* compute length */
3139 /* 4 * '\1' + key length */
3140 return key_len[0] + key_len[1] + key_len[2] + key_len[3] + 4;
3141
3142 if (dstlen < key_len[0] + key_len[1] + key_len[2] + key_len[3] + 4 + 1)
3143 return 0; /* overflow */
3144
3145 src = src_save;
3146 srclen = srclen_save;
3147
3148 key_ptr[0] = dst;
3149 key_ptr[1] = key_ptr[0] + key_len[0] + 1;
3150 key_ptr[2] = key_ptr[1] + key_len[1] + 1;
3151 key_ptr[3] = key_ptr[2] + key_len[2] + 1;
3152
3153 for (; srclen; srclen--, src++)
3154 {
3155 unsigned int i, decomposed_len = 1;/*wine_decompose(*src, dummy, 4);*/
3156 dummy[0] = *src;
3157 if (decomposed_len)
3158 {
3159 for (i = 0; i < decomposed_len; i++)
3160 {
3161 WCHAR wch = dummy[i];
3162 unsigned int ce;
3163
3164 if ((flags & NORM_IGNORESYMBOLS) &&
3165 (get_char_type( CT_CTYPE1, wch ) & (C1_PUNCT | C1_SPACE)))
3166 continue;
3167
3168 if (flags & NORM_IGNORECASE) wch = casemap( nls_info.LowerCaseTable, wch );
3169
3170 ce = collation_table[collation_table[collation_table[wch >> 8] + ((wch >> 4) & 0x0f)] + (wch & 0xf)];
3171 if (ce != (unsigned int)-1)
3172 {
3173 WCHAR key;
3174 if ((key = ce >> 16))
3175 {
3176 *key_ptr[0]++ = key >> 8;
3177 *key_ptr[0]++ = key & 0xff;
3178 }
3179 /* make key 1 start from 2 */
3180 if ((key = (ce >> 8) & 0xff)) *key_ptr[1]++ = key + 1;
3181 /* make key 2 start from 2 */
3182 if ((key = (ce >> 4) & 0x0f)) *key_ptr[2]++ = key + 1;
3183 /* key 3 is always a character code */
3184 if (ce & 1)
3185 {
3186 if (wch >> 8) *key_ptr[3]++ = wch >> 8;
3187 if (wch & 0xff) *key_ptr[3]++ = wch & 0xff;
3188 }
3189 }
3190 else
3191 {
3192 *key_ptr[0]++ = 0xff;
3193 *key_ptr[0]++ = 0xfe;
3194 if (wch >> 8) *key_ptr[0]++ = wch >> 8;
3195 if (wch & 0xff) *key_ptr[0]++ = wch & 0xff;
3196 }
3197 }
3198 }
3199 }
3200
3201 *key_ptr[0] = 1;
3202 *key_ptr[1] = 1;
3203 *key_ptr[2] = 1;
3204 *key_ptr[3]++ = 1;
3205 *key_ptr[3] = 0;
3206 return key_ptr[3] - dst;
3207 }
3208
3209
3210 /* compose a full-width katakana. return consumed source characters. */
3211 static int compose_katakana( const WCHAR *src, int srclen, WCHAR *dst )
3212 {
3213 static const BYTE katakana_map[] =
3214 {
3215 /* */ 0x02, 0x0c, 0x0d, 0x01, 0xfb, 0xf2, 0xa1, /* U+FF61- */
3216 0xa3, 0xa5, 0xa7, 0xa9, 0xe3, 0xe5, 0xe7, 0xc3, /* U+FF68- */
3217 0xfc, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xab, 0xad, /* U+FF70- */
3218 0xaf, 0xb1, 0xb3, 0xb5, 0xb7, 0xb9, 0xbb, 0xbd, /* U+FF78- */
3219 0xbf, 0xc1, 0xc4, 0xc6, 0xc8, 0xca, 0xcb, 0xcc, /* U+FF80- */
3220 0xcd, 0xce, 0xcf, 0xd2, 0xd5, 0xd8, 0xdb, 0xde, /* U+FF88- */
3221 0xdf, 0xe0, 0xe1, 0xe2, 0xe4, 0xe6, 0xe8, 0xe9, /* U+FF90- */
3222 0xea, 0xeb, 0xec, 0xed, 0xef, 0xf3, 0x99, 0x9a, /* U+FF98- */
3223 };
3224 WCHAR dummy;
3225 int shift;
3226
3227 if (!dst) dst = &dummy;
3228
3229 switch (*src)
3230 {
3231 case 0x309b:
3232 case 0x309c:
3233 *dst = *src - 2;
3234 return 1;
3235 case 0x30f0:
3236 case 0x30f1:
3237 case 0x30fd:
3238 *dst = *src;
3239 break;
3240 default:
3241 shift = *src - 0xff61;
3242 if (shift < 0 || shift >= ARRAY_SIZE( katakana_map )) return 0;
3243 *dst = katakana_map[shift] | 0x3000;
3244 break;
3245 }
3246
3247 if (srclen <= 1) return 1;
3248
3249 switch (src[1])
3250 {
3251 case 0xff9e: /* datakuten (voiced sound) */
3252 if ((*src >= 0xff76 && *src <= 0xff84) || (*src >= 0xff8a && *src <= 0xff8e) || *src == 0x30fd)
3253 *dst += 1;
3254 else if (*src == 0xff73)
3255 *dst = 0x30f4; /* KATAKANA LETTER VU */
3256 else if (*src == 0xff9c)
3257 *dst = 0x30f7; /* KATAKANA LETTER VA */
3258 else if (*src == 0x30f0)
3259 *dst = 0x30f8; /* KATAKANA LETTER VI */
3260 else if (*src == 0x30f1)
3261 *dst = 0x30f9; /* KATAKANA LETTER VE */
3262 else if (*src == 0xff66)
3263 *dst = 0x30fa; /* KATAKANA LETTER VO */
3264 else
3265 return 1;
3266 break;
3267 case 0xff9f: /* handakuten (semi-voiced sound) */
3268 if (*src >= 0xff8a && *src <= 0xff8e)
3269 *dst += 2;
3270 else
3271 return 1;
3272 break;
3273 default:
3274 return 1;
3275 }
3276 return 2;
3277 }
3278
3279 /* map one or two half-width characters to one full-width character */
3280 static int map_to_fullwidth( const WCHAR *src, int srclen, WCHAR *dst )
3281 {
3282 INT n;
3283
3284 if (*src <= '~' && *src > ' ' && *src != '\\')
3285 *dst = *src - 0x20 + 0xff00;
3286 else if (*src == ' ')
3287 *dst = 0x3000;
3288 else if (*src <= 0x00af && *src >= 0x00a2)
3289 {
3290 static const BYTE misc_symbols_table[] =
3291 {
3292 0xe0, 0xe1, 0x00, 0xe5, 0xe4, 0x00, 0x00, /* U+00A2- */
3293 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0xe3 /* U+00A9- */
3294 };
3295 if (misc_symbols_table[*src - 0x00a2])
3296 *dst = misc_symbols_table[*src - 0x00a2] | 0xff00;
3297 else
3298 *dst = *src;
3299 }
3300 else if (*src == 0x20a9) /* WON SIGN */
3301 *dst = 0xffe6;
3302 else if ((n = compose_katakana(src, srclen, dst)) > 0)
3303 return n;
3304 else if (*src >= 0xffa0 && *src <= 0xffdc)
3305 {
3306 static const BYTE hangul_mapping_table[] =
3307 {
3308 0x64, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, /* U+FFA0- */
3309 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, /* U+FFA8- */
3310 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* U+FFB0- */
3311 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x00, /* U+FFB8- */
3312 0x00, 0x00, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, /* U+FFC0- */
3313 0x00, 0x00, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, /* U+FFC8- */
3314 0x00, 0x00, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, /* U+FFD0- */
3315 0x00, 0x00, 0x61, 0x62, 0x63 /* U+FFD8- */
3316 };
3317
3318 if (hangul_mapping_table[*src - 0xffa0])
3319 *dst = hangul_mapping_table[*src - 0xffa0] | 0x3100;
3320 else
3321 *dst = *src;
3322 }
3323 else
3324 *dst = *src;
3325
3326 return 1;
3327 }
3328
3329 /* decompose a full-width katakana character into one or two half-width characters. */
3330 static int decompose_katakana( WCHAR c, WCHAR *dst, int dstlen )
3331 {
3332 static const BYTE katakana_map[] =
3333 {
3334 /* */ 0x9e, 0x9f, 0x9e, 0x9f, 0x00, 0x00, 0x00, /* U+3099- */
3335 0x00, 0x67, 0x71, 0x68, 0x72, 0x69, 0x73, 0x6a, /* U+30a1- */
3336 0x74, 0x6b, 0x75, 0x76, 0x01, 0x77, 0x01, 0x78, /* U+30a8- */
3337 0x01, 0x79, 0x01, 0x7a, 0x01, 0x7b, 0x01, 0x7c, /* U+30b0- */
3338 0x01, 0x7d, 0x01, 0x7e, 0x01, 0x7f, 0x01, 0x80, /* U+30b8- */
3339 0x01, 0x81, 0x01, 0x6f, 0x82, 0x01, 0x83, 0x01, /* U+30c0- */
3340 0x84, 0x01, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, /* U+30c8- */
3341 0x01, 0x02, 0x8b, 0x01, 0x02, 0x8c, 0x01, 0x02, /* U+30d0- */
3342 0x8d, 0x01, 0x02, 0x8e, 0x01, 0x02, 0x8f, 0x90, /* U+30d8- */
3343 0x91, 0x92, 0x93, 0x6c, 0x94, 0x6d, 0x95, 0x6e, /* U+30e0- */
3344 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x00, 0x9c, /* U+30e8- */
3345 0x00, 0x00, 0x66, 0x9d, 0x4e, 0x00, 0x00, 0x08, /* U+30f0- */
3346 0x58, 0x58, 0x08, 0x65, 0x70, 0x00, 0x51 /* U+30f8- */
3347 };
3348 int len = 0, shift = c - 0x3099;
3349 BYTE k;
3350
3351 if (shift < 0 || shift >= ARRAY_SIZE( katakana_map )) return 0;
3352
3353 k = katakana_map[shift];
3354 if (!k)
3355 {
3356 if (dstlen > 0) *dst = c;
3357 len++;
3358 }
3359 else if (k > 0x60)
3360 {
3361 if (dstlen > 0) *dst = k | 0xff00;
3362 len++;
3363 }
3364 else
3365 {
3366 if (dstlen >= 2)
3367 {
3368 dst[0] = (k > 0x50) ? (c - (k & 0xf)) : (katakana_map[shift - k] | 0xff00);
3369 dst[1] = (k == 2) ? 0xff9f : 0xff9e;
3370 }
3371 len += 2;
3372 }
3373 return len;
3374 }
3375
3376 /* map single full-width character to single or double half-width characters. */
3377 static int map_to_halfwidth( WCHAR c, WCHAR *dst, int dstlen )
3378 {
3379 int n = decompose_katakana( c, dst, dstlen );
3380 if (n > 0) return n;
3381
3382 if (c == 0x3000)
3383 *dst = ' ';
3384 else if (c == 0x3001)
3385 *dst = 0xff64;
3386 else if (c == 0x3002)
3387 *dst = 0xff61;
3388 else if (c == 0x300c || c == 0x300d)
3389 *dst = (c - 0x300c) + 0xff62;
3390 else if (c >= 0x3131 && c <= 0x3163)
3391 {
3392 *dst = c - 0x3131 + 0xffa1;
3393 if (*dst >= 0xffbf) *dst += 3;
3394 if (*dst >= 0xffc8) *dst += 2;
3395 if (*dst >= 0xffd0) *dst += 2;
3396 if (*dst >= 0xffd8) *dst += 2;
3397 }
3398 else if (c == 0x3164)
3399 *dst = 0xffa0;
3400 else if (c == 0x2019)
3401 *dst = '\'';
3402 else if (c == 0x201d)
3403 *dst = '"';
3404 else if (c > 0xff00 && c < 0xff5f && c != 0xff3c)
3405 *dst = c - 0xff00 + 0x20;
3406 else if (c >= 0xffe0 && c <= 0xffe6)
3407 {
3408 static const WCHAR misc_symbol_map[] = { 0x00a2, 0x00a3, 0x00ac, 0x00af, 0x00a6, 0x00a5, 0x20a9 };
3409 *dst = misc_symbol_map[c - 0xffe0];
3410 }
3411 else
3412 *dst = c;
3413
3414 return 1;
3415 }
3416
3417
3418 /* 32-bit collation element table format:
3419 * unicode weight - high 16 bit, diacritic weight - high 8 bit of low 16 bit,
3420 * case weight - high 4 bit of low 8 bit.
3421 */
3422
3423 enum weight { UNICODE_WEIGHT, DIACRITIC_WEIGHT, CASE_WEIGHT };
3424
3425 static unsigned int get_weight( WCHAR ch, enum weight type )
3426 {
3427 unsigned int ret;
3428
3429 ret = collation_table[collation_table[collation_table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0xf)];
3430 if (ret == ~0u) return ch;
3431
3432 switch (type)
3433 {
3434 case UNICODE_WEIGHT: return ret >> 16;
3435 case DIACRITIC_WEIGHT: return (ret >> 8) & 0xff;
3436 case CASE_WEIGHT: return (ret >> 4) & 0x0f;
3437 default: return 0;
3438 }
3439 }
3440
3441
3442 static void inc_str_pos( const WCHAR **str, int *len, unsigned int *dpos, unsigned int *dlen )
3443 {
3444 (*dpos)++;
3445 if (*dpos == *dlen)
3446 {
3447 *dpos = *dlen = 0;
3448 (*str)++;
3449 (*len)--;
3450 }
3451 }
3452
3453
3454 static int compare_weights(int flags, const WCHAR *str1, int len1,
3455 const WCHAR *str2, int len2, enum weight type )
3456 {
3457 unsigned int ce1, ce2, dpos1 = 0, dpos2 = 0, dlen1 = 0, dlen2 = 0;
3458 const WCHAR *dstr1 = NULL, *dstr2 = NULL;
3459
3460 while (len1 > 0 && len2 > 0)
3461 {
3462 if (!dlen1 && !(dstr1 = get_decomposition( *str1, &dlen1 ))) dstr1 = str1;
3463 if (!dlen2 && !(dstr2 = get_decomposition( *str2, &dlen2 ))) dstr2 = str2;
3464
3465 if (flags & NORM_IGNORESYMBOLS)
3466 {
3467 int skip = 0;
3468 /* FIXME: not tested */
3469 if (get_char_type( CT_CTYPE1, dstr1[dpos1] ) & (C1_PUNCT | C1_SPACE))
3470 {
3471 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
3472 skip = 1;
3473 }
3474 if (get_char_type( CT_CTYPE1, dstr2[dpos2] ) & (C1_PUNCT | C1_SPACE))
3475 {
3476 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
3477 skip = 1;
3478 }
3479 if (skip) continue;
3480 }
3481
3482 /* hyphen and apostrophe are treated differently depending on
3483 * whether SORT_STRINGSORT specified or not
3484 */
3485 if (type == UNICODE_WEIGHT && !(flags & SORT_STRINGSORT))
3486 {
3487 if (dstr1[dpos1] == '-' || dstr1[dpos1] == '\'')
3488 {
3489 if (dstr2[dpos2] != '-' && dstr2[dpos2] != '\'')
3490 {
3491 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
3492 continue;
3493 }
3494 }
3495 else if (dstr2[dpos2] == '-' || dstr2[dpos2] == '\'')
3496 {
3497 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
3498 continue;
3499 }
3500 }
3501
3502 ce1 = get_weight( dstr1[dpos1], type );
3503 if (!ce1)
3504 {
3505 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
3506 continue;
3507 }
3508 ce2 = get_weight( dstr2[dpos2], type );
3509 if (!ce2)
3510 {
3511 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
3512 continue;
3513 }
3514
3515 if (ce1 - ce2) return ce1 - ce2;
3516
3517 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
3518 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
3519 }
3520 while (len1)
3521 {
3522 if (!dlen1 && !(dstr1 = get_decomposition( *str1, &dlen1 ))) dstr1 = str1;
3523 ce1 = get_weight( dstr1[dpos1], type );
3524 if (ce1) break;
3525 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
3526 }
3527 while (len2)
3528 {
3529 if (!dlen2 && !(dstr2 = get_decomposition( *str2, &dlen2 ))) dstr2 = str2;
3530 ce2 = get_weight( dstr2[dpos2], type );
3531 if (ce2) break;
3532 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
3533 }
3534 return len1 - len2;
3535 }
3536
3537
3538 static int compare_tzdate( const TIME_FIELDS *tf, const SYSTEMTIME *compare )
3539 {
3540 static const int month_lengths[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
3541 int first, last, limit, dayinsecs;
3542
3543 if (tf->Month < compare->wMonth) return -1; /* We are in a month before the date limit. */
3544 if (tf->Month > compare->wMonth) return 1; /* We are in a month after the date limit. */
3545
3546 /* if year is 0 then date is in day-of-week format, otherwise
3547 * it's absolute date.
3548 */
3549 if (!compare->wYear)
3550 {
3551 /* wDay is interpreted as number of the week in the month
3552 * 5 means: the last week in the month */
3553 /* calculate the day of the first DayOfWeek in the month */
3554 first = (6 + compare->wDayOfWeek - tf->Weekday + tf->Day) % 7 + 1;
3555 /* check needed for the 5th weekday of the month */
3556 last = month_lengths[tf->Month - 1] +
3557 (tf->Month == 2 && (!(tf->Year % 4) && (tf->Year % 100 || !(tf->Year % 400))));
3558 limit = first + 7 * (compare->wDay - 1);
3559 if (limit > last) limit -= 7;
3560 }
3561 else limit = compare->wDay;
3562
3563 limit = ((limit * 24 + compare->wHour) * 60 + compare->wMinute) * 60;
3564 dayinsecs = ((tf->Day * 24 + tf->Hour) * 60 + tf->Minute) * 60 + tf->Second;
3565 return dayinsecs - limit;
3566 }
3567
3568
3569 static DWORD get_timezone_id( const TIME_ZONE_INFORMATION *info, LARGE_INTEGER time, BOOL is_local )
3570 {
3571 int year;
3572 BOOL before_standard_date, after_daylight_date;
3573 LARGE_INTEGER t2;
3574 TIME_FIELDS tf;
3575
3576 if (!info->DaylightDate.wMonth) return TIME_ZONE_ID_UNKNOWN;
3577
3578 /* if year is 0 then date is in day-of-week format, otherwise it's absolute date */
3579 if (info->StandardDate.wMonth == 0 ||
3580 (info->StandardDate.wYear == 0 &&
3581 (info->StandardDate.wDay < 1 || info->StandardDate.wDay > 5 ||
3582 info->DaylightDate.wDay < 1 || info->DaylightDate.wDay > 5)))
3583 {
3584 SetLastError( ERROR_INVALID_PARAMETER );
3585 return TIME_ZONE_ID_INVALID;
3586 }
3587
3588 if (!is_local) time.QuadPart -= info->Bias * (LONGLONG)600000000;
3589 RtlTimeToTimeFields( &time, &tf );
3590 year = tf.Year;
3591 if (!is_local)
3592 {
3593 t2.QuadPart = time.QuadPart - info->DaylightBias * (LONGLONG)600000000;
3594 RtlTimeToTimeFields( &t2, &tf );
3595 }
3596 if (tf.Year == year)
3597 before_standard_date = compare_tzdate( &tf, &info->StandardDate ) < 0;
3598 else
3599 before_standard_date = tf.Year < year;
3600
3601 if (!is_local)
3602 {
3603 t2.QuadPart = time.QuadPart - info->StandardBias * (LONGLONG)600000000;
3604 RtlTimeToTimeFields( &t2, &tf );
3605 }
3606 if (tf.Year == year)
3607 after_daylight_date = compare_tzdate( &tf, &info->DaylightDate ) >= 0;
3608 else
3609 after_daylight_date = tf.Year > year;
3610
3611 if (info->DaylightDate.wMonth < info->StandardDate.wMonth) /* Northern hemisphere */
3612 {
3613 if (before_standard_date && after_daylight_date) return TIME_ZONE_ID_DAYLIGHT;
3614 }
3615 else /* Down south */
3616 {
3617 if (before_standard_date || after_daylight_date) return TIME_ZONE_ID_DAYLIGHT;
3618 }
3619 return TIME_ZONE_ID_STANDARD;
3620 }
3621
3622
3623 /* Note: the Internal_ functions are not documented. The number of parameters
3624 * should be correct, but their exact meaning may not.
3625 */
3626
3627 /******************************************************************************
3628 * Internal_EnumCalendarInfo (kernelbase.@)
3629 */
3630 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumCalendarInfo( CALINFO_ENUMPROCW proc, LCID lcid, CALID id,
3631 CALTYPE type, BOOL unicode, BOOL ex,
3632 BOOL exex, LPARAM lparam )
3633 {
3634 WCHAR buffer[256];
3635 CALID calendars[2] = { id };
3636 INT ret, i;
3637
3638 if (!proc)
3639 {
3640 SetLastError( ERROR_INVALID_PARAMETER );
3641 return FALSE;
3642 }
3643
3644 if (id == ENUM_ALL_CALENDARS)
3645 {
3646 if (!GetLocaleInfoW( lcid, LOCALE_ICALENDARTYPE | LOCALE_RETURN_NUMBER,
3647 (WCHAR *)&calendars[0], sizeof(calendars[0]) / sizeof(WCHAR) )) return FALSE;
3648 if (!GetLocaleInfoW( lcid, LOCALE_IOPTIONALCALENDAR | LOCALE_RETURN_NUMBER,
3649 (WCHAR *)&calendars[1], sizeof(calendars[1]) / sizeof(WCHAR) )) calendars[1] = 0;
3650 }
3651
3652 for (i = 0; i < ARRAY_SIZE(calendars) && calendars[i]; i++)
3653 {
3654 id = calendars[i];
3655 if (type & CAL_RETURN_NUMBER)
3656 ret = GetCalendarInfoW( lcid, id, type, NULL, 0, (LPDWORD)buffer );
3657 else if (unicode)
3658 ret = GetCalendarInfoW( lcid, id, type, buffer, ARRAY_SIZE(buffer), NULL );
3659 else
3660 {
3661 WCHAR bufW[256];
3662 ret = GetCalendarInfoW( lcid, id, type, bufW, ARRAY_SIZE(bufW), NULL );
3663 if (ret) WideCharToMultiByte( CP_ACP, 0, bufW, -1, (char *)buffer, sizeof(buffer), NULL, NULL );
3664 }
3665
3666 if (ret)
3667 {
3668 if (exex) ret = ((CALINFO_ENUMPROCEXEX)proc)( buffer, id, NULL, lparam );
3669 else if (ex) ret = ((CALINFO_ENUMPROCEXW)proc)( buffer, id );
3670 else ret = proc( buffer );
3671 }
3672 if (!ret) break;
3673 }
3674 return TRUE;
3675 }
3676
3677
3678 /**************************************************************************
3679 * Internal_EnumDateFormats (kernelbase.@)
3680 */
3681 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumDateFormats( DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags,
3682 BOOL unicode, BOOL ex, BOOL exex, LPARAM lparam )
3683 {
3684 WCHAR buffer[256];
3685 LCTYPE lctype;
3686 CALID cal_id;
3687 INT ret;
3688
3689 if (!proc)
3690 {
3691 SetLastError( ERROR_INVALID_PARAMETER );
3692 return FALSE;
3693 }
3694 if (!GetLocaleInfoW( lcid, LOCALE_ICALENDARTYPE|LOCALE_RETURN_NUMBER,
3695 (LPWSTR)&cal_id, sizeof(cal_id)/sizeof(WCHAR) ))
3696 return FALSE;
3697
3698 switch (flags & ~LOCALE_USE_CP_ACP)
3699 {
3700 case 0:
3701 case DATE_SHORTDATE:
3702 lctype = LOCALE_SSHORTDATE;
3703 break;
3704 case DATE_LONGDATE:
3705 lctype = LOCALE_SLONGDATE;
3706 break;
3707 case DATE_YEARMONTH:
3708 lctype = LOCALE_SYEARMONTH;
3709 break;
3710 default:
3711 FIXME( "unknown date format 0x%08lx\n", flags );
3712 SetLastError( ERROR_INVALID_PARAMETER );
3713 return FALSE;
3714 }
3715
3716 lctype |= flags & LOCALE_USE_CP_ACP;
3717 if (unicode)
3718 ret = GetLocaleInfoW( lcid, lctype, buffer, ARRAY_SIZE(buffer) );
3719 else
3720 ret = GetLocaleInfoA( lcid, lctype, (char *)buffer, sizeof(buffer) );
3721
3722 if (ret)
3723 {
3724 if (exex) ((DATEFMT_ENUMPROCEXEX)proc)( buffer, cal_id, lparam );
3725 else if (ex) ((DATEFMT_ENUMPROCEXW)proc)( buffer, cal_id );
3726 else proc( buffer );
3727 }
3728 return TRUE;
3729 }
3730
3731
3732 /******************************************************************************
3733 * Internal_EnumLanguageGroupLocales (kernelbase.@)
3734 */
3735 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumLanguageGroupLocales( LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id,
3736 DWORD flags, LONG_PTR param, BOOL unicode )
3737 {
3738 WCHAR name[10], value[10];
3739 DWORD name_len, value_len, type, index = 0, alt = 0;
3740 HKEY key, altkey;
3741 LCID lcid;
3742
3743 if (!proc || id < LGRPID_WESTERN_EUROPE || id > LGRPID_ARMENIAN)
3744 {
3745 SetLastError( ERROR_INVALID_PARAMETER );
3746 return FALSE;
3747 }
3748
3749 if (RegOpenKeyExW( nls_key, L"Locale", 0, KEY_READ, &key )) return FALSE;
3750 if (RegOpenKeyExW( key, L"Alternate Sorts", 0, KEY_READ, &altkey )) altkey = 0;
3751
3752 for (;;)
3753 {
3754 name_len = ARRAY_SIZE(name);
3755 value_len = sizeof(value);
3756 if (RegEnumValueW( alt ? altkey : key, index++, name, &name_len, NULL,
3757 &type, (BYTE *)value, &value_len ))
3758 {
3759 if (alt++) break;
3760 index = 0;
3761 continue;
3762 }
3763 if (type != REG_SZ) continue;
3764 if (id != wcstoul( value, NULL, 16 )) continue;
3765 lcid = wcstoul( name, NULL, 16 );
3766 if (!unicode)
3767 {
3768 char nameA[10];
3769 WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
3770 if (!((LANGGROUPLOCALE_ENUMPROCA)proc)( id, lcid, nameA, param )) break;
3771 }
3772 else if (!proc( id, lcid, name, param )) break;
3773 }
3774 RegCloseKey( altkey );
3775 RegCloseKey( key );
3776 return TRUE;
3777 }
3778
3779
3780 /***********************************************************************
3781 * Internal_EnumSystemCodePages (kernelbase.@)
3782 */
3783 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumSystemCodePages( CODEPAGE_ENUMPROCW proc, DWORD flags,
3784 BOOL unicode )
3785 {
3786 WCHAR name[10];
3787 DWORD name_len, type, index = 0;
3788 HKEY key;
3789
3790 if (RegOpenKeyExW( nls_key, L"Codepage", 0, KEY_READ, &key )) return FALSE;
3791
3792 for (;;)
3793 {
3794 name_len = ARRAY_SIZE(name);
3795 if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, NULL, NULL )) break;
3796 if (type != REG_SZ) continue;
3797 if (!wcstoul( name, NULL, 10 )) continue;
3798 if (!unicode)
3799 {
3800 char nameA[10];
3801 WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
3802 if (!((CODEPAGE_ENUMPROCA)proc)( nameA )) break;
3803 }
3804 else if (!proc( name )) break;
3805 }
3806 RegCloseKey( key );
3807 return TRUE;
3808 }
3809
3810
3811 /******************************************************************************
3812 * Internal_EnumSystemLanguageGroups (kernelbase.@)
3813 */
3814 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumSystemLanguageGroups( LANGUAGEGROUP_ENUMPROCW proc,
3815 DWORD flags, LONG_PTR param, BOOL unicode )
3816 {
3817 WCHAR name[10], value[10], descr[80];
3818 DWORD name_len, value_len, type, index = 0;
3819 HKEY key;
3820 LGRPID id;
3821
3822 if (!proc)
3823 {
3824 SetLastError( ERROR_INVALID_PARAMETER );
3825 return FALSE;
3826 }
3827
3828 switch (flags)
3829 {
3830 case 0:
3831 flags = LGRPID_INSTALLED;
3832 break;
3833 case LGRPID_INSTALLED:
3834 case LGRPID_SUPPORTED:
3835 break;
3836 default:
3837 SetLastError( ERROR_INVALID_FLAGS );
3838 return FALSE;
3839 }
3840
3841 if (RegOpenKeyExW( nls_key, L"Language Groups", 0, KEY_READ, &key )) return FALSE;
3842
3843 for (;;)
3844 {
3845 name_len = ARRAY_SIZE(name);
3846 value_len = sizeof(value);
3847 if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, (BYTE *)value, &value_len )) break;
3848 if (type != REG_SZ) continue;
3849
3850 id = wcstoul( name, NULL, 16 );
3851
3852 if (!(flags & LGRPID_SUPPORTED) && !wcstoul( value, NULL, 10 )) continue;
3853 if (!LoadStringW( kernelbase_handle, id, descr, ARRAY_SIZE(descr) )) descr[0] = 0;
3854 TRACE( "%p: %lu %s %s %lx %Ix\n", proc, id, debugstr_w(name), debugstr_w(descr), flags, param );
3855 if (!unicode)
3856 {
3857 char nameA[10], descrA[80];
3858 WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
3859 WideCharToMultiByte( CP_ACP, 0, descr, -1, descrA, sizeof(descrA), NULL, NULL );
3860 if (!((LANGUAGEGROUP_ENUMPROCA)proc)( id, nameA, descrA, flags, param )) break;
3861 }
3862 else if (!proc( id, name, descr, flags, param )) break;
3863 }
3864 RegCloseKey( key );
3865 return TRUE;
3866 }
3867
3868
3869 /**************************************************************************
3870 * Internal_EnumTimeFormats (kernelbase.@)
3871 */
3872 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumTimeFormats( TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags,
3873 BOOL unicode, BOOL ex, LPARAM lparam )
3874 {
3875 WCHAR buffer[256];
3876 LCTYPE lctype;
3877 INT ret;
3878
3879 if (!proc)
3880 {
3881 SetLastError( ERROR_INVALID_PARAMETER );
3882 return FALSE;
3883 }
3884 switch (flags & ~LOCALE_USE_CP_ACP)
3885 {
3886 case 0:
3887 lctype = LOCALE_STIMEFORMAT;
3888 break;
3889 case TIME_NOSECONDS:
3890 lctype = LOCALE_SSHORTTIME;
3891 break;
3892 default:
3893 FIXME( "Unknown time format %lx\n", flags );
3894 SetLastError( ERROR_INVALID_PARAMETER );
3895 return FALSE;
3896 }
3897
3898 lctype |= flags & LOCALE_USE_CP_ACP;
3899 if (unicode)
3900 ret = GetLocaleInfoW( lcid, lctype, buffer, ARRAY_SIZE(buffer) );
3901 else
3902 ret = GetLocaleInfoA( lcid, lctype, (char *)buffer, sizeof(buffer) );
3903
3904 if (ret)
3905 {
3906 if (ex) ((TIMEFMT_ENUMPROCEX)proc)( buffer, lparam );
3907 else proc( buffer );
3908 }
3909 return TRUE;
3910 }
3911
3912
3913 /******************************************************************************
3914 * Internal_EnumUILanguages (kernelbase.@)
3915 */
3916 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumUILanguages( UILANGUAGE_ENUMPROCW proc, DWORD flags,
3917 LONG_PTR param, BOOL unicode )
3918 {
3919 WCHAR nameW[LOCALE_NAME_MAX_LENGTH];
3920 char nameA[LOCALE_NAME_MAX_LENGTH];
3921 DWORD i;
3922
3923 if (!proc)
3924 {
3925 SetLastError( ERROR_INVALID_PARAMETER );
3926 return FALSE;
3927 }
3928 if (flags & ~(MUI_LANGUAGE_ID | MUI_LANGUAGE_NAME))
3929 {
3930 SetLastError( ERROR_INVALID_FLAGS );
3931 return FALSE;
3932 }
3933
3934 for (i = 0; i < locale_table->nb_lcnames; i++)
3935 {
3936 if (!lcnames_index[i].name) continue; /* skip invariant locale */
3937 if (lcnames_index[i].id & 0x80000000) continue; /* skip aliases */
3938 if (!get_locale_data( lcnames_index[i].idx )->inotneutral) continue; /* skip neutral locales */
3939 if (!SORTIDFROMLCID( lcnames_index[i].id ) != !(flags & LCID_ALTERNATE_SORTS))
3940 continue; /* skip alternate sorts */
3941 if (flags & MUI_LANGUAGE_NAME)
3942 {
3943 const WCHAR *str = locale_strings + lcnames_index[i].name;
3944
3945 if (unicode)
3946 {
3947 memcpy( nameW, str + 1, (*str + 1) * sizeof(WCHAR) );
3948 if (!proc( nameW, param )) break;
3949 }
3950 else
3951 {
3952 WideCharToMultiByte( CP_ACP, 0, str + 1, -1, nameA, sizeof(nameA), NULL, NULL );
3953 if (!((UILANGUAGE_ENUMPROCA)proc)( nameA, param )) break;
3954 }
3955 }
3956 else
3957 {
3958 if (lcnames_index[i].id == LOCALE_CUSTOM_UNSPECIFIED) continue; /* skip locales with no lcid */
3959 if (unicode)
3960 {
3961 swprintf( nameW, ARRAY_SIZE(nameW), L"%04lx", lcnames_index[i].id );
3962 if (!proc( nameW, param )) break;
3963 }
3964 else
3965 {
3966 sprintf( nameA, "%04x", lcnames_index[i].id );
3967 if (!((UILANGUAGE_ENUMPROCA)proc)( nameA, param )) break;
3968 }
3969 }
3970 }
3971 return TRUE;
3972 }
3973
3974
3975 /******************************************************************************
3976 * CompareStringEx (kernelbase.@)
3977 */
3978 INT WINAPI CompareStringEx( const WCHAR *locale, DWORD flags, const WCHAR *str1, int len1,
3979 const WCHAR *str2, int len2, NLSVERSIONINFO *version,
3980 void *reserved, LPARAM handle )
3981 {
3982 DWORD supported_flags = NORM_IGNORECASE | NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS | SORT_STRINGSORT |
3983 NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH | LOCALE_USE_CP_ACP;
3984 DWORD semistub_flags = NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE | LINGUISTIC_IGNOREDIACRITIC |
3985 SORT_DIGITSASNUMBERS | 0x10000000;
3986 /* 0x10000000 is related to diacritics in Arabic, Japanese, and Hebrew */
3987 INT ret;
3988 static int once;
3989
3990 if (version) FIXME( "unexpected version parameter\n" );
3991 if (reserved) FIXME( "unexpected reserved value\n" );
3992 if (handle) FIXME( "unexpected handle\n" );
3993
3994 if (!str1 || !str2)
3995 {
3996 SetLastError( ERROR_INVALID_PARAMETER );
3997 return 0;
3998 }
3999
4000 if (flags & ~(supported_flags | semistub_flags))
4001 {
4002 SetLastError( ERROR_INVALID_FLAGS );
4003 return 0;
4004 }
4005
4006 if (flags & semistub_flags)
4007 {
4008 if (!once++) FIXME( "semi-stub behavior for flag(s) 0x%lx\n", flags & semistub_flags );
4009 }
4010
4011 if (len1 < 0) len1 = lstrlenW(str1);
4012 if (len2 < 0) len2 = lstrlenW(str2);
4013
4014 ret = compare_weights( flags, str1, len1, str2, len2, UNICODE_WEIGHT );
4015 if (!ret)
4016 {
4017 if (!(flags & NORM_IGNORENONSPACE))
4018 ret = compare_weights( flags, str1, len1, str2, len2, DIACRITIC_WEIGHT );
4019 if (!ret && !(flags & NORM_IGNORECASE))
4020 ret = compare_weights( flags, str1, len1, str2, len2, CASE_WEIGHT );
4021 }
4022 if (!ret) return CSTR_EQUAL;
4023 return (ret < 0) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
4024 }
4025
4026
4027 /******************************************************************************
4028 * CompareStringA (kernelbase.@)
4029 */
4030 INT WINAPI DECLSPEC_HOTPATCH CompareStringA( LCID lcid, DWORD flags, const char *str1, int len1,
4031 const char *str2, int len2 )
4032 {
4033 WCHAR *buf1W = NtCurrentTeb()->StaticUnicodeBuffer;
4034 WCHAR *buf2W = buf1W + 130;
4035 LPWSTR str1W, str2W;
4036 INT len1W = 0, len2W = 0, ret;
4037 UINT locale_cp = CP_ACP;
4038
4039 if (!str1 || !str2)
4040 {
4041 SetLastError( ERROR_INVALID_PARAMETER );
4042 return 0;
4043 }
4044
4045 if (flags & SORT_DIGITSASNUMBERS)
4046 {
4047 SetLastError( ERROR_INVALID_FLAGS );
4048 return 0;
4049 }
4050
4051 if (len1 < 0) len1 = strlen(str1);
4052 if (len2 < 0) len2 = strlen(str2);
4053
4054 locale_cp = get_lcid_codepage( lcid, flags );
4055 if (len1)
4056 {
4057 if (len1 <= 130) len1W = MultiByteToWideChar( locale_cp, 0, str1, len1, buf1W, 130 );
4058 if (len1W) str1W = buf1W;
4059 else
4060 {
4061 len1W = MultiByteToWideChar( locale_cp, 0, str1, len1, NULL, 0 );
4062 str1W = HeapAlloc( GetProcessHeap(), 0, len1W * sizeof(WCHAR) );
4063 if (!str1W)
4064 {
4065 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
4066 return 0;
4067 }
4068 MultiByteToWideChar( locale_cp, 0, str1, len1, str1W, len1W );
4069 }
4070 }
4071 else
4072 {
4073 len1W = 0;
4074 str1W = buf1W;
4075 }
4076
4077 if (len2)
4078 {
4079 if (len2 <= 130) len2W = MultiByteToWideChar( locale_cp, 0, str2, len2, buf2W, 130 );
4080 if (len2W) str2W = buf2W;
4081 else
4082 {
4083 len2W = MultiByteToWideChar( locale_cp, 0, str2, len2, NULL, 0 );
4084 str2W = HeapAlloc( GetProcessHeap(), 0, len2W * sizeof(WCHAR) );
4085 if (!str2W)
4086 {
4087 if (str1W != buf1W) HeapFree( GetProcessHeap(), 0, str1W );
4088 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
4089 return 0;
4090 }
4091 MultiByteToWideChar( locale_cp, 0, str2, len2, str2W, len2W );
4092 }
4093 }
4094 else
4095 {
4096 len2W = 0;
4097 str2W = buf2W;
4098 }
4099
4100 ret = CompareStringW( lcid, flags, str1W, len1W, str2W, len2W );
4101
4102 if (str1W != buf1W) HeapFree( GetProcessHeap(), 0, str1W );
4103 if (str2W != buf2W) HeapFree( GetProcessHeap(), 0, str2W );
4104 return ret;
4105 }
4106
4107
4108 /******************************************************************************
4109 * CompareStringW (kernelbase.@)
4110 */
4111 INT WINAPI DECLSPEC_HOTPATCH CompareStringW( LCID lcid, DWORD flags, const WCHAR *str1, int len1,
4112 const WCHAR *str2, int len2 )
4113 {
4114 return CompareStringEx( NULL, flags, str1, len1, str2, len2, NULL, NULL, 0 );
4115 }
4116
4117
4118 /******************************************************************************
4119 * CompareStringOrdinal (kernelbase.@)
4120 */
4121 INT WINAPI DECLSPEC_HOTPATCH CompareStringOrdinal( const WCHAR *str1, INT len1,
4122 const WCHAR *str2, INT len2, BOOL ignore_case )
4123 {
4124 int ret;
4125
4126 if (!str1 || !str2)
4127 {
4128 SetLastError( ERROR_INVALID_PARAMETER );
4129 return 0;
4130 }
4131 if (len1 < 0) len1 = lstrlenW( str1 );
4132 if (len2 < 0) len2 = lstrlenW( str2 );
4133
4134 ret = RtlCompareUnicodeStrings( str1, len1, str2, len2, ignore_case );
4135 if (ret < 0) return CSTR_LESS_THAN;
4136 if (ret > 0) return CSTR_GREATER_THAN;
4137 return CSTR_EQUAL;
4138 }
4139
4140
4141 /******************************************************************************
4142 * ConvertDefaultLocale (kernelbase.@)
4143 */
4144 LCID WINAPI DECLSPEC_HOTPATCH ConvertDefaultLocale( LCID lcid )
4145 {
4146 const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, 0 );
4147 if (locale) lcid = locale->ilanguage;
4148 return lcid;
4149 }
4150
4151
4152 /******************************************************************************
4153 * EnumCalendarInfoW (kernelbase.@)
4154 */
4155 BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoW( CALINFO_ENUMPROCW proc, LCID lcid,
4156 CALID id, CALTYPE type )
4157 {
4158 return Internal_EnumCalendarInfo( proc, lcid, id, type, TRUE, FALSE, FALSE, 0 );
4159 }
4160
4161
4162 /******************************************************************************
4163 * EnumCalendarInfoExW (kernelbase.@)
4164 */
4165 BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoExW( CALINFO_ENUMPROCEXW proc, LCID lcid,
4166 CALID id, CALTYPE type )
4167 {
4168 return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, lcid, id, type, TRUE, TRUE, FALSE, 0 );
4169 }
4170
4171 /******************************************************************************
4172 * EnumCalendarInfoExEx (kernelbase.@)
4173 */
4174 BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoExEx( CALINFO_ENUMPROCEXEX proc, LPCWSTR locale, CALID id,
4175 LPCWSTR reserved, CALTYPE type, LPARAM lparam )
4176 {
4177 LCID lcid = LocaleNameToLCID( locale, 0 );
4178 return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, lcid, id, type, TRUE, TRUE, TRUE, lparam );
4179 }
4180
4181
4182 /**************************************************************************
4183 * EnumDateFormatsW (kernelbase.@)
4184 */
4185 BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsW( DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags )
4186 {
4187 return Internal_EnumDateFormats( proc, lcid, flags, TRUE, FALSE, FALSE, 0 );
4188 }
4189
4190
4191 /**************************************************************************
4192 * EnumDateFormatsExW (kernelbase.@)
4193 */
4194 BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsExW( DATEFMT_ENUMPROCEXW proc, LCID lcid, DWORD flags )
4195 {
4196 return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, lcid, flags, TRUE, TRUE, FALSE, 0 );
4197 }
4198
4199
4200 /**************************************************************************
4201 * EnumDateFormatsExEx (kernelbase.@)
4202 */
4203 BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsExEx( DATEFMT_ENUMPROCEXEX proc, const WCHAR *locale,
4204 DWORD flags, LPARAM lparam )
4205 {
4206 LCID lcid = LocaleNameToLCID( locale, 0 );
4207 return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, lcid, flags, TRUE, TRUE, TRUE, lparam );
4208 }
4209
4210
4211
4212 /******************************************************************************
4213 * EnumDynamicTimeZoneInformation (kernelbase.@)
4214 */
4215 DWORD WINAPI DECLSPEC_HOTPATCH EnumDynamicTimeZoneInformation( DWORD index,
4216 DYNAMIC_TIME_ZONE_INFORMATION *info )
4217 {
4218 DYNAMIC_TIME_ZONE_INFORMATION tz;
4219 LSTATUS ret;
4220 DWORD size;
4221
4222 if (!info) return ERROR_INVALID_PARAMETER;
4223
4224 size = ARRAY_SIZE(tz.TimeZoneKeyName);
4225 ret = RegEnumKeyExW( tz_key, index, tz.TimeZoneKeyName, &size, NULL, NULL, NULL, NULL );
4226 if (ret) return ret;
4227
4228 tz.DynamicDaylightTimeDisabled = TRUE;
4229 if (!GetTimeZoneInformationForYear( 0, &tz, (TIME_ZONE_INFORMATION *)info )) return GetLastError();
4230
4231 lstrcpyW( info->TimeZoneKeyName, tz.TimeZoneKeyName );
4232 info->DynamicDaylightTimeDisabled = FALSE;
4233 return 0;
4234 }
4235
4236
4237 /******************************************************************************
4238 * EnumLanguageGroupLocalesW (kernelbase.@)
4239 */
4240 BOOL WINAPI DECLSPEC_HOTPATCH EnumLanguageGroupLocalesW( LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id,
4241 DWORD flags, LONG_PTR param )
4242 {
4243 return Internal_EnumLanguageGroupLocales( proc, id, flags, param, TRUE );
4244 }
4245
4246
4247 /******************************************************************************
4248 * EnumUILanguagesW (kernelbase.@)
4249 */
4250 BOOL WINAPI DECLSPEC_HOTPATCH EnumUILanguagesW( UILANGUAGE_ENUMPROCW proc, DWORD flags, LONG_PTR param )
4251 {
4252 return Internal_EnumUILanguages( proc, flags, param, TRUE );
4253 }
4254
4255
4256 /***********************************************************************
4257 * EnumSystemCodePagesW (kernelbase.@)
4258 */
4259 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemCodePagesW( CODEPAGE_ENUMPROCW proc, DWORD flags )
4260 {
4261 return Internal_EnumSystemCodePages( proc, flags, TRUE );
4262 }
4263
4264
4265 /******************************************************************************
4266 * EnumSystemGeoID (kernelbase.@)
4267 */
4268 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemGeoID( GEOCLASS class, GEOID parent, GEO_ENUMPROC proc )
4269 {
4270 INT i;
4271
4272 TRACE( "(%ld, %ld, %p)\n", class, parent, proc );
4273
4274 if (!proc)
4275 {
4276 SetLastError( ERROR_INVALID_PARAMETER );
4277 return FALSE;
4278 }
4279 if (class != GEOCLASS_NATION && class != GEOCLASS_REGION && class != GEOCLASS_ALL)
4280 {
4281 SetLastError( ERROR_INVALID_FLAGS );
4282 return FALSE;
4283 }
4284
4285 for (i = 0; i < geo_ids_count; i++)
4286 {
4287 if (class != GEOCLASS_ALL && geo_ids[i].class != class) continue;
4288 if (parent && geo_ids[i].parent != parent) continue;
4289 if (!proc( geo_ids[i].id )) break;
4290 }
4291 return TRUE;
4292 }
4293
4294
4295 /******************************************************************************
4296 * EnumSystemLanguageGroupsW (kernelbase.@)
4297 */
4298 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLanguageGroupsW( LANGUAGEGROUP_ENUMPROCW proc,
4299 DWORD flags, LONG_PTR param )
4300 {
4301 return Internal_EnumSystemLanguageGroups( proc, flags, param, TRUE );
4302 }
4303
4304
4305 /******************************************************************************
4306 * EnumSystemLocalesA (kernelbase.@)
4307 */
4308 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesA( LOCALE_ENUMPROCA proc, DWORD flags )
4309 {
4310 char name[10];
4311 DWORD i;
4312
4313 for (i = 0; i < locale_table->nb_lcnames; i++)
4314 {
4315 if (!lcnames_index[i].name) continue; /* skip invariant locale */
4316 if (lcnames_index[i].id == LOCALE_CUSTOM_UNSPECIFIED) continue; /* skip locales with no lcid */
4317 if (lcnames_index[i].id & 0x80000000) continue; /* skip aliases */
4318 if (!get_locale_data( lcnames_index[i].idx )->inotneutral) continue; /* skip neutral locales */
4319 if (!SORTIDFROMLCID( lcnames_index[i].id ) != !(flags & LCID_ALTERNATE_SORTS))
4320 continue; /* skip alternate sorts */
4321 sprintf( name, "%08x", lcnames_index[i].id );
4322 if (!proc( name )) break;
4323 }
4324 return TRUE;
4325 }
4326
4327
4328 /******************************************************************************
4329 * EnumSystemLocalesW (kernelbase.@)
4330 */
4331 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesW( LOCALE_ENUMPROCW proc, DWORD flags )
4332 {
4333 WCHAR name[10];
4334 DWORD i;
4335
4336 for (i = 0; i < locale_table->nb_lcnames; i++)
4337 {
4338 if (!lcnames_index[i].name) continue; /* skip invariant locale */
4339 if (lcnames_index[i].id == LOCALE_CUSTOM_UNSPECIFIED) continue; /* skip locales with no lcid */
4340 if (lcnames_index[i].id & 0x80000000) continue; /* skip aliases */
4341 if (!get_locale_data( lcnames_index[i].idx )->inotneutral) continue; /* skip neutral locales */
4342 if (!SORTIDFROMLCID( lcnames_index[i].id ) != !(flags & LCID_ALTERNATE_SORTS))
4343 continue; /* skip alternate sorts */
4344 swprintf( name, ARRAY_SIZE(name), L"%08lx", lcnames_index[i].id );
4345 if (!proc( name )) break;
4346 }
4347 return TRUE;
4348 }
4349
4350
4351 /******************************************************************************
4352 * EnumSystemLocalesEx (kernelbase.@)
4353 */
4354 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesEx( LOCALE_ENUMPROCEX proc, DWORD wanted_flags,
4355 LPARAM param, void *reserved )
4356 {
4357 WCHAR buffer[LOCALE_NAME_MAX_LENGTH];
4358 DWORD i, flags;
4359
4360 if (reserved)
4361 {
4362 SetLastError( ERROR_INVALID_PARAMETER );
4363 return FALSE;
4364 }
4365
4366 for (i = 0; i < locale_table->nb_lcnames; i++)
4367 {
4368 const NLS_LOCALE_DATA *locale = get_locale_data( lcnames_index[i].idx );
4369 const WCHAR *str = locale_strings + lcnames_index[i].name;
4370
4371 if (lcnames_index[i].id & 0x80000000) continue; /* skip aliases */
4372 memcpy( buffer, str + 1, (*str + 1) * sizeof(WCHAR) );
4373 if (SORTIDFROMLCID( lcnames_index[i].id ) || wcschr( str + 1, '_' ))
4374 flags = LOCALE_ALTERNATE_SORTS;
4375 else
4376 flags = LOCALE_WINDOWS | (locale->inotneutral ? LOCALE_SPECIFICDATA : LOCALE_NEUTRALDATA);
4377 if (wanted_flags && !(flags & wanted_flags)) continue;
4378 if (!proc( buffer, flags, param )) break;
4379 }
4380 return TRUE;
4381 }
4382
4383
4384 /**************************************************************************
4385 * EnumTimeFormatsW (kernelbase.@)
4386 */
4387 BOOL WINAPI DECLSPEC_HOTPATCH EnumTimeFormatsW( TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags )
4388 {
4389 return Internal_EnumTimeFormats( proc, lcid, flags, TRUE, FALSE, 0 );
4390 }
4391
4392
4393 /**************************************************************************
4394 * EnumTimeFormatsEx (kernelbase.@)
4395 */
4396 BOOL WINAPI DECLSPEC_HOTPATCH EnumTimeFormatsEx( TIMEFMT_ENUMPROCEX proc, const WCHAR *locale,
4397 DWORD flags, LPARAM lparam )
4398 {
4399 LCID lcid = LocaleNameToLCID( locale, 0 );
4400 return Internal_EnumTimeFormats( (TIMEFMT_ENUMPROCW)proc, lcid, flags, TRUE, TRUE, lparam );
4401 }
4402
4403
4404 /**************************************************************************
4405 * FindNLSString (kernelbase.@)
4406 */
4407 INT WINAPI DECLSPEC_HOTPATCH FindNLSString( LCID lcid, DWORD flags, const WCHAR *src,
4408 int srclen, const WCHAR *value, int valuelen, int *found )
4409 {
4410 WCHAR locale[LOCALE_NAME_MAX_LENGTH];
4411
4412 LCIDToLocaleName( lcid, locale, ARRAY_SIZE(locale), 0 );
4413 return FindNLSStringEx( locale, flags, src, srclen, value, valuelen, found, NULL, NULL, 0 );
4414 }
4415
4416
4417 /**************************************************************************
4418 * FindNLSStringEx (kernelbase.@)
4419 */
4420 INT WINAPI DECLSPEC_HOTPATCH FindNLSStringEx( const WCHAR *locale, DWORD flags, const WCHAR *src,
4421 int srclen, const WCHAR *value, int valuelen, int *found,
4422 NLSVERSIONINFO *version, void *reserved, LPARAM handle )
4423 {
4424 /* FIXME: this function should normalize strings before calling CompareStringEx() */
4425 DWORD mask = flags;
4426 int offset, inc, count;
4427
4428 TRACE( "%s %lx %s %d %s %d %p %p %p %Id\n", wine_dbgstr_w(locale), flags,
4429 wine_dbgstr_w(src), srclen, wine_dbgstr_w(value), valuelen, found,
4430 version, reserved, handle );
4431
4432 if (version || reserved || handle || !IsValidLocaleName(locale) ||
4433 !src || !srclen || srclen < -1 || !value || !valuelen || valuelen < -1)
4434 {
4435 SetLastError( ERROR_INVALID_PARAMETER );
4436 return -1;
4437 }
4438 if (srclen == -1) srclen = lstrlenW(src);
4439 if (valuelen == -1) valuelen = lstrlenW(value);
4440
4441 srclen -= valuelen;
4442 if (srclen < 0) return -1;
4443
4444 mask = flags & ~(FIND_FROMSTART | FIND_FROMEND | FIND_STARTSWITH | FIND_ENDSWITH);
4445 count = flags & (FIND_FROMSTART | FIND_FROMEND) ? srclen + 1 : 1;
4446 offset = flags & (FIND_FROMSTART | FIND_STARTSWITH) ? 0 : srclen;
4447 inc = flags & (FIND_FROMSTART | FIND_STARTSWITH) ? 1 : -1;
4448 while (count--)
4449 {
4450 if (CompareStringEx( locale, mask, src + offset, valuelen,
4451 value, valuelen, NULL, NULL, 0 ) == CSTR_EQUAL)
4452 {
4453 if (found) *found = valuelen;
4454 return offset;
4455 }
4456 offset += inc;
4457 }
4458 return -1;
4459 }
4460
4461
4462 /******************************************************************************
4463 * FindStringOrdinal (kernelbase.@)
4464 */
4465 INT WINAPI DECLSPEC_HOTPATCH FindStringOrdinal( DWORD flag, const WCHAR *src, INT src_size,
4466 const WCHAR *val, INT val_size, BOOL ignore_case )
4467 {
4468 INT offset, inc, count;
4469
4470 TRACE( "%#lx %s %d %s %d %d\n", flag, wine_dbgstr_w(src), src_size,
4471 wine_dbgstr_w(val), val_size, ignore_case );
4472
4473 if (!src || !val)
4474 {
4475 SetLastError( ERROR_INVALID_PARAMETER );
4476 return -1;
4477 }
4478
4479 if (flag != FIND_FROMSTART && flag != FIND_FROMEND && flag != FIND_STARTSWITH && flag != FIND_ENDSWITH)
4480 {
4481 SetLastError( ERROR_INVALID_FLAGS );
4482 return -1;
4483 }
4484
4485 if (src_size == -1) src_size = lstrlenW( src );
4486 if (val_size == -1) val_size = lstrlenW( val );
4487
4488 SetLastError( ERROR_SUCCESS );
4489 src_size -= val_size;
4490 if (src_size < 0) return -1;
4491
4492 count = flag & (FIND_FROMSTART | FIND_FROMEND) ? src_size + 1 : 1;
4493 offset = flag & (FIND_FROMSTART | FIND_STARTSWITH) ? 0 : src_size;
4494 inc = flag & (FIND_FROMSTART | FIND_STARTSWITH) ? 1 : -1;
4495 while (count--)
4496 {
4497 if (CompareStringOrdinal( src + offset, val_size, val, val_size, ignore_case ) == CSTR_EQUAL)
4498 return offset;
4499 offset += inc;
4500 }
4501 return -1;
4502 }
4503
4504
4505 /******************************************************************************
4506 * FoldStringW (kernelbase.@)
4507 */
4508 INT WINAPI DECLSPEC_HOTPATCH FoldStringW( DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen )
4509 {
4510 NTSTATUS status;
4511 WCHAR *buf = dst;
4512 int len = dstlen;
4513
4514 if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
4515 {
4516 SetLastError( ERROR_INVALID_PARAMETER );
4517 return 0;
4518 }
4519 if (srclen == -1) srclen = lstrlenW(src) + 1;
4520
4521 if (!dstlen && (flags & (MAP_PRECOMPOSED | MAP_FOLDCZONE | MAP_COMPOSITE)))
4522 {
4523 len = srclen * 4;
4524 if (!(buf = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4525 {
4526 SetLastError( ERROR_OUTOFMEMORY );
4527 return 0;
4528 }
4529 }
4530
4531 for (;;)
4532 {
4533 status = fold_string( flags, src, srclen, buf, &len );
4534 if (buf != dst) RtlFreeHeap( GetProcessHeap(), 0, buf );
4535 if (status != STATUS_BUFFER_TOO_SMALL) break;
4536 if (!(buf = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4537 {
4538 SetLastError( ERROR_OUTOFMEMORY );
4539 return 0;
4540 }
4541 }
4542 if (status == STATUS_INVALID_PARAMETER_1)
4543 {
4544 SetLastError( ERROR_INVALID_FLAGS );
4545 return 0;
4546 }
4547 if (!set_ntstatus( status )) return 0;
4548
4549 if (dstlen && dstlen < len) SetLastError( ERROR_INSUFFICIENT_BUFFER );
4550 return len;
4551 }
4552
4553
4554 static const WCHAR *get_message( DWORD flags, const void *src, UINT id, UINT lang,
4555 BOOL ansi, WCHAR **buffer )
4556 {
4557 DWORD len;
4558
4559 if (!(flags & FORMAT_MESSAGE_FROM_STRING))
4560 {
4561 const MESSAGE_RESOURCE_ENTRY *entry;
4562 NTSTATUS status = STATUS_INVALID_PARAMETER;
4563
4564 if (flags & FORMAT_MESSAGE_FROM_HMODULE)
4565 {
4566 HMODULE module = (HMODULE)src;
4567 if (!module) module = GetModuleHandleW( 0 );
4568 status = RtlFindMessage( module, RT_MESSAGETABLE, lang, id, &entry );
4569 }
4570 if (status && (flags & FORMAT_MESSAGE_FROM_SYSTEM))
4571 {
4572 /* Fold win32 hresult to its embedded error code. */
4573 if (HRESULT_SEVERITY(id) == SEVERITY_ERROR && HRESULT_FACILITY(id) == FACILITY_WIN32)
4574 id = HRESULT_CODE( id );
4575 status = RtlFindMessage( kernelbase_handle, RT_MESSAGETABLE, lang, id, &entry );
4576 }
4577 if (!set_ntstatus( status )) return NULL;
4578
4579 src = entry->Text;
4580 ansi = !(entry->Flags & MESSAGE_RESOURCE_UNICODE);
4581 }
4582
4583 if (!ansi) return src;
4584 len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
4585 if (!(*buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
4586 MultiByteToWideChar( CP_ACP, 0, src, -1, *buffer, len );
4587 return *buffer;
4588 }
4589
4590
4591 /***********************************************************************
4592 * FormatMessageA (kernelbase.@)
4593 */
4594 DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageA( DWORD flags, const void *source, DWORD msgid, DWORD langid,
4595 char *buffer, DWORD size, va_list *args )
4596 {
4597 DWORD ret = 0;
4598 ULONG len, retsize = 0;
4599 ULONG width = (flags & FORMAT_MESSAGE_MAX_WIDTH_MASK);
4600 const WCHAR *src;
4601 WCHAR *result, *message = NULL;
4602 NTSTATUS status;
4603
4604 TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
4605
4606 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
4607 {
4608 if (!buffer)
4609 {
4610 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
4611 return 0;
4612 }
4613 *(char **)buffer = NULL;
4614 }
4615 if (size >= 32768)
4616 {
4617 SetLastError( ERROR_INVALID_PARAMETER );
4618 return 0;
4619 }
4620
4621 if (width == 0xff) width = ~0u;
4622
4623 if (!(src = get_message( flags, source, msgid, langid, TRUE, &message ))) return 0;
4624
4625 if (!(result = HeapAlloc( GetProcessHeap(), 0, 65536 )))
4626 status = STATUS_NO_MEMORY;
4627 else
4628 status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
4629 TRUE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
4630 result, 65536, &retsize );
4631
4632 HeapFree( GetProcessHeap(), 0, message );
4633
4634 if (status == STATUS_BUFFER_OVERFLOW)
4635 {
4636 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4637 goto done;
4638 }
4639 if (!set_ntstatus( status )) goto done;
4640
4641 len = WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), NULL, 0, NULL, NULL );
4642 if (len <= 1)
4643 {
4644 SetLastError( ERROR_NO_WORK_DONE );
4645 goto done;
4646 }
4647
4648 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
4649 {
4650 char *buf = LocalAlloc( LMEM_ZEROINIT, max( size, len ));
4651 if (!buf)
4652 {
4653 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
4654 goto done;
4655 }
4656 *(char **)buffer = buf;
4657 WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), buf, max( size, len ), NULL, NULL );
4658 }
4659 else if (len > size)
4660 {
4661 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4662 goto done;
4663 }
4664 else WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), buffer, size, NULL, NULL );
4665
4666 ret = len - 1;
4667
4668 done:
4669 HeapFree( GetProcessHeap(), 0, result );
4670 return ret;
4671 }
4672
4673
4674 /***********************************************************************
4675 * FormatMessageW (kernelbase.@)
4676 */
4677 DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageW( DWORD flags, const void *source, DWORD msgid, DWORD langid,
4678 WCHAR *buffer, DWORD size, va_list *args )
4679 {
4680 ULONG retsize = 0;
4681 ULONG width = (flags & FORMAT_MESSAGE_MAX_WIDTH_MASK);
4682 const WCHAR *src;
4683 WCHAR *message = NULL;
4684 NTSTATUS status;
4685
4686 TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
4687
4688 if (!buffer)
4689 {
4690 SetLastError( ERROR_INVALID_PARAMETER );
4691 return 0;
4692 }
4693
4694 if (width == 0xff) width = ~0u;
4695
4696 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER) *(LPWSTR *)buffer = NULL;
4697
4698 if (!(src = get_message( flags, source, msgid, langid, FALSE, &message ))) return 0;
4699
4700 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
4701 {
4702 WCHAR *result;
4703 ULONG alloc = max( size * sizeof(WCHAR), 65536 );
4704
4705 for (;;)
4706 {
4707 if (!(result = HeapAlloc( GetProcessHeap(), 0, alloc )))
4708 {
4709 status = STATUS_NO_MEMORY;
4710 break;
4711 }
4712 status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
4713 FALSE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
4714 result, alloc, &retsize );
4715 if (!status)
4716 {
4717 if (retsize <= sizeof(WCHAR)) HeapFree( GetProcessHeap(), 0, result );
4718 else *(WCHAR **)buffer = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY,
4719 result, max( retsize, size * sizeof(WCHAR) ));
4720 break;
4721 }
4722 HeapFree( GetProcessHeap(), 0, result );
4723 if (status != STATUS_BUFFER_OVERFLOW) break;
4724 alloc *= 2;
4725 }
4726 }
4727 else status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
4728 FALSE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
4729 buffer, size * sizeof(WCHAR), &retsize );
4730
4731 HeapFree( GetProcessHeap(), 0, message );
4732
4733 if (status == STATUS_BUFFER_OVERFLOW)
4734 {
4735 if (size) buffer[size - 1] = 0;
4736 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4737 return 0;
4738 }
4739 if (!set_ntstatus( status )) return 0;
4740 if (retsize <= sizeof(WCHAR)) SetLastError( ERROR_NO_WORK_DONE );
4741 return retsize / sizeof(WCHAR) - 1;
4742 }
4743
4744
4745 /******************************************************************************
4746 * GetACP (kernelbase.@)
4747 */
4748 UINT WINAPI GetACP(void)
4749 {
4750 return nls_info.AnsiTableInfo.CodePage;
4751 }
4752
4753
4754 /***********************************************************************
4755 * GetCPInfo (kernelbase.@)
4756 */
4757 BOOL WINAPI DECLSPEC_HOTPATCH GetCPInfo( UINT codepage, CPINFO *cpinfo )
4758 {
4759 const CPTABLEINFO *table;
4760
4761 if (!cpinfo)
4762 {
4763 SetLastError( ERROR_INVALID_PARAMETER );
4764 return FALSE;
4765 }
4766 switch (codepage)
4767 {
4768 case CP_UTF7:
4769 case CP_UTF8:
4770 cpinfo->DefaultChar[0] = 0x3f;
4771 cpinfo->DefaultChar[1] = 0;
4772 memset( cpinfo->LeadByte, 0, sizeof(cpinfo->LeadByte) );
4773 cpinfo->MaxCharSize = (codepage == CP_UTF7) ? 5 : 4;
4774 break;
4775 default:
4776 if (!(table = get_codepage_table( codepage ))) return FALSE;
4777 cpinfo->MaxCharSize = table->MaximumCharacterSize;
4778 memcpy( cpinfo->DefaultChar, &table->DefaultChar, sizeof(cpinfo->DefaultChar) );
4779 memcpy( cpinfo->LeadByte, table->LeadByte, sizeof(cpinfo->LeadByte) );
4780 break;
4781 }
4782 return TRUE;
4783 }
4784
4785
4786 /***********************************************************************
4787 * GetCPInfoExW (kernelbase.@)
4788 */
4789 BOOL WINAPI GetCPInfoExW( UINT codepage, DWORD flags, CPINFOEXW *cpinfo )
4790 {
4791 const CPTABLEINFO *table;
4792 int min, max, pos;
4793
4794 if (!cpinfo)
4795 {
4796 SetLastError( ERROR_INVALID_PARAMETER );
4797 return FALSE;
4798 }
4799 switch (codepage)
4800 {
4801 case CP_UTF7:
4802 cpinfo->DefaultChar[0] = 0x3f;
4803 cpinfo->DefaultChar[1] = 0;
4804 cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
4805 cpinfo->MaxCharSize = 5;
4806 cpinfo->CodePage = CP_UTF7;
4807 cpinfo->UnicodeDefaultChar = 0x3f;
4808 break;
4809 case CP_UTF8:
4810 cpinfo->DefaultChar[0] = 0x3f;
4811 cpinfo->DefaultChar[1] = 0;
4812 cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
4813 cpinfo->MaxCharSize = 4;
4814 cpinfo->CodePage = CP_UTF8;
4815 cpinfo->UnicodeDefaultChar = 0x3f;
4816 break;
4817 default:
4818 if (!(table = get_codepage_table( codepage ))) return FALSE;
4819 cpinfo->MaxCharSize = table->MaximumCharacterSize;
4820 memcpy( cpinfo->DefaultChar, &table->DefaultChar, sizeof(cpinfo->DefaultChar) );
4821 memcpy( cpinfo->LeadByte, table->LeadByte, sizeof(cpinfo->LeadByte) );
4822 cpinfo->CodePage = table->CodePage;
4823 cpinfo->UnicodeDefaultChar = table->UniDefaultChar;
4824 break;
4825 }
4826
4827 min = 0;
4828 max = ARRAY_SIZE(codepage_names) - 1;
4829 cpinfo->CodePageName[0] = 0;
4830 while (min <= max)
4831 {
4832 pos = (min + max) / 2;
4833 if (codepage_names[pos].cp < cpinfo->CodePage) min = pos + 1;
4834 else if (codepage_names[pos].cp > cpinfo->CodePage) max = pos - 1;
4835 else
4836 {
4837 wcscpy( cpinfo->CodePageName, codepage_names[pos].name );
4838 break;
4839 }
4840 }
4841 return TRUE;
4842 }
4843
4844
4845 /***********************************************************************
4846 * GetCalendarInfoW (kernelbase.@)
4847 */
4848 INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoW( LCID lcid, CALID calendar, CALTYPE type,
4849 WCHAR *buffer, INT len, DWORD *value )
4850 {
4851 const NLS_LOCALE_DATA *locale;
4852
4853 TRACE( "%04lx %lu 0x%lx %p %d %p\n", lcid, calendar, type, buffer, len, value );
4854
4855 if (!(locale = NlsValidateLocale( &lcid, 0 )))
4856 {
4857 SetLastError( ERROR_INVALID_PARAMETER );
4858 return 0;
4859 }
4860 return get_calendar_info( locale, calendar, type, buffer, len, value );
4861 }
4862
4863
4864 /***********************************************************************
4865 * GetCalendarInfoEx (kernelbase.@)
4866 */
4867 INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoEx( const WCHAR *name, CALID calendar, const WCHAR *reserved,
4868 CALTYPE type, WCHAR *buffer, INT len, DWORD *value )
4869 {
4870 LCID lcid;
4871 const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
4872
4873 TRACE( "%s %lu 0x%lx %p %d %p\n", debugstr_w(name), calendar, type, buffer, len, value );
4874
4875 if (!locale)
4876 {
4877 SetLastError( ERROR_INVALID_PARAMETER );
4878 return 0;
4879 }
4880 return get_calendar_info( locale, calendar, type, buffer, len, value );
4881 }
4882
4883
4884 static CRITICAL_SECTION tzname_section;
4885 static CRITICAL_SECTION_DEBUG tzname_section_debug =
4886 {
4887 0, 0, &tzname_section,
4888 { &tzname_section_debug.ProcessLocksList, &tzname_section_debug.ProcessLocksList },
4889 0, 0, { (DWORD_PTR)(__FILE__ ": tzname_section") }
4890 };
4891 static CRITICAL_SECTION tzname_section = { &tzname_section_debug, -1, 0, 0, 0, 0 };
4892 static struct {
4893 LCID lcid;
4894 WCHAR key_name[128];
4895 WCHAR standard_name[32];
4896 WCHAR daylight_name[32];
4897 } cached_tzname;
4898
4899 /***********************************************************************
4900 * GetDynamicTimeZoneInformation (kernelbase.@)
4901 */
4902 DWORD WINAPI DECLSPEC_HOTPATCH GetDynamicTimeZoneInformation( DYNAMIC_TIME_ZONE_INFORMATION *info )
4903 {
4904 HKEY key;
4905 LARGE_INTEGER now;
4906
4907 if (!set_ntstatus( RtlQueryDynamicTimeZoneInformation( (RTL_DYNAMIC_TIME_ZONE_INFORMATION *)info )))
4908 return TIME_ZONE_ID_INVALID;
4909
4910 RtlEnterCriticalSection( &tzname_section );
4911 if (cached_tzname.lcid == GetThreadLocale() &&
4912 !wcscmp( info->TimeZoneKeyName, cached_tzname.key_name ))
4913 {
4914 wcscpy( info->StandardName, cached_tzname.standard_name );
4915 wcscpy( info->DaylightName, cached_tzname.daylight_name );
4916 RtlLeaveCriticalSection( &tzname_section );
4917 }
4918 else
4919 {
4920 RtlLeaveCriticalSection( &tzname_section );
4921 if (!RegOpenKeyExW( tz_key, info->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key ))
4922 {
4923 RegLoadMUIStringW( key, L"MUI_Std", info->StandardName,
4924 sizeof(info->StandardName), NULL, 0, system_dir );
4925 RegLoadMUIStringW( key, L"MUI_Dlt", info->DaylightName,
4926 sizeof(info->DaylightName), NULL, 0, system_dir );
4927 RegCloseKey( key );
4928 }
4929 else return TIME_ZONE_ID_INVALID;
4930
4931 RtlEnterCriticalSection( &tzname_section );
4932 cached_tzname.lcid = GetThreadLocale();
4933 wcscpy( cached_tzname.key_name, info->TimeZoneKeyName );
4934 wcscpy( cached_tzname.standard_name, info->StandardName );
4935 wcscpy( cached_tzname.daylight_name, info->DaylightName );
4936 RtlLeaveCriticalSection( &tzname_section );
4937 }
4938
4939 NtQuerySystemTime( &now );
4940 return get_timezone_id( (TIME_ZONE_INFORMATION *)info, now, FALSE );
4941 }
4942
4943
4944 /******************************************************************************
4945 * GetDynamicTimeZoneInformationEffectiveYears (kernelbase.@)
4946 */
4947 DWORD WINAPI DECLSPEC_HOTPATCH GetDynamicTimeZoneInformationEffectiveYears( const DYNAMIC_TIME_ZONE_INFORMATION *info,
4948 DWORD *first, DWORD *last )
4949 {
4950 HKEY key, dst_key = 0;
4951 DWORD type, count, ret = ERROR_FILE_NOT_FOUND;
4952
4953 if (RegOpenKeyExW( tz_key, info->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key )) return ret;
4954
4955 if (RegOpenKeyExW( key, L"Dynamic DST", 0, KEY_ALL_ACCESS, &dst_key )) goto done;
4956 count = sizeof(DWORD);
4957 if (RegQueryValueExW( dst_key, L"FirstEntry", NULL, &type, (BYTE *)first, &count )) goto done;
4958 if (type != REG_DWORD) goto done;
4959 count = sizeof(DWORD);
4960 if (RegQueryValueExW( dst_key, L"LastEntry", NULL, &type, (BYTE *)last, &count )) goto done;
4961 if (type != REG_DWORD) goto done;
4962 ret = 0;
4963
4964 done:
4965 RegCloseKey( dst_key );
4966 RegCloseKey( key );
4967 return ret;
4968 }
4969
4970
4971 /******************************************************************************
4972 * GetFileMUIInfo (kernelbase.@)
4973 */
4974 BOOL WINAPI /* DECLSPEC_HOTPATCH */ GetFileMUIInfo( DWORD flags, const WCHAR *path,
4975 FILEMUIINFO *info, DWORD *size )
4976 {
4977 FIXME( "stub: %lu, %s, %p, %p\n", flags, debugstr_w(path), info, size );
4978 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
4979 return FALSE;
4980 }
4981
4982
4983 /******************************************************************************
4984 * GetFileMUIPath (kernelbase.@)
4985 */
4986 BOOL WINAPI /* DECLSPEC_HOTPATCH */ GetFileMUIPath( DWORD flags, const WCHAR *filepath,
4987 WCHAR *language, ULONG *languagelen,
4988 WCHAR *muipath, ULONG *muipathlen,
4989 ULONGLONG *enumerator )
4990 {
4991 FIXME( "stub: 0x%lx, %s, %s, %p, %p, %p, %p\n", flags, debugstr_w(filepath),
4992 debugstr_w(language), languagelen, muipath, muipathlen, enumerator );
4993 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
4994 return FALSE;
4995 }
4996
4997
4998 /******************************************************************************
4999 * GetGeoInfoW (kernelbase.@)
5000 */
5001 INT WINAPI DECLSPEC_HOTPATCH GetGeoInfoW( GEOID id, GEOTYPE type, WCHAR *data, int count, LANGID lang )
5002 {
5003 const struct geo_id *ptr = find_geo_id_entry( id );
5004
5005 TRACE( "%ld %ld %p %d %d\n", id, type, data, count, lang );
5006
5007 if (!ptr)
5008 {
5009 SetLastError( ERROR_INVALID_PARAMETER );
5010 return 0;
5011 }
5012 return get_geo_info( ptr, type, data, count, lang );
5013 }
5014
5015
5016 /******************************************************************************
5017 * GetLocaleInfoA (kernelbase.@)
5018 */
5019 INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoA( LCID lcid, LCTYPE lctype, char *buffer, INT len )
5020 {
5021 WCHAR *bufferW;
5022 INT lenW, ret;
5023
5024 TRACE( "lcid=0x%lx lctype=0x%lx %p %d\n", lcid, lctype, buffer, len );
5025
5026 if (len < 0 || (len && !buffer))
5027 {
5028 SetLastError( ERROR_INVALID_PARAMETER );
5029 return 0;
5030 }
5031 if (LOWORD(lctype) == LOCALE_SSHORTTIME || (lctype & LOCALE_RETURN_GENITIVE_NAMES))
5032 {
5033 SetLastError( ERROR_INVALID_FLAGS );
5034 return 0;
5035 }
5036
5037 if (LOWORD(lctype) == LOCALE_FONTSIGNATURE || (lctype & LOCALE_RETURN_NUMBER))
5038 return GetLocaleInfoW( lcid, lctype, (WCHAR *)buffer, len / sizeof(WCHAR) ) * sizeof(WCHAR);
5039
5040 if (!(lenW = GetLocaleInfoW( lcid, lctype, NULL, 0 ))) return 0;
5041
5042 if (!(bufferW = RtlAllocateHeap( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
5043 {
5044 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
5045 return 0;
5046 }
5047 ret = GetLocaleInfoW( lcid, lctype, bufferW, lenW );
5048 if (ret) ret = WideCharToMultiByte( get_lcid_codepage( lcid, lctype ), 0,
5049 bufferW, ret, buffer, len, NULL, NULL );
5050 RtlFreeHeap( GetProcessHeap(), 0, bufferW );
5051 return ret;
5052 }
5053
5054
5055 /******************************************************************************
5056 * GetLocaleInfoW (kernelbase.@)
5057 */
5058 INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoW( LCID lcid, LCTYPE lctype, WCHAR *buffer, INT len )
5059 {
5060 const NLS_LOCALE_DATA *locale;
5061
5062 if (len < 0 || (len && !buffer))
5063 {
5064 SetLastError( ERROR_INVALID_PARAMETER );
5065 return 0;
5066 }
5067
5068 TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d)\n", lcid, lctype, buffer, len );
5069
5070 if (!(locale = NlsValidateLocale( &lcid, 0 )))
5071 {
5072 SetLastError( ERROR_INVALID_PARAMETER );
5073 return 0;
5074 }
5075 return get_locale_info( locale, lcid, lctype, buffer, len );
5076 }
5077
5078
5079 /******************************************************************************
5080 * GetLocaleInfoEx (kernelbase.@)
5081 */
5082 INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoEx( const WCHAR *name, LCTYPE info, WCHAR *buffer, INT len )
5083 {
5084 LCID lcid;
5085 const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
5086
5087 TRACE( "%s 0x%lx %p %d\n", debugstr_w(name), info, buffer, len );
5088
5089 if (!locale)
5090 {
5091 SetLastError( ERROR_INVALID_PARAMETER );
5092 return 0;
5093 }
5094 return get_locale_info( locale, lcid, info, buffer, len );
5095 }
5096
5097
5098 /******************************************************************************
5099 * GetNLSVersion (kernelbase.@)
5100 */
5101 BOOL WINAPI DECLSPEC_HOTPATCH GetNLSVersion( NLS_FUNCTION func, LCID lcid, NLSVERSIONINFO *info )
5102 {
5103 WCHAR locale[LOCALE_NAME_MAX_LENGTH];
5104
5105 if (info->dwNLSVersionInfoSize < offsetof( NLSVERSIONINFO, dwEffectiveId ))
5106 {
5107 SetLastError( ERROR_INSUFFICIENT_BUFFER );
5108 return FALSE;
5109 }
5110 if (!LCIDToLocaleName( lcid, locale, LOCALE_NAME_MAX_LENGTH, LOCALE_ALLOW_NEUTRAL_NAMES ))
5111 {
5112 SetLastError( ERROR_INVALID_PARAMETER );
5113 return FALSE;
5114 }
5115 return GetNLSVersionEx( func, locale, (NLSVERSIONINFOEX *)info );
5116 }
5117
5118
5119 /******************************************************************************
5120 * GetNLSVersionEx (kernelbase.@)
5121 */
5122 BOOL WINAPI DECLSPEC_HOTPATCH GetNLSVersionEx( NLS_FUNCTION func, const WCHAR *locale,
5123 NLSVERSIONINFOEX *info )
5124 {
5125 LCID lcid = 0;
5126
5127 if (func != COMPARE_STRING)
5128 {
5129 SetLastError( ERROR_INVALID_FLAGS );
5130 return FALSE;
5131 }
5132 if (info->dwNLSVersionInfoSize < sizeof(*info) &&
5133 (info->dwNLSVersionInfoSize != offsetof( NLSVERSIONINFO, dwEffectiveId )))
5134 {
5135 SetLastError( ERROR_INSUFFICIENT_BUFFER );
5136 return FALSE;
5137 }
5138
5139 if (!(lcid = LocaleNameToLCID( locale, 0 ))) return FALSE;
5140
5141 info->dwNLSVersion = info->dwDefinedVersion = sort.version;
5142 if (info->dwNLSVersionInfoSize >= sizeof(*info))
5143 {
5144 const struct sortguid *sortid = get_language_sort( locale );
5145 info->dwEffectiveId = lcid;
5146 info->guidCustomVersion = sortid ? sortid->id : default_sort_guid;
5147 }
5148 return TRUE;
5149 }
5150
5151
5152 /******************************************************************************
5153 * GetOEMCP (kernelbase.@)
5154 */
5155 UINT WINAPI GetOEMCP(void)
5156 {
5157 return nls_info.OemTableInfo.CodePage;
5158 }
5159
5160
5161 /***********************************************************************
5162 * GetProcessPreferredUILanguages (kernelbase.@)
5163 */
5164 BOOL WINAPI DECLSPEC_HOTPATCH GetProcessPreferredUILanguages( DWORD flags, ULONG *count,
5165 WCHAR *buffer, ULONG *size )
5166 {
5167 return set_ntstatus( RtlGetProcessPreferredUILanguages( flags, count, buffer, size ));
5168 }
5169
5170
5171 /***********************************************************************
5172 * GetStringTypeA (kernelbase.@)
5173 */
5174 BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeA( LCID locale, DWORD type, const char *src, int count,
5175 WORD *chartype )
5176 {
5177 UINT cp;
5178 INT countW;
5179 LPWSTR srcW;
5180 BOOL ret = FALSE;
5181
5182 if (count == -1) count = strlen(src) + 1;
5183
5184 cp = get_lcid_codepage( locale, 0 );
5185 countW = MultiByteToWideChar(cp, 0, src, count, NULL, 0);
5186 if((srcW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
5187 {
5188 MultiByteToWideChar(cp, 0, src, count, srcW, countW);
5189 /*
5190 * NOTE: the target buffer has 1 word for each CHARACTER in the source
5191 * string, with multibyte characters there maybe be more bytes in count
5192 * than character space in the buffer!
5193 */
5194 ret = GetStringTypeW(type, srcW, countW, chartype);
5195 HeapFree(GetProcessHeap(), 0, srcW);
5196 }
5197 return ret;
5198 }
5199
5200
5201 /***********************************************************************
5202 * GetStringTypeW (kernelbase.@)
5203 */
5204 BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeW( DWORD type, const WCHAR *src, INT count, WORD *chartype )
5205 {
5206 if (!src)
5207 {
5208 SetLastError( ERROR_INVALID_PARAMETER );
5209 return FALSE;
5210 }
5211 if (type != CT_CTYPE1 && type != CT_CTYPE2 && type != CT_CTYPE3)
5212 {
5213 SetLastError( ERROR_INVALID_PARAMETER );
5214 return FALSE;
5215 }
5216
5217 if (count == -1) count = lstrlenW(src) + 1;
5218
5219 while (count--) *chartype++ = get_char_type( type, *src++ );
5220
5221 return TRUE;
5222 }
5223
5224
5225 /***********************************************************************
5226 * GetStringTypeExW (kernelbase.@)
5227 */
5228 BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeExW( LCID locale, DWORD type, const WCHAR *src, int count,
5229 WORD *chartype )
5230 {
5231 /* locale is ignored for Unicode */
5232 return GetStringTypeW( type, src, count, chartype );
5233 }
5234
5235
5236 /***********************************************************************
5237 * GetSystemDefaultLCID (kernelbase.@)
5238 */
5239 LCID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLCID(void)
5240 {
5241 return system_lcid;
5242 }
5243
5244
5245 /***********************************************************************
5246 * GetSystemDefaultLangID (kernelbase.@)
5247 */
5248 LANGID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLangID(void)
5249 {
5250 return LANGIDFROMLCID( GetSystemDefaultLCID() );
5251 }
5252
5253
5254 /***********************************************************************
5255 * GetSystemDefaultLocaleName (kernelbase.@)
5256 */
5257 INT WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLocaleName( LPWSTR name, INT count )
5258 {
5259 return get_locale_info( system_locale, system_lcid, LOCALE_SNAME, name, count );
5260 }
5261
5262
5263 /***********************************************************************
5264 * GetSystemDefaultUILanguage (kernelbase.@)
5265 */
5266 LANGID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultUILanguage(void)
5267 {
5268 LANGID lang;
5269 NtQueryInstallUILanguage( &lang );
5270 return lang;
5271 }
5272
5273
5274 /***********************************************************************
5275 * GetSystemPreferredUILanguages (kernelbase.@)
5276 */
5277 BOOL WINAPI DECLSPEC_HOTPATCH GetSystemPreferredUILanguages( DWORD flags, ULONG *count,
5278 WCHAR *buffer, ULONG *size )
5279 {
5280 return set_ntstatus( RtlGetSystemPreferredUILanguages( flags, 0, count, buffer, size ));
5281 }
5282
5283
5284 /***********************************************************************
5285 * GetThreadPreferredUILanguages (kernelbase.@)
5286 */
5287 BOOL WINAPI DECLSPEC_HOTPATCH GetThreadPreferredUILanguages( DWORD flags, ULONG *count,
5288 WCHAR *buffer, ULONG *size )
5289 {
5290 return set_ntstatus( RtlGetThreadPreferredUILanguages( flags, count, buffer, size ));
5291 }
5292
5293
5294 /***********************************************************************
5295 * GetTimeZoneInformation (kernelbase.@)
5296 */
5297 DWORD WINAPI DECLSPEC_HOTPATCH GetTimeZoneInformation( TIME_ZONE_INFORMATION *info )
5298 {
5299 DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
5300 DWORD ret = GetDynamicTimeZoneInformation( &tzinfo );
5301
5302 memcpy( info, &tzinfo, sizeof(*info) );
5303 return ret;
5304 }
5305
5306
5307 /***********************************************************************
5308 * GetTimeZoneInformationForYear (kernelbase.@)
5309 */
5310 BOOL WINAPI DECLSPEC_HOTPATCH GetTimeZoneInformationForYear( USHORT year,
5311 DYNAMIC_TIME_ZONE_INFORMATION *dynamic,
5312 TIME_ZONE_INFORMATION *info )
5313 {
5314 DYNAMIC_TIME_ZONE_INFORMATION local_info;
5315 HKEY key = 0, dst_key;
5316 DWORD count;
5317 LRESULT ret;
5318 struct
5319 {
5320 LONG bias;
5321 LONG std_bias;
5322 LONG dlt_bias;
5323 SYSTEMTIME std_date;
5324 SYSTEMTIME dlt_date;
5325 } data;
5326
5327 TRACE( "(%u,%p)\n", year, info );
5328
5329 if (!dynamic)
5330 {
5331 if (GetDynamicTimeZoneInformation( &local_info ) == TIME_ZONE_ID_INVALID) return FALSE;
5332 dynamic = &local_info;
5333 }
5334
5335 if ((ret = RegOpenKeyExW( tz_key, dynamic->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key ))) goto done;
5336 if (RegLoadMUIStringW( key, L"MUI_Std", info->StandardName,
5337 sizeof(info->StandardName), NULL, 0, system_dir ))
5338 {
5339 count = sizeof(info->StandardName);
5340 if ((ret = RegQueryValueExW( key, L"Std", NULL, NULL, (BYTE *)info->StandardName, &count )))
5341 goto done;
5342 }
5343 if (RegLoadMUIStringW( key, L"MUI_Dlt", info->DaylightName,
5344 sizeof(info->DaylightName), NULL, 0, system_dir ))
5345 {
5346 count = sizeof(info->DaylightName);
5347 if ((ret = RegQueryValueExW( key, L"Dlt", NULL, NULL, (BYTE *)info->DaylightName, &count )))
5348 goto done;
5349 }
5350
5351 ret = ERROR_FILE_NOT_FOUND;
5352 if (!dynamic->DynamicDaylightTimeDisabled &&
5353 !RegOpenKeyExW( key, L"Dynamic DST", 0, KEY_ALL_ACCESS, &dst_key ))
5354 {
5355 WCHAR yearW[16];
5356 swprintf( yearW, ARRAY_SIZE(yearW), L"%u", year );
5357 count = sizeof(data);
5358 ret = RegQueryValueExW( dst_key, yearW, NULL, NULL, (BYTE *)&data, &count );
5359 RegCloseKey( dst_key );
5360 }
5361 if (ret)
5362 {
5363 count = sizeof(data);
5364 ret = RegQueryValueExW( key, L"TZI", NULL, NULL, (BYTE *)&data, &count );
5365 }
5366
5367 if (!ret)
5368 {
5369 info->Bias = data.bias;
5370 info->StandardBias = data.std_bias;
5371 info->DaylightBias = data.dlt_bias;
5372 info->StandardDate = data.std_date;
5373 info->DaylightDate = data.dlt_date;
5374 }
5375
5376 done:
5377 RegCloseKey( key );
5378 if (ret) SetLastError( ret );
5379 return !ret;
5380 }
5381
5382
5383 /***********************************************************************
5384 * GetUserDefaultLCID (kernelbase.@)
5385 */
5386 LCID WINAPI DECLSPEC_HOTPATCH GetUserDefaultLCID(void)
5387 {
5388 return user_lcid;
5389 }
5390
5391
5392 /***********************************************************************
5393 * GetUserDefaultLangID (kernelbase.@)
5394 */
5395 LANGID WINAPI DECLSPEC_HOTPATCH GetUserDefaultLangID(void)
5396 {
5397 return LANGIDFROMLCID( GetUserDefaultLCID() );
5398 }
5399
5400
5401 /***********************************************************************
5402 * GetUserDefaultLocaleName (kernelbase.@)
5403 */
5404 INT WINAPI DECLSPEC_HOTPATCH GetUserDefaultLocaleName( LPWSTR name, INT len )
5405 {
5406 return get_locale_info( user_locale, user_lcid, LOCALE_SNAME, name, len );
5407 }
5408
5409
5410 /***********************************************************************
5411 * GetUserDefaultUILanguage (kernelbase.@)
5412 */
5413 LANGID WINAPI DECLSPEC_HOTPATCH GetUserDefaultUILanguage(void)
5414 {
5415 return LANGIDFROMLCID( GetUserDefaultLCID() );
5416 }
5417
5418
5419 /******************************************************************************
5420 * GetUserGeoID (kernelbase.@)
5421 */
5422 GEOID WINAPI DECLSPEC_HOTPATCH GetUserGeoID( GEOCLASS geoclass )
5423 {
5424 GEOID ret = 39070;
5425 const WCHAR *name;
5426 WCHAR bufferW[40];
5427 HKEY hkey;
5428
5429 switch (geoclass)
5430 {
5431 case GEOCLASS_NATION:
5432 name = L"Nation";
5433 break;
5434 case GEOCLASS_REGION:
5435 name = L"Region";
5436 break;
5437 default:
5438 WARN("Unknown geoclass %ld\n", geoclass);
5439 return GEOID_NOT_AVAILABLE;
5440 }
5441 if (!RegOpenKeyExW( intl_key, L"Geo", 0, KEY_ALL_ACCESS, &hkey ))
5442 {
5443 DWORD count = sizeof(bufferW);
5444 if (!RegQueryValueExW( hkey, name, NULL, NULL, (BYTE *)bufferW, &count ))
5445 ret = wcstol( bufferW, NULL, 10 );
5446 RegCloseKey( hkey );
5447 }
5448 return ret;
5449 }
5450
5451
5452 /******************************************************************************
5453 * GetUserPreferredUILanguages (kernelbase.@)
5454 */
5455 BOOL WINAPI DECLSPEC_HOTPATCH GetUserPreferredUILanguages( DWORD flags, ULONG *count,
5456 WCHAR *buffer, ULONG *size )
5457 {
5458 return set_ntstatus( RtlGetUserPreferredUILanguages( flags, 0, count, buffer, size ));
5459 }
5460
5461
5462 /******************************************************************************
5463 * IdnToAscii (kernelbase.@)
5464 */
5465 INT WINAPI DECLSPEC_HOTPATCH IdnToAscii( DWORD flags, const WCHAR *src, INT srclen,
5466 WCHAR *dst, INT dstlen )
5467 {
5468 NTSTATUS status = RtlIdnToAscii( flags, src, srclen, dst, &dstlen );
5469 if (!set_ntstatus( status )) return 0;
5470 return dstlen;
5471 }
5472
5473
5474 /******************************************************************************
5475 * IdnToNameprepUnicode (kernelbase.@)
5476 */
5477 INT WINAPI DECLSPEC_HOTPATCH IdnToNameprepUnicode( DWORD flags, const WCHAR *src, INT srclen,
5478 WCHAR *dst, INT dstlen )
5479 {
5480 NTSTATUS status = RtlIdnToNameprepUnicode( flags, src, srclen, dst, &dstlen );
5481 if (!set_ntstatus( status )) return 0;
5482 return dstlen;
5483 }
5484
5485
5486 /******************************************************************************
5487 * IdnToUnicode (kernelbase.@)
5488 */
5489 INT WINAPI DECLSPEC_HOTPATCH IdnToUnicode( DWORD flags, const WCHAR *src, INT srclen,
5490 WCHAR *dst, INT dstlen )
5491 {
5492 NTSTATUS status = RtlIdnToUnicode( flags, src, srclen, dst, &dstlen );
5493 if (!set_ntstatus( status )) return 0;
5494 return dstlen;
5495 }
5496
5497
5498 /******************************************************************************
5499 * IsCharAlphaA (kernelbase.@)
5500 */
5501 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaA( CHAR c )
5502 {
5503 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5504 return !!(get_char_type( CT_CTYPE1, wc ) & C1_ALPHA);
5505 }
5506
5507
5508 /******************************************************************************
5509 * IsCharAlphaW (kernelbase.@)
5510 */
5511 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaW( WCHAR wc )
5512 {
5513 return !!(get_char_type( CT_CTYPE1, wc ) & C1_ALPHA);
5514 }
5515
5516
5517 /******************************************************************************
5518 * IsCharAlphaNumericA (kernelbase.@)
5519 */
5520 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaNumericA( CHAR c )
5521 {
5522 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5523 return !!(get_char_type( CT_CTYPE1, wc ) & (C1_ALPHA | C1_DIGIT));
5524 }
5525
5526
5527 /******************************************************************************
5528 * IsCharAlphaNumericW (kernelbase.@)
5529 */
5530 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaNumericW( WCHAR wc )
5531 {
5532 return !!(get_char_type( CT_CTYPE1, wc ) & (C1_ALPHA | C1_DIGIT));
5533 }
5534
5535
5536 /******************************************************************************
5537 * IsCharBlankW (kernelbase.@)
5538 */
5539 BOOL WINAPI DECLSPEC_HOTPATCH IsCharBlankW( WCHAR wc )
5540 {
5541 return !!(get_char_type( CT_CTYPE1, wc ) & C1_BLANK);
5542 }
5543
5544
5545 /******************************************************************************
5546 * IsCharCntrlW (kernelbase.@)
5547 */
5548 BOOL WINAPI DECLSPEC_HOTPATCH IsCharCntrlW( WCHAR wc )
5549 {
5550 return !!(get_char_type( CT_CTYPE1, wc ) & C1_CNTRL);
5551 }
5552
5553
5554 /******************************************************************************
5555 * IsCharDigitW (kernelbase.@)
5556 */
5557 BOOL WINAPI DECLSPEC_HOTPATCH IsCharDigitW( WCHAR wc )
5558 {
5559 return !!(get_char_type( CT_CTYPE1, wc ) & C1_DIGIT);
5560 }
5561
5562
5563 /******************************************************************************
5564 * IsCharLowerA (kernelbase.@)
5565 */
5566 BOOL WINAPI DECLSPEC_HOTPATCH IsCharLowerA( CHAR c )
5567 {
5568 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5569 return !!(get_char_type( CT_CTYPE1, wc ) & C1_LOWER);
5570 }
5571
5572
5573 /******************************************************************************
5574 * IsCharLowerW (kernelbase.@)
5575 */
5576 BOOL WINAPI DECLSPEC_HOTPATCH IsCharLowerW( WCHAR wc )
5577 {
5578 return !!(get_char_type( CT_CTYPE1, wc ) & C1_LOWER);
5579 }
5580
5581
5582 /******************************************************************************
5583 * IsCharPunctW (kernelbase.@)
5584 */
5585 BOOL WINAPI DECLSPEC_HOTPATCH IsCharPunctW( WCHAR wc )
5586 {
5587 return !!(get_char_type( CT_CTYPE1, wc ) & C1_PUNCT);
5588 }
5589
5590
5591 /******************************************************************************
5592 * IsCharSpaceA (kernelbase.@)
5593 */
5594 BOOL WINAPI DECLSPEC_HOTPATCH IsCharSpaceA( CHAR c )
5595 {
5596 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5597 return !!(get_char_type( CT_CTYPE1, wc ) & C1_SPACE);
5598 }
5599
5600
5601 /******************************************************************************
5602 * IsCharSpaceW (kernelbase.@)
5603 */
5604 BOOL WINAPI DECLSPEC_HOTPATCH IsCharSpaceW( WCHAR wc )
5605 {
5606 return !!(get_char_type( CT_CTYPE1, wc ) & C1_SPACE);
5607 }
5608
5609
5610 /******************************************************************************
5611 * IsCharUpperA (kernelbase.@)
5612 */
5613 BOOL WINAPI DECLSPEC_HOTPATCH IsCharUpperA( CHAR c )
5614 {
5615 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5616 return !!(get_char_type( CT_CTYPE1, wc ) & C1_UPPER);
5617 }
5618
5619
5620 /******************************************************************************
5621 * IsCharUpperW (kernelbase.@)
5622 */
5623 BOOL WINAPI DECLSPEC_HOTPATCH IsCharUpperW( WCHAR wc )
5624 {
5625 return !!(get_char_type( CT_CTYPE1, wc ) & C1_UPPER);
5626 }
5627
5628
5629 /******************************************************************************
5630 * IsCharXDigitW (kernelbase.@)
5631 */
5632 BOOL WINAPI DECLSPEC_HOTPATCH IsCharXDigitW( WCHAR wc )
5633 {
5634 return !!(get_char_type( CT_CTYPE1, wc ) & C1_XDIGIT);
5635 }
5636
5637
5638 /******************************************************************************
5639 * IsDBCSLeadByte (kernelbase.@)
5640 */
5641 BOOL WINAPI DECLSPEC_HOTPATCH IsDBCSLeadByte( BYTE testchar )
5642 {
5643 return nls_info.AnsiTableInfo.DBCSCodePage && nls_info.AnsiTableInfo.DBCSOffsets[testchar];
5644 }
5645
5646
5647 /******************************************************************************
5648 * IsDBCSLeadByteEx (kernelbase.@)
5649 */
5650 BOOL WINAPI DECLSPEC_HOTPATCH IsDBCSLeadByteEx( UINT codepage, BYTE testchar )
5651 {
5652 const CPTABLEINFO *table = get_codepage_table( codepage );
5653 return table && table->DBCSCodePage && table->DBCSOffsets[testchar];
5654 }
5655
5656
5657 /******************************************************************************
5658 * IsNormalizedString (kernelbase.@)
5659 */
5660 BOOL WINAPI DECLSPEC_HOTPATCH IsNormalizedString( NORM_FORM form, const WCHAR *str, INT len )
5661 {
5662 BOOLEAN res;
5663 if (!set_ntstatus( RtlIsNormalizedString( form, str, len, &res ))) res = FALSE;
5664 return res;
5665 }
5666
5667
5668 /******************************************************************************
5669 * IsValidCodePage (kernelbase.@)
5670 */
5671 BOOL WINAPI DECLSPEC_HOTPATCH IsValidCodePage( UINT codepage )
5672 {
5673 switch (codepage)
5674 {
5675 case CP_ACP:
5676 case CP_OEMCP:
5677 case CP_MACCP:
5678 case CP_THREAD_ACP:
5679 return FALSE;
5680 case CP_UTF7:
5681 case CP_UTF8:
5682 return TRUE;
5683 default:
5684 return get_codepage_table( codepage ) != NULL;
5685 }
5686 }
5687
5688
5689 /******************************************************************************
5690 * IsValidLanguageGroup (kernelbase.@)
5691 */
5692 BOOL WINAPI DECLSPEC_HOTPATCH IsValidLanguageGroup( LGRPID id, DWORD flags )
5693 {
5694 WCHAR name[10], value[10];
5695 DWORD type, value_len = sizeof(value);
5696 BOOL ret = FALSE;
5697 HKEY key;
5698
5699 if (RegOpenKeyExW( nls_key, L"Language Groups", 0, KEY_READ, &key )) return FALSE;
5700
5701 swprintf( name, ARRAY_SIZE(name), L"%x", id );
5702 if (!RegQueryValueExW( key, name, NULL, &type, (BYTE *)value, &value_len ) && type == REG_SZ)
5703 ret = (flags & LGRPID_SUPPORTED) || wcstoul( value, NULL, 10 );
5704
5705 RegCloseKey( key );
5706 return ret;
5707 }
5708
5709
5710 /******************************************************************************
5711 * IsValidLocale (kernelbase.@)
5712 */
5713 BOOL WINAPI DECLSPEC_HOTPATCH IsValidLocale( LCID lcid, DWORD flags )
5714 {
5715 switch (lcid)
5716 {
5717 case LOCALE_NEUTRAL:
5718 case LOCALE_USER_DEFAULT:
5719 case LOCALE_SYSTEM_DEFAULT:
5720 return FALSE;
5721 default:
5722 return !!NlsValidateLocale( &lcid, LOCALE_ALLOW_NEUTRAL_NAMES );
5723 }
5724 }
5725
5726
5727 /******************************************************************************
5728 * IsValidLocaleName (kernelbase.@)
5729 */
5730 BOOL WINAPI DECLSPEC_HOTPATCH IsValidLocaleName( const WCHAR *locale )
5731 {
5732 if (locale == LOCALE_NAME_USER_DEFAULT) return FALSE;
5733 return !!find_lcname_entry( locale );
5734 }
5735
5736
5737 /******************************************************************************
5738 * IsValidNLSVersion (kernelbase.@)
5739 */
5740 DWORD WINAPI DECLSPEC_HOTPATCH IsValidNLSVersion( NLS_FUNCTION func, const WCHAR *locale,
5741 NLSVERSIONINFOEX *info )
5742 {
5743 static const GUID GUID_NULL;
5744 NLSVERSIONINFOEX infoex;
5745 DWORD ret;
5746
5747 if (func != COMPARE_STRING)
5748 {
5749 SetLastError( ERROR_INVALID_PARAMETER );
5750 return FALSE;
5751 }
5752 if (info->dwNLSVersionInfoSize < sizeof(*info) &&
5753 (info->dwNLSVersionInfoSize != offsetof( NLSVERSIONINFO, dwEffectiveId )))
5754 {
5755 SetLastError( ERROR_INVALID_PARAMETER );
5756 return FALSE;
5757 }
5758 infoex.dwNLSVersionInfoSize = sizeof(infoex);
5759 if (!GetNLSVersionEx( func, locale, &infoex )) return FALSE;
5760
5761 ret = (infoex.dwNLSVersion & ~0xff) == (info->dwNLSVersion & ~0xff);
5762 if (ret && !IsEqualGUID( &info->guidCustomVersion, &GUID_NULL ))
5763 ret = find_sortguid( &info->guidCustomVersion ) != NULL;
5764
5765 if (!ret) SetLastError( ERROR_SUCCESS );
5766 return ret;
5767 }
5768
5769
5770 /***********************************************************************
5771 * LCIDToLocaleName (kernelbase.@)
5772 */
5773 INT WINAPI DECLSPEC_HOTPATCH LCIDToLocaleName( LCID lcid, WCHAR *name, INT count, DWORD flags )
5774 {
5775 const NLS_LOCALE_DATA *locale = NlsValidateLocale( &lcid, flags );
5776
5777 if (!locale)
5778 {
5779 SetLastError( ERROR_INVALID_PARAMETER );
5780 return 0;
5781 }
5782 return get_locale_info( locale, lcid, LOCALE_SNAME, name, count );
5783 }
5784
5785
5786 /***********************************************************************
5787 * LCMapStringEx (kernelbase.@)
5788 */
5789 INT WINAPI DECLSPEC_HOTPATCH LCMapStringEx( const WCHAR *locale, DWORD flags, const WCHAR *src, int srclen,
5790 WCHAR *dst, int dstlen, NLSVERSIONINFO *version,
5791 void *reserved, LPARAM handle )
5792 {
5793 const struct sortguid *sortid = NULL;
5794 LPWSTR dst_ptr;
5795 INT len;
5796
5797 if (version) FIXME( "unsupported version structure %p\n", version );
5798 if (reserved) FIXME( "unsupported reserved pointer %p\n", reserved );
5799 if (handle)
5800 {
5801 static int once;
5802 if (!once++) FIXME( "unsupported lparam %Ix\n", handle );
5803 }
5804
5805 if (!src || !srclen || dstlen < 0)
5806 {
5807 SetLastError( ERROR_INVALID_PARAMETER );
5808 return 0;
5809 }
5810
5811 /* mutually exclusive flags */
5812 if ((flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE)) == (LCMAP_LOWERCASE | LCMAP_UPPERCASE) ||
5813 (flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA)) == (LCMAP_HIRAGANA | LCMAP_KATAKANA) ||
5814 (flags & (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) == (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH) ||
5815 (flags & (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE)) == (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE) ||
5816 !flags)
5817 {
5818 SetLastError( ERROR_INVALID_FLAGS );
5819 return 0;
5820 }
5821
5822 if (!dstlen) dst = NULL;
5823
5824 if (flags & LCMAP_LINGUISTIC_CASING && !(sortid = get_language_sort( locale )))
5825 {
5826 FIXME( "unknown locale %s\n", debugstr_w(locale) );
5827 SetLastError( ERROR_INVALID_PARAMETER );
5828 return 0;
5829 }
5830
5831 if (flags & LCMAP_SORTKEY)
5832 {
5833 INT ret;
5834
5835 if (src == dst)
5836 {
5837 SetLastError( ERROR_INVALID_FLAGS );
5838 return 0;
5839 }
5840 if (srclen < 0) srclen = lstrlenW(src);
5841
5842 TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
5843 debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
5844
5845 if ((ret = get_sortkey( flags, src, srclen, (char *)dst, dstlen ))) ret++;
5846 else SetLastError( ERROR_INSUFFICIENT_BUFFER );
5847 return ret;
5848 }
5849
5850 /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
5851 if (flags & SORT_STRINGSORT)
5852 {
5853 SetLastError( ERROR_INVALID_FLAGS );
5854 return 0;
5855 }
5856 if (((flags & (NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS)) &&
5857 (flags & ~(NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS))) ||
5858 ((flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA | LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) &&
5859 (flags & (LCMAP_SIMPLIFIED_CHINESE | LCMAP_TRADITIONAL_CHINESE))))
5860 {
5861 SetLastError( ERROR_INVALID_FLAGS );
5862 return 0;
5863 }
5864
5865 if (srclen < 0) srclen = lstrlenW(src) + 1;
5866
5867 TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
5868 debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
5869
5870 if (!dst) /* return required string length */
5871 {
5872 if (flags & NORM_IGNORESYMBOLS)
5873 {
5874 for (len = 0; srclen; src++, srclen--)
5875 if (!(get_char_type( CT_CTYPE1, *src ) & (C1_PUNCT | C1_SPACE))) len++;
5876 }
5877 else if (flags & LCMAP_FULLWIDTH)
5878 {
5879 for (len = 0; srclen; src++, srclen--, len++)
5880 {
5881 if (compose_katakana( src, srclen, NULL ) == 2)
5882 {
5883 src++;
5884 srclen--;
5885 }
5886 }
5887 }
5888 else if (flags & LCMAP_HALFWIDTH)
5889 {
5890 for (len = 0; srclen; src++, srclen--, len++)
5891 {
5892 WCHAR wch = *src;
5893 /* map Hiragana to Katakana before decomposition if needed */
5894 if ((flags & LCMAP_KATAKANA) &&
5895 ((wch >= 0x3041 && wch <= 0x3096) || wch == 0x309D || wch == 0x309E))
5896 wch += 0x60;
5897
5898 if (decompose_katakana( wch, NULL, 0 ) == 2) len++;
5899 }
5900 }
5901 else len = srclen;
5902 return len;
5903 }
5904
5905 if (src == dst && (flags & ~(LCMAP_LOWERCASE | LCMAP_UPPERCASE)))
5906 {
5907 SetLastError( ERROR_INVALID_FLAGS );
5908 return 0;
5909 }
5910
5911 if (flags & (NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS))
5912 {
5913 for (len = dstlen, dst_ptr = dst; srclen && len; src++, srclen--)
5914 {
5915 if ((flags & NORM_IGNORESYMBOLS) && (get_char_type( CT_CTYPE1, *src ) & (C1_PUNCT | C1_SPACE)))
5916 continue;
5917 *dst_ptr++ = *src;
5918 len--;
5919 }
5920 goto done;
5921 }
5922
5923 if (flags & (LCMAP_FULLWIDTH | LCMAP_HALFWIDTH | LCMAP_HIRAGANA | LCMAP_KATAKANA))
5924 {
5925 for (len = dstlen, dst_ptr = dst; len && srclen; src++, srclen--, len--, dst_ptr++)
5926 {
5927 WCHAR wch;
5928 if (flags & LCMAP_FULLWIDTH)
5929 {
5930 /* map half-width character to full-width one,
5931 e.g. U+FF71 -> U+30A2, U+FF8C U+FF9F -> U+30D7. */
5932 if (map_to_fullwidth( src, srclen, &wch ) == 2)
5933 {
5934 src++;
5935 srclen--;
5936 }
5937 }
5938 else wch = *src;
5939
5940 if (flags & LCMAP_KATAKANA)
5941 {
5942 /* map hiragana to katakana, e.g. U+3041 -> U+30A1.
5943 we can't use C3_HIRAGANA as some characters can't map to katakana */
5944 if ((wch >= 0x3041 && wch <= 0x3096) || wch == 0x309D || wch == 0x309E) wch += 0x60;
5945 }
5946 else if (flags & LCMAP_HIRAGANA)
5947 {
5948 /* map katakana to hiragana, e.g. U+30A1 -> U+3041.
5949 we can't use C3_KATAKANA as some characters can't map to hiragana */
5950 if ((wch >= 0x30A1 && wch <= 0x30F6) || wch == 0x30FD || wch == 0x30FE) wch -= 0x60;
5951 }
5952
5953 if (flags & LCMAP_HALFWIDTH)
5954 {
5955 /* map full-width character to half-width one,
5956 e.g. U+30A2 -> U+FF71, U+30D7 -> U+FF8C U+FF9F. */
5957 if (map_to_halfwidth(wch, dst_ptr, len) == 2)
5958 {
5959 len--;
5960 dst_ptr++;
5961 if (!len) break;
5962 }
5963 }
5964 else *dst_ptr = wch;
5965 }
5966 if (!(flags & (LCMAP_UPPERCASE | LCMAP_LOWERCASE)) || srclen) goto done;
5967
5968 srclen = dst_ptr - dst;
5969 src = dst;
5970 }
5971
5972 if (flags & (LCMAP_UPPERCASE | LCMAP_LOWERCASE))
5973 {
5974 const USHORT *table = sort.casemap + (flags & LCMAP_LINGUISTIC_CASING ? sortid->casemap : 0);
5975 table = table + 2 + (flags & LCMAP_LOWERCASE ? table[1] : 0);
5976 for (len = dstlen, dst_ptr = dst; srclen && len; src++, srclen--, len--)
5977 *dst_ptr++ = casemap( table, *src );
5978 }
5979 else
5980 {
5981 len = min( srclen, dstlen );
5982 memcpy( dst, src, len * sizeof(WCHAR) );
5983 dst_ptr = dst + len;
5984 srclen -= len;
5985 }
5986
5987 done:
5988 if (srclen)
5989 {
5990 SetLastError( ERROR_INSUFFICIENT_BUFFER );
5991 return 0;
5992 }
5993
5994 return dst_ptr - dst;
5995 }
5996
5997
5998 /***********************************************************************
5999 * LCMapStringA (kernelbase.@)
6000 */
6001 INT WINAPI DECLSPEC_HOTPATCH LCMapStringA( LCID lcid, DWORD flags, const char *src, int srclen,
6002 char *dst, int dstlen )
6003 {
6004 WCHAR *bufW = NtCurrentTeb()->StaticUnicodeBuffer;
6005 LPWSTR srcW, dstW;
6006 INT ret = 0, srclenW, dstlenW;
6007 UINT locale_cp = CP_ACP;
6008
6009 if (!src || !srclen || dstlen < 0)
6010 {
6011 SetLastError( ERROR_INVALID_PARAMETER );
6012 return 0;
6013 }
6014
6015 locale_cp = get_lcid_codepage( lcid, flags );
6016
6017 srclenW = MultiByteToWideChar( locale_cp, 0, src, srclen, bufW, 260 );
6018 if (srclenW) srcW = bufW;
6019 else
6020 {
6021 srclenW = MultiByteToWideChar( locale_cp, 0, src, srclen, NULL, 0 );
6022 srcW = HeapAlloc( GetProcessHeap(), 0, srclenW * sizeof(WCHAR) );
6023 if (!srcW)
6024 {
6025 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
6026 return 0;
6027 }
6028 MultiByteToWideChar( locale_cp, 0, src, srclen, srcW, srclenW );
6029 }
6030
6031 if (flags & LCMAP_SORTKEY)
6032 {
6033 if (src == dst)
6034 {
6035 SetLastError( ERROR_INVALID_FLAGS );
6036 goto done;
6037 }
6038 ret = LCMapStringEx( NULL, flags, srcW, srclenW, (WCHAR *)dst, dstlen, NULL, NULL, 0 );
6039 goto done;
6040 }
6041
6042 if (flags & SORT_STRINGSORT)
6043 {
6044 SetLastError( ERROR_INVALID_FLAGS );
6045 goto done;
6046 }
6047
6048 dstlenW = LCMapStringEx( NULL, flags, srcW, srclenW, NULL, 0, NULL, NULL, 0 );
6049 if (!dstlenW) goto done;
6050
6051 dstW = HeapAlloc( GetProcessHeap(), 0, dstlenW * sizeof(WCHAR) );
6052 if (!dstW)
6053 {
6054 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
6055 goto done;
6056 }
6057 LCMapStringEx( NULL, flags, srcW, srclenW, dstW, dstlenW, NULL, NULL, 0 );
6058 ret = WideCharToMultiByte( locale_cp, 0, dstW, dstlenW, dst, dstlen, NULL, NULL );
6059 HeapFree( GetProcessHeap(), 0, dstW );
6060
6061 done:
6062 if (srcW != bufW) HeapFree( GetProcessHeap(), 0, srcW );
6063 return ret;
6064 }
6065
6066
6067 /***********************************************************************
6068 * LCMapStringW (kernelbase.@)
6069 */
6070 INT WINAPI DECLSPEC_HOTPATCH LCMapStringW( LCID lcid, DWORD flags, const WCHAR *src, int srclen,
6071 WCHAR *dst, int dstlen )
6072 {
6073 return LCMapStringEx( NULL, flags, src, srclen, dst, dstlen, NULL, NULL, 0 );
6074 }
6075
6076
6077 /***********************************************************************
6078 * LocaleNameToLCID (kernelbase.@)
6079 */
6080 LCID WINAPI DECLSPEC_HOTPATCH LocaleNameToLCID( const WCHAR *name, DWORD flags )
6081 {
6082 LCID lcid;
6083 const NLS_LOCALE_DATA *locale = get_locale_by_name( name, &lcid );
6084
6085 if (!locale)
6086 {
6087 SetLastError( ERROR_INVALID_PARAMETER );
6088 return 0;
6089 }
6090 if (!(flags & LOCALE_ALLOW_NEUTRAL_NAMES) && !locale->inotneutral)
6091 lcid = locale->idefaultlanguage;
6092 return lcid;
6093 }
6094
6095
6096 /******************************************************************************
6097 * MultiByteToWideChar (kernelbase.@)
6098 */
6099 INT WINAPI DECLSPEC_HOTPATCH MultiByteToWideChar( UINT codepage, DWORD flags, const char *src, INT srclen,
6100 WCHAR *dst, INT dstlen )
6101 {
6102 int ret;
6103
6104 if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
6105 {
6106 SetLastError( ERROR_INVALID_PARAMETER );
6107 return 0;
6108 }
6109 if (srclen < 0) srclen = strlen(src) + 1;
6110
6111 switch (codepage)
6112 {
6113 case CP_SYMBOL:
6114 ret = mbstowcs_cpsymbol( flags, src, srclen, dst, dstlen );
6115 break;
6116 case CP_UTF7:
6117 ret = mbstowcs_utf7( flags, src, srclen, dst, dstlen );
6118 break;
6119 case CP_UTF8:
6120 ret = mbstowcs_utf8( flags, src, srclen, dst, dstlen );
6121 break;
6122 case CP_UNIXCP:
6123 if (unix_cp == CP_UTF8)
6124 {
6125 ret = mbstowcs_utf8( flags, src, srclen, dst, dstlen );
6126 break;
6127 }
6128 codepage = unix_cp;
6129 /* fall through */
6130 default:
6131 ret = mbstowcs_codepage( codepage, flags, src, srclen, dst, dstlen );
6132 break;
6133 }
6134 TRACE( "cp %d %s -> %s, ret = %d\n", codepage, debugstr_an(src, srclen), debugstr_wn(dst, ret), ret );
6135 return ret;
6136 }
6137
6138
6139 /******************************************************************************
6140 * NormalizeString (kernelbase.@)
6141 */
6142 INT WINAPI DECLSPEC_HOTPATCH NormalizeString(NORM_FORM form, const WCHAR *src, INT src_len,
6143 WCHAR *dst, INT dst_len)
6144 {
6145 NTSTATUS status = RtlNormalizeString( form, src, src_len, dst, &dst_len );
6146
6147 switch (status)
6148 {
6149 case STATUS_OBJECT_NAME_NOT_FOUND:
6150 status = STATUS_INVALID_PARAMETER;
6151 break;
6152 case STATUS_BUFFER_TOO_SMALL:
6153 case STATUS_NO_UNICODE_TRANSLATION:
6154 dst_len = -dst_len;
6155 break;
6156 }
6157 SetLastError( RtlNtStatusToDosError( status ));
6158 return dst_len;
6159 }
6160
6161
6162 /******************************************************************************
6163 * ResolveLocaleName (kernelbase.@)
6164 */
6165 INT WINAPI DECLSPEC_HOTPATCH ResolveLocaleName( LPCWSTR name, LPWSTR buffer, INT len )
6166 {
6167 FIXME( "stub: %s, %p, %d\n", wine_dbgstr_w(name), buffer, len );
6168
6169 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
6170 return 0;
6171 }
6172
6173
6174 /******************************************************************************
6175 * SetLocaleInfoW (kernelbase.@)
6176 */
6177 BOOL WINAPI DECLSPEC_HOTPATCH SetLocaleInfoW( LCID lcid, LCTYPE lctype, const WCHAR *data )
6178 {
6179 WCHAR *str, tmp[80];
6180
6181 if (!data)
6182 {
6183 SetLastError( ERROR_INVALID_PARAMETER );
6184 return FALSE;
6185 }
6186
6187 switch (LOWORD(lctype))
6188 {
6189 case LOCALE_ICALENDARTYPE: return set_registry_entry( &entry_icalendartype, data );
6190 case LOCALE_ICURRDIGITS: return set_registry_entry( &entry_icurrdigits, data );
6191 case LOCALE_ICURRENCY: return set_registry_entry( &entry_icurrency, data );
6192 case LOCALE_IDIGITS: return set_registry_entry( &entry_idigits, data );
6193 case LOCALE_IDIGITSUBSTITUTION: return set_registry_entry( &entry_idigitsubstitution, data );
6194 case LOCALE_IFIRSTDAYOFWEEK: return set_registry_entry( &entry_ifirstdayofweek, data );
6195 case LOCALE_IFIRSTWEEKOFYEAR: return set_registry_entry( &entry_ifirstweekofyear, data );
6196 case LOCALE_ILZERO: return set_registry_entry( &entry_ilzero, data );
6197 case LOCALE_IMEASURE: return set_registry_entry( &entry_imeasure, data );
6198 case LOCALE_INEGCURR: return set_registry_entry( &entry_inegcurr, data );
6199 case LOCALE_INEGNUMBER: return set_registry_entry( &entry_inegnumber, data );
6200 case LOCALE_IPAPERSIZE: return set_registry_entry( &entry_ipapersize, data );
6201 case LOCALE_S1159: return set_registry_entry( &entry_s1159, data );
6202 case LOCALE_S2359: return set_registry_entry( &entry_s2359, data );
6203 case LOCALE_SCURRENCY: return set_registry_entry( &entry_scurrency, data );
6204 case LOCALE_SDECIMAL: return set_registry_entry( &entry_sdecimal, data );
6205 case LOCALE_SGROUPING: return set_registry_entry( &entry_sgrouping, data );
6206 case LOCALE_SLIST: return set_registry_entry( &entry_slist, data );
6207 case LOCALE_SLONGDATE: return set_registry_entry( &entry_slongdate, data );
6208 case LOCALE_SMONDECIMALSEP: return set_registry_entry( &entry_smondecimalsep, data );
6209 case LOCALE_SMONGROUPING: return set_registry_entry( &entry_smongrouping, data );
6210 case LOCALE_SMONTHOUSANDSEP: return set_registry_entry( &entry_smonthousandsep, data );
6211 case LOCALE_SNATIVEDIGITS: return set_registry_entry( &entry_snativedigits, data );
6212 case LOCALE_SNEGATIVESIGN: return set_registry_entry( &entry_snegativesign, data );
6213 case LOCALE_SPOSITIVESIGN: return set_registry_entry( &entry_spositivesign, data );
6214 case LOCALE_SSHORTTIME: return set_registry_entry( &entry_sshorttime, data );
6215 case LOCALE_STHOUSAND: return set_registry_entry( &entry_sthousand, data );
6216 case LOCALE_SYEARMONTH: return set_registry_entry( &entry_syearmonth, data );
6217
6218 case LOCALE_SDATE:
6219 if (!get_locale_info( user_locale, user_lcid, LOCALE_SSHORTDATE, tmp, ARRAY_SIZE(tmp) )) break;
6220 data = locale_replace_separator( tmp, data );
6221 /* fall through */
6222 case LOCALE_SSHORTDATE:
6223 if (!set_registry_entry( &entry_sshortdate, data )) return FALSE;
6224 update_registry_value( LOCALE_IDATE, L"iDate" );
6225 update_registry_value( LOCALE_SDATE, L"sDate" );
6226 return TRUE;
6227
6228 case LOCALE_STIME:
6229 if (!get_locale_info( user_locale, user_lcid, LOCALE_STIMEFORMAT, tmp, ARRAY_SIZE(tmp) )) break;
6230 data = locale_replace_separator( tmp, data );
6231 /* fall through */
6232 case LOCALE_STIMEFORMAT:
6233 if (!set_registry_entry( &entry_stimeformat, data )) return FALSE;
6234 update_registry_value( LOCALE_ITIME, L"iTime" );
6235 update_registry_value( LOCALE_ITIMEMARKPOSN, L"iTimePrefix" );
6236 update_registry_value( LOCALE_ITLZERO, L"iTLZero" );
6237 update_registry_value( LOCALE_STIME, L"sTime" );
6238 return TRUE;
6239
6240 case LOCALE_ITIME:
6241 if (!get_locale_info( user_locale, user_lcid, LOCALE_STIMEFORMAT, tmp, ARRAY_SIZE(tmp) )) break;
6242 if (!(str = find_format( tmp, L"Hh" ))) break;
6243 while (*str == 'h' || *str == 'H') *str++ = (*data == '0' ? 'h' : 'H');
6244 if (!set_registry_entry( &entry_stimeformat, tmp )) break;
6245 update_registry_value( LOCALE_ITIME, L"iTime" );
6246 return TRUE;
6247
6248 case LOCALE_SINTLSYMBOL:
6249 /* FIXME: also store sintlsymbol */
6250 set_registry_entry( &entry_scurrency, data );
6251 return TRUE;
6252 }
6253 SetLastError( ERROR_INVALID_FLAGS );
6254 return FALSE;
6255 }
6256
6257
6258 /***********************************************************************
6259 * SetCalendarInfoW (kernelbase.@)
6260 */
6261 INT WINAPI /* DECLSPEC_HOTPATCH */ SetCalendarInfoW( LCID lcid, CALID calendar, CALTYPE type, const WCHAR *data )
6262 {
6263 FIXME( "(%08lx,%08lx,%08lx,%s): stub\n", lcid, calendar, type, debugstr_w(data) );
6264 return 0;
6265 }
6266
6267
6268 /***********************************************************************
6269 * SetProcessPreferredUILanguages (kernelbase.@)
6270 */
6271 BOOL WINAPI DECLSPEC_HOTPATCH SetProcessPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
6272 {
6273 return set_ntstatus( RtlSetProcessPreferredUILanguages( flags, buffer, count ));
6274 }
6275
6276
6277 /***********************************************************************
6278 * SetThreadPreferredUILanguages (kernelbase.@)
6279 */
6280 BOOL WINAPI DECLSPEC_HOTPATCH SetThreadPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
6281 {
6282 return set_ntstatus( RtlSetThreadPreferredUILanguages( flags, buffer, count ));
6283 }
6284
6285
6286 /***********************************************************************
6287 * SetTimeZoneInformation (kernelbase.@)
6288 */
6289 BOOL WINAPI DECLSPEC_HOTPATCH SetTimeZoneInformation( const TIME_ZONE_INFORMATION *info )
6290 {
6291 return set_ntstatus( RtlSetTimeZoneInformation( (const RTL_TIME_ZONE_INFORMATION *)info ));
6292 }
6293
6294
6295 /******************************************************************************
6296 * SetUserGeoID (kernelbase.@)
6297 */
6298 BOOL WINAPI DECLSPEC_HOTPATCH SetUserGeoID( GEOID id )
6299 {
6300 const struct geo_id *geo = find_geo_id_entry( id );
6301 WCHAR bufferW[10];
6302 HKEY hkey;
6303
6304 if (!geo)
6305 {
6306 SetLastError( ERROR_INVALID_PARAMETER );
6307 return FALSE;
6308 }
6309 if (!RegCreateKeyExW( intl_key, L"Geo", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
6310 {
6311 const WCHAR *name = geo->class == GEOCLASS_NATION ? L"Nation" : L"Region";
6312 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%u", geo->id );
6313 RegSetValueExW( hkey, name, 0, REG_SZ, (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
6314
6315 if (geo->class == GEOCLASS_NATION || wcscmp( geo->iso2, L"XX" ))
6316 lstrcpyW( bufferW, geo->iso2 );
6317 else
6318 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03u", geo->uncode );
6319 RegSetValueExW( hkey, L"Name", 0, REG_SZ, (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
6320 RegCloseKey( hkey );
6321 }
6322 return TRUE;
6323 }
6324
6325
6326 /***********************************************************************
6327 * SystemTimeToTzSpecificLocalTime (kernelbase.@)
6328 */
6329 BOOL WINAPI DECLSPEC_HOTPATCH SystemTimeToTzSpecificLocalTime( const TIME_ZONE_INFORMATION *info,
6330 const SYSTEMTIME *system,
6331 SYSTEMTIME *local )
6332 {
6333 TIME_ZONE_INFORMATION tzinfo;
6334 LARGE_INTEGER ft;
6335
6336 if (!info)
6337 {
6338 RtlQueryTimeZoneInformation( (RTL_TIME_ZONE_INFORMATION *)&tzinfo );
6339 info = &tzinfo;
6340 }
6341
6342 if (!SystemTimeToFileTime( system, (FILETIME *)&ft )) return FALSE;
6343 switch (get_timezone_id( info, ft, FALSE ))
6344 {
6345 case TIME_ZONE_ID_UNKNOWN:
6346 ft.QuadPart -= info->Bias * (LONGLONG)600000000;
6347 break;
6348 case TIME_ZONE_ID_STANDARD:
6349 ft.QuadPart -= (info->Bias + info->StandardBias) * (LONGLONG)600000000;
6350 break;
6351 case TIME_ZONE_ID_DAYLIGHT:
6352 ft.QuadPart -= (info->Bias + info->DaylightBias) * (LONGLONG)600000000;
6353 break;
6354 default:
6355 return FALSE;
6356 }
6357 return FileTimeToSystemTime( (FILETIME *)&ft, local );
6358 }
6359
6360
6361 /***********************************************************************
6362 * TzSpecificLocalTimeToSystemTime (kernelbase.@)
6363 */
6364 BOOL WINAPI DECLSPEC_HOTPATCH TzSpecificLocalTimeToSystemTime( const TIME_ZONE_INFORMATION *info,
6365 const SYSTEMTIME *local,
6366 SYSTEMTIME *system )
6367 {
6368 TIME_ZONE_INFORMATION tzinfo;
6369 LARGE_INTEGER ft;
6370
6371 if (!info)
6372 {
6373 RtlQueryTimeZoneInformation( (RTL_TIME_ZONE_INFORMATION *)&tzinfo );
6374 info = &tzinfo;
6375 }
6376
6377 if (!SystemTimeToFileTime( local, (FILETIME *)&ft )) return FALSE;
6378 switch (get_timezone_id( info, ft, TRUE ))
6379 {
6380 case TIME_ZONE_ID_UNKNOWN:
6381 ft.QuadPart += info->Bias * (LONGLONG)600000000;
6382 break;
6383 case TIME_ZONE_ID_STANDARD:
6384 ft.QuadPart += (info->Bias + info->StandardBias) * (LONGLONG)600000000;
6385 break;
6386 case TIME_ZONE_ID_DAYLIGHT:
6387 ft.QuadPart += (info->Bias + info->DaylightBias) * (LONGLONG)600000000;
6388 break;
6389 default:
6390 return FALSE;
6391 }
6392 return FileTimeToSystemTime( (FILETIME *)&ft, system );
6393 }
6394
6395
6396 /***********************************************************************
6397 * VerLanguageNameA (kernelbase.@)
6398 */
6399 DWORD WINAPI DECLSPEC_HOTPATCH VerLanguageNameA( DWORD lang, LPSTR buffer, DWORD size )
6400 {
6401 return GetLocaleInfoA( MAKELCID( lang, SORT_DEFAULT ), LOCALE_SENGLANGUAGE, buffer, size );
6402 }
6403
6404
6405 /***********************************************************************
6406 * VerLanguageNameW (kernelbase.@)
6407 */
6408 DWORD WINAPI DECLSPEC_HOTPATCH VerLanguageNameW( DWORD lang, LPWSTR buffer, DWORD size )
6409 {
6410 return GetLocaleInfoW( MAKELCID( lang, SORT_DEFAULT ), LOCALE_SENGLANGUAGE, buffer, size );
6411 }
6412
6413
6414 /***********************************************************************
6415 * WideCharToMultiByte (kernelbase.@)
6416 */
6417 INT WINAPI DECLSPEC_HOTPATCH WideCharToMultiByte( UINT codepage, DWORD flags, LPCWSTR src, INT srclen,
6418 LPSTR dst, INT dstlen, LPCSTR defchar, BOOL *used )
6419 {
6420 int ret;
6421
6422 if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
6423 {
6424 SetLastError( ERROR_INVALID_PARAMETER );
6425 return 0;
6426 }
6427
6428 if (srclen < 0) srclen = lstrlenW(src) + 1;
6429
6430 switch (codepage)
6431 {
6432 case CP_SYMBOL:
6433 ret = wcstombs_cpsymbol( flags, src, srclen, dst, dstlen, defchar, used );
6434 break;
6435 case CP_UTF7:
6436 ret = wcstombs_utf7( flags, src, srclen, dst, dstlen, defchar, used );
6437 break;
6438 case CP_UTF8:
6439 ret = wcstombs_utf8( flags, src, srclen, dst, dstlen, defchar, used );
6440 break;
6441 case CP_UNIXCP:
6442 if (unix_cp == CP_UTF8)
6443 {
6444 if (used) *used = FALSE;
6445 ret = wcstombs_utf8( flags, src, srclen, dst, dstlen, NULL, NULL );
6446 break;
6447 }
6448 codepage = unix_cp;
6449 /* fall through */
6450 default:
6451 ret = wcstombs_codepage( codepage, flags, src, srclen, dst, dstlen, defchar, used );
6452 break;
6453 }
6454 TRACE( "cp %d %s -> %s, ret = %d\n", codepage, debugstr_wn(src, srclen), debugstr_an(dst, ret), ret );
6455 return ret;
6456 }
6457
6458
6459 /***********************************************************************
6460 * GetUserDefaultGeoName (kernelbase.@)
6461 */
6462 INT WINAPI GetUserDefaultGeoName(LPWSTR geo_name, int count)
6463 {
6464 WCHAR buffer[32];
6465 LSTATUS status;
6466 DWORD size;
6467 HKEY key;
6468
6469 TRACE( "geo_name %p, count %d.\n", geo_name, count );
6470
6471 if (count && !geo_name)
6472 {
6473 SetLastError( ERROR_INVALID_PARAMETER );
6474 return 0;
6475 }
6476 if (!(status = RegOpenKeyExW( intl_key, L"Geo", 0, KEY_ALL_ACCESS, &key )))
6477 {
6478 size = sizeof(buffer);
6479 status = RegQueryValueExW( key, L"Name", NULL, NULL, (BYTE *)buffer, &size );
6480 RegCloseKey( key );
6481 }
6482 if (status)
6483 {
6484 const struct geo_id *geo = find_geo_id_entry( GetUserGeoID( GEOCLASS_NATION ));
6485 if (geo && geo->id != 39070)
6486 lstrcpyW( buffer, geo->iso2 );
6487 else
6488 lstrcpyW( buffer, L"001" );
6489 }
6490 size = lstrlenW( buffer ) + 1;
6491 if (count < size)
6492 {
6493 if (!count)
6494 return size;
6495 SetLastError( ERROR_INSUFFICIENT_BUFFER );
6496 return 0;
6497 }
6498 lstrcpyW( geo_name, buffer );
6499 return size;
6500 }
6501
6502
6503 /***********************************************************************
6504 * SetUserDefaultGeoName (kernelbase.@)
6505 */
6506 BOOL WINAPI SetUserGeoName(PWSTR geo_name)
6507 {
6508 const struct geo_id *geo;
6509
6510 TRACE( "geo_name %s.\n", debugstr_w( geo_name ));
6511
6512 if (!geo_name || !(geo = find_geo_name_entry( geo_name )))
6513 {
6514 SetLastError( ERROR_INVALID_PARAMETER );
6515 return FALSE;
6516 }
6517 return SetUserGeoID( geo->id );
6518 }
Windows API implementation