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