?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dbghelp: Sparse array speed up.
[wine/wine-kai.git] / dlls / kernel32 / locale.c
blob8792623f6531f496667b55a9ec679c56ee305956
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 2002 Alexandre Julliard for CodeWeavers
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <assert.h>
28 #include <locale.h>
29 #include <string.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <ctype.h>
33 #include <stdlib.h>
34
35 #ifdef __APPLE__
36 # include <CoreFoundation/CFLocale.h>
37 # include <CoreFoundation/CFString.h>
38 #endif
39
40 #include "ntstatus.h"
41 #define WIN32_NO_STATUS
42 #include "windef.h"
43 #include "winbase.h"
44 #include "winuser.h" /* for RT_STRINGW */
45 #include "winternl.h"
46 #include "wine/unicode.h"
47 #include "winnls.h"
48 #include "winerror.h"
49 #include "winver.h"
50 #include "kernel_private.h"
51 #include "wine/debug.h"
52
53 WINE_DEFAULT_DEBUG_CHANNEL(nls);
54
55 #define LOCALE_LOCALEINFOFLAGSMASK (LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP|LOCALE_RETURN_NUMBER)
56
57 /* current code pages */
58 static const union cptable *ansi_cptable;
59 static const union cptable *oem_cptable;
60 static const union cptable *mac_cptable;
61 static const union cptable *unix_cptable; /* NULL if UTF8 */
62
63 static HANDLE NLS_RegOpenKey(HANDLE hRootKey, LPCWSTR szKeyName);
64 static HANDLE NLS_RegOpenSubKey(HANDLE hRootKey, LPCWSTR szKeyName);
65
66 static const WCHAR szNlsKeyName[] = {
67 'M','a','c','h','i','n','e','\\','S','y','s','t','e','m','\\',
68 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
69 'C','o','n','t','r','o','l','\\','N','l','s','\0'
70 };
71
72 /* Charset to codepage map, sorted by name. */
73 static const struct charset_entry
74 {
75 const char *charset_name;
76 UINT codepage;
77 } charset_names[] =
78 {
79 { "BIG5", 950 },
80 { "CP1250", 1250 },
81 { "CP1251", 1251 },
82 { "CP1252", 1252 },
83 { "CP1253", 1253 },
84 { "CP1254", 1254 },
85 { "CP1255", 1255 },
86 { "CP1256", 1256 },
87 { "CP1257", 1257 },
88 { "CP1258", 1258 },
89 { "CP932", 932 },
90 { "CP936", 936 },
91 { "CP949", 949 },
92 { "CP950", 950 },
93 { "EUCJP", 20932 },
94 { "GB2312", 936 },
95 { "IBM037", 37 },
96 { "IBM1026", 1026 },
97 { "IBM424", 424 },
98 { "IBM437", 437 },
99 { "IBM500", 500 },
100 { "IBM850", 850 },
101 { "IBM852", 852 },
102 { "IBM855", 855 },
103 { "IBM857", 857 },
104 { "IBM860", 860 },
105 { "IBM861", 861 },
106 { "IBM862", 862 },
107 { "IBM863", 863 },
108 { "IBM864", 864 },
109 { "IBM865", 865 },
110 { "IBM866", 866 },
111 { "IBM869", 869 },
112 { "IBM874", 874 },
113 { "IBM875", 875 },
114 { "ISO88591", 28591 },
115 { "ISO885910", 28600 },
116 { "ISO885913", 28603 },
117 { "ISO885914", 28604 },
118 { "ISO885915", 28605 },
119 { "ISO885916", 28606 },
120 { "ISO88592", 28592 },
121 { "ISO88593", 28593 },
122 { "ISO88594", 28594 },
123 { "ISO88595", 28595 },
124 { "ISO88596", 28596 },
125 { "ISO88597", 28597 },
126 { "ISO88598", 28598 },
127 { "ISO88599", 28599 },
128 { "KOI8R", 20866 },
129 { "KOI8U", 21866 },
130 { "UTF8", CP_UTF8 }
131 };
132
133
134 struct locale_name
135 {
136 WCHAR win_name[128]; /* Windows name ("en-US") */
137 WCHAR lang[128]; /* language ("en") (note: buffer contains the other strings too) */
138 WCHAR *country; /* country ("US") */
139 WCHAR *charset; /* charset ("UTF-8") for Unix format only */
140 WCHAR *script; /* script ("Latn") for Windows format only */
141 WCHAR *modifier; /* modifier or sort order */
142 LCID lcid; /* corresponding LCID */
143 int matches; /* number of elements matching LCID (0..4) */
144 UINT codepage; /* codepage corresponding to charset */
145 };
146
147 /* locale ids corresponding to the various Unix locale parameters */
148 static LCID lcid_LC_COLLATE;
149 static LCID lcid_LC_CTYPE;
150 static LCID lcid_LC_MESSAGES;
151 static LCID lcid_LC_MONETARY;
152 static LCID lcid_LC_NUMERIC;
153 static LCID lcid_LC_TIME;
154 static LCID lcid_LC_PAPER;
155 static LCID lcid_LC_MEASUREMENT;
156 static LCID lcid_LC_TELEPHONE;
157
158 /* Copy Ascii string to Unicode without using codepages */
159 static inline void strcpynAtoW( WCHAR *dst, const char *src, size_t n )
160 {
161 while (n > 1 && *src)
162 {
163 *dst++ = (unsigned char)*src++;
164 n--;
165 }
166 if (n) *dst = 0;
167 }
168
169
170 /***********************************************************************
171 * get_lcid_codepage
172 *
173 * Retrieve the ANSI codepage for a given locale.
174 */
175 inline static UINT get_lcid_codepage( LCID lcid )
176 {
177 UINT ret;
178 if (!GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER, (WCHAR *)&ret,
179 sizeof(ret)/sizeof(WCHAR) )) ret = 0;
180 return ret;
181 }
182
183
184 /***********************************************************************
185 * get_codepage_table
186 *
187 * Find the table for a given codepage, handling CP_ACP etc. pseudo-codepages
188 */
189 static const union cptable *get_codepage_table( unsigned int codepage )
190 {
191 const union cptable *ret = NULL;
192
193 assert( ansi_cptable ); /* init must have been done already */
194
195 switch(codepage)
196 {
197 case CP_ACP:
198 return ansi_cptable;
199 case CP_OEMCP:
200 return oem_cptable;
201 case CP_MACCP:
202 return mac_cptable;
203 case CP_UTF7:
204 case CP_UTF8:
205 break;
206 case CP_THREAD_ACP:
207 if (!(codepage = kernel_get_thread_data()->code_page)) return ansi_cptable;
208 /* fall through */
209 default:
210 if (codepage == ansi_cptable->info.codepage) return ansi_cptable;
211 if (codepage == oem_cptable->info.codepage) return oem_cptable;
212 if (codepage == mac_cptable->info.codepage) return mac_cptable;
213 ret = wine_cp_get_table( codepage );
214 break;
215 }
216 return ret;
217 }
218
219
220 /***********************************************************************
221 * charset_cmp (internal)
222 */
223 static int charset_cmp( const void *name, const void *entry )
224 {
225 const struct charset_entry *charset = (const struct charset_entry *)entry;
226 return strcasecmp( (const char *)name, charset->charset_name );
227 }
228
229 /***********************************************************************
230 * find_charset
231 */
232 static UINT find_charset( const WCHAR *name )
233 {
234 const struct charset_entry *entry;
235 char charset_name[16];
236 size_t i, j;
237
238 /* remove punctuation characters from charset name */
239 for (i = j = 0; name[i] && j < sizeof(charset_name)-1; i++)
240 if (isalnum((unsigned char)name[i])) charset_name[j++] = name[i];
241 charset_name[j] = 0;
242
243 entry = bsearch( charset_name, charset_names,
244 sizeof(charset_names)/sizeof(charset_names[0]),
245 sizeof(charset_names[0]), charset_cmp );
246 if (entry) return entry->codepage;
247 return 0;
248 }
249
250
251 /***********************************************************************
252 * find_locale_id_callback
253 */
254 static BOOL CALLBACK find_locale_id_callback( HMODULE hModule, LPCWSTR type,
255 LPCWSTR name, WORD LangID, LPARAM lParam )
256 {
257 struct locale_name *data = (struct locale_name *)lParam;
258 WCHAR buffer[128];
259 int matches = 0;
260 LCID lcid = MAKELCID( LangID, SORT_DEFAULT ); /* FIXME: handle sort order */
261
262 if (PRIMARYLANGID(LangID) == LANG_NEUTRAL) return TRUE; /* continue search */
263
264 /* first check exact name */
265 if (data->win_name[0] &&
266 GetLocaleInfoW( lcid, LOCALE_SNAME | LOCALE_NOUSEROVERRIDE,
267 buffer, sizeof(buffer)/sizeof(WCHAR) ))
268 {
269 if (!strcmpW( data->win_name, buffer ))
270 {
271 matches = 4; /* everything matches */
272 goto done;
273 }
274 }
275
276 if (!GetLocaleInfoW( lcid, LOCALE_SISO639LANGNAME | LOCALE_NOUSEROVERRIDE,
277 buffer, sizeof(buffer)/sizeof(WCHAR) ))
278 return TRUE;
279 if (strcmpW( buffer, data->lang )) return TRUE;
280 matches++; /* language name matched */
281
282 if (data->country)
283 {
284 if (GetLocaleInfoW( lcid, LOCALE_SISO3166CTRYNAME|LOCALE_NOUSEROVERRIDE,
285 buffer, sizeof(buffer)/sizeof(WCHAR) ))
286 {
287 if (strcmpW( buffer, data->country )) goto done;
288 matches++; /* country name matched */
289 }
290 }
291 else /* match default language */
292 {
293 if (SUBLANGID(LangID) == SUBLANG_DEFAULT) matches++;
294 }
295
296 if (data->codepage)
297 {
298 UINT unix_cp;
299 if (GetLocaleInfoW( lcid, LOCALE_IDEFAULTUNIXCODEPAGE | LOCALE_RETURN_NUMBER,
300 (LPWSTR)&unix_cp, sizeof(unix_cp)/sizeof(WCHAR) ))
301 {
302 if (unix_cp == data->codepage) matches++;
303 }
304 }
305
306 /* FIXME: check sort order */
307
308 done:
309 if (matches > data->matches)
310 {
311 data->lcid = lcid;
312 data->matches = matches;
313 }
314 return (data->matches < 4); /* no need to continue for perfect match */
315 }
316
317
318 /***********************************************************************
319 * parse_locale_name
320 *
321 * Parse a locale name into a struct locale_name, handling both Windows and Unix formats.
322 * Unix format is: lang[_country][.charset][@modifier]
323 * Windows format is: lang[-script][-country][_modifier]
324 */
325 static void parse_locale_name( const WCHAR *str, struct locale_name *name )
326 {
327 static const WCHAR sepW[] = {'-','_','.','@'};
328 static const WCHAR winsepW[] = {'-','_'};
329 static const WCHAR posixW[] = {'P','O','S','I','X',0};
330 static const WCHAR cW[] = {'C',0};
331 static const WCHAR latinW[] = {'l','a','t','i','n',0};
332 static const WCHAR latnW[] = {'-','L','a','t','n',0};
333 WCHAR *p;
334
335 name->country = name->charset = name->script = name->modifier = NULL;
336 name->lcid = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT );
337 name->matches = 0;
338 name->codepage = 0;
339 name->win_name[0] = 0;
340 lstrcpynW( name->lang, str, sizeof(name->lang)/sizeof(WCHAR) );
341
342 if (!(p = strpbrkW( name->lang, sepW )))
343 {
344 if (!strcmpW( name->lang, posixW ) || !strcmpW( name->lang, cW ))
345 {
346 name->matches = 4; /* perfect match for default English lcid */
347 return;
348 }
349 strcpyW( name->win_name, name->lang );
350 }
351 else if (*p == '-') /* Windows format */
352 {
353 strcpyW( name->win_name, name->lang );
354 *p++ = 0;
355 name->country = p;
356 if (!(p = strpbrkW( p, winsepW ))) goto done;
357 if (*p == '-')
358 {
359 *p++ = 0;
360 name->script = name->country;
361 name->country = p;
362 if (!(p = strpbrkW( p, winsepW ))) goto done;
363 }
364 *p++ = 0;
365 name->modifier = p;
366 }
367 else /* Unix format */
368 {
369 if (*p == '_')
370 {
371 *p++ = 0;
372 name->country = p;
373 p = strpbrkW( p, sepW + 2 );
374 }
375 if (p && *p == '.')
376 {
377 *p++ = 0;
378 name->charset = p;
379 name->codepage = find_charset( name->charset );
380 p = strchrW( p, '@' );
381 }
382 if (p)
383 {
384 *p++ = 0;
385 name->modifier = p;
386 }
387
388 /* rebuild a Windows name if possible */
389
390 if (name->charset) goto done; /* can't specify charset in Windows format */
391 if (name->modifier && strcmpW( name->modifier, latinW ))
392 goto done; /* only Latn script supported for now */
393 strcpyW( name->win_name, name->lang );
394 if (name->modifier) strcatW( name->win_name, latnW );
395 if (name->country)
396 {
397 p = name->win_name + strlenW(name->win_name);
398 *p++ = '-';
399 strcpyW( p, name->country );
400 }
401 }
402 done:
403 EnumResourceLanguagesW( kernel32_handle, (LPCWSTR)RT_STRING, (LPCWSTR)LOCALE_ILANGUAGE,
404 find_locale_id_callback, (LPARAM)name );
405 }
406
407
408 /***********************************************************************
409 * convert_default_lcid
410 *
411 * Get the default LCID to use for a given lctype in GetLocaleInfo.
412 */
413 static LCID convert_default_lcid( LCID lcid, LCTYPE lctype )
414 {
415 if (lcid == LOCALE_SYSTEM_DEFAULT ||
416 lcid == LOCALE_USER_DEFAULT ||
417 lcid == LOCALE_NEUTRAL)
418 {
419 LCID default_id = 0;
420
421 switch(lctype & 0xffff)
422 {
423 case LOCALE_SSORTNAME:
424 default_id = lcid_LC_COLLATE;
425 break;
426
427 case LOCALE_FONTSIGNATURE:
428 case LOCALE_IDEFAULTANSICODEPAGE:
429 case LOCALE_IDEFAULTCODEPAGE:
430 case LOCALE_IDEFAULTEBCDICCODEPAGE:
431 case LOCALE_IDEFAULTMACCODEPAGE:
432 case LOCALE_IDEFAULTUNIXCODEPAGE:
433 default_id = lcid_LC_CTYPE;
434 break;
435
436 case LOCALE_ICURRDIGITS:
437 case LOCALE_ICURRENCY:
438 case LOCALE_IINTLCURRDIGITS:
439 case LOCALE_INEGCURR:
440 case LOCALE_INEGSEPBYSPACE:
441 case LOCALE_INEGSIGNPOSN:
442 case LOCALE_INEGSYMPRECEDES:
443 case LOCALE_IPOSSEPBYSPACE:
444 case LOCALE_IPOSSIGNPOSN:
445 case LOCALE_IPOSSYMPRECEDES:
446 case LOCALE_SCURRENCY:
447 case LOCALE_SINTLSYMBOL:
448 case LOCALE_SMONDECIMALSEP:
449 case LOCALE_SMONGROUPING:
450 case LOCALE_SMONTHOUSANDSEP:
451 case LOCALE_SNATIVECURRNAME:
452 default_id = lcid_LC_MONETARY;
453 break;
454
455 case LOCALE_IDIGITS:
456 case LOCALE_IDIGITSUBSTITUTION:
457 case LOCALE_ILZERO:
458 case LOCALE_INEGNUMBER:
459 case LOCALE_SDECIMAL:
460 case LOCALE_SGROUPING:
461 case LOCALE_SNAN:
462 case LOCALE_SNATIVEDIGITS:
463 case LOCALE_SNEGATIVESIGN:
464 case LOCALE_SNEGINFINITY:
465 case LOCALE_SPOSINFINITY:
466 case LOCALE_SPOSITIVESIGN:
467 case LOCALE_STHOUSAND:
468 default_id = lcid_LC_NUMERIC;
469 break;
470
471 case LOCALE_ICALENDARTYPE:
472 case LOCALE_ICENTURY:
473 case LOCALE_IDATE:
474 case LOCALE_IDAYLZERO:
475 case LOCALE_IFIRSTDAYOFWEEK:
476 case LOCALE_IFIRSTWEEKOFYEAR:
477 case LOCALE_ILDATE:
478 case LOCALE_IMONLZERO:
479 case LOCALE_IOPTIONALCALENDAR:
480 case LOCALE_ITIME:
481 case LOCALE_ITIMEMARKPOSN:
482 case LOCALE_ITLZERO:
483 case LOCALE_S1159:
484 case LOCALE_S2359:
485 case LOCALE_SABBREVDAYNAME1:
486 case LOCALE_SABBREVDAYNAME2:
487 case LOCALE_SABBREVDAYNAME3:
488 case LOCALE_SABBREVDAYNAME4:
489 case LOCALE_SABBREVDAYNAME5:
490 case LOCALE_SABBREVDAYNAME6:
491 case LOCALE_SABBREVDAYNAME7:
492 case LOCALE_SABBREVMONTHNAME1:
493 case LOCALE_SABBREVMONTHNAME2:
494 case LOCALE_SABBREVMONTHNAME3:
495 case LOCALE_SABBREVMONTHNAME4:
496 case LOCALE_SABBREVMONTHNAME5:
497 case LOCALE_SABBREVMONTHNAME6:
498 case LOCALE_SABBREVMONTHNAME7:
499 case LOCALE_SABBREVMONTHNAME8:
500 case LOCALE_SABBREVMONTHNAME9:
501 case LOCALE_SABBREVMONTHNAME10:
502 case LOCALE_SABBREVMONTHNAME11:
503 case LOCALE_SABBREVMONTHNAME12:
504 case LOCALE_SABBREVMONTHNAME13:
505 case LOCALE_SDATE:
506 case LOCALE_SDAYNAME1:
507 case LOCALE_SDAYNAME2:
508 case LOCALE_SDAYNAME3:
509 case LOCALE_SDAYNAME4:
510 case LOCALE_SDAYNAME5:
511 case LOCALE_SDAYNAME6:
512 case LOCALE_SDAYNAME7:
513 case LOCALE_SDURATION:
514 case LOCALE_SLONGDATE:
515 case LOCALE_SMONTHNAME1:
516 case LOCALE_SMONTHNAME2:
517 case LOCALE_SMONTHNAME3:
518 case LOCALE_SMONTHNAME4:
519 case LOCALE_SMONTHNAME5:
520 case LOCALE_SMONTHNAME6:
521 case LOCALE_SMONTHNAME7:
522 case LOCALE_SMONTHNAME8:
523 case LOCALE_SMONTHNAME9:
524 case LOCALE_SMONTHNAME10:
525 case LOCALE_SMONTHNAME11:
526 case LOCALE_SMONTHNAME12:
527 case LOCALE_SMONTHNAME13:
528 case LOCALE_SSHORTDATE:
529 case LOCALE_SSHORTESTDAYNAME1:
530 case LOCALE_SSHORTESTDAYNAME2:
531 case LOCALE_SSHORTESTDAYNAME3:
532 case LOCALE_SSHORTESTDAYNAME4:
533 case LOCALE_SSHORTESTDAYNAME5:
534 case LOCALE_SSHORTESTDAYNAME6:
535 case LOCALE_SSHORTESTDAYNAME7:
536 case LOCALE_STIME:
537 case LOCALE_STIMEFORMAT:
538 case LOCALE_SYEARMONTH:
539 default_id = lcid_LC_TIME;
540 break;
541
542 case LOCALE_IPAPERSIZE:
543 default_id = lcid_LC_PAPER;
544 break;
545
546 case LOCALE_IMEASURE:
547 default_id = lcid_LC_MEASUREMENT;
548 break;
549
550 case LOCALE_ICOUNTRY:
551 default_id = lcid_LC_TELEPHONE;
552 break;
553 }
554 if (default_id) lcid = default_id;
555 }
556 return ConvertDefaultLocale( lcid );
557 }
558
559
560 /***********************************************************************
561 * create_registry_key
562 *
563 * Create the Control Panel\\International registry key.
564 */
565 inline static HANDLE create_registry_key(void)
566 {
567 static const WCHAR intlW[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
568 'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
569 OBJECT_ATTRIBUTES attr;
570 UNICODE_STRING nameW;
571 HANDLE hkey;
572
573 if (RtlOpenCurrentUser( KEY_ALL_ACCESS, &hkey ) != STATUS_SUCCESS) return 0;
574
575 attr.Length = sizeof(attr);
576 attr.RootDirectory = hkey;
577 attr.ObjectName = &nameW;
578 attr.Attributes = 0;
579 attr.SecurityDescriptor = NULL;
580 attr.SecurityQualityOfService = NULL;
581 RtlInitUnicodeString( &nameW, intlW );
582
583 if (NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS) hkey = 0;
584 NtClose( attr.RootDirectory );
585 return hkey;
586 }
587
588
589 /* update the registry settings for a given locale parameter */
590 /* return TRUE if an update was needed */
591 static BOOL locale_update_registry( HKEY hkey, const WCHAR *name, LCID lcid,
592 const LCTYPE *values, UINT nb_values )
593 {
594 static const WCHAR formatW[] = { '%','0','8','x',0 };
595 WCHAR bufferW[40];
596 UNICODE_STRING nameW;
597 DWORD count, i;
598
599 RtlInitUnicodeString( &nameW, name );
600 count = sizeof(bufferW);
601 if (!NtQueryValueKey(hkey, &nameW, KeyValuePartialInformation, (LPBYTE)bufferW, count, &count))
602 {
603 const KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)bufferW;
604 LPCWSTR text = (LPCWSTR)info->Data;
605
606 if (strtoulW( text, NULL, 16 ) == lcid) return FALSE; /* already set correctly */
607 TRACE( "updating registry, locale %s changed %s -> %08x\n",
608 debugstr_w(name), debugstr_w(text), lcid );
609 }
610 else TRACE( "updating registry, locale %s changed none -> %08x\n", debugstr_w(name), lcid );
611 sprintfW( bufferW, formatW, lcid );
612 NtSetValueKey( hkey, &nameW, 0, REG_SZ, bufferW, (strlenW(bufferW) + 1) * sizeof(WCHAR) );
613
614 for (i = 0; i < nb_values; i++)
615 {
616 GetLocaleInfoW( lcid, values[i] | LOCALE_NOUSEROVERRIDE, bufferW,
617 sizeof(bufferW)/sizeof(WCHAR) );
618 SetLocaleInfoW( lcid, values[i], bufferW );
619 }
620 return TRUE;
621 }
622
623
624 /***********************************************************************
625 * LOCALE_InitRegistry
626 *
627 * Update registry contents on startup if the user locale has changed.
628 * This simulates the action of the Windows control panel.
629 */
630 void LOCALE_InitRegistry(void)
631 {
632 static const WCHAR CodepageW[] = {'C','o','d','e','p','a','g','e',0};
633 static const WCHAR acpW[] = {'A','C','P',0};
634 static const WCHAR oemcpW[] = {'O','E','M','C','P',0};
635 static const WCHAR maccpW[] = {'M','A','C','C','P',0};
636 static const WCHAR localeW[] = {'L','o','c','a','l','e',0};
637 static const WCHAR lc_ctypeW[] = { 'L','C','_','C','T','Y','P','E',0 };
638 static const WCHAR lc_monetaryW[] = { 'L','C','_','M','O','N','E','T','A','R','Y',0 };
639 static const WCHAR lc_numericW[] = { 'L','C','_','N','U','M','E','R','I','C',0 };
640 static const WCHAR lc_timeW[] = { 'L','C','_','T','I','M','E',0 };
641 static const WCHAR lc_measurementW[] = { 'L','C','_','M','E','A','S','U','R','E','M','E','N','T',0 };
642 static const WCHAR lc_telephoneW[] = { 'L','C','_','T','E','L','E','P','H','O','N','E',0 };
643 static const struct
644 {
645 LPCWSTR name;
646 USHORT value;
647 } update_cp_values[] = {
648 { acpW, LOCALE_IDEFAULTANSICODEPAGE },
649 { oemcpW, LOCALE_IDEFAULTCODEPAGE },
650 { maccpW, LOCALE_IDEFAULTMACCODEPAGE }
651 };
652 static const LCTYPE lc_messages_values[] = {
653 LOCALE_SLANGUAGE,
654 LOCALE_SCOUNTRY,
655 LOCALE_SLIST };
656 static const LCTYPE lc_monetary_values[] = {
657 LOCALE_SCURRENCY,
658 LOCALE_ICURRENCY,
659 LOCALE_INEGCURR,
660 LOCALE_ICURRDIGITS,
661 LOCALE_ILZERO };
662 static const LCTYPE lc_numeric_values[] = {
663 LOCALE_SDECIMAL,
664 LOCALE_STHOUSAND,
665 LOCALE_IDIGITS,
666 LOCALE_IDIGITSUBSTITUTION,
667 LOCALE_SNATIVEDIGITS };
668 static const LCTYPE lc_time_values[] = {
669 LOCALE_S1159,
670 LOCALE_S2359,
671 LOCALE_STIME,
672 LOCALE_ITIME,
673 LOCALE_ITLZERO,
674 LOCALE_SSHORTDATE,
675 LOCALE_SLONGDATE,
676 LOCALE_SDATE,
677 LOCALE_ITIMEMARKPOSN,
678 LOCALE_ICALENDARTYPE };
679 static const LCTYPE lc_measurement_values[] = { LOCALE_IMEASURE };
680 static const LCTYPE lc_telephone_values[] = { LOCALE_ICOUNTRY };
681
682 UNICODE_STRING nameW;
683 WCHAR bufferW[80];
684 DWORD count, i;
685 HANDLE hkey;
686 LCID lcid = GetUserDefaultLCID();
687
688 if (!(hkey = create_registry_key()))
689 return; /* don't do anything if we can't create the registry key */
690
691 locale_update_registry( hkey, localeW, lcid_LC_MESSAGES, lc_messages_values,
692 sizeof(lc_messages_values)/sizeof(lc_messages_values[0]) );
693 locale_update_registry( hkey, lc_monetaryW, lcid_LC_MONETARY, lc_monetary_values,
694 sizeof(lc_monetary_values)/sizeof(lc_monetary_values[0]) );
695 locale_update_registry( hkey, lc_numericW, lcid_LC_NUMERIC, lc_numeric_values,
696 sizeof(lc_numeric_values)/sizeof(lc_numeric_values[0]) );
697 locale_update_registry( hkey, lc_timeW, lcid_LC_TIME, lc_time_values,
698 sizeof(lc_time_values)/sizeof(lc_time_values[0]) );
699 locale_update_registry( hkey, lc_measurementW, lcid_LC_MEASUREMENT, lc_measurement_values,
700 sizeof(lc_measurement_values)/sizeof(lc_measurement_values[0]) );
701 locale_update_registry( hkey, lc_telephoneW, lcid_LC_TELEPHONE, lc_telephone_values,
702 sizeof(lc_telephone_values)/sizeof(lc_telephone_values[0]) );
703
704 if (locale_update_registry( hkey, lc_ctypeW, lcid_LC_CTYPE, NULL, 0 ))
705 {
706 HKEY nls_key = NLS_RegOpenSubKey( NLS_RegOpenKey( 0, szNlsKeyName ), CodepageW );
707
708 for (i = 0; i < sizeof(update_cp_values)/sizeof(update_cp_values[0]); i++)
709 {
710 count = GetLocaleInfoW( lcid, update_cp_values[i].value | LOCALE_NOUSEROVERRIDE,
711 bufferW, sizeof(bufferW)/sizeof(WCHAR) );
712 RtlInitUnicodeString( &nameW, update_cp_values[i].name );
713 NtSetValueKey( nls_key, &nameW, 0, REG_SZ, bufferW, count * sizeof(WCHAR) );
714 }
715 NtClose( nls_key );
716 }
717
718 NtClose( hkey );
719 }
720
721
722 /***********************************************************************
723 * setup_unix_locales
724 */
725 static UINT setup_unix_locales(void)
726 {
727 struct locale_name locale_name;
728 WCHAR buffer[128], ctype_buff[128];
729 char *locale;
730 UINT unix_cp = 0;
731
732 if ((locale = setlocale( LC_CTYPE, NULL )))
733 {
734 strcpynAtoW( ctype_buff, locale, sizeof(ctype_buff)/sizeof(WCHAR) );
735 parse_locale_name( ctype_buff, &locale_name );
736 lcid_LC_CTYPE = locale_name.lcid;
737 unix_cp = locale_name.codepage;
738 }
739 if (!lcid_LC_CTYPE) /* this one needs a default value */
740 lcid_LC_CTYPE = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT );
741
742 TRACE( "got lcid %04x (%d matches) for LC_CTYPE=%s\n",
743 locale_name.lcid, locale_name.matches, debugstr_a(locale) );
744
745 #define GET_UNIX_LOCALE(cat) do \
746 if ((locale = setlocale( cat, NULL ))) \
747 { \
748 strcpynAtoW( buffer, locale, sizeof(buffer)/sizeof(WCHAR) ); \
749 if (!strcmpW( buffer, ctype_buff )) lcid_##cat = lcid_LC_CTYPE; \
750 else { \
751 parse_locale_name( buffer, &locale_name ); \
752 lcid_##cat = locale_name.lcid; \
753 TRACE( "got lcid %04x (%d matches) for " #cat "=%s\n", \
754 locale_name.lcid, locale_name.matches, debugstr_a(locale) ); \
755 } \
756 } while (0)
757
758 GET_UNIX_LOCALE( LC_COLLATE );
759 GET_UNIX_LOCALE( LC_MESSAGES );
760 GET_UNIX_LOCALE( LC_MONETARY );
761 GET_UNIX_LOCALE( LC_NUMERIC );
762 GET_UNIX_LOCALE( LC_TIME );
763 #ifdef LC_PAPER
764 GET_UNIX_LOCALE( LC_PAPER );
765 #endif
766 #ifdef LC_MEASUREMENT
767 GET_UNIX_LOCALE( LC_MEASUREMENT );
768 #endif
769 #ifdef LC_TELEPHONE
770 GET_UNIX_LOCALE( LC_TELEPHONE );
771 #endif
772
773 #undef GET_UNIX_LOCALE
774
775 return unix_cp;
776 }
777
778
779 /***********************************************************************
780 * GetUserDefaultLangID (KERNEL32.@)
781 *
782 * Get the default language Id for the current user.
783 *
784 * PARAMS
785 * None.
786 *
787 * RETURNS
788 * The current LANGID of the default language for the current user.
789 */
790 LANGID WINAPI GetUserDefaultLangID(void)
791 {
792 return LANGIDFROMLCID(GetUserDefaultLCID());
793 }
794
795
796 /***********************************************************************
797 * GetSystemDefaultLangID (KERNEL32.@)
798 *
799 * Get the default language Id for the system.
800 *
801 * PARAMS
802 * None.
803 *
804 * RETURNS
805 * The current LANGID of the default language for the system.
806 */
807 LANGID WINAPI GetSystemDefaultLangID(void)
808 {
809 return LANGIDFROMLCID(GetSystemDefaultLCID());
810 }
811
812
813 /***********************************************************************
814 * GetUserDefaultLCID (KERNEL32.@)
815 *
816 * Get the default locale Id for the current user.
817 *
818 * PARAMS
819 * None.
820 *
821 * RETURNS
822 * The current LCID of the default locale for the current user.
823 */
824 LCID WINAPI GetUserDefaultLCID(void)
825 {
826 LCID lcid;
827 NtQueryDefaultLocale( TRUE, &lcid );
828 return lcid;
829 }
830
831
832 /***********************************************************************
833 * GetSystemDefaultLCID (KERNEL32.@)
834 *
835 * Get the default locale Id for the system.
836 *
837 * PARAMS
838 * None.
839 *
840 * RETURNS
841 * The current LCID of the default locale for the system.
842 */
843 LCID WINAPI GetSystemDefaultLCID(void)
844 {
845 LCID lcid;
846 NtQueryDefaultLocale( FALSE, &lcid );
847 return lcid;
848 }
849
850
851 /***********************************************************************
852 * GetUserDefaultUILanguage (KERNEL32.@)
853 *
854 * Get the default user interface language Id for the current user.
855 *
856 * PARAMS
857 * None.
858 *
859 * RETURNS
860 * The current LANGID of the default UI language for the current user.
861 */
862 LANGID WINAPI GetUserDefaultUILanguage(void)
863 {
864 LANGID lang;
865 NtQueryDefaultUILanguage( &lang );
866 return lang;
867 }
868
869
870 /***********************************************************************
871 * GetSystemDefaultUILanguage (KERNEL32.@)
872 *
873 * Get the default user interface language Id for the system.
874 *
875 * PARAMS
876 * None.
877 *
878 * RETURNS
879 * The current LANGID of the default UI language for the system. This is
880 * typically the same language used during the installation process.
881 */
882 LANGID WINAPI GetSystemDefaultUILanguage(void)
883 {
884 LANGID lang;
885 NtQueryInstallUILanguage( &lang );
886 return lang;
887 }
888
889
890 /***********************************************************************
891 * LocaleNameToLCID (KERNEL32.@)
892 */
893 LCID WINAPI LocaleNameToLCID( LPCWSTR name, DWORD flags )
894 {
895 struct locale_name locale_name;
896
897 if (flags) FIXME( "unsupported flags %x\n", flags );
898
899 parse_locale_name( name, &locale_name );
900
901 TRACE( "found lcid %x for %s, matches %d\n",
902 locale_name.lcid, debugstr_w(name), locale_name.matches );
903
904 if (!locale_name.matches)
905 WARN( "locale %s not recognized, defaulting to English\n", debugstr_w(name) );
906 else if (locale_name.matches == 1)
907 WARN( "locale %s not recognized, defaulting to %s\n",
908 debugstr_w(name), debugstr_w(locale_name.lang) );
909
910 return locale_name.lcid;
911 }
912
913
914 /***********************************************************************
915 * LCIDToLocaleName (KERNEL32.@)
916 */
917 INT WINAPI LCIDToLocaleName( LCID lcid, LPWSTR name, INT count, DWORD flags )
918 {
919 if (flags) FIXME( "unsupported flags %x\n", flags );
920
921 return GetLocaleInfoW( lcid, LOCALE_SNAME | LOCALE_NOUSEROVERRIDE, name, count );
922 }
923
924
925 /******************************************************************************
926 * get_locale_value_name
927 *
928 * Gets the registry value name for a given lctype.
929 */
930 static const WCHAR *get_locale_value_name( DWORD lctype )
931 {
932 static const WCHAR iCalendarTypeW[] = {'i','C','a','l','e','n','d','a','r','T','y','p','e',0};
933 static const WCHAR iCountryW[] = {'i','C','o','u','n','t','r','y',0};
934 static const WCHAR iCurrDigitsW[] = {'i','C','u','r','r','D','i','g','i','t','s',0};
935 static const WCHAR iCurrencyW[] = {'i','C','u','r','r','e','n','c','y',0};
936 static const WCHAR iDateW[] = {'i','D','a','t','e',0};
937 static const WCHAR iDigitsW[] = {'i','D','i','g','i','t','s',0};
938 static const WCHAR iFirstDayOfWeekW[] = {'i','F','i','r','s','t','D','a','y','O','f','W','e','e','k',0};
939 static const WCHAR iFirstWeekOfYearW[] = {'i','F','i','r','s','t','W','e','e','k','O','f','Y','e','a','r',0};
940 static const WCHAR iLDateW[] = {'i','L','D','a','t','e',0};
941 static const WCHAR iLZeroW[] = {'i','L','Z','e','r','o',0};
942 static const WCHAR iMeasureW[] = {'i','M','e','a','s','u','r','e',0};
943 static const WCHAR iNegCurrW[] = {'i','N','e','g','C','u','r','r',0};
944 static const WCHAR iNegNumberW[] = {'i','N','e','g','N','u','m','b','e','r',0};
945 static const WCHAR iPaperSizeW[] = {'i','P','a','p','e','r','S','i','z','e',0};
946 static const WCHAR iTLZeroW[] = {'i','T','L','Z','e','r','o',0};
947 static const WCHAR iTimePrefixW[] = {'i','T','i','m','e','P','r','e','f','i','x',0};
948 static const WCHAR iTimeW[] = {'i','T','i','m','e',0};
949 static const WCHAR s1159W[] = {'s','1','1','5','9',0};
950 static const WCHAR s2359W[] = {'s','2','3','5','9',0};
951 static const WCHAR sCountryW[] = {'s','C','o','u','n','t','r','y',0};
952 static const WCHAR sCurrencyW[] = {'s','C','u','r','r','e','n','c','y',0};
953 static const WCHAR sDateW[] = {'s','D','a','t','e',0};
954 static const WCHAR sDecimalW[] = {'s','D','e','c','i','m','a','l',0};
955 static const WCHAR sGroupingW[] = {'s','G','r','o','u','p','i','n','g',0};
956 static const WCHAR sLanguageW[] = {'s','L','a','n','g','u','a','g','e',0};
957 static const WCHAR sListW[] = {'s','L','i','s','t',0};
958 static const WCHAR sLongDateW[] = {'s','L','o','n','g','D','a','t','e',0};
959 static const WCHAR sMonDecimalSepW[] = {'s','M','o','n','D','e','c','i','m','a','l','S','e','p',0};
960 static const WCHAR sMonGroupingW[] = {'s','M','o','n','G','r','o','u','p','i','n','g',0};
961 static const WCHAR sMonThousandSepW[] = {'s','M','o','n','T','h','o','u','s','a','n','d','S','e','p',0};
962 static const WCHAR sNativeDigitsW[] = {'s','N','a','t','i','v','e','D','i','g','i','t','s',0};
963 static const WCHAR sNegativeSignW[] = {'s','N','e','g','a','t','i','v','e','S','i','g','n',0};
964 static const WCHAR sPositiveSignW[] = {'s','P','o','s','i','t','i','v','e','S','i','g','n',0};
965 static const WCHAR sShortDateW[] = {'s','S','h','o','r','t','D','a','t','e',0};
966 static const WCHAR sThousandW[] = {'s','T','h','o','u','s','a','n','d',0};
967 static const WCHAR sTimeFormatW[] = {'s','T','i','m','e','F','o','r','m','a','t',0};
968 static const WCHAR sTimeW[] = {'s','T','i','m','e',0};
969 static const WCHAR sYearMonthW[] = {'s','Y','e','a','r','M','o','n','t','h',0};
970 static const WCHAR NumShapeW[] = {'N','u','m','s','h','a','p','e',0};
971
972 switch (lctype)
973 {
974 /* These values are used by SetLocaleInfo and GetLocaleInfo, and
975 * the values are stored in the registry, confirmed under Windows.
976 */
977 case LOCALE_ICALENDARTYPE: return iCalendarTypeW;
978 case LOCALE_ICURRDIGITS: return iCurrDigitsW;
979 case LOCALE_ICURRENCY: return iCurrencyW;
980 case LOCALE_IDIGITS: return iDigitsW;
981 case LOCALE_IFIRSTDAYOFWEEK: return iFirstDayOfWeekW;
982 case LOCALE_IFIRSTWEEKOFYEAR: return iFirstWeekOfYearW;
983 case LOCALE_ILZERO: return iLZeroW;
984 case LOCALE_IMEASURE: return iMeasureW;
985 case LOCALE_INEGCURR: return iNegCurrW;
986 case LOCALE_INEGNUMBER: return iNegNumberW;
987 case LOCALE_IPAPERSIZE: return iPaperSizeW;
988 case LOCALE_ITIME: return iTimeW;
989 case LOCALE_S1159: return s1159W;
990 case LOCALE_S2359: return s2359W;
991 case LOCALE_SCURRENCY: return sCurrencyW;
992 case LOCALE_SDATE: return sDateW;
993 case LOCALE_SDECIMAL: return sDecimalW;
994 case LOCALE_SGROUPING: return sGroupingW;
995 case LOCALE_SLIST: return sListW;
996 case LOCALE_SLONGDATE: return sLongDateW;
997 case LOCALE_SMONDECIMALSEP: return sMonDecimalSepW;
998 case LOCALE_SMONGROUPING: return sMonGroupingW;
999 case LOCALE_SMONTHOUSANDSEP: return sMonThousandSepW;
1000 case LOCALE_SNEGATIVESIGN: return sNegativeSignW;
1001 case LOCALE_SPOSITIVESIGN: return sPositiveSignW;
1002 case LOCALE_SSHORTDATE: return sShortDateW;
1003 case LOCALE_STHOUSAND: return sThousandW;
1004 case LOCALE_STIME: return sTimeW;
1005 case LOCALE_STIMEFORMAT: return sTimeFormatW;
1006 case LOCALE_SYEARMONTH: return sYearMonthW;
1007
1008 /* The following are not listed under MSDN as supported,
1009 * but seem to be used and also stored in the registry.
1010 */
1011 case LOCALE_ICOUNTRY: return iCountryW;
1012 case LOCALE_IDATE: return iDateW;
1013 case LOCALE_ILDATE: return iLDateW;
1014 case LOCALE_ITLZERO: return iTLZeroW;
1015 case LOCALE_SCOUNTRY: return sCountryW;
1016 case LOCALE_SLANGUAGE: return sLanguageW;
1017
1018 /* The following are used in XP and later */
1019 case LOCALE_IDIGITSUBSTITUTION: return NumShapeW;
1020 case LOCALE_SNATIVEDIGITS: return sNativeDigitsW;
1021 case LOCALE_ITIMEMARKPOSN: return iTimePrefixW;
1022 }
1023 return NULL;
1024 }
1025
1026
1027 /******************************************************************************
1028 * get_registry_locale_info
1029 *
1030 * Retrieve user-modified locale info from the registry.
1031 * Return length, 0 on error, -1 if not found.
1032 */
1033 static INT get_registry_locale_info( LPCWSTR value, LPWSTR buffer, INT len )
1034 {
1035 DWORD size;
1036 INT ret;
1037 HANDLE hkey;
1038 NTSTATUS status;
1039 UNICODE_STRING nameW;
1040 KEY_VALUE_PARTIAL_INFORMATION *info;
1041 static const int info_size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
1042
1043 if (!(hkey = create_registry_key())) return -1;
1044
1045 RtlInitUnicodeString( &nameW, value );
1046 size = info_size + len * sizeof(WCHAR);
1047
1048 if (!(info = HeapAlloc( GetProcessHeap(), 0, size )))
1049 {
1050 NtClose( hkey );
1051 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1052 return 0;
1053 }
1054
1055 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, info, size, &size );
1056
1057 if (!status)
1058 {
1059 ret = (size - info_size) / sizeof(WCHAR);
1060 /* append terminating null if needed */
1061 if (!ret || ((WCHAR *)info->Data)[ret-1])
1062 {
1063 if (ret < len || !buffer) ret++;
1064 else
1065 {
1066 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1067 ret = 0;
1068 }
1069 }
1070 if (ret && buffer)
1071 {
1072 memcpy( buffer, info->Data, (ret-1) * sizeof(WCHAR) );
1073 buffer[ret-1] = 0;
1074 }
1075 }
1076 else if (status == STATUS_BUFFER_OVERFLOW && !buffer)
1077 {
1078 ret = (size - info_size) / sizeof(WCHAR) + 1;
1079 }
1080 else if (status == STATUS_OBJECT_NAME_NOT_FOUND)
1081 {
1082 ret = -1;
1083 }
1084 else
1085 {
1086 SetLastError( RtlNtStatusToDosError(status) );
1087 ret = 0;
1088 }
1089 NtClose( hkey );
1090 HeapFree( GetProcessHeap(), 0, info );
1091 return ret;
1092 }
1093
1094
1095 /******************************************************************************
1096 * GetLocaleInfoA (KERNEL32.@)
1097 *
1098 * Get information about an aspect of a locale.
1099 *
1100 * PARAMS
1101 * lcid [I] LCID of the locale
1102 * lctype [I] LCTYPE_ flags from "winnls.h"
1103 * buffer [O] Destination for the information
1104 * len [I] Length of buffer in characters
1105 *
1106 * RETURNS
1107 * Success: The size of the data requested. If buffer is non-NULL, it is filled
1108 * with the information.
1109 * Failure: 0. Use GetLastError() to determine the cause.
1110 *
1111 * NOTES
1112 * - LOCALE_NEUTRAL is equal to LOCALE_SYSTEM_DEFAULT
1113 * - The string returned is NUL terminated, except for LOCALE_FONTSIGNATURE,
1114 * which is a bit string.
1115 */
1116 INT WINAPI GetLocaleInfoA( LCID lcid, LCTYPE lctype, LPSTR buffer, INT len )
1117 {
1118 WCHAR *bufferW;
1119 INT lenW, ret;
1120
1121 TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d)\n", lcid, lctype, buffer, len );
1122
1123 if (len < 0 || (len && !buffer))
1124 {
1125 SetLastError( ERROR_INVALID_PARAMETER );
1126 return 0;
1127 }
1128 if (!len) buffer = NULL;
1129
1130 if (!(lenW = GetLocaleInfoW( lcid, lctype, NULL, 0 ))) return 0;
1131
1132 if (!(bufferW = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
1133 {
1134 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1135 return 0;
1136 }
1137 if ((ret = GetLocaleInfoW( lcid, lctype, bufferW, lenW )))
1138 {
1139 if ((lctype & LOCALE_RETURN_NUMBER) ||
1140 ((lctype & ~LOCALE_LOCALEINFOFLAGSMASK) == LOCALE_FONTSIGNATURE))
1141 {
1142 /* it's not an ASCII string, just bytes */
1143 ret *= sizeof(WCHAR);
1144 if (buffer)
1145 {
1146 if (ret <= len) memcpy( buffer, bufferW, ret );
1147 else
1148 {
1149 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1150 ret = 0;
1151 }
1152 }
1153 }
1154 else
1155 {
1156 UINT codepage = CP_ACP;
1157 if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
1158 ret = WideCharToMultiByte( codepage, 0, bufferW, ret, buffer, len, NULL, NULL );
1159 }
1160 }
1161 HeapFree( GetProcessHeap(), 0, bufferW );
1162 return ret;
1163 }
1164
1165
1166 /******************************************************************************
1167 * GetLocaleInfoW (KERNEL32.@)
1168 *
1169 * See GetLocaleInfoA.
1170 */
1171 INT WINAPI GetLocaleInfoW( LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len )
1172 {
1173 LANGID lang_id;
1174 HRSRC hrsrc;
1175 HGLOBAL hmem;
1176 INT ret;
1177 UINT lcflags;
1178 const WCHAR *p;
1179 unsigned int i;
1180
1181 if (len < 0 || (len && !buffer))
1182 {
1183 SetLastError( ERROR_INVALID_PARAMETER );
1184 return 0;
1185 }
1186 if (!len) buffer = NULL;
1187
1188 lcid = convert_default_lcid( lcid, lctype );
1189
1190 lcflags = lctype & LOCALE_LOCALEINFOFLAGSMASK;
1191 lctype &= 0xffff;
1192
1193 TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d)\n", lcid, lctype, buffer, len );
1194
1195 /* first check for overrides in the registry */
1196
1197 if (!(lcflags & LOCALE_NOUSEROVERRIDE) &&
1198 lcid == convert_default_lcid( LOCALE_USER_DEFAULT, lctype ))
1199 {
1200 const WCHAR *value = get_locale_value_name(lctype);
1201
1202 if (value)
1203 {
1204 if (lcflags & LOCALE_RETURN_NUMBER)
1205 {
1206 WCHAR tmp[16];
1207 ret = get_registry_locale_info( value, tmp, sizeof(tmp)/sizeof(WCHAR) );
1208 if (ret > 0)
1209 {
1210 WCHAR *end;
1211 UINT number = strtolW( tmp, &end, 10 );
1212 if (*end) /* invalid number */
1213 {
1214 SetLastError( ERROR_INVALID_FLAGS );
1215 return 0;
1216 }
1217 ret = sizeof(UINT)/sizeof(WCHAR);
1218 if (!buffer) return ret;
1219 if (ret > len)
1220 {
1221 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1222 return 0;
1223 }
1224 memcpy( buffer, &number, sizeof(number) );
1225 }
1226 }
1227 else ret = get_registry_locale_info( value, buffer, len );
1228
1229 if (ret != -1) return ret;
1230 }
1231 }
1232
1233 /* now load it from kernel resources */
1234
1235 lang_id = LANGIDFROMLCID( lcid );
1236
1237 /* replace SUBLANG_NEUTRAL by SUBLANG_DEFAULT */
1238 if (SUBLANGID(lang_id) == SUBLANG_NEUTRAL)
1239 lang_id = MAKELANGID(PRIMARYLANGID(lang_id), SUBLANG_DEFAULT);
1240
1241 if (!(hrsrc = FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING,
1242 (LPCWSTR)((lctype >> 4) + 1), lang_id )))
1243 {
1244 SetLastError( ERROR_INVALID_FLAGS ); /* no such lctype */
1245 return 0;
1246 }
1247 if (!(hmem = LoadResource( kernel32_handle, hrsrc )))
1248 return 0;
1249
1250 p = LockResource( hmem );
1251 for (i = 0; i < (lctype & 0x0f); i++) p += *p + 1;
1252
1253 if (lcflags & LOCALE_RETURN_NUMBER) ret = sizeof(UINT)/sizeof(WCHAR);
1254 else ret = (lctype == LOCALE_FONTSIGNATURE) ? *p : *p + 1;
1255
1256 if (!buffer) return ret;
1257
1258 if (ret > len)
1259 {
1260 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1261 return 0;
1262 }
1263
1264 if (lcflags & LOCALE_RETURN_NUMBER)
1265 {
1266 UINT number;
1267 WCHAR *end, *tmp = HeapAlloc( GetProcessHeap(), 0, (*p + 1) * sizeof(WCHAR) );
1268 if (!tmp) return 0;
1269 memcpy( tmp, p + 1, *p * sizeof(WCHAR) );
1270 tmp[*p] = 0;
1271 number = strtolW( tmp, &end, 10 );
1272 if (!*end)
1273 memcpy( buffer, &number, sizeof(number) );
1274 else /* invalid number */
1275 {
1276 SetLastError( ERROR_INVALID_FLAGS );
1277 ret = 0;
1278 }
1279 HeapFree( GetProcessHeap(), 0, tmp );
1280
1281 TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning number %d\n",
1282 lcid, lctype, buffer, len, number );
1283 }
1284 else
1285 {
1286 memcpy( buffer, p + 1, *p * sizeof(WCHAR) );
1287 if (lctype != LOCALE_FONTSIGNATURE) buffer[ret-1] = 0;
1288
1289 TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning %d %s\n",
1290 lcid, lctype, buffer, len, ret, debugstr_w(buffer) );
1291 }
1292 return ret;
1293 }
1294
1295
1296 /******************************************************************************
1297 * SetLocaleInfoA [KERNEL32.@]
1298 *
1299 * Set information about an aspect of a locale.
1300 *
1301 * PARAMS
1302 * lcid [I] LCID of the locale
1303 * lctype [I] LCTYPE_ flags from "winnls.h"
1304 * data [I] Information to set
1305 *
1306 * RETURNS
1307 * Success: TRUE. The information given will be returned by GetLocaleInfoA()
1308 * whenever it is called without LOCALE_NOUSEROVERRIDE.
1309 * Failure: FALSE. Use GetLastError() to determine the cause.
1310 *
1311 * NOTES
1312 * - Values are only be set for the current user locale; the system locale
1313 * settings cannot be changed.
1314 * - Any settings changed by this call are lost when the locale is changed by
1315 * the control panel (in Wine, this happens every time you change LANG).
1316 * - The native implementation of this function does not check that lcid matches
1317 * the current user locale, and simply sets the new values. Wine warns you in
1318 * this case, but behaves the same.
1319 */
1320 BOOL WINAPI SetLocaleInfoA(LCID lcid, LCTYPE lctype, LPCSTR data)
1321 {
1322 UINT codepage = CP_ACP;
1323 WCHAR *strW;
1324 DWORD len;
1325 BOOL ret;
1326
1327 if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
1328
1329 if (!data)
1330 {
1331 SetLastError( ERROR_INVALID_PARAMETER );
1332 return FALSE;
1333 }
1334 len = MultiByteToWideChar( codepage, 0, data, -1, NULL, 0 );
1335 if (!(strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1336 {
1337 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1338 return FALSE;
1339 }
1340 MultiByteToWideChar( codepage, 0, data, -1, strW, len );
1341 ret = SetLocaleInfoW( lcid, lctype, strW );
1342 HeapFree( GetProcessHeap(), 0, strW );
1343 return ret;
1344 }
1345
1346
1347 /******************************************************************************
1348 * SetLocaleInfoW (KERNEL32.@)
1349 *
1350 * See SetLocaleInfoA.
1351 */
1352 BOOL WINAPI SetLocaleInfoW( LCID lcid, LCTYPE lctype, LPCWSTR data )
1353 {
1354 const WCHAR *value;
1355 static const WCHAR intlW[] = {'i','n','t','l',0 };
1356 UNICODE_STRING valueW;
1357 NTSTATUS status;
1358 HANDLE hkey;
1359
1360 lctype &= 0xffff;
1361 value = get_locale_value_name( lctype );
1362
1363 if (!data || !value)
1364 {
1365 SetLastError( ERROR_INVALID_PARAMETER );
1366 return FALSE;
1367 }
1368
1369 if (lctype == LOCALE_IDATE || lctype == LOCALE_ILDATE)
1370 {
1371 SetLastError( ERROR_INVALID_FLAGS );
1372 return FALSE;
1373 }
1374
1375 TRACE("setting %x (%s) to %s\n", lctype, debugstr_w(value), debugstr_w(data) );
1376
1377 /* FIXME: should check that data to set is sane */
1378
1379 /* FIXME: profile functions should map to registry */
1380 WriteProfileStringW( intlW, value, data );
1381
1382 if (!(hkey = create_registry_key())) return FALSE;
1383 RtlInitUnicodeString( &valueW, value );
1384 status = NtSetValueKey( hkey, &valueW, 0, REG_SZ, data, (strlenW(data)+1)*sizeof(WCHAR) );
1385
1386 if (lctype == LOCALE_SSHORTDATE || lctype == LOCALE_SLONGDATE)
1387 {
1388 /* Set I-value from S value */
1389 WCHAR *lpD, *lpM, *lpY;
1390 WCHAR szBuff[2];
1391
1392 lpD = strrchrW(data, 'd');
1393 lpM = strrchrW(data, 'M');
1394 lpY = strrchrW(data, 'y');
1395
1396 if (lpD <= lpM)
1397 {
1398 szBuff[0] = '1'; /* D-M-Y */
1399 }
1400 else
1401 {
1402 if (lpY <= lpM)
1403 szBuff[0] = '2'; /* Y-M-D */
1404 else
1405 szBuff[0] = '0'; /* M-D-Y */
1406 }
1407
1408 szBuff[1] = '\0';
1409
1410 if (lctype == LOCALE_SSHORTDATE)
1411 lctype = LOCALE_IDATE;
1412 else
1413 lctype = LOCALE_ILDATE;
1414
1415 value = get_locale_value_name( lctype );
1416
1417 WriteProfileStringW( intlW, value, szBuff );
1418
1419 RtlInitUnicodeString( &valueW, value );
1420 status = NtSetValueKey( hkey, &valueW, 0, REG_SZ, szBuff, sizeof(szBuff) );
1421 }
1422
1423 NtClose( hkey );
1424
1425 if (status) SetLastError( RtlNtStatusToDosError(status) );
1426 return !status;
1427 }
1428
1429
1430 /******************************************************************************
1431 * GetACP (KERNEL32.@)
1432 *
1433 * Get the current Ansi code page Id for the system.
1434 *
1435 * PARAMS
1436 * None.
1437 *
1438 * RETURNS
1439 * The current Ansi code page identifier for the system.
1440 */
1441 UINT WINAPI GetACP(void)
1442 {
1443 assert( ansi_cptable );
1444 return ansi_cptable->info.codepage;
1445 }
1446
1447
1448 /******************************************************************************
1449 * SetCPGlobal (KERNEL32.@)
1450 *
1451 * Set the current Ansi code page Id for the system.
1452 *
1453 * PARAMS
1454 * acp [I] code page ID to be the new ACP.
1455 *
1456 * RETURNS
1457 * The previous ACP.
1458 */
1459 UINT WINAPI SetCPGlobal( UINT acp )
1460 {
1461 UINT ret = GetACP();
1462 const union cptable *new_cptable = wine_cp_get_table( acp );
1463
1464 if (new_cptable) ansi_cptable = new_cptable;
1465 return ret;
1466 }
1467
1468
1469 /***********************************************************************
1470 * GetOEMCP (KERNEL32.@)
1471 *
1472 * Get the current OEM code page Id for the system.
1473 *
1474 * PARAMS
1475 * None.
1476 *
1477 * RETURNS
1478 * The current OEM code page identifier for the system.
1479 */
1480 UINT WINAPI GetOEMCP(void)
1481 {
1482 assert( oem_cptable );
1483 return oem_cptable->info.codepage;
1484 }
1485
1486
1487 /***********************************************************************
1488 * IsValidCodePage (KERNEL32.@)
1489 *
1490 * Determine if a given code page identifier is valid.
1491 *
1492 * PARAMS
1493 * codepage [I] Code page Id to verify.
1494 *
1495 * RETURNS
1496 * TRUE, If codepage is valid and available on the system,
1497 * FALSE otherwise.
1498 */
1499 BOOL WINAPI IsValidCodePage( UINT codepage )
1500 {
1501 switch(codepage) {
1502 case CP_UTF7:
1503 case CP_UTF8:
1504 return TRUE;
1505 default:
1506 return wine_cp_get_table( codepage ) != NULL;
1507 }
1508 }
1509
1510
1511 /***********************************************************************
1512 * IsDBCSLeadByteEx (KERNEL32.@)
1513 *
1514 * Determine if a character is a lead byte in a given code page.
1515 *
1516 * PARAMS
1517 * codepage [I] Code page for the test.
1518 * testchar [I] Character to test
1519 *
1520 * RETURNS
1521 * TRUE, if testchar is a lead byte in codepage,
1522 * FALSE otherwise.
1523 */
1524 BOOL WINAPI IsDBCSLeadByteEx( UINT codepage, BYTE testchar )
1525 {
1526 const union cptable *table = get_codepage_table( codepage );
1527 return table && wine_is_dbcs_leadbyte( table, testchar );
1528 }
1529
1530
1531 /***********************************************************************
1532 * IsDBCSLeadByte (KERNEL32.@)
1533 * IsDBCSLeadByte (KERNEL.207)
1534 *
1535 * Determine if a character is a lead byte.
1536 *
1537 * PARAMS
1538 * testchar [I] Character to test
1539 *
1540 * RETURNS
1541 * TRUE, if testchar is a lead byte in the Ansii code page,
1542 * FALSE otherwise.
1543 */
1544 BOOL WINAPI IsDBCSLeadByte( BYTE testchar )
1545 {
1546 if (!ansi_cptable) return FALSE;
1547 return wine_is_dbcs_leadbyte( ansi_cptable, testchar );
1548 }
1549
1550
1551 /***********************************************************************
1552 * GetCPInfo (KERNEL32.@)
1553 *
1554 * Get information about a code page.
1555 *
1556 * PARAMS
1557 * codepage [I] Code page number
1558 * cpinfo [O] Destination for code page information
1559 *
1560 * RETURNS
1561 * Success: TRUE. cpinfo is updated with the information about codepage.
1562 * Failure: FALSE, if codepage is invalid or cpinfo is NULL.
1563 */
1564 BOOL WINAPI GetCPInfo( UINT codepage, LPCPINFO cpinfo )
1565 {
1566 const union cptable *table;
1567
1568 if (!cpinfo)
1569 {
1570 SetLastError( ERROR_INVALID_PARAMETER );
1571 return FALSE;
1572 }
1573
1574 if (!(table = get_codepage_table( codepage )))
1575 {
1576 switch(codepage)
1577 {
1578 case CP_UTF7:
1579 case CP_UTF8:
1580 cpinfo->DefaultChar[0] = 0x3f;
1581 cpinfo->DefaultChar[1] = 0;
1582 cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
1583 cpinfo->MaxCharSize = (codepage == CP_UTF7) ? 5 : 4;
1584 return TRUE;
1585 }
1586
1587 SetLastError( ERROR_INVALID_PARAMETER );
1588 return FALSE;
1589 }
1590 if (table->info.def_char & 0xff00)
1591 {
1592 cpinfo->DefaultChar[0] = (table->info.def_char & 0xff00) >> 8;
1593 cpinfo->DefaultChar[1] = table->info.def_char & 0x00ff;
1594 }
1595 else
1596 {
1597 cpinfo->DefaultChar[0] = table->info.def_char & 0xff;
1598 cpinfo->DefaultChar[1] = 0;
1599 }
1600 if ((cpinfo->MaxCharSize = table->info.char_size) == 2)
1601 memcpy( cpinfo->LeadByte, table->dbcs.lead_bytes, sizeof(cpinfo->LeadByte) );
1602 else
1603 cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
1604
1605 return TRUE;
1606 }
1607
1608 /***********************************************************************
1609 * GetCPInfoExA (KERNEL32.@)
1610 *
1611 * Get extended information about a code page.
1612 *
1613 * PARAMS
1614 * codepage [I] Code page number
1615 * dwFlags [I] Reserved, must to 0.
1616 * cpinfo [O] Destination for code page information
1617 *
1618 * RETURNS
1619 * Success: TRUE. cpinfo is updated with the information about codepage.
1620 * Failure: FALSE, if codepage is invalid or cpinfo is NULL.
1621 */
1622 BOOL WINAPI GetCPInfoExA( UINT codepage, DWORD dwFlags, LPCPINFOEXA cpinfo )
1623 {
1624 CPINFOEXW cpinfoW;
1625
1626 if (!GetCPInfoExW( codepage, dwFlags, &cpinfoW ))
1627 return FALSE;
1628
1629 /* the layout is the same except for CodePageName */
1630 memcpy(cpinfo, &cpinfoW, sizeof(CPINFOEXA));
1631 WideCharToMultiByte(CP_ACP, 0, cpinfoW.CodePageName, -1, cpinfo->CodePageName, sizeof(cpinfo->CodePageName), NULL, NULL);
1632 return TRUE;
1633 }
1634
1635 /***********************************************************************
1636 * GetCPInfoExW (KERNEL32.@)
1637 *
1638 * Unicode version of GetCPInfoExA.
1639 */
1640 BOOL WINAPI GetCPInfoExW( UINT codepage, DWORD dwFlags, LPCPINFOEXW cpinfo )
1641 {
1642 if (!GetCPInfo( codepage, (LPCPINFO)cpinfo ))
1643 return FALSE;
1644
1645 switch(codepage)
1646 {
1647 case CP_UTF7:
1648 {
1649 static const WCHAR utf7[] = {'U','n','i','c','o','d','e',' ','(','U','T','F','-','7',')',0};
1650
1651 cpinfo->CodePage = CP_UTF7;
1652 cpinfo->UnicodeDefaultChar = 0x3f;
1653 strcpyW(cpinfo->CodePageName, utf7);
1654 break;
1655 }
1656
1657 case CP_UTF8:
1658 {
1659 static const WCHAR utf8[] = {'U','n','i','c','o','d','e',' ','(','U','T','F','-','8',')',0};
1660
1661 cpinfo->CodePage = CP_UTF8;
1662 cpinfo->UnicodeDefaultChar = 0x3f;
1663 strcpyW(cpinfo->CodePageName, utf8);
1664 break;
1665 }
1666
1667 default:
1668 {
1669 const union cptable *table = get_codepage_table( codepage );
1670
1671 cpinfo->CodePage = table->info.codepage;
1672 cpinfo->UnicodeDefaultChar = table->info.def_unicode_char;
1673 MultiByteToWideChar( CP_ACP, 0, table->info.name, -1, cpinfo->CodePageName,
1674 sizeof(cpinfo->CodePageName)/sizeof(WCHAR));
1675 break;
1676 }
1677 }
1678 return TRUE;
1679 }
1680
1681 /***********************************************************************
1682 * EnumSystemCodePagesA (KERNEL32.@)
1683 *
1684 * Call a user defined function for every code page installed on the system.
1685 *
1686 * PARAMS
1687 * lpfnCodePageEnum [I] User CODEPAGE_ENUMPROC to call with each found code page
1688 * flags [I] Reserved, set to 0.
1689 *
1690 * RETURNS
1691 * TRUE, If all code pages have been enumerated, or
1692 * FALSE if lpfnCodePageEnum returned FALSE to stop the enumeration.
1693 */
1694 BOOL WINAPI EnumSystemCodePagesA( CODEPAGE_ENUMPROCA lpfnCodePageEnum, DWORD flags )
1695 {
1696 const union cptable *table;
1697 char buffer[10];
1698 int index = 0;
1699
1700 for (;;)
1701 {
1702 if (!(table = wine_cp_enum_table( index++ ))) break;
1703 sprintf( buffer, "%d", table->info.codepage );
1704 if (!lpfnCodePageEnum( buffer )) break;
1705 }
1706 return TRUE;
1707 }
1708
1709
1710 /***********************************************************************
1711 * EnumSystemCodePagesW (KERNEL32.@)
1712 *
1713 * See EnumSystemCodePagesA.
1714 */
1715 BOOL WINAPI EnumSystemCodePagesW( CODEPAGE_ENUMPROCW lpfnCodePageEnum, DWORD flags )
1716 {
1717 const union cptable *table;
1718 WCHAR buffer[10], *p;
1719 int page, index = 0;
1720
1721 for (;;)
1722 {
1723 if (!(table = wine_cp_enum_table( index++ ))) break;
1724 p = buffer + sizeof(buffer)/sizeof(WCHAR);
1725 *--p = 0;
1726 page = table->info.codepage;
1727 do
1728 {
1729 *--p = '0' + (page % 10);
1730 page /= 10;
1731 } while( page );
1732 if (!lpfnCodePageEnum( p )) break;
1733 }
1734 return TRUE;
1735 }
1736
1737
1738 /***********************************************************************
1739 * MultiByteToWideChar (KERNEL32.@)
1740 *
1741 * Convert a multibyte character string into a Unicode string.
1742 *
1743 * PARAMS
1744 * page [I] Codepage character set to convert from
1745 * flags [I] Character mapping flags
1746 * src [I] Source string buffer
1747 * srclen [I] Length of src, or -1 if src is NUL terminated
1748 * dst [O] Destination buffer
1749 * dstlen [I] Length of dst, or 0 to compute the required length
1750 *
1751 * RETURNS
1752 * Success: If dstlen > 0, the number of characters written to dst.
1753 * If dstlen == 0, the number of characters needed to perform the
1754 * conversion. In both cases the count includes the terminating NUL.
1755 * Failure: 0. Use GetLastError() to determine the cause. Possible errors are
1756 * ERROR_INSUFFICIENT_BUFFER, if not enough space is available in dst
1757 * and dstlen != 0; ERROR_INVALID_PARAMETER, if an invalid parameter
1758 * is passed, and ERROR_NO_UNICODE_TRANSLATION if no translation is
1759 * possible for src.
1760 */
1761 INT WINAPI MultiByteToWideChar( UINT page, DWORD flags, LPCSTR src, INT srclen,
1762 LPWSTR dst, INT dstlen )
1763 {
1764 const union cptable *table;
1765 int ret;
1766 static int once;
1767
1768 if (!src || (!dst && dstlen))
1769 {
1770 SetLastError( ERROR_INVALID_PARAMETER );
1771 return 0;
1772 }
1773
1774 if (srclen < 0) srclen = strlen(src) + 1;
1775
1776 if (!once && (flags & MB_USEGLYPHCHARS))
1777 {
1778 once = 1;
1779 FIXME("MB_USEGLYPHCHARS not supported\n");
1780 }
1781
1782 switch(page)
1783 {
1784 case CP_SYMBOL:
1785 if( flags)
1786 {
1787 SetLastError( ERROR_INVALID_PARAMETER );
1788 return 0;
1789 }
1790 ret = wine_cpsymbol_mbstowcs( src, srclen, dst, dstlen );
1791 break;
1792 case CP_UTF7:
1793 FIXME("UTF-7 not supported\n");
1794 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1795 return 0;
1796 case CP_UNIXCP:
1797 if (unix_cptable)
1798 {
1799 ret = wine_cp_mbstowcs( unix_cptable, flags, src, srclen, dst, dstlen );
1800 break;
1801 }
1802 /* fall through */
1803 case CP_UTF8:
1804 ret = wine_utf8_mbstowcs( flags, src, srclen, dst, dstlen );
1805 break;
1806 default:
1807 if (!(table = get_codepage_table( page )))
1808 {
1809 SetLastError( ERROR_INVALID_PARAMETER );
1810 return 0;
1811 }
1812 ret = wine_cp_mbstowcs( table, flags, src, srclen, dst, dstlen );
1813 break;
1814 }
1815
1816 if (ret < 0)
1817 {
1818 switch(ret)
1819 {
1820 case -1: SetLastError( ERROR_INSUFFICIENT_BUFFER ); break;
1821 case -2: SetLastError( ERROR_NO_UNICODE_TRANSLATION ); break;
1822 }
1823 ret = 0;
1824 }
1825 return ret;
1826 }
1827
1828
1829 /***********************************************************************
1830 * WideCharToMultiByte (KERNEL32.@)
1831 *
1832 * Convert a Unicode character string into a multibyte string.
1833 *
1834 * PARAMS
1835 * page [I] Code page character set to convert to
1836 * flags [I] Mapping Flags (MB_ constants from "winnls.h").
1837 * src [I] Source string buffer
1838 * srclen [I] Length of src, or -1 if src is NUL terminated
1839 * dst [O] Destination buffer
1840 * dstlen [I] Length of dst, or 0 to compute the required length
1841 * defchar [I] Default character to use for conversion if no exact
1842 * conversion can be made
1843 * used [O] Set if default character was used in the conversion
1844 *
1845 * RETURNS
1846 * Success: If dstlen > 0, the number of characters written to dst.
1847 * If dstlen == 0, number of characters needed to perform the
1848 * conversion. In both cases the count includes the terminating NUL.
1849 * Failure: 0. Use GetLastError() to determine the cause. Possible errors are
1850 * ERROR_INSUFFICIENT_BUFFER, if not enough space is available in dst
1851 * and dstlen != 0, and ERROR_INVALID_PARAMETER, if an invalid
1852 * parameter was given.
1853 */
1854 INT WINAPI WideCharToMultiByte( UINT page, DWORD flags, LPCWSTR src, INT srclen,
1855 LPSTR dst, INT dstlen, LPCSTR defchar, BOOL *used )
1856 {
1857 const union cptable *table;
1858 int ret, used_tmp;
1859
1860 if (!src || (!dst && dstlen))
1861 {
1862 SetLastError( ERROR_INVALID_PARAMETER );
1863 return 0;
1864 }
1865
1866 if (srclen < 0) srclen = strlenW(src) + 1;
1867
1868 switch(page)
1869 {
1870 case CP_SYMBOL:
1871 if( flags || defchar || used)
1872 {
1873 SetLastError( ERROR_INVALID_PARAMETER );
1874 return 0;
1875 }
1876 ret = wine_cpsymbol_wcstombs( src, srclen, dst, dstlen );
1877 break;
1878 case CP_UTF7:
1879 FIXME("UTF-7 not supported\n");
1880 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1881 return 0;
1882 case CP_UNIXCP:
1883 if (unix_cptable)
1884 {
1885 ret = wine_cp_wcstombs( unix_cptable, flags, src, srclen, dst, dstlen,
1886 defchar, used ? &used_tmp : NULL );
1887 break;
1888 }
1889 /* fall through */
1890 case CP_UTF8:
1891 if (used) *used = FALSE; /* all chars are valid for UTF-8 */
1892 ret = wine_utf8_wcstombs( src, srclen, dst, dstlen );
1893 break;
1894 default:
1895 if (!(table = get_codepage_table( page )))
1896 {
1897 SetLastError( ERROR_INVALID_PARAMETER );
1898 return 0;
1899 }
1900 ret = wine_cp_wcstombs( table, flags, src, srclen, dst, dstlen,
1901 defchar, used ? &used_tmp : NULL );
1902 if (used) *used = used_tmp;
1903 break;
1904 }
1905
1906 if (ret < 0)
1907 {
1908 switch(ret)
1909 {
1910 case -1: SetLastError( ERROR_INSUFFICIENT_BUFFER ); break;
1911 case -2: SetLastError( ERROR_NO_UNICODE_TRANSLATION ); break;
1912 }
1913 ret = 0;
1914 }
1915 TRACE("cp %d %s -> %s, ret = %d\n",
1916 page, debugstr_wn(src, srclen), debugstr_an(dst, ret), ret);
1917 return ret;
1918 }
1919
1920
1921 /***********************************************************************
1922 * GetThreadLocale (KERNEL32.@)
1923 *
1924 * Get the current threads locale.
1925 *
1926 * PARAMS
1927 * None.
1928 *
1929 * RETURNS
1930 * The LCID currently assocated with the calling thread.
1931 */
1932 LCID WINAPI GetThreadLocale(void)
1933 {
1934 LCID ret = NtCurrentTeb()->CurrentLocale;
1935 if (!ret) NtCurrentTeb()->CurrentLocale = ret = GetUserDefaultLCID();
1936 return ret;
1937 }
1938
1939 /**********************************************************************
1940 * SetThreadLocale (KERNEL32.@)
1941 *
1942 * Set the current threads locale.
1943 *
1944 * PARAMS
1945 * lcid [I] LCID of the locale to set
1946 *
1947 * RETURNS
1948 * Success: TRUE. The threads locale is set to lcid.
1949 * Failure: FALSE. Use GetLastError() to determine the cause.
1950 */
1951 BOOL WINAPI SetThreadLocale( LCID lcid )
1952 {
1953 TRACE("(0x%04X)\n", lcid);
1954
1955 lcid = ConvertDefaultLocale(lcid);
1956
1957 if (lcid != GetThreadLocale())
1958 {
1959 if (!IsValidLocale(lcid, LCID_SUPPORTED))
1960 {
1961 SetLastError(ERROR_INVALID_PARAMETER);
1962 return FALSE;
1963 }
1964
1965 NtCurrentTeb()->CurrentLocale = lcid;
1966 kernel_get_thread_data()->code_page = get_lcid_codepage( lcid );
1967 }
1968 return TRUE;
1969 }
1970
1971 /**********************************************************************
1972 * SetThreadUILanguage (KERNEL32.@)
1973 *
1974 * Set the current threads UI language.
1975 *
1976 * PARAMS
1977 * langid [I] LANGID of the language to set, or 0 to use
1978 * the available language which is best supported
1979 * for console applications
1980 *
1981 * RETURNS
1982 * Success: The return value is the same as the input value.
1983 * Failure: The return value differs from the input value.
1984 * Use GetLastError() to determine the cause.
1985 */
1986 LANGID WINAPI SetThreadUILanguage( LANGID langid )
1987 {
1988 TRACE("(0x%04x) stub - returning success\n", langid);
1989 return langid;
1990 }
1991
1992 /******************************************************************************
1993 * ConvertDefaultLocale (KERNEL32.@)
1994 *
1995 * Convert a default locale identifier into a real identifier.
1996 *
1997 * PARAMS
1998 * lcid [I] LCID identifier of the locale to convert
1999 *
2000 * RETURNS
2001 * lcid unchanged, if not a default locale or its sublanguage is
2002 * not SUBLANG_NEUTRAL.
2003 * GetSystemDefaultLCID(), if lcid == LOCALE_SYSTEM_DEFAULT.
2004 * GetUserDefaultLCID(), if lcid == LOCALE_USER_DEFAULT or LOCALE_NEUTRAL.
2005 * Otherwise, lcid with sublanguage changed to SUBLANG_DEFAULT.
2006 */
2007 LCID WINAPI ConvertDefaultLocale( LCID lcid )
2008 {
2009 LANGID langid;
2010
2011 switch (lcid)
2012 {
2013 case LOCALE_SYSTEM_DEFAULT:
2014 lcid = GetSystemDefaultLCID();
2015 break;
2016 case LOCALE_USER_DEFAULT:
2017 case LOCALE_NEUTRAL:
2018 lcid = GetUserDefaultLCID();
2019 break;
2020 default:
2021 /* Replace SUBLANG_NEUTRAL with SUBLANG_DEFAULT */
2022 langid = LANGIDFROMLCID(lcid);
2023 if (SUBLANGID(langid) == SUBLANG_NEUTRAL)
2024 {
2025 langid = MAKELANGID(PRIMARYLANGID(langid), SUBLANG_DEFAULT);
2026 lcid = MAKELCID(langid, SORTIDFROMLCID(lcid));
2027 }
2028 }
2029 return lcid;
2030 }
2031
2032
2033 /******************************************************************************
2034 * IsValidLocale (KERNEL32.@)
2035 *
2036 * Determine if a locale is valid.
2037 *
2038 * PARAMS
2039 * lcid [I] LCID of the locale to check
2040 * flags [I] LCID_SUPPORTED = Valid, LCID_INSTALLED = Valid and installed on the system
2041 *
2042 * RETURNS
2043 * TRUE, if lcid is valid,
2044 * FALSE, otherwise.
2045 *
2046 * NOTES
2047 * Wine does not currently make the distinction between supported and installed. All
2048 * languages supported are installed by default.
2049 */
2050 BOOL WINAPI IsValidLocale( LCID lcid, DWORD flags )
2051 {
2052 /* check if language is registered in the kernel32 resources */
2053 return FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING,
2054 (LPCWSTR)LOCALE_ILANGUAGE, LANGIDFROMLCID(lcid)) != 0;
2055 }
2056
2057
2058 static BOOL CALLBACK enum_lang_proc_a( HMODULE hModule, LPCSTR type,
2059 LPCSTR name, WORD LangID, LONG_PTR lParam )
2060 {
2061 LOCALE_ENUMPROCA lpfnLocaleEnum = (LOCALE_ENUMPROCA)lParam;
2062 char buf[20];
2063
2064 sprintf(buf, "%08x", (UINT)LangID);
2065 return lpfnLocaleEnum( buf );
2066 }
2067
2068 static BOOL CALLBACK enum_lang_proc_w( HMODULE hModule, LPCWSTR type,
2069 LPCWSTR name, WORD LangID, LONG_PTR lParam )
2070 {
2071 static const WCHAR formatW[] = {'%','0','8','x',0};
2072 LOCALE_ENUMPROCW lpfnLocaleEnum = (LOCALE_ENUMPROCW)lParam;
2073 WCHAR buf[20];
2074 sprintfW( buf, formatW, (UINT)LangID );
2075 return lpfnLocaleEnum( buf );
2076 }
2077
2078 /******************************************************************************
2079 * EnumSystemLocalesA (KERNEL32.@)
2080 *
2081 * Call a users function for each locale available on the system.
2082 *
2083 * PARAMS
2084 * lpfnLocaleEnum [I] Callback function to call for each locale
2085 * dwFlags [I] LOCALE_SUPPORTED=All supported, LOCALE_INSTALLED=Installed only
2086 *
2087 * RETURNS
2088 * Success: TRUE.
2089 * Failure: FALSE. Use GetLastError() to determine the cause.
2090 */
2091 BOOL WINAPI EnumSystemLocalesA( LOCALE_ENUMPROCA lpfnLocaleEnum, DWORD dwFlags )
2092 {
2093 TRACE("(%p,%08x)\n", lpfnLocaleEnum, dwFlags);
2094 EnumResourceLanguagesA( kernel32_handle, (LPSTR)RT_STRING,
2095 (LPCSTR)LOCALE_ILANGUAGE, enum_lang_proc_a,
2096 (LONG_PTR)lpfnLocaleEnum);
2097 return TRUE;
2098 }
2099
2100
2101 /******************************************************************************
2102 * EnumSystemLocalesW (KERNEL32.@)
2103 *
2104 * See EnumSystemLocalesA.
2105 */
2106 BOOL WINAPI EnumSystemLocalesW( LOCALE_ENUMPROCW lpfnLocaleEnum, DWORD dwFlags )
2107 {
2108 TRACE("(%p,%08x)\n", lpfnLocaleEnum, dwFlags);
2109 EnumResourceLanguagesW( kernel32_handle, (LPWSTR)RT_STRING,
2110 (LPCWSTR)LOCALE_ILANGUAGE, enum_lang_proc_w,
2111 (LONG_PTR)lpfnLocaleEnum);
2112 return TRUE;
2113 }
2114
2115
2116 /***********************************************************************
2117 * VerLanguageNameA (KERNEL32.@)
2118 *
2119 * Get the name of a language.
2120 *
2121 * PARAMS
2122 * wLang [I] LANGID of the language
2123 * szLang [O] Destination for the language name
2124 *
2125 * RETURNS
2126 * Success: The size of the language name. If szLang is non-NULL, it is filled
2127 * with the name.
2128 * Failure: 0. Use GetLastError() to determine the cause.
2129 *
2130 */
2131 DWORD WINAPI VerLanguageNameA( UINT wLang, LPSTR szLang, UINT nSize )
2132 {
2133 return GetLocaleInfoA( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
2134 }
2135
2136
2137 /***********************************************************************
2138 * VerLanguageNameW (KERNEL32.@)
2139 *
2140 * See VerLanguageNameA.
2141 */
2142 DWORD WINAPI VerLanguageNameW( UINT wLang, LPWSTR szLang, UINT nSize )
2143 {
2144 return GetLocaleInfoW( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
2145 }
2146
2147
2148 /******************************************************************************
2149 * GetStringTypeW (KERNEL32.@)
2150 *
2151 * See GetStringTypeA.
2152 */
2153 BOOL WINAPI GetStringTypeW( DWORD type, LPCWSTR src, INT count, LPWORD chartype )
2154 {
2155 if (count == -1) count = strlenW(src) + 1;
2156 switch(type)
2157 {
2158 case CT_CTYPE1:
2159 while (count--) *chartype++ = get_char_typeW( *src++ ) & 0xfff;
2160 break;
2161 case CT_CTYPE2:
2162 while (count--) *chartype++ = get_char_typeW( *src++ ) >> 12;
2163 break;
2164 case CT_CTYPE3:
2165 {
2166 WARN("CT_CTYPE3: semi-stub.\n");
2167 while (count--)
2168 {
2169 int c = *src;
2170 WORD type1, type3 = 0; /* C3_NOTAPPLICABLE */
2171
2172 type1 = get_char_typeW( *src++ ) & 0xfff;
2173 /* try to construct type3 from type1 */
2174 if(type1 & C1_SPACE) type3 |= C3_SYMBOL;
2175 if(type1 & C1_ALPHA) type3 |= C3_ALPHA;
2176 if ((c>=0x30A0)&&(c<=0x30FF)) type3 |= C3_KATAKANA;
2177 if ((c>=0x3040)&&(c<=0x309F)) type3 |= C3_HIRAGANA;
2178 if ((c>=0x4E00)&&(c<=0x9FAF)) type3 |= C3_IDEOGRAPH;
2179 if ((c>=0x0600)&&(c<=0x06FF)) type3 |= C3_KASHIDA;
2180 if ((c>=0x3000)&&(c<=0x303F)) type3 |= C3_SYMBOL;
2181
2182 if ((c>=0xFF00)&&(c<=0xFF60)) type3 |= C3_FULLWIDTH;
2183 if ((c>=0xFF00)&&(c<=0xFF20)) type3 |= C3_SYMBOL;
2184 if ((c>=0xFF3B)&&(c<=0xFF40)) type3 |= C3_SYMBOL;
2185 if ((c>=0xFF5B)&&(c<=0xFF60)) type3 |= C3_SYMBOL;
2186 if ((c>=0xFF21)&&(c<=0xFF3A)) type3 |= C3_ALPHA;
2187 if ((c>=0xFF41)&&(c<=0xFF5A)) type3 |= C3_ALPHA;
2188 if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_FULLWIDTH;
2189 if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_SYMBOL;
2190
2191 if ((c>=0xFF61)&&(c<=0xFFDC)) type3 |= C3_HALFWIDTH;
2192 if ((c>=0xFF61)&&(c<=0xFF64)) type3 |= C3_SYMBOL;
2193 if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_KATAKANA;
2194 if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_ALPHA;
2195 if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_HALFWIDTH;
2196 if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_SYMBOL;
2197 *chartype++ = type3;
2198 }
2199 break;
2200 }
2201 default:
2202 SetLastError( ERROR_INVALID_PARAMETER );
2203 return FALSE;
2204 }
2205 return TRUE;
2206 }
2207
2208
2209 /******************************************************************************
2210 * GetStringTypeExW (KERNEL32.@)
2211 *
2212 * See GetStringTypeExA.
2213 */
2214 BOOL WINAPI GetStringTypeExW( LCID locale, DWORD type, LPCWSTR src, INT count, LPWORD chartype )
2215 {
2216 /* locale is ignored for Unicode */
2217 return GetStringTypeW( type, src, count, chartype );
2218 }
2219
2220
2221 /******************************************************************************
2222 * GetStringTypeA (KERNEL32.@)
2223 *
2224 * Get characteristics of the characters making up a string.
2225 *
2226 * PARAMS
2227 * locale [I] Locale Id for the string
2228 * type [I] CT_CTYPE1 = classification, CT_CTYPE2 = directionality, CT_CTYPE3 = typographic info
2229 * src [I] String to analyse
2230 * count [I] Length of src in chars, or -1 if src is NUL terminated
2231 * chartype [O] Destination for the calculated characteristics
2232 *
2233 * RETURNS
2234 * Success: TRUE. chartype is filled with the requested characteristics of each char
2235 * in src.
2236 * Failure: FALSE. Use GetLastError() to determine the cause.
2237 */
2238 BOOL WINAPI GetStringTypeA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
2239 {
2240 UINT cp;
2241 INT countW;
2242 LPWSTR srcW;
2243 BOOL ret = FALSE;
2244
2245 if(count == -1) count = strlen(src) + 1;
2246
2247 if (!(cp = get_lcid_codepage( locale )))
2248 {
2249 FIXME("For locale %04x using current ANSI code page\n", locale);
2250 cp = GetACP();
2251 }
2252
2253 countW = MultiByteToWideChar(cp, 0, src, count, NULL, 0);
2254 if((srcW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2255 {
2256 MultiByteToWideChar(cp, 0, src, count, srcW, countW);
2257 /*
2258 * NOTE: the target buffer has 1 word for each CHARACTER in the source
2259 * string, with multibyte characters there maybe be more bytes in count
2260 * than character space in the buffer!
2261 */
2262 ret = GetStringTypeW(type, srcW, countW, chartype);
2263 HeapFree(GetProcessHeap(), 0, srcW);
2264 }
2265 return ret;
2266 }
2267
2268 /******************************************************************************
2269 * GetStringTypeExA (KERNEL32.@)
2270 *
2271 * Get characteristics of the characters making up a string.
2272 *
2273 * PARAMS
2274 * locale [I] Locale Id for the string
2275 * type [I] CT_CTYPE1 = classification, CT_CTYPE2 = directionality, CT_CTYPE3 = typographic info
2276 * src [I] String to analyse
2277 * count [I] Length of src in chars, or -1 if src is NUL terminated
2278 * chartype [O] Destination for the calculated characteristics
2279 *
2280 * RETURNS
2281 * Success: TRUE. chartype is filled with the requested characteristics of each char
2282 * in src.
2283 * Failure: FALSE. Use GetLastError() to determine the cause.
2284 */
2285 BOOL WINAPI GetStringTypeExA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
2286 {
2287 return GetStringTypeA(locale, type, src, count, chartype);
2288 }
2289
2290
2291 /*************************************************************************
2292 * LCMapStringW (KERNEL32.@)
2293 *
2294 * See LCMapStringA.
2295 */
2296 INT WINAPI LCMapStringW(LCID lcid, DWORD flags, LPCWSTR src, INT srclen,
2297 LPWSTR dst, INT dstlen)
2298 {
2299 LPWSTR dst_ptr;
2300
2301 if (!src || !srclen || dstlen < 0)
2302 {
2303 SetLastError(ERROR_INVALID_PARAMETER);
2304 return 0;
2305 }
2306
2307 /* mutually exclusive flags */
2308 if ((flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE)) == (LCMAP_LOWERCASE | LCMAP_UPPERCASE) ||
2309 (flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA)) == (LCMAP_HIRAGANA | LCMAP_KATAKANA) ||
2310 (flags & (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) == (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH) ||
2311 (flags & (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE)) == (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE))
2312 {
2313 SetLastError(ERROR_INVALID_FLAGS);
2314 return 0;
2315 }
2316
2317 if (!dstlen) dst = NULL;
2318
2319 lcid = ConvertDefaultLocale(lcid);
2320
2321 if (flags & LCMAP_SORTKEY)
2322 {
2323 if (src == dst)
2324 {
2325 SetLastError(ERROR_INVALID_FLAGS);
2326 return 0;
2327 }
2328
2329 if (srclen < 0) srclen = strlenW(src);
2330
2331 TRACE("(0x%04x,0x%08x,%s,%d,%p,%d)\n",
2332 lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
2333
2334 return wine_get_sortkey(flags, src, srclen, (char *)dst, dstlen);
2335 }
2336
2337 /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
2338 if (flags & SORT_STRINGSORT)
2339 {
2340 SetLastError(ERROR_INVALID_FLAGS);
2341 return 0;
2342 }
2343
2344 if (srclen < 0) srclen = strlenW(src) + 1;
2345
2346 TRACE("(0x%04x,0x%08x,%s,%d,%p,%d)\n",
2347 lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
2348
2349 if (!dst) /* return required string length */
2350 {
2351 INT len;
2352
2353 for (len = 0; srclen; src++, srclen--)
2354 {
2355 WCHAR wch = *src;
2356 /* tests show that win2k just ignores NORM_IGNORENONSPACE,
2357 * and skips white space and punctuation characters for
2358 * NORM_IGNORESYMBOLS.
2359 */
2360 if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
2361 continue;
2362 len++;
2363 }
2364 return len;
2365 }
2366
2367 if (flags & LCMAP_UPPERCASE)
2368 {
2369 for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
2370 {
2371 WCHAR wch = *src;
2372 if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
2373 continue;
2374 *dst_ptr++ = toupperW(wch);
2375 dstlen--;
2376 }
2377 }
2378 else if (flags & LCMAP_LOWERCASE)
2379 {
2380 for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
2381 {
2382 WCHAR wch = *src;
2383 if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
2384 continue;
2385 *dst_ptr++ = tolowerW(wch);
2386 dstlen--;
2387 }
2388 }
2389 else
2390 {
2391 if (src == dst)
2392 {
2393 SetLastError(ERROR_INVALID_FLAGS);
2394 return 0;
2395 }
2396 for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
2397 {
2398 WCHAR wch = *src;
2399 if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
2400 continue;
2401 *dst_ptr++ = wch;
2402 dstlen--;
2403 }
2404 }
2405
2406 if (srclen)
2407 {
2408 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2409 return 0;
2410 }
2411
2412 return dst_ptr - dst;
2413 }
2414
2415 /*************************************************************************
2416 * LCMapStringA (KERNEL32.@)
2417 *
2418 * Map characters in a locale sensitive string.
2419 *
2420 * PARAMS
2421 * lcid [I] LCID for the conversion.
2422 * flags [I] Flags controlling the mapping (LCMAP_ constants from "winnls.h").
2423 * src [I] String to map
2424 * srclen [I] Length of src in chars, or -1 if src is NUL terminated
2425 * dst [O] Destination for mapped string
2426 * dstlen [I] Length of dst in characters
2427 *
2428 * RETURNS
2429 * Success: The length of the mapped string in dst, including the NUL terminator.
2430 * Failure: 0. Use GetLastError() to determine the cause.
2431 */
2432 INT WINAPI LCMapStringA(LCID lcid, DWORD flags, LPCSTR src, INT srclen,
2433 LPSTR dst, INT dstlen)
2434 {
2435 WCHAR *bufW = NtCurrentTeb()->StaticUnicodeBuffer;
2436 LPWSTR srcW, dstW;
2437 INT ret = 0, srclenW, dstlenW;
2438 UINT locale_cp = CP_ACP;
2439
2440 if (!src || !srclen || dstlen < 0)
2441 {
2442 SetLastError(ERROR_INVALID_PARAMETER);
2443 return 0;
2444 }
2445
2446 if (!(flags & LOCALE_USE_CP_ACP)) locale_cp = get_lcid_codepage( lcid );
2447
2448 srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, bufW, 260);
2449 if (srclenW)
2450 srcW = bufW;
2451 else
2452 {
2453 srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, NULL, 0);
2454 srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
2455 if (!srcW)
2456 {
2457 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2458 return 0;
2459 }
2460 MultiByteToWideChar(locale_cp, 0, src, srclen, srcW, srclenW);
2461 }
2462
2463 if (flags & LCMAP_SORTKEY)
2464 {
2465 if (src == dst)
2466 {
2467 SetLastError(ERROR_INVALID_FLAGS);
2468 goto map_string_exit;
2469 }
2470 ret = wine_get_sortkey(flags, srcW, srclenW, dst, dstlen);
2471 goto map_string_exit;
2472 }
2473
2474 if (flags & SORT_STRINGSORT)
2475 {
2476 SetLastError(ERROR_INVALID_FLAGS);
2477 goto map_string_exit;
2478 }
2479
2480 dstlenW = LCMapStringW(lcid, flags, srcW, srclenW, NULL, 0);
2481 if (!dstlenW)
2482 goto map_string_exit;
2483
2484 dstW = HeapAlloc(GetProcessHeap(), 0, dstlenW * sizeof(WCHAR));
2485 if (!dstW)
2486 {
2487 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2488 goto map_string_exit;
2489 }
2490
2491 LCMapStringW(lcid, flags, srcW, srclenW, dstW, dstlenW);
2492 ret = WideCharToMultiByte(locale_cp, 0, dstW, dstlenW, dst, dstlen, NULL, NULL);
2493 HeapFree(GetProcessHeap(), 0, dstW);
2494
2495 map_string_exit:
2496 if (srcW != bufW) HeapFree(GetProcessHeap(), 0, srcW);
2497 return ret;
2498 }
2499
2500 /*************************************************************************
2501 * FoldStringA (KERNEL32.@)
2502 *
2503 * Map characters in a string.
2504 *
2505 * PARAMS
2506 * dwFlags [I] Flags controlling chars to map (MAP_ constants from "winnls.h")
2507 * src [I] String to map
2508 * srclen [I] Length of src, or -1 if src is NUL terminated
2509 * dst [O] Destination for mapped string
2510 * dstlen [I] Length of dst, or 0 to find the required length for the mapped string
2511 *
2512 * RETURNS
2513 * Success: The length of the string written to dst, including the terminating NUL. If
2514 * dstlen is 0, the value returned is the same, but nothing is written to dst,
2515 * and dst may be NULL.
2516 * Failure: 0. Use GetLastError() to determine the cause.
2517 */
2518 INT WINAPI FoldStringA(DWORD dwFlags, LPCSTR src, INT srclen,
2519 LPSTR dst, INT dstlen)
2520 {
2521 INT ret = 0, srclenW = 0;
2522 WCHAR *srcW = NULL, *dstW = NULL;
2523
2524 if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
2525 {
2526 SetLastError(ERROR_INVALID_PARAMETER);
2527 return 0;
2528 }
2529
2530 srclenW = MultiByteToWideChar(CP_ACP, dwFlags & MAP_COMPOSITE ? MB_COMPOSITE : 0,
2531 src, srclen, NULL, 0);
2532 srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
2533
2534 if (!srcW)
2535 {
2536 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2537 goto FoldStringA_exit;
2538 }
2539
2540 MultiByteToWideChar(CP_ACP, dwFlags & MAP_COMPOSITE ? MB_COMPOSITE : 0,
2541 src, srclen, srcW, srclenW);
2542
2543 dwFlags = (dwFlags & ~MAP_PRECOMPOSED) | MAP_FOLDCZONE;
2544
2545 ret = FoldStringW(dwFlags, srcW, srclenW, NULL, 0);
2546 if (ret && dstlen)
2547 {
2548 dstW = HeapAlloc(GetProcessHeap(), 0, ret * sizeof(WCHAR));
2549
2550 if (!dstW)
2551 {
2552 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2553 goto FoldStringA_exit;
2554 }
2555
2556 ret = FoldStringW(dwFlags, srcW, srclenW, dstW, ret);
2557 if (!WideCharToMultiByte(CP_ACP, 0, dstW, ret, dst, dstlen, NULL, NULL))
2558 {
2559 ret = 0;
2560 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2561 }
2562 }
2563
2564 HeapFree(GetProcessHeap(), 0, dstW);
2565
2566 FoldStringA_exit:
2567 HeapFree(GetProcessHeap(), 0, srcW);
2568 return ret;
2569 }
2570
2571 /*************************************************************************
2572 * FoldStringW (KERNEL32.@)
2573 *
2574 * See FoldStringA.
2575 */
2576 INT WINAPI FoldStringW(DWORD dwFlags, LPCWSTR src, INT srclen,
2577 LPWSTR dst, INT dstlen)
2578 {
2579 int ret;
2580
2581 switch (dwFlags & (MAP_COMPOSITE|MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES))
2582 {
2583 case 0:
2584 if (dwFlags)
2585 break;
2586 /* Fall through for dwFlags == 0 */
2587 case MAP_PRECOMPOSED|MAP_COMPOSITE:
2588 case MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES:
2589 case MAP_COMPOSITE|MAP_EXPAND_LIGATURES:
2590 SetLastError(ERROR_INVALID_FLAGS);
2591 return 0;
2592 }
2593
2594 if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
2595 {
2596 SetLastError(ERROR_INVALID_PARAMETER);
2597 return 0;
2598 }
2599
2600 ret = wine_fold_string(dwFlags, src, srclen, dst, dstlen);
2601 if (!ret)
2602 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2603 return ret;
2604 }
2605
2606 /******************************************************************************
2607 * CompareStringW (KERNEL32.@)
2608 *
2609 * See CompareStringA.
2610 */
2611 INT WINAPI CompareStringW(LCID lcid, DWORD style,
2612 LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)
2613 {
2614 INT ret;
2615
2616 if (!str1 || !str2)
2617 {
2618 SetLastError(ERROR_INVALID_PARAMETER);
2619 return 0;
2620 }
2621
2622 if( style & ~(NORM_IGNORECASE|NORM_IGNORENONSPACE|NORM_IGNORESYMBOLS|
2623 SORT_STRINGSORT|NORM_IGNOREKANATYPE|NORM_IGNOREWIDTH|LOCALE_USE_CP_ACP|0x10000000) )
2624 {
2625 SetLastError(ERROR_INVALID_FLAGS);
2626 return 0;
2627 }
2628
2629 /* this style is related to diacritics in Arabic, Japanese, and Hebrew */
2630 if (style & 0x10000000)
2631 WARN("Ignoring unknown style 0x10000000\n");
2632
2633 if (len1 < 0) len1 = strlenW(str1);
2634 if (len2 < 0) len2 = strlenW(str2);
2635
2636 ret = wine_compare_string(style, str1, len1, str2, len2);
2637
2638 if (ret) /* need to translate result */
2639 return (ret < 0) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
2640 return CSTR_EQUAL;
2641 }
2642
2643 /******************************************************************************
2644 * CompareStringA (KERNEL32.@)
2645 *
2646 * Compare two locale sensitive strings.
2647 *
2648 * PARAMS
2649 * lcid [I] LCID for the comparison
2650 * style [I] Flags for the comparison (NORM_ constants from "winnls.h").
2651 * str1 [I] First string to compare
2652 * len1 [I] Length of str1, or -1 if str1 is NUL terminated
2653 * str2 [I] Second string to compare
2654 * len2 [I] Length of str2, or -1 if str2 is NUL terminated
2655 *
2656 * RETURNS
2657 * Success: CSTR_LESS_THAN, CSTR_EQUAL or CSTR_GREATER_THAN depending on whether
2658 * str2 is less than, equal to or greater than str1 respectively.
2659 * Failure: FALSE. Use GetLastError() to determine the cause.
2660 */
2661 INT WINAPI CompareStringA(LCID lcid, DWORD style,
2662 LPCSTR str1, INT len1, LPCSTR str2, INT len2)
2663 {
2664 WCHAR *buf1W = NtCurrentTeb()->StaticUnicodeBuffer;
2665 WCHAR *buf2W = buf1W + 130;
2666 LPWSTR str1W, str2W;
2667 INT len1W, len2W, ret;
2668 UINT locale_cp = CP_ACP;
2669
2670 if (!str1 || !str2)
2671 {
2672 SetLastError(ERROR_INVALID_PARAMETER);
2673 return 0;
2674 }
2675 if (len1 < 0) len1 = strlen(str1);
2676 if (len2 < 0) len2 = strlen(str2);
2677
2678 if (!(style & LOCALE_USE_CP_ACP)) locale_cp = get_lcid_codepage( lcid );
2679
2680 len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, buf1W, 130);
2681 if (len1W)
2682 str1W = buf1W;
2683 else
2684 {
2685 len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, NULL, 0);
2686 str1W = HeapAlloc(GetProcessHeap(), 0, len1W * sizeof(WCHAR));
2687 if (!str1W)
2688 {
2689 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2690 return 0;
2691 }
2692 MultiByteToWideChar(locale_cp, 0, str1, len1, str1W, len1W);
2693 }
2694 len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, buf2W, 130);
2695 if (len2W)
2696 str2W = buf2W;
2697 else
2698 {
2699 len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, NULL, 0);
2700 str2W = HeapAlloc(GetProcessHeap(), 0, len2W * sizeof(WCHAR));
2701 if (!str2W)
2702 {
2703 if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
2704 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2705 return 0;
2706 }
2707 MultiByteToWideChar(locale_cp, 0, str2, len2, str2W, len2W);
2708 }
2709
2710 ret = CompareStringW(lcid, style, str1W, len1W, str2W, len2W);
2711
2712 if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
2713 if (str2W != buf2W) HeapFree(GetProcessHeap(), 0, str2W);
2714 return ret;
2715 }
2716
2717 /*************************************************************************
2718 * lstrcmp (KERNEL32.@)
2719 * lstrcmpA (KERNEL32.@)
2720 *
2721 * Compare two strings using the current thread locale.
2722 *
2723 * PARAMS
2724 * str1 [I] First string to compare
2725 * str2 [I] Second string to compare
2726 *
2727 * RETURNS
2728 * Success: A number less than, equal to or greater than 0 depending on whether
2729 * str2 is less than, equal to or greater than str1 respectively.
2730 * Failure: FALSE. Use GetLastError() to determine the cause.
2731 */
2732 int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
2733 {
2734 int ret;
2735
2736 if ((str1 == NULL) && (str2 == NULL)) return 0;
2737 if (str1 == NULL) return -1;
2738 if (str2 == NULL) return 1;
2739
2740 ret = CompareStringA(GetThreadLocale(), LOCALE_USE_CP_ACP, str1, -1, str2, -1);
2741 if (ret) ret -= 2;
2742
2743 return ret;
2744 }
2745
2746 /*************************************************************************
2747 * lstrcmpi (KERNEL32.@)
2748 * lstrcmpiA (KERNEL32.@)
2749 *
2750 * Compare two strings using the current thread locale, ignoring case.
2751 *
2752 * PARAMS
2753 * str1 [I] First string to compare
2754 * str2 [I] Second string to compare
2755 *
2756 * RETURNS
2757 * Success: A number less than, equal to or greater than 0 depending on whether
2758 * str2 is less than, equal to or greater than str1 respectively.
2759 * Failure: FALSE. Use GetLastError() to determine the cause.
2760 */
2761 int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
2762 {
2763 int ret;
2764
2765 if ((str1 == NULL) && (str2 == NULL)) return 0;
2766 if (str1 == NULL) return -1;
2767 if (str2 == NULL) return 1;
2768
2769 ret = CompareStringA(GetThreadLocale(), NORM_IGNORECASE|LOCALE_USE_CP_ACP, str1, -1, str2, -1);
2770 if (ret) ret -= 2;
2771
2772 return ret;
2773 }
2774
2775 /*************************************************************************
2776 * lstrcmpW (KERNEL32.@)
2777 *
2778 * See lstrcmpA.
2779 */
2780 int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
2781 {
2782 int ret;
2783
2784 if ((str1 == NULL) && (str2 == NULL)) return 0;
2785 if (str1 == NULL) return -1;
2786 if (str2 == NULL) return 1;
2787
2788 ret = CompareStringW(GetThreadLocale(), 0, str1, -1, str2, -1);
2789 if (ret) ret -= 2;
2790
2791 return ret;
2792 }
2793
2794 /*************************************************************************
2795 * lstrcmpiW (KERNEL32.@)
2796 *
2797 * See lstrcmpiA.
2798 */
2799 int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
2800 {
2801 int ret;
2802
2803 if ((str1 == NULL) && (str2 == NULL)) return 0;
2804 if (str1 == NULL) return -1;
2805 if (str2 == NULL) return 1;
2806
2807 ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, -1, str2, -1);
2808 if (ret) ret -= 2;
2809
2810 return ret;
2811 }
2812
2813 /******************************************************************************
2814 * LOCALE_Init
2815 */
2816 void LOCALE_Init(void)
2817 {
2818 extern void __wine_init_codepages( const union cptable *ansi_cp, const union cptable *oem_cp,
2819 const union cptable *unix_cp );
2820
2821 UINT ansi_cp = 1252, oem_cp = 437, mac_cp = 10000, unix_cp;
2822
2823 #ifdef __APPLE__
2824 /* MacOS doesn't set the locale environment variables so we have to do it ourselves */
2825 char user_locale[50];
2826 CFLocaleRef user_locale_ref = CFLocaleCopyCurrent();
2827 CFStringRef user_locale_string_ref = CFLocaleGetIdentifier( user_locale_ref );
2828
2829 CFStringGetCString( user_locale_string_ref, user_locale, sizeof(user_locale), kCFStringEncodingUTF8 );
2830 CFRelease( user_locale_ref );
2831 if (!strchr( user_locale, '.' )) strcat( user_locale, ".UTF-8" );
2832 unix_cp = CP_UTF8; /* default to utf-8 even if we don't get a valid locale */
2833 setenv( "LANG", user_locale, 0 );
2834 TRACE( "setting locale to '%s'\n", user_locale );
2835 #endif
2836 setlocale( LC_ALL, "" );
2837
2838 unix_cp = setup_unix_locales();
2839 if (!lcid_LC_MESSAGES) lcid_LC_MESSAGES = lcid_LC_CTYPE;
2840 NtSetDefaultUILanguage( LANGIDFROMLCID(lcid_LC_MESSAGES) );
2841 NtSetDefaultLocale( TRUE, lcid_LC_MESSAGES );
2842 NtSetDefaultLocale( FALSE, lcid_LC_CTYPE );
2843
2844 ansi_cp = get_lcid_codepage( LOCALE_USER_DEFAULT );
2845 GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IDEFAULTMACCODEPAGE | LOCALE_RETURN_NUMBER,
2846 (LPWSTR)&mac_cp, sizeof(mac_cp)/sizeof(WCHAR) );
2847 GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
2848 (LPWSTR)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR) );
2849 if (!unix_cp)
2850 GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IDEFAULTUNIXCODEPAGE | LOCALE_RETURN_NUMBER,
2851 (LPWSTR)&unix_cp, sizeof(unix_cp)/sizeof(WCHAR) );
2852
2853 if (!(ansi_cptable = wine_cp_get_table( ansi_cp )))
2854 ansi_cptable = wine_cp_get_table( 1252 );
2855 if (!(oem_cptable = wine_cp_get_table( oem_cp )))
2856 oem_cptable = wine_cp_get_table( 437 );
2857 if (!(mac_cptable = wine_cp_get_table( mac_cp )))
2858 mac_cptable = wine_cp_get_table( 10000 );
2859 if (unix_cp != CP_UTF8)
2860 {
2861 if (!(unix_cptable = wine_cp_get_table( unix_cp )))
2862 unix_cptable = wine_cp_get_table( 28591 );
2863 }
2864
2865 __wine_init_codepages( ansi_cptable, oem_cptable, unix_cptable );
2866
2867 TRACE( "ansi=%03d oem=%03d mac=%03d unix=%03d\n",
2868 ansi_cptable->info.codepage, oem_cptable->info.codepage,
2869 mac_cptable->info.codepage, unix_cp );
2870
2871 setlocale(LC_NUMERIC, "C"); /* FIXME: oleaut32 depends on this */
2872 }
2873
2874 static HANDLE NLS_RegOpenKey(HANDLE hRootKey, LPCWSTR szKeyName)
2875 {
2876 UNICODE_STRING keyName;
2877 OBJECT_ATTRIBUTES attr;
2878 HANDLE hkey;
2879
2880 RtlInitUnicodeString( &keyName, szKeyName );
2881 InitializeObjectAttributes(&attr, &keyName, 0, hRootKey, NULL);
2882
2883 if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) != STATUS_SUCCESS)
2884 hkey = 0;
2885
2886 return hkey;
2887 }
2888
2889 static HANDLE NLS_RegOpenSubKey(HANDLE hRootKey, LPCWSTR szKeyName)
2890 {
2891 HANDLE hKey = NLS_RegOpenKey(hRootKey, szKeyName);
2892
2893 if (hRootKey)
2894 NtClose( hRootKey );
2895
2896 return hKey;
2897 }
2898
2899 static BOOL NLS_RegEnumSubKey(HANDLE hKey, UINT ulIndex, LPWSTR szKeyName,
2900 ULONG keyNameSize)
2901 {
2902 BYTE buffer[80];
2903 KEY_BASIC_INFORMATION *info = (KEY_BASIC_INFORMATION *)buffer;
2904 DWORD dwLen;
2905
2906 if (NtEnumerateKey( hKey, ulIndex, KeyBasicInformation, buffer,
2907 sizeof(buffer), &dwLen) != STATUS_SUCCESS ||
2908 info->NameLength > keyNameSize)
2909 {
2910 return FALSE;
2911 }
2912
2913 TRACE("info->Name %s info->NameLength %d\n", debugstr_w(info->Name), info->NameLength);
2914
2915 memcpy( szKeyName, info->Name, info->NameLength);
2916 szKeyName[info->NameLength / sizeof(WCHAR)] = '\0';
2917
2918 TRACE("returning %s\n", debugstr_w(szKeyName));
2919 return TRUE;
2920 }
2921
2922 static BOOL NLS_RegEnumValue(HANDLE hKey, UINT ulIndex,
2923 LPWSTR szValueName, ULONG valueNameSize,
2924 LPWSTR szValueData, ULONG valueDataSize)
2925 {
2926 BYTE buffer[80];
2927 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
2928 DWORD dwLen;
2929
2930 if (NtEnumerateValueKey( hKey, ulIndex, KeyValueFullInformation,
2931 buffer, sizeof(buffer), &dwLen ) != STATUS_SUCCESS ||
2932 info->NameLength > valueNameSize ||
2933 info->DataLength > valueDataSize)
2934 {
2935 return FALSE;
2936 }
2937
2938 TRACE("info->Name %s info->DataLength %d\n", debugstr_w(info->Name), info->DataLength);
2939
2940 memcpy( szValueName, info->Name, info->NameLength);
2941 szValueName[info->NameLength / sizeof(WCHAR)] = '\0';
2942 memcpy( szValueData, buffer + info->DataOffset, info->DataLength );
2943 szValueData[info->DataLength / sizeof(WCHAR)] = '\0';
2944
2945 TRACE("returning %s %s\n", debugstr_w(szValueName), debugstr_w(szValueData));
2946 return TRUE;
2947 }
2948
2949 static BOOL NLS_RegGetDword(HANDLE hKey, LPCWSTR szValueName, DWORD *lpVal)
2950 {
2951 BYTE buffer[128];
2952 const KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
2953 DWORD dwSize = sizeof(buffer);
2954 UNICODE_STRING valueName;
2955
2956 RtlInitUnicodeString( &valueName, szValueName );
2957
2958 TRACE("%p, %s\n", hKey, debugstr_w(szValueName));
2959 if (NtQueryValueKey( hKey, &valueName, KeyValuePartialInformation,
2960 buffer, dwSize, &dwSize ) == STATUS_SUCCESS &&
2961 info->DataLength == sizeof(DWORD))
2962 {
2963 memcpy(lpVal, info->Data, sizeof(DWORD));
2964 return TRUE;
2965 }
2966
2967 return FALSE;
2968 }
2969
2970 static BOOL NLS_GetLanguageGroupName(LGRPID lgrpid, LPWSTR szName, ULONG nameSize)
2971 {
2972 LANGID langId;
2973 LPCWSTR szResourceName = MAKEINTRESOURCEW(((lgrpid + 0x2000) >> 4) + 1);
2974 HRSRC hResource;
2975 BOOL bRet = FALSE;
2976
2977 /* FIXME: Is it correct to use the system default langid? */
2978 langId = GetSystemDefaultLangID();
2979
2980 if (SUBLANGID(langId) == SUBLANG_NEUTRAL)
2981 langId = MAKELANGID( PRIMARYLANGID(langId), SUBLANG_DEFAULT );
2982
2983 hResource = FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING, szResourceName, langId );
2984
2985 if (hResource)
2986 {
2987 HGLOBAL hResDir = LoadResource( kernel32_handle, hResource );
2988
2989 if (hResDir)
2990 {
2991 ULONG iResourceIndex = lgrpid & 0xf;
2992 LPCWSTR lpResEntry = LockResource( hResDir );
2993 ULONG i;
2994
2995 for (i = 0; i < iResourceIndex; i++)
2996 lpResEntry += *lpResEntry + 1;
2997
2998 if (*lpResEntry < nameSize)
2999 {
3000 memcpy( szName, lpResEntry + 1, *lpResEntry * sizeof(WCHAR) );
3001 szName[*lpResEntry] = '\0';
3002 bRet = TRUE;
3003 }
3004
3005 }
3006 FreeResource( hResource );
3007 }
3008 return bRet;
3009 }
3010
3011 /* Registry keys for NLS related information */
3012 static const WCHAR szLangGroupsKeyName[] = {
3013 'L','a','n','g','u','a','g','e',' ','G','r','o','u','p','s','\0'
3014 };
3015
3016 static const WCHAR szCountryListName[] = {
3017 'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\',
3018 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
3019 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3020 'T','e','l','e','p','h','o','n','y','\\',
3021 'C','o','u','n','t','r','y',' ','L','i','s','t','\0'
3022 };
3023
3024
3025 /* Callback function ptrs for EnumSystemLanguageGroupsA/W */
3026 typedef struct
3027 {
3028 LANGUAGEGROUP_ENUMPROCA procA;
3029 LANGUAGEGROUP_ENUMPROCW procW;
3030 DWORD dwFlags;
3031 LONG_PTR lParam;
3032 } ENUMLANGUAGEGROUP_CALLBACKS;
3033
3034 /* Internal implementation of EnumSystemLanguageGroupsA/W */
3035 static BOOL NLS_EnumSystemLanguageGroups(ENUMLANGUAGEGROUP_CALLBACKS *lpProcs)
3036 {
3037 WCHAR szNumber[10], szValue[4];
3038 HANDLE hKey;
3039 BOOL bContinue = TRUE;
3040 ULONG ulIndex = 0;
3041
3042 if (!lpProcs)
3043 {
3044 SetLastError(ERROR_INVALID_PARAMETER);
3045 return FALSE;
3046 }
3047
3048 switch (lpProcs->dwFlags)
3049 {
3050 case 0:
3051 /* Default to LGRPID_INSTALLED */
3052 lpProcs->dwFlags = LGRPID_INSTALLED;
3053 /* Fall through... */
3054 case LGRPID_INSTALLED:
3055 case LGRPID_SUPPORTED:
3056 break;
3057 default:
3058 SetLastError(ERROR_INVALID_FLAGS);
3059 return FALSE;
3060 }
3061
3062 hKey = NLS_RegOpenSubKey( NLS_RegOpenKey( 0, szNlsKeyName ), szLangGroupsKeyName );
3063
3064 if (!hKey)
3065 FIXME("NLS registry key not found. Please apply the default registry file 'wine.inf'\n");
3066
3067 while (bContinue)
3068 {
3069 if (NLS_RegEnumValue( hKey, ulIndex, szNumber, sizeof(szNumber),
3070 szValue, sizeof(szValue) ))
3071 {
3072 BOOL bInstalled = szValue[0] == '1' ? TRUE : FALSE;
3073 LGRPID lgrpid = strtoulW( szNumber, NULL, 16 );
3074
3075 TRACE("grpid %s (%sinstalled)\n", debugstr_w(szNumber),
3076 bInstalled ? "" : "not ");
3077
3078 if (lpProcs->dwFlags == LGRPID_SUPPORTED || bInstalled)
3079 {
3080 WCHAR szGrpName[48];
3081
3082 if (!NLS_GetLanguageGroupName( lgrpid, szGrpName, sizeof(szGrpName) / sizeof(WCHAR) ))
3083 szGrpName[0] = '\0';
3084
3085 if (lpProcs->procW)
3086 bContinue = lpProcs->procW( lgrpid, szNumber, szGrpName, lpProcs->dwFlags,
3087 lpProcs->lParam );
3088 else
3089 {
3090 char szNumberA[sizeof(szNumber)/sizeof(WCHAR)];
3091 char szGrpNameA[48];
3092
3093 /* FIXME: MSDN doesn't say which code page the W->A translation uses,
3094 * or whether the language names are ever localised. Assume CP_ACP.
3095 */
3096
3097 WideCharToMultiByte(CP_ACP, 0, szNumber, -1, szNumberA, sizeof(szNumberA), 0, 0);
3098 WideCharToMultiByte(CP_ACP, 0, szGrpName, -1, szGrpNameA, sizeof(szGrpNameA), 0, 0);
3099
3100 bContinue = lpProcs->procA( lgrpid, szNumberA, szGrpNameA, lpProcs->dwFlags,
3101 lpProcs->lParam );
3102 }
3103 }
3104
3105 ulIndex++;
3106 }
3107 else
3108 bContinue = FALSE;
3109
3110 if (!bContinue)
3111 break;
3112 }
3113
3114 if (hKey)
3115 NtClose( hKey );
3116
3117 return TRUE;
3118 }
3119
3120 /******************************************************************************
3121 * EnumSystemLanguageGroupsA (KERNEL32.@)
3122 *
3123 * Call a users function for each language group available on the system.
3124 *
3125 * PARAMS
3126 * pLangGrpEnumProc [I] Callback function to call for each language group
3127 * dwFlags [I] LGRPID_SUPPORTED=All Supported, LGRPID_INSTALLED=Installed only
3128 * lParam [I] User parameter to pass to pLangGrpEnumProc
3129 *
3130 * RETURNS
3131 * Success: TRUE.
3132 * Failure: FALSE. Use GetLastError() to determine the cause.
3133 */
3134 BOOL WINAPI EnumSystemLanguageGroupsA(LANGUAGEGROUP_ENUMPROCA pLangGrpEnumProc,
3135 DWORD dwFlags, LONG_PTR lParam)
3136 {
3137 ENUMLANGUAGEGROUP_CALLBACKS procs;
3138
3139 TRACE("(%p,0x%08X,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
3140
3141 procs.procA = pLangGrpEnumProc;
3142 procs.procW = NULL;
3143 procs.dwFlags = dwFlags;
3144 procs.lParam = lParam;
3145
3146 return NLS_EnumSystemLanguageGroups( pLangGrpEnumProc ? &procs : NULL);
3147 }
3148
3149 /******************************************************************************
3150 * EnumSystemLanguageGroupsW (KERNEL32.@)
3151 *
3152 * See EnumSystemLanguageGroupsA.
3153 */
3154 BOOL WINAPI EnumSystemLanguageGroupsW(LANGUAGEGROUP_ENUMPROCW pLangGrpEnumProc,
3155 DWORD dwFlags, LONG_PTR lParam)
3156 {
3157 ENUMLANGUAGEGROUP_CALLBACKS procs;
3158
3159 TRACE("(%p,0x%08X,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
3160
3161 procs.procA = NULL;
3162 procs.procW = pLangGrpEnumProc;
3163 procs.dwFlags = dwFlags;
3164 procs.lParam = lParam;
3165
3166 return NLS_EnumSystemLanguageGroups( pLangGrpEnumProc ? &procs : NULL);
3167 }
3168
3169 /******************************************************************************
3170 * IsValidLanguageGroup (KERNEL32.@)
3171 *
3172 * Determine if a language group is supported and/or installed.
3173 *
3174 * PARAMS
3175 * lgrpid [I] Language Group Id (LGRPID_ values from "winnls.h")
3176 * dwFlags [I] LGRPID_SUPPORTED=Supported, LGRPID_INSTALLED=Installed
3177 *
3178 * RETURNS
3179 * TRUE, if lgrpid is supported and/or installed, according to dwFlags.
3180 * FALSE otherwise.
3181 */
3182 BOOL WINAPI IsValidLanguageGroup(LGRPID lgrpid, DWORD dwFlags)
3183 {
3184 static const WCHAR szFormat[] = { '%','x','\0' };
3185 WCHAR szValueName[16], szValue[2];
3186 BOOL bSupported = FALSE, bInstalled = FALSE;
3187 HANDLE hKey;
3188
3189
3190 switch (dwFlags)
3191 {
3192 case LGRPID_INSTALLED:
3193 case LGRPID_SUPPORTED:
3194
3195 hKey = NLS_RegOpenSubKey( NLS_RegOpenKey( 0, szNlsKeyName ), szLangGroupsKeyName );
3196
3197 sprintfW( szValueName, szFormat, lgrpid );
3198
3199 if (NLS_RegGetDword( hKey, szValueName, (LPDWORD)&szValue ))
3200 {
3201 bSupported = TRUE;
3202
3203 if (szValue[0] == '1')
3204 bInstalled = TRUE;
3205 }
3206
3207 if (hKey)
3208 NtClose( hKey );
3209
3210 break;
3211 }
3212
3213 if ((dwFlags == LGRPID_SUPPORTED && bSupported) ||
3214 (dwFlags == LGRPID_INSTALLED && bInstalled))
3215 return TRUE;
3216
3217 return FALSE;
3218 }
3219
3220 /* Callback function ptrs for EnumLanguageGrouplocalesA/W */
3221 typedef struct
3222 {
3223 LANGGROUPLOCALE_ENUMPROCA procA;
3224 LANGGROUPLOCALE_ENUMPROCW procW;
3225 DWORD dwFlags;
3226 LGRPID lgrpid;
3227 LONG_PTR lParam;
3228 } ENUMLANGUAGEGROUPLOCALE_CALLBACKS;
3229
3230 /* Internal implementation of EnumLanguageGrouplocalesA/W */
3231 static BOOL NLS_EnumLanguageGroupLocales(ENUMLANGUAGEGROUPLOCALE_CALLBACKS *lpProcs)
3232 {
3233 static const WCHAR szLocaleKeyName[] = {
3234 'L','o','c','a','l','e','\0'
3235 };
3236 static const WCHAR szAlternateSortsKeyName[] = {
3237 'A','l','t','e','r','n','a','t','e',' ','S','o','r','t','s','\0'
3238 };
3239 WCHAR szNumber[10], szValue[4];
3240 HANDLE hKey;
3241 BOOL bContinue = TRUE, bAlternate = FALSE;
3242 LGRPID lgrpid;
3243 ULONG ulIndex = 1; /* Ignore default entry of 1st key */
3244
3245 if (!lpProcs || !lpProcs->lgrpid || lpProcs->lgrpid > LGRPID_ARMENIAN)
3246 {
3247 SetLastError(ERROR_INVALID_PARAMETER);
3248 return FALSE;
3249 }
3250
3251 if (lpProcs->dwFlags)
3252 {
3253 SetLastError(ERROR_INVALID_FLAGS);
3254 return FALSE;
3255 }
3256
3257 hKey = NLS_RegOpenSubKey( NLS_RegOpenKey( 0, szNlsKeyName ), szLocaleKeyName );
3258
3259 if (!hKey)
3260 WARN("NLS registry key not found. Please apply the default registry file 'wine.inf'\n");
3261
3262 while (bContinue)
3263 {
3264 if (NLS_RegEnumValue( hKey, ulIndex, szNumber, sizeof(szNumber),
3265 szValue, sizeof(szValue) ))
3266 {
3267 lgrpid = strtoulW( szValue, NULL, 16 );
3268
3269 TRACE("lcid %s, grpid %d (%smatched)\n", debugstr_w(szNumber),
3270 lgrpid, lgrpid == lpProcs->lgrpid ? "" : "not ");
3271
3272 if (lgrpid == lpProcs->lgrpid)
3273 {
3274 LCID lcid;
3275
3276 lcid = strtoulW( szNumber, NULL, 16 );
3277
3278 /* FIXME: native returns extra text for a few (17/150) locales, e.g:
3279 * '00000437 ;Georgian'
3280 * At present we only pass the LCID string.
3281 */
3282
3283 if (lpProcs->procW)
3284 bContinue = lpProcs->procW( lgrpid, lcid, szNumber, lpProcs->lParam );
3285 else
3286 {
3287 char szNumberA[sizeof(szNumber)/sizeof(WCHAR)];
3288
3289 WideCharToMultiByte(CP_ACP, 0, szNumber, -1, szNumberA, sizeof(szNumberA), 0, 0);
3290
3291 bContinue = lpProcs->procA( lgrpid, lcid, szNumberA, lpProcs->lParam );
3292 }
3293 }
3294
3295 ulIndex++;
3296 }
3297 else
3298 {
3299 /* Finished enumerating this key */
3300 if (!bAlternate)
3301 {
3302 /* Enumerate alternate sorts also */
3303 hKey = NLS_RegOpenKey( hKey, szAlternateSortsKeyName );
3304 bAlternate = TRUE;
3305 ulIndex = 0;
3306 }
3307 else
3308 bContinue = FALSE; /* Finished both keys */
3309 }
3310
3311 if (!bContinue)
3312 break;
3313 }
3314
3315 if (hKey)
3316 NtClose( hKey );
3317
3318 return TRUE;
3319 }
3320
3321 /******************************************************************************
3322 * EnumLanguageGroupLocalesA (KERNEL32.@)
3323 *
3324 * Call a users function for every locale in a language group available on the system.
3325 *
3326 * PARAMS
3327 * pLangGrpLcEnumProc [I] Callback function to call for each locale
3328 * lgrpid [I] Language group (LGRPID_ values from "winnls.h")
3329 * dwFlags [I] Reserved, set to 0
3330 * lParam [I] User parameter to pass to pLangGrpLcEnumProc
3331 *
3332 * RETURNS
3333 * Success: TRUE.
3334 * Failure: FALSE. Use GetLastError() to determine the cause.
3335 */
3336 BOOL WINAPI EnumLanguageGroupLocalesA(LANGGROUPLOCALE_ENUMPROCA pLangGrpLcEnumProc,
3337 LGRPID lgrpid, DWORD dwFlags, LONG_PTR lParam)
3338 {
3339 ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
3340
3341 TRACE("(%p,0x%08X,0x%08X,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
3342
3343 callbacks.procA = pLangGrpLcEnumProc;
3344 callbacks.procW = NULL;
3345 callbacks.dwFlags = dwFlags;
3346 callbacks.lgrpid = lgrpid;
3347 callbacks.lParam = lParam;
3348
3349 return NLS_EnumLanguageGroupLocales( pLangGrpLcEnumProc ? &callbacks : NULL );
3350 }
3351
3352 /******************************************************************************
3353 * EnumLanguageGroupLocalesW (KERNEL32.@)
3354 *
3355 * See EnumLanguageGroupLocalesA.
3356 */
3357 BOOL WINAPI EnumLanguageGroupLocalesW(LANGGROUPLOCALE_ENUMPROCW pLangGrpLcEnumProc,
3358 LGRPID lgrpid, DWORD dwFlags, LONG_PTR lParam)
3359 {
3360 ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
3361
3362 TRACE("(%p,0x%08X,0x%08X,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
3363
3364 callbacks.procA = NULL;
3365 callbacks.procW = pLangGrpLcEnumProc;
3366 callbacks.dwFlags = dwFlags;
3367 callbacks.lgrpid = lgrpid;
3368 callbacks.lParam = lParam;
3369
3370 return NLS_EnumLanguageGroupLocales( pLangGrpLcEnumProc ? &callbacks : NULL );
3371 }
3372
3373 /******************************************************************************
3374 * EnumSystemGeoID (KERNEL32.@)
3375 *
3376 * Call a users function for every location available on the system.
3377 *
3378 * PARAMS
3379 * geoclass [I] Type of information desired (SYSGEOTYPE enum from "winnls.h")
3380 * reserved [I] Reserved, set to 0
3381 * pGeoEnumProc [I] Callback function to call for each location
3382 *
3383 * RETURNS
3384 * Success: TRUE.
3385 * Failure: FALSE. Use GetLastError() to determine the cause.
3386 */
3387 BOOL WINAPI EnumSystemGeoID(GEOCLASS geoclass, GEOID reserved, GEO_ENUMPROC pGeoEnumProc)
3388 {
3389 static const WCHAR szCountryCodeValueName[] = {
3390 'C','o','u','n','t','r','y','C','o','d','e','\0'
3391 };
3392 WCHAR szNumber[10];
3393 HANDLE hKey;
3394 ULONG ulIndex = 0;
3395
3396 TRACE("(0x%08X,0x%08X,%p)\n", geoclass, reserved, pGeoEnumProc);
3397
3398 if (geoclass != GEOCLASS_NATION || reserved || !pGeoEnumProc)
3399 {
3400 SetLastError(ERROR_INVALID_PARAMETER);
3401 return FALSE;
3402 }
3403
3404 hKey = NLS_RegOpenKey( 0, szCountryListName );
3405
3406 while (NLS_RegEnumSubKey( hKey, ulIndex, szNumber, sizeof(szNumber) ))
3407 {
3408 BOOL bContinue = TRUE;
3409 DWORD dwGeoId;
3410 HANDLE hSubKey = NLS_RegOpenKey( hKey, szNumber );
3411
3412 if (hSubKey)
3413 {
3414 if (NLS_RegGetDword( hSubKey, szCountryCodeValueName, &dwGeoId ))
3415 {
3416 TRACE("Got geoid %d\n", dwGeoId);
3417
3418 if (!pGeoEnumProc( dwGeoId ))
3419 bContinue = FALSE;
3420 }
3421
3422 NtClose( hSubKey );
3423 }
3424
3425 if (!bContinue)
3426 break;
3427
3428 ulIndex++;
3429 }
3430
3431 if (hKey)
3432 NtClose( hKey );
3433
3434 return TRUE;
3435 }
3436
3437 /******************************************************************************
3438 * InvalidateNLSCache (KERNEL32.@)
3439 *
3440 * Invalidate the cache of NLS values.
3441 *
3442 * PARAMS
3443 * None.
3444 *
3445 * RETURNS
3446 * Success: TRUE.
3447 * Failure: FALSE.
3448 */
3449 BOOL WINAPI InvalidateNLSCache(void)
3450 {
3451 FIXME("() stub\n");
3452 return FALSE;
3453 }
3454
3455 /******************************************************************************
3456 * GetUserGeoID (KERNEL32.@)
3457 */
3458 GEOID WINAPI GetUserGeoID( GEOCLASS GeoClass )
3459 {
3460 FIXME("%d\n",GeoClass);
3461 return GEOID_NOT_AVAILABLE;
3462 }
3463
3464 /******************************************************************************
3465 * SetUserGeoID (KERNEL32.@)
3466 */
3467 BOOL WINAPI SetUserGeoID( GEOID GeoID )
3468 {
3469 FIXME("%d\n",GeoID);
3470 return FALSE;
3471 }
3472
3473 typedef struct
3474 {
3475 union
3476 {
3477 UILANGUAGE_ENUMPROCA procA;
3478 UILANGUAGE_ENUMPROCW procW;
3479 } u;
3480 DWORD flags;
3481 LONG_PTR param;
3482 } ENUM_UILANG_CALLBACK;
3483
3484 static BOOL CALLBACK enum_uilang_proc_a( HMODULE hModule, LPCSTR type,
3485 LPCSTR name, WORD LangID, LONG_PTR lParam )
3486 {
3487 ENUM_UILANG_CALLBACK *enum_uilang = (ENUM_UILANG_CALLBACK *)lParam;
3488 char buf[20];
3489
3490 sprintf(buf, "%08x", (UINT)LangID);
3491 return enum_uilang->u.procA( buf, enum_uilang->param );
3492 }
3493
3494 static BOOL CALLBACK enum_uilang_proc_w( HMODULE hModule, LPCWSTR type,
3495 LPCWSTR name, WORD LangID, LONG_PTR lParam )
3496 {
3497 static const WCHAR formatW[] = {'%','0','8','x',0};
3498 ENUM_UILANG_CALLBACK *enum_uilang = (ENUM_UILANG_CALLBACK *)lParam;
3499 WCHAR buf[20];
3500
3501 sprintfW( buf, formatW, (UINT)LangID );
3502 return enum_uilang->u.procW( buf, enum_uilang->param );
3503 }
3504
3505 /******************************************************************************
3506 * EnumUILanguagesA (KERNEL32.@)
3507 */
3508 BOOL WINAPI EnumUILanguagesA(UILANGUAGE_ENUMPROCA pUILangEnumProc, DWORD dwFlags, LONG_PTR lParam)
3509 {
3510 ENUM_UILANG_CALLBACK enum_uilang;
3511
3512 TRACE("%p, %x, %lx\n", pUILangEnumProc, dwFlags, lParam);
3513
3514 if(!pUILangEnumProc) {
3515 SetLastError(ERROR_INVALID_PARAMETER);
3516 return FALSE;
3517 }
3518 if(dwFlags) {
3519 SetLastError(ERROR_INVALID_FLAGS);
3520 return FALSE;
3521 }
3522
3523 enum_uilang.u.procA = pUILangEnumProc;
3524 enum_uilang.flags = dwFlags;
3525 enum_uilang.param = lParam;
3526
3527 EnumResourceLanguagesA( kernel32_handle, (LPCSTR)RT_STRING,
3528 (LPCSTR)LOCALE_ILANGUAGE, enum_uilang_proc_a,
3529 (LONG_PTR)&enum_uilang);
3530 return TRUE;
3531 }
3532
3533 /******************************************************************************
3534 * EnumUILanguagesW (KERNEL32.@)
3535 */
3536 BOOL WINAPI EnumUILanguagesW(UILANGUAGE_ENUMPROCW pUILangEnumProc, DWORD dwFlags, LONG_PTR lParam)
3537 {
3538 ENUM_UILANG_CALLBACK enum_uilang;
3539
3540 TRACE("%p, %x, %lx\n", pUILangEnumProc, dwFlags, lParam);
3541
3542
3543 if(!pUILangEnumProc) {
3544 SetLastError(ERROR_INVALID_PARAMETER);
3545 return FALSE;
3546 }
3547 if(dwFlags) {
3548 SetLastError(ERROR_INVALID_FLAGS);
3549 return FALSE;
3550 }
3551
3552 enum_uilang.u.procW = pUILangEnumProc;
3553 enum_uilang.flags = dwFlags;
3554 enum_uilang.param = lParam;
3555
3556 EnumResourceLanguagesW( kernel32_handle, (LPCWSTR)RT_STRING,
3557 (LPCWSTR)LOCALE_ILANGUAGE, enum_uilang_proc_w,
3558 (LONG_PTR)&enum_uilang);
3559 return TRUE;
3560 }
3561
3562 INT WINAPI GetGeoInfoW(GEOID GeoId, GEOTYPE GeoType, LPWSTR lpGeoData,
3563 int cchData, LANGID language)
3564 {
3565 FIXME("%d %d %p %d %d\n", GeoId, GeoType, lpGeoData, cchData, language);
3566 return 0;
3567 }
3568
3569 INT WINAPI GetGeoInfoA(GEOID GeoId, GEOTYPE GeoType, LPSTR lpGeoData,
3570 int cchData, LANGID language)
3571 {
3572 FIXME("%d %d %p %d %d\n", GeoId, GeoType, lpGeoData, cchData, language);
3573 return 0;
3574 }
Work in progress by Kai Blin