?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Fix lc_collate_cp initialization.
[wine.git] / dlls / msvcrt / locale.c
blob68936858281fdb16ee711ee460a910dd933313e2
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 #define MAX_ELEM_LEN 64 /* Max length of country/language/CP string */
42 #define MAX_LOCALE_LENGTH 256
43 MSVCRT__locale_t MSVCRT_locale = NULL;
44 unsigned short *MSVCRT__pctype = NULL;
45 int MSVCRT___lc_codepage = 0;
46 int MSVCRT___lc_collate_cp = 0;
47 LCID MSVCRT___lc_handle[MSVCRT_LC_MAX - MSVCRT_LC_MIN + 1] = { 0 };
48 int MSVCRT___mb_cur_max = 1;
49 static unsigned char charmax = CHAR_MAX;
50
51 /* MT */
52 #define LOCK_LOCALE _mlock(_SETLOCALE_LOCK);
53 #define UNLOCK_LOCALE _munlock(_SETLOCALE_LOCK);
54
55 #define MSVCRT_LEADBYTE 0x8000
56 #define MSVCRT_C1_DEFINED 0x200
57
58 /* Friendly country strings & language names abbreviations. */
59 static const char * const _country_synonyms[] =
60 {
61 "american", "enu",
62 "american english", "enu",
63 "american-english", "enu",
64 "english-american", "enu",
65 "english-us", "enu",
66 "english-usa", "enu",
67 "us", "enu",
68 "usa", "enu",
69 "australian", "ena",
70 "english-aus", "ena",
71 "belgian", "nlb",
72 "french-belgian", "frb",
73 "canadian", "enc",
74 "english-can", "enc",
75 "french-canadian", "frc",
76 "chinese", "chs",
77 "chinese-simplified", "chs",
78 "chinese-traditional", "cht",
79 "dutch-belgian", "nlb",
80 "english-nz", "enz",
81 "uk", "eng",
82 "english-uk", "eng",
83 "french-swiss", "frs",
84 "swiss", "des",
85 "german-swiss", "des",
86 "italian-swiss", "its",
87 "german-austrian", "dea",
88 "portugese", "ptb",
89 "portuguese-brazil", "ptb",
90 "spanish-mexican", "esm",
91 "norwegian-bokmal", "nor",
92 "norwegian-nynorsk", "non",
93 "spanish-modern", "esn"
94 };
95
96 /* INTERNAL: Map a synonym to an ISO code */
97 static void remap_synonym(char *name)
98 {
99 unsigned int i;
100 for (i = 0; i < sizeof(_country_synonyms)/sizeof(char*); i += 2 )
101 {
102 if (!strcasecmp(_country_synonyms[i],name))
103 {
104 TRACE(":Mapping synonym %s to %s\n",name,_country_synonyms[i+1]);
105 strcpy(name, _country_synonyms[i+1]);
106 return;
107 }
108 }
109 }
110
111 /* Note: Flags are weighted in order of matching importance */
112 #define FOUND_LANGUAGE 0x4
113 #define FOUND_COUNTRY 0x2
114 #define FOUND_CODEPAGE 0x1
115
116 typedef struct {
117 char search_language[MAX_ELEM_LEN];
118 char search_country[MAX_ELEM_LEN];
119 char search_codepage[MAX_ELEM_LEN];
120 char found_codepage[MAX_ELEM_LEN];
121 unsigned int match_flags;
122 LANGID found_lang_id;
123 } locale_search_t;
124
125 #define CONTINUE_LOOKING TRUE
126 #define STOP_LOOKING FALSE
127
128 /* INTERNAL: Get and compare locale info with a given string */
129 static int compare_info(LCID lcid, DWORD flags, char* buff, const char* cmp, BOOL exact)
130 {
131 int len;
132
133 buff[0] = 0;
134 GetLocaleInfoA(lcid, flags|LOCALE_NOUSEROVERRIDE, buff, MAX_ELEM_LEN);
135 if (!buff[0] || !cmp[0])
136 return 0;
137
138 /* Partial matches are only allowed on language/country names */
139 len = strlen(cmp);
140 if(exact || len<=3)
141 return !strcasecmp(cmp, buff);
142 else
143 return !strncasecmp(cmp, buff, len);
144 }
145
146 static BOOL CALLBACK
147 find_best_locale_proc(HMODULE hModule, LPCSTR type, LPCSTR name, WORD LangID, LONG_PTR lParam)
148 {
149 locale_search_t *res = (locale_search_t *)lParam;
150 const LCID lcid = MAKELCID(LangID, SORT_DEFAULT);
151 char buff[MAX_ELEM_LEN];
152 unsigned int flags = 0;
153
154 if(PRIMARYLANGID(LangID) == LANG_NEUTRAL)
155 return CONTINUE_LOOKING;
156
157 /* Check Language */
158 if (compare_info(lcid,LOCALE_SISO639LANGNAME,buff,res->search_language, TRUE) ||
159 compare_info(lcid,LOCALE_SABBREVLANGNAME,buff,res->search_language, TRUE) ||
160 compare_info(lcid,LOCALE_SENGLANGUAGE,buff,res->search_language, FALSE))
161 {
162 TRACE(":Found language: %s->%s\n", res->search_language, buff);
163 flags |= FOUND_LANGUAGE;
164 }
165 else if (res->match_flags & FOUND_LANGUAGE)
166 {
167 return CONTINUE_LOOKING;
168 }
169
170 /* Check Country */
171 if (compare_info(lcid,LOCALE_SISO3166CTRYNAME,buff,res->search_country, TRUE) ||
172 compare_info(lcid,LOCALE_SABBREVCTRYNAME,buff,res->search_country, TRUE) ||
173 compare_info(lcid,LOCALE_SENGCOUNTRY,buff,res->search_country, FALSE))
174 {
175 TRACE("Found country:%s->%s\n", res->search_country, buff);
176 flags |= FOUND_COUNTRY;
177 }
178 else if (res->match_flags & FOUND_COUNTRY)
179 {
180 return CONTINUE_LOOKING;
181 }
182
183 /* Check codepage */
184 if (compare_info(lcid,LOCALE_IDEFAULTCODEPAGE,buff,res->search_codepage, TRUE) ||
185 (compare_info(lcid,LOCALE_IDEFAULTANSICODEPAGE,buff,res->search_codepage, TRUE)))
186 {
187 TRACE("Found codepage:%s->%s\n", res->search_codepage, buff);
188 flags |= FOUND_CODEPAGE;
189 memcpy(res->found_codepage,res->search_codepage,MAX_ELEM_LEN);
190 }
191 else if (res->match_flags & FOUND_CODEPAGE)
192 {
193 return CONTINUE_LOOKING;
194 }
195
196 if (flags > res->match_flags)
197 {
198 /* Found a better match than previously */
199 res->match_flags = flags;
200 res->found_lang_id = LangID;
201 }
202 if ((flags & (FOUND_LANGUAGE | FOUND_COUNTRY | FOUND_CODEPAGE)) ==
203 (FOUND_LANGUAGE | FOUND_COUNTRY | FOUND_CODEPAGE))
204 {
205 TRACE(":found exact locale match\n");
206 return STOP_LOOKING;
207 }
208 return CONTINUE_LOOKING;
209 }
210
211 extern int atoi(const char *);
212
213 /* Internal: Find the LCID for a locale specification */
214 LCID MSVCRT_locale_to_LCID(const char *locale)
215 {
216 LCID lcid;
217 locale_search_t search;
218 const char *cp, *region;
219
220 memset(&search, 0, sizeof(locale_search_t));
221
222 cp = strchr(locale, '.');
223 region = strchr(locale, '_');
224
225 lstrcpynA(search.search_language, locale, MAX_ELEM_LEN);
226 if(region) {
227 lstrcpynA(search.search_country, region+1, MAX_ELEM_LEN);
228 if(region-locale < MAX_ELEM_LEN)
229 search.search_language[region-locale] = '\0';
230 } else
231 search.search_country[0] = '\0';
232
233 if(cp) {
234 lstrcpynA(search.search_codepage, cp+1, MAX_ELEM_LEN);
235 if(region && cp-region-1<MAX_ELEM_LEN)
236 search.search_country[cp-region-1] = '\0';
237 if(cp-locale < MAX_ELEM_LEN)
238 search.search_language[cp-locale] = '\0';
239 } else
240 search.search_codepage[0] = '\0';
241
242 if(!search.search_country[0] && !search.search_codepage[0])
243 remap_synonym(search.search_language);
244
245 EnumResourceLanguagesA(GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
246 (LPCSTR)LOCALE_ILANGUAGE,find_best_locale_proc,
247 (LONG_PTR)&search);
248
249 if (!search.match_flags)
250 return -1;
251
252 /* If we were given something that didn't match, fail */
253 if (search.search_country[0] && !(search.match_flags & FOUND_COUNTRY))
254 return -1;
255
256 lcid = MAKELCID(search.found_lang_id, SORT_DEFAULT);
257
258 /* Populate partial locale, translating LCID to locale string elements */
259 if (!search.found_codepage[0]) {
260 /* Even if a codepage is not enumerated for a locale
261 * it can be set if valid */
262 if (search.search_codepage[0]) {
263 if (IsValidCodePage(atoi(search.search_codepage)))
264 memcpy(search.found_codepage,search.search_codepage,MAX_ELEM_LEN);
265 else {
266 /* Special codepage values: OEM & ANSI */
267 if (strcasecmp(search.search_codepage,"OCP")) {
268 GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
269 search.found_codepage, MAX_ELEM_LEN);
270 } else if (strcasecmp(search.search_codepage,"ACP")) {
271 GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
272 search.found_codepage, MAX_ELEM_LEN);
273 } else
274 return -1;
275
276 if (!atoi(search.found_codepage))
277 return -1;
278 }
279 } else {
280 /* Prefer ANSI codepages if present */
281 GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
282 search.found_codepage, MAX_ELEM_LEN);
283 if (!search.found_codepage[0] || !atoi(search.found_codepage))
284 GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
285 search.found_codepage, MAX_ELEM_LEN);
286 }
287 }
288
289 return lcid;
290 }
291
292 /* INTERNAL: Set lc_handle, lc_id and lc_category in threadlocinfo struct */
293 static BOOL update_threadlocinfo_category(LCID lcid, MSVCRT__locale_t loc, int category)
294 {
295 char buf[256], *p;
296 int len;
297
298 if(GetLocaleInfoA(lcid, LOCALE_ILANGUAGE|LOCALE_NOUSEROVERRIDE, buf, 256)) {
299 p = buf;
300
301 loc->locinfo->lc_id[category].wLanguage = 0;
302 while(*p) {
303 loc->locinfo->lc_id[category].wLanguage *= 16;
304
305 if(*p <= '9')
306 loc->locinfo->lc_id[category].wLanguage += *p-'0';
307 else
308 loc->locinfo->lc_id[category].wLanguage += *p-'a'+10;
309
310 p++;
311 }
312
313 loc->locinfo->lc_id[category].wCountry =
314 loc->locinfo->lc_id[category].wLanguage;
315 }
316
317 if(GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE
318 |LOCALE_NOUSEROVERRIDE, buf, 256))
319 loc->locinfo->lc_id[category].wCodePage = atoi(buf);
320
321 loc->locinfo->lc_handle[category] = lcid;
322
323 len = 0;
324 len += GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE
325 |LOCALE_NOUSEROVERRIDE, buf, 256);
326 buf[len-1] = '_';
327 len += GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY
328 |LOCALE_NOUSEROVERRIDE, &buf[len], 256-len);
329 buf[len-1] = '.';
330 len += GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE
331 |LOCALE_NOUSEROVERRIDE, &buf[len], 256-len);
332
333 loc->locinfo->lc_category[category].locale = MSVCRT_malloc(len);
334 loc->locinfo->lc_category[category].refcount = MSVCRT_malloc(sizeof(int));
335 if(!loc->locinfo->lc_category[category].locale
336 || !loc->locinfo->lc_category[category].refcount) {
337 MSVCRT_free(loc->locinfo->lc_category[category].locale);
338 MSVCRT_free(loc->locinfo->lc_category[category].refcount);
339 loc->locinfo->lc_category[category].locale = NULL;
340 loc->locinfo->lc_category[category].refcount = NULL;
341 return TRUE;
342 }
343 memcpy(loc->locinfo->lc_category[category].locale, buf, len);
344 *loc->locinfo->lc_category[category].refcount = 1;
345
346 return FALSE;
347 }
348
349 /* INTERNAL: swap pointers values */
350 static inline void swap_pointers(void **p1, void **p2) {
351 void *hlp;
352
353 hlp = *p1;
354 *p1 = *p2;
355 *p2 = hlp;
356 }
357
358 /* INTERNAL: returns pthreadlocinfo struct */
359 MSVCRT_pthreadlocinfo get_locinfo(void) {
360 thread_data_t *data = msvcrt_get_thread_data();
361
362 if(!data || !data->have_locale)
363 return MSVCRT_locale->locinfo;
364
365 return data->locinfo;
366 }
367
368 /* INTERNAL: returns pthreadlocinfo struct */
369 MSVCRT_pthreadmbcinfo get_mbcinfo(void) {
370 thread_data_t *data = msvcrt_get_thread_data();
371
372 if(!data || !data->have_locale)
373 return MSVCRT_locale->mbcinfo;
374
375 return data->mbcinfo;
376 }
377
378 /* INTERNAL: constructs string returned by setlocale */
379 static inline char* construct_lc_all(MSVCRT_pthreadlocinfo locinfo) {
380 static char current_lc_all[MAX_LOCALE_LENGTH];
381
382 int i;
383
384 for(i=MSVCRT_LC_MIN+1; i<MSVCRT_LC_MAX; i++) {
385 if(strcmp(locinfo->lc_category[i].locale,
386 locinfo->lc_category[i+1].locale))
387 break;
388 }
389
390 if(i==MSVCRT_LC_MAX)
391 return locinfo->lc_category[MSVCRT_LC_COLLATE].locale;
392
393 sprintf(current_lc_all,
394 "LC_COLLATE=%s;LC_CTYPE=%s;LC_MONETARY=%s;LC_NUMERIC=%s;LC_TIME=%s",
395 locinfo->lc_category[MSVCRT_LC_COLLATE].locale,
396 locinfo->lc_category[MSVCRT_LC_CTYPE].locale,
397 locinfo->lc_category[MSVCRT_LC_MONETARY].locale,
398 locinfo->lc_category[MSVCRT_LC_NUMERIC].locale,
399 locinfo->lc_category[MSVCRT_LC_TIME].locale);
400
401 return current_lc_all;
402 }
403
404
405 /*********************************************************************
406 * wsetlocale (MSVCRT.@)
407 */
408 MSVCRT_wchar_t* CDECL MSVCRT__wsetlocale(int category, const MSVCRT_wchar_t* locale)
409 {
410 static MSVCRT_wchar_t fake[] = {
411 'E','n','g','l','i','s','h','_','U','n','i','t','e','d',' ',
412 'S','t','a','t','e','s','.','1','2','5','2',0 };
413
414 FIXME("%d %s\n", category, debugstr_w(locale));
415
416 return fake;
417 }
418
419 /*********************************************************************
420 * _Getdays (MSVCRT.@)
421 */
422 const char* CDECL _Getdays(void)
423 {
424 static const char MSVCRT_days[] = ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:"
425 "Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
426 /* FIXME: Use locale */
427 TRACE("(void) semi-stub\n");
428 return MSVCRT_days;
429 }
430
431 /*********************************************************************
432 * _Getmonths (MSVCRT.@)
433 */
434 const char* CDECL _Getmonths(void)
435 {
436 static const char MSVCRT_months[] = ":Jan:January:Feb:February:Mar:March:Apr:"
437 "April:May:May:Jun:June:Jul:July:Aug:August:Sep:September:Oct:"
438 "October:Nov:November:Dec:December";
439 /* FIXME: Use locale */
440 TRACE("(void) semi-stub\n");
441 return MSVCRT_months;
442 }
443
444 /*********************************************************************
445 * _Gettnames (MSVCRT.@)
446 */
447 const char* CDECL _Gettnames(void)
448 {
449 /* FIXME: */
450 TRACE("(void) stub\n");
451 return "";
452 }
453
454 /*********************************************************************
455 * _Strftime (MSVCRT.@)
456 */
457 const char* CDECL _Strftime(char *out, unsigned int len, const char *fmt,
458 const void *tm, void *foo)
459 {
460 /* FIXME: */
461 TRACE("(%p %d %s %p %p) stub\n", out, len, fmt, tm, foo);
462 return "";
463 }
464
465 /*********************************************************************
466 * __crtLCMapStringA (MSVCRT.@)
467 */
468 int CDECL __crtLCMapStringA(
469 LCID lcid, DWORD mapflags, const char* src, int srclen, char* dst,
470 int dstlen, unsigned int codepage, int xflag
471 ) {
472 FIXME("(lcid %x, flags %x, %s(%d), %p(%d), %x, %d), partial stub!\n",
473 lcid,mapflags,src,srclen,dst,dstlen,codepage,xflag);
474 /* FIXME: A bit incorrect. But msvcrt itself just converts its
475 * arguments to wide strings and then calls LCMapStringW
476 */
477 return LCMapStringA(lcid,mapflags,src,srclen,dst,dstlen);
478 }
479
480 /*********************************************************************
481 * __crtLCMapStringW (MSVCRT.@)
482 */
483 int CDECL __crtLCMapStringW(LCID lcid, DWORD mapflags, const MSVCRT_wchar_t *src,
484 int srclen, MSVCRT_wchar_t *dst, int dstlen, unsigned int codepage, int xflag)
485 {
486 FIXME("(lcid %x, flags %x, %s(%d), %p(%d), %x, %d), partial stub!\n",
487 lcid, mapflags, debugstr_w(src), srclen, dst, dstlen, codepage, xflag);
488
489 return LCMapStringW(lcid, mapflags, src, srclen, dst, dstlen);
490 }
491
492 /*********************************************************************
493 * __crtCompareStringA (MSVCRT.@)
494 */
495 int CDECL __crtCompareStringA( LCID lcid, DWORD flags, const char *src1, int len1,
496 const char *src2, int len2 )
497 {
498 FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
499 lcid, flags, debugstr_a(src1), len1, debugstr_a(src2), len2 );
500 /* FIXME: probably not entirely right */
501 return CompareStringA( lcid, flags, src1, len1, src2, len2 );
502 }
503
504 /*********************************************************************
505 * __crtCompareStringW (MSVCRT.@)
506 */
507 int CDECL __crtCompareStringW( LCID lcid, DWORD flags, const MSVCRT_wchar_t *src1, int len1,
508 const MSVCRT_wchar_t *src2, int len2 )
509 {
510 FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
511 lcid, flags, debugstr_w(src1), len1, debugstr_w(src2), len2 );
512 /* FIXME: probably not entirely right */
513 return CompareStringW( lcid, flags, src1, len1, src2, len2 );
514 }
515
516 /*********************************************************************
517 * __crtGetLocaleInfoW (MSVCRT.@)
518 */
519 int CDECL __crtGetLocaleInfoW( LCID lcid, LCTYPE type, MSVCRT_wchar_t *buffer, int len )
520 {
521 FIXME("(lcid %x, type %x, %p(%d), partial stub\n", lcid, type, buffer, len );
522 /* FIXME: probably not entirely right */
523 return GetLocaleInfoW( lcid, type, buffer, len );
524 }
525
526 /*********************************************************************
527 * btowc(MSVCRT.@)
528 */
529 MSVCRT_wint_t CDECL MSVCRT_btowc(int c)
530 {
531 unsigned char letter = c;
532 MSVCRT_wchar_t ret;
533
534 if(!MultiByteToWideChar(get_locinfo()->lc_handle[MSVCRT_LC_CTYPE],
535 0, (LPCSTR)&letter, 1, &ret, 1))
536 return 0;
537
538 return ret;
539 }
540
541 /*********************************************************************
542 * __crtGetStringTypeW(MSVCRT.@)
543 *
544 * This function was accepting different number of arguments in older
545 * versions of msvcrt.
546 */
547 BOOL CDECL __crtGetStringTypeW(DWORD unk, DWORD type,
548 MSVCRT_wchar_t *buffer, int len, WORD *out)
549 {
550 FIXME("(unk %x, type %x, wstr %p(%d), %p) partial stub\n",
551 unk, type, buffer, len, out);
552
553 return GetStringTypeW(type, buffer, len, out);
554 }
555
556 /*********************************************************************
557 * localeconv (MSVCRT.@)
558 */
559 struct MSVCRT_lconv * CDECL MSVCRT_localeconv(void)
560 {
561 return get_locinfo()->lconv;
562 }
563
564 /*********************************************************************
565 * __lconv_init (MSVCRT.@)
566 */
567 int CDECL __lconv_init(void)
568 {
569 /* this is used to make chars unsigned */
570 charmax = 255;
571 return 0;
572 }
573
574 /*********************************************************************
575 * ___lc_handle_func (MSVCRT.@)
576 */
577 LCID* CDECL ___lc_handle_func(void)
578 {
579 return MSVCRT___lc_handle;
580 }
581
582 /*********************************************************************
583 * ___lc_codepage_func (MSVCRT.@)
584 */
585 int CDECL ___lc_codepage_func(void)
586 {
587 return MSVCRT___lc_codepage;
588 }
589
590 /*********************************************************************
591 * ___lc_collate_cp_func (MSVCRT.@)
592 */
593 int CDECL ___lc_collate_cp_func(void)
594 {
595 return get_locinfo()->lc_collate_cp;
596 }
597
598 /* INTERNAL: frees MSVCRT_pthreadlocinfo struct */
599 void free_locinfo(MSVCRT_pthreadlocinfo locinfo)
600 {
601 int i;
602
603 if(!locinfo)
604 return;
605
606 if(InterlockedDecrement(&locinfo->refcount))
607 return;
608
609 for(i=MSVCRT_LC_MIN+1; i<=MSVCRT_LC_MAX; i++) {
610 MSVCRT_free(locinfo->lc_category[i].locale);
611 MSVCRT_free(locinfo->lc_category[i].refcount);
612 }
613
614 if(locinfo->lconv) {
615 MSVCRT_free(locinfo->lconv->decimal_point);
616 MSVCRT_free(locinfo->lconv->thousands_sep);
617 MSVCRT_free(locinfo->lconv->grouping);
618 MSVCRT_free(locinfo->lconv->int_curr_symbol);
619 MSVCRT_free(locinfo->lconv->currency_symbol);
620 MSVCRT_free(locinfo->lconv->mon_decimal_point);
621 MSVCRT_free(locinfo->lconv->mon_thousands_sep);
622 MSVCRT_free(locinfo->lconv->mon_grouping);
623 MSVCRT_free(locinfo->lconv->positive_sign);
624 MSVCRT_free(locinfo->lconv->negative_sign);
625 }
626 MSVCRT_free(locinfo->lconv_intl_refcount);
627 MSVCRT_free(locinfo->lconv_num_refcount);
628 MSVCRT_free(locinfo->lconv_mon_refcount);
629 MSVCRT_free(locinfo->lconv);
630
631 MSVCRT_free(locinfo->ctype1_refcount);
632 MSVCRT_free(locinfo->ctype1);
633
634 MSVCRT_free(locinfo->pclmap);
635 MSVCRT_free(locinfo->pcumap);
636
637 MSVCRT_free(locinfo);
638 }
639
640 /* INTERNAL: frees MSVCRT_pthreadmbcinfo struct */
641 void free_mbcinfo(MSVCRT_pthreadmbcinfo mbcinfo)
642 {
643 if(!mbcinfo)
644 return;
645
646 if(InterlockedDecrement(&mbcinfo->refcount))
647 return;
648
649 MSVCRT_free(mbcinfo);
650 }
651
652 /* _get_current_locale - not exported in native msvcrt */
653 MSVCRT__locale_t CDECL MSVCRT__get_current_locale(void)
654 {
655 MSVCRT__locale_t loc = MSVCRT_malloc(sizeof(MSVCRT__locale_tstruct));
656 if(!loc)
657 return NULL;
658
659 loc->locinfo = get_locinfo();
660 loc->mbcinfo = get_mbcinfo();
661 InterlockedIncrement(&loc->locinfo->refcount);
662 InterlockedIncrement(&loc->mbcinfo->refcount);
663 return loc;
664 }
665
666 /* _free_locale - not exported in native msvcrt */
667 void CDECL MSVCRT__free_locale(MSVCRT__locale_t locale)
668 {
669 if (!locale)
670 return;
671
672 free_locinfo(locale->locinfo);
673 free_mbcinfo(locale->mbcinfo);
674 MSVCRT_free(locale);
675 }
676
677 /* _create_locale - not exported in native msvcrt */
678 MSVCRT__locale_t CDECL MSVCRT__create_locale(int category, const char *locale)
679 {
680 static const char collate[] = "COLLATE=";
681 static const char ctype[] = "CTYPE=";
682 static const char monetary[] = "MONETARY=";
683 static const char numeric[] = "NUMERIC=";
684 static const char time[] = "TIME=";
685
686 MSVCRT__locale_t loc;
687 LCID lcid[6] = { 0 };
688 char buf[256];
689 int i;
690
691 TRACE("(%d %s)\n", category, locale);
692
693 if(category<MSVCRT_LC_MIN || category>MSVCRT_LC_MAX || !locale)
694 return NULL;
695
696 if(locale[0]=='C' && !locale[1])
697 lcid[0] = CP_ACP;
698 else if(!locale[0])
699 lcid[0] = GetSystemDefaultLCID();
700 else if (locale[0] == 'L' && locale[1] == 'C' && locale[2] == '_') {
701 const char *p;
702
703 while(1) {
704 locale += 3; /* LC_ */
705 if(!memcmp(locale, collate, sizeof(collate)-1)) {
706 i = MSVCRT_LC_COLLATE;
707 locale += sizeof(collate)-1;
708 } else if(!memcmp(locale, ctype, sizeof(ctype)-1)) {
709 i = MSVCRT_LC_CTYPE;
710 locale += sizeof(ctype)-1;
711 } else if(!memcmp(locale, monetary, sizeof(monetary)-1)) {
712 i = MSVCRT_LC_MONETARY;
713 locale += sizeof(monetary)-1;
714 } else if(!memcmp(locale, numeric, sizeof(numeric)-1)) {
715 i = MSVCRT_LC_NUMERIC;
716 locale += sizeof(numeric)-1;
717 } else if(!memcmp(locale, time, sizeof(time)-1)) {
718 i = MSVCRT_LC_TIME;
719 locale += sizeof(time)-1;
720 } else
721 return NULL;
722
723 p = strchr(locale, ';');
724 if(locale[0]=='C' && (locale[1]==';' || locale[1]=='\0'))
725 lcid[i] = 0;
726 else if(p) {
727 memcpy(buf, locale, p-locale);
728 buf[p-locale] = '\0';
729 lcid[i] = MSVCRT_locale_to_LCID(buf);
730 } else
731 lcid[i] = MSVCRT_locale_to_LCID(locale);
732
733 if(lcid[i] == -1)
734 return NULL;
735
736 if(!p || *(p+1)!='L' || *(p+2)!='C' || *(p+3)!='_')
737 break;
738
739 locale = p+1;
740 }
741 } else {
742 lcid[0] = MSVCRT_locale_to_LCID(locale);
743 if(lcid[0] == -1)
744 return NULL;
745 }
746
747 for(i=1; i<6; i++) {
748 if(!lcid[i])
749 lcid[i] = lcid[0];
750 }
751
752 loc = MSVCRT_malloc(sizeof(MSVCRT__locale_tstruct));
753 if(!loc)
754 return NULL;
755
756 loc->locinfo = MSVCRT_malloc(sizeof(MSVCRT_threadlocinfo));
757 if(!loc->locinfo) {
758 MSVCRT_free(loc);
759 return NULL;
760 }
761
762 loc->mbcinfo = MSVCRT_malloc(sizeof(MSVCRT_threadmbcinfo));
763 if(!loc->mbcinfo) {
764 MSVCRT_free(loc->locinfo);
765 MSVCRT_free(loc);
766 return NULL;
767 }
768
769 memset(loc->locinfo, 0, sizeof(MSVCRT_threadlocinfo));
770 loc->locinfo->refcount = 1;
771 loc->mbcinfo->refcount = 1;
772
773 loc->locinfo->lconv = MSVCRT_malloc(sizeof(struct MSVCRT_lconv));
774 if(!loc->locinfo->lconv) {
775 MSVCRT__free_locale(loc);
776 return NULL;
777 }
778 memset(loc->locinfo->lconv, 0, sizeof(struct MSVCRT_lconv));
779
780 loc->locinfo->pclmap = MSVCRT_malloc(sizeof(char[256]));
781 loc->locinfo->pcumap = MSVCRT_malloc(sizeof(char[256]));
782 if(!loc->locinfo->pclmap || !loc->locinfo->pcumap) {
783 MSVCRT__free_locale(loc);
784 return NULL;
785 }
786
787 if(lcid[MSVCRT_LC_COLLATE] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_COLLATE)) {
788 if(update_threadlocinfo_category(lcid[MSVCRT_LC_COLLATE], loc, MSVCRT_LC_COLLATE)) {
789 MSVCRT__free_locale(loc);
790 return NULL;
791 }
792
793 loc->locinfo->lc_collate_cp = loc->locinfo->lc_id[MSVCRT_LC_COLLATE].wCodePage;
794 } else
795 loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale = MSVCRT__strdup("C");
796
797 if(lcid[MSVCRT_LC_CTYPE] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_CTYPE)) {
798 CPINFO cp;
799 int j;
800
801 if(update_threadlocinfo_category(lcid[MSVCRT_LC_CTYPE], loc, MSVCRT_LC_CTYPE)) {
802 MSVCRT__free_locale(loc);
803 return NULL;
804 }
805
806 loc->locinfo->lc_codepage = loc->locinfo->lc_id[MSVCRT_LC_CTYPE].wCodePage;
807 loc->locinfo->lc_clike = 1;
808 if(!GetCPInfo(loc->locinfo->lc_codepage, &cp)) {
809 MSVCRT__free_locale(loc);
810 return NULL;
811 }
812 loc->locinfo->mb_cur_max = cp.MaxCharSize;
813
814 loc->locinfo->ctype1_refcount = MSVCRT_malloc(sizeof(int));
815 loc->locinfo->ctype1 = MSVCRT_malloc(sizeof(short[257]));
816 if(!loc->locinfo->ctype1_refcount || !loc->locinfo->ctype1) {
817 MSVCRT__free_locale(loc);
818 return NULL;
819 }
820
821 *loc->locinfo->ctype1_refcount = 1;
822 loc->locinfo->ctype1[0] = 0;
823 loc->locinfo->pctype = loc->locinfo->ctype1+1;
824
825 buf[1] = buf[2] = '\0';
826 for(i=1; i<257; i++) {
827 buf[0] = i-1;
828
829 /* builtin GetStringTypeA doesn't set output to 0 on invalid input */
830 loc->locinfo->ctype1[i] = 0;
831
832 GetStringTypeA(lcid[MSVCRT_LC_CTYPE], CT_CTYPE1, buf,
833 1, loc->locinfo->ctype1+i);
834 }
835
836 for(i=0; cp.LeadByte[i+1]!=0; i+=2)
837 for(j=cp.LeadByte[i]; j<=cp.LeadByte[i+1]; j++)
838 loc->locinfo->ctype1[j+1] |= MSVCRT__LEADBYTE;
839 } else {
840 loc->locinfo->lc_clike = 1;
841 loc->locinfo->mb_cur_max = 1;
842 loc->locinfo->pctype = MSVCRT__ctype+1;
843 loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale = MSVCRT__strdup("C");
844 }
845
846 for(i=0; i<256; i++) {
847 if(loc->locinfo->pctype[i] & MSVCRT__LEADBYTE)
848 buf[i] = ' ';
849 else
850 buf[i] = i;
851
852 }
853
854 if(lcid[MSVCRT_LC_CTYPE]) {
855 LCMapStringA(lcid[MSVCRT_LC_CTYPE], LCMAP_LOWERCASE, buf, 256,
856 (char*)loc->locinfo->pclmap, 256);
857 LCMapStringA(lcid[MSVCRT_LC_CTYPE], LCMAP_UPPERCASE, buf, 256,
858 (char*)loc->locinfo->pcumap, 256);
859 } else {
860 for(i=0; i<256; i++) {
861 loc->locinfo->pclmap[i] = (i>='A' && i<='Z' ? i-'A'+'a' : i);
862 loc->locinfo->pcumap[i] = (i>='a' && i<='z' ? i-'a'+'A' : i);
863 }
864 }
865
866 _setmbcp_l(loc->locinfo->lc_id[MSVCRT_LC_CTYPE].wCodePage, lcid[MSVCRT_LC_CTYPE], loc->mbcinfo);
867
868 if(lcid[MSVCRT_LC_MONETARY] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_MONETARY)) {
869 if(update_threadlocinfo_category(lcid[MSVCRT_LC_MONETARY], loc, MSVCRT_LC_MONETARY)) {
870 MSVCRT__free_locale(loc);
871 return NULL;
872 }
873
874 loc->locinfo->lconv_intl_refcount = MSVCRT_malloc(sizeof(int));
875 loc->locinfo->lconv_mon_refcount = MSVCRT_malloc(sizeof(int));
876 if(!loc->locinfo->lconv_intl_refcount || !loc->locinfo->lconv_mon_refcount) {
877 MSVCRT__free_locale(loc);
878 return NULL;
879 }
880
881 *loc->locinfo->lconv_intl_refcount = 1;
882 *loc->locinfo->lconv_mon_refcount = 1;
883
884 i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SINTLSYMBOL
885 |LOCALE_NOUSEROVERRIDE, buf, 256);
886 if(i && (loc->locinfo->lconv->int_curr_symbol = MSVCRT_malloc(i)))
887 memcpy(loc->locinfo->lconv->int_curr_symbol, buf, i);
888 else {
889 MSVCRT__free_locale(loc);
890 return NULL;
891 }
892
893 i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SCURRENCY
894 |LOCALE_NOUSEROVERRIDE, buf, 256);
895 if(i && (loc->locinfo->lconv->currency_symbol = MSVCRT_malloc(i)))
896 memcpy(loc->locinfo->lconv->currency_symbol, buf, i);
897 else {
898 MSVCRT__free_locale(loc);
899 return NULL;
900 }
901
902 i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SMONDECIMALSEP
903 |LOCALE_NOUSEROVERRIDE, buf, 256);
904 if(i && (loc->locinfo->lconv->mon_decimal_point = MSVCRT_malloc(i)))
905 memcpy(loc->locinfo->lconv->mon_decimal_point, buf, i);
906 else {
907 MSVCRT__free_locale(loc);
908 return NULL;
909 }
910
911 i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SMONTHOUSANDSEP
912 |LOCALE_NOUSEROVERRIDE, buf, 256);
913 if(i && (loc->locinfo->lconv->mon_thousands_sep = MSVCRT_malloc(i)))
914 memcpy(loc->locinfo->lconv->mon_thousands_sep, buf, i);
915 else {
916 MSVCRT__free_locale(loc);
917 return NULL;
918 }
919
920 i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SMONGROUPING
921 |LOCALE_NOUSEROVERRIDE, buf, 256);
922 if(i>1)
923 i = i/2 + (buf[i-2]=='0'?0:1);
924 if(i && (loc->locinfo->lconv->mon_grouping = MSVCRT_malloc(i))) {
925 for(i=0; buf[i+1]==';'; i+=2)
926 loc->locinfo->lconv->mon_grouping[i/2] = buf[i]-'0';
927 loc->locinfo->lconv->mon_grouping[i/2] = buf[i]-'0';
928 if(buf[i] != '0')
929 loc->locinfo->lconv->mon_grouping[i/2+1] = 127;
930 } else {
931 MSVCRT__free_locale(loc);
932 return NULL;
933 }
934
935 i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SPOSITIVESIGN
936 |LOCALE_NOUSEROVERRIDE, buf, 256);
937 if(i && (loc->locinfo->lconv->positive_sign = MSVCRT_malloc(i)))
938 memcpy(loc->locinfo->lconv->positive_sign, buf, i);
939 else {
940 MSVCRT__free_locale(loc);
941 return NULL;
942 }
943
944 i = GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_SNEGATIVESIGN
945 |LOCALE_NOUSEROVERRIDE, buf, 256);
946 if(i && (loc->locinfo->lconv->negative_sign = MSVCRT_malloc(i)))
947 memcpy(loc->locinfo->lconv->negative_sign, buf, i);
948 else {
949 MSVCRT__free_locale(loc);
950 return NULL;
951 }
952
953 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IINTLCURRDIGITS
954 |LOCALE_NOUSEROVERRIDE, buf, 256))
955 loc->locinfo->lconv->int_frac_digits = atoi(buf);
956 else {
957 MSVCRT__free_locale(loc);
958 return NULL;
959 }
960
961 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_ICURRDIGITS
962 |LOCALE_NOUSEROVERRIDE, buf, 256))
963 loc->locinfo->lconv->frac_digits = atoi(buf);
964 else {
965 MSVCRT__free_locale(loc);
966 return NULL;
967 }
968
969 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IPOSSYMPRECEDES
970 |LOCALE_NOUSEROVERRIDE, buf, 256))
971 loc->locinfo->lconv->p_cs_precedes = atoi(buf);
972 else {
973 MSVCRT__free_locale(loc);
974 return NULL;
975 }
976
977 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IPOSSEPBYSPACE
978 |LOCALE_NOUSEROVERRIDE, buf, 256))
979 loc->locinfo->lconv->p_sep_by_space = atoi(buf);
980 else {
981 MSVCRT__free_locale(loc);
982 return NULL;
983 }
984
985 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_INEGSYMPRECEDES
986 |LOCALE_NOUSEROVERRIDE, buf, 256))
987 loc->locinfo->lconv->n_cs_precedes = atoi(buf);
988 else {
989 MSVCRT__free_locale(loc);
990 return NULL;
991 }
992
993 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_INEGSEPBYSPACE
994 |LOCALE_NOUSEROVERRIDE, buf, 256))
995 loc->locinfo->lconv->n_sep_by_space = atoi(buf);
996 else {
997 MSVCRT__free_locale(loc);
998 return NULL;
999 }
1000
1001 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_IPOSSIGNPOSN
1002 |LOCALE_NOUSEROVERRIDE, buf, 256))
1003 loc->locinfo->lconv->p_sign_posn = atoi(buf);
1004 else {
1005 MSVCRT__free_locale(loc);
1006 return NULL;
1007 }
1008
1009 if(GetLocaleInfoA(lcid[MSVCRT_LC_MONETARY], LOCALE_INEGSIGNPOSN
1010 |LOCALE_NOUSEROVERRIDE, buf, 256))
1011 loc->locinfo->lconv->n_sign_posn = atoi(buf);
1012 else {
1013 MSVCRT__free_locale(loc);
1014 return NULL;
1015 }
1016 } else {
1017 loc->locinfo->lconv->int_curr_symbol = MSVCRT_malloc(sizeof(char));
1018 loc->locinfo->lconv->currency_symbol = MSVCRT_malloc(sizeof(char));
1019 loc->locinfo->lconv->mon_decimal_point = MSVCRT_malloc(sizeof(char));
1020 loc->locinfo->lconv->mon_thousands_sep = MSVCRT_malloc(sizeof(char));
1021 loc->locinfo->lconv->mon_grouping = MSVCRT_malloc(sizeof(char));
1022 loc->locinfo->lconv->positive_sign = MSVCRT_malloc(sizeof(char));
1023 loc->locinfo->lconv->negative_sign = MSVCRT_malloc(sizeof(char));
1024
1025 if(!loc->locinfo->lconv->int_curr_symbol || !loc->locinfo->lconv->currency_symbol
1026 || !loc->locinfo->lconv->mon_decimal_point || !loc->locinfo->lconv->mon_thousands_sep
1027 || !loc->locinfo->lconv->mon_grouping || !loc->locinfo->lconv->positive_sign
1028 || !loc->locinfo->lconv->negative_sign) {
1029 MSVCRT__free_locale(loc);
1030 return NULL;
1031 }
1032
1033 loc->locinfo->lconv->int_curr_symbol[0] = '\0';
1034 loc->locinfo->lconv->currency_symbol[0] = '\0';
1035 loc->locinfo->lconv->mon_decimal_point[0] = '\0';
1036 loc->locinfo->lconv->mon_thousands_sep[0] = '\0';
1037 loc->locinfo->lconv->mon_grouping[0] = '\0';
1038 loc->locinfo->lconv->positive_sign[0] = '\0';
1039 loc->locinfo->lconv->negative_sign[0] = '\0';
1040 loc->locinfo->lconv->int_frac_digits = 127;
1041 loc->locinfo->lconv->frac_digits = 127;
1042 loc->locinfo->lconv->p_cs_precedes = 127;
1043 loc->locinfo->lconv->p_sep_by_space = 127;
1044 loc->locinfo->lconv->n_cs_precedes = 127;
1045 loc->locinfo->lconv->n_sep_by_space = 127;
1046 loc->locinfo->lconv->p_sign_posn = 127;
1047 loc->locinfo->lconv->n_sign_posn = 127;
1048
1049 loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale = MSVCRT__strdup("C");
1050 }
1051
1052 if(lcid[MSVCRT_LC_NUMERIC] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_NUMERIC)) {
1053 if(update_threadlocinfo_category(lcid[MSVCRT_LC_NUMERIC], loc, MSVCRT_LC_NUMERIC)) {
1054 MSVCRT__free_locale(loc);
1055 return NULL;
1056 }
1057
1058 if(!loc->locinfo->lconv_intl_refcount)
1059 loc->locinfo->lconv_intl_refcount = MSVCRT_malloc(sizeof(int));
1060 loc->locinfo->lconv_num_refcount = MSVCRT_malloc(sizeof(int));
1061 if(!loc->locinfo->lconv_intl_refcount || !loc->locinfo->lconv_num_refcount) {
1062 MSVCRT__free_locale(loc);
1063 return NULL;
1064 }
1065
1066 *loc->locinfo->lconv_intl_refcount = 1;
1067 *loc->locinfo->lconv_num_refcount = 1;
1068
1069 i = GetLocaleInfoA(lcid[MSVCRT_LC_NUMERIC], LOCALE_SDECIMAL
1070 |LOCALE_NOUSEROVERRIDE, buf, 256);
1071 if(i && (loc->locinfo->lconv->decimal_point = MSVCRT_malloc(i)))
1072 memcpy(loc->locinfo->lconv->decimal_point, buf, i);
1073 else {
1074 MSVCRT__free_locale(loc);
1075 return NULL;
1076 }
1077
1078 i = GetLocaleInfoA(lcid[MSVCRT_LC_NUMERIC], LOCALE_STHOUSAND
1079 |LOCALE_NOUSEROVERRIDE, buf, 256);
1080 if(i && (loc->locinfo->lconv->thousands_sep = MSVCRT_malloc(i)))
1081 memcpy(loc->locinfo->lconv->thousands_sep, buf, i);
1082 else {
1083 MSVCRT__free_locale(loc);
1084 return NULL;
1085 }
1086
1087 i = GetLocaleInfoA(lcid[MSVCRT_LC_NUMERIC], LOCALE_SGROUPING
1088 |LOCALE_NOUSEROVERRIDE, buf, 256);
1089 if(i>1)
1090 i = i/2 + (buf[i-2]=='0'?0:1);
1091 if(i && (loc->locinfo->lconv->grouping = MSVCRT_malloc(i))) {
1092 for(i=0; buf[i+1]==';'; i+=2)
1093 loc->locinfo->lconv->grouping[i/2] = buf[i]-'0';
1094 loc->locinfo->lconv->grouping[i/2] = buf[i]-'0';
1095 if(buf[i] != '0')
1096 loc->locinfo->lconv->grouping[i/2+1] = 127;
1097 } else {
1098 MSVCRT__free_locale(loc);
1099 return NULL;
1100 }
1101 } else {
1102 loc->locinfo->lconv->decimal_point = MSVCRT_malloc(sizeof(char[2]));
1103 loc->locinfo->lconv->thousands_sep = MSVCRT_malloc(sizeof(char));
1104 loc->locinfo->lconv->grouping = MSVCRT_malloc(sizeof(char));
1105 if(!loc->locinfo->lconv->decimal_point || !loc->locinfo->lconv->thousands_sep
1106 || !loc->locinfo->lconv->grouping) {
1107 MSVCRT__free_locale(loc);
1108 return NULL;
1109 }
1110
1111 loc->locinfo->lconv->decimal_point[0] = '.';
1112 loc->locinfo->lconv->decimal_point[1] = '\0';
1113 loc->locinfo->lconv->thousands_sep[0] = '\0';
1114 loc->locinfo->lconv->grouping[0] = '\0';
1115
1116 loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale = MSVCRT__strdup("C");
1117 }
1118
1119 if(lcid[MSVCRT_LC_TIME] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_TIME)) {
1120 if(update_threadlocinfo_category(lcid[MSVCRT_LC_TIME], loc, MSVCRT_LC_TIME)) {
1121 MSVCRT__free_locale(loc);
1122 return NULL;
1123 }
1124 } else
1125 loc->locinfo->lc_category[MSVCRT_LC_TIME].locale = MSVCRT__strdup("C");
1126
1127 return loc;
1128 }
1129
1130 /*********************************************************************
1131 * setlocale (MSVCRT.@)
1132 */
1133 char* CDECL MSVCRT_setlocale(int category, const char* locale)
1134 {
1135 MSVCRT__locale_t loc;
1136 MSVCRT_pthreadlocinfo locinfo = get_locinfo();
1137
1138 if(category<MSVCRT_LC_MIN || category>MSVCRT_LC_MAX)
1139 return NULL;
1140
1141 if(!locale) {
1142 if(category == MSVCRT_LC_ALL)
1143 return construct_lc_all(locinfo);
1144
1145 return locinfo->lc_category[category].locale;
1146 }
1147
1148 loc = MSVCRT__create_locale(category, locale);
1149 if(!loc) {
1150 WARN("%d %s failed\n", category, locale);
1151 return NULL;
1152 }
1153
1154 LOCK_LOCALE;
1155
1156 switch(category) {
1157 case MSVCRT_LC_ALL:
1158 case MSVCRT_LC_COLLATE:
1159 locinfo->lc_collate_cp = loc->locinfo->lc_collate_cp;
1160 locinfo->lc_handle[MSVCRT_LC_COLLATE] =
1161 loc->locinfo->lc_handle[MSVCRT_LC_COLLATE];
1162 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_COLLATE].locale,
1163 (void**)&loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale);
1164 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_COLLATE].refcount,
1165 (void**)&loc->locinfo->lc_category[MSVCRT_LC_COLLATE].refcount);
1166
1167 if(category != MSVCRT_LC_ALL)
1168 break;
1169 /* fall through */
1170 case MSVCRT_LC_CTYPE:
1171 locinfo->lc_handle[MSVCRT_LC_CTYPE] =
1172 loc->locinfo->lc_handle[MSVCRT_LC_CTYPE];
1173 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_CTYPE].locale,
1174 (void**)&loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale);
1175 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_CTYPE].refcount,
1176 (void**)&loc->locinfo->lc_category[MSVCRT_LC_CTYPE].refcount);
1177
1178 locinfo->lc_codepage = loc->locinfo->lc_codepage;
1179 locinfo->lc_clike = loc->locinfo->lc_clike;
1180 locinfo->mb_cur_max = loc->locinfo->mb_cur_max;
1181
1182 swap_pointers((void**)&locinfo->ctype1_refcount,
1183 (void**)&loc->locinfo->ctype1_refcount);
1184 swap_pointers((void**)&locinfo->ctype1, (void**)&loc->locinfo->ctype1);
1185 swap_pointers((void**)&locinfo->pctype, (void**)&loc->locinfo->pctype);
1186 swap_pointers((void**)&locinfo->pclmap, (void**)&loc->locinfo->pclmap);
1187 swap_pointers((void**)&locinfo->pcumap, (void**)&loc->locinfo->pcumap);
1188
1189 if(category != MSVCRT_LC_ALL)
1190 break;
1191 /* fall through */
1192 case MSVCRT_LC_MONETARY:
1193 locinfo->lc_handle[MSVCRT_LC_MONETARY] =
1194 loc->locinfo->lc_handle[MSVCRT_LC_MONETARY];
1195 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_MONETARY].locale,
1196 (void**)&loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale);
1197 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_MONETARY].refcount,
1198 (void**)&loc->locinfo->lc_category[MSVCRT_LC_MONETARY].refcount);
1199
1200 swap_pointers((void**)&locinfo->lconv->int_curr_symbol,
1201 (void**)&loc->locinfo->lconv->int_curr_symbol);
1202 swap_pointers((void**)&locinfo->lconv->currency_symbol,
1203 (void**)&loc->locinfo->lconv->currency_symbol);
1204 swap_pointers((void**)&locinfo->lconv->mon_decimal_point,
1205 (void**)&loc->locinfo->lconv->mon_decimal_point);
1206 swap_pointers((void**)&locinfo->lconv->mon_thousands_sep,
1207 (void**)&loc->locinfo->lconv->mon_thousands_sep);
1208 swap_pointers((void**)&locinfo->lconv->mon_grouping,
1209 (void**)&loc->locinfo->lconv->mon_grouping);
1210 swap_pointers((void**)&locinfo->lconv->positive_sign,
1211 (void**)&loc->locinfo->lconv->positive_sign);
1212 swap_pointers((void**)&locinfo->lconv->negative_sign,
1213 (void**)&loc->locinfo->lconv->negative_sign);
1214 locinfo->lconv->int_frac_digits = loc->locinfo->lconv->int_frac_digits;
1215 locinfo->lconv->frac_digits = loc->locinfo->lconv->frac_digits;
1216 locinfo->lconv->p_cs_precedes = loc->locinfo->lconv->p_cs_precedes;
1217 locinfo->lconv->p_sep_by_space = loc->locinfo->lconv->p_sep_by_space;
1218 locinfo->lconv->n_cs_precedes = loc->locinfo->lconv->n_cs_precedes;
1219 locinfo->lconv->n_sep_by_space = loc->locinfo->lconv->n_sep_by_space;
1220 locinfo->lconv->p_sign_posn = loc->locinfo->lconv->p_sign_posn;
1221 locinfo->lconv->n_sign_posn = loc->locinfo->lconv->n_sign_posn;
1222
1223 if(category != MSVCRT_LC_ALL)
1224 break;
1225 /* fall through */
1226 case MSVCRT_LC_NUMERIC:
1227 locinfo->lc_handle[MSVCRT_LC_NUMERIC] =
1228 loc->locinfo->lc_handle[MSVCRT_LC_NUMERIC];
1229 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_NUMERIC].locale,
1230 (void**)&loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale);
1231 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_NUMERIC].refcount,
1232 (void**)&loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].refcount);
1233
1234 swap_pointers((void**)&locinfo->lconv->decimal_point,
1235 (void**)&loc->locinfo->lconv->decimal_point);
1236 swap_pointers((void**)&locinfo->lconv->thousands_sep,
1237 (void**)&loc->locinfo->lconv->thousands_sep);
1238 swap_pointers((void**)&locinfo->lconv->grouping,
1239 (void**)&loc->locinfo->lconv->grouping);
1240
1241 if(category != MSVCRT_LC_ALL)
1242 break;
1243 /* fall through */
1244 case MSVCRT_LC_TIME:
1245 locinfo->lc_handle[MSVCRT_LC_TIME] =
1246 loc->locinfo->lc_handle[MSVCRT_LC_TIME];
1247 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_TIME].locale,
1248 (void**)&loc->locinfo->lc_category[MSVCRT_LC_TIME].locale);
1249 swap_pointers((void**)&locinfo->lc_category[MSVCRT_LC_TIME].refcount,
1250 (void**)&loc->locinfo->lc_category[MSVCRT_LC_TIME].refcount);
1251
1252 if(category != MSVCRT_LC_ALL)
1253 break;
1254 }
1255
1256 MSVCRT__free_locale(loc);
1257 UNLOCK_LOCALE;
1258
1259 if(locinfo == MSVCRT_locale->locinfo) {
1260 int i;
1261
1262 MSVCRT___lc_codepage = locinfo->lc_codepage;
1263 MSVCRT___lc_collate_cp = locinfo->lc_collate_cp;
1264 MSVCRT___mb_cur_max = locinfo->mb_cur_max;
1265 MSVCRT__pctype = locinfo->pctype;
1266 for(i=MSVCRT_LC_MIN; i<=MSVCRT_LC_MAX; i++)
1267 MSVCRT___lc_handle[i] = MSVCRT_locale->locinfo->lc_handle[i];
1268 }
1269
1270 if(category == MSVCRT_LC_ALL)
1271 return construct_lc_all(locinfo);
1272
1273 return locinfo->lc_category[category].locale;
1274 }
1275
1276 /* _configthreadlocale - not exported in native msvcrt */
1277 int CDECL _configthreadlocale(int type)
1278 {
1279 thread_data_t *data = msvcrt_get_thread_data();
1280 MSVCRT__locale_t locale;
1281 int ret;
1282
1283 if(!data)
1284 return -1;
1285
1286 ret = (data->have_locale ? MSVCRT__ENABLE_PER_THREAD_LOCALE : MSVCRT__DISABLE_PER_THREAD_LOCALE);
1287
1288 if(type == MSVCRT__ENABLE_PER_THREAD_LOCALE) {
1289 if(!data->have_locale) {
1290 /* Copy current global locale */
1291 locale = MSVCRT__create_locale(MSVCRT_LC_ALL, MSVCRT_setlocale(MSVCRT_LC_ALL, NULL));
1292 if(!locale)
1293 return -1;
1294
1295 data->locinfo = locale->locinfo;
1296 data->mbcinfo = locale->mbcinfo;
1297 data->have_locale = TRUE;
1298 MSVCRT_free(locale);
1299 }
1300
1301 return ret;
1302 }
1303
1304 if(type == MSVCRT__DISABLE_PER_THREAD_LOCALE) {
1305 if(data->have_locale) {
1306 free_locinfo(data->locinfo);
1307 free_mbcinfo(data->mbcinfo);
1308 data->locinfo = MSVCRT_locale->locinfo;
1309 data->mbcinfo = MSVCRT_locale->mbcinfo;
1310 data->have_locale = FALSE;
1311 }
1312
1313 return ret;
1314 }
1315
1316 if(!type)
1317 return ret;
1318
1319 return -1;
1320 }
1321
1322 BOOL msvcrt_init_locale(void)
1323 {
1324 int i;
1325
1326 LOCK_LOCALE;
1327 MSVCRT_locale = MSVCRT__create_locale(0, "C");
1328 UNLOCK_LOCALE;
1329 if(!MSVCRT_locale)
1330 return FALSE;
1331
1332 MSVCRT___lc_codepage = MSVCRT_locale->locinfo->lc_codepage;
1333 MSVCRT___lc_collate_cp = MSVCRT_locale->locinfo->lc_collate_cp;
1334 MSVCRT___mb_cur_max = MSVCRT_locale->locinfo->mb_cur_max;
1335 MSVCRT__pctype = MSVCRT_locale->locinfo->pctype;
1336 for(i=MSVCRT_LC_MIN; i<=MSVCRT_LC_MAX; i++)
1337 MSVCRT___lc_handle[i] = MSVCRT_locale->locinfo->lc_handle[i];
1338 _setmbcp(_MB_CP_ANSI);
1339 return TRUE;
1340 }
Windows API implementation