dlls/kernel32/locale.c

   1 /*
   2  * Locale support
   3  *
   4  * Copyright 1995 Martin von Loewis
   5  * Copyright 1998 David Lee Lambert
   6  * Copyright 2000 Julio César Gázquez
   7  * Copyright 2002 Alexandre Julliard for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <assert.h>
  25 #include <locale.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <ctype.h>
  30 #include <stdlib.h>
  31
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winternl.h"
  37 #include "winnls.h"
  38 #include "winerror.h"
  39 #include "winver.h"
  40 #include "kernel_private.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(nls);
  44
  45 extern const NLS_LOCALE_DATA * WINAPI NlsValidateLocale( LCID *lcid, ULONG flags );
  46
  47 extern BOOL WINAPI Internal_EnumCalendarInfo( CALINFO_ENUMPROCW proc,
  48                                               const NLS_LOCALE_DATA *locale, CALID id,
  49                                               CALTYPE type, BOOL unicode, BOOL ex,
  50                                               BOOL exex, LPARAM lparam );
  51 extern BOOL WINAPI Internal_EnumDateFormats( DATEFMT_ENUMPROCW proc, const NLS_LOCALE_DATA *locale,
  52                                              DWORD flags, BOOL unicode, BOOL ex, BOOL exex, LPARAM lparam );
  53 extern BOOL WINAPI Internal_EnumLanguageGroupLocales( LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id,
  54                                                       DWORD flags, LONG_PTR param, BOOL unicode );
  55 extern BOOL WINAPI Internal_EnumSystemCodePages( CODEPAGE_ENUMPROCW proc, DWORD flags, BOOL unicode );
  56 extern BOOL WINAPI Internal_EnumSystemLanguageGroups( LANGUAGEGROUP_ENUMPROCW proc, DWORD flags,
  57                                                       LONG_PTR param, BOOL unicode );
  58 extern BOOL WINAPI Internal_EnumTimeFormats( TIMEFMT_ENUMPROCW proc, const NLS_LOCALE_DATA *locale,
  59                                              DWORD flags, BOOL unicode, BOOL ex, LPARAM lparam );
  60 extern BOOL WINAPI Internal_EnumUILanguages( UILANGUAGE_ENUMPROCW proc, DWORD flags,
  61                                              LONG_PTR param, BOOL unicode );
  62
  63 /***********************************************************************
  64  *              get_lcid_codepage
  65  *
  66  * Retrieve the ANSI codepage for a given locale.
  67  */
  68 static UINT get_lcid_codepage( LCID lcid, UINT flags )
  69 {
  70     UINT ret = 0;
  71
  72     if (flags & LOCALE_USE_CP_ACP) return CP_ACP;
  73     GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
  74                     (WCHAR *)&ret, sizeof(ret)/sizeof(WCHAR) );
  75     return ret;
  76 }
  77
  78
  79 /******************************************************************************
  80  *              SetLocaleInfoA  [KERNEL32.@]
  81  *
  82  * Set information about an aspect of a locale.
  83  *
  84  * PARAMS
  85  *  lcid   [I] LCID of the locale
  86  *  lctype [I] LCTYPE_ flags from "winnls.h"
  87  *  data   [I] Information to set
  88  *
  89  * RETURNS
  90  *  Success: TRUE. The information given will be returned by GetLocaleInfoA()
  91  *           whenever it is called without LOCALE_NOUSEROVERRIDE.
  92  *  Failure: FALSE. Use GetLastError() to determine the cause.
  93  *
  94  * NOTES
  95  *  - Values are only be set for the current user locale; the system locale
  96  *  settings cannot be changed.
  97  *  - Any settings changed by this call are lost when the locale is changed by
  98  *  the control panel (in Wine, this happens every time you change LANG).
  99  *  - The native implementation of this function does not check that lcid matches
 100  *  the current user locale, and simply sets the new values. Wine warns you in
 101  *  this case, but behaves the same.
 102  */
 103 BOOL WINAPI SetLocaleInfoA(LCID lcid, LCTYPE lctype, LPCSTR data)
 104 {
 105     UINT codepage = get_lcid_codepage( lcid, lctype );
 106     WCHAR *strW;
 107     DWORD len;
 108     BOOL ret;
 109
 110     if (!data)
 111     {
 112         SetLastError( ERROR_INVALID_PARAMETER );
 113         return FALSE;
 114     }
 115     len = MultiByteToWideChar( codepage, 0, data, -1, NULL, 0 );
 116     if (!(strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 117     {
 118         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 119         return FALSE;
 120     }
 121     MultiByteToWideChar( codepage, 0, data, -1, strW, len );
 122     ret = SetLocaleInfoW( lcid, lctype, strW );
 123     HeapFree( GetProcessHeap(), 0, strW );
 124     return ret;
 125 }
 126
 127
 128 /******************************************************************************
 129  *              SetCPGlobal   (KERNEL32.@)
 130  *
 131  * Set the current Ansi code page Id for the system.
 132  *
 133  * PARAMS
 134  *    acp [I] code page ID to be the new ACP.
 135  *
 136  * RETURNS
 137  *    The previous ACP.
 138  */
 139 UINT WINAPI SetCPGlobal( UINT acp )
 140 {
 141     FIXME( "not supported\n" );
 142     return GetACP();
 143 }
 144
 145
 146 /***********************************************************************
 147  *           GetCPInfoExA   (KERNEL32.@)
 148  *
 149  * Get extended information about a code page.
 150  *
 151  * PARAMS
 152  *  codepage [I] Code page number
 153  *  dwFlags  [I] Reserved, must to 0.
 154  *  cpinfo   [O] Destination for code page information
 155  *
 156  * RETURNS
 157  *  Success: TRUE. cpinfo is updated with the information about codepage.
 158  *  Failure: FALSE, if codepage is invalid or cpinfo is NULL.
 159  */
 160 BOOL WINAPI GetCPInfoExA( UINT codepage, DWORD dwFlags, LPCPINFOEXA cpinfo )
 161 {
 162     CPINFOEXW cpinfoW;
 163
 164     if (!GetCPInfoExW( codepage, dwFlags, &cpinfoW ))
 165       return FALSE;
 166
 167     /* the layout is the same except for CodePageName */
 168     memcpy(cpinfo, &cpinfoW, sizeof(CPINFOEXA));
 169     WideCharToMultiByte(CP_ACP, 0, cpinfoW.CodePageName, -1, cpinfo->CodePageName, sizeof(cpinfo->CodePageName), NULL, NULL);
 170     return TRUE;
 171 }
 172
 173
 174 /*********************************************************************
 175  *              GetDaylightFlag   (KERNEL32.@)
 176  */
 177 BOOL WINAPI GetDaylightFlag(void)
 178 {
 179     TIME_ZONE_INFORMATION tzinfo;
 180     return GetTimeZoneInformation( &tzinfo) == TIME_ZONE_ID_DAYLIGHT;
 181 }
 182
 183
 184 /***********************************************************************
 185  *              EnumSystemCodePagesA   (KERNEL32.@)
 186  */
 187 BOOL WINAPI EnumSystemCodePagesA( CODEPAGE_ENUMPROCA proc, DWORD flags )
 188 {
 189     return Internal_EnumSystemCodePages( (CODEPAGE_ENUMPROCW)proc, flags, FALSE );
 190 }
 191
 192
 193 /******************************************************************************
 194  *           GetStringTypeExA    (KERNEL32.@)
 195  *
 196  * Get characteristics of the characters making up a string.
 197  *
 198  * PARAMS
 199  *  locale   [I] Locale Id for the string
 200  *  type     [I] CT_CTYPE1 = classification, CT_CTYPE2 = directionality, CT_CTYPE3 = typographic info
 201  *  src      [I] String to analyse
 202  *  count    [I] Length of src in chars, or -1 if src is NUL terminated
 203  *  chartype [O] Destination for the calculated characteristics
 204  *
 205  * RETURNS
 206  *  Success: TRUE. chartype is filled with the requested characteristics of each char
 207  *           in src.
 208  *  Failure: FALSE. Use GetLastError() to determine the cause.
 209  */
 210 BOOL WINAPI GetStringTypeExA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
 211 {
 212     return GetStringTypeA(locale, type, src, count, chartype);
 213 }
 214
 215 /*************************************************************************
 216  *           FoldStringA    (KERNEL32.@)
 217  *
 218  * Map characters in a string.
 219  *
 220  * PARAMS
 221  *  dwFlags [I] Flags controlling chars to map (MAP_ constants from "winnls.h")
 222  *  src     [I] String to map
 223  *  srclen  [I] Length of src, or -1 if src is NUL terminated
 224  *  dst     [O] Destination for mapped string
 225  *  dstlen  [I] Length of dst, or 0 to find the required length for the mapped string
 226  *
 227  * RETURNS
 228  *  Success: The length of the string written to dst, including the terminating NUL. If
 229  *           dstlen is 0, the value returned is the same, but nothing is written to dst,
 230  *           and dst may be NULL.
 231  *  Failure: 0. Use GetLastError() to determine the cause.
 232  */
 233 INT WINAPI FoldStringA(DWORD dwFlags, LPCSTR src, INT srclen,
 234                        LPSTR dst, INT dstlen)
 235 {
 236     INT ret = 0, srclenW = 0;
 237     WCHAR *srcW = NULL, *dstW = NULL;
 238
 239     if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
 240     {
 241         SetLastError(ERROR_INVALID_PARAMETER);
 242         return 0;
 243     }
 244
 245     srclenW = MultiByteToWideChar(CP_ACP, 0, src, srclen, NULL, 0);
 246     srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
 247
 248     if (!srcW)
 249     {
 250         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 251         goto FoldStringA_exit;
 252     }
 253
 254     MultiByteToWideChar(CP_ACP, 0, src, srclen, srcW, srclenW);
 255
 256     ret = FoldStringW(dwFlags, srcW, srclenW, NULL, 0);
 257     if (ret && dstlen)
 258     {
 259         dstW = HeapAlloc(GetProcessHeap(), 0, ret * sizeof(WCHAR));
 260
 261         if (!dstW)
 262         {
 263             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 264             goto FoldStringA_exit;
 265         }
 266
 267         ret = FoldStringW(dwFlags, srcW, srclenW, dstW, ret);
 268         if (!WideCharToMultiByte(CP_ACP, 0, dstW, ret, dst, dstlen, NULL, NULL))
 269         {
 270             ret = 0;
 271             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 272         }
 273     }
 274
 275     HeapFree(GetProcessHeap(), 0, dstW);
 276
 277 FoldStringA_exit:
 278     HeapFree(GetProcessHeap(), 0, srcW);
 279     return ret;
 280 }
 281
 282 /******************************************************************************
 283  *           EnumSystemLanguageGroupsA    (KERNEL32.@)
 284  */
 285 BOOL WINAPI EnumSystemLanguageGroupsA( LANGUAGEGROUP_ENUMPROCA proc, DWORD flags, LONG_PTR param )
 286 {
 287     return Internal_EnumSystemLanguageGroups( (LANGUAGEGROUP_ENUMPROCW)proc, flags, param, FALSE );
 288 }
 289
 290 /******************************************************************************
 291  *           EnumLanguageGroupLocalesA    (KERNEL32.@)
 292  */
 293 BOOL WINAPI EnumLanguageGroupLocalesA( LANGGROUPLOCALE_ENUMPROCA proc, LGRPID id,
 294                                        DWORD flags, LONG_PTR param )
 295 {
 296     return Internal_EnumLanguageGroupLocales( (LANGGROUPLOCALE_ENUMPROCW)proc, id, flags, param, FALSE );
 297 }
 298
 299 /******************************************************************************
 300  *              EnumCalendarInfoA       [KERNEL32.@]
 301  */
 302 BOOL WINAPI EnumCalendarInfoA( CALINFO_ENUMPROCA proc, LCID lcid, CALID id, CALTYPE type )
 303 {
 304     return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, NlsValidateLocale( &lcid, 0 ),
 305                                       id, type, FALSE, FALSE, FALSE, 0 );
 306 }
 307
 308 /******************************************************************************
 309  *              EnumCalendarInfoExA     [KERNEL32.@]
 310  */
 311 BOOL WINAPI EnumCalendarInfoExA( CALINFO_ENUMPROCEXA proc, LCID lcid, CALID id, CALTYPE type )
 312 {
 313     return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, NlsValidateLocale( &lcid, 0 ),
 314                                       id, type, FALSE, TRUE, FALSE, 0 );
 315 }
 316
 317 /**************************************************************************
 318  *              EnumDateFormatsExA    (KERNEL32.@)
 319  *
 320  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
 321  * LOCALE_NOUSEROVERRIDE here as well?
 322  */
 323 BOOL WINAPI EnumDateFormatsExA(DATEFMT_ENUMPROCEXA proc, LCID lcid, DWORD flags)
 324 {
 325     return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, NlsValidateLocale( &lcid, 0 ),
 326                                      flags, FALSE, TRUE, FALSE, 0 );
 327 }
 328
 329 /**************************************************************************
 330  *              EnumDateFormatsA        (KERNEL32.@)
 331  *
 332  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
 333  * LOCALE_NOUSEROVERRIDE here as well?
 334  */
 335 BOOL WINAPI EnumDateFormatsA(DATEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
 336 {
 337     return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, NlsValidateLocale( &lcid, 0 ),
 338                                      flags, FALSE, FALSE, FALSE, 0 );
 339 }
 340
 341 /**************************************************************************
 342  *              EnumTimeFormatsA        (KERNEL32.@)
 343  *
 344  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
 345  * LOCALE_NOUSEROVERRIDE here as well?
 346  */
 347 BOOL WINAPI EnumTimeFormatsA( TIMEFMT_ENUMPROCA proc, LCID lcid, DWORD flags )
 348 {
 349     /* EnumTimeFormatsA doesn't support flags, EnumTimeFormatsW does. */
 350     if (flags & ~LOCALE_USE_CP_ACP)
 351     {
 352         SetLastError(ERROR_INVALID_FLAGS);
 353         return FALSE;
 354     }
 355     return Internal_EnumTimeFormats( (TIMEFMT_ENUMPROCW)proc, NlsValidateLocale( &lcid, 0 ),
 356                                      flags, FALSE, FALSE, 0 );
 357 }
 358
 359 /******************************************************************************
 360  *           InvalidateNLSCache           (KERNEL32.@)
 361  *
 362  * Invalidate the cache of NLS values.
 363  *
 364  * PARAMS
 365  *  None.
 366  *
 367  * RETURNS
 368  *  Success: TRUE.
 369  *  Failure: FALSE.
 370  */
 371 BOOL WINAPI InvalidateNLSCache(void)
 372 {
 373   FIXME("() stub\n");
 374   return FALSE;
 375 }
 376
 377 /******************************************************************************
 378  *           EnumUILanguagesA (KERNEL32.@)
 379  */
 380 BOOL WINAPI EnumUILanguagesA( UILANGUAGE_ENUMPROCA proc, DWORD flags, LONG_PTR param )
 381 {
 382     return Internal_EnumUILanguages( (UILANGUAGE_ENUMPROCW)proc, flags, param, FALSE );
 383 }
 384
 385
 386 /*********************************************************************
 387  *            GetCalendarInfoA (KERNEL32.@)
 388  */
 389 int WINAPI GetCalendarInfoA( LCID lcid, CALID id, CALTYPE type, LPSTR data, int data_len, DWORD *val )
 390 {
 391     WCHAR buffer[256];
 392
 393     if (type & CAL_RETURN_NUMBER)
 394         return GetCalendarInfoW( lcid, id, type, (WCHAR *)data, data_len, val ) * sizeof(WCHAR);
 395
 396     if (!GetCalendarInfoW( lcid, id, type, buffer, ARRAY_SIZE(buffer), val )) return 0;
 397     return WideCharToMultiByte( get_lcid_codepage(lcid, type), 0, buffer, -1, data, data_len, NULL, NULL );
 398 }
 399
 400
 401 /*********************************************************************
 402  *            SetCalendarInfoA (KERNEL32.@)
 403  */
 404 int WINAPI SetCalendarInfoA( LCID lcid, CALID id, CALTYPE type, LPCSTR data )
 405 {
 406     WCHAR buffer[256];
 407
 408     if (!MultiByteToWideChar( get_lcid_codepage(lcid, type), 0, data, -1, buffer, ARRAY_SIZE(buffer) ))
 409         return 0;
 410     return SetCalendarInfoW( lcid, id, type, buffer );
 411 }
 412
 413
 414 /**************************************************************************
 415  *           GetNumberFormatA (KERNEL32.@)
 416  */
 417 int WINAPI GetNumberFormatA( LCID lcid, DWORD flags, const char *value,
 418                              const NUMBERFMTA *format, char *buffer, int len )
 419 {
 420     UINT cp = get_lcid_codepage( lcid, flags );
 421     WCHAR input[128], output[128];
 422     int ret;
 423
 424     TRACE( "(0x%04lx,0x%08lx,%s,%p,%p,%d)\n", lcid, flags, debugstr_a(value), format, buffer, len );
 425
 426     if (len < 0 || (len && !buffer) || !value)
 427     {
 428         SetLastError( ERROR_INVALID_PARAMETER );
 429         return 0;
 430     }
 431     MultiByteToWideChar( cp, 0, value, -1, input, ARRAY_SIZE(input) );
 432
 433     if (format)
 434     {
 435         NUMBERFMTW fmt;
 436         WCHAR fmt_decimal[4], fmt_thousand[4];
 437
 438         if (flags & LOCALE_NOUSEROVERRIDE)
 439         {
 440             SetLastError( ERROR_INVALID_FLAGS );
 441             return 0;
 442         }
 443         if (!format->lpDecimalSep || !format->lpThousandSep)
 444         {
 445             SetLastError( ERROR_INVALID_PARAMETER );
 446             return 0;
 447         }
 448         MultiByteToWideChar( cp, 0, format->lpDecimalSep, -1, fmt_decimal, ARRAY_SIZE(fmt_decimal) );
 449         MultiByteToWideChar( cp, 0, format->lpThousandSep, -1, fmt_thousand, ARRAY_SIZE(fmt_thousand) );
 450         fmt.NumDigits     = format->NumDigits;
 451         fmt.LeadingZero   = format->LeadingZero;
 452         fmt.Grouping      = format->Grouping;
 453         fmt.NegativeOrder = format->NegativeOrder;
 454         fmt.lpDecimalSep  = fmt_decimal;
 455         fmt.lpThousandSep = fmt_thousand;
 456         ret = GetNumberFormatW( lcid, flags, input, &fmt, output, ARRAY_SIZE(output) );
 457     }
 458     else ret = GetNumberFormatW( lcid, flags, input, NULL, output, ARRAY_SIZE(output) );
 459
 460     if (ret) ret = WideCharToMultiByte( cp, 0, output, -1, buffer, len, 0, 0 );
 461     return ret;
 462 }
 463
 464
 465 /**************************************************************************
 466  *           GetCurrencyFormatA (KERNEL32.@)
 467  */
 468 int WINAPI GetCurrencyFormatA( LCID lcid, DWORD flags, const char *value,
 469                                const CURRENCYFMTA *format, char *buffer, int len )
 470 {
 471     UINT cp = get_lcid_codepage( lcid, flags );
 472     WCHAR input[128], output[128];
 473     int ret;
 474
 475     TRACE( "(0x%04lx,0x%08lx,%s,%p,%p,%d)\n", lcid, flags, debugstr_a(value), format, buffer, len );
 476
 477     if (len < 0 || (len && !buffer) || !value)
 478     {
 479         SetLastError( ERROR_INVALID_PARAMETER );
 480         return 0;
 481     }
 482     MultiByteToWideChar( cp, 0, value, -1, input, ARRAY_SIZE(input) );
 483
 484     if (format)
 485     {
 486         CURRENCYFMTW fmt;
 487         WCHAR fmt_decimal[4], fmt_thousand[4], fmt_symbol[13];
 488
 489         if (flags & LOCALE_NOUSEROVERRIDE)
 490         {
 491             SetLastError( ERROR_INVALID_FLAGS );
 492             return 0;
 493         }
 494         if (!format->lpDecimalSep || !format->lpThousandSep || !format->lpCurrencySymbol)
 495         {
 496             SetLastError( ERROR_INVALID_PARAMETER );
 497             return 0;
 498         }
 499         MultiByteToWideChar( cp, 0, format->lpDecimalSep, -1, fmt_decimal, ARRAY_SIZE(fmt_decimal) );
 500         MultiByteToWideChar( cp, 0, format->lpThousandSep, -1, fmt_thousand, ARRAY_SIZE(fmt_thousand) );
 501         MultiByteToWideChar( cp, 0, format->lpCurrencySymbol, -1, fmt_symbol, ARRAY_SIZE(fmt_symbol) );
 502         fmt.NumDigits = format->NumDigits;
 503         fmt.LeadingZero = format->LeadingZero;
 504         fmt.Grouping = format->Grouping;
 505         fmt.NegativeOrder = format->NegativeOrder;
 506         fmt.PositiveOrder = format->PositiveOrder;
 507         fmt.lpDecimalSep = fmt_decimal;
 508         fmt.lpThousandSep = fmt_thousand;
 509         fmt.lpCurrencySymbol = fmt_symbol;
 510         ret = GetCurrencyFormatW( lcid, flags, input, &fmt, output, ARRAY_SIZE(output) );
 511     }
 512     else ret = GetCurrencyFormatW( lcid, flags, input, NULL, output, ARRAY_SIZE(output) );
 513
 514     if (ret) ret = WideCharToMultiByte( cp, 0, output, -1, buffer, len, 0, 0 );
 515     return ret;
 516 }
 517
 518
 519 /******************************************************************************
 520  *           GetGeoInfoA (KERNEL32.@)
 521  */
 522 INT WINAPI GetGeoInfoA(GEOID geoid, GEOTYPE geotype, LPSTR data, int data_len, LANGID lang)
 523 {
 524     WCHAR buffer[256];
 525
 526     TRACE("%ld %ld %p %d %d\n", geoid, geotype, data, data_len, lang);
 527
 528     if (!GetGeoInfoW( geoid, geotype, buffer, ARRAY_SIZE(buffer), lang )) return 0;
 529     return WideCharToMultiByte( CP_ACP, 0, buffer, -1, data, data_len, NULL, NULL );
 530 }