?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Change implementation of setlocale.
[wine/testsucceed.git] / dlls / msvcrt / locale.c
blobc30b90751a54b0b6733252f9e220d25524e2f06c
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;
48 int MSVCRT___lc_collate_cp;
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(locale_search_t* locale)
197 {
198 LCID lcid;
199 EnumResourceLanguagesA(GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
200 (LPCSTR)LOCALE_ILANGUAGE,find_best_locale_proc,
201 (LONG_PTR)locale);
202
203 if (!locale->match_flags)
204 return 0;
205
206 /* If we were given something that didn't match, fail */
207 if (locale->search_country[0] && !(locale->match_flags & FOUND_COUNTRY))
208 return 0;
209
210 lcid = MAKELCID(locale->found_lang_id, SORT_DEFAULT);
211
212 /* Populate partial locale, translating LCID to locale string elements */
213 if (!locale->found_codepage[0])
214 {
215 /* Even if a codepage is not enumerated for a locale
216 * it can be set if valid */
217 if (locale->search_codepage[0])
218 {
219 if (IsValidCodePage(atoi(locale->search_codepage)))
220 memcpy(locale->found_codepage,locale->search_codepage,MAX_ELEM_LEN);
221 else
222 {
223 /* Special codepage values: OEM & ANSI */
224 if (strcasecmp(locale->search_codepage,"OCP"))
225 {
226 GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
227 locale->found_codepage, MAX_ELEM_LEN);
228 }
229 else if (strcasecmp(locale->search_codepage,"ACP"))
230 {
231 GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
232 locale->found_codepage, MAX_ELEM_LEN);
233 }
234 else
235 return 0;
236
237 if (!atoi(locale->found_codepage))
238 return 0;
239 }
240 }
241 else
242 {
243 /* Prefer ANSI codepages if present */
244 GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
245 locale->found_codepage, MAX_ELEM_LEN);
246 if (!locale->found_codepage[0] || !atoi(locale->found_codepage))
247 GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
248 locale->found_codepage, MAX_ELEM_LEN);
249 }
250 }
251 GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE|LOCALE_NOUSEROVERRIDE,
252 locale->found_language, MAX_ELEM_LEN);
253 GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY|LOCALE_NOUSEROVERRIDE,
254 locale->found_country, MAX_ELEM_LEN);
255 return lcid;
256 }
257
258 /* INTERNAL: Set lc_handle, lc_id and lc_category in threadlocinfo struct */
259 static BOOL update_threadlocinfo_category(LCID lcid, MSVCRT__locale_t loc, int category)
260 {
261 char buf[256], *p;
262 int len;
263
264 if(GetLocaleInfoA(lcid, LOCALE_ILANGUAGE, buf, 256)) {
265 p = buf;
266
267 loc->locinfo->lc_id[category].wLanguage = 0;
268 while(*p) {
269 loc->locinfo->lc_id[category].wLanguage *= 16;
270
271 if(*p <= '9')
272 loc->locinfo->lc_id[category].wLanguage += *p-'0';
273 else
274 loc->locinfo->lc_id[category].wLanguage += *p-'a'+10;
275
276 p++;
277 }
278
279 loc->locinfo->lc_id[category].wCountry =
280 loc->locinfo->lc_id[category].wLanguage;
281 }
282
283 if(GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, buf, 256))
284 loc->locinfo->lc_id[category].wCodePage = atoi(buf);
285
286 loc->locinfo->lc_handle[category] = lcid;
287
288 len = 0;
289 len += GetLocaleInfoA(lcid, LOCALE_SLANGUAGE, buf, 256);
290 buf[len-1] = '_';
291 len += GetLocaleInfoA(lcid, LOCALE_SCOUNTRY, &buf[len], 256-len);
292 buf[len-1] = '.';
293 len += GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, &buf[len], 256-len);
294
295 loc->locinfo->lc_category[category].locale = MSVCRT_malloc(sizeof(char[len]));
296 loc->locinfo->lc_category[category].refcount = MSVCRT_malloc(sizeof(int));
297 if(!loc->locinfo->lc_category[category].locale
298 || !loc->locinfo->lc_category[category].refcount) {
299 MSVCRT_free(loc->locinfo->lc_category[category].locale);
300 MSVCRT_free(loc->locinfo->lc_category[category].refcount);
301 loc->locinfo->lc_category[category].locale = NULL;
302 loc->locinfo->lc_category[category].refcount = NULL;
303 return TRUE;
304 }
305 memcpy(loc->locinfo->lc_category[category].locale, buf, sizeof(char[len]));
306 *loc->locinfo->lc_category[category].refcount = 1;
307
308 return FALSE;
309 }
310
311 /* INTERNAL: swap pointers values */
312 static inline void swap_pointers(void **p1, void **p2) {
313 void *hlp;
314
315 hlp = *p1;
316 *p1 = *p2;
317 *p2 = hlp;
318 }
319
320
321 /*********************************************************************
322 * wsetlocale (MSVCRT.@)
323 */
324 MSVCRT_wchar_t* CDECL MSVCRT__wsetlocale(int category, const MSVCRT_wchar_t* locale)
325 {
326 static MSVCRT_wchar_t fake[] = {
327 'E','n','g','l','i','s','h','_','U','n','i','t','e','d',' ',
328 'S','t','a','t','e','s','.','1','2','5','2',0 };
329
330 FIXME("%d %s\n", category, debugstr_w(locale));
331
332 return fake;
333 }
334
335 /*********************************************************************
336 * _Getdays (MSVCRT.@)
337 */
338 const char* CDECL _Getdays(void)
339 {
340 static const char MSVCRT_days[] = ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:"
341 "Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
342 /* FIXME: Use locale */
343 TRACE("(void) semi-stub\n");
344 return MSVCRT_days;
345 }
346
347 /*********************************************************************
348 * _Getmonths (MSVCRT.@)
349 */
350 const char* CDECL _Getmonths(void)
351 {
352 static const char MSVCRT_months[] = ":Jan:January:Feb:February:Mar:March:Apr:"
353 "April:May:May:Jun:June:Jul:July:Aug:August:Sep:September:Oct:"
354 "October:Nov:November:Dec:December";
355 /* FIXME: Use locale */
356 TRACE("(void) semi-stub\n");
357 return MSVCRT_months;
358 }
359
360 /*********************************************************************
361 * _Gettnames (MSVCRT.@)
362 */
363 const char* CDECL _Gettnames(void)
364 {
365 /* FIXME: */
366 TRACE("(void) stub\n");
367 return "";
368 }
369
370 /*********************************************************************
371 * _Strftime (MSVCRT.@)
372 */
373 const char* CDECL _Strftime(char *out, unsigned int len, const char *fmt,
374 const void *tm, void *foo)
375 {
376 /* FIXME: */
377 TRACE("(%p %d %s %p %p) stub\n", out, len, fmt, tm, foo);
378 return "";
379 }
380
381 /*********************************************************************
382 * __crtLCMapStringA (MSVCRT.@)
383 */
384 int CDECL __crtLCMapStringA(
385 LCID lcid, DWORD mapflags, const char* src, int srclen, char* dst,
386 int dstlen, unsigned int codepage, int xflag
387 ) {
388 FIXME("(lcid %x, flags %x, %s(%d), %p(%d), %x, %d), partial stub!\n",
389 lcid,mapflags,src,srclen,dst,dstlen,codepage,xflag);
390 /* FIXME: A bit incorrect. But msvcrt itself just converts its
391 * arguments to wide strings and then calls LCMapStringW
392 */
393 return LCMapStringA(lcid,mapflags,src,srclen,dst,dstlen);
394 }
395
396 /*********************************************************************
397 * __crtCompareStringA (MSVCRT.@)
398 */
399 int CDECL __crtCompareStringA( LCID lcid, DWORD flags, const char *src1, int len1,
400 const char *src2, int len2 )
401 {
402 FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
403 lcid, flags, debugstr_a(src1), len1, debugstr_a(src2), len2 );
404 /* FIXME: probably not entirely right */
405 return CompareStringA( lcid, flags, src1, len1, src2, len2 );
406 }
407
408 /*********************************************************************
409 * __crtCompareStringW (MSVCRT.@)
410 */
411 int CDECL __crtCompareStringW( LCID lcid, DWORD flags, const MSVCRT_wchar_t *src1, int len1,
412 const MSVCRT_wchar_t *src2, int len2 )
413 {
414 FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
415 lcid, flags, debugstr_w(src1), len1, debugstr_w(src2), len2 );
416 /* FIXME: probably not entirely right */
417 return CompareStringW( lcid, flags, src1, len1, src2, len2 );
418 }
419
420 /*********************************************************************
421 * __crtGetLocaleInfoW (MSVCRT.@)
422 */
423 int CDECL __crtGetLocaleInfoW( LCID lcid, LCTYPE type, MSVCRT_wchar_t *buffer, int len )
424 {
425 FIXME("(lcid %x, type %x, %p(%d), partial stub\n", lcid, type, buffer, len );
426 /* FIXME: probably not entirely right */
427 return GetLocaleInfoW( lcid, type, buffer, len );
428 }
429
430 /*********************************************************************
431 * localeconv (MSVCRT.@)
432 */
433 struct MSVCRT_lconv * CDECL MSVCRT_localeconv(void)
434 {
435 static struct MSVCRT_lconv xlconv;
436 struct lconv *ylconv = localeconv();
437
438 xlconv.decimal_point = ylconv->decimal_point;
439 xlconv.thousands_sep = ylconv->thousands_sep;
440 xlconv.grouping = ylconv->grouping; /* FIXME: fixup charmax here too */
441 xlconv.int_curr_symbol = ylconv->int_curr_symbol;
442 xlconv.currency_symbol = ylconv->currency_symbol;
443 xlconv.mon_decimal_point = ylconv->mon_decimal_point;
444 xlconv.mon_thousands_sep = ylconv->mon_thousands_sep;
445 xlconv.mon_grouping = ylconv->mon_grouping;
446 xlconv.positive_sign = ylconv->positive_sign;
447 xlconv.negative_sign = ylconv->negative_sign;
448 xlconv.int_frac_digits = ylconv->int_frac_digits;
449 xlconv.frac_digits = ylconv->frac_digits;
450 xlconv.p_cs_precedes = ylconv->p_cs_precedes;
451 xlconv.p_sep_by_space = ylconv->p_sep_by_space;
452 xlconv.n_cs_precedes = ylconv->n_cs_precedes;
453 xlconv.n_sep_by_space = ylconv->n_sep_by_space;
454 xlconv.p_sign_posn = ylconv->p_sign_posn;
455 xlconv.n_sign_posn = ylconv->n_sign_posn;
456
457 if (ylconv->int_frac_digits == CHAR_MAX) xlconv.int_frac_digits = charmax;
458 if (ylconv->frac_digits == CHAR_MAX) xlconv.frac_digits = charmax;
459 if (ylconv->p_cs_precedes == CHAR_MAX) xlconv.p_cs_precedes = charmax;
460 if (ylconv->p_sep_by_space == CHAR_MAX) xlconv.p_sep_by_space = charmax;
461 if (ylconv->n_cs_precedes == CHAR_MAX) xlconv.n_cs_precedes = charmax;
462 if (ylconv->n_sep_by_space == CHAR_MAX) xlconv.n_sep_by_space = charmax;
463 if (ylconv->p_sign_posn == CHAR_MAX) xlconv.p_sign_posn = charmax;
464 if (ylconv->n_sign_posn == CHAR_MAX) xlconv.n_sign_posn = charmax;
465
466 return &xlconv;
467 }
468
469 /*********************************************************************
470 * __lconv_init (MSVCRT.@)
471 */
472 void CDECL __lconv_init(void)
473 {
474 /* this is used to make chars unsigned */
475 charmax = 255;
476 }
477
478 /*********************************************************************
479 * ___lc_handle_func (MSVCRT.@)
480 */
481 HANDLE * CDECL ___lc_handle_func(void)
482 {
483 return MSVCRT___lc_handle;
484 }
485
486 /*********************************************************************
487 * ___lc_codepage_func (MSVCRT.@)
488 */
489 int CDECL ___lc_codepage_func(void)
490 {
491 return MSVCRT___lc_codepage;
492 }
493
494 /*********************************************************************
495 * ___lc_collate_cp_func (MSVCRT.@)
496 */
497 int CDECL ___lc_collate_cp_func(void)
498 {
499 return MSVCRT___lc_collate_cp;
500 }
501
502 /* _free_locale - not exported in native msvcrt */
503 void CDECL _free_locale(MSVCRT__locale_t locale)
504 {
505 int i;
506
507 for(i=MSVCRT_LC_MIN+1; i<=MSVCRT_LC_MAX; i++) {
508 MSVCRT_free(locale->locinfo->lc_category[i].locale);
509 MSVCRT_free(locale->locinfo->lc_category[i].refcount);
510 }
511
512 if(locale->locinfo->lconv) {
513 MSVCRT_free(locale->locinfo->lconv->decimal_point);
514 MSVCRT_free(locale->locinfo->lconv->thousands_sep);
515 MSVCRT_free(locale->locinfo->lconv->grouping);
516 MSVCRT_free(locale->locinfo->lconv->int_curr_symbol);
517 MSVCRT_free(locale->locinfo->lconv->currency_symbol);
518 MSVCRT_free(locale->locinfo->lconv->mon_decimal_point);
519 MSVCRT_free(locale->locinfo->lconv->mon_thousands_sep);
520 MSVCRT_free(locale->locinfo->lconv->mon_grouping);
521 MSVCRT_free(locale->locinfo->lconv->positive_sign);
522 MSVCRT_free(locale->locinfo->lconv->negative_sign);
523 }
524 MSVCRT_free(locale->locinfo->lconv_intl_refcount);
525 MSVCRT_free(locale->locinfo->lconv_num_refcount);
526 MSVCRT_free(locale->locinfo->lconv_mon_refcount);
527 MSVCRT_free(locale->locinfo->lconv);
528
529 MSVCRT_free(locale->locinfo->ctype1_refcount);
530 MSVCRT_free(locale->locinfo->ctype1);
531
532 MSVCRT_free(locale->locinfo->pclmap);
533 MSVCRT_free(locale->locinfo->pcumap);
534
535 MSVCRT_free(locale->locinfo);
536 MSVCRT_free(locale->mbcinfo);
537 MSVCRT_free(locale);
538 }
539
540 /* _create_locale - not exported in native msvcrt */
541 MSVCRT__locale_t _create_locale(int category, const char *locale)
542 {
543 MSVCRT__locale_t loc;
544 LCID lcid;
545 char buf[256];
546 int i;
547
548 TRACE("(%d %s)\n", category, locale);
549
550 if(category<MSVCRT_LC_MIN || category>MSVCRT_LC_MAX || !locale)
551 return NULL;
552
553 if(locale[0]=='C' && !locale[1])
554 lcid = CP_ACP;
555 else if(!locale[0])
556 lcid = GetSystemDefaultLCID();
557 else if (locale[0] == 'L' && locale[1] == 'C' && locale[2] == '_') {
558 FIXME(":restore previous locale not implemented!\n");
559 /* FIXME: Easiest way to do this is parse the string and
560 * call this function recursively with its elements,
561 * Where they differ for each lc_ type.
562 */
563 return NULL;
564 } else {
565 locale_search_t search;
566 char *cp, *region;
567
568 memset(&search, 0, sizeof(locale_search_t));
569
570 cp = strchr(locale, '.');
571 region = strchr(locale, '_');
572
573 lstrcpynA(search.search_language, locale, MAX_ELEM_LEN);
574 if(region) {
575 lstrcpynA(search.search_country, region+1, MAX_ELEM_LEN);
576 if(region-locale < MAX_ELEM_LEN)
577 search.search_language[region-locale] = '\0';
578 } else
579 search.search_country[0] = '\0';
580
581 if(cp) {
582 lstrcpynA(search.search_codepage, cp+1, MAX_ELEM_LEN);
583 if(cp-region < MAX_ELEM_LEN)
584 search.search_country[cp-region] = '\0';
585 if(cp-locale < MAX_ELEM_LEN)
586 search.search_language[cp-locale] = '\0';
587 } else
588 search.search_codepage[0] = '\0';
589
590 /* FIXME: MSVCRT_locale_to_LCID is not finding remaped values */
591 remap_synonym(search.search_country);
592
593 lcid = MSVCRT_locale_to_LCID(&search);
594 if(!lcid)
595 return NULL;
596 }
597
598 loc = MSVCRT_malloc(sizeof(MSVCRT__locale_tstruct));
599 if(!loc)
600 return NULL;
601
602 loc->locinfo = MSVCRT_malloc(sizeof(MSVCRT_threadlocinfo));
603 if(!loc->locinfo) {
604 MSVCRT_free(loc);
605 return NULL;
606 }
607
608 loc->mbcinfo = MSVCRT_malloc(sizeof(MSVCRT_threadmbcinfo));
609 if(!loc->mbcinfo) {
610 MSVCRT_free(loc->locinfo);
611 MSVCRT_free(loc);
612 return NULL;
613 }
614
615 memset(loc->locinfo, 0, sizeof(MSVCRT_threadlocinfo));
616 memset(loc->mbcinfo, 0, sizeof(MSVCRT_threadmbcinfo));
617
618 loc->locinfo->lconv = MSVCRT_malloc(sizeof(struct MSVCRT_lconv));
619 if(!loc->locinfo->lconv) {
620 _free_locale(loc);
621 return NULL;
622 }
623 memset(loc->locinfo->lconv, 0, sizeof(struct MSVCRT_lconv));
624
625 loc->locinfo->pclmap = MSVCRT_malloc(sizeof(char[256]));
626 loc->locinfo->pcumap = MSVCRT_malloc(sizeof(char[256]));
627 if(!loc->locinfo->pclmap || !loc->locinfo->pcumap) {
628 _free_locale(loc);
629 return NULL;
630 }
631
632 loc->locinfo->refcount = 1;
633
634 if(lcid && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_COLLATE)) {
635 if(update_threadlocinfo_category(lcid, loc, MSVCRT_LC_COLLATE)) {
636 _free_locale(loc);
637 return NULL;
638 }
639 } else
640 loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale = strdup("C");
641
642 if(lcid && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_CTYPE)) {
643 CPINFO cp;
644
645 if(update_threadlocinfo_category(lcid, loc, MSVCRT_LC_CTYPE)) {
646 _free_locale(loc);
647 return NULL;
648 }
649
650 loc->locinfo->lc_codepage = loc->locinfo->lc_id[MSVCRT_LC_CTYPE].wCodePage;
651 loc->locinfo->lc_collate_cp = loc->locinfo->lc_codepage;
652 loc->locinfo->lc_clike = 1;
653 if(!GetCPInfo(loc->locinfo->lc_codepage, &cp)) {
654 _free_locale(loc);
655 return NULL;
656 }
657 loc->locinfo->mb_cur_max = cp.MaxCharSize;
658
659 loc->locinfo->ctype1_refcount = MSVCRT_malloc(sizeof(int));
660 loc->locinfo->ctype1 = MSVCRT_malloc(sizeof(short[257]));
661 if(!loc->locinfo->ctype1_refcount || !loc->locinfo->ctype1) {
662 _free_locale(loc);
663 return NULL;
664 }
665
666 *loc->locinfo->ctype1_refcount = 1;
667 loc->locinfo->ctype1[0] = 0;
668 loc->locinfo->pctype = loc->locinfo->ctype1+1;
669
670 buf[1] = buf[2] = '\0';
671 for(i=1; i<257; i++) {
672 buf[0] = i-1;
673
674 GetStringTypeA(lcid, CT_CTYPE1, buf, 1, loc->locinfo->ctype1+i);
675 loc->locinfo->ctype1[i] |= 0x200;
676 }
677 } else {
678 loc->locinfo->lc_clike = 1;
679 loc->locinfo->mb_cur_max = 1;
680 loc->locinfo->pctype = MSVCRT__ctype+1;
681 loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale = strdup("C");
682 }
683
684 for(i=0; i<256; i++)
685 buf[i] = i;
686
687 LCMapStringA(lcid, LCMAP_LOWERCASE, buf, 256, (char*)loc->locinfo->pclmap, 256);
688 LCMapStringA(lcid, LCMAP_UPPERCASE, buf, 256, (char*)loc->locinfo->pcumap, 256);
689
690 loc->mbcinfo->refcount = 1;
691 loc->mbcinfo->mbcodepage = loc->locinfo->lc_id[MSVCRT_LC_CTYPE].wCodePage;
692
693 for(i=0; i<256; i++) {
694 if(loc->locinfo->pclmap[i] != i) {
695 loc->mbcinfo->mbctype[i+1] |= 0x10;
696 loc->mbcinfo->mbcasemap[i] = loc->locinfo->pclmap[i];
697 } else if(loc->locinfo->pcumap[i] != i) {
698 loc->mbcinfo->mbctype[i+1] |= 0x20;
699 loc->mbcinfo->mbcasemap[i] = loc->locinfo->pcumap[i];
700 }
701 }
702
703 if(lcid && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_MONETARY)) {
704 if(update_threadlocinfo_category(lcid, loc, MSVCRT_LC_MONETARY)) {
705 _free_locale(loc);
706 return NULL;
707 }
708
709 loc->locinfo->lconv_intl_refcount = MSVCRT_malloc(sizeof(int));
710 loc->locinfo->lconv_mon_refcount = MSVCRT_malloc(sizeof(int));
711 if(!loc->locinfo->lconv_intl_refcount || !loc->locinfo->lconv_mon_refcount) {
712 _free_locale(loc);
713 return NULL;
714 }
715
716 *loc->locinfo->lconv_intl_refcount = 1;
717 *loc->locinfo->lconv_mon_refcount = 1;
718
719 i = GetLocaleInfoA(lcid, LOCALE_SINTLSYMBOL, buf, 256);
720 if(i && (loc->locinfo->lconv->int_curr_symbol = MSVCRT_malloc(sizeof(char[i]))))
721 memcpy(loc->locinfo->lconv->int_curr_symbol, buf, sizeof(char[i]));
722 else {
723 _free_locale(loc);
724 return NULL;
725 }
726
727 i = GetLocaleInfoA(lcid, LOCALE_SCURRENCY, buf, 256);
728 if(i && (loc->locinfo->lconv->currency_symbol = MSVCRT_malloc(sizeof(char[i]))))
729 memcpy(loc->locinfo->lconv->currency_symbol, buf, sizeof(char[i]));
730 else {
731 _free_locale(loc);
732 return NULL;
733 }
734
735 i = GetLocaleInfoA(lcid, LOCALE_SMONDECIMALSEP, buf, 256);
736 if(i && (loc->locinfo->lconv->mon_decimal_point = MSVCRT_malloc(sizeof(char[i]))))
737 memcpy(loc->locinfo->lconv->mon_decimal_point, buf, sizeof(char[i]));
738 else {
739 _free_locale(loc);
740 return NULL;
741 }
742
743 i = GetLocaleInfoA(lcid, LOCALE_SMONTHOUSANDSEP, buf, 256);
744 if(i && (loc->locinfo->lconv->mon_thousands_sep = MSVCRT_malloc(sizeof(char[i]))))
745 memcpy(loc->locinfo->lconv->mon_thousands_sep, buf, sizeof(char[i]));
746 else {
747 _free_locale(loc);
748 return NULL;
749 }
750
751 i = GetLocaleInfoA(lcid, LOCALE_SMONGROUPING, buf, 256);
752 if(i>1)
753 i = i/2 + (buf[i-2]=='0'?0:1);
754 if(i && (loc->locinfo->lconv->mon_grouping = MSVCRT_malloc(sizeof(char[i])))) {
755 for(i=0; buf[i+1]==';'; i+=2)
756 loc->locinfo->lconv->mon_grouping[i/2] = buf[i]-'0';
757 loc->locinfo->lconv->mon_grouping[i/2] = buf[i]-'0';
758 if(buf[i] != '0')
759 loc->locinfo->lconv->mon_grouping[i/2+1] = 127;
760 } else {
761 _free_locale(loc);
762 return NULL;
763 }
764
765 i = GetLocaleInfoA(lcid, LOCALE_SPOSITIVESIGN, buf, 256);
766 if(i && (loc->locinfo->lconv->positive_sign = MSVCRT_malloc(sizeof(char[i]))))
767 memcpy(loc->locinfo->lconv->positive_sign, buf, sizeof(char[i]));
768 else {
769 _free_locale(loc);
770 return NULL;
771 }
772
773 i = GetLocaleInfoA(lcid, LOCALE_SNEGATIVESIGN, buf, 256);
774 if(i && (loc->locinfo->lconv->negative_sign = MSVCRT_malloc(sizeof(char[i]))))
775 memcpy(loc->locinfo->lconv->negative_sign, buf, sizeof(char[i]));
776 else {
777 _free_locale(loc);
778 return NULL;
779 }
780
781 if(GetLocaleInfoA(lcid, LOCALE_IINTLCURRDIGITS, buf, 256))
782 loc->locinfo->lconv->int_frac_digits = atoi(buf);
783 else {
784 _free_locale(loc);
785 return NULL;
786 }
787
788 if(GetLocaleInfoA(lcid, LOCALE_ICURRDIGITS, buf, 256))
789 loc->locinfo->lconv->frac_digits = atoi(buf);
790 else {
791 _free_locale(loc);
792 return NULL;
793 }
794
795 if(GetLocaleInfoA(lcid, LOCALE_IPOSSYMPRECEDES, buf, 256))
796 loc->locinfo->lconv->p_cs_precedes = atoi(buf);
797 else {
798 _free_locale(loc);
799 return NULL;
800 }
801
802 if(GetLocaleInfoA(lcid, LOCALE_IPOSSEPBYSPACE, buf, 256))
803 loc->locinfo->lconv->p_sep_by_space = atoi(buf);
804 else {
805 _free_locale(loc);
806 return NULL;
807 }
808
809 if(GetLocaleInfoA(lcid, LOCALE_INEGSYMPRECEDES, buf, 256))
810 loc->locinfo->lconv->n_cs_precedes = atoi(buf);
811 else {
812 _free_locale(loc);
813 return NULL;
814 }
815
816 if(GetLocaleInfoA(lcid, LOCALE_INEGSEPBYSPACE, buf, 256))
817 loc->locinfo->lconv->n_sep_by_space = atoi(buf);
818 else {
819 _free_locale(loc);
820 return NULL;
821 }
822
823 if(GetLocaleInfoA(lcid, LOCALE_IPOSSIGNPOSN, buf, 256))
824 loc->locinfo->lconv->p_sign_posn = atoi(buf);
825 else {
826 _free_locale(loc);
827 return NULL;
828 }
829
830 if(GetLocaleInfoA(lcid, LOCALE_INEGSIGNPOSN, buf, 256))
831 loc->locinfo->lconv->n_sign_posn = atoi(buf);
832 else {
833 _free_locale(loc);
834 return NULL;
835 }
836 } else {
837 loc->locinfo->lconv->int_curr_symbol = MSVCRT_malloc(sizeof(char));
838 loc->locinfo->lconv->currency_symbol = MSVCRT_malloc(sizeof(char));
839 loc->locinfo->lconv->mon_decimal_point = MSVCRT_malloc(sizeof(char));
840 loc->locinfo->lconv->mon_thousands_sep = MSVCRT_malloc(sizeof(char));
841 loc->locinfo->lconv->mon_grouping = MSVCRT_malloc(sizeof(char));
842 loc->locinfo->lconv->positive_sign = MSVCRT_malloc(sizeof(char));
843 loc->locinfo->lconv->negative_sign = MSVCRT_malloc(sizeof(char));
844
845 if(!loc->locinfo->lconv->int_curr_symbol || !loc->locinfo->lconv->currency_symbol
846 || !loc->locinfo->lconv->mon_decimal_point || !loc->locinfo->lconv->mon_thousands_sep
847 || !loc->locinfo->lconv->mon_grouping || !loc->locinfo->lconv->positive_sign
848 || !loc->locinfo->lconv->negative_sign) {
849 _free_locale(loc);
850 return NULL;
851 }
852
853 loc->locinfo->lconv->int_curr_symbol[0] = '\0';
854 loc->locinfo->lconv->currency_symbol[0] = '\0';
855 loc->locinfo->lconv->mon_decimal_point[0] = '\0';
856 loc->locinfo->lconv->mon_thousands_sep[0] = '\0';
857 loc->locinfo->lconv->mon_grouping[0] = '\0';
858 loc->locinfo->lconv->positive_sign[0] = '\0';
859 loc->locinfo->lconv->negative_sign[0] = '\0';
860 loc->locinfo->lconv->int_frac_digits = 127;
861 loc->locinfo->lconv->frac_digits = 127;
862 loc->locinfo->lconv->p_cs_precedes = 127;
863 loc->locinfo->lconv->p_sep_by_space = 127;
864 loc->locinfo->lconv->n_cs_precedes = 127;
865 loc->locinfo->lconv->n_sep_by_space = 127;
866 loc->locinfo->lconv->p_sign_posn = 127;
867 loc->locinfo->lconv->n_sign_posn = 127;
868
869 loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale = strdup("C");
870 }
871
872 if(lcid && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_NUMERIC)) {
873 if(update_threadlocinfo_category(lcid, loc, MSVCRT_LC_NUMERIC)) {
874 _free_locale(loc);
875 return NULL;
876 }
877
878 if(!loc->locinfo->lconv_intl_refcount)
879 loc->locinfo->lconv_intl_refcount = MSVCRT_malloc(sizeof(int));
880 loc->locinfo->lconv_num_refcount = MSVCRT_malloc(sizeof(int));
881 if(!loc->locinfo->lconv_intl_refcount || !loc->locinfo->lconv_num_refcount) {
882 _free_locale(loc);
883 return NULL;
884 }
885
886 *loc->locinfo->lconv_intl_refcount = 1;
887 *loc->locinfo->lconv_num_refcount = 1;
888
889 i = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, buf, 256);
890 if(i && (loc->locinfo->lconv->decimal_point = MSVCRT_malloc(sizeof(char[i]))))
891 memcpy(loc->locinfo->lconv->decimal_point, buf, sizeof(char[i]));
892 else {
893 _free_locale(loc);
894 return NULL;
895 }
896
897 i = GetLocaleInfoA(lcid, LOCALE_STHOUSAND, buf, 256);
898 if(i && (loc->locinfo->lconv->thousands_sep = MSVCRT_malloc(sizeof(char[i]))))
899 memcpy(loc->locinfo->lconv->thousands_sep, buf, sizeof(char[i]));
900 else {
901 _free_locale(loc);
902 return NULL;
903 }
904
905 i = GetLocaleInfoA(lcid, LOCALE_SGROUPING, buf, 256);
906 if(i>1)
907 i = i/2 + (buf[i-2]=='0'?0:1);
908 if(i && (loc->locinfo->lconv->grouping = MSVCRT_malloc(sizeof(char[i])))) {
909 for(i=0; buf[i+1]==';'; i+=2)
910 loc->locinfo->lconv->grouping[i/2] = buf[i]-'0';
911 loc->locinfo->lconv->grouping[i/2] = buf[i]-'0';
912 if(buf[i] != '0')
913 loc->locinfo->lconv->grouping[i/2+1] = 127;
914 } else {
915 _free_locale(loc);
916 return NULL;
917 }
918 } else {
919 loc->locinfo->lconv->decimal_point = MSVCRT_malloc(sizeof(char[2]));
920 loc->locinfo->lconv->thousands_sep = MSVCRT_malloc(sizeof(char));
921 loc->locinfo->lconv->grouping = MSVCRT_malloc(sizeof(char));
922 if(!loc->locinfo->lconv->decimal_point || !loc->locinfo->lconv->thousands_sep
923 || !loc->locinfo->lconv->grouping) {
924 _free_locale(loc);
925 return NULL;
926 }
927
928 loc->locinfo->lconv->decimal_point[0] = '.';
929 loc->locinfo->lconv->decimal_point[1] = '\0';
930 loc->locinfo->lconv->thousands_sep[0] = '\0';
931 loc->locinfo->lconv->grouping[0] = '\0';
932
933 loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale = strdup("C");
934 }
935
936 if(lcid && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_TIME)) {
937 if(update_threadlocinfo_category(lcid, loc, MSVCRT_LC_TIME)) {
938 _free_locale(loc);
939 return NULL;
940 }
941 } else
942 loc->locinfo->lc_category[MSVCRT_LC_TIME].locale = strdup("C");
943
944 return loc;
945 }
946
947 /*********************************************************************
948 * setlocale (MSVCRT.@)
949 */
950 char* CDECL MSVCRT_setlocale(int category, const char* locale)
951 {
952 static char current_lc_all[MAX_LOCALE_LENGTH];
953
954 MSVCRT__locale_t loc;
955
956 if(locale == NULL) {
957 if(category == MSVCRT_LC_ALL) {
958 sprintf(current_lc_all,
959 "LC_COLLATE=%s;LC_CTYPE=%s;LC_MONETARY=%s;LC_NUMERIC=%s;LC_TIME=%s",
960 MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_COLLATE].locale,
961 MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_CTYPE].locale,
962 MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_MONETARY].locale,
963 MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale,
964 MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_TIME].locale);
965
966 return current_lc_all;
967 }
968
969 return MSVCRT_locale->locinfo->lc_category[category].locale;
970 }
971
972 loc = _create_locale(category, locale);
973 if(!loc)
974 return NULL;
975
976 LOCK_LOCALE;
977
978 switch(category) {
979 case MSVCRT_LC_ALL:
980 if(!MSVCRT_locale)
981 break;
982 case MSVCRT_LC_COLLATE:
983 MSVCRT_locale->locinfo->lc_handle[MSVCRT_LC_COLLATE] =
984 loc->locinfo->lc_handle[MSVCRT_LC_COLLATE];
985 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_COLLATE].locale,
986 (void**)&loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale);
987 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_COLLATE].refcount,
988 (void**)&loc->locinfo->lc_category[MSVCRT_LC_COLLATE].refcount);
989
990 if(category != MSVCRT_LC_ALL)
991 break;
992 case MSVCRT_LC_CTYPE:
993 MSVCRT_locale->locinfo->lc_handle[MSVCRT_LC_CTYPE] =
994 loc->locinfo->lc_handle[MSVCRT_LC_CTYPE];
995 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_CTYPE].locale,
996 (void**)&loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale);
997 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_CTYPE].refcount,
998 (void**)&loc->locinfo->lc_category[MSVCRT_LC_CTYPE].refcount);
999
1000 MSVCRT_locale->locinfo->lc_codepage = loc->locinfo->lc_codepage;
1001 MSVCRT_locale->locinfo->lc_collate_cp = loc->locinfo->lc_collate_cp;
1002 MSVCRT_locale->locinfo->lc_clike = loc->locinfo->lc_clike;
1003 MSVCRT_locale->locinfo->mb_cur_max = loc->locinfo->mb_cur_max;
1004
1005 swap_pointers((void**)&MSVCRT_locale->locinfo->ctype1_refcount,
1006 (void**)&loc->locinfo->ctype1_refcount);
1007 swap_pointers((void**)&MSVCRT_locale->locinfo->ctype1, (void**)&loc->locinfo->ctype1);
1008 swap_pointers((void**)&MSVCRT_locale->locinfo->pctype, (void**)&loc->locinfo->pctype);
1009 swap_pointers((void**)&MSVCRT_locale->locinfo->pclmap, (void**)&loc->locinfo->pclmap);
1010 swap_pointers((void**)&MSVCRT_locale->locinfo->pcumap, (void**)&loc->locinfo->pcumap);
1011
1012 memcpy(MSVCRT_locale->mbcinfo, loc->mbcinfo, sizeof(MSVCRT_threadmbcinfo));
1013
1014 if(category != MSVCRT_LC_ALL)
1015 break;
1016 case MSVCRT_LC_MONETARY:
1017 MSVCRT_locale->locinfo->lc_handle[MSVCRT_LC_MONETARY] =
1018 loc->locinfo->lc_handle[MSVCRT_LC_MONETARY];
1019 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_MONETARY].locale,
1020 (void**)&loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale);
1021 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_MONETARY].refcount,
1022 (void**)&loc->locinfo->lc_category[MSVCRT_LC_MONETARY].refcount);
1023
1024 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->int_curr_symbol,
1025 (void**)&loc->locinfo->lconv->int_curr_symbol);
1026 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->currency_symbol,
1027 (void**)&loc->locinfo->lconv->currency_symbol);
1028 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->mon_decimal_point,
1029 (void**)&loc->locinfo->lconv->mon_decimal_point);
1030 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->mon_thousands_sep,
1031 (void**)&loc->locinfo->lconv->mon_thousands_sep);
1032 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->mon_grouping,
1033 (void**)&loc->locinfo->lconv->mon_grouping);
1034 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->positive_sign,
1035 (void**)&loc->locinfo->lconv->positive_sign);
1036 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->negative_sign,
1037 (void**)&loc->locinfo->lconv->negative_sign);
1038 MSVCRT_locale->locinfo->lconv->int_frac_digits = loc->locinfo->lconv->int_frac_digits;
1039 MSVCRT_locale->locinfo->lconv->frac_digits = loc->locinfo->lconv->frac_digits;
1040 MSVCRT_locale->locinfo->lconv->p_cs_precedes = loc->locinfo->lconv->p_cs_precedes;
1041 MSVCRT_locale->locinfo->lconv->p_sep_by_space = loc->locinfo->lconv->p_sep_by_space;
1042 MSVCRT_locale->locinfo->lconv->n_cs_precedes = loc->locinfo->lconv->n_cs_precedes;
1043 MSVCRT_locale->locinfo->lconv->n_sep_by_space = loc->locinfo->lconv->n_sep_by_space;
1044 MSVCRT_locale->locinfo->lconv->p_sign_posn = loc->locinfo->lconv->p_sign_posn;
1045 MSVCRT_locale->locinfo->lconv->n_sign_posn = loc->locinfo->lconv->n_sign_posn;
1046
1047 if(category != MSVCRT_LC_ALL)
1048 break;
1049 case MSVCRT_LC_NUMERIC:
1050 MSVCRT_locale->locinfo->lc_handle[MSVCRT_LC_NUMERIC] =
1051 loc->locinfo->lc_handle[MSVCRT_LC_NUMERIC];
1052 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale,
1053 (void**)&loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale);
1054 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_NUMERIC].refcount,
1055 (void**)&loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].refcount);
1056
1057 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->decimal_point,
1058 (void**)&loc->locinfo->lconv->decimal_point);
1059 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->thousands_sep,
1060 (void**)&loc->locinfo->lconv->thousands_sep);
1061 swap_pointers((void**)&MSVCRT_locale->locinfo->lconv->grouping,
1062 (void**)&loc->locinfo->lconv->grouping);
1063
1064 if(category != MSVCRT_LC_ALL)
1065 break;
1066 case MSVCRT_LC_TIME:
1067 MSVCRT_locale->locinfo->lc_handle[MSVCRT_LC_TIME] =
1068 loc->locinfo->lc_handle[MSVCRT_LC_TIME];
1069 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_TIME].locale,
1070 (void**)&loc->locinfo->lc_category[MSVCRT_LC_TIME].locale);
1071 swap_pointers((void**)&MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_TIME].refcount,
1072 (void**)&loc->locinfo->lc_category[MSVCRT_LC_TIME].refcount);
1073
1074 if(category != MSVCRT_LC_ALL)
1075 break;
1076 }
1077
1078 if(!MSVCRT_locale)
1079 MSVCRT_locale = loc;
1080 else
1081 _free_locale(loc);
1082
1083 UNLOCK_LOCALE;
1084
1085 MSVCRT___lc_codepage = MSVCRT_locale->locinfo->lc_codepage;
1086 MSVCRT___lc_collate_cp = MSVCRT_locale->locinfo->lc_collate_cp;
1087 MSVCRT___mb_cur_max = MSVCRT_locale->locinfo->mb_cur_max;
1088 MSVCRT__pctype = MSVCRT_locale->locinfo->pctype;
1089
1090 if(category == MSVCRT_LC_ALL)
1091 return MSVCRT_locale->locinfo->lc_category[MSVCRT_LC_COLLATE].locale;
1092
1093 return MSVCRT_locale->locinfo->lc_category[category].locale;
1094 }
Quick hack tree for wine patches julliard doesn't want to commit