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/heap.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(nls);
  45
  46 extern BOOL WINAPI Internal_EnumCalendarInfo( CALINFO_ENUMPROCW proc, LCID lcid, CALID id,
  47                                               CALTYPE type, BOOL unicode, BOOL ex,
  48                                               BOOL exex, LPARAM lparam );
  49 extern BOOL WINAPI Internal_EnumDateFormats( DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags, BOOL unicode,
  50                                              BOOL ex, BOOL exex, LPARAM lparam );
  51 extern BOOL WINAPI Internal_EnumLanguageGroupLocales( LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id,
  52                                                       DWORD flags, LONG_PTR param, BOOL unicode );
  53 extern BOOL WINAPI Internal_EnumSystemCodePages( CODEPAGE_ENUMPROCW proc, DWORD flags, BOOL unicode );
  54 extern BOOL WINAPI Internal_EnumSystemLanguageGroups( LANGUAGEGROUP_ENUMPROCW proc, DWORD flags,
  55                                                       LONG_PTR param, BOOL unicode );
  56 extern BOOL WINAPI Internal_EnumTimeFormats( TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags,
  57                                              BOOL unicode, BOOL ex, LPARAM lparam );
  58 extern BOOL WINAPI Internal_EnumUILanguages( UILANGUAGE_ENUMPROCW proc, DWORD flags,
  59                                              LONG_PTR param, BOOL unicode );
  60
  61 /***********************************************************************
  62  *              get_lcid_codepage
  63  *
  64  * Retrieve the ANSI codepage for a given locale.
  65  */
  66 static inline UINT get_lcid_codepage( LCID lcid )
  67 {
  68     UINT ret;
  69     if (!GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER, (WCHAR *)&ret,
  70                          sizeof(ret)/sizeof(WCHAR) )) ret = 0;
  71     return ret;
  72 }
  73
  74
  75 /******************************************************************************
  76  *              SetLocaleInfoA  [KERNEL32.@]
  77  *
  78  * Set information about an aspect of a locale.
  79  *
  80  * PARAMS
  81  *  lcid   [I] LCID of the locale
  82  *  lctype [I] LCTYPE_ flags from "winnls.h"
  83  *  data   [I] Information to set
  84  *
  85  * RETURNS
  86  *  Success: TRUE. The information given will be returned by GetLocaleInfoA()
  87  *           whenever it is called without LOCALE_NOUSEROVERRIDE.
  88  *  Failure: FALSE. Use GetLastError() to determine the cause.
  89  *
  90  * NOTES
  91  *  - Values are only be set for the current user locale; the system locale
  92  *  settings cannot be changed.
  93  *  - Any settings changed by this call are lost when the locale is changed by
  94  *  the control panel (in Wine, this happens every time you change LANG).
  95  *  - The native implementation of this function does not check that lcid matches
  96  *  the current user locale, and simply sets the new values. Wine warns you in
  97  *  this case, but behaves the same.
  98  */
  99 BOOL WINAPI SetLocaleInfoA(LCID lcid, LCTYPE lctype, LPCSTR data)
 100 {
 101     UINT codepage = CP_ACP;
 102     WCHAR *strW;
 103     DWORD len;
 104     BOOL ret;
 105
 106     if (!(lctype & LOCALE_USE_CP_ACP)) codepage = get_lcid_codepage( lcid );
 107
 108     if (!data)
 109     {
 110         SetLastError( ERROR_INVALID_PARAMETER );
 111         return FALSE;
 112     }
 113     len = MultiByteToWideChar( codepage, 0, data, -1, NULL, 0 );
 114     if (!(strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 115     {
 116         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 117         return FALSE;
 118     }
 119     MultiByteToWideChar( codepage, 0, data, -1, strW, len );
 120     ret = SetLocaleInfoW( lcid, lctype, strW );
 121     HeapFree( GetProcessHeap(), 0, strW );
 122     return ret;
 123 }
 124
 125
 126 /******************************************************************************
 127  *              SetCPGlobal   (KERNEL32.@)
 128  *
 129  * Set the current Ansi code page Id for the system.
 130  *
 131  * PARAMS
 132  *    acp [I] code page ID to be the new ACP.
 133  *
 134  * RETURNS
 135  *    The previous ACP.
 136  */
 137 UINT WINAPI SetCPGlobal( UINT acp )
 138 {
 139     FIXME( "not supported\n" );
 140     return GetACP();
 141 }
 142
 143
 144 /***********************************************************************
 145  *           GetCPInfoExA   (KERNEL32.@)
 146  *
 147  * Get extended information about a code page.
 148  *
 149  * PARAMS
 150  *  codepage [I] Code page number
 151  *  dwFlags  [I] Reserved, must to 0.
 152  *  cpinfo   [O] Destination for code page information
 153  *
 154  * RETURNS
 155  *  Success: TRUE. cpinfo is updated with the information about codepage.
 156  *  Failure: FALSE, if codepage is invalid or cpinfo is NULL.
 157  */
 158 BOOL WINAPI GetCPInfoExA( UINT codepage, DWORD dwFlags, LPCPINFOEXA cpinfo )
 159 {
 160     CPINFOEXW cpinfoW;
 161
 162     if (!GetCPInfoExW( codepage, dwFlags, &cpinfoW ))
 163       return FALSE;
 164
 165     /* the layout is the same except for CodePageName */
 166     memcpy(cpinfo, &cpinfoW, sizeof(CPINFOEXA));
 167     WideCharToMultiByte(CP_ACP, 0, cpinfoW.CodePageName, -1, cpinfo->CodePageName, sizeof(cpinfo->CodePageName), NULL, NULL);
 168     return TRUE;
 169 }
 170
 171
 172 /*********************************************************************
 173  *              GetDaylightFlag   (KERNEL32.@)
 174  */
 175 BOOL WINAPI GetDaylightFlag(void)
 176 {
 177     TIME_ZONE_INFORMATION tzinfo;
 178     return GetTimeZoneInformation( &tzinfo) == TIME_ZONE_ID_DAYLIGHT;
 179 }
 180
 181
 182 /***********************************************************************
 183  *              EnumSystemCodePagesA   (KERNEL32.@)
 184  */
 185 BOOL WINAPI EnumSystemCodePagesA( CODEPAGE_ENUMPROCA proc, DWORD flags )
 186 {
 187     return Internal_EnumSystemCodePages( (CODEPAGE_ENUMPROCW)proc, flags, FALSE );
 188 }
 189
 190
 191 /******************************************************************************
 192  *           GetStringTypeExA    (KERNEL32.@)
 193  *
 194  * Get characteristics of the characters making up a string.
 195  *
 196  * PARAMS
 197  *  locale   [I] Locale Id for the string
 198  *  type     [I] CT_CTYPE1 = classification, CT_CTYPE2 = directionality, CT_CTYPE3 = typographic info
 199  *  src      [I] String to analyse
 200  *  count    [I] Length of src in chars, or -1 if src is NUL terminated
 201  *  chartype [O] Destination for the calculated characteristics
 202  *
 203  * RETURNS
 204  *  Success: TRUE. chartype is filled with the requested characteristics of each char
 205  *           in src.
 206  *  Failure: FALSE. Use GetLastError() to determine the cause.
 207  */
 208 BOOL WINAPI GetStringTypeExA( LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype )
 209 {
 210     return GetStringTypeA(locale, type, src, count, chartype);
 211 }
 212
 213 /*************************************************************************
 214  *           FoldStringA    (KERNEL32.@)
 215  *
 216  * Map characters in a string.
 217  *
 218  * PARAMS
 219  *  dwFlags [I] Flags controlling chars to map (MAP_ constants from "winnls.h")
 220  *  src     [I] String to map
 221  *  srclen  [I] Length of src, or -1 if src is NUL terminated
 222  *  dst     [O] Destination for mapped string
 223  *  dstlen  [I] Length of dst, or 0 to find the required length for the mapped string
 224  *
 225  * RETURNS
 226  *  Success: The length of the string written to dst, including the terminating NUL. If
 227  *           dstlen is 0, the value returned is the same, but nothing is written to dst,
 228  *           and dst may be NULL.
 229  *  Failure: 0. Use GetLastError() to determine the cause.
 230  */
 231 INT WINAPI FoldStringA(DWORD dwFlags, LPCSTR src, INT srclen,
 232                        LPSTR dst, INT dstlen)
 233 {
 234     INT ret = 0, srclenW = 0;
 235     WCHAR *srcW = NULL, *dstW = NULL;
 236
 237     if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
 238     {
 239         SetLastError(ERROR_INVALID_PARAMETER);
 240         return 0;
 241     }
 242
 243     srclenW = MultiByteToWideChar(CP_ACP, 0, src, srclen, NULL, 0);
 244     srcW = HeapAlloc(GetProcessHeap(), 0, srclenW * sizeof(WCHAR));
 245
 246     if (!srcW)
 247     {
 248         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 249         goto FoldStringA_exit;
 250     }
 251
 252     MultiByteToWideChar(CP_ACP, 0, src, srclen, srcW, srclenW);
 253
 254     ret = FoldStringW(dwFlags, srcW, srclenW, NULL, 0);
 255     if (ret && dstlen)
 256     {
 257         dstW = HeapAlloc(GetProcessHeap(), 0, ret * sizeof(WCHAR));
 258
 259         if (!dstW)
 260         {
 261             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 262             goto FoldStringA_exit;
 263         }
 264
 265         ret = FoldStringW(dwFlags, srcW, srclenW, dstW, ret);
 266         if (!WideCharToMultiByte(CP_ACP, 0, dstW, ret, dst, dstlen, NULL, NULL))
 267         {
 268             ret = 0;
 269             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 270         }
 271     }
 272
 273     HeapFree(GetProcessHeap(), 0, dstW);
 274
 275 FoldStringA_exit:
 276     HeapFree(GetProcessHeap(), 0, srcW);
 277     return ret;
 278 }
 279
 280 /******************************************************************************
 281  *           EnumSystemLanguageGroupsA    (KERNEL32.@)
 282  */
 283 BOOL WINAPI EnumSystemLanguageGroupsA( LANGUAGEGROUP_ENUMPROCA proc, DWORD flags, LONG_PTR param )
 284 {
 285     return Internal_EnumSystemLanguageGroups( (LANGUAGEGROUP_ENUMPROCW)proc, flags, param, FALSE );
 286 }
 287
 288 /******************************************************************************
 289  *           EnumLanguageGroupLocalesA    (KERNEL32.@)
 290  */
 291 BOOL WINAPI EnumLanguageGroupLocalesA( LANGGROUPLOCALE_ENUMPROCA proc, LGRPID id,
 292                                        DWORD flags, LONG_PTR param )
 293 {
 294     return Internal_EnumLanguageGroupLocales( (LANGGROUPLOCALE_ENUMPROCW)proc, id, flags, param, FALSE );
 295 }
 296
 297 /******************************************************************************
 298  *              EnumCalendarInfoA       [KERNEL32.@]
 299  */
 300 BOOL WINAPI EnumCalendarInfoA( CALINFO_ENUMPROCA proc, LCID lcid, CALID id, CALTYPE type )
 301 {
 302     return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, lcid, id, type, FALSE, FALSE, FALSE, 0 );
 303 }
 304
 305 /******************************************************************************
 306  *              EnumCalendarInfoExA     [KERNEL32.@]
 307  */
 308 BOOL WINAPI EnumCalendarInfoExA( CALINFO_ENUMPROCEXA proc, LCID lcid, CALID id, CALTYPE type )
 309 {
 310     return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, lcid, id, type, FALSE, TRUE, FALSE, 0 );
 311 }
 312
 313 /**************************************************************************
 314  *              EnumDateFormatsExA    (KERNEL32.@)
 315  *
 316  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
 317  * LOCALE_NOUSEROVERRIDE here as well?
 318  */
 319 BOOL WINAPI EnumDateFormatsExA(DATEFMT_ENUMPROCEXA proc, LCID lcid, DWORD flags)
 320 {
 321     return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, lcid, flags, FALSE, TRUE, FALSE, 0 );
 322 }
 323
 324 /**************************************************************************
 325  *              EnumDateFormatsA        (KERNEL32.@)
 326  *
 327  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
 328  * LOCALE_NOUSEROVERRIDE here as well?
 329  */
 330 BOOL WINAPI EnumDateFormatsA(DATEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
 331 {
 332     return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, lcid, flags, FALSE, FALSE, FALSE, 0 );
 333 }
 334
 335 /**************************************************************************
 336  *              EnumTimeFormatsA        (KERNEL32.@)
 337  *
 338  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
 339  * LOCALE_NOUSEROVERRIDE here as well?
 340  */
 341 BOOL WINAPI EnumTimeFormatsA( TIMEFMT_ENUMPROCA proc, LCID lcid, DWORD flags )
 342 {
 343     /* EnumTimeFormatsA doesn't support flags, EnumTimeFormatsW does. */
 344     if (flags & ~LOCALE_USE_CP_ACP)
 345     {
 346         SetLastError(ERROR_INVALID_FLAGS);
 347         return FALSE;
 348     }
 349     return Internal_EnumTimeFormats( (TIMEFMT_ENUMPROCW)proc, lcid, flags, FALSE, FALSE, 0 );
 350 }
 351
 352 /******************************************************************************
 353  *           InvalidateNLSCache           (KERNEL32.@)
 354  *
 355  * Invalidate the cache of NLS values.
 356  *
 357  * PARAMS
 358  *  None.
 359  *
 360  * RETURNS
 361  *  Success: TRUE.
 362  *  Failure: FALSE.
 363  */
 364 BOOL WINAPI InvalidateNLSCache(void)
 365 {
 366   FIXME("() stub\n");
 367   return FALSE;
 368 }
 369
 370 /******************************************************************************
 371  *           EnumUILanguagesA (KERNEL32.@)
 372  */
 373 BOOL WINAPI EnumUILanguagesA( UILANGUAGE_ENUMPROCA proc, DWORD flags, LONG_PTR param )
 374 {
 375     return Internal_EnumUILanguages( (UILANGUAGE_ENUMPROCW)proc, flags, param, FALSE );
 376 }
 377
 378
 379 /******************************************************************************
 380  *           GetGeoInfoA (KERNEL32.@)
 381  */
 382 INT WINAPI GetGeoInfoA(GEOID geoid, GEOTYPE geotype, LPSTR data, int data_len, LANGID lang)
 383 {
 384     WCHAR *buffW;
 385     INT len;
 386
 387     TRACE("%d %d %p %d %d\n", geoid, geotype, data, data_len, lang);
 388
 389     len = GetGeoInfoW(geoid, geotype, NULL, 0, lang);
 390     if (!len)
 391         return 0;
 392
 393     buffW = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 394     if (!buffW)
 395         return 0;
 396
 397     GetGeoInfoW(geoid, geotype, buffW, len, lang);
 398     len = WideCharToMultiByte(CP_ACP, 0, buffW, -1, NULL, 0, NULL, NULL);
 399     if (!data || !data_len) {
 400         HeapFree(GetProcessHeap(), 0, buffW);
 401         return len;
 402     }
 403
 404     len = WideCharToMultiByte(CP_ACP, 0, buffW, -1, data, data_len, NULL, NULL);
 405     HeapFree(GetProcessHeap(), 0, buffW);
 406
 407     if (data_len < len)
 408         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 409     return data_len < len ? 0 : len;
 410 }