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