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 <locale.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "winnls.h"
  32
  33 #include "msvcrt.h"
  34 #include "mtdll.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  39
  40 /* FIXME: Need to hold locale for each LC_* type and aggregate
  41  * string to produce lc_all.
  42  */
  43 #define MAX_ELEM_LEN 64 /* Max length of country/language/CP string */
  44 #define MAX_LOCALE_LENGTH 256
  45 char MSVCRT_current_lc_all[MAX_LOCALE_LENGTH] = { 0 };
  46 LCID MSVCRT_current_lc_all_lcid = 0;
  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
  51 /* MT */
  52 #define LOCK_LOCALE   _mlock(_SETLOCALE_LOCK);
  53 #define UNLOCK_LOCALE _munlock(_SETLOCALE_LOCK);
  54
  55 #define MSVCRT_LEADBYTE  0x8000
  56
  57 /* Friendly country strings & iso codes for synonym support.
  58  * Based on MS documentation for setlocale().
  59  */
  60 static const char * const _country_synonyms[] =
  61 {
  62   "Hong Kong","HK",
  63   "Hong-Kong","HK",
  64   "New Zealand","NZ",
  65   "New-Zealand","NZ",
  66   "PR China","CN",
  67   "PR-China","CN",
  68   "United Kingdom","GB",
  69   "United-Kingdom","GB",
  70   "Britain","GB",
  71   "England","GB",
  72   "Great Britain","GB",
  73   "United States","US",
  74   "United-States","US",
  75   "America","US"
  76 };
  77
  78 /* INTERNAL: Map a synonym to an ISO code */
  79 static void remap_synonym(char *name)
  80 {
  81   size_t i;
  82   for (i = 0; i < sizeof(_country_synonyms)/sizeof(char*); i += 2 )
  83   {
  84     if (!strcasecmp(_country_synonyms[i],name))
  85     {
  86       TRACE(":Mapping synonym %s to %s\n",name,_country_synonyms[i+1]);
  87       name[0] = _country_synonyms[i+1][0];
  88       name[1] = _country_synonyms[i+1][1];
  89       name[2] = '\0';
  90       return;
  91     }
  92   }
  93 }
  94
  95 /* Note: Flags are weighted in order of matching importance */
  96 #define FOUND_LANGUAGE         0x4
  97 #define FOUND_COUNTRY          0x2
  98 #define FOUND_CODEPAGE         0x1
  99
 100 typedef struct {
 101   char search_language[MAX_ELEM_LEN];
 102   char search_country[MAX_ELEM_LEN];
 103   char search_codepage[MAX_ELEM_LEN];
 104   char found_language[MAX_ELEM_LEN];
 105   char found_country[MAX_ELEM_LEN];
 106   char found_codepage[MAX_ELEM_LEN];
 107   unsigned int match_flags;
 108   LANGID found_lang_id;
 109 } locale_search_t;
 110
 111 #define CONTINUE_LOOKING TRUE
 112 #define STOP_LOOKING     FALSE
 113
 114 /* INTERNAL: Get and compare locale info with a given string */
 115 static int compare_info(LCID lcid, DWORD flags, char* buff, const char* cmp)
 116 {
 117   buff[0] = 0;
 118   GetLocaleInfoA(lcid, flags|LOCALE_NOUSEROVERRIDE,buff, MAX_ELEM_LEN);
 119   if (!buff[0] || !cmp[0])
 120     return 0;
 121   /* Partial matches are allowed, e.g. "Germ" matches "Germany" */
 122   return !strncasecmp(cmp, buff, strlen(cmp));
 123 }
 124
 125 static BOOL CALLBACK
 126 find_best_locale_proc(HMODULE hModule, LPCSTR type, LPCSTR name, WORD LangID, LONG_PTR lParam)
 127 {
 128   locale_search_t *res = (locale_search_t *)lParam;
 129   const LCID lcid = MAKELCID(LangID, SORT_DEFAULT);
 130   char buff[MAX_ELEM_LEN];
 131   unsigned int flags = 0;
 132
 133   if(PRIMARYLANGID(LangID) == LANG_NEUTRAL)
 134     return CONTINUE_LOOKING;
 135
 136   /* Check Language */
 137   if (compare_info(lcid,LOCALE_SISO639LANGNAME,buff,res->search_language) ||
 138       compare_info(lcid,LOCALE_SABBREVLANGNAME,buff,res->search_language) ||
 139       compare_info(lcid,LOCALE_SENGLANGUAGE,buff,res->search_language))
 140   {
 141     TRACE(":Found language: %s->%s\n", res->search_language, buff);
 142     flags |= FOUND_LANGUAGE;
 143     memcpy(res->found_language,res->search_language,MAX_ELEM_LEN);
 144   }
 145   else if (res->match_flags & FOUND_LANGUAGE)
 146   {
 147     return CONTINUE_LOOKING;
 148   }
 149
 150   /* Check Country */
 151   if (compare_info(lcid,LOCALE_SISO3166CTRYNAME,buff,res->search_country) ||
 152       compare_info(lcid,LOCALE_SABBREVCTRYNAME,buff,res->search_country) ||
 153       compare_info(lcid,LOCALE_SENGCOUNTRY,buff,res->search_country))
 154   {
 155     TRACE("Found country:%s->%s\n", res->search_country, buff);
 156     flags |= FOUND_COUNTRY;
 157     memcpy(res->found_country,res->search_country,MAX_ELEM_LEN);
 158   }
 159   else if (res->match_flags & FOUND_COUNTRY)
 160   {
 161     return CONTINUE_LOOKING;
 162   }
 163
 164   /* Check codepage */
 165   if (compare_info(lcid,LOCALE_IDEFAULTCODEPAGE,buff,res->search_codepage) ||
 166       (compare_info(lcid,LOCALE_IDEFAULTANSICODEPAGE,buff,res->search_codepage)))
 167   {
 168     TRACE("Found codepage:%s->%s\n", res->search_codepage, buff);
 169     flags |= FOUND_CODEPAGE;
 170     memcpy(res->found_codepage,res->search_codepage,MAX_ELEM_LEN);
 171   }
 172   else if (res->match_flags & FOUND_CODEPAGE)
 173   {
 174     return CONTINUE_LOOKING;
 175   }
 176
 177   if (flags > res->match_flags)
 178   {
 179     /* Found a better match than previously */
 180     res->match_flags = flags;
 181     res->found_lang_id = LangID;
 182   }
 183   if ((flags & (FOUND_LANGUAGE | FOUND_COUNTRY | FOUND_CODEPAGE)) ==
 184         (FOUND_LANGUAGE | FOUND_COUNTRY | FOUND_CODEPAGE))
 185   {
 186     TRACE(":found exact locale match\n");
 187     return STOP_LOOKING;
 188   }
 189   return CONTINUE_LOOKING;
 190 }
 191
 192 extern int atoi(const char *);
 193
 194 /* Internal: Find the LCID for a locale specification */
 195 static LCID MSVCRT_locale_to_LCID(locale_search_t* locale)
 196 {
 197   LCID lcid;
 198   EnumResourceLanguagesA(GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
 199                          (LPCSTR)LOCALE_ILANGUAGE,find_best_locale_proc,
 200                          (LONG_PTR)locale);
 201
 202   if (!locale->match_flags)
 203     return 0;
 204
 205   /* If we were given something that didn't match, fail */
 206   if (locale->search_country[0] && !(locale->match_flags & FOUND_COUNTRY))
 207     return 0;
 208
 209   lcid =  MAKELCID(locale->found_lang_id, SORT_DEFAULT);
 210
 211   /* Populate partial locale, translating LCID to locale string elements */
 212   if (!locale->found_codepage[0])
 213   {
 214     /* Even if a codepage is not enumerated for a locale
 215      * it can be set if valid */
 216     if (locale->search_codepage[0])
 217     {
 218       if (IsValidCodePage(atoi(locale->search_codepage)))
 219         memcpy(locale->found_codepage,locale->search_codepage,MAX_ELEM_LEN);
 220       else
 221       {
 222         /* Special codepage values: OEM & ANSI */
 223         if (strcasecmp(locale->search_codepage,"OCP"))
 224         {
 225           GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
 226                          locale->found_codepage, MAX_ELEM_LEN);
 227         }
 228         if (strcasecmp(locale->search_codepage,"ACP"))
 229         {
 230           GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
 231                          locale->found_codepage, MAX_ELEM_LEN);
 232         }
 233         else
 234           return 0;
 235
 236         if (!atoi(locale->found_codepage))
 237            return 0;
 238       }
 239     }
 240     else
 241     {
 242       /* Prefer ANSI codepages if present */
 243       GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
 244                      locale->found_codepage, MAX_ELEM_LEN);
 245       if (!locale->found_codepage[0] || !atoi(locale->found_codepage))
 246           GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
 247                          locale->found_codepage, MAX_ELEM_LEN);
 248     }
 249   }
 250   GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE|LOCALE_NOUSEROVERRIDE,
 251                  locale->found_language, MAX_ELEM_LEN);
 252   GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY|LOCALE_NOUSEROVERRIDE,
 253                  locale->found_country, MAX_ELEM_LEN);
 254   return lcid;
 255 }
 256
 257 /* INTERNAL: Set ctype behaviour for a codepage */
 258 static void msvcrt_set_ctype(unsigned int codepage, LCID lcid)
 259 {
 260   CPINFO cp;
 261
 262   memset(&cp, 0, sizeof(CPINFO));
 263
 264   if (GetCPInfo(codepage, &cp))
 265   {
 266     int i;
 267     char str[3];
 268     unsigned char *traverse = cp.LeadByte;
 269
 270     memset(MSVCRT_current_ctype, 0, sizeof(MSVCRT__ctype));
 271     MSVCRT___lc_codepage = codepage;
 272     MSVCRT___lc_collate_cp = codepage;
 273
 274     /* Switch ctype macros to MBCS if needed */
 275     MSVCRT___mb_cur_max = cp.MaxCharSize;
 276
 277     /* Set remaining ctype flags: FIXME: faster way to do this? */
 278     str[1] = str[2] = 0;
 279     for (i = 0; i < 256; i++)
 280     {
 281       if (!(MSVCRT__pctype[i] & MSVCRT_LEADBYTE))
 282       {
 283         str[0] = i;
 284         GetStringTypeA(lcid, CT_CTYPE1, str, 1, MSVCRT__pctype + i);
 285       }
 286     }
 287
 288     /* Set leadbyte flags */
 289     while (traverse[0] || traverse[1])
 290     {
 291       for( i = traverse[0]; i <= traverse[1]; i++ )
 292         MSVCRT_current_ctype[i+1] |= MSVCRT_LEADBYTE;
 293       traverse += 2;
 294     };
 295   }
 296 }
 297
 298
 299 /*********************************************************************
 300  *              setlocale (MSVCRT.@)
 301  */
 302 char* CDECL MSVCRT_setlocale(int category, const char* locale)
 303 {
 304   LCID lcid = 0;
 305   locale_search_t lc;
 306   int haveLang, haveCountry, haveCP;
 307   char* next;
 308   int lc_all = 0;
 309
 310   TRACE("(%d %s)\n",category,locale);
 311
 312   if (category < MSVCRT_LC_MIN || category > MSVCRT_LC_MAX)
 313     return NULL;
 314
 315   if (locale == NULL)
 316   {
 317     /* Report the current Locale */
 318     return MSVCRT_current_lc_all;
 319   }
 320
 321   LOCK_LOCALE;
 322
 323   if (locale[0] == 'L' && locale[1] == 'C' && locale[2] == '_')
 324   {
 325     FIXME(":restore previous locale not implemented!\n");
 326     /* FIXME: Easiest way to do this is parse the string and
 327      * call this function recursively with its elements,
 328      * Where they differ for each lc_ type.
 329      */
 330     UNLOCK_LOCALE;
 331     return MSVCRT_current_lc_all;
 332   }
 333
 334   /* Default Locale: Special case handling */
 335   if (!strlen(locale) || ((toupper(locale[0]) == 'C') && !locale[1]))
 336   {
 337     MSVCRT_current_lc_all[0] = 'C';
 338     MSVCRT_current_lc_all[1] = '\0';
 339     MSVCRT___lc_codepage = GetACP();
 340     MSVCRT___lc_collate_cp = GetACP();
 341
 342     switch (category) {
 343     case MSVCRT_LC_ALL:
 344       lc_all = 1; /* Fall through all cases ... */
 345     case MSVCRT_LC_COLLATE:
 346       if (!lc_all) break;
 347     case MSVCRT_LC_CTYPE:
 348       /* Restore C locale ctype info */
 349       MSVCRT___mb_cur_max = 1;
 350       memcpy(MSVCRT_current_ctype, MSVCRT__ctype, sizeof(MSVCRT__ctype));
 351       if (!lc_all) break;
 352     case MSVCRT_LC_MONETARY:
 353       if (!lc_all) break;
 354     case MSVCRT_LC_NUMERIC:
 355       if (!lc_all) break;
 356     case MSVCRT_LC_TIME:
 357       break;
 358     }
 359     UNLOCK_LOCALE;
 360     return MSVCRT_current_lc_all;
 361   }
 362
 363   /* Get locale elements */
 364   haveLang = haveCountry = haveCP = 0;
 365   memset(&lc,0,sizeof(lc));
 366
 367   next = strchr(locale,'_');
 368   if (next && next != locale)
 369   {
 370     haveLang = 1;
 371     memcpy(lc.search_language,locale,next-locale);
 372     locale += next-locale+1;
 373   }
 374
 375   next = strchr(locale,'.');
 376   if (next)
 377   {
 378     haveCP = 1;
 379     if (next == locale)
 380     {
 381       locale++;
 382       lstrcpynA(lc.search_codepage, locale, MAX_ELEM_LEN);
 383     }
 384     else
 385     {
 386       if (haveLang)
 387       {
 388         haveCountry = 1;
 389         memcpy(lc.search_country,locale,next-locale);
 390         locale += next-locale+1;
 391       }
 392       else
 393       {
 394         haveLang = 1;
 395         memcpy(lc.search_language,locale,next-locale);
 396         locale += next-locale+1;
 397       }
 398       lstrcpynA(lc.search_codepage, locale, MAX_ELEM_LEN);
 399     }
 400   }
 401   else
 402   {
 403     if (haveLang)
 404     {
 405       haveCountry = 1;
 406       lstrcpynA(lc.search_country, locale, MAX_ELEM_LEN);
 407     }
 408     else
 409     {
 410       haveLang = 1;
 411       lstrcpynA(lc.search_language, locale, MAX_ELEM_LEN);
 412     }
 413   }
 414
 415   if (haveCountry)
 416     remap_synonym(lc.search_country);
 417
 418   if (haveCP && !haveCountry && !haveLang)
 419   {
 420     FIXME(":Codepage only locale not implemented\n");
 421     /* FIXME: Use default lang/country and skip locale_to_LCID()
 422      * call below...
 423      */
 424     UNLOCK_LOCALE;
 425     return NULL;
 426   }
 427
 428   lcid = MSVCRT_locale_to_LCID(&lc);
 429
 430   TRACE(":found LCID %d\n",lcid);
 431
 432   if (lcid == 0)
 433   {
 434     UNLOCK_LOCALE;
 435     return NULL;
 436   }
 437
 438   MSVCRT_current_lc_all_lcid = lcid;
 439
 440   snprintf(MSVCRT_current_lc_all,MAX_LOCALE_LENGTH,"%s_%s.%s",
 441            lc.found_language,lc.found_country,lc.found_codepage);
 442
 443   switch (category) {
 444   case MSVCRT_LC_ALL:
 445     lc_all = 1; /* Fall through all cases ... */
 446   case MSVCRT_LC_COLLATE:
 447     if (!lc_all) break;
 448   case MSVCRT_LC_CTYPE:
 449     msvcrt_set_ctype(atoi(lc.found_codepage),lcid);
 450     if (!lc_all) break;
 451   case MSVCRT_LC_MONETARY:
 452     if (!lc_all) break;
 453   case MSVCRT_LC_NUMERIC:
 454     if (!lc_all) break;
 455   case MSVCRT_LC_TIME:
 456     break;
 457   }
 458   UNLOCK_LOCALE;
 459   return MSVCRT_current_lc_all;
 460 }
 461
 462 /*********************************************************************
 463  *              setlocale (MSVCRT.@)
 464  */
 465 MSVCRT_wchar_t* CDECL MSVCRT__wsetlocale(int category, const MSVCRT_wchar_t* locale)
 466 {
 467   static MSVCRT_wchar_t fake[] = {
 468     'E','n','g','l','i','s','h','_','U','n','i','t','e','d',' ',
 469     'S','t','a','t','e','s','.','1','2','5','2',0 };
 470
 471   FIXME("%d %s\n", category, debugstr_w(locale));
 472
 473   return fake;
 474 }
 475
 476 /*********************************************************************
 477  *              _Getdays (MSVCRT.@)
 478  */
 479 const char* CDECL _Getdays(void)
 480 {
 481   static const char MSVCRT_days[] = ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:"
 482                             "Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
 483   /* FIXME: Use locale */
 484   TRACE("(void) semi-stub\n");
 485   return MSVCRT_days;
 486 }
 487
 488 /*********************************************************************
 489  *              _Getmonths (MSVCRT.@)
 490  */
 491 const char* CDECL _Getmonths(void)
 492 {
 493   static const char MSVCRT_months[] = ":Jan:January:Feb:February:Mar:March:Apr:"
 494                 "April:May:May:Jun:June:Jul:July:Aug:August:Sep:September:Oct:"
 495                 "October:Nov:November:Dec:December";
 496   /* FIXME: Use locale */
 497   TRACE("(void) semi-stub\n");
 498   return MSVCRT_months;
 499 }
 500
 501 /*********************************************************************
 502  *              _Gettnames (MSVCRT.@)
 503  */
 504 const char* CDECL _Gettnames(void)
 505 {
 506   /* FIXME: */
 507   TRACE("(void) stub\n");
 508   return "";
 509 }
 510
 511 /*********************************************************************
 512  *              _Strftime (MSVCRT.@)
 513  */
 514 const char* CDECL _Strftime(char *out, unsigned int len, const char *fmt,
 515                             const void *tm, void *foo)
 516 {
 517   /* FIXME: */
 518   TRACE("(%p %d %s %p %p) stub\n", out, len, fmt, tm, foo);
 519   return "";
 520 }
 521
 522 /*********************************************************************
 523  *              __crtLCMapStringA (MSVCRT.@)
 524  */
 525 int CDECL __crtLCMapStringA(
 526   LCID lcid, DWORD mapflags, const char* src, int srclen, char* dst,
 527   int dstlen, unsigned int codepage, int xflag
 528 ) {
 529   FIXME("(lcid %x, flags %x, %s(%d), %p(%d), %x, %d), partial stub!\n",
 530         lcid,mapflags,src,srclen,dst,dstlen,codepage,xflag);
 531   /* FIXME: A bit incorrect. But msvcrt itself just converts its
 532    * arguments to wide strings and then calls LCMapStringW
 533    */
 534   return LCMapStringA(lcid,mapflags,src,srclen,dst,dstlen);
 535 }
 536
 537 /*********************************************************************
 538  *              __crtCompareStringA (MSVCRT.@)
 539  */
 540 int CDECL __crtCompareStringA( LCID lcid, DWORD flags, const char *src1, int len1,
 541                                const char *src2, int len2 )
 542 {
 543     FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
 544           lcid, flags, debugstr_a(src1), len1, debugstr_a(src2), len2 );
 545     /* FIXME: probably not entirely right */
 546     return CompareStringA( lcid, flags, src1, len1, src2, len2 );
 547 }
 548
 549 /*********************************************************************
 550  *              __crtCompareStringW (MSVCRT.@)
 551  */
 552 int CDECL __crtCompareStringW( LCID lcid, DWORD flags, const MSVCRT_wchar_t *src1, int len1,
 553                                const MSVCRT_wchar_t *src2, int len2 )
 554 {
 555     FIXME("(lcid %x, flags %x, %s(%d), %s(%d), partial stub\n",
 556           lcid, flags, debugstr_w(src1), len1, debugstr_w(src2), len2 );
 557     /* FIXME: probably not entirely right */
 558     return CompareStringW( lcid, flags, src1, len1, src2, len2 );
 559 }
 560
 561 /*********************************************************************
 562  *              __crtGetLocaleInfoW (MSVCRT.@)
 563  */
 564 int CDECL __crtGetLocaleInfoW( LCID lcid, LCTYPE type, MSVCRT_wchar_t *buffer, int len )
 565 {
 566     FIXME("(lcid %x, type %x, %p(%d), partial stub\n", lcid, type, buffer, len );
 567     /* FIXME: probably not entirely right */
 568     return GetLocaleInfoW( lcid, type, buffer, len );
 569 }
 570
 571 /*********************************************************************
 572  *              localeconv (MSVCRT.@)
 573  */
 574 struct MSVCRT_lconv * CDECL MSVCRT_localeconv(void) {
 575
 576   struct lconv *ylconv;
 577   static struct MSVCRT_lconv xlconv;
 578
 579   ylconv = localeconv();
 580
 581 #define X(x) xlconv.x = ylconv->x;
 582   X(decimal_point);
 583   X(thousands_sep);
 584   X(grouping);
 585   X(int_curr_symbol);
 586   X(currency_symbol);
 587   X(mon_decimal_point);
 588   X(mon_thousands_sep);
 589   X(mon_grouping);
 590   X(positive_sign);
 591   X(negative_sign);
 592   X(int_frac_digits);
 593   X(frac_digits);
 594   X(p_cs_precedes);
 595   X(p_sep_by_space);
 596   X(n_cs_precedes);
 597   X(n_sep_by_space);
 598   X(p_sign_posn);
 599   X(n_sign_posn);
 600   return &xlconv;
 601 }
 602
 603 /*********************************************************************
 604  *              __lconv_init (MSVCRT.@)
 605  */
 606 void CDECL __lconv_init(void)
 607 {
 608   FIXME(" stub\n");
 609 }