git.oblomov.eu Git - wine/blob - dlls/msvcrt/locale.c

   1 /*
   2  * msvcrt.dll locale functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <limits.h>
  25 #include <locale.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "winnls.h"
  33
  34 #include "msvcrt.h"
  35 #include "mtdll.h"
  36
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  40
  41 /* FIXME: Need to hold locale for each LC_* type and aggregate
  42  * string to produce lc_all.
  43  */
  44 #define MAX_ELEM_LEN 64 /* Max length of country/language/CP string */
  45 #define MAX_LOCALE_LENGTH 256
  46 MSVCRT__locale_t MSVCRT_locale = NULL;
  47 int MSVCRT___lc_codepage = 0;
  48 int MSVCRT___lc_collate_cp = 0;
  49 HANDLE MSVCRT___lc_handle[MSVCRT_LC_MAX - MSVCRT_LC_MIN + 1] = { 0 };
  50 unsigned char charmax = CHAR_MAX;
  51
  52 /* MT */
  53 #define LOCK_LOCALE   _mlock(_SETLOCALE_LOCK);
  54 #define UNLOCK_LOCALE _munlock(_SETLOCALE_LOCK);
  55
  56 #define MSVCRT_LEADBYTE  0x8000
  57
  58 /* Friendly country strings & iso codes for synonym support.
  59  * Based on MS documentation for setlocale().
  60  */
  61 static const char * const _country_synonyms[] =
  62 {
  63   "Hong Kong","HK",
  64   "Hong-Kong","HK",
  65   "New Zealand","NZ",
  66   "New-Zealand","NZ",
  67   "PR China","CN",
  68   "PR-China","CN",
  69   "United Kingdom","GB",
  70   "United-Kingdom","GB",
  71   "Britain","GB",
  72   "England","GB",
  73   "Great Britain","GB",
  74   "United States","US",
  75   "United-States","US",
  76   "America","US"
  77 };
  78
  79 /* INTERNAL: Map a synonym to an ISO code */
  80 static void remap_synonym(char *name)
  81 {
  82   unsigned int i;
  83   for (i = 0; i < sizeof(_country_synonyms)/sizeof(char*); i += 2 )
  84   {
  85     if (!strcasecmp(_country_synonyms[i],name))
  86     {
  87       TRACE(":Mapping synonym %s to %s\n",name,_country_synonyms[i+1]);
  88       name[0] = _country_synonyms[i+1][0];
  89       name[1] = _country_synonyms[i+1][1];
  90       name[2] = '\0';
  91       return;
  92     }
  93   }
  94 }
  95
  96 /* Note: Flags are weighted in order of matching importance */
  97 #define FOUND_LANGUAGE         0x4
  98 #define FOUND_COUNTRY          0x2
  99 #define FOUND_CODEPAGE         0x1
 100
 101 typedef struct {
 102   char search_language[MAX_ELEM_LEN];
 103   char search_country[MAX_ELEM_LEN];
 104   char search_codepage[MAX_ELEM_LEN];
 105   char found_language[MAX_ELEM_LEN];
 106   char found_country[MAX_ELEM_LEN];
 107   char found_codepage[MAX_ELEM_LEN];
 108   unsigned int match_flags;
 109   LANGID found_lang_id;
 110 } locale_search_t;
 111
 112 #define CONTINUE_LOOKING TRUE
 113 #define STOP_LOOKING     FALSE
 114
 115 /* INTERNAL: Get and compare locale info with a given string */
 116 static int compare_info(LCID lcid, DWORD flags, char* buff, const char* cmp)
 117 {
 118   buff[0] = 0;
 119   GetLocaleInfoA(lcid, flags|LOCALE_NOUSEROVERRIDE,buff, MAX_ELEM_LEN);
 120   if (!buff[0] || !cmp[0])
 121     return 0;
 122   /* Partial matches are allowed, e.g. "Germ" matches "Germany" */
 123   return !strncasecmp(cmp, buff, strlen(cmp));
 124 }
 125
 126 static BOOL CALLBACK
 127 find_best_locale_proc(HMODULE hModule, LPCSTR type, LPCSTR name, WORD LangID, LONG_PTR lParam)
 128 {
 129   locale_search_t *res = (locale_search_t *)lParam;
 130   const LCID lcid = MAKELCID(LangID, SORT_DEFAULT);
 131   char buff[MAX_ELEM_LEN];
 132   unsigned int flags = 0;
 133
 134   if(PRIMARYLANGID(LangID) == LANG_NEUTRAL)
 135     return CONTINUE_LOOKING;
 136
 137   /* Check Language */
 138   if (compare_info(lcid,LOCALE_SISO639LANGNAME,buff,res->search_language) ||
 139       compare_info(lcid,LOCALE_SABBREVLANGNAME,buff,res->search_language) ||
 140       compare_info(lcid,LOCALE_SENGLANGUAGE,buff,res->search_language))
 141   {
 142     TRACE(":Found language: %s->%s\n", res->search_language, buff);
 143     flags |= FOUND_LANGUAGE;
 144     memcpy(res->found_language,res->search_language,MAX_ELEM_LEN);
 145   }
 146   else if (res->match_flags & FOUND_LANGUAGE)
 147   {
 148     return CONTINUE_LOOKING;
 149   }
 150
 151   /* Check Country */
 152   if (compare_info(lcid,LOCALE_SISO3166CTRYNAME,buff,res->search_country) ||
 153       compare_info(lcid,LOCALE_SABBREVCTRYNAME,buff,res->search_country) ||
 154       compare_info(lcid,LOCALE_SENGCOUNTRY,buff,res->search_country))
 155   {
 156     TRACE("Found country:%s->%s\n", res->search_country, buff);
 157     flags |= FOUND_COUNTRY;
 158     memcpy(res->found_country,res->search_country,MAX_ELEM_LEN);
 159   }
 160   else if (res->match_flags & FOUND_COUNTRY)
 161   {
 162     return CONTINUE_LOOKING;
 163   }
 164
 165   /* Check codepage */
 166   if (compare_info(lcid,LOCALE_IDEFAULTCODEPAGE,buff,res->search_codepage) ||
 167       (compare_info(lcid,LOCALE_IDEFAULTANSICODEPAGE,buff,res->search_codepage)))
 168   {
 169     TRACE("Found codepage:%s->%s\n", res->search_codepage, buff);
 170     flags |= FOUND_CODEPAGE;
 171     memcpy(res->found_codepage,res->search_codepage,MAX_ELEM_LEN);
 172   }
 173   else if (res->match_flags & FOUND_CODEPAGE)
 174   {
 175     return CONTINUE_LOOKING;
 176   }
 177
 178   if (flags > res->match_flags)
 179   {
 180     /* Found a better match than previously */
 181     res->match_flags = flags;
 182     res->found_lang_id = LangID;
 183   }
 184   if ((flags & (FOUND_LANGUAGE | FOUND_COUNTRY | FOUND_CODEPAGE)) ==
 185         (FOUND_LANGUAGE | FOUND_COUNTRY | FOUND_CODEPAGE))
 186   {
 187     TRACE(":found exact locale match\n");
 188     return STOP_LOOKING;
 189   }
 190   return CONTINUE_LOOKING;
 191 }
 192
 193 extern int atoi(const char *);
 194
 195 /* Internal: Find the LCID for a locale specification */
 196 static LCID MSVCRT_locale_to_LCID(const char *locale)
 197 {
 198     LCID lcid;
 199     locale_search_t search;
 200     char *cp, *region;
 201
 202     memset(&search, 0, sizeof(locale_search_t));
 203
 204     cp = strchr(locale, '.');
 205     region = strchr(locale, '_');
 206
 207     lstrcpynA(search.search_language, locale, MAX_ELEM_LEN);
 208     if(region) {
 209         lstrcpynA(search.search_country, region+1, MAX_ELEM_LEN);
 210         if(region-locale < MAX_ELEM_LEN)
 211             search.search_language[region-locale] = '\0';
 212     } else
 213         search.search_country[0] = '\0';
 214
 215     if(cp) {
 216         lstrcpynA(search.search_codepage, cp+1, MAX_ELEM_LEN);
 217         if(cp-region < MAX_ELEM_LEN)
 218           search.search_country[cp-region] = '\0';
 219         if(cp-locale < MAX_ELEM_LEN)
 220             search.search_language[cp-locale] = '\0';
 221     } else
 222         search.search_codepage[0] = '\0';
 223
 224     /* FIXME:  MSVCRT_locale_to_LCID is not finding remaped values */
 225     remap_synonym(search.search_country);
 226
 227     EnumResourceLanguagesA(GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
 228             (LPCSTR)LOCALE_ILANGUAGE,find_best_locale_proc,
 229             (LONG_PTR)&search);
 230
 231     if (!search.match_flags)
 232         return 0;
 233
 234     /* If we were given something that didn't match, fail */
 235     if (search.search_country[0] && !(search.match_flags & FOUND_COUNTRY))
 236         return 0;
 237
 238     lcid =  MAKELCID(search.found_lang_id, SORT_DEFAULT);
 239
 240     /* Populate partial locale, translating LCID to locale string elements */
 241     if (!search.found_codepage[0]) {
 242         /* Even if a codepage is not enumerated for a locale
 243          * it can be set if valid */
 244         if (search.search_codepage[0]) {
 245             if (IsValidCodePage(atoi(search.search_codepage)))
 246                 memcpy(search.found_codepage,search.search_codepage,MAX_ELEM_LEN);
 247             else {
 248                 /* Special codepage values: OEM & ANSI */
 249                 if (strcasecmp(search.search_codepage,"OCP")) {
 250                     GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
 251                             search.found_codepage, MAX_ELEM_LEN);
 252                 } else if (strcasecmp(search.search_codepage,"ACP")) {
 253                     GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
 254                             search.found_codepage, MAX_ELEM_LEN);
 255                 } else
 256                     return 0;
 257
 258                 if (!atoi(search.found_codepage))
 259                     return 0;
 260             }
 261         } else {
 262             /* Prefer ANSI codepages if present */
 263             GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
 264                     search.found_codepage, MAX_ELEM_LEN);
 265             if (!search.found_codepage[0] || !atoi(search.found_codepage))
 266                 GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
 267                         search.found_codepage, MAX_ELEM_LEN);
 268         }
 269     }
 270
 271     GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE|LOCALE_NOUSEROVERRIDE,
 272             search.found_language, MAX_ELEM_LEN);
 273     GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY|LOCALE_NOUSEROVERRIDE,
 274             search.found_country, MAX_ELEM_LEN);
 275     return lcid;
 276 }
 277
 278 /* INTERNAL: Set lc_handle, lc_id and lc_category in threadlocinfo struct */
 279 static BOOL update_threadlocinfo_category(LCID lcid, MSVCRT__locale_t loc, int category)
 280 {
 281     char buf[256], *p;
 282     int len;
 283
 284     if(GetLocaleInfoA(lcid, LOCALE_ILANGUAGE, buf, 256)) {
 285         p = buf;
 286
 287         loc->locinfo->lc_id[category].wLanguage = 0;
 288         while(*p) {
 289             loc->locinfo->lc_id[category].wLanguage *= 16;
 290
 291             if(*p <= '9')
 292                 loc->locinfo->lc_id[category].wLanguage += *p-'0';
 293             else
 294                 loc->locinfo->lc_id[category].wLanguage += *p-'a'+10;
 295
 296             p++;
 297         }
 298
 299         loc->locinfo->lc_id[category].wCountry =
 300             loc->locinfo->lc_id[category].wLanguage;
 301     }
 302
 303     if(GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, buf, 256))
 304         loc->locinfo->lc_id[category].wCodePage = atoi(buf);
 305
 306     loc->locinfo->lc_handle[category] = lcid;
 307
 308     len = 0;
 309     len += GetLocaleInfoA(lcid, LOCALE_SLANGUAGE, buf, 256);
 310     buf[len-1] = '_';
 311     len += GetLocaleInfoA(lcid, LOCALE_SCOUNTRY, &buf[len], 256-len);
 312     buf[len-1] = '.';
 313     len += GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, &buf[len], 256-len);
 314
 315     loc->locinfo->lc_category[category].locale = MSVCRT_malloc(sizeof(char[len]));
 316     loc->locinfo->lc_category[category].refcount = MSVCRT_malloc(sizeof(int));
 317     if(!loc->locinfo->lc_category[category].locale
 318             || !loc->locinfo->lc_category[category].refcount) {
 319         MSVCRT_free(loc->locinfo->lc_category[category].locale);
 320         MSVCRT_free(loc->locinfo->lc_category[category].refcount);
 321         loc->locinfo->lc_category[category].locale = NULL;
 322         loc->locinfo->lc_category[category].refcount = NULL;
 323         return TRUE;
 324     }
 325     memcpy(loc->locinfo->lc_category[category].locale, buf, sizeof(char[len]));
 326     *loc->locinfo->lc_category[category].refcount = 1;
 327
 328     return FALSE;
 329 }
 330
 331 /* INTERNAL: swap pointers values */
 332 static inline void swap_pointers(void **p1, void **p2) {
 333     void *hlp;
 334
 335     hlp = *p1;
 336     *p1 = *p2;
 337     *p2 = hlp;
 338 }
 339
 340 /* INTERNAL: returns _locale_t struct for current locale */
 341 MSVCRT__locale_t get_locale(void) {
 342     thread_data_t *data = msvcrt_get_thread_data();
 343
 344     if(!data || !data->locale)
 345         return MSVCRT_locale;
 346
 347     return data->locale;
 348 }
 349
 350
 351 /*********************************************************************
 352  *              wsetlocale (MSVCRT.@)
 353  */
 354 MSVCRT_wchar_t* CDECL MSVCRT__wsetlocale(int category, const MSVCRT_wchar_t* locale)
 355 {
 356   static MSVCRT_wchar_t fake[] = {
 357     'E','n','g','l','i','s','h','_','U','n','i','t','e','d',' ',
 358     'S','t','a','t','e','s','.','1','2','5','2',0 };
 359
 360   FIXME("%d %s\n", category, debugstr_w(locale));
 361
 362   return fake;
 363 }
 364
 365 /*********************************************************************
 366  *              _Getdays (MSVCRT.@)
 367  */
 368 const char* CDECL _Getdays(void)
 369 {
 370   static const char MSVCRT_days[] = ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:"
 371                             "Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
 372   /* FIXME: Use locale */
 373   TRACE("(void) semi-stub\n");
 374   return MSVCRT_days;
 375 }
 376
 377 /*********************************************************************
 378  *              _Getmonths (MSVCRT.@)
 379  */
 380 const char* CDECL _Getmonths(void)
 381 {
 382   static const char MSVCRT_months[] = ":Jan:January:Feb:February:Mar:March:Apr:"
 383                 "April:May:May:Jun:June:Jul:July:Aug:August:Sep:September:Oct:"
 384                 "October:Nov:November:Dec:December";
 385   /* FIXME: Use locale */
 386   TRACE("(void) semi-stub\n");
 387   return MSVCRT_months;
 388 }
 389
 390 /*********************************************************************
 391  *              _Gettnames (MSVCRT.@)
 392  */
 393 const char* CDECL _Gettnames(void)
 394 {
 395   /* FIXME: */
 396   TRACE("(void) stub\n");
 397   return "";
 398 }
 399
 400 /*********************************************************************
 401  *              _Strftime (MSVCRT.@)
 402  */
 403 const char* CDECL _Strftime(char *out, unsigned int len, const char *fmt,
 404                             const void *tm, void *foo)
 405 {
 406   /* FIXME: */
 407   TRACE("(%p %d %s %p %p) stub\n", out, len, fmt, tm, foo);
 408   return "";
 409 }
 410
 411 /*********************************************************************
 412  *              __crtLCMapStringA (MSVCRT.@)
 413  */
 414 int CDECL __crtLCMapStringA(
 415   LCID lcid, DWORD mapflags, const char* src, int srclen, char* dst,
 416   int dstlen, unsigned int codepage, int xflag
 417 ) {
 418   FIXME("(lcid %x, flags %x, %s(%d), %p(%d), %x, %d), partial stub!\n",
 419         lcid,mapflags,src,srclen,dst,dstlen,codepage,xflag);
 420   /* FIXME: A bit incorrect. But msvcrt itself just converts its
 421    * arguments to wide strings and then calls LCMapStringW
 422    */
 423   return LCMapStringA(lcid,mapflags,src,srclen,dst,dstlen);
 424 }
 425
 426 /*********************************************************************
 427  *              __crtCompareStringA (MSVCRT.@)
 428  */
 429 int CDECL __crtCompareStringA( LCID lcid, DWORD flags, const char *src1, int len1,
 430                                const char *src2, int len2 )
 431 {
 432     FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
 433           lcid, flags, debugstr_a(src1), len1, debugstr_a(src2), len2 );
 434     /* FIXME: probably not entirely right */
 435     return CompareStringA( lcid, flags, src1, len1, src2, len2 );
 436 }
 437
 438 /*********************************************************************
 439  *              __crtCompareStringW (MSVCRT.@)
 440  */
 441 int CDECL __crtCompareStringW( LCID lcid, DWORD flags, const MSVCRT_wchar_t *src1, int len1,
 442                                const MSVCRT_wchar_t *src2, int len2 )
 443 {
 444     FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
 445           lcid, flags, debugstr_w(src1), len1, debugstr_w(src2), len2 );
 446     /* FIXME: probably not entirely right */
 447     return CompareStringW( lcid, flags, src1, len1, src2, len2 );
 448 }
 449
 450 /*********************************************************************
 451  *              __crtGetLocaleInfoW (MSVCRT.@)
 452  */
 453 int CDECL __crtGetLocaleInfoW( LCID lcid, LCTYPE type, MSVCRT_wchar_t *buffer, int len )
 454 {
 455     FIXME("(lcid %x, type %x, %p(%d), partial stub\n", lcid, type, buffer, len );
 456     /* FIXME: probably not entirely right */
 457     return GetLocaleInfoW( lcid, type, buffer, len );
 458 }
 459
 460 /*********************************************************************
 461  *              localeconv (MSVCRT.@)
 462  */
 463 struct MSVCRT_lconv * CDECL MSVCRT_localeconv(void)
 464 {
 465     static struct MSVCRT_lconv xlconv;
 466     struct lconv *ylconv = localeconv();
 467
 468     xlconv.decimal_point     = ylconv->decimal_point;
 469     xlconv.thousands_sep     = ylconv->thousands_sep;
 470     xlconv.grouping          = ylconv->grouping;  /* FIXME: fixup charmax here too */
 471     xlconv.int_curr_symbol   = ylconv->int_curr_symbol;
 472     xlconv.currency_symbol   = ylconv->currency_symbol;
 473     xlconv.mon_decimal_point = ylconv->mon_decimal_point;
 474     xlconv.mon_thousands_sep = ylconv->mon_thousands_sep;
 475     xlconv.mon_grouping      = ylconv->mon_grouping;
 476     xlconv.positive_sign     = ylconv->positive_sign;
 477     xlconv.negative_sign     = ylconv->negative_sign;
 478     xlconv.int_frac_digits   = ylconv->int_frac_digits;
 479     xlconv.frac_digits       = ylconv->frac_digits;
 480     xlconv.p_cs_precedes     = ylconv->p_cs_precedes;
 481     xlconv.p_sep_by_space    = ylconv->p_sep_by_space;
 482     xlconv.n_cs_precedes     = ylconv->n_cs_precedes;
 483     xlconv.n_sep_by_space    = ylconv->n_sep_by_space;
 484     xlconv.p_sign_posn       = ylconv->p_sign_posn;
 485     xlconv.n_sign_posn       = ylconv->n_sign_posn;
 486
 487     if (ylconv->int_frac_digits == CHAR_MAX) xlconv.int_frac_digits = charmax;
 488     if (ylconv->frac_digits == CHAR_MAX)     xlconv.frac_digits = charmax;
 489     if (ylconv->p_cs_precedes == CHAR_MAX)   xlconv.p_cs_precedes = charmax;
 490     if (ylconv->p_sep_by_space == CHAR_MAX)  xlconv.p_sep_by_space = charmax;
 491     if (ylconv->n_cs_precedes == CHAR_MAX)   xlconv.n_cs_precedes = charmax;
 492     if (ylconv->n_sep_by_space == CHAR_MAX)  xlconv.n_sep_by_space = charmax;
 493     if (ylconv->p_sign_posn == CHAR_MAX)     xlconv.p_sign_posn = charmax;
 494     if (ylconv->n_sign_posn == CHAR_MAX)     xlconv.n_sign_posn = charmax;
 495
 496     return &xlconv;
 497 }
 498
 499 /*********************************************************************
 500  *              __lconv_init (MSVCRT.@)
 501  */
 502 void CDECL __lconv_init(void)
 503 {
 504     /* this is used to make chars unsigned */
 505     charmax = 255;
 506 }
 507
 508 /*********************************************************************
 509  *      ___lc_handle_func (MSVCRT.@)
 510  */
 511 HANDLE * CDECL ___lc_handle_func(void)
 512 {
 513     return MSVCRT___lc_handle;
 514 }
 515
 516 /*********************************************************************
 517  *      ___lc_codepage_func (MSVCRT.@)
 518  */
 519 int CDECL ___lc_codepage_func(void)
 520 {
 521     return MSVCRT___lc_codepage;
 522 }
 523
 524 /*********************************************************************
 525  *      ___lc_collate_cp_func (MSVCRT.@)
 526  */
 527 int CDECL ___lc_collate_cp_func(void)
 528 {
 529     return get_locale()->locinfo->lc_collate_cp;
 530 }
 531
 532 /* _free_locale - not exported in native msvcrt */
 533 void CDECL _free_locale(MSVCRT__locale_t locale)
 534 {
 535     int i;
 536
 537     for(i=MSVCRT_LC_MIN+1; i<=MSVCRT_LC_MAX; i++) {
 538         MSVCRT_free(locale->locinfo->lc_category[i].locale);
 539         MSVCRT_free(locale->locinfo->lc_category[i].refcount);
 540     }
 541
 542     if(locale->locinfo->lconv) {
 543         MSVCRT_free(locale->locinfo->lconv->decimal_point);
 544         MSVCRT_free(locale->locinfo->lconv->thousands_sep);
 545         MSVCRT_free(locale->locinfo->lconv->grouping);
 546         MSVCRT_free(locale->locinfo->lconv->int_curr_symbol);
 547         MSVCRT_free(locale->locinfo->lconv->currency_symbol);
 548         MSVCRT_free(locale->locinfo->lconv->mon_decimal_point);
 549         MSVCRT_free(locale->locinfo->lconv->mon_thousands_sep);
 550         MSVCRT_free(locale->locinfo->lconv->mon_grouping);
 551         MSVCRT_free(locale->locinfo->lconv->positive_sign);
 552         MSVCRT_free(locale->locinfo->lconv->negative_sign);
 553     }
 554     MSVCRT_free(locale->locinfo->lconv_intl_refcount);
 555     MSVCRT_free(locale->locinfo->lconv_num_refcount);
 556     MSVCRT_free(locale->locinfo->lconv_mon_refcount);
 557     MSVCRT_free(locale->locinfo->lconv);
 558
 559     MSVCRT_free(locale->locinfo->ctype1_refcount);
 560     MSVCRT_free(locale->locinfo->ctype1);
 561
 562     MSVCRT_free(locale->locinfo->pclmap);
 563     MSVCRT_free(locale->locinfo->pcumap);
 564
 565     MSVCRT_free(locale->locinfo);
 566     MSVCRT_free(locale->mbcinfo);
 567     MSVCRT_free(locale);
 568 }
 569
 570 /* _create_locale - not exported in native msvcrt */
 571 MSVCRT__locale_t _create_locale(int category, const char *locale)
 572 {
 573     static const char collate[] = "COLLATE=";
 574     static const char ctype[] = "CTYPE=";
 575     static const char monetary[] = "MONETARY=";
 576     static const char numeric[] = "NUMERIC=";
 577     static const char time[] = "TIME=";
 578
 579     MSVCRT__locale_t loc;
 580     LCID lcid[6] = { 0 };
 581     char buf[256];
 582     int i;
 583
 584     TRACE("(%d %s)\n", category, locale);
 585
 586     if(category<MSVCRT_LC_MIN || category>MSVCRT_LC_MAX || !locale)
 587         return NULL;
 588
 589     if(locale[0]=='C' && !locale[1])
 590         lcid[0] = CP_ACP;
 591     else if(!locale[0])
 592         lcid[0] = GetSystemDefaultLCID();
 593     else if (locale[0] == 'L' && locale[1] == 'C' && locale[2] == '_') {
 594         char *p;
 595
 596         while(1) {
 597             locale += 3; /* LC_ */
 598             if(!memcmp(locale, collate, sizeof(collate)-1)) {
 599                 i = MSVCRT_LC_COLLATE;
 600                 locale += sizeof(collate)-1;
 601             } else if(!memcmp(locale, ctype, sizeof(ctype)-1)) {
 602                 i = MSVCRT_LC_CTYPE;
 603                 locale += sizeof(ctype)-1;
 604             } else if(!memcmp(locale, monetary, sizeof(monetary)-1)) {
 605                 i = MSVCRT_LC_MONETARY;
 606                 locale += sizeof(monetary)-1;
 607             } else if(!memcmp(locale, numeric, sizeof(numeric)-1)) {
 608                 i = MSVCRT_LC_NUMERIC;
 609                 locale += sizeof(numeric)-1;
 610             } else if(!memcmp(locale, time, sizeof(time)-1)) {
 611                 i = MSVCRT_LC_TIME;
 612                 locale += sizeof(time)-1;
 613             } else
 614                 return NULL;
 615
 616             p = strchr(locale, ';');
 617             if(p) {
 618                 memcpy(buf, locale, p-locale);
 619                 lcid[i] = MSVCRT_locale_to_LCID(buf);
 620             } else
 621                 lcid[i] = MSVCRT_locale_to_LCID(locale);
 622
 623             if(!lcid[i])
 624                 return NULL;
 625
 626             if(!p || *(p+1)!='L' || *(p+2)!='C' || *(p+3)!='_')
 627                 break;
 628
 629             locale = p+4;
 630         }
 631     } else {
 632         lcid[0] = MSVCRT_locale_to_LCID(locale);
 633         if(!lcid[0])
 634             return NULL;
 635     }
 636
 637     for(i=1; i<6; i++) {
 638         if(!lcid[i])
 639             lcid[i] = lcid[0];
 640     }
 641
 642     loc = MSVCRT_malloc(sizeof(MSVCRT__locale_tstruct));
 643     if(!loc)
 644         return NULL;
 645
 646     loc->locinfo = MSVCRT_malloc(sizeof(MSVCRT_threadlocinfo));
 647     if(!loc->locinfo) {
 648         MSVCRT_free(loc);
 649         return NULL;
 650     }
 651
 652     loc->mbcinfo = MSVCRT_malloc(sizeof(MSVCRT_threadmbcinfo));
 653     if(!loc->mbcinfo) {
 654         MSVCRT_free(loc->locinfo);
 655         MSVCRT_free(loc);
 656         return NULL;
 657     }
 658
 659     memset(loc->locinfo, 0, sizeof(MSVCRT_threadlocinfo));
 660     memset(loc->mbcinfo, 0, sizeof(MSVCRT_threadmbcinfo));
 661
 662     loc->locinfo->lconv = MSVCRT_malloc(sizeof(struct MSVCRT_lconv));
 663     if(!loc->locinfo->lconv) {
 664         _free_locale(loc);
 665         return NULL;
 666     }
 667     memset(loc->locinfo->lconv, 0, sizeof(struct MSVCRT_lconv));
 668
 669     loc->locinfo->pclmap = MSVCRT_malloc(sizeof(char[256]));
 670     loc->locinfo->pcumap = MSVCRT_malloc(sizeof(char[256]));
 671     if(!loc->locinfo->pclmap || !loc->locinfo->pcumap) {
 672         _free_locale(loc);
 673         return NULL;
 674     }
 675
 676     loc->locinfo->refcount = 1;
 677
 678     if(lcid[MSVCRT_LC_COLLATE] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_COLLATE)) {
 679         if(update_threadlocinfo_category(lcid[MSVCRT_LC_COLLATE], loc, MSVCRT_LC_COLLATE)) {
 680             _free_locale(loc);
 681             return NULL;
 682         }
 683     } else
 684         loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale = strdup("C");
 685
 686     if(lcid[MSVCRT_LC_CTYPE] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_CTYPE)) {
 687         CPINFO cp;
 688
 689         if(update_threadlocinfo_category(lcid[MSVCRT_LC_CTYPE], loc, MSVCRT_LC_CTYPE)) {
 690             _free_locale(loc);
 691             return NULL;
 692         }
 693
 694         loc->locinfo->lc_codepage = loc->locinfo->lc_id[MSVCRT_LC_CTYPE].wCodePage;
 695         loc->locinfo->lc_collate_cp = loc->locinfo->lc_codepage;
 696         loc->locinfo->lc_clike = 1;
 697         if(!GetCPInfo(loc->locinfo->lc_codepage, &cp)) {
 698             _free_locale(loc);
 699             return NULL;
 700         }
 701         loc->locinfo->mb_cur_max = cp.MaxCharSize;
 702
 703         loc->locinfo->ctype1_refcount = MSVCRT_malloc(sizeof(int));
 704         loc->locinfo->ctype1 = MSVCRT_malloc(sizeof(short[257]));
 705         if(!loc->locinfo->ctype1_refcount || !loc->locinfo->ctype1) {
 706             _free_locale(loc);
 707             return NULL;
 708         }
 709
 710         *loc->locinfo->ctype1_refcount = 1;
 711         loc->locinfo->ctype1[0] = 0;
 712         loc->locinfo->pctype = loc->locinfo->ctype1+1;
 713
 714         buf[1] = buf[2] = '\0';
 715         for(i=1; i<257; i++) {
 716             buf[0] = i-1;
 717
 718             GetStringTypeA(lcid[MSVCRT_LC_CTYPE], CT_CTYPE1, buf,
 719                     1, loc->locinfo->ctype1+i);
 720             loc->locinfo->ctype1[i] |= 0x200;
 721         }
 722     } else {
 723         loc->locinfo->lc_clike = 1;
 724         loc->locinfo->mb_cur_max = 1;
 725         loc->locinfo->pctype = MSVCRT__ctype+1;
 726         loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale = strdup("C");
 727     }
 728
 729     for(i=0; i<256; i++)
 730         buf[i] = i;
 731
 732     LCMapStringA(lcid[MSVCRT_LC_CTYPE], LCMAP_LOWERCASE, buf, 256,
 733             (char*)loc->locinfo->pclmap, 256);
 734     LCMapStringA(lcid[MSVCRT_LC_CTYPE], LCMAP_UPPERCASE, buf, 256,
 735             (char*)loc->locinfo->pcumap, 256);
 736
 737     loc->mbcinfo->refcount = 1;
 738     loc->mbcinfo->mbcodepage = loc->locinfo->lc_id[MSVCRT_LC_CTYPE].wCodePage;
 739
 740     for(i=0; i<256; i++) {
 741         if(loc->locinfo->pclmap[i] != i) {
 742             loc->mbcinfo->mbctype[i+1] |= 0x10;
 743             loc->mbcinfo->mbcasemap[i] = loc->locinfo->pclmap[i];
 744         } else if(loc->locinfo->pcumap[i] != i) {
 745             loc->mbcinfo->mbctype[i+1] |= 0x20;
 746             loc->mbcinfo->mbcasemap[i] = loc->locinfo->pcumap[i];
 747         }
 748     }
 749
 750     if(lcid[MSVCRT_LC_MONETARY] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_MONETARY)) {
 751         if(update_threadlocinfo_category(lcid[MSVCRT_LC_MONETARY], loc, MSVCRT_LC_MONETARY)) {
 752             _free_locale(loc);
 753             return NULL;
 754         }
 755
 756         loc->locinfo->lconv_intl_refcount = MSVCRT_malloc(sizeof(int));
 757         loc->locinfo->lconv_mon_refcount = MSVCRT_malloc(sizeof(int));
 758         if(!loc->locinfo->lconv_intl_refcount || !loc->locinfo->lconv_mon_refcount) {
 759             _free_locale(loc);
 760             return NULL;
 761         }
 762
 763         *loc->locinfo->lconv_intl_refcount = 1;
 764         *loc->locinfo->lconv_mon_refcount = 1;
 765
 766         i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SINTLSYMBOL, buf, 256);
 767         if(i && (loc->locinfo->lconv->int_curr_symbol = MSVCRT_malloc(sizeof(char[i]))))
 768             memcpy(loc->locinfo->lconv->int_curr_symbol, buf, sizeof(char[i]));
 769         else {
 770             _free_locale(loc);
 771             return NULL;
 772         }
 773
 774         i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SCURRENCY, buf, 256);
 775         if(i && (loc->locinfo->lconv->currency_symbol = MSVCRT_malloc(sizeof(char[i]))))
 776             memcpy(loc->locinfo->lconv->currency_symbol, buf, sizeof(char[i]));
 777         else {
 778             _free_locale(loc);
 779             return NULL;
 780         }
 781
 782         i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SMONDECIMALSEP, buf, 256);
 783         if(i && (loc->locinfo->lconv->mon_decimal_point = MSVCRT_malloc(sizeof(char[i]))))
 784             memcpy(loc->locinfo->lconv->mon_decimal_point, buf, sizeof(char[i]));
 785         else {
 786             _free_locale(loc);
 787             return NULL;
 788         }
 789
 790         i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SMONTHOUSANDSEP, buf, 256);
 791         if(i && (loc->locinfo->lconv->mon_thousands_sep = MSVCRT_malloc(sizeof(char[i]))))
 792             memcpy(loc->locinfo->lconv->mon_thousands_sep, buf, sizeof(char[i]));
 793         else {
 794             _free_locale(loc);
 795             return NULL;
 796         }
 797
 798         i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SMONGROUPING, buf, 256);
 799         if(i>1)
 800             i = i/2 + (buf[i-2]=='0'?0:1);
 801         if(i && (loc->locinfo->lconv->mon_grouping = MSVCRT_malloc(sizeof(char[i])))) {
 802             for(i=0; buf[i+1]==';'; i+=2)
 803                 loc->locinfo->lconv->mon_grouping[i/2] = buf[i]-'0';
 804             loc->locinfo->lconv->mon_grouping[i/2] = buf[i]-'0';
 805             if(buf[i] != '0')
 806                 loc->locinfo->lconv->mon_grouping[i/2+1] = 127;
 807         } else {
 808             _free_locale(loc);
 809             return NULL;
 810         }
 811
 812         i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SPOSITIVESIGN, buf, 256);
 813         if(i && (loc->locinfo->lconv->positive_sign = MSVCRT_malloc(sizeof(char[i]))))
 814             memcpy(loc->locinfo->lconv->positive_sign, buf, sizeof(char[i]));
 815         else {
 816             _free_locale(loc);
 817             return NULL;
 818         }
 819
 820         i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SNEGATIVESIGN, buf, 256);
 821         if(i && (loc->locinfo->lconv->negative_sign = MSVCRT_malloc(sizeof(char[i]))))
 822             memcpy(loc->locinfo->lconv->negative_sign, buf, sizeof(char[i]));
 823         else {
 824             _free_locale(loc);
 825             return NULL;
 826         }
 827
 828         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IINTLCURRDIGITS, buf, 256))
 829             loc->locinfo->lconv->int_frac_digits = atoi(buf);
 830         else {
 831             _free_locale(loc);
 832             return NULL;
 833         }
 834
 835         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_ICURRDIGITS, buf, 256))
 836             loc->locinfo->lconv->frac_digits = atoi(buf);
 837         else {
 838             _free_locale(loc);
 839             return NULL;
 840         }
 841
 842         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IPOSSYMPRECEDES, buf, 256))
 843             loc->locinfo->lconv->p_cs_precedes = atoi(buf);
 844         else {
 845             _free_locale(loc);
 846             return NULL;
 847         }
 848
 849         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IPOSSEPBYSPACE, buf, 256))
 850             loc->locinfo->lconv->p_sep_by_space = atoi(buf);
 851         else {
 852             _free_locale(loc);
 853             return NULL;
 854         }
 855
 856         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_INEGSYMPRECEDES, buf, 256))
 857             loc->locinfo->lconv->n_cs_precedes = atoi(buf);
 858         else {
 859             _free_locale(loc);
 860             return NULL;
 861         }
 862
 863         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_INEGSEPBYSPACE, buf, 256))
 864             loc->locinfo->lconv->n_sep_by_space = atoi(buf);
 865         else {
 866             _free_locale(loc);
 867             return NULL;
 868         }
 869
 870         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IPOSSIGNPOSN, buf, 256))
 871             loc->locinfo->lconv->p_sign_posn = atoi(buf);
 872         else {
 873             _free_locale(loc);
 874             return NULL;
 875         }
 876
 877         if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_INEGSIGNPOSN, buf, 256))
 878             loc->locinfo->lconv->n_sign_posn = atoi(buf);
 879         else {
 880             _free_locale(loc);
 881             return NULL;
 882         }
 883     } else {
 884         loc->locinfo->lconv->int_curr_symbol = MSVCRT_malloc(sizeof(char));
 885         loc->locinfo->lconv->currency_symbol = MSVCRT_malloc(sizeof(char));
 886         loc->locinfo->lconv->mon_decimal_point = MSVCRT_malloc(sizeof(char));
 887         loc->locinfo->lconv->mon_thousands_sep = MSVCRT_malloc(sizeof(char));
 888         loc->locinfo->lconv->mon_grouping = MSVCRT_malloc(sizeof(char));
 889         loc->locinfo->lconv->positive_sign = MSVCRT_malloc(sizeof(char));
 890         loc->locinfo->lconv->negative_sign = MSVCRT_malloc(sizeof(char));
 891
 892         if(!loc->locinfo->lconv->int_curr_symbol || !loc->locinfo->lconv->currency_symbol
 893                 || !loc->locinfo->lconv->mon_decimal_point || !loc->locinfo->lconv->mon_thousands_sep
 894                 || !loc->locinfo->lconv->mon_grouping || !loc->locinfo->lconv->positive_sign
 895                 || !loc->locinfo->lconv->negative_sign) {
 896             _free_locale(loc);
 897             return NULL;
 898         }
 899
 900         loc->locinfo->lconv->int_curr_symbol[0] = '\0';
 901         loc->locinfo->lconv->currency_symbol[0] = '\0';
 902         loc->locinfo->lconv->mon_decimal_point[0] = '\0';
 903         loc->locinfo->lconv->mon_thousands_sep[0] = '\0';
 904         loc->locinfo->lconv->mon_grouping[0] = '\0';
 905         loc->locinfo->lconv->positive_sign[0] = '\0';
 906         loc->locinfo->lconv->negative_sign[0] = '\0';
 907         loc->locinfo->lconv->int_frac_digits = 127;
 908         loc->locinfo->lconv->frac_digits = 127;
 909         loc->locinfo->lconv->p_cs_precedes = 127;
 910         loc->locinfo->lconv->p_sep_by_space = 127;
 911         loc->locinfo->lconv->n_cs_precedes = 127;
 912         loc->locinfo->lconv->n_sep_by_space = 127;
 913         loc->locinfo->lconv->p_sign_posn = 127;
 914         loc->locinfo->lconv->n_sign_posn = 127;
 915
 916         loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale = strdup("C");
 917     }
 918
 919     if(lcid[MSVCRT_LC_NUMERIC] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_NUMERIC)) {
 920         if(update_threadlocinfo_category(lcid[MSVCRT_LC_NUMERIC], loc, MSVCRT_LC_NUMERIC)) {
 921             _free_locale(loc);
 922             return NULL;
 923         }
 924
 925         if(!loc->locinfo->lconv_intl_refcount)
 926             loc->locinfo->lconv_intl_refcount = MSVCRT_malloc(sizeof(int));
 927         loc->locinfo->lconv_num_refcount = MSVCRT_malloc(sizeof(int));
 928         if(!loc->locinfo->lconv_intl_refcount || !loc->locinfo->lconv_num_refcount) {
 929             _free_locale(loc);
 930             return NULL;
 931         }
 932
 933         *loc->locinfo->lconv_intl_refcount = 1;
 934         *loc->locinfo->lconv_num_refcount = 1;
 935
 936         i = GetLocaleInfoA(lcid[MSVCRT_LC_NUMERIC], LOCALE_SDECIMAL, buf, 256);
 937         if(i && (loc->locinfo->lconv->decimal_point = MSVCRT_malloc(sizeof(char[i]))))
 938             memcpy(loc->locinfo->lconv->decimal_point, buf, sizeof(char[i]));
 939         else {
 940             _free_locale(loc);
 941             return NULL;
 942         }
 943
 944         i = GetLocaleInfoA(lcid[MSVCRT_LC_NUMERIC], LOCALE_STHOUSAND, buf, 256);
 945         if(i && (loc->locinfo->lconv->thousands_sep = MSVCRT_malloc(sizeof(char[i]))))
 946             memcpy(loc->locinfo->lconv->thousands_sep, buf, sizeof(char[i]));
 947         else {
 948             _free_locale(loc);
 949             return NULL;
 950         }
 951
 952         i = GetLocaleInfoA(lcid[MSVCRT_LC_NUMERIC], LOCALE_SGROUPING, buf, 256);
 953         if(i>1)
 954             i = i/2 + (buf[i-2]=='0'?0:1);
 955         if(i && (loc->locinfo->lconv->grouping = MSVCRT_malloc(sizeof(char[i])))) {
 956             for(i=0; buf[i+1]==';'; i+=2)
 957                 loc->locinfo->lconv->grouping[i/2] = buf[i]-'0';
 958             loc->locinfo->lconv->grouping[i/2] = buf[i]-'0';
 959             if(buf[i] != '0')
 960                 loc->locinfo->lconv->grouping[i/2+1] = 127;
 961         } else {
 962             _free_locale(loc);
 963             return NULL;
 964         }
 965     } else {
 966         loc->locinfo->lconv->decimal_point = MSVCRT_malloc(sizeof(char[2]));
 967         loc->locinfo->lconv->thousands_sep = MSVCRT_malloc(sizeof(char));
 968         loc->locinfo->lconv->grouping = MSVCRT_malloc(sizeof(char));
 969         if(!loc->locinfo->lconv->decimal_point || !loc->locinfo->lconv->thousands_sep
 970                 || !loc->locinfo->lconv->grouping) {
 971             _free_locale(loc);
 972             return NULL;
 973         }
 974
 975         loc->locinfo->lconv->decimal_point[0] = '.';
 976         loc->locinfo->lconv->decimal_point[1] = '\0';
 977         loc->locinfo->lconv->thousands_sep[0] = '\0';
 978         loc->locinfo->lconv->grouping[0] = '\0';
 979
 980         loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale = strdup("C");
 981     }
 982
 983     if(lcid[MSVCRT_LC_TIME] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_TIME)) {
 984         if(update_threadlocinfo_category(lcid[MSVCRT_LC_TIME], loc, MSVCRT_LC_TIME)) {
 985             _free_locale(loc);
 986             return NULL;
 987         }
 988     } else
 989         loc->locinfo->lc_category[MSVCRT_LC_TIME].locale = strdup("C");
 990
 991     return loc;
 992 }
 993
 994 /* _configthreadlocale - not exported in native msvcrt */
 995 int CDECL _configthreadlocale(int type)
 996 {
 997     thread_data_t *data = msvcrt_get_thread_data();
 998     int ret;
 999
1000     if(!data)
1001         return -1;
1002
1003     ret = (data->locale ? MSVCRT__ENABLE_PER_THREAD_LOCALE : MSVCRT__DISABLE_PER_THREAD_LOCALE);
1004
1005     if(type == MSVCRT__ENABLE_PER_THREAD_LOCALE) {
1006         if(!data->locale) {
1007             /* Copy current global locale */
1008             data->locale = _create_locale(MSVCRT_LC_ALL, MSVCRT_setlocale(MSVCRT_LC_ALL, NULL));
1009             if(!data->locale)
1010                 return -1;
1011         }
1012
1013         return ret;
1014     }
1015
1016     if(type == MSVCRT__DISABLE_PER_THREAD_LOCALE) {
1017         if(data->locale) {
1018             _free_locale(data->locale);
1019             data->locale = NULL;
1020         }
1021
1022         return ret;
1023     }
1024
1025     if(!type)
1026         return ret;
1027
1028     return -1;
1029 }
1030
1031 /*********************************************************************
1032  *             setlocale (MSVCRT.@)
1033  */
1034 char* CDECL MSVCRT_setlocale(int category, const char* locale)
1035 {
1036     static char current_lc_all[MAX_LOCALE_LENGTH];
1037
1038     MSVCRT__locale_t loc, cur;
1039
1040     cur = get_locale();
1041
1042     if(locale == NULL) {
1043         if(category == MSVCRT_LC_ALL) {
1044             sprintf(current_lc_all,
1045                     "LC_COLLATE=%s;LC_CTYPE=%s;LC_MONETARY=%s;LC_NUMERIC=%s;LC_TIME=%s",
1046                     cur->locinfo->lc_category[MSVCRT_LC_COLLATE].locale,
1047                     cur->locinfo->lc_category[MSVCRT_LC_CTYPE].locale,
1048                     cur->locinfo->lc_category[MSVCRT_LC_MONETARY].locale,
1049                     cur->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale,
1050                     cur->locinfo->lc_category[MSVCRT_LC_TIME].locale);
1051
1052             return current_lc_all;
1053         }
1054
1055         return cur->locinfo->lc_category[category].locale;
1056     }
1057
1058     loc = _create_locale(category, locale);
1059     if(!loc)
1060         return NULL;
1061
1062     LOCK_LOCALE;
1063
1064     switch(category) {
1065         case MSVCRT_LC_ALL:
1066             if(!cur)
1067                 break;
1068         case MSVCRT_LC_COLLATE:
1069             cur->locinfo->lc_handle[MSVCRT_LC_COLLATE] =
1070                 loc->locinfo->lc_handle[MSVCRT_LC_COLLATE];
1071             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_COLLATE].locale,
1072                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale);
1073             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_COLLATE].refcount,
1074                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_COLLATE].refcount);
1075
1076             if(category != MSVCRT_LC_ALL)
1077                 break;
1078         case MSVCRT_LC_CTYPE:
1079             cur->locinfo->lc_handle[MSVCRT_LC_CTYPE] =
1080                 loc->locinfo->lc_handle[MSVCRT_LC_CTYPE];
1081             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_CTYPE].locale,
1082                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale);
1083             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_CTYPE].refcount,
1084                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_CTYPE].refcount);
1085
1086             cur->locinfo->lc_codepage = loc->locinfo->lc_codepage;
1087             cur->locinfo->lc_collate_cp = loc->locinfo->lc_collate_cp;
1088             cur->locinfo->lc_clike = loc->locinfo->lc_clike;
1089             cur->locinfo->mb_cur_max = loc->locinfo->mb_cur_max;
1090
1091             swap_pointers((void**)&cur->locinfo->ctype1_refcount,
1092                     (void**)&loc->locinfo->ctype1_refcount);
1093             swap_pointers((void**)&cur->locinfo->ctype1, (void**)&loc->locinfo->ctype1);
1094             swap_pointers((void**)&cur->locinfo->pctype, (void**)&loc->locinfo->pctype);
1095             swap_pointers((void**)&cur->locinfo->pclmap, (void**)&loc->locinfo->pclmap);
1096             swap_pointers((void**)&cur->locinfo->pcumap, (void**)&loc->locinfo->pcumap);
1097
1098             memcpy(cur->mbcinfo, loc->mbcinfo, sizeof(MSVCRT_threadmbcinfo));
1099
1100             if(category != MSVCRT_LC_ALL)
1101                 break;
1102         case MSVCRT_LC_MONETARY:
1103             cur->locinfo->lc_handle[MSVCRT_LC_MONETARY] =
1104                 loc->locinfo->lc_handle[MSVCRT_LC_MONETARY];
1105             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_MONETARY].locale,
1106                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale);
1107             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_MONETARY].refcount,
1108                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_MONETARY].refcount);
1109
1110             swap_pointers((void**)&cur->locinfo->lconv->int_curr_symbol,
1111                     (void**)&loc->locinfo->lconv->int_curr_symbol);
1112             swap_pointers((void**)&cur->locinfo->lconv->currency_symbol,
1113                     (void**)&loc->locinfo->lconv->currency_symbol);
1114             swap_pointers((void**)&cur->locinfo->lconv->mon_decimal_point,
1115                     (void**)&loc->locinfo->lconv->mon_decimal_point);
1116             swap_pointers((void**)&cur->locinfo->lconv->mon_thousands_sep,
1117                     (void**)&loc->locinfo->lconv->mon_thousands_sep);
1118             swap_pointers((void**)&cur->locinfo->lconv->mon_grouping,
1119                     (void**)&loc->locinfo->lconv->mon_grouping);
1120             swap_pointers((void**)&cur->locinfo->lconv->positive_sign,
1121                     (void**)&loc->locinfo->lconv->positive_sign);
1122             swap_pointers((void**)&cur->locinfo->lconv->negative_sign,
1123                     (void**)&loc->locinfo->lconv->negative_sign);
1124             cur->locinfo->lconv->int_frac_digits = loc->locinfo->lconv->int_frac_digits;
1125             cur->locinfo->lconv->frac_digits = loc->locinfo->lconv->frac_digits;
1126             cur->locinfo->lconv->p_cs_precedes = loc->locinfo->lconv->p_cs_precedes;
1127             cur->locinfo->lconv->p_sep_by_space = loc->locinfo->lconv->p_sep_by_space;
1128             cur->locinfo->lconv->n_cs_precedes = loc->locinfo->lconv->n_cs_precedes;
1129             cur->locinfo->lconv->n_sep_by_space = loc->locinfo->lconv->n_sep_by_space;
1130             cur->locinfo->lconv->p_sign_posn = loc->locinfo->lconv->p_sign_posn;
1131             cur->locinfo->lconv->n_sign_posn = loc->locinfo->lconv->n_sign_posn;
1132
1133             if(category != MSVCRT_LC_ALL)
1134                 break;
1135         case MSVCRT_LC_NUMERIC:
1136             cur->locinfo->lc_handle[MSVCRT_LC_NUMERIC] =
1137                 loc->locinfo->lc_handle[MSVCRT_LC_NUMERIC];
1138             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale,
1139                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale);
1140             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_NUMERIC].refcount,
1141                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].refcount);
1142
1143             swap_pointers((void**)&cur->locinfo->lconv->decimal_point,
1144                     (void**)&loc->locinfo->lconv->decimal_point);
1145             swap_pointers((void**)&cur->locinfo->lconv->thousands_sep,
1146                     (void**)&loc->locinfo->lconv->thousands_sep);
1147             swap_pointers((void**)&cur->locinfo->lconv->grouping,
1148                     (void**)&loc->locinfo->lconv->grouping);
1149
1150             if(category != MSVCRT_LC_ALL)
1151                 break;
1152         case MSVCRT_LC_TIME:
1153             cur->locinfo->lc_handle[MSVCRT_LC_TIME] =
1154                 loc->locinfo->lc_handle[MSVCRT_LC_TIME];
1155             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_TIME].locale,
1156                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_TIME].locale);
1157             swap_pointers((void**)&cur->locinfo->lc_category[MSVCRT_LC_TIME].refcount,
1158                     (void**)&loc->locinfo->lc_category[MSVCRT_LC_TIME].refcount);
1159
1160             if(category != MSVCRT_LC_ALL)
1161                 break;
1162     }
1163
1164     if(!cur)
1165         MSVCRT_locale = cur = loc;
1166     else
1167         _free_locale(loc);
1168
1169     UNLOCK_LOCALE;
1170
1171     if(cur == MSVCRT_locale) {
1172         MSVCRT___lc_codepage = cur->locinfo->lc_codepage;
1173         MSVCRT___lc_collate_cp = cur->locinfo->lc_collate_cp;
1174         MSVCRT___mb_cur_max = cur->locinfo->mb_cur_max;
1175         MSVCRT__pctype = cur->locinfo->pctype;
1176     }
1177
1178     if(category == MSVCRT_LC_ALL)
1179         return cur->locinfo->lc_category[MSVCRT_LC_COLLATE].locale;
1180
1181     return cur->locinfo->lc_category[category].locale;
1182 }