git.oblomov.eu Git - wine/blob - 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 extern void CODEPAGE_Init( UINT ansi_cp, UINT oem_cp, UINT mac_cp, UINT unix_cp, LCID lcid );
  50
  51 /* Charset to codepage map, sorted by name. */
  52 static const struct charset_entry
  53 {
  54     const char *charset_name;
  55     UINT        codepage;
  56 } charset_names[] =
  57 {
  58     { "CP1250", 1250 },
  59     { "CP1251", 1251 },
  60     { "CP1252", 1252 },
  61     { "CP1253", 1253 },
  62     { "CP1254", 1254 },
  63     { "CP1255", 1255 },
  64     { "CP1256", 1256 },
  65     { "CP1257", 1257 },
  66     { "CP1258", 1258 },
  67     { "IBM037", 37 },
  68     { "IBM1026", 1026 },
  69     { "IBM424", 424 },
  70     { "IBM437", 437 },
  71     { "IBM500", 500 },
  72     { "IBM850", 850 },
  73     { "IBM852", 852 },
  74     { "IBM855", 855 },
  75     { "IBM857", 857 },
  76     { "IBM860", 860 },
  77     { "IBM861", 861 },
  78     { "IBM862", 862 },
  79     { "IBM863", 863 },
  80     { "IBM864", 864 },
  81     { "IBM865", 865 },
  82     { "IBM866", 866 },
  83     { "IBM869", 869 },
  84     { "IBM874", 874 },
  85     { "IBM875", 875 },
  86     { "ISO-8859-1", 28591 },
  87     { "ISO-8859-10", 28600 },
  88     { "ISO-8859-13", 28603 },
  89     { "ISO-8859-14", 28604 },
  90     { "ISO-8859-15", 28605 },
  91     { "ISO-8859-2", 28592 },
  92     { "ISO-8859-3", 28593 },
  93     { "ISO-8859-4", 28594 },
  94     { "ISO-8859-5", 28595 },
  95     { "ISO-8859-6", 28596 },
  96     { "ISO-8859-7", 28597 },
  97     { "ISO-8859-8", 28598 },
  98     { "ISO-8859-9", 28599 },
  99     { "ISO_8859-1", 28591 },
 100     { "ISO_8859-10", 28600 },
 101     { "ISO_8859-13", 28603 },
 102     { "ISO_8859-14", 28604 },
 103     { "ISO_8859-15", 28605 },
 104     { "ISO_8859-2", 28592 },
 105     { "ISO_8859-3", 28593 },
 106     { "ISO_8859-4", 28594 },
 107     { "ISO_8859-5", 28595 },
 108     { "ISO_8859-6", 28596 },
 109     { "ISO_8859-7", 28597 },
 110     { "ISO_8859-8", 28598 },
 111     { "ISO_8859-9", 28599 },
 112     { "KOI8-R", 20866 },
 113     { "KOI8-U", 20866 },
 114     { "UTF-8", CP_UTF8 }
 115 };
 116
 117 #define NLS_MAX_LANGUAGES 20
 118 typedef struct {
 119     char lang[128];
 120     char country[128];
 121     LANGID found_lang_id[NLS_MAX_LANGUAGES];
 122     char found_language[NLS_MAX_LANGUAGES][3];
 123     char found_country[NLS_MAX_LANGUAGES][3];
 124     int n_found;
 125 } LANG_FIND_DATA;
 126
 127
 128 /***********************************************************************
 129  *              get_lcid_codepage
 130  *
 131  * Retrieve the ANSI codepage for a given locale.
 132  */
 133 inline static UINT get_lcid_codepage( LCID lcid )
 134 {
 135     UINT ret;
 136     if (!GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER, (WCHAR *)&ret,
 137                          sizeof(ret)/sizeof(WCHAR) )) ret = 0;
 138     return ret;
 139 }
 140
 141
 142 /***********************************************************************
 143  *              create_registry_key
 144  *
 145  * Create the Control Panel\\International registry key.
 146  */
 147 inline static HKEY create_registry_key(void)
 148 {
 149     static const WCHAR intlW[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
 150                                   'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
 151     OBJECT_ATTRIBUTES attr;
 152     UNICODE_STRING nameW;
 153     HKEY hkey;
 154
 155     if (RtlOpenCurrentUser( KEY_ALL_ACCESS, &hkey ) != STATUS_SUCCESS) return 0;
 156
 157     attr.Length = sizeof(attr);
 158     attr.RootDirectory = hkey;
 159     attr.ObjectName = &nameW;
 160     attr.Attributes = 0;
 161     attr.SecurityDescriptor = NULL;
 162     attr.SecurityQualityOfService = NULL;
 163     RtlInitUnicodeString( &nameW, intlW );
 164
 165     if (NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS) hkey = 0;
 166     NtClose( attr.RootDirectory );
 167     return hkey;
 168 }
 169
 170
 171 /***********************************************************************
 172  *              update_registry
 173  *
 174  * Update registry contents on startup if the user locale has changed.
 175  * This simulates the action of the Windows control panel.
 176  */
 177 inline static void update_registry( LCID lcid )
 178 {
 179     static const WCHAR LocaleW[] = {'L','o','c','a','l','e',0};
 180     UNICODE_STRING nameW;
 181     char buffer[20];
 182     WCHAR bufferW[80];
 183     DWORD count = sizeof(buffer);
 184     HKEY hkey;
 185
 186     if (!(hkey = create_registry_key()))
 187         return;  /* don't do anything if we can't create the registry key */
 188
 189     RtlInitUnicodeString( &nameW, LocaleW );
 190     count = sizeof(bufferW);
 191     if (!NtQueryValueKey(hkey, &nameW, KeyValuePartialInformation, (LPBYTE)bufferW, count, &count))
 192     {
 193         KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)bufferW;
 194         RtlUnicodeToMultiByteN( buffer, sizeof(buffer)-1, &count,
 195                                 (WCHAR *)info->Data, info->DataLength );
 196         buffer[count] = 0;
 197         if (strtol( buffer, NULL, 16 ) == lcid)  /* already set correctly */
 198         {
 199             NtClose( hkey );
 200             return;
 201         }
 202         TRACE( "updating registry, locale changed %s -> %08lx\n", buffer, lcid );
 203     }
 204     else TRACE( "updating registry, locale changed none -> %08lx\n", lcid );
 205
 206     sprintf( buffer, "%08lx", lcid );
 207     RtlMultiByteToUnicodeN( bufferW, sizeof(bufferW), NULL, buffer, strlen(buffer)+1 );
 208     NtSetValueKey( hkey, &nameW, 0, REG_SZ, bufferW, (strlenW(bufferW)+1) * sizeof(WCHAR) );
 209     NtClose( hkey );
 210
 211 #define UPDATE_VALUE(lctype) do { \
 212     GetLocaleInfoW( lcid, (lctype)|LOCALE_NOUSEROVERRIDE, bufferW, sizeof(bufferW)/sizeof(WCHAR) ); \
 213     SetLocaleInfoW( lcid, (lctype), bufferW ); } while (0)
 214
 215     UPDATE_VALUE(LOCALE_SLANGUAGE);
 216     UPDATE_VALUE(LOCALE_SCOUNTRY);
 217     UPDATE_VALUE(LOCALE_ICOUNTRY);
 218     UPDATE_VALUE(LOCALE_S1159);
 219     UPDATE_VALUE(LOCALE_S2359);
 220     UPDATE_VALUE(LOCALE_STIME);
 221     UPDATE_VALUE(LOCALE_ITIME);
 222     UPDATE_VALUE(LOCALE_ITLZERO);
 223     UPDATE_VALUE(LOCALE_SSHORTDATE);
 224     UPDATE_VALUE(LOCALE_IDATE);
 225     UPDATE_VALUE(LOCALE_SLONGDATE);
 226     UPDATE_VALUE(LOCALE_SDATE);
 227     UPDATE_VALUE(LOCALE_SCURRENCY);
 228     UPDATE_VALUE(LOCALE_ICURRENCY);
 229     UPDATE_VALUE(LOCALE_INEGCURR);
 230     UPDATE_VALUE(LOCALE_ICURRDIGITS);
 231     UPDATE_VALUE(LOCALE_SDECIMAL);
 232     UPDATE_VALUE(LOCALE_SLIST);
 233     UPDATE_VALUE(LOCALE_STHOUSAND);
 234     UPDATE_VALUE(LOCALE_IDIGITS);
 235     UPDATE_VALUE(LOCALE_ILZERO);
 236     UPDATE_VALUE(LOCALE_IMEASURE);
 237 #undef UPDATE_VALUE
 238 }
 239
 240
 241 /***********************************************************************
 242  *           find_language_id_proc
 243  */
 244 static BOOL CALLBACK find_language_id_proc( HMODULE hModule, LPCSTR type,
 245                                             LPCSTR name, WORD LangID, LPARAM lParam )
 246 {
 247     LANG_FIND_DATA *l_data = (LANG_FIND_DATA *)lParam;
 248     LCID lcid = MAKELCID(LangID, SORT_DEFAULT);
 249     char buf_language[128];
 250     char buf_country[128];
 251     char buf_en_language[128];
 252
 253     TRACE("%04X\n", (UINT)LangID);
 254     if(PRIMARYLANGID(LangID) == LANG_NEUTRAL)
 255         return TRUE; /* continue search */
 256
 257     buf_language[0] = 0;
 258     buf_country[0] = 0;
 259
 260     GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME|LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP,
 261                    buf_language, sizeof(buf_language));
 262     TRACE("LOCALE_SISO639LANGNAME: %s\n", buf_language);
 263
 264     GetLocaleInfoA(lcid, LOCALE_SISO3166CTRYNAME|LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP,
 265                    buf_country, sizeof(buf_country));
 266     TRACE("LOCALE_SISO3166CTRYNAME: %s\n", buf_country);
 267
 268     if(l_data->lang && strlen(l_data->lang) > 0 && !strcasecmp(l_data->lang, buf_language))
 269     {
 270         if(l_data->country && strlen(l_data->country) > 0)
 271         {
 272             if(!strcasecmp(l_data->country, buf_country))
 273             {
 274                 l_data->found_lang_id[0] = LangID;
 275                 l_data->n_found = 1;
 276                 TRACE("Found lang_id %04X for %s_%s\n", LangID, l_data->lang, l_data->country);
 277                 return FALSE; /* stop enumeration */
 278             }
 279         }
 280         else /* l_data->country not specified */
 281         {
 282             if(l_data->n_found < NLS_MAX_LANGUAGES)
 283             {
 284                 l_data->found_lang_id[l_data->n_found] = LangID;
 285                 strncpy(l_data->found_country[l_data->n_found], buf_country, 3);
 286                 strncpy(l_data->found_language[l_data->n_found], buf_language, 3);
 287                 l_data->n_found++;
 288                 TRACE("Found lang_id %04X for %s\n", LangID, l_data->lang);
 289                 return TRUE; /* continue search */
 290             }
 291         }
 292     }
 293
 294     /* Just in case, check LOCALE_SENGLANGUAGE too,
 295      * in hope that possible alias name might have that value.
 296      */
 297     buf_en_language[0] = 0;
 298     GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE|LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP,
 299                    buf_en_language, sizeof(buf_en_language));
 300     TRACE("LOCALE_SENGLANGUAGE: %s\n", buf_en_language);
 301
 302     if(l_data->lang && strlen(l_data->lang) > 0 && !strcasecmp(l_data->lang, buf_en_language))
 303     {
 304         l_data->found_lang_id[l_data->n_found] = LangID;
 305         strncpy(l_data->found_country[l_data->n_found], buf_country, 3);
 306         strncpy(l_data->found_language[l_data->n_found], buf_language, 3);
 307         l_data->n_found++;
 308         TRACE("Found lang_id %04X for %s\n", LangID, l_data->lang);
 309     }
 310
 311     return TRUE; /* continue search */
 312 }
 313
 314
 315 /***********************************************************************
 316  *           get_language_id
 317  *
 318  * INPUT:
 319  *      Lang: a string whose two first chars are the iso name of a language.
 320  *      Country: a string whose two first chars are the iso name of country
 321  *      Charset: a string defining the chosen charset encoding
 322  *      Dialect: a string defining a variation of the locale
 323  *
 324  *      all those values are from the standardized format of locale
 325  *      name in unix which is: Lang[_Country][.Charset][@Dialect]
 326  *
 327  * RETURNS:
 328  *      the numeric code of the language used by Windows
 329  *
 330  * FIXME: Charset and Dialect are not handled
 331  */
 332 static LANGID get_language_id(LPCSTR Lang, LPCSTR Country, LPCSTR Charset, LPCSTR Dialect)
 333 {
 334     LANG_FIND_DATA l_data;
 335     char lang_string[256];
 336
 337     if(!Lang)
 338     {
 339         l_data.found_lang_id[0] = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 340         goto END;
 341     }
 342
 343     memset(&l_data, 0, sizeof(LANG_FIND_DATA));
 344     strncpy(l_data.lang, Lang, sizeof(l_data.lang));
 345
 346     if(Country && strlen(Country) > 0)
 347         strncpy(l_data.country, Country, sizeof(l_data.country));
 348
 349     EnumResourceLanguagesA(GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
 350                            (LPCSTR)LOCALE_ILANGUAGE, find_language_id_proc, (LPARAM)&l_data);
 351
 352     strcpy(lang_string, l_data.lang);
 353     if(l_data.country && strlen(l_data.country) > 0)
 354     {
 355         strcat(lang_string, "_");
 356         strcat(lang_string, l_data.country);
 357     }
 358
 359     if(!l_data.n_found)
 360     {
 361         if(l_data.country && strlen(l_data.country) > 0)
 362         {
 363             MESSAGE("Warning: Language '%s' was not found, retrying without country name...\n", lang_string);
 364             l_data.country[0] = 0;
 365             EnumResourceLanguagesA(GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
 366                                    (LPCSTR)LOCALE_ILANGUAGE, find_language_id_proc, (LONG)&l_data);
 367         }
 368     }
 369
 370     /* Re-evaluate lang_string */
 371     strcpy(lang_string, l_data.lang);
 372     if(l_data.country && strlen(l_data.country) > 0)
 373     {
 374         strcat(lang_string, "_");
 375         strcat(lang_string, l_data.country);
 376     }
 377
 378     if(!l_data.n_found)
 379     {
 380         MESSAGE("Warning: Language '%s' was not recognized, defaulting to English\n", lang_string);
 381         l_data.found_lang_id[0] = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 382     }
 383     else
 384     {
 385         if(l_data.n_found == 1)
 386             TRACE("For language '%s' lang_id %04X was found\n", lang_string, l_data.found_lang_id[0]);
 387         else /* l_data->n_found > 1 */
 388         {
 389             int i;
 390             MESSAGE("For language '%s' several language ids were found:\n", lang_string);
 391             for(i = 0; i < l_data.n_found; i++)
 392                 MESSAGE("%s_%s - %04X; ", l_data.found_language[i], l_data.found_country[i], l_data.found_lang_id[i]);
 393
 394             MESSAGE("\nInstead of using first in the list, suggest to define\n"
 395                     "your LANG environment variable like this: LANG=%s_%s\n",
 396                     l_data.found_language[0], l_data.found_country[0]);
 397         }
 398     }
 399 END:
 400     TRACE("Returning %04X\n", l_data.found_lang_id[0]);
 401     return l_data.found_lang_id[0];
 402 }
 403
 404
 405 /***********************************************************************
 406  *              charset_cmp (internal)
 407  */
 408 static int charset_cmp( const void *name, const void *entry )
 409 {
 410     const struct charset_entry *charset = (struct charset_entry *)entry;
 411     return strcasecmp( (char *)name, charset->charset_name );
 412 }
 413
 414 /***********************************************************************
 415  *              init_default_lcid
 416  */
 417 static LCID init_default_lcid( UINT *unix_cp )
 418 {
 419     char buf[256];
 420     char *lang,*country,*charset,*dialect,*next;
 421     LCID ret = 0;
 422
 423     if (GetEnvironmentVariableA( "LC_ALL", buf, sizeof(buf) ) ||
 424         GetEnvironmentVariableA( "LC_CTYPE", buf, sizeof(buf) ) ||
 425         GetEnvironmentVariableA( "LANGUAGE", buf, sizeof(buf) ) ||
 426         GetEnvironmentVariableA( "LC_MESSAGES", buf, sizeof(buf) ) ||
 427         GetEnvironmentVariableA( "LANG", buf, sizeof(buf) ))
 428     {
 429         if (!strcmp(buf,"POSIX") || !strcmp(buf,"C")) goto done;
 430
 431         lang=buf;
 432
 433         do {
 434             next=strchr(lang,':'); if (next) *next++='\0';
 435             dialect=strchr(lang,'@'); if (dialect) *dialect++='\0';
 436             charset=strchr(lang,'.'); if (charset) *charset++='\0';
 437             country=strchr(lang,'_'); if (country) *country++='\0';
 438
 439             ret = get_language_id(lang, country, charset, dialect);
 440             if (ret && charset)
 441             {
 442                 const struct charset_entry *entry;
 443                 entry = bsearch( charset, charset_names, sizeof(charset_names)/sizeof(charset_names[0]),
 444                                sizeof(charset_names[0]), charset_cmp );
 445                 if (entry)
 446                 {
 447                     *unix_cp = entry->codepage;
 448                     TRACE("charset %s was mapped to cp %u\n", charset, *unix_cp);
 449                 }
 450                 else
 451                     FIXME("charset %s was not recognized\n", charset);
 452             }
 453
 454             lang=next;
 455         } while (lang && !ret);
 456
 457         if (!ret) MESSAGE("Warning: language '%s' not recognized, defaulting to English\n", buf);
 458     }
 459
 460  done:
 461     if (!ret) ret = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT) ;
 462     return ret;
 463 }
 464
 465
 466 /******************************************************************************
 467  *              get_locale_value_name
 468  *
 469  * Gets the registry value name for a given lctype.
 470  */
 471 static const WCHAR *get_locale_value_name( DWORD lctype )
 472 {
 473     static const WCHAR iCalendarTypeW[] = {'i','C','a','l','e','n','d','a','r','T','y','p','e',0};
 474     static const WCHAR iCountryW[] = {'i','C','o','u','n','t','r','y',0};
 475     static const WCHAR iCurrDigitsW[] = {'i','C','u','r','r','D','i','g','i','t','s',0};
 476     static const WCHAR iCurrencyW[] = {'i','C','u','r','r','e','n','c','y',0};
 477     static const WCHAR iDateW[] = {'i','D','a','t','e',0};
 478     static const WCHAR iDigitsW[] = {'i','D','i','g','i','t','s',0};
 479     static const WCHAR iFirstDayOfWeekW[] = {'i','F','i','r','s','t','D','a','y','O','f','W','e','e','k',0};
 480     static const WCHAR iFirstWeekOfYearW[] = {'i','F','i','r','s','t','W','e','e','k','O','f','Y','e','a','r',0};
 481     static const WCHAR iLDateW[] = {'i','L','D','a','t','e',0};
 482     static const WCHAR iLZeroW[] = {'i','L','Z','e','r','o',0};
 483     static const WCHAR iMeasureW[] = {'i','M','e','a','s','u','r','e',0};
 484     static const WCHAR iNegCurrW[] = {'i','N','e','g','C','u','r','r',0};
 485     static const WCHAR iNegNumberW[] = {'i','N','e','g','N','u','m','b','e','r',0};
 486     static const WCHAR iPaperSizeW[] = {'i','P','a','p','e','r','S','i','z','e',0};
 487     static const WCHAR iTLZeroW[] = {'i','T','L','Z','e','r','o',0};
 488     static const WCHAR iTimeW[] = {'i','T','i','m','e',0};
 489     static const WCHAR s1159W[] = {'s','1','1','5','9',0};
 490     static const WCHAR s2359W[] = {'s','2','3','5','9',0};
 491     static const WCHAR sCountryW[] = {'s','C','o','u','n','t','r','y',0};
 492     static const WCHAR sCurrencyW[] = {'s','C','u','r','r','e','n','c','y',0};
 493     static const WCHAR sDateW[] = {'s','D','a','t','e',0};
 494     static const WCHAR sDecimalW[] = {'s','D','e','c','i','m','a','l',0};
 495     static const WCHAR sGroupingW[] = {'s','G','r','o','u','p','i','n','g',0};
 496     static const WCHAR sLanguageW[] = {'s','L','a','n','g','u','a','g','e',0};
 497     static const WCHAR sListW[] = {'s','L','i','s','t',0};
 498     static const WCHAR sLongDateW[] = {'s','L','o','n','g','D','a','t','e',0};
 499     static const WCHAR sMonDecimalSepW[] = {'s','M','o','n','D','e','c','i','m','a','l','S','e','p',0};
 500     static const WCHAR sMonGroupingW[] = {'s','M','o','n','G','r','o','u','p','i','n','g',0};
 501     static const WCHAR sMonThousandSepW[] = {'s','M','o','n','T','h','o','u','s','a','n','d','S','e','p',0};
 502     static const WCHAR sNegativeSignW[] = {'s','N','e','g','a','t','i','v','e','S','i','g','n',0};
 503     static const WCHAR sPositiveSignW[] = {'s','P','o','s','i','t','i','v','e','S','i','g','n',0};
 504     static const WCHAR sShortDateW[] = {'s','S','h','o','r','t','D','a','t','e',0};
 505     static const WCHAR sThousandW[] = {'s','T','h','o','u','s','a','n','d',0};
 506     static const WCHAR sTimeFormatW[] = {'s','T','i','m','e','F','o','r','m','a','t',0};
 507     static const WCHAR sTimeW[] = {'s','T','i','m','e',0};
 508     static const WCHAR sYearMonthW[] = {'s','Y','e','a','r','M','o','n','t','h',0};
 509
 510     switch (lctype & ~LOCALE_LOCALEINFOFLAGSMASK)
 511     {
 512     /* These values are used by SetLocaleInfo and GetLocaleInfo, and
 513      * the values are stored in the registry, confirmed under Windows.
 514      */
 515     case LOCALE_ICALENDARTYPE:    return iCalendarTypeW;
 516     case LOCALE_ICURRDIGITS:      return iCurrDigitsW;
 517     case LOCALE_ICURRENCY:        return iCurrencyW;
 518     case LOCALE_IDIGITS:          return iDigitsW;
 519     case LOCALE_IFIRSTDAYOFWEEK:  return iFirstDayOfWeekW;
 520     case LOCALE_IFIRSTWEEKOFYEAR: return iFirstWeekOfYearW;
 521     case LOCALE_ILZERO:           return iLZeroW;
 522     case LOCALE_IMEASURE:         return iMeasureW;
 523     case LOCALE_INEGCURR:         return iNegCurrW;
 524     case LOCALE_INEGNUMBER:       return iNegNumberW;
 525     case LOCALE_IPAPERSIZE:       return iPaperSizeW;
 526     case LOCALE_ITIME:            return iTimeW;
 527     case LOCALE_S1159:            return s1159W;
 528     case LOCALE_S2359:            return s2359W;
 529     case LOCALE_SCURRENCY:        return sCurrencyW;
 530     case LOCALE_SDATE:            return sDateW;
 531     case LOCALE_SDECIMAL:         return sDecimalW;
 532     case LOCALE_SGROUPING:        return sGroupingW;
 533     case LOCALE_SLIST:            return sListW;
 534     case LOCALE_SLONGDATE:        return sLongDateW;
 535     case LOCALE_SMONDECIMALSEP:   return sMonDecimalSepW;
 536     case LOCALE_SMONGROUPING:     return sMonGroupingW;
 537     case LOCALE_SMONTHOUSANDSEP:  return sMonThousandSepW;
 538     case LOCALE_SNEGATIVESIGN:    return sNegativeSignW;
 539     case LOCALE_SPOSITIVESIGN:    return sPositiveSignW;
 540     case LOCALE_SSHORTDATE:       return sShortDateW;
 541     case LOCALE_STHOUSAND:        return sThousandW;
 542     case LOCALE_STIME:            return sTimeW;
 543     case LOCALE_STIMEFORMAT:      return sTimeFormatW;
 544     case LOCALE_SYEARMONTH:       return sYearMonthW;
 545
 546     /* The following are not listed under MSDN as supported,
 547      * but seem to be used and also stored in the registry.
 548      */
 549     case LOCALE_ICOUNTRY:         return iCountryW;
 550     case LOCALE_IDATE:            return iDateW;
 551     case LOCALE_ILDATE:           return iLDateW;
 552     case LOCALE_ITLZERO:          return iTLZeroW;
 553     case LOCALE_SCOUNTRY:         return sCountryW;
 554     case LOCALE_SLANGUAGE:        return sLanguageW;
 555     }
 556     return NULL;
 557 }
 558
 559
 560 /******************************************************************************
 561  *              get_registry_locale_info
 562  *
 563  * Retrieve user-modified locale info from the registry.
 564  * Return length, 0 on error, -1 if not found.
 565  */
 566 static INT get_registry_locale_info( LPCWSTR value, LPWSTR buffer, INT len )
 567 {
 568     DWORD size;
 569     INT ret;
 570     HKEY hkey;
 571     NTSTATUS status;
 572     UNICODE_STRING nameW;
 573     KEY_VALUE_PARTIAL_INFORMATION *info;
 574     static const int info_size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
 575
 576     if (!(hkey = create_registry_key())) return -1;
 577
 578     RtlInitUnicodeString( &nameW, value );
 579     size = info_size + len * sizeof(WCHAR);
 580
 581     if (!(info = HeapAlloc( GetProcessHeap(), 0, size )))
 582     {
 583         NtClose( hkey );
 584         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 585         return 0;
 586     }
 587
 588     status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, info, size, &size );
 589     if (status == STATUS_BUFFER_OVERFLOW && !buffer) status = 0;
 590
 591     if (!status)
 592     {
 593         ret = (size - info_size) / sizeof(WCHAR);
 594         /* append terminating null if needed */
 595         if (!ret || ((WCHAR *)info->Data)[ret-1])
 596         {
 597             if (ret < len || !buffer) ret++;
 598             else
 599             {
 600                 SetLastError( ERROR_INSUFFICIENT_BUFFER );
 601                 ret = 0;
 602             }
 603         }
 604         if (ret && buffer)
 605         {
 606             memcpy( buffer, info->Data, (ret-1) * sizeof(WCHAR) );
 607             buffer[ret-1] = 0;
 608         }
 609     }
 610     else
 611     {
 612         if (status == STATUS_OBJECT_NAME_NOT_FOUND) ret = -1;
 613         else
 614         {
 615             SetLastError( RtlNtStatusToDosError(status) );
 616             ret = 0;
 617         }
 618     }
 619     NtClose( hkey );
 620     HeapFree( GetProcessHeap(), 0, info );
 621     return ret;
 622 }
 623
 624
 625 /******************************************************************************
 626  *              GetLocaleInfoA (KERNEL32.@)
 627  *
 628  * NOTES
 629  *  LOCALE_NEUTRAL is equal to LOCALE_SYSTEM_DEFAULT
 630  *
 631  *  MS online documentation states that the string returned is NULL terminated
 632  *  except for LOCALE_FONTSIGNATURE  which "will return a non-NULL
 633  *  terminated string".
 634  */
 635 INT WINAPI GetLocaleInfoA( LCID lcid, LCTYPE lctype, LPSTR buffer, INT len )
 636 {
 637     WCHAR *bufferW;
 638     INT lenW, ret;
 639
 640     if (len < 0 || (len && !buffer))
 641     {
 642         SetLastError( ERROR_INVALID_PARAMETER );
 643         return 0;
 644     }
 645     if (!len) buffer = NULL;
 646
 647     if (!(lenW = GetLocaleInfoW( lcid, lctype, NULL, 0 ))) return 0;
 648
 649     if (!(bufferW = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
 650     {
 651         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 652         return 0;
 653     }
 654     if ((ret = GetLocaleInfoW( lcid, lctype, bufferW, lenW )))
 655     {
 656         if ((lctype & LOCALE_RETURN_NUMBER) ||
 657             ((lctype & ~LOCALE_LOCALEINFOFLAGSMASK) == LOCALE_FONTSIGNATURE))
 658         {
 659             /* it's not an ASCII string, just bytes */
 660             ret *= sizeof(WCHAR);
 661             if (buffer)
 662             {
 663                 if (ret <= len) memcpy( buffer, bufferW, ret );
 664                 else
 665                 {
 666                     SetLastError( ERROR_INSUFFICIENT_BUFFER );
 667                     ret = 0;
 668                 }
 669             }
 670         }
 671         else
 672         {
 673             UINT codepage = CP_ACP;
 674             if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
 675             ret = WideCharToMultiByte( codepage, 0, bufferW, ret, buffer, len, NULL, NULL );
 676         }
 677     }
 678     HeapFree( GetProcessHeap(), 0, bufferW );
 679     return ret;
 680 }
 681
 682
 683 /******************************************************************************
 684  *              GetLocaleInfoW (KERNEL32.@)
 685  *
 686  * NOTES
 687  *  LOCALE_NEUTRAL is equal to LOCALE_SYSTEM_DEFAULT
 688  *
 689  *  MS online documentation states that the string returned is NULL terminated
 690  *  except for LOCALE_FONTSIGNATURE  which "will return a non-NULL
 691  *  terminated string".
 692  */
 693 INT WINAPI GetLocaleInfoW( LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len )
 694 {
 695     LANGID lang_id;
 696     HRSRC hrsrc;
 697     HGLOBAL hmem;
 698     HMODULE hModule;
 699     INT ret;
 700     UINT lcflags;
 701     const WCHAR *p;
 702     int i;
 703
 704     if (len < 0 || (len && !buffer))
 705     {
 706         SetLastError( ERROR_INVALID_PARAMETER );
 707         return 0;
 708     }
 709     if (!len) buffer = NULL;
 710
 711     if (lcid == LOCALE_NEUTRAL || lcid == LOCALE_SYSTEM_DEFAULT) lcid = GetSystemDefaultLCID();
 712     else if (lcid == LOCALE_USER_DEFAULT) lcid = GetUserDefaultLCID();
 713
 714     lcflags = lctype & LOCALE_LOCALEINFOFLAGSMASK;
 715     lctype &= ~LOCALE_LOCALEINFOFLAGSMASK;
 716
 717     /* first check for overrides in the registry */
 718
 719     if (!(lcflags & LOCALE_NOUSEROVERRIDE) && lcid == GetUserDefaultLCID())
 720     {
 721         const WCHAR *value = get_locale_value_name(lctype);
 722
 723         if (value && ((ret = get_registry_locale_info( value, buffer, len )) != -1)) return ret;
 724     }
 725
 726     /* now load it from kernel resources */
 727
 728     lang_id = LANGIDFROMLCID( lcid );
 729
 730     /* replace SUBLANG_NEUTRAL by SUBLANG_DEFAULT */
 731     if (SUBLANGID(lang_id) == SUBLANG_NEUTRAL)
 732         lang_id = MAKELANGID(PRIMARYLANGID(lang_id), SUBLANG_DEFAULT);
 733
 734     hModule = GetModuleHandleA( "kernel32.dll" );
 735     if (!(hrsrc = FindResourceExW( hModule, (LPWSTR)RT_STRING, (LPCWSTR)((lctype >> 4) + 1), lang_id )))
 736     {
 737         SetLastError( ERROR_INVALID_FLAGS );  /* no such lctype */
 738         return 0;
 739     }
 740     if (!(hmem = LoadResource( hModule, hrsrc )))
 741         return 0;
 742
 743     p = LockResource( hmem );
 744     for (i = 0; i < (lctype & 0x0f); i++) p += *p + 1;
 745
 746     if (lcflags & LOCALE_RETURN_NUMBER) ret = sizeof(UINT)/sizeof(WCHAR);
 747     else ret = (lctype == LOCALE_FONTSIGNATURE) ? *p : *p + 1;
 748
 749     if (!buffer) return ret;
 750
 751     if (ret > len)
 752     {
 753         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 754         return 0;
 755     }
 756
 757     if (lcflags & LOCALE_RETURN_NUMBER)
 758     {
 759         UINT number;
 760         WCHAR *end, *tmp = HeapAlloc( GetProcessHeap(), 0, (*p + 1) * sizeof(WCHAR) );
 761         if (!tmp) return 0;
 762         memcpy( tmp, p + 1, *p * sizeof(WCHAR) );
 763         tmp[*p] = 0;
 764         number = strtolW( tmp, &end, 10 );
 765         if (!*end)
 766             memcpy( buffer, &number, sizeof(number) );
 767         else  /* invalid number */
 768         {
 769             SetLastError( ERROR_INVALID_FLAGS );
 770             ret = 0;
 771         }
 772         HeapFree( GetProcessHeap(), 0, tmp );
 773
 774         TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning number %d\n",
 775                lcid, lctype, buffer, len, number );
 776     }
 777     else
 778     {
 779         memcpy( buffer, p + 1, *p * sizeof(WCHAR) );
 780         if (lctype != LOCALE_FONTSIGNATURE) buffer[ret-1] = 0;
 781
 782         TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning %d %s\n",
 783                lcid, lctype, buffer, len, ret, debugstr_w(buffer) );
 784     }
 785     return ret;
 786 }
 787
 788
 789 /******************************************************************************
 790  *              SetLocaleInfoA  [KERNEL32.@]
 791  */
 792 BOOL WINAPI SetLocaleInfoA(LCID lcid, LCTYPE lctype, LPCSTR data)
 793 {
 794     UINT codepage = CP_ACP;
 795     WCHAR *strW;
 796     DWORD len;
 797     BOOL ret;
 798
 799     if (lcid == LOCALE_NEUTRAL || lcid == LOCALE_SYSTEM_DEFAULT) lcid = GetSystemDefaultLCID();
 800     else if (lcid == LOCALE_USER_DEFAULT) lcid = GetUserDefaultLCID();
 801
 802     if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
 803     len = MultiByteToWideChar( codepage, 0, data, -1, NULL, 0 );
 804     if (!(strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 805     {
 806         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 807         return FALSE;
 808     }
 809     MultiByteToWideChar( codepage, 0, data, -1, strW, len );
 810     ret = SetLocaleInfoW( lcid, lctype, strW );
 811     HeapFree( GetProcessHeap(), 0, strW );
 812     return ret;
 813 }
 814
 815
 816 /******************************************************************************
 817  *              SetLocaleInfoW  (KERNEL32.@)
 818  */
 819 BOOL WINAPI SetLocaleInfoW( LCID lcid, LCTYPE lctype, LPCWSTR data )
 820 {
 821     const WCHAR *value;
 822     const WCHAR intlW[] = {'i','n','t','l',0 };
 823     UNICODE_STRING valueW;
 824     NTSTATUS status;
 825     HKEY hkey;
 826
 827     if (lcid == LOCALE_NEUTRAL || lcid == LOCALE_SYSTEM_DEFAULT) lcid = GetSystemDefaultLCID();
 828     else if (lcid == LOCALE_USER_DEFAULT) lcid = GetUserDefaultLCID();
 829
 830     if (!(value = get_locale_value_name( lctype )))
 831     {
 832         SetLastError( ERROR_INVALID_PARAMETER );
 833         return FALSE;
 834     }
 835     if (lcid != GetUserDefaultLCID()) return TRUE;  /* fake success */
 836
 837     TRACE("setting %lx to %s\n", lctype, debugstr_w(data) );
 838
 839     /* FIXME: should check that data to set is sane */
 840
 841     /* FIXME: profile functions should map to registry */
 842     WriteProfileStringW( intlW, value, data );
 843
 844     if (!(hkey = create_registry_key())) return FALSE;
 845     RtlInitUnicodeString( &valueW, value );
 846     status = NtSetValueKey( hkey, &valueW, 0, REG_SZ, data, (strlenW(data)+1)*sizeof(WCHAR) );
 847     NtClose( hkey );
 848
 849     if (status) SetLastError( RtlNtStatusToDosError(status) );
 850     return !status;
 851     return TRUE;
 852 }
 853
 854
 855 /***********************************************************************
 856  *           GetThreadLocale    (KERNEL32.@)
 857  */
 858 LCID WINAPI GetThreadLocale(void)
 859 {
 860     LCID ret = NtCurrentTeb()->CurrentLocale;
 861     if (!ret) NtCurrentTeb()->CurrentLocale = ret = GetUserDefaultLCID();
 862     return ret;
 863 }
 864
 865
 866 /**********************************************************************
 867  *           SetThreadLocale    (KERNEL32.@)
 868  *
 869  * FIXME
 870  *  check if lcid is a valid cp
 871  */
 872 BOOL WINAPI SetThreadLocale( LCID lcid ) /* [in] Locale identifier */
 873 {
 874     if (lcid == LOCALE_NEUTRAL || lcid == LOCALE_SYSTEM_DEFAULT) lcid = GetSystemDefaultLCID();
 875     else if (lcid == LOCALE_USER_DEFAULT) lcid = GetUserDefaultLCID();
 876
 877     NtCurrentTeb()->CurrentLocale = lcid;
 878     NtCurrentTeb()->code_page = get_lcid_codepage( lcid );
 879     return TRUE;
 880 }
 881
 882
 883 /******************************************************************************
 884  *              ConvertDefaultLocale (KERNEL32.@)
 885  */
 886 LCID WINAPI ConvertDefaultLocale( LCID lcid )
 887 {
 888     switch (lcid)
 889     {
 890     case LOCALE_SYSTEM_DEFAULT:
 891         return GetSystemDefaultLCID();
 892     case LOCALE_USER_DEFAULT:
 893         return GetUserDefaultLCID();
 894     case LOCALE_NEUTRAL:
 895         return MAKELCID (LANG_NEUTRAL, SUBLANG_NEUTRAL);
 896     }
 897     return MAKELANGID( PRIMARYLANGID(lcid), SUBLANG_NEUTRAL);
 898 }
 899
 900
 901 /******************************************************************************
 902  *           IsValidLocale   (KERNEL32.@)
 903  */
 904 BOOL WINAPI IsValidLocale( LCID lcid, DWORD flags )
 905 {
 906     /* check if language is registered in the kernel32 resources */
 907     return FindResourceExW( GetModuleHandleA("KERNEL32"), (LPWSTR)RT_STRING,
 908                             (LPCWSTR)LOCALE_ILANGUAGE, LANGIDFROMLCID(lcid)) != 0;
 909 }
 910
 911
 912 static BOOL CALLBACK enum_lang_proc_a( HMODULE hModule, LPCSTR type,
 913                                        LPCSTR name, WORD LangID, LONG lParam )
 914 {
 915     LOCALE_ENUMPROCA lpfnLocaleEnum = (LOCALE_ENUMPROCA)lParam;
 916     char buf[20];
 917
 918     sprintf(buf, "%08x", (UINT)LangID);
 919     return lpfnLocaleEnum( buf );
 920 }
 921
 922 static BOOL CALLBACK enum_lang_proc_w( HMODULE hModule, LPCWSTR type,
 923                                        LPCWSTR name, WORD LangID, LONG lParam )
 924 {
 925     static const WCHAR formatW[] = {'%','0','8','x',0};
 926     LOCALE_ENUMPROCW lpfnLocaleEnum = (LOCALE_ENUMPROCW)lParam;
 927     WCHAR buf[20];
 928     sprintfW( buf, formatW, (UINT)LangID );
 929     return lpfnLocaleEnum( buf );
 930 }
 931
 932 /******************************************************************************
 933  *           EnumSystemLocalesA  (KERNEL32.@)
 934  */
 935 BOOL WINAPI EnumSystemLocalesA(LOCALE_ENUMPROCA lpfnLocaleEnum,
 936                                    DWORD flags)
 937 {
 938     TRACE("(%p,%08lx)\n", lpfnLocaleEnum,flags);
 939     EnumResourceLanguagesA( GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
 940                             (LPCSTR)LOCALE_ILANGUAGE, enum_lang_proc_a,
 941                             (LONG)lpfnLocaleEnum);
 942     return TRUE;
 943 }
 944
 945
 946 /******************************************************************************
 947  *           EnumSystemLocalesW  (KERNEL32.@)
 948  */
 949 BOOL WINAPI EnumSystemLocalesW( LOCALE_ENUMPROCW lpfnLocaleEnum, DWORD flags )
 950 {
 951     TRACE("(%p,%08lx)\n", lpfnLocaleEnum,flags);
 952     EnumResourceLanguagesW( GetModuleHandleA("KERNEL32"), (LPWSTR)RT_STRING,
 953                             (LPCWSTR)LOCALE_ILANGUAGE, enum_lang_proc_w,
 954                             (LONG)lpfnLocaleEnum);
 955     return TRUE;
 956 }
 957
 958
 959 /***********************************************************************
 960  *           VerLanguageNameA  (KERNEL32.@)
 961  */
 962 DWORD WINAPI VerLanguageNameA( UINT wLang, LPSTR szLang, UINT nSize )
 963 {
 964     return GetLocaleInfoA( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
 965 }
 966
 967
 968 /***********************************************************************
 969  *           VerLanguageNameW  (KERNEL32.@)
 970  */
 971 DWORD WINAPI VerLanguageNameW( UINT wLang, LPWSTR szLang, UINT nSize )
 972 {
 973     return GetLocaleInfoW( MAKELCID(wLang, SORT_DEFAULT), LOCALE_SENGLANGUAGE, szLang, nSize );
 974 }
 975
 976
 977 /******************************************************************************
 978  *           GetStringTypeW    (KERNEL32.@)
 979  */
 980 BOOL WINAPI GetStringTypeW( DWORD type, LPCWSTR src, INT count, LPWORD chartype )
 981 {
 982     if (count == -1) count = strlenW(src) + 1;
 983     switch(type)
 984     {
 985     case CT_CTYPE1:
 986         while (count--) *chartype++ = get_char_typeW( *src++ ) & 0xfff;
 987         break;
 988     case CT_CTYPE2:
 989         while (count--) *chartype++ = get_char_typeW( *src++ ) >> 12;
 990         break;
 991     case CT_CTYPE3:
 992     {
 993         WARN("CT_CTYPE3: semi-stub.\n");
 994         while (count--)
 995         {
 996             int c = *src;
 997             WORD type1, type3 = 0; /* C3_NOTAPPLICABLE */
 998
 999             type1 = get_char_typeW( *src++ ) & 0xfff;
1000             /* try to construct type3 from type1 */
1001             if(type1 & C1_SPACE) type3 |= C3_SYMBOL;
1002             if(type1 & C1_ALPHA) type3 |= C3_ALPHA;
1003             if ((c>=0x30A0)&&(c<=0x30FF)) type3 |= C3_KATAKANA;
1004             if ((c>=0x3040)&&(c<=0x309F)) type3 |= C3_HIRAGANA;
1005             if ((c>=0x4E00)&&(c<=0x9FAF)) type3 |= C3_IDEOGRAPH;
1006             if ((c>=0x0600)&&(c<=0x06FF)) type3 |= C3_KASHIDA;
1007             if ((c>=0x3000)&&(c<=0x303F)) type3 |= C3_SYMBOL;
1008
1009             if ((c>=0xFF00)&&(c<=0xFF60)) type3 |= C3_FULLWIDTH;
1010             if ((c>=0xFF00)&&(c<=0xFF20)) type3 |= C3_SYMBOL;
1011             if ((c>=0xFF3B)&&(c<=0xFF40)) type3 |= C3_SYMBOL;
1012             if ((c>=0xFF5B)&&(c<=0xFF60)) type3 |= C3_SYMBOL;
1013             if ((c>=0xFF21)&&(c<=0xFF3A)) type3 |= C3_ALPHA;
1014             if ((c>=0xFF41)&&(c<=0xFF5A)) type3 |= C3_ALPHA;
1015             if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_FULLWIDTH;
1016             if ((c>=0xFFE0)&&(c<=0xFFE6)) type3 |= C3_SYMBOL;
1017
1018             if ((c>=0xFF61)&&(c<=0xFFDC)) type3 |= C3_HALFWIDTH;
1019             if ((c>=0xFF61)&&(c<=0xFF64)) type3 |= C3_SYMBOL;
1020             if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_KATAKANA;
1021             if ((c>=0xFF65)&&(c<=0xFF9F)) type3 |= C3_ALPHA;
1022             if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_HALFWIDTH;
1023             if ((c>=0xFFE8)&&(c<=0xFFEE)) type3 |= C3_SYMBOL;
1024             *chartype++ = type3;
1025         }
1026         break;
1027     }
1028     default:
1029         SetLastError( ERROR_INVALID_PARAMETER );
1030         return FALSE;
1031     }
1032     return TRUE;
1033 }
1034
1035
1036 /******************************************************************************
1037  *           GetStringTypeExW    (KERNEL32.@)
1038  */
1039 BOOL WINAPI GetStringTypeExW( LCID locale, DWORD type, LPCWSTR src, INT count, LPWORD chartype )
1040 {
1041     /* locale is ignored for Unicode */
1042     return GetStringTypeW( type, src, count, chartype );
1043 }
1044
1045
1046 /******************************************************************************
1047  *           GetStringTypeA    (KERNEL32.@)
1048  */
1049 BOOL WINAPI GetStringTypeA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
1050 {
1051     UINT cp;
1052     INT countW;
1053     LPWSTR srcW;
1054     BOOL ret = FALSE;
1055
1056     if(count == -1) count = strlen(src) + 1;
1057
1058     if (!(cp = get_lcid_codepage( locale )))
1059     {
1060         FIXME("For locale %04lx using current ANSI code page\n", locale);
1061         cp = GetACP();
1062     }
1063
1064     countW = MultiByteToWideChar(cp, 0, src, count, NULL, 0);
1065     if((srcW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
1066     {
1067         MultiByteToWideChar(cp, 0, src, count, srcW, countW);
1068     /*
1069      * NOTE: the target buffer has 1 word for each CHARACTER in the source
1070      * string, with multibyte characters there maybe be more bytes in count
1071      * than character space in the buffer!
1072      */
1073         ret = GetStringTypeW(type, srcW, countW, chartype);
1074         HeapFree(GetProcessHeap(), 0, srcW);
1075     }
1076     return ret;
1077 }
1078
1079 /******************************************************************************
1080  *           GetStringTypeExA    (KERNEL32.@)
1081  */
1082 BOOL WINAPI GetStringTypeExA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
1083 {
1084     return GetStringTypeA(locale, type, src, count, chartype);
1085 }
1086
1087
1088 /*************************************************************************
1089  *           LCMapStringW    (KERNEL32.@)
1090  */
1091 INT WINAPI LCMapStringW(LCID lcid, DWORD flags, LPCWSTR src, INT srclen,
1092                         LPWSTR dst, INT dstlen)
1093 {
1094     LPWSTR dst_ptr;
1095
1096     if (!src || !srclen || dstlen < 0)
1097     {
1098         SetLastError(ERROR_INVALID_PARAMETER);
1099         return 0;
1100     }
1101
1102     /* mutually exclusive flags */
1103     if ((flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE)) == (LCMAP_LOWERCASE | LCMAP_UPPERCASE) ||
1104         (flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA)) == (LCMAP_HIRAGANA | LCMAP_KATAKANA) ||
1105         (flags & (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) == (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH) ||
1106         (flags & (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE)) == (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE))
1107     {
1108         SetLastError(ERROR_INVALID_FLAGS);
1109         return 0;
1110     }
1111
1112     if (!dstlen) dst = NULL;
1113
1114     if (lcid == LOCALE_NEUTRAL || lcid == LOCALE_SYSTEM_DEFAULT) lcid = GetSystemDefaultLCID();
1115     else if (lcid == LOCALE_USER_DEFAULT) lcid = GetUserDefaultLCID();
1116
1117     if (flags & LCMAP_SORTKEY)
1118     {
1119         if (src == dst)
1120         {
1121             SetLastError(ERROR_INVALID_FLAGS);
1122             return 0;
1123         }
1124
1125         if (srclen < 0) srclen = strlenW(src);
1126
1127         TRACE("(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
1128               lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
1129
1130         return wine_get_sortkey(flags, src, srclen, (char *)dst, dstlen);
1131     }
1132
1133     /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
1134     if (flags & SORT_STRINGSORT)
1135     {
1136         SetLastError(ERROR_INVALID_FLAGS);
1137         return 0;
1138     }
1139
1140     if (srclen < 0) srclen = strlenW(src) + 1;
1141
1142     TRACE("(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
1143           lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
1144
1145     if (!dst) /* return required string length */
1146     {
1147         INT len;
1148
1149         for (len = 0; srclen; src++, srclen--)
1150         {
1151             WCHAR wch = *src;
1152             /* tests show that win2k just ignores NORM_IGNORENONSPACE,
1153              * and skips white space and punctuation characters for
1154              * NORM_IGNORESYMBOLS.
1155              */
1156             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1157                 continue;
1158             len++;
1159         }
1160         return len;
1161     }
1162
1163     if (flags & LCMAP_UPPERCASE)
1164     {
1165         for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
1166         {
1167             WCHAR wch = *src;
1168             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1169                 continue;
1170             *dst_ptr++ = toupperW(wch);
1171             dstlen--;
1172         }
1173     }
1174     else if (flags & LCMAP_LOWERCASE)
1175     {
1176         for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
1177         {
1178             WCHAR wch = *src;
1179             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1180                 continue;
1181             *dst_ptr++ = tolowerW(wch);
1182             dstlen--;
1183         }
1184     }
1185     else
1186     {
1187         if (src == dst)
1188         {
1189             SetLastError(ERROR_INVALID_FLAGS);
1190             return 0;
1191         }
1192         for (dst_ptr = dst; srclen && dstlen; src++, srclen--)
1193         {
1194             WCHAR wch = *src;
1195             if ((flags & NORM_IGNORESYMBOLS) && (get_char_typeW(wch) & (C1_PUNCT | C1_SPACE)))
1196                 continue;
1197             *dst_ptr++ = wch;
1198             dstlen--;
1199         }
1200     }
1201
1202     return dst_ptr - dst;
1203 }
1204
1205 /*************************************************************************
1206  *           LCMapStringA    (KERNEL32.@)
1207  */
1208 INT WINAPI LCMapStringA(LCID lcid, DWORD flags, LPCSTR src, INT srclen,
1209                         LPSTR dst, INT dstlen)
1210 {
1211     WCHAR bufW[128];
1212     LPWSTR srcW, dstW;
1213     INT ret = 0, srclenW, dstlenW;
1214     UINT locale_cp;
1215
1216     if (!src || !srclen || dstlen < 0)
1217     {
1218         SetLastError(ERROR_INVALID_PARAMETER);
1219         return 0;
1220     }
1221
1222     GetLocaleInfoW(lcid, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
1223                    (WCHAR *)&locale_cp, (sizeof(locale_cp)/sizeof(WCHAR)));
1224
1225     srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, bufW, 128);
1226     if (srclenW)
1227         srcW = bufW;
1228     else
1229     {
1230         srclenW = MultiByteToWideChar(locale_cp, 0, src, srclen, NULL, 0);
1231         srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
1232         if (!srcW)
1233         {
1234             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1235             return 0;
1236         }
1237         MultiByteToWideChar(locale_cp, 0, src, srclen, srcW, srclenW);
1238     }
1239
1240     if (flags & LCMAP_SORTKEY)
1241     {
1242         if (src == dst)
1243         {
1244             SetLastError(ERROR_INVALID_FLAGS);
1245             goto map_string_exit;
1246         }
1247         ret = wine_get_sortkey(flags, srcW, srclenW, dst, dstlen);
1248         goto map_string_exit;
1249     }
1250
1251     if (flags & SORT_STRINGSORT)
1252     {
1253         SetLastError(ERROR_INVALID_FLAGS);
1254         goto map_string_exit;
1255     }
1256
1257     dstlenW = LCMapStringW(lcid, flags, srcW, srclenW, NULL, 0);
1258     dstW = HeapAlloc(GetProcessHeap(), 0, dstlenW * sizeof(WCHAR));
1259     if (!dstW)
1260     {
1261         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1262         goto map_string_exit;
1263     }
1264
1265     LCMapStringW(lcid, flags, srcW, srclenW, dstW, dstlenW);
1266     ret = WideCharToMultiByte(locale_cp, 0, dstW, dstlenW, dst, dstlen, NULL, NULL);
1267     HeapFree(GetProcessHeap(), 0, dstW);
1268
1269 map_string_exit:
1270     if (srcW != bufW) HeapFree(GetProcessHeap(), 0, srcW);
1271     return ret;
1272 }
1273
1274 /******************************************************************************
1275  *           CompareStringW    (KERNEL32.@)
1276  */
1277 INT WINAPI CompareStringW(LCID lcid, DWORD style,
1278                           LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)
1279 {
1280     INT ret, len;
1281
1282     if (!str1 || !str2)
1283     {
1284         SetLastError(ERROR_INVALID_PARAMETER);
1285         return 0;
1286     }
1287
1288     if (len1 < 0) len1 = lstrlenW(str1);
1289     if (len2 < 0) len2 = lstrlenW(str2);
1290
1291     len = (len1 < len2) ? len1 : len2;
1292     ret = (style & NORM_IGNORECASE) ? strncmpiW(str1, str2, len) :
1293                                       strncmpW(str1, str2, len);
1294
1295     if (ret) /* need to translate result */
1296         return (ret < 0) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
1297
1298     if (len1 == len2) return CSTR_EQUAL;
1299     /* the longer one is lexically greater */
1300     return (len1 < len2) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
1301 }
1302
1303 /******************************************************************************
1304  *           CompareStringA    (KERNEL32.@)
1305  */
1306 INT WINAPI CompareStringA(LCID lcid, DWORD style,
1307                           LPCSTR str1, INT len1, LPCSTR str2, INT len2)
1308 {
1309     WCHAR buf1W[128], buf2W[128];
1310     LPWSTR str1W, str2W;
1311     INT len1W, len2W, ret;
1312     UINT locale_cp;
1313
1314     if (!str1 || !str2)
1315     {
1316         SetLastError(ERROR_INVALID_PARAMETER);
1317         return 0;
1318     }
1319
1320     if (len1 < 0) len1 = strlen(str1);
1321     if (len2 < 0) len2 = strlen(str2);
1322
1323     GetLocaleInfoW(lcid, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
1324                    (WCHAR *)&locale_cp, (sizeof(locale_cp)/sizeof(WCHAR)));
1325
1326     len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, buf1W, 128);
1327     if (len1W)
1328         str1W = buf1W;
1329     else
1330     {
1331         len1W = MultiByteToWideChar(locale_cp, 0, str1, len1, NULL, 0);
1332         str1W = HeapAlloc(GetProcessHeap(), 0, len1W * sizeof(WCHAR));
1333         if (!str1W)
1334         {
1335             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1336             return 0;
1337         }
1338         MultiByteToWideChar(locale_cp, 0, str1, len1, str1W, len1W);
1339     }
1340     len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, buf2W, 128);
1341     if (len2W)
1342         str2W = buf2W;
1343     else
1344     {
1345         len2W = MultiByteToWideChar(locale_cp, 0, str2, len2, NULL, 0);
1346         str2W = HeapAlloc(GetProcessHeap(), 0, len2W * sizeof(WCHAR));
1347         if (!str2W)
1348         {
1349             if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
1350             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1351             return 0;
1352         }
1353         MultiByteToWideChar(locale_cp, 0, str2, len2, str2W, len2W);
1354     }
1355
1356     ret = CompareStringW(lcid, style, str1W, len1W, str2W, len2W);
1357
1358     if (str1W != buf1W) HeapFree(GetProcessHeap(), 0, str1W);
1359     if (str2W != buf2W) HeapFree(GetProcessHeap(), 0, str2W);
1360     return ret;
1361 }
1362
1363 /*************************************************************************
1364  *           lstrcmp     (KERNEL32.@)
1365  *           lstrcmpA    (KERNEL32.@)
1366  */
1367 int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
1368 {
1369     int ret = CompareStringA(GetThreadLocale(), 0, str1, -1, str2, -1);
1370     if (ret) ret -= 2;
1371     return ret;
1372 }
1373
1374 /*************************************************************************
1375  *           lstrcmpi     (KERNEL32.@)
1376  *           lstrcmpiA    (KERNEL32.@)
1377  */
1378 int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
1379 {
1380     int ret = CompareStringA(GetThreadLocale(), NORM_IGNORECASE, str1, -1, str2, -1);
1381     if (ret) ret -= 2;
1382     return ret;
1383 }
1384
1385 /*************************************************************************
1386  *           lstrcmpW    (KERNEL32.@)
1387  */
1388 int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
1389 {
1390     int ret = CompareStringW(GetThreadLocale(), 0, str1, -1, str2, -1);
1391     if (ret) ret -= 2;
1392     return ret;
1393 }
1394
1395 /*************************************************************************
1396  *           lstrcmpiW    (KERNEL32.@)
1397  */
1398 int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
1399 {
1400     int ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, -1, str2, -1);
1401     if (ret) ret -= 2;
1402     return ret;
1403 }
1404
1405 /******************************************************************************
1406  *              LOCALE_Init
1407  */
1408 void LOCALE_Init(void)
1409 {
1410     UINT ansi_cp = 1252, oem_cp = 437, mac_cp = 10000, unix_cp = -1;
1411     LCID lcid = init_default_lcid( &unix_cp );
1412
1413     NtSetDefaultLocale( FALSE, lcid );
1414     NtSetDefaultLocale( TRUE, lcid );
1415
1416     GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
1417                     (LPWSTR)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR) );
1418     GetLocaleInfoW( lcid, LOCALE_IDEFAULTMACCODEPAGE | LOCALE_RETURN_NUMBER,
1419                     (LPWSTR)&mac_cp, sizeof(mac_cp)/sizeof(WCHAR) );
1420     GetLocaleInfoW( lcid, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
1421                     (LPWSTR)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR) );
1422     if (unix_cp == -1)
1423         GetLocaleInfoW( lcid, LOCALE_IDEFAULTUNIXCODEPAGE | LOCALE_RETURN_NUMBER,
1424                     (LPWSTR)&unix_cp, sizeof(unix_cp)/sizeof(WCHAR) );
1425
1426     CODEPAGE_Init( ansi_cp, oem_cp, mac_cp, unix_cp, lcid );
1427     update_registry( lcid );
1428 }
1429
1430 /******************************************************************************
1431  *           EnumSystemLanguageGroupsA    (KERNEL32.@)
1432  */
1433 BOOL WINAPI EnumSystemLanguageGroupsA(
1434   LANGUAGEGROUP_ENUMPROCA pLangGroupEnumProc, /* [in] callback function */
1435   DWORD dwFlags,                              /* [in] language groups */
1436   LONG_PTR  lParam                            /* [in] callback parameter */
1437 )
1438 {
1439   FIXME("stub\n");
1440   SetLastError( ERROR_INVALID_PARAMETER );
1441   return FALSE;
1442 }
1443
1444 /******************************************************************************
1445  *           EnumSystemLanguageGroupsW    (KERNEL32.@)
1446  */
1447 BOOL WINAPI EnumSystemLanguageGroupsW(
1448   LANGUAGEGROUP_ENUMPROCW pLangGroupEnumProc, /* [in] callback function */
1449   DWORD dwFlags,                              /* [in] language groups */
1450   LONG_PTR  lParam                            /* [in] callback parameter */
1451 )
1452 {
1453   FIXME("stub\n");
1454   SetLastError( ERROR_INVALID_PARAMETER );
1455   return FALSE;
1456 }
1457
1458 /******************************************************************************
1459  *           InvalidateNLSCache           (KERNEL32.@)
1460  */
1461 BOOL WINAPI InvalidateNLSCache(void)
1462 {
1463   FIXME("stub\n");
1464   return FALSE;
1465 }