We can now use the standard DllMain as entry point.
[wine] / dlls / kernel / locale.c
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <string.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <ctype.h>
31 #include <stdlib.h>
32
33 #include "ntstatus.h"
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winuser.h"  /* for RT_STRINGW */
37 #include "winreg.h"
38 #include "winternl.h"
39 #include "wine/unicode.h"
40 #include "winnls.h"
41 #include "winerror.h"
42 #include "thread.h"
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(nls);
46
47 #define LOCALE_LOCALEINFOFLAGSMASK (LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP|LOCALE_RETURN_NUMBER)
48
49 static const WCHAR kernel32W[] = { 'K','E','R','N','E','L','3','2','\0' };
50
51 extern void CODEPAGE_Init( UINT ansi_cp, UINT oem_cp, UINT mac_cp, UINT unix_cp, LCID lcid );
52
53 /* Charset to codepage map, sorted by name. */
54 static const struct charset_entry
55 {
56     const char *charset_name;
57     UINT        codepage;
58 } charset_names[] =
59 {
60     { "CP1250", 1250 },
61     { "CP1251", 1251 },
62     { "CP1252", 1252 },
63     { "CP1253", 1253 },
64     { "CP1254", 1254 },
65     { "CP1255", 1255 },
66     { "CP1256", 1256 },
67     { "CP1257", 1257 },
68     { "CP1258", 1258 },
69     { "IBM037", 37 },
70     { "IBM1026", 1026 },
71     { "IBM424", 424 },
72     { "IBM437", 437 },
73     { "IBM500", 500 },
74     { "IBM850", 850 },
75     { "IBM852", 852 },
76     { "IBM855", 855 },
77     { "IBM857", 857 },
78     { "IBM860", 860 },
79     { "IBM861", 861 },
80     { "IBM862", 862 },
81     { "IBM863", 863 },
82     { "IBM864", 864 },
83     { "IBM865", 865 },
84     { "IBM866", 866 },
85     { "IBM869", 869 },
86     { "IBM874", 874 },
87     { "IBM875", 875 },
88     { "ISO88591", 28591 },
89     { "ISO885910", 28600 },
90     { "ISO885913", 28603 },
91     { "ISO885914", 28604 },
92     { "ISO885915", 28605 },
93     { "ISO88592", 28592 },
94     { "ISO88593", 28593 },
95     { "ISO88594", 28594 },
96     { "ISO88595", 28595 },
97     { "ISO88596", 28596 },
98     { "ISO88597", 28597 },
99     { "ISO88598", 28598 },
100     { "ISO88599", 28599 },
101     { "KOI8R", 20866 },
102     { "KOI8U", 20866 },
103     { "UTF8", CP_UTF8 }
104 };
105
106 #define NLS_MAX_LANGUAGES 20
107 typedef struct {
108     char lang[128];
109     char country[128];
110     LANGID found_lang_id[NLS_MAX_LANGUAGES];
111     char found_language[NLS_MAX_LANGUAGES][3];
112     char found_country[NLS_MAX_LANGUAGES][3];
113     int n_found;
114 } LANG_FIND_DATA;
115
116
117 /***********************************************************************
118  *              get_lcid_codepage
119  *
120  * Retrieve the ANSI codepage for a given locale.
121  */
122 inline static UINT get_lcid_codepage( LCID lcid )
123 {
124     UINT ret;
125     if (!GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER, (WCHAR *)&ret,
126                          sizeof(ret)/sizeof(WCHAR) )) ret = 0;
127     return ret;
128 }
129
130
131 /***********************************************************************
132  *              create_registry_key
133  *
134  * Create the Control Panel\\International registry key.
135  */
136 inline static HKEY create_registry_key(void)
137 {
138     static const WCHAR intlW[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
139                                   'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
140     OBJECT_ATTRIBUTES attr;
141     UNICODE_STRING nameW;
142     HKEY hkey;
143
144     if (RtlOpenCurrentUser( KEY_ALL_ACCESS, &hkey ) != STATUS_SUCCESS) return 0;
145
146     attr.Length = sizeof(attr);
147     attr.RootDirectory = hkey;
148     attr.ObjectName = &nameW;
149     attr.Attributes = 0;
150     attr.SecurityDescriptor = NULL;
151     attr.SecurityQualityOfService = NULL;
152     RtlInitUnicodeString( &nameW, intlW );
153
154     if (NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS) hkey = 0;
155     NtClose( attr.RootDirectory );
156     return hkey;
157 }
158
159
160 /***********************************************************************
161  *              update_registry
162  *
163  * Update registry contents on startup if the user locale has changed.
164  * This simulates the action of the Windows control panel.
165  */
166 inline static void update_registry( LCID lcid )
167 {
168     static const USHORT updateValues[] = {
169       LOCALE_SLANGUAGE,
170       LOCALE_SCOUNTRY, LOCALE_ICOUNTRY,
171       LOCALE_S1159, LOCALE_S2359,
172       LOCALE_STIME, LOCALE_ITIME,
173       LOCALE_ITLZERO,
174       LOCALE_SSHORTDATE,
175       LOCALE_IDATE,
176       LOCALE_SLONGDATE,
177       LOCALE_SDATE,
178       LOCALE_SCURRENCY, LOCALE_ICURRENCY,
179       LOCALE_INEGCURR,
180       LOCALE_ICURRDIGITS,
181       LOCALE_SDECIMAL,
182       LOCALE_SLIST,
183       LOCALE_STHOUSAND,
184       LOCALE_IDIGITS,
185       LOCALE_IDIGITSUBSTITUTION,
186       LOCALE_SNATIVEDIGITS,
187       LOCALE_ITIMEMARKPOSN,
188       LOCALE_ICALENDARTYPE,
189       LOCALE_ILZERO,
190       LOCALE_IMEASURE
191     };
192     static const WCHAR LocaleW[] = {'L','o','c','a','l','e',0};
193     UNICODE_STRING nameW;
194     char buffer[20];
195     WCHAR bufferW[80];
196     DWORD count, i;
197     HKEY hkey;
198
199     if (!(hkey = create_registry_key()))
200         return;  /* don't do anything if we can't create the registry key */
201
202     RtlInitUnicodeString( &nameW, LocaleW );
203     count = sizeof(bufferW);
204     if (!NtQueryValueKey(hkey, &nameW, KeyValuePartialInformation, (LPBYTE)bufferW, count, &count))
205     {
206         const KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)bufferW;
207         LPCWSTR szValueText = (LPCWSTR)info->Data;
208
209         if (strtoulW( szValueText, NULL, 16 ) == lcid)  /* already set correctly */
210         {
211             NtClose( hkey );
212             return;
213         }
214         TRACE( "updating registry, locale changed %s -> %08lx\n", debugstr_w(szValueText), lcid );
215     }
216     else TRACE( "updating registry, locale changed none -> %08lx\n", lcid );
217
218     sprintf( buffer, "%08lx", lcid );
219     /* Note: '9' constant below is strlen(buffer) + 1 */
220     RtlMultiByteToUnicodeN( bufferW, sizeof(bufferW), NULL, buffer, 9 );
221     NtSetValueKey( hkey, &nameW, 0, REG_SZ, bufferW, 9 * sizeof(WCHAR) );
222     NtClose( hkey );
223
224     for (i = 0; i < sizeof(updateValues)/sizeof(updateValues[0]); i++)
225     {
226         GetLocaleInfoW( lcid, updateValues[i] | LOCALE_NOUSEROVERRIDE, bufferW,
227                         sizeof(bufferW)/sizeof(WCHAR) );
228         SetLocaleInfoW( lcid, updateValues[i], bufferW );
229     }
230 }
231
232
233 /***********************************************************************
234  *           find_language_id_proc
235  */
236 static BOOL CALLBACK find_language_id_proc( HMODULE hModule, LPCSTR type,
237                                             LPCSTR name, WORD LangID, LPARAM lParam )
238 {
239     LANG_FIND_DATA *l_data = (LANG_FIND_DATA *)lParam;
240     LCID lcid = MAKELCID(LangID, SORT_DEFAULT);
241     char buf_language[128];
242     char buf_country[128];
243     char buf_en_language[128];
244
245     TRACE("%04X\n", (UINT)LangID);
246     if(PRIMARYLANGID(LangID) == LANG_NEUTRAL)
247         return TRUE; /* continue search */
248
249     buf_language[0] = 0;
250     buf_country[0] = 0;
251
252     GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME|LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP,
253                    buf_language, sizeof(buf_language));
254     TRACE("LOCALE_SISO639LANGNAME: %s\n", buf_language);
255
256     GetLocaleInfoA(lcid, LOCALE_SISO3166CTRYNAME|LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP,
257                    buf_country, sizeof(buf_country));
258     TRACE("LOCALE_SISO3166CTRYNAME: %s\n", buf_country);
259
260     if(l_data->lang[0] && !strcasecmp(l_data->lang, buf_language))
261     {
262         if(l_data->country[0])
263         {
264             if(!strcasecmp(l_data->country, buf_country))
265             {
266                 l_data->found_lang_id[0] = LangID;
267                 l_data->n_found = 1;
268                 TRACE("Found lang_id %04X for %s_%s\n", LangID, l_data->lang, l_data->country);
269                 return FALSE; /* stop enumeration */
270             }
271         }
272         else /* l_data->country not specified */
273         {
274             if(l_data->n_found < NLS_MAX_LANGUAGES)
275             {
276                 l_data->found_lang_id[l_data->n_found] = LangID;
277                 strncpy(l_data->found_country[l_data->n_found], buf_country, 3);
278                 strncpy(l_data->found_language[l_data->n_found], buf_language, 3);
279                 l_data->n_found++;
280                 TRACE("Found lang_id %04X for %s\n", LangID, l_data->lang);
281                 return TRUE; /* continue search */
282             }
283         }
284     }
285
286     /* Just in case, check LOCALE_SENGLANGUAGE too,
287      * in hope that possible alias name might have that value.
288      */
289     buf_en_language[0] = 0;
290     GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE|LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP,
291                    buf_en_language, sizeof(buf_en_language));
292     TRACE("LOCALE_SENGLANGUAGE: %s\n", buf_en_language);
293
294     if(l_data->lang[0] && !strcasecmp(l_data->lang, buf_en_language))
295     {
296         l_data->found_lang_id[l_data->n_found] = LangID;
297         strncpy(l_data->found_country[l_data->n_found], buf_country, 3);
298         strncpy(l_data->found_language[l_data->n_found], buf_language, 3);
299         l_data->n_found++;
300         TRACE("Found lang_id %04X for %s\n", LangID, l_data->lang);
301     }
302
303     return TRUE; /* continue search */
304 }
305
306
307 /***********************************************************************
308  *           get_language_id
309  *
310  * INPUT:
311  *      Lang: a string whose two first chars are the iso name of a language.
312  *      Country: a string whose two first chars are the iso name of country
313  *      Charset: a string defining the chosen charset encoding
314  *      Dialect: a string defining a variation of the locale
315  *
316  *      all those values are from the standardized format of locale
317  *      name in unix which is: Lang[_Country][.Charset][@Dialect]
318  *
319  * RETURNS:
320  *      the numeric code of the language used by Windows
321  *
322  * FIXME: Charset and Dialect are not handled
323  */
324 static LANGID get_language_id(LPCSTR Lang, LPCSTR Country, LPCSTR Charset, LPCSTR Dialect)
325 {
326     LANG_FIND_DATA l_data;
327     char lang_string[256];
328     HMODULE hKernel32;
329
330     if(!Lang)
331     {
332         l_data.found_lang_id[0] = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
333         goto END;
334     }
335
336     memset(&l_data, 0, sizeof(LANG_FIND_DATA));
337     strncpy(l_data.lang, Lang, sizeof(l_data.lang));
338
339     if(Country && Country[0])
340         strncpy(l_data.country, Country, sizeof(l_data.country));
341
342     hKernel32 = GetModuleHandleW(kernel32W);
343
344     EnumResourceLanguagesA(hKernel32, (LPSTR)RT_STRING,
345                            (LPCSTR)LOCALE_ILANGUAGE, find_language_id_proc, (LPARAM)&l_data);
346
347     strcpy(lang_string, l_data.lang);
348     if(l_data.country[0])
349     {
350         strcat(lang_string, "_");
351         strcat(lang_string, l_data.country);
352     }
353
354     if(!l_data.n_found)
355     {
356         if(l_data.country[0])
357         {
358             MESSAGE("Warning: Language '%s' was not found, retrying without country name...\n", lang_string);
359             l_data.country[0] = 0;
360             EnumResourceLanguagesA(hKernel32, (LPSTR)RT_STRING,
361                                    (LPCSTR)LOCALE_ILANGUAGE, find_language_id_proc, (LONG)&l_data);
362         }
363     }
364
365     /* Re-evaluate lang_string */
366     strcpy(lang_string, l_data.lang);
367     if(l_data.country[0])
368     {
369         strcat(lang_string, "_");
370         strcat(lang_string, l_data.country);
371     }
372
373     if(!l_data.n_found)
374     {
375         MESSAGE("Warning: Language '%s' was not recognized, defaulting to English\n", lang_string);
376         l_data.found_lang_id[0] = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
377     }
378     else
379     {
380         if(l_data.n_found == 1)
381             TRACE("For language '%s' lang_id %04X was found\n", lang_string, l_data.found_lang_id[0]);
382         else /* l_data->n_found > 1 */
383         {
384             int i;
385             MESSAGE("For language '%s' several language ids were found:\n", lang_string);
386             for(i = 0; i < l_data.n_found; i++)
387                 MESSAGE("%s_%s - %04X; ", l_data.found_language[i], l_data.found_country[i], l_data.found_lang_id[i]);
388
389             MESSAGE("\nInstead of using first in the list, suggest to define\n"
390                     "your LANG environment variable like this: LANG=%s_%s\n",
391                     l_data.found_language[0], l_data.found_country[0]);
392         }
393     }
394 END:
395     TRACE("Returning %04X\n", l_data.found_lang_id[0]);
396     return l_data.found_lang_id[0];
397 }
398
399
400 /***********************************************************************
401  *              charset_cmp (internal)
402  */
403 static int charset_cmp( const void *name, const void *entry )
404 {
405     const struct charset_entry *charset = (struct charset_entry *)entry;
406     return strcasecmp( (char *)name, charset->charset_name );
407 }
408
409 /***********************************************************************
410  *              init_default_lcid
411  */
412 static LCID init_default_lcid( UINT *unix_cp )
413 {
414     char buf[256];
415     char *lang,*country,*charset,*dialect,*next;
416     LCID ret = 0;
417
418     if (GetEnvironmentVariableA( "LC_ALL", buf, sizeof(buf) ) ||
419         GetEnvironmentVariableA( "LC_CTYPE", buf, sizeof(buf) ) ||
420         GetEnvironmentVariableA( "LANGUAGE", buf, sizeof(buf) ) ||
421         GetEnvironmentVariableA( "LC_MESSAGES", buf, sizeof(buf) ) ||
422         GetEnvironmentVariableA( "LANG", buf, sizeof(buf) ))
423     {
424         if (!strcmp(buf,"POSIX") || !strcmp(buf,"C")) goto done;
425
426         lang=buf;
427
428         do {
429             next=strchr(lang,':'); if (next) *next++='\0';
430             dialect=strchr(lang,'@'); if (dialect) *dialect++='\0';
431             charset=strchr(lang,'.'); if (charset) *charset++='\0';
432             country=strchr(lang,'_'); if (country) *country++='\0';
433
434             ret = get_language_id(lang, country, charset, dialect);
435             if (ret && charset)
436             {
437                 const struct charset_entry *entry;
438                 char charset_name[16];
439                 size_t i, j;
440
441                 /* remove punctuation characters from charset name */
442                 for (i = j = 0; charset[i] && j < sizeof(charset_name)-1; i++)
443                     if (isalnum(charset[i])) charset_name[j++] = charset[i];
444                 charset_name[j] = 0;
445
446                 entry = bsearch( charset_name, charset_names,
447                                  sizeof(charset_names)/sizeof(charset_names[0]),
448                                  sizeof(charset_names[0]), charset_cmp );
449                 if (entry)
450                 {
451                     *unix_cp = entry->codepage;
452                     TRACE("charset %s was mapped to cp %u\n", charset, *unix_cp);
453                 }
454                 else
455                     FIXME("charset %s was not recognized\n", charset);
456             }
457
458             lang=next;
459         } while (lang && !ret);
460
461         if (!ret) MESSAGE("Warning: language '%s' not recognized, defaulting to English\n", buf);
462     }
463
464  done:
465     if (!ret) ret = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT) ;
466     return ret;
467 }
468
469
470 /******************************************************************************
471  *              get_locale_value_name
472  *
473  * Gets the registry value name for a given lctype.
474  */
475 static const WCHAR *get_locale_value_name( DWORD lctype )
476 {
477     static const WCHAR iCalendarTypeW[] = {'i','C','a','l','e','n','d','a','r','T','y','p','e',0};
478     static const WCHAR iCountryW[] = {'i','C','o','u','n','t','r','y',0};
479     static const WCHAR iCurrDigitsW[] = {'i','C','u','r','r','D','i','g','i','t','s',0};
480     static const WCHAR iCurrencyW[] = {'i','C','u','r','r','e','n','c','y',0};
481     static const WCHAR iDateW[] = {'i','D','a','t','e',0};
482     static const WCHAR iDigitsW[] = {'i','D','i','g','i','t','s',0};
483     static const WCHAR iFirstDayOfWeekW[] = {'i','F','i','r','s','t','D','a','y','O','f','W','e','e','k',0};
484     static const WCHAR iFirstWeekOfYearW[] = {'i','F','i','r','s','t','W','e','e','k','O','f','Y','e','a','r',0};
485     static const WCHAR iLDateW[] = {'i','L','D','a','t','e',0};
486     static const WCHAR iLZeroW[] = {'i','L','Z','e','r','o',0};
487     static const WCHAR iMeasureW[] = {'i','M','e','a','s','u','r','e',0};
488     static const WCHAR iNegCurrW[] = {'i','N','e','g','C','u','r','r',0};
489     static const WCHAR iNegNumberW[] = {'i','N','e','g','N','u','m','b','e','r',0};
490     static const WCHAR iPaperSizeW[] = {'i','P','a','p','e','r','S','i','z','e',0};
491     static const WCHAR iTLZeroW[] = {'i','T','L','Z','e','r','o',0};
492     static const WCHAR iTimePrefixW[] = {'i','T','i','m','e','P','r','e','f','i','x',0};
493     static const WCHAR iTimeW[] = {'i','T','i','m','e',0};
494     static const WCHAR s1159W[] = {'s','1','1','5','9',0};
495     static const WCHAR s2359W[] = {'s','2','3','5','9',0};
496     static const WCHAR sCountryW[] = {'s','C','o','u','n','t','r','y',0};
497     static const WCHAR sCurrencyW[] = {'s','C','u','r','r','e','n','c','y',0};
498     static const WCHAR sDateW[] = {'s','D','a','t','e',0};
499     static const WCHAR sDecimalW[] = {'s','D','e','c','i','m','a','l',0};
500     static const WCHAR sGroupingW[] = {'s','G','r','o','u','p','i','n','g',0};
501     static const WCHAR sLanguageW[] = {'s','L','a','n','g','u','a','g','e',0};
502     static const WCHAR sListW[] = {'s','L','i','s','t',0};
503     static const WCHAR sLongDateW[] = {'s','L','o','n','g','D','a','t','e',0};
504     static const WCHAR sMonDecimalSepW[] = {'s','M','o','n','D','e','c','i','m','a','l','S','e','p',0};
505     static const WCHAR sMonGroupingW[] = {'s','M','o','n','G','r','o','u','p','i','n','g',0};
506     static const WCHAR sMonThousandSepW[] = {'s','M','o','n','T','h','o','u','s','a','n','d','S','e','p',0};
507     static const WCHAR sNativeDigitsW[] = {'s','N','a','t','i','v','e','D','i','g','i','t','s',0};
508     static const WCHAR sNegativeSignW[] = {'s','N','e','g','a','t','i','v','e','S','i','g','n',0};
509     static const WCHAR sPositiveSignW[] = {'s','P','o','s','i','t','i','v','e','S','i','g','n',0};
510     static const WCHAR sShortDateW[] = {'s','S','h','o','r','t','D','a','t','e',0};
511     static const WCHAR sThousandW[] = {'s','T','h','o','u','s','a','n','d',0};
512     static const WCHAR sTimeFormatW[] = {'s','T','i','m','e','F','o','r','m','a','t',0};
513     static const WCHAR sTimeW[] = {'s','T','i','m','e',0};
514     static const WCHAR sYearMonthW[] = {'s','Y','e','a','r','M','o','n','t','h',0};
515     static const WCHAR NumShapeW[] = {'N','u','m','s','h','a','p','e',0};
516
517     switch (lctype & ~LOCALE_LOCALEINFOFLAGSMASK)
518     {
519     /* These values are used by SetLocaleInfo and GetLocaleInfo, and
520      * the values are stored in the registry, confirmed under Windows.
521      */
522     case LOCALE_ICALENDARTYPE:    return iCalendarTypeW;
523     case LOCALE_ICURRDIGITS:      return iCurrDigitsW;
524     case LOCALE_ICURRENCY:        return iCurrencyW;
525     case LOCALE_IDIGITS:          return iDigitsW;
526     case LOCALE_IFIRSTDAYOFWEEK:  return iFirstDayOfWeekW;
527     case LOCALE_IFIRSTWEEKOFYEAR: return iFirstWeekOfYearW;
528     case LOCALE_ILZERO:           return iLZeroW;
529     case LOCALE_IMEASURE:         return iMeasureW;
530     case LOCALE_INEGCURR:         return iNegCurrW;
531     case LOCALE_INEGNUMBER:       return iNegNumberW;
532     case LOCALE_IPAPERSIZE:       return iPaperSizeW;
533     case LOCALE_ITIME:            return iTimeW;
534     case LOCALE_S1159:            return s1159W;
535     case LOCALE_S2359:            return s2359W;
536     case LOCALE_SCURRENCY:        return sCurrencyW;
537     case LOCALE_SDATE:            return sDateW;
538     case LOCALE_SDECIMAL:         return sDecimalW;
539     case LOCALE_SGROUPING:        return sGroupingW;
540     case LOCALE_SLIST:            return sListW;
541     case LOCALE_SLONGDATE:        return sLongDateW;
542     case LOCALE_SMONDECIMALSEP:   return sMonDecimalSepW;
543     case LOCALE_SMONGROUPING:     return sMonGroupingW;
544     case LOCALE_SMONTHOUSANDSEP:  return sMonThousandSepW;
545     case LOCALE_SNEGATIVESIGN:    return sNegativeSignW;
546     case LOCALE_SPOSITIVESIGN:    return sPositiveSignW;
547     case LOCALE_SSHORTDATE:       return sShortDateW;
548     case LOCALE_STHOUSAND:        return sThousandW;
549     case LOCALE_STIME:            return sTimeW;
550     case LOCALE_STIMEFORMAT:      return sTimeFormatW;
551     case LOCALE_SYEARMONTH:       return sYearMonthW;
552
553     /* The following are not listed under MSDN as supported,
554      * but seem to be used and also stored in the registry.
555      */
556     case LOCALE_ICOUNTRY:         return iCountryW;
557     case LOCALE_IDATE:            return iDateW;
558     case LOCALE_ILDATE:           return iLDateW;
559     case LOCALE_ITLZERO:          return iTLZeroW;
560     case LOCALE_SCOUNTRY:         return sCountryW;
561     case LOCALE_SLANGUAGE:        return sLanguageW;
562
563     /* The following are used in XP and later */
564     case LOCALE_IDIGITSUBSTITUTION: return NumShapeW;
565     case LOCALE_SNATIVEDIGITS:      return sNativeDigitsW;
566     case LOCALE_ITIMEMARKPOSN:      return iTimePrefixW;
567     }
568     return NULL;
569 }
570
571
572 /******************************************************************************
573  *              get_registry_locale_info
574  *
575  * Retrieve user-modified locale info from the registry.
576  * Return length, 0 on error, -1 if not found.
577  */
578 static INT get_registry_locale_info( LPCWSTR value, LPWSTR buffer, INT len )
579 {
580     DWORD size;
581     INT ret;
582     HKEY hkey;
583     NTSTATUS status;
584     UNICODE_STRING nameW;
585     KEY_VALUE_PARTIAL_INFORMATION *info;
586     static const int info_size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
587
588     if (!(hkey = create_registry_key())) return -1;
589
590     RtlInitUnicodeString( &nameW, value );
591     size = info_size + len * sizeof(WCHAR);
592
593     if (!(info = HeapAlloc( GetProcessHeap(), 0, size )))
594     {
595         NtClose( hkey );
596         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
597         return 0;
598     }
599
600     status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, info, size, &size );
601     if (status == STATUS_BUFFER_OVERFLOW && !buffer) status = 0;
602
603     if (!status)
604     {
605         ret = (size - info_size) / sizeof(WCHAR);
606         /* append terminating null if needed */
607         if (!ret || ((WCHAR *)info->Data)[ret-1])
608         {
609             if (ret < len || !buffer) ret++;
610             else
611             {
612                 SetLastError( ERROR_INSUFFICIENT_BUFFER );
613                 ret = 0;
614             }
615         }
616         if (ret && buffer)
617         {
618             memcpy( buffer, info->Data, (ret-1) * sizeof(WCHAR) );
619             buffer[ret-1] = 0;
620         }
621     }
622     else
623     {
624         if (status == STATUS_OBJECT_NAME_NOT_FOUND) ret = -1;
625         else
626         {
627             SetLastError( RtlNtStatusToDosError(status) );
628             ret = 0;
629         }
630     }
631     NtClose( hkey );
632     HeapFree( GetProcessHeap(), 0, info );
633     return ret;
634 }
635
636
637 /******************************************************************************
638  *              GetLocaleInfoA (KERNEL32.@)
639  *
640  * Get information about an aspect of a locale.
641  *
642  * PARAMS
643  *  lcid   [I] LCID of the locale
644  *  lctype [I] LCTYPE_ flags from "winnls.h"
645  *  buffer [O] Destination for the information
646  *  len    [I] Length of buffer in characters
647  *
648  * RETURNS
649  *  Success: The size of the data requested. If buffer is non-NULL, it is filled
650  *           with the information.
651  *  Failure: 0. Use GetLastError() to determine the cause.
652  *
653  * NOTES
654  *  - LOCALE_NEUTRAL is equal to LOCALE_SYSTEM_DEFAULT
655  *  - The string returned is NUL terminated, except for LOCALE_FONTSIGNATURE,
656  *    which is a bit string.
657  */
658 INT WINAPI GetLocaleInfoA( LCID lcid, LCTYPE lctype, LPSTR buffer, INT len )
659 {
660     WCHAR *bufferW;
661     INT lenW, ret;
662
663     if (len < 0 || (len && !buffer))
664     {
665         SetLastError( ERROR_INVALID_PARAMETER );
666         return 0;
667     }
668     if (!len) buffer = NULL;
669
670     if (!(lenW = GetLocaleInfoW( lcid, lctype, NULL, 0 ))) return 0;
671
672     if (!(bufferW = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
673     {
674         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
675         return 0;
676     }
677     if ((ret = GetLocaleInfoW( lcid, lctype, bufferW, lenW )))
678     {
679         if ((lctype & LOCALE_RETURN_NUMBER) ||
680             ((lctype & ~LOCALE_LOCALEINFOFLAGSMASK) == LOCALE_FONTSIGNATURE))
681         {
682             /* it's not an ASCII string, just bytes */
683             ret *= sizeof(WCHAR);
684             if (buffer)
685             {
686                 if (ret <= len) memcpy( buffer, bufferW, ret );
687                 else
688                 {
689                     SetLastError( ERROR_INSUFFICIENT_BUFFER );
690                     ret = 0;
691                 }
692             }
693         }
694         else
695         {
696             UINT codepage = CP_ACP;
697             if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
698             ret = WideCharToMultiByte( codepage, 0, bufferW, ret, buffer, len, NULL, NULL );
699         }
700     }
701     HeapFree( GetProcessHeap(), 0, bufferW );
702     return ret;
703 }
704
705
706 /******************************************************************************
707  *              GetLocaleInfoW (KERNEL32.@)
708  *
709  * See GetLocaleInfoA.
710  */
711 INT WINAPI GetLocaleInfoW( LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len )
712 {
713     LANGID lang_id;
714     HRSRC hrsrc;
715     HGLOBAL hmem;
716     HMODULE hModule;
717     INT ret;
718     UINT lcflags;
719     const WCHAR *p;
720     unsigned int i;
721
722     if (len < 0 || (len && !buffer))
723     {
724         SetLastError( ERROR_INVALID_PARAMETER );
725         return 0;
726     }
727     if (!len) buffer = NULL;
728
729     lcid = ConvertDefaultLocale(lcid);
730
731     lcflags = lctype & LOCALE_LOCALEINFOFLAGSMASK;
732     lctype &= ~LOCALE_LOCALEINFOFLAGSMASK;
733
734     /* first check for overrides in the registry */
735
736     if (!(lcflags & LOCALE_NOUSEROVERRIDE) && lcid == GetUserDefaultLCID())
737     {
738         const WCHAR *value = get_locale_value_name(lctype);
739
740         if (value && ((ret = get_registry_locale_info( value, buffer, len )) != -1)) return ret;
741     }
742
743     /* now load it from kernel resources */
744
745     lang_id = LANGIDFROMLCID( lcid );
746
747     /* replace SUBLANG_NEUTRAL by SUBLANG_DEFAULT */
748     if (SUBLANGID(lang_id) == SUBLANG_NEUTRAL)
749         lang_id = MAKELANGID(PRIMARYLANGID(lang_id), SUBLANG_DEFAULT);
750
751     hModule = GetModuleHandleW( kernel32W );
752     if (!(hrsrc = FindResourceExW( hModule, (LPWSTR)RT_STRING, (LPCWSTR)((lctype >> 4) + 1), lang_id )))
753     {
754         SetLastError( ERROR_INVALID_FLAGS );  /* no such lctype */
755         return 0;
756     }
757     if (!(hmem = LoadResource( hModule, hrsrc )))
758         return 0;
759
760     p = LockResource( hmem );
761     for (i = 0; i < (lctype & 0x0f); i++) p += *p + 1;
762
763     if (lcflags & LOCALE_RETURN_NUMBER) ret = sizeof(UINT)/sizeof(WCHAR);
764     else ret = (lctype == LOCALE_FONTSIGNATURE) ? *p : *p + 1;
765
766     if (!buffer) return ret;
767
768     if (ret > len)
769     {
770         SetLastError( ERROR_INSUFFICIENT_BUFFER );
771         return 0;
772     }
773
774     if (lcflags & LOCALE_RETURN_NUMBER)
775     {
776         UINT number;
777         WCHAR *end, *tmp = HeapAlloc( GetProcessHeap(), 0, (*p + 1) * sizeof(WCHAR) );
778         if (!tmp) return 0;
779         memcpy( tmp, p + 1, *p * sizeof(WCHAR) );
780         tmp[*p] = 0;
781         number = strtolW( tmp, &end, 10 );
782         if (!*end)
783             memcpy( buffer, &number, sizeof(number) );
784         else  /* invalid number */
785         {
786             SetLastError( ERROR_INVALID_FLAGS );
787             ret = 0;
788         }
789         HeapFree( GetProcessHeap(), 0, tmp );
790
791         TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning number %d\n",
792                lcid, lctype, buffer, len, number );
793     }
794     else
795     {
796         memcpy( buffer, p + 1, *p * sizeof(WCHAR) );
797         if (lctype != LOCALE_FONTSIGNATURE) buffer[ret-1] = 0;
798
799         TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning %d %s\n",
800                lcid, lctype, buffer, len, ret, debugstr_w(buffer) );
801     }
802     return ret;
803 }
804
805
806 /******************************************************************************
807  *              SetLocaleInfoA  [KERNEL32.@]
808  *
809  * Set information about an aspect of a locale.
810  *
811  * PARAMS
812  *  lcid   [I] LCID of the locale
813  *  lctype [I] LCTYPE_ flags from "winnls.h"
814  *  data   [I] Information to set
815  *
816  * RETURNS
817  *  Success: TRUE. The information given will be returned by GetLocaleInfoA()
818  *           whenever it is called without LOCALE_NOUSEROVERRIDE.
819  *  Failure: FALSE. Use GetLastError() to determine the cause.
820  *
821  * NOTES
822  *  - Values are only be set for the current user locale; the system locale
823  *  settings cannot be changed.
824  *  - Any settings changed by this call are lost when the locale is changed by
825  *  the control panel (in Wine, this happens every time you change LANG).
826  *  - The native implementation of this function does not check that lcid matches
827  *  the current user locale, and simply sets the new values. Wine warns you in
828  *  this case, but behaves the same.
829  */
830 BOOL WINAPI SetLocaleInfoA(LCID lcid, LCTYPE lctype, LPCSTR data)
831 {
832     UINT codepage = CP_ACP;
833     WCHAR *strW;
834     DWORD len;
835     BOOL ret;
836
837     lcid = ConvertDefaultLocale(lcid);
838
839     if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
840     len = MultiByteToWideChar( codepage, 0, data, -1, NULL, 0 );
841     if (!(strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
842     {
843         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
844         return FALSE;
845     }
846     MultiByteToWideChar( codepage, 0, data, -1, strW, len );
847     ret = SetLocaleInfoW( lcid, lctype, strW );
848     HeapFree( GetProcessHeap(), 0, strW );
849     return ret;
850 }
851
852
853 /******************************************************************************
854  *              SetLocaleInfoW  (KERNEL32.@)
855  *
856  * See SetLocaleInfoA.
857  */
858 BOOL WINAPI SetLocaleInfoW( LCID lcid, LCTYPE lctype, LPCWSTR data )
859 {
860     const WCHAR *value;
861     const WCHAR intlW[] = {'i','n','t','l',0 };
862     UNICODE_STRING valueW;
863     NTSTATUS status;
864     HKEY hkey;
865
866     lcid = ConvertDefaultLocale(lcid);
867
868     lctype &= ~LOCALE_LOCALEINFOFLAGSMASK;
869     value = get_locale_value_name( lctype );
870
871     if (!data || !value)
872     {
873         SetLastError( ERROR_INVALID_PARAMETER );
874         return FALSE;
875     }
876
877     if (lctype == LOCALE_IDATE || lctype == LOCALE_ILDATE)
878     {
879         SetLastError( ERROR_INVALID_FLAGS );
880         return FALSE;
881     }
882
883     if (lcid != GetUserDefaultLCID())
884     {
885         /* Windows does not check that the lcid matches the current lcid */
886         WARN("locale 0x%08lx isn't the current locale (0x%08lx), setting anyway!\n",
887              lcid, GetUserDefaultLCID());
888     }
889
890     TRACE("setting %lx to %s\n", lctype, debugstr_w(data) );
891
892     /* FIXME: should check that data to set is sane */
893
894     /* FIXME: profile functions should map to registry */
895     WriteProfileStringW( intlW, value, data );
896
897     if (!(hkey = create_registry_key())) return FALSE;
898     RtlInitUnicodeString( &valueW, value );
899     status = NtSetValueKey( hkey, &valueW, 0, REG_SZ, data, (strlenW(data)+1)*sizeof(WCHAR) );
900
901     if (lctype == LOCALE_SDATE || lctype == LOCALE_SLONGDATE)
902     {
903       /* Set I-value from S value */
904       WCHAR *lpD, *lpM, *lpY;
905       WCHAR szBuff[2];
906
907       lpD = strchrW(data, 'd');
908       lpM = strchrW(data, 'M');
909       lpY = strchrW(data, 'y');
910
911       if (lpD <= lpM)
912       {
913         szBuff[0] = '1'; /* D-M-Y */
914       }
915       else
916       {
917         if (lpY <= lpM)
918           szBuff[0] = '2'; /* Y-M-D */
919         else
920           szBuff[0] = '0'; /* M-D-Y */
921       }
922
923       szBuff[1] = '\0';
924
925       if (lctype == LOCALE_SDATE)
926         lctype = LOCALE_IDATE;
927       else
928         lctype = LOCALE_ILDATE;
929
930       value = get_locale_value_name( lctype );
931
932       WriteProfileStringW( intlW, value, szBuff );
933
934       RtlInitUnicodeString( &valueW, value );
935       status = NtSetValueKey( hkey, &valueW, 0, REG_SZ, szBuff, sizeof(szBuff) );
936     }
937
938     NtClose( hkey );
939
940     if (status) SetLastError( RtlNtStatusToDosError(status) );
941     return !status;
942 }
943
944
945 /***********************************************************************
946  *           GetThreadLocale    (KERNEL32.@)
947  *
948  * Get the current threads locale.
949  *
950  * PARAMS
951  *  None.
952  *
953  * RETURNS
954  *  The LCID currently assocated with the calling thread.
955  */
956 LCID WINAPI GetThreadLocale(void)
957 {
958     LCID ret = NtCurrentTeb()->CurrentLocale;
959     if (!ret) NtCurrentTeb()->CurrentLocale = ret = GetUserDefaultLCID();
960     return ret;
961 }
962
963 /**********************************************************************
964  *           SetThreadLocale    (KERNEL32.@)
965  *
966  * Set the current threads locale.
967  *
968  * PARAMS
969  *  lcid [I] LCID of the locale to set
970  *
971  * RETURNS
972  *  Success: TRUE. The threads locale is set to lcid.
973  *  Failure: FALSE. Use GetLastError() to determine the cause.
974  */
975 BOOL WINAPI SetThreadLocale( LCID lcid )
976 {
977     TRACE("(0x%04lX)\n", lcid);
978
979     lcid = ConvertDefaultLocale(lcid);
980
981     if (lcid != GetThreadLocale())
982     {
983         if (!IsValidLocale(lcid, LCID_SUPPORTED))
984         {
985             SetLastError(ERROR_INVALID_PARAMETER);
986             return FALSE;
987         }
988
989         NtCurrentTeb()->CurrentLocale = lcid;
990         NtCurrentTeb()->code_page = get_lcid_codepage( lcid );
991     }
992     return TRUE;
993 }
994
995 /******************************************************************************
996  *              ConvertDefaultLocale (KERNEL32.@)
997  *
998  * Convert a default locale identifier into a real identifier.
999  *
1000  * PARAMS
1001  *  lcid [I] LCID identifier of the locale to convert
1002  *
1003  * RETURNS
1004  *  lcid unchanged, if not a default locale or is its sublanguage is
1005  *   not SUBLANG_NEUTRAL.
1006  *  GetSystemDefaultLCID(), if lcid == LOCALE_SYSTEM_DEFAULT.
1007  *  GetUserDefaultLCID(), if lcid == LOCALE_USER_DEFAULT or LOCALE_NEUTRAL.
1008  *  Otherwise, lcid with sublanguage cheanged to SUBLANG_DEFAULT.
1009  */
1010 LCID WINAPI ConvertDefaultLocale( LCID lcid )
1011 {
1012     LANGID langid;
1013
1014     switch (lcid)
1015     {
1016     case LOCALE_SYSTEM_DEFAULT:
1017         lcid = GetSystemDefaultLCID();
1018         break;
1019     case LOCALE_USER_DEFAULT:
1020     case LOCALE_NEUTRAL:
1021         lcid = GetUserDefaultLCID();
1022         break;
1023     default:
1024         /* Replace SUBLANG_NEUTRAL with SUBLANG_DEFAULT */
1025         langid = LANGIDFROMLCID(lcid);
1026         if (SUBLANGID(langid) == SUBLANG_NEUTRAL)
1027         {
1028           langid = MAKELANGID(PRIMARYLANGID(langid), SUBLANG_DEFAULT);
1029           lcid = MAKELCID(langid, SORTIDFROMLCID(lcid));
1030         }
1031     }
1032     return lcid;
1033 }
1034
1035
1036 /******************************************************************************
1037  *           IsValidLocale   (KERNEL32.@)
1038  *
1039  * Determine if a locale is valid.
1040  *
1041  * PARAMS
1042  *  lcid  [I] LCID of the locale to check
1043  *  flags [I] LCID_SUPPORTED = Valid, LCID_INSTALLED = Valid and installed on the system
1044  *
1045  * RETURN
1046  *  TRUE,  if lcid is valid,
1047  *  FALSE, otherwise.
1048  *
1049  * NOTES
1050  *  Wine does not currently make the distinction between supported and installed. All
1051  *  languages supported are installed by default.
1052  */
1053 BOOL WINAPI IsValidLocale( LCID lcid, DWORD flags )
1054 {
1055     /* check if language is registered in the kernel32 resources */
1056     return FindResourceExW( GetModuleHandleW(kernel32W), (LPWSTR)RT_STRING,
1057                             (LPCWSTR)LOCALE_ILANGUAGE, LANGIDFROMLCID(lcid)) != 0;
1058 }
1059
1060
1061 static BOOL CALLBACK enum_lang_proc_a( HMODULE hModule, LPCSTR type,
1062                                        LPCSTR name, WORD LangID, LONG lParam )
1063 {
1064     LOCALE_ENUMPROCA lpfnLocaleEnum = (LOCALE_ENUMPROCA)lParam;
1065     char buf[20];
1066
1067     sprintf(buf, "%08x", (UINT)LangID);
1068     return lpfnLocaleEnum( buf );
1069 }
1070
1071 static BOOL CALLBACK enum_lang_proc_w( HMODULE hModule, LPCWSTR type,
1072                                        LPCWSTR name, WORD LangID, LONG lParam )
1073 {
1074     static const WCHAR formatW[] = {'%','0','8','x',0};
1075     LOCALE_ENUMPROCW lpfnLocaleEnum = (LOCALE_ENUMPROCW)lParam;
1076     WCHAR buf[20];
1077     sprintfW( buf, formatW, (UINT)LangID );
1078     return lpfnLocaleEnum( buf );
1079 }
1080
1081 /******************************************************************************
1082  *           EnumSystemLocalesA  (KERNEL32.@)
1083  *
1084  * Call a users function for each locale available on the system.
1085  *
1086  * PARAMS
1087  *  lpfnLocaleEnum [I] Callback function to call for each locale
1088  *  dwFlags        [I] LOCALE_SUPPORTED=All supported, LOCALE_INSTALLED=Installed only
1089  *
1090  * RETURNS
1091  *  Success: TRUE.
1092  *  Failure: FALSE. Use GetLastError() to determine the cause.
1093  */
1094 BOOL WINAPI EnumSystemLocalesA( LOCALE_ENUMPROCA lpfnLocaleEnum, DWORD dwFlags )
1095 {
1096     TRACE("(%p,%08lx)\n", lpfnLocaleEnum, dwFlags);
1097     EnumResourceLanguagesA( GetModuleHandleW(kernel32W), (LPSTR)RT_STRING,
1098                             (LPCSTR)LOCALE_ILANGUAGE, enum_lang_proc_a,
1099                             (LONG)lpfnLocaleEnum);
1100     return TRUE;
1101 }
1102
1103
1104 /******************************************************************************
1105  *           EnumSystemLocalesW  (KERNEL32.@)
1106  *
1107  * See EnumSystemLocalesA.
1108  */
1109 BOOL WINAPI EnumSystemLocalesW( LOCALE_ENUMPROCW lpfnLocaleEnum, DWORD dwFlags )
1110 {
1111     TRACE("(%p,%08lx)\n", lpfnLocaleEnum, dwFlags);
1112     EnumResourceLanguagesW( GetModuleHandleW(kernel32W), (LPWSTR)RT_STRING,
1113                             (LPCWSTR)LOCALE_ILANGUAGE, enum_lang_proc_w,
1114                             (LONG)lpfnLocaleEnum);
1115     return TRUE;
1116 }
1117
1118
1119 /***********************************************************************
1120  *           VerLanguageNameA  (KERNEL32.@)
1121  *
1122  * Get the name of a language.
1123  *
1124  * PARAMS
1125  *  wLang  [I] LANGID of the language
1126  *  szLang [O] Destination for the language name
1127  *
1128  * RETURNS
1129  *  Success: The size of the language name. If szLang is non-NULL, it is filled
1130  *           with the name.
1131  *  Failure: 0. Use GetLastError() to determine the cause.
1132  *
1133  */
1134 DWORD WINAPI VerLanguageNameA( UINT wLang, LPSTR szLang, UINT nSize )
1135 {
1136     return GetLocaleInfoA( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
1137 }
1138
1139
1140 /***********************************************************************
1141  *           VerLanguageNameW  (KERNEL32.@)
1142  *
1143  * See VerLanguageNameA.
1144  */
1145 DWORD WINAPI VerLanguageNameW( UINT wLang, LPWSTR szLang, UINT nSize )
1146 {
1147     return GetLocaleInfoW( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
1148 }
1149
1150
1151 /******************************************************************************
1152  *           GetStringTypeW    (KERNEL32.@)
1153  */
1154 BOOL WINAPI GetStringTypeW( DWORD type, LPCWSTR src, INT count, LPWORD chartype )
1155 {
1156     if (count == -1) count = strlenW(src) + 1;
1157     switch(type)
1158     {
1159     case CT_CTYPE1:
1160         while (count--) *chartype++ = get_char_typeW( *src++ ) & 0xfff;
1161         break;
1162     case CT_CTYPE2:
1163         while (count--) *chartype++ = get_char_typeW( *src++ ) >> 12;
1164         break;
1165     case CT_CTYPE3:
1166     {
1167         WARN("CT_CTYPE3: semi-stub.\n");
1168         while (count--)
1169         {
1170             int c = *src;
1171             WORD type1, type3 = 0; /* C3_NOTAPPLICABLE */
1172
1173             type1 = get_char_typeW( *src++ ) & 0xfff;
1174             /* try to construct type3 from type1 */
1175             if(type1 & C1_SPACE) type3 |= C3_SYMBOL;
1176             if(type1 & C1_ALPHA) type3 |= C3_ALPHA;
1177             if ((c>=0x30A0)&&(c<=0x30FF)) type3 |= C3_KATAKANA;
1178             if ((c>=0x3040)&&(c<=0x309F)) type3 |= C3_HIRAGANA;
1179             if ((c>=0x4E00)&&(c<=0x9FAF)) type3 |= C3_IDEOGRAPH;
1180             if ((c>=0x0600)&&(c<=0x06FF)) type3 |= C3_KASHIDA;
1181             if ((c>=0x3000)&&(c<=0x303F)) type3 |= C3_SYMBOL;
1182
1183             if ((c>=0xFF00)&&(c<=0xFF60)) type3 |= C3_FULLWIDTH;
1184             if ((c>=0xFF00)&&(c<=0xFF20)) type3 |= C3_SYMBOL;
1185             if ((c>=0xFF3B)&&(c<=0xFF40)) type3 |= C3_SYMBOL;
1186             if ((c>=0xFF5B)&&(c<=0xFF60)) type3 |= C3_SYMBOL;
1187             if ((c>=0xFF21)&&(c<=0xFF3A)) type3 |= C3_ALPHA;
1188             if ((c>=0xFF41)&&(c<=0xFF5A)) type3 |= C3_ALPHA;
1189             if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_FULLWIDTH;
1190             if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_SYMBOL;
1191
1192             if ((c>=0xFF61)&&(c<=0xFFDC)) type3 |= C3_HALFWIDTH;
1193             if ((c>=0xFF61)&&(c<=0xFF64)) type3 |= C3_SYMBOL;
1194             if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_KATAKANA;
1195             if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_ALPHA;
1196             if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_HALFWIDTH;
1197             if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_SYMBOL;
1198             *chartype++ = type3;
1199         }
1200         break;
1201     }
1202     default:
1203         SetLastError( ERROR_INVALID_PARAMETER );
1204         return FALSE;
1205     }
1206     return TRUE;
1207 }
1208
1209
1210 /******************************************************************************
1211  *           GetStringTypeExW    (KERNEL32.@)
1212  */
1213 BOOL WINAPI GetStringTypeExW( LCID locale, DWORD type, LPCWSTR src, INT count, LPWORD chartype )
1214 {
1215     /* locale is ignored for Unicode */
1216     return GetStringTypeW( type, src, count, chartype );
1217 }
1218
1219
1220 /******************************************************************************
1221  *           GetStringTypeA    (KERNEL32.@)
1222  */
1223 BOOL WINAPI GetStringTypeA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
1224 {
1225     UINT cp;
1226     INT countW;
1227     LPWSTR srcW;
1228     BOOL ret = FALSE;
1229
1230     if(count == -1) count = strlen(src) + 1;
1231
1232     if (!(cp = get_lcid_codepage( locale )))
1233     {
1234         FIXME("For locale %04lx using current ANSI code page\n", locale);
1235         cp = GetACP();
1236     }
1237
1238     countW = MultiByteToWideChar(cp, 0, src, count, NULL, 0);
1239     if((srcW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
1240     {
1241         MultiByteToWideChar(cp, 0, src, count, srcW, countW);
1242     /*
1243      * NOTE: the target buffer has 1 word for each CHARACTER in the source
1244      * string, with multibyte characters there maybe be more bytes in count
1245      * than character space in the buffer!
1246      */
1247         ret = GetStringTypeW(type, srcW, countW, chartype);
1248         HeapFree(GetProcessHeap(), 0, srcW);
1249     }
1250     return ret;
1251 }
1252
1253 /******************************************************************************
1254  *           GetStringTypeExA    (KERNEL32.@)
1255  */
1256 BOOL WINAPI GetStringTypeExA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
1257 {
1258     return GetStringTypeA(locale, type, src, count, chartype);
1259 }
1260
1261
1262 /*************************************************************************
1263  *           LCMapStringW    (KERNEL32.@)
1264  */
1265 INT WINAPI LCMapStringW(LCID lcid, DWORD flags, LPCWSTR src, INT srclen,
1266                         LPWSTR dst, INT dstlen)
1267 {
1268     LPWSTR dst_ptr;
1269
1270     if (!src || !srclen || dstlen < 0)
1271     {
1272         SetLastError(ERROR_INVALID_PARAMETER);
1273         return 0;
1274     }
1275
1276     /* mutually exclusive flags */
1277     if ((flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE)) == (LCMAP_LOWERCASE | LCMAP_UPPERCASE) ||
1278         (flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA)) == (LCMAP_HIRAGANA | LCMAP_KATAKANA) ||
1279         (flags & (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) == (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH) ||
1280         (flags & (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE)) == (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE))
1281     {
1282         SetLastError(ERROR_INVALID_FLAGS);
1283         return 0;
1284     }
1285
1286     if (!dstlen) dst = NULL;
1287
1288     lcid = ConvertDefaultLocale(lcid);
1289
1290     if (flags & LCMAP_SORTKEY)
1291     {
1292         if (src == dst)
1293         {
1294             SetLastError(ERROR_INVALID_FLAGS);
1295             return 0;
1296         }
1297
1298         if (srclen < 0) srclen = strlenW(src);
1299
1300         TRACE("(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
1301               lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
1302
1303         return wine_get_sortkey(flags, src, srclen, (char *)dst, dstlen);
1304     }
1305
1306     /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
1307     if (flags & SORT_STRINGSORT)
1308     {
1309         SetLastError(ERROR_INVALID_FLAGS);
1310         return 0;
1311     }
1312
1313     if (srclen < 0) srclen = strlenW(src) + 1;
1314
1315     TRACE("(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
1316           lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
1317
1318     if (!dst) /* return required string length */
1319     {
1320         INT len;
1321
1322         for (len = 0; srclen; src++, srclen--)
1323         {
1324             WCHAR wch = *src;
1325             /* tests show that win2k just ignores NORM_IGNORENONSPACE,
1326              * and skips white space and punctuation characters for
1327              * NORM_IGNORESYMBOLS.
1328              */
1329             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1330                 continue;
1331             len++;
1332         }
1333         return len;
1334     }
1335
1336     if (flags & LCMAP_UPPERCASE)
1337     {
1338         for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
1339         {
1340             WCHAR wch = *src;
1341             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1342                 continue;
1343             *dst_ptr++ = toupperW(wch);
1344             dstlen--;
1345         }
1346     }
1347     else if (flags & LCMAP_LOWERCASE)
1348     {
1349         for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
1350         {
1351             WCHAR wch = *src;
1352             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1353                 continue;
1354             *dst_ptr++ = tolowerW(wch);
1355             dstlen--;
1356         }
1357     }
1358     else
1359     {
1360         if (src == dst)
1361         {
1362             SetLastError(ERROR_INVALID_FLAGS);
1363             return 0;
1364         }
1365         for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
1366         {
1367             WCHAR wch = *src;
1368             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1369                 continue;
1370             *dst_ptr++ = wch;
1371             dstlen--;
1372         }
1373     }
1374
1375     return dst_ptr - dst;
1376 }
1377
1378 /*************************************************************************
1379  *           LCMapStringA    (KERNEL32.@)
1380  */
1381 INT WINAPI LCMapStringA(LCID lcid, DWORD flags, LPCSTR src, INT srclen,
1382                         LPSTR dst, INT dstlen)
1383 {
1384     WCHAR bufW[128];
1385     LPWSTR srcW, dstW;
1386     INT ret = 0, srclenW, dstlenW;
1387     UINT locale_cp;
1388
1389     if (!src || !srclen || dstlen < 0)
1390     {
1391         SetLastError(ERROR_INVALID_PARAMETER);
1392         return 0;
1393     }
1394
1395     locale_cp = get_lcid_codepage(lcid);
1396
1397     srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, bufW, 128);
1398     if (srclenW)
1399         srcW = bufW;
1400     else
1401     {
1402         srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, NULL, 0);
1403         srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
1404         if (!srcW)
1405         {
1406             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1407             return 0;
1408         }
1409         MultiByteToWideChar(locale_cp, 0, src, srclen, srcW, srclenW);
1410     }
1411
1412     if (flags & LCMAP_SORTKEY)
1413     {
1414         if (src == dst)
1415         {
1416             SetLastError(ERROR_INVALID_FLAGS);
1417             goto map_string_exit;
1418         }
1419         ret = wine_get_sortkey(flags, srcW, srclenW, dst, dstlen);
1420         goto map_string_exit;
1421     }
1422
1423     if (flags & SORT_STRINGSORT)
1424     {
1425         SetLastError(ERROR_INVALID_FLAGS);
1426         goto map_string_exit;
1427     }
1428
1429     dstlenW = LCMapStringW(lcid, flags, srcW, srclenW, NULL, 0);
1430     dstW = HeapAlloc(GetProcessHeap(), 0, dstlenW * sizeof(WCHAR));
1431     if (!dstW)
1432     {
1433         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1434         goto map_string_exit;
1435     }
1436
1437     LCMapStringW(lcid, flags, srcW, srclenW, dstW, dstlenW);
1438     ret = WideCharToMultiByte(locale_cp, 0, dstW, dstlenW, dst, dstlen, NULL, NULL);
1439     HeapFree(GetProcessHeap(), 0, dstW);
1440
1441 map_string_exit:
1442     if (srcW != bufW) HeapFree(GetProcessHeap(), 0, srcW);
1443     return ret;
1444 }
1445
1446 /******************************************************************************
1447  *           CompareStringW    (KERNEL32.@)
1448  */
1449 INT WINAPI CompareStringW(LCID lcid, DWORD style,
1450                           LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)
1451 {
1452     INT ret, len;
1453
1454     if (!str1 || !str2)
1455     {
1456         SetLastError(ERROR_INVALID_PARAMETER);
1457         return 0;
1458     }
1459
1460     if (len1 < 0) len1 = lstrlenW(str1);
1461     if (len2 < 0) len2 = lstrlenW(str2);
1462
1463     len = (len1 < len2) ? len1 : len2;
1464     ret = (style & NORM_IGNORECASE) ? strncmpiW(str1, str2, len) :
1465                                       strncmpW(str1, str2, len);
1466
1467     if (ret) /* need to translate result */
1468         return (ret < 0) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
1469
1470     if (len1 == len2) return CSTR_EQUAL;
1471     /* the longer one is lexically greater */
1472     return (len1 < len2) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
1473 }
1474
1475 /******************************************************************************
1476  *           CompareStringA    (KERNEL32.@)
1477  */
1478 INT WINAPI CompareStringA(LCID lcid, DWORD style,
1479                           LPCSTR str1, INT len1, LPCSTR str2, INT len2)
1480 {
1481     WCHAR buf1W[128], buf2W[128];
1482     LPWSTR str1W, str2W;
1483     INT len1W, len2W, ret;
1484     UINT locale_cp;
1485
1486     if (!str1 || !str2)
1487     {
1488         SetLastError(ERROR_INVALID_PARAMETER);
1489         return 0;
1490     }
1491
1492     if (len1 < 0) len1 = strlen(str1);
1493     if (len2 < 0) len2 = strlen(str2);
1494
1495     locale_cp = get_lcid_codepage(lcid);
1496
1497     len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, buf1W, 128);
1498     if (len1W)
1499         str1W = buf1W;
1500     else
1501     {
1502         len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, NULL, 0);
1503         str1W = HeapAlloc(GetProcessHeap(), 0, len1W * sizeof(WCHAR));
1504         if (!str1W)
1505         {
1506             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1507             return 0;
1508         }
1509         MultiByteToWideChar(locale_cp, 0, str1, len1, str1W, len1W);
1510     }
1511     len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, buf2W, 128);
1512     if (len2W)
1513         str2W = buf2W;
1514     else
1515     {
1516         len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, NULL, 0);
1517         str2W = HeapAlloc(GetProcessHeap(), 0, len2W * sizeof(WCHAR));
1518         if (!str2W)
1519         {
1520             if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
1521             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1522             return 0;
1523         }
1524         MultiByteToWideChar(locale_cp, 0, str2, len2, str2W, len2W);
1525     }
1526
1527     ret = CompareStringW(lcid, style, str1W, len1W, str2W, len2W);
1528
1529     if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
1530     if (str2W != buf2W) HeapFree(GetProcessHeap(), 0, str2W);
1531     return ret;
1532 }
1533
1534 /*************************************************************************
1535  *           lstrcmp     (KERNEL32.@)
1536  *           lstrcmpA    (KERNEL32.@)
1537  */
1538 int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
1539 {
1540     int ret = CompareStringA(GetThreadLocale(), 0, str1, -1, str2, -1);
1541     if (ret) ret -= 2;
1542     return ret;
1543 }
1544
1545 /*************************************************************************
1546  *           lstrcmpi     (KERNEL32.@)
1547  *           lstrcmpiA    (KERNEL32.@)
1548  */
1549 int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
1550 {
1551     int ret = CompareStringA(GetThreadLocale(), NORM_IGNORECASE, str1, -1, str2, -1);
1552     if (ret) ret -= 2;
1553     return ret;
1554 }
1555
1556 /*************************************************************************
1557  *           lstrcmpW    (KERNEL32.@)
1558  */
1559 int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
1560 {
1561     int ret = CompareStringW(GetThreadLocale(), 0, str1, -1, str2, -1);
1562     if (ret) ret -= 2;
1563     return ret;
1564 }
1565
1566 /*************************************************************************
1567  *           lstrcmpiW    (KERNEL32.@)
1568  */
1569 int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
1570 {
1571     int ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, -1, str2, -1);
1572     if (ret) ret -= 2;
1573     return ret;
1574 }
1575
1576 /******************************************************************************
1577  *              LOCALE_Init
1578  */
1579 void LOCALE_Init(void)
1580 {
1581     UINT ansi_cp = 1252, oem_cp = 437, mac_cp = 10000, unix_cp = ~0U;
1582     LCID lcid = init_default_lcid( &unix_cp );
1583
1584     NtSetDefaultLocale( FALSE, lcid );
1585     NtSetDefaultLocale( TRUE, lcid );
1586
1587     ansi_cp = get_lcid_codepage(lcid);
1588     GetLocaleInfoW( lcid, LOCALE_IDEFAULTMACCODEPAGE | LOCALE_RETURN_NUMBER,
1589                     (LPWSTR)&mac_cp, sizeof(mac_cp)/sizeof(WCHAR) );
1590     GetLocaleInfoW( lcid, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
1591                     (LPWSTR)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR) );
1592     if (unix_cp == ~0U)
1593         GetLocaleInfoW( lcid, LOCALE_IDEFAULTUNIXCODEPAGE | LOCALE_RETURN_NUMBER,
1594                     (LPWSTR)&unix_cp, sizeof(unix_cp)/sizeof(WCHAR) );
1595
1596     CODEPAGE_Init( ansi_cp, oem_cp, mac_cp, unix_cp, lcid );
1597     update_registry( lcid );
1598 }
1599
1600 static HKEY NLS_RegOpenKey(HKEY hRootKey, LPCWSTR szKeyName)
1601 {
1602     UNICODE_STRING keyName;
1603     OBJECT_ATTRIBUTES attr;
1604     HKEY hkey;
1605
1606     RtlInitUnicodeString( &keyName, szKeyName );
1607     InitializeObjectAttributes(&attr, &keyName, 0, hRootKey, NULL);
1608
1609     if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) != STATUS_SUCCESS)
1610         hkey = 0;
1611
1612     return hkey;
1613 }
1614
1615 static HKEY NLS_RegOpenSubKey(HKEY hRootKey, LPCWSTR szKeyName)
1616 {
1617     HKEY hKey = NLS_RegOpenKey(hRootKey, szKeyName);
1618
1619     if (hRootKey)
1620         NtClose( hRootKey );
1621
1622     return hKey;
1623 }
1624
1625 static BOOL NLS_RegEnumSubKey(HKEY hKey, UINT ulIndex, LPWSTR szKeyName,
1626                               ULONG keyNameSize)
1627 {
1628     BYTE buffer[80];
1629     KEY_BASIC_INFORMATION *info = (KEY_BASIC_INFORMATION *)buffer;
1630     DWORD dwLen;
1631
1632     if (NtEnumerateKey( hKey, ulIndex, KeyBasicInformation, buffer,
1633                         sizeof(buffer), &dwLen) != STATUS_SUCCESS ||
1634         info->NameLength > keyNameSize)
1635     {
1636         return FALSE;
1637     }
1638
1639     TRACE("info->Name %s info->NameLength %ld\n", debugstr_w(info->Name), info->NameLength);
1640
1641     memcpy( szKeyName, info->Name, info->NameLength);
1642     szKeyName[info->NameLength / sizeof(WCHAR)] = '\0';
1643
1644     TRACE("returning %s\n", debugstr_w(szKeyName));
1645     return TRUE;
1646 }
1647
1648 static BOOL NLS_RegEnumValue(HKEY hKey, UINT ulIndex,
1649                              LPWSTR szValueName, ULONG valueNameSize,
1650                              LPWSTR szValueData, ULONG valueDataSize)
1651 {
1652     BYTE buffer[80];
1653     KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
1654     DWORD dwLen;
1655
1656     if (NtEnumerateValueKey( hKey, ulIndex, KeyValueFullInformation,
1657         buffer, sizeof(buffer), &dwLen ) != STATUS_SUCCESS ||
1658         info->NameLength > valueNameSize ||
1659         info->DataLength > valueDataSize)
1660     {
1661         return FALSE;
1662     }
1663
1664     TRACE("info->Name %s info->DataLength %ld\n", debugstr_w(info->Name), info->DataLength);
1665
1666     memcpy( szValueName, info->Name, info->NameLength);
1667     szValueName[info->NameLength / sizeof(WCHAR)] = '\0';
1668     memcpy( szValueData, buffer + info->DataOffset, info->DataLength );
1669     szValueData[info->DataLength / sizeof(WCHAR)] = '\0';
1670
1671     TRACE("returning %s %s\n", debugstr_w(szValueName), debugstr_w(szValueData));
1672     return TRUE;
1673 }
1674
1675 static BOOL NLS_RegGetDword(HKEY hKey, LPCWSTR szValueName, DWORD *lpVal)
1676 {
1677     BYTE buffer[128];
1678     const KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
1679     DWORD dwSize = sizeof(buffer);
1680     UNICODE_STRING valueName;
1681
1682     RtlInitUnicodeString( &valueName, szValueName );
1683
1684     TRACE("%p, %s\n", hKey, debugstr_w(szValueName));
1685     if (NtQueryValueKey( hKey, &valueName, KeyValuePartialInformation,
1686                          buffer, dwSize, &dwSize ) == STATUS_SUCCESS &&
1687         info->DataLength == sizeof(DWORD))
1688     {
1689         memcpy(lpVal, info->Data, sizeof(DWORD));
1690         return TRUE;
1691     }
1692
1693     return FALSE;
1694 }
1695
1696 static BOOL NLS_GetLanguageGroupName(LGRPID lgrpid, LPWSTR szName, ULONG nameSize)
1697 {
1698     HMODULE hModule = GetModuleHandleW(kernel32W);
1699     LANGID  langId;
1700     LPCWSTR szResourceName = (LPCWSTR)(((lgrpid + 0x2000) >> 4) + 1);
1701     HRSRC   hResource;
1702     BOOL    bRet = FALSE;
1703
1704     /* FIXME: Is it correct to use the system default langid? */
1705     langId = GetSystemDefaultLangID();
1706
1707     if (SUBLANGID(langId) == SUBLANG_NEUTRAL)
1708         langId = MAKELANGID( PRIMARYLANGID(langId), SUBLANG_DEFAULT );
1709
1710     hResource = FindResourceExW( hModule, (LPWSTR)RT_STRING, szResourceName, langId );
1711
1712     if (hResource)
1713     {
1714         HGLOBAL hResDir = LoadResource( hModule, hResource );
1715
1716         if (hResDir)
1717         {
1718             ULONG   iResourceIndex = lgrpid & 0xf;
1719             LPCWSTR lpResEntry = LockResource( hResDir );
1720             ULONG   i;
1721
1722             for (i = 0; i < iResourceIndex; i++)
1723                 lpResEntry += *lpResEntry + 1;
1724
1725             if (*lpResEntry < nameSize)
1726             {
1727                 memcpy( szName, lpResEntry + 1, *lpResEntry * sizeof(WCHAR) );
1728                 szName[*lpResEntry] = '\0';
1729                 bRet = TRUE;
1730             }
1731
1732         }
1733         FreeResource( hResource );
1734     }
1735     return bRet;
1736 }
1737
1738 /* Registry keys for NLS related information */
1739 static const WCHAR szNlsKeyName[] = {
1740     'M','a','c','h','i','n','e','\\','S','y','s','t','e','m','\\',
1741     'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1742     'C','o','n','t','r','o','l','\\','N','l','s','\0'
1743 };
1744
1745 static const WCHAR szLangGroupsKeyName[] = {
1746     'L','a','n','g','u','a','g','e',' ','G','r','o','u','p','s','\0'
1747 };
1748
1749 static const WCHAR szCountryListName[] = {
1750     'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\',
1751     'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
1752     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1753     'T','e','l','e','p','h','o','n','y','\\',
1754     'C','o','u','n','t','r','y',' ','L','i','s','t','\0'
1755 };
1756
1757
1758 /* Callback function ptrs for EnumSystemLanguageGroupsA/W */
1759 typedef struct
1760 {
1761   LANGUAGEGROUP_ENUMPROCA procA;
1762   LANGUAGEGROUP_ENUMPROCW procW;
1763   DWORD    dwFlags;
1764   LONG_PTR lParam;
1765 } ENUMLANGUAGEGROUP_CALLBACKS;
1766
1767 /* Internal implementation of EnumSystemLanguageGroupsA/W */
1768 static BOOL NLS_EnumSystemLanguageGroups(ENUMLANGUAGEGROUP_CALLBACKS *lpProcs)
1769 {
1770     WCHAR szNumber[10], szValue[4];
1771     HKEY hKey;
1772     BOOL bContinue = TRUE;
1773     ULONG ulIndex = 0;
1774
1775     if (!lpProcs)
1776     {
1777         SetLastError(ERROR_INVALID_PARAMETER);
1778         return FALSE;
1779     }
1780
1781     switch (lpProcs->dwFlags)
1782     {
1783     case 0:
1784         /* Default to LGRPID_INSTALLED */
1785         lpProcs->dwFlags = LGRPID_INSTALLED;
1786         /* Fall through... */
1787     case LGRPID_INSTALLED:
1788     case LGRPID_SUPPORTED:
1789         break;
1790     default:
1791         SetLastError(ERROR_INVALID_FLAGS);
1792         return FALSE;
1793     }
1794
1795     hKey = NLS_RegOpenSubKey( NLS_RegOpenKey( 0, szNlsKeyName ), szLangGroupsKeyName );
1796
1797     if (!hKey)
1798       WARN("NLS registry key not found. Please apply the default registry file 'winedefault.reg'\n");
1799
1800     while (bContinue)
1801     {
1802         if (NLS_RegEnumValue( hKey, ulIndex, szNumber, sizeof(szNumber),
1803                               szValue, sizeof(szValue) ))
1804         {
1805             BOOL bInstalled = szValue[0] == '1' ? TRUE : FALSE;
1806             LGRPID lgrpid = strtoulW( szNumber, NULL, 16 );
1807
1808             TRACE("grpid %s (%sinstalled)\n", debugstr_w(szNumber),
1809                    bInstalled ? "" : "not ");
1810
1811             if (lpProcs->dwFlags == LGRPID_SUPPORTED || bInstalled)
1812             {
1813                 WCHAR szGrpName[48];
1814
1815                 if (!NLS_GetLanguageGroupName( lgrpid, szGrpName, sizeof(szGrpName) / sizeof(WCHAR) ))
1816                     szGrpName[0] = '\0';
1817
1818                 if (lpProcs->procW)
1819                     bContinue = lpProcs->procW( lgrpid, szNumber, szGrpName, lpProcs->dwFlags,
1820                                                 lpProcs->lParam );
1821                 else
1822                 {
1823                     char szNumberA[sizeof(szNumber)/sizeof(WCHAR)];
1824                     char szGrpNameA[48];
1825
1826                     /* FIXME: MSDN doesn't say which code page the W->A translation uses,
1827                      *        or whether the language names are ever localised. Assume CP_ACP.
1828                      */
1829
1830                     WideCharToMultiByte(CP_ACP, 0, szNumber, -1, szNumberA, sizeof(szNumberA), 0, 0);
1831                     WideCharToMultiByte(CP_ACP, 0, szGrpName, -1, szGrpNameA, sizeof(szGrpNameA), 0, 0);
1832
1833                     bContinue = lpProcs->procA( lgrpid, szNumberA, szGrpNameA, lpProcs->dwFlags,
1834                                                 lpProcs->lParam );
1835                 }
1836             }
1837
1838             ulIndex++;
1839         }
1840         else
1841             bContinue = FALSE;
1842
1843         if (!bContinue)
1844             break;
1845     }
1846
1847     if (hKey)
1848         NtClose( hKey );
1849
1850     return TRUE;
1851 }
1852
1853 /******************************************************************************
1854  *           EnumSystemLanguageGroupsA    (KERNEL32.@)
1855  *
1856  * Call a users function for each language group available on the system.
1857  *
1858  * PARAMS
1859  *  pLangGrpEnumProc [I] Callback function to call for each language group
1860  *  dwFlags          [I] LGRPID_SUPPORTED=All Supported, LGRPID_INSTALLED=Installed only
1861  *  lParam           [I] User parameter to pass to pLangGrpEnumProc
1862  *
1863  * RETURNS
1864  *  Success: TRUE.
1865  *  Failure: FALSE. Use GetLastError() to determine the cause.
1866  */
1867 BOOL WINAPI EnumSystemLanguageGroupsA(LANGUAGEGROUP_ENUMPROCA pLangGrpEnumProc,
1868                                       DWORD dwFlags, LONG_PTR lParam)
1869 {
1870     ENUMLANGUAGEGROUP_CALLBACKS procs;
1871
1872     TRACE("(%p,0x%08lX,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
1873
1874     procs.procA = pLangGrpEnumProc;
1875     procs.procW = NULL;
1876     procs.dwFlags = dwFlags;
1877     procs.lParam = lParam;
1878
1879     return NLS_EnumSystemLanguageGroups( pLangGrpEnumProc ? &procs : NULL);
1880 }
1881
1882 /******************************************************************************
1883  *           EnumSystemLanguageGroupsW    (KERNEL32.@)
1884  *
1885  * See EnumSystemLanguageGroupsA.
1886  */
1887 BOOL WINAPI EnumSystemLanguageGroupsW(LANGUAGEGROUP_ENUMPROCW pLangGrpEnumProc,
1888                                       DWORD dwFlags, LONG_PTR lParam)
1889 {
1890     ENUMLANGUAGEGROUP_CALLBACKS procs;
1891
1892     TRACE("(%p,0x%08lX,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
1893
1894     procs.procA = NULL;
1895     procs.procW = pLangGrpEnumProc;
1896     procs.dwFlags = dwFlags;
1897     procs.lParam = lParam;
1898
1899     return NLS_EnumSystemLanguageGroups( pLangGrpEnumProc ? &procs : NULL);
1900 }
1901
1902 /******************************************************************************
1903  *           IsValidLanguageGroup    (KERNEL32.@)
1904  *
1905  * Determine if a language group is supported and/or installed.
1906  *
1907  * PARAMS
1908  *  lgrpid  [I] Language Group Id (LGRPID_ values from "winnls.h")
1909  *  dwFlags [I] LGRPID_SUPPORTED=Supported, LGRPID_INSTALLED=Installed
1910  *
1911  * RETURNS
1912  *  TRUE, if lgrpid is supported and/or installed, according to dwFlags.
1913  *  FALSE otherwise.
1914  */
1915 BOOL WINAPI IsValidLanguageGroup(LGRPID lgrpid, DWORD dwFlags)
1916 {
1917     static const WCHAR szFormat[] = { '%','x','\0' };
1918     WCHAR szValueName[16], szValue[2];
1919     BOOL bSupported = FALSE, bInstalled = FALSE;
1920     HKEY hKey;
1921
1922
1923     switch (dwFlags)
1924     {
1925     case LGRPID_INSTALLED:
1926     case LGRPID_SUPPORTED:
1927
1928         hKey = NLS_RegOpenSubKey( NLS_RegOpenKey( 0, szNlsKeyName ), szLangGroupsKeyName );
1929
1930         sprintfW( szValueName, szFormat, lgrpid );
1931
1932         if (NLS_RegGetDword( hKey, szValueName, (LPDWORD)&szValue ))
1933         {
1934             bSupported = TRUE;
1935
1936             if (szValue[0] == '1')
1937                 bInstalled = TRUE;
1938         }
1939
1940         if (hKey)
1941             NtClose( hKey );
1942
1943         break;
1944     }
1945
1946     if ((dwFlags == LGRPID_SUPPORTED && bSupported) ||
1947         (dwFlags == LGRPID_INSTALLED && bInstalled))
1948         return TRUE;
1949
1950     return FALSE;
1951 }
1952
1953 /* Callback function ptrs for EnumLanguageGrouplocalesA/W */
1954 typedef struct
1955 {
1956   LANGGROUPLOCALE_ENUMPROCA procA;
1957   LANGGROUPLOCALE_ENUMPROCW procW;
1958   DWORD    dwFlags;
1959   LGRPID   lgrpid;
1960   LONG_PTR lParam;
1961 } ENUMLANGUAGEGROUPLOCALE_CALLBACKS;
1962
1963 /* Internal implementation of EnumLanguageGrouplocalesA/W */
1964 static BOOL NLS_EnumLanguageGroupLocales(ENUMLANGUAGEGROUPLOCALE_CALLBACKS *lpProcs)
1965 {
1966     static const WCHAR szLocaleKeyName[] = {
1967       'L','o','c','a','l','e','\0'
1968     };
1969     static const WCHAR szAlternateSortsKeyName[] = {
1970       'A','l','t','e','r','n','a','t','e',' ','S','o','r','t','s','\0'
1971     };
1972     WCHAR szNumber[10], szValue[4];
1973     HKEY hKey;
1974     BOOL bContinue = TRUE, bAlternate = FALSE;
1975     LGRPID lgrpid;
1976     ULONG ulIndex = 1;  /* Ignore default entry of 1st key */
1977
1978     if (!lpProcs || !lpProcs->lgrpid || lpProcs->lgrpid > LGRPID_ARMENIAN)
1979     {
1980         SetLastError(ERROR_INVALID_PARAMETER);
1981         return FALSE;
1982     }
1983
1984     if (lpProcs->dwFlags)
1985     {
1986         SetLastError(ERROR_INVALID_FLAGS);
1987         return FALSE;
1988     }
1989
1990     hKey = NLS_RegOpenSubKey( NLS_RegOpenKey( 0, szNlsKeyName ), szLocaleKeyName );
1991
1992     if (!hKey)
1993       WARN("NLS registry key not found. Please apply the default registry file 'winedefault.reg'\n");
1994
1995     while (bContinue)
1996     {
1997         if (NLS_RegEnumValue( hKey, ulIndex, szNumber, sizeof(szNumber),
1998                               szValue, sizeof(szValue) ))
1999         {
2000             lgrpid = strtoulW( szValue, NULL, 16 );
2001
2002             TRACE("lcid %s, grpid %ld (%smatched)\n", debugstr_w(szNumber),
2003                    lgrpid, lgrpid == lpProcs->lgrpid ? "" : "not ");
2004
2005             if (lgrpid == lpProcs->lgrpid)
2006             {
2007                 LCID lcid;
2008
2009                 lcid = strtoulW( szNumber, NULL, 16 );
2010
2011                 /* FIXME: native returns extra text for a few (17/150) locales, e.g:
2012                  * '00000437          ;Georgian'
2013                  * At present we only pass the LCID string.
2014                  */
2015
2016                 if (lpProcs->procW)
2017                     bContinue = lpProcs->procW( lgrpid, lcid, szNumber, lpProcs->lParam );
2018                 else
2019                 {
2020                     char szNumberA[sizeof(szNumber)/sizeof(WCHAR)];
2021
2022                     WideCharToMultiByte(CP_ACP, 0, szNumber, -1, szNumberA, sizeof(szNumberA), 0, 0);
2023
2024                     bContinue = lpProcs->procA( lgrpid, lcid, szNumberA, lpProcs->lParam );
2025                 }
2026             }
2027
2028             ulIndex++;
2029         }
2030         else
2031         {
2032             /* Finished enumerating this key */
2033             if (!bAlternate)
2034             {
2035                 /* Enumerate alternate sorts also */
2036                 hKey = NLS_RegOpenKey( hKey, szAlternateSortsKeyName );
2037                 bAlternate = TRUE;
2038                 ulIndex = 0;
2039             }
2040             else
2041                 bContinue = FALSE; /* Finished both keys */
2042         }
2043
2044         if (!bContinue)
2045             break;
2046     }
2047
2048     if (hKey)
2049         NtClose( hKey );
2050
2051     return TRUE;
2052 }
2053
2054 /******************************************************************************
2055  *           EnumLanguageGroupLocalesA    (KERNEL32.@)
2056  *
2057  * Call a users function for every locale in a language group available on the system.
2058  *
2059  * PARAMS
2060  *  pLangGrpLcEnumProc [I] Callback function to call for each locale
2061  *  lgrpid             [I] Language group (LGRPID_ values from "winnls.h")
2062  *  dwFlags            [I] Reserved, set to 0
2063  *  lParam             [I] User parameter to pass to pLangGrpLcEnumProc
2064  *
2065  * RETURNS
2066  *  Success: TRUE.
2067  *  Failure: FALSE. Use GetLastError() to determine the cause.
2068  */
2069 BOOL WINAPI EnumLanguageGroupLocalesA(LANGGROUPLOCALE_ENUMPROCA pLangGrpLcEnumProc,
2070                                       LGRPID lgrpid, DWORD dwFlags, LONG_PTR lParam)
2071 {
2072     ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
2073
2074     TRACE("(%p,0x%08lX,0x%08lX,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
2075
2076     callbacks.procA   = pLangGrpLcEnumProc;
2077     callbacks.procW   = NULL;
2078     callbacks.dwFlags = dwFlags;
2079     callbacks.lgrpid  = lgrpid;
2080     callbacks.lParam  = lParam;
2081
2082     return NLS_EnumLanguageGroupLocales( pLangGrpLcEnumProc ? &callbacks : NULL );
2083 }
2084
2085 /******************************************************************************
2086  *           EnumLanguageGroupLocalesW    (KERNEL32.@)
2087  *
2088  * See EnumLanguageGroupLocalesA.
2089  */
2090 BOOL WINAPI EnumLanguageGroupLocalesW(LANGGROUPLOCALE_ENUMPROCW pLangGrpLcEnumProc,
2091                                       LGRPID lgrpid, DWORD dwFlags, LONG_PTR lParam)
2092 {
2093     ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
2094
2095     TRACE("(%p,0x%08lX,0x%08lX,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
2096
2097     callbacks.procA   = NULL;
2098     callbacks.procW   = pLangGrpLcEnumProc;
2099     callbacks.dwFlags = dwFlags;
2100     callbacks.lgrpid  = lgrpid;
2101     callbacks.lParam  = lParam;
2102
2103     return NLS_EnumLanguageGroupLocales( pLangGrpLcEnumProc ? &callbacks : NULL );
2104 }
2105
2106 /******************************************************************************
2107  *           EnumSystemGeoID    (KERNEL32.@)
2108  *
2109  * Call a users function for every location available on the system.
2110  *
2111  * PARAMS
2112  *  geoclass     [I] Type of information desired (SYSGEOTYPE enum from "winnls.h")
2113  *  reserved     [I] Reserved, set to 0
2114  *  pGeoEnumProc [I] Callback function to call for each location
2115  *
2116  * RETURNS
2117  *  Success: TRUE.
2118  *  Failure: FALSE. Use GetLastError() to determine the cause.
2119  */
2120 BOOL WINAPI EnumSystemGeoID(GEOCLASS geoclass, GEOID reserved, GEO_ENUMPROC pGeoEnumProc)
2121 {
2122     static const WCHAR szCountryCodeValueName[] = {
2123       'C','o','u','n','t','r','y','C','o','d','e','\0'
2124     };
2125     WCHAR szNumber[10];
2126     HKEY hKey;
2127     ULONG ulIndex = 0;
2128
2129     TRACE("(0x%08lX,0x%08lX,%p)\n", geoclass, reserved, pGeoEnumProc);
2130
2131     if (geoclass != GEOCLASS_NATION || reserved || !pGeoEnumProc)
2132     {
2133         SetLastError(ERROR_INVALID_PARAMETER);
2134         return FALSE;
2135     }
2136
2137     hKey = NLS_RegOpenKey( 0, szCountryListName );
2138
2139     while (NLS_RegEnumSubKey( hKey, ulIndex, szNumber, sizeof(szNumber) ))
2140     {
2141         BOOL bContinue = TRUE;
2142         DWORD dwGeoId;
2143         HKEY hSubKey = NLS_RegOpenKey( hKey, szNumber );
2144
2145         if (hSubKey)
2146         {
2147             if (NLS_RegGetDword( hSubKey, szCountryCodeValueName, &dwGeoId ))
2148             {
2149                 TRACE("Got geoid %ld\n", dwGeoId);
2150
2151                 if (!pGeoEnumProc( dwGeoId ))
2152                     bContinue = FALSE;
2153             }
2154
2155             NtClose( hSubKey );
2156         }
2157
2158         if (!bContinue)
2159             break;
2160
2161         ulIndex++;
2162     }
2163
2164     if (hKey)
2165         NtClose( hKey );
2166
2167     return TRUE;
2168 }
2169
2170 /******************************************************************************
2171  *           InvalidateNLSCache           (KERNEL32.@)
2172  *
2173  * Invalidate the cache of NLS values.
2174  *
2175  * PARAMS
2176  *  None.
2177  *
2178  * RETURNS
2179  *  Success: TRUE.
2180  *  Failure: FALSE.
2181  */
2182 BOOL WINAPI InvalidateNLSCache(void)
2183 {
2184   FIXME("() stub\n");
2185   return FALSE;
2186 }
2187
2188 /******************************************************************************
2189  *           GetUserGeoID (KERNEL32.@)
2190  */
2191 GEOID WINAPI GetUserGeoID( GEOCLASS GeoClass )
2192 {
2193     FIXME("%ld\n",GeoClass);
2194     return GEOID_NOT_AVAILABLE;
2195 }
2196
2197 /******************************************************************************
2198  *           SetUserGeoID (KERNEL32.@)
2199  */
2200 BOOL WINAPI SetUserGeoID( GEOID GeoID )
2201 {
2202     FIXME("%ld\n",GeoID);
2203     return FALSE;
2204 }