git.oblomov.eu Git - wine/blob - dlls/kernel32/lcformat.c

   1 /*
   2  * Locale-dependent format handling
   3  *
   4  * Copyright 1995 Martin von Loewis
   5  * Copyright 1998 David Lee Lambert
   6  * Copyright 2000 Julio César Gázquez
   7  * Copyright 2003 Jon Griffiths
   8  * Copyright 2005 Dmitry Timoshkov
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <string.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "wine/unicode.h"
  36 #include "wine/debug.h"
  37 #include "winternl.h"
  38
  39 #include "kernel_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(nls);
  42
  43 #define DATE_DATEVARSONLY 0x0100  /* only date stuff: yMdg */
  44 #define TIME_TIMEVARSONLY 0x0200  /* only time stuff: hHmst */
  45
  46 /* Since calculating the formatting data for each locale is time-consuming,
  47  * we get the format data for each locale only once and cache it in memory.
  48  * We cache both the system default and user overridden data, after converting
  49  * them into the formats that the functions here expect. Since these functions
  50  * will typically be called with only a small number of the total locales
  51  * installed, the memory overhead is minimal while the speedup is significant.
  52  *
  53  * Our cache takes the form of a singly linked list, whose node is below:
  54  */
  55 #define NLS_NUM_CACHED_STRINGS 45
  56
  57 typedef struct _NLS_FORMAT_NODE
  58 {
  59   LCID  lcid;         /* Locale Id */
  60   DWORD dwFlags;      /* 0 or LOCALE_NOUSEROVERRIDE */
  61   DWORD dwCodePage;   /* Default code page (if LOCALE_USE_ANSI_CP not given) */
  62   NUMBERFMTW   fmt;   /* Default format for numbers */
  63   CURRENCYFMTW cyfmt; /* Default format for currencies */
  64   LPWSTR lppszStrings[NLS_NUM_CACHED_STRINGS]; /* Default formats,day/month names */
  65   WCHAR szShortAM[2]; /* Short 'AM' marker */
  66   WCHAR szShortPM[2]; /* Short 'PM' marker */
  67   struct _NLS_FORMAT_NODE *next;
  68 } NLS_FORMAT_NODE;
  69
  70 /* Macros to get particular data strings from a format node */
  71 #define GetNegative(fmt)  fmt->lppszStrings[0]
  72 #define GetLongDate(fmt)  fmt->lppszStrings[1]
  73 #define GetShortDate(fmt) fmt->lppszStrings[2]
  74 #define GetTime(fmt)      fmt->lppszStrings[3]
  75 #define GetAM(fmt)        fmt->lppszStrings[42]
  76 #define GetPM(fmt)        fmt->lppszStrings[43]
  77 #define GetYearMonth(fmt) fmt->lppszStrings[44]
  78
  79 #define GetLongDay(fmt,day)    fmt->lppszStrings[4 + day]
  80 #define GetShortDay(fmt,day)   fmt->lppszStrings[11 + day]
  81 #define GetLongMonth(fmt,mth)  fmt->lppszStrings[18 + mth]
  82 #define GetShortMonth(fmt,mth) fmt->lppszStrings[30 + mth]
  83
  84 /* Write access to the cache is protected by this critical section */
  85 static CRITICAL_SECTION NLS_FormatsCS;
  86 static CRITICAL_SECTION_DEBUG NLS_FormatsCS_debug =
  87 {
  88     0, 0, &NLS_FormatsCS,
  89     { &NLS_FormatsCS_debug.ProcessLocksList,
  90       &NLS_FormatsCS_debug.ProcessLocksList },
  91       0, 0, { (DWORD_PTR)(__FILE__ ": NLS_Formats") }
  92 };
  93 static CRITICAL_SECTION NLS_FormatsCS = { &NLS_FormatsCS_debug, -1, 0, 0, 0, 0 };
  94
  95 /**************************************************************************
  96  * NLS_GetLocaleNumber <internal>
  97  *
  98  * Get a numeric locale format value.
  99  */
 100 static DWORD NLS_GetLocaleNumber(LCID lcid, DWORD dwFlags)
 101 {
 102   WCHAR szBuff[80];
 103   DWORD dwVal = 0;
 104
 105   szBuff[0] = '\0';
 106   GetLocaleInfoW(lcid, dwFlags, szBuff, sizeof(szBuff) / sizeof(WCHAR));
 107
 108   if (szBuff[0] && szBuff[1] == ';' && szBuff[2] != '0')
 109     dwVal = (szBuff[0] - '0') * 10 + (szBuff[2] - '0');
 110   else
 111   {
 112     const WCHAR* iter = szBuff;
 113     dwVal = 0;
 114     while(*iter >= '0' && *iter <= '9')
 115       dwVal = dwVal * 10 + (*iter++ - '0');
 116   }
 117   return dwVal;
 118 }
 119
 120 /**************************************************************************
 121  * NLS_GetLocaleString <internal>
 122  *
 123  * Get a string locale format value.
 124  */
 125 static WCHAR* NLS_GetLocaleString(LCID lcid, DWORD dwFlags)
 126 {
 127   WCHAR szBuff[80], *str;
 128   DWORD dwLen;
 129
 130   szBuff[0] = '\0';
 131   GetLocaleInfoW(lcid, dwFlags, szBuff, sizeof(szBuff) / sizeof(WCHAR));
 132   dwLen = strlenW(szBuff) + 1;
 133   str = HeapAlloc(GetProcessHeap(), 0, dwLen * sizeof(WCHAR));
 134   if (str)
 135     memcpy(str, szBuff, dwLen * sizeof(WCHAR));
 136   return str;
 137 }
 138
 139 #define GET_LOCALE_NUMBER(num, type) num = NLS_GetLocaleNumber(lcid, type|dwFlags); \
 140   TRACE( #type ": %d (%08x)\n", (DWORD)num, (DWORD)num)
 141
 142 #define GET_LOCALE_STRING(str, type) str = NLS_GetLocaleString(lcid, type|dwFlags); \
 143   TRACE( #type ": '%s'\n", debugstr_w(str))
 144
 145 /**************************************************************************
 146  * NLS_GetFormats <internal>
 147  *
 148  * Calculate (and cache) the number formats for a locale.
 149  */
 150 static const NLS_FORMAT_NODE *NLS_GetFormats(LCID lcid, DWORD dwFlags)
 151 {
 152   /* GetLocaleInfo() identifiers for cached formatting strings */
 153   static const USHORT NLS_LocaleIndices[] = {
 154     LOCALE_SNEGATIVESIGN,
 155     LOCALE_SLONGDATE,   LOCALE_SSHORTDATE,
 156     LOCALE_STIMEFORMAT,
 157     LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3,
 158     LOCALE_SDAYNAME4, LOCALE_SDAYNAME5, LOCALE_SDAYNAME6, LOCALE_SDAYNAME7,
 159     LOCALE_SABBREVDAYNAME1, LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3,
 160     LOCALE_SABBREVDAYNAME4, LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6,
 161     LOCALE_SABBREVDAYNAME7,
 162     LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3,
 163     LOCALE_SMONTHNAME4, LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6,
 164     LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8, LOCALE_SMONTHNAME9,
 165     LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12,
 166     LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2, LOCALE_SABBREVMONTHNAME3,
 167     LOCALE_SABBREVMONTHNAME4, LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
 168     LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8, LOCALE_SABBREVMONTHNAME9,
 169     LOCALE_SABBREVMONTHNAME10, LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12,
 170     LOCALE_S1159, LOCALE_S2359,
 171     LOCALE_SYEARMONTH
 172   };
 173   static NLS_FORMAT_NODE *NLS_CachedFormats = NULL;
 174   NLS_FORMAT_NODE *node = NLS_CachedFormats;
 175
 176   dwFlags &= LOCALE_NOUSEROVERRIDE;
 177
 178   TRACE("(0x%04x,0x%08x)\n", lcid, dwFlags);
 179
 180   /* See if we have already cached the locales number format */
 181   while (node && (node->lcid != lcid || node->dwFlags != dwFlags) && node->next)
 182     node = node->next;
 183
 184   if (!node || node->lcid != lcid || node->dwFlags != dwFlags)
 185   {
 186     NLS_FORMAT_NODE *new_node;
 187     DWORD i;
 188
 189     TRACE("Creating new cache entry\n");
 190
 191     if (!(new_node = HeapAlloc(GetProcessHeap(), 0, sizeof(NLS_FORMAT_NODE))))
 192       return NULL;
 193
 194     GET_LOCALE_NUMBER(new_node->dwCodePage, LOCALE_IDEFAULTANSICODEPAGE);
 195
 196     /* Number Format */
 197     new_node->lcid = lcid;
 198     new_node->dwFlags = dwFlags;
 199     new_node->next = NULL;
 200
 201     GET_LOCALE_NUMBER(new_node->fmt.NumDigits, LOCALE_IDIGITS);
 202     GET_LOCALE_NUMBER(new_node->fmt.LeadingZero, LOCALE_ILZERO);
 203     GET_LOCALE_NUMBER(new_node->fmt.NegativeOrder, LOCALE_INEGNUMBER);
 204
 205     GET_LOCALE_NUMBER(new_node->fmt.Grouping, LOCALE_SGROUPING);
 206     if (new_node->fmt.Grouping > 9 && new_node->fmt.Grouping != 32)
 207     {
 208       WARN("LOCALE_SGROUPING (%d) unhandled, please report!\n",
 209            new_node->fmt.Grouping);
 210       new_node->fmt.Grouping = 0;
 211     }
 212
 213     GET_LOCALE_STRING(new_node->fmt.lpDecimalSep, LOCALE_SDECIMAL);
 214     GET_LOCALE_STRING(new_node->fmt.lpThousandSep, LOCALE_STHOUSAND);
 215
 216     /* Currency Format */
 217     new_node->cyfmt.NumDigits = new_node->fmt.NumDigits;
 218     new_node->cyfmt.LeadingZero = new_node->fmt.LeadingZero;
 219
 220     GET_LOCALE_NUMBER(new_node->cyfmt.Grouping, LOCALE_SGROUPING);
 221
 222     if (new_node->cyfmt.Grouping > 9)
 223     {
 224       WARN("LOCALE_SMONGROUPING (%d) unhandled, please report!\n",
 225            new_node->cyfmt.Grouping);
 226       new_node->cyfmt.Grouping = 0;
 227     }
 228
 229     GET_LOCALE_NUMBER(new_node->cyfmt.NegativeOrder, LOCALE_INEGCURR);
 230     if (new_node->cyfmt.NegativeOrder > 15)
 231     {
 232       WARN("LOCALE_INEGCURR (%d) unhandled, please report!\n",
 233            new_node->cyfmt.NegativeOrder);
 234       new_node->cyfmt.NegativeOrder = 0;
 235     }
 236     GET_LOCALE_NUMBER(new_node->cyfmt.PositiveOrder, LOCALE_ICURRENCY);
 237     if (new_node->cyfmt.PositiveOrder > 3)
 238     {
 239       WARN("LOCALE_IPOSCURR (%d) unhandled,please report!\n",
 240            new_node->cyfmt.PositiveOrder);
 241       new_node->cyfmt.PositiveOrder = 0;
 242     }
 243     GET_LOCALE_STRING(new_node->cyfmt.lpDecimalSep, LOCALE_SMONDECIMALSEP);
 244     GET_LOCALE_STRING(new_node->cyfmt.lpThousandSep, LOCALE_SMONTHOUSANDSEP);
 245     GET_LOCALE_STRING(new_node->cyfmt.lpCurrencySymbol, LOCALE_SCURRENCY);
 246
 247     /* Date/Time Format info, negative character, etc */
 248     for (i = 0; i < sizeof(NLS_LocaleIndices)/sizeof(NLS_LocaleIndices[0]); i++)
 249     {
 250       GET_LOCALE_STRING(new_node->lppszStrings[i], NLS_LocaleIndices[i]);
 251     }
 252     new_node->szShortAM[0] = GetAM(new_node)[0]; new_node->szShortAM[1] = '\0';
 253     new_node->szShortPM[0] = GetPM(new_node)[0]; new_node->szShortPM[1] = '\0';
 254
 255     /* Now add the computed format to the cache */
 256     RtlEnterCriticalSection(&NLS_FormatsCS);
 257
 258     /* Search again: We may have raced to add the node */
 259     node = NLS_CachedFormats;
 260     while (node && (node->lcid != lcid || node->dwFlags != dwFlags) && node->next)
 261       node = node->next;
 262
 263     if (!node)
 264     {
 265       node = NLS_CachedFormats = new_node; /* Empty list */
 266       new_node = NULL;
 267     }
 268     else if (node->lcid != lcid || node->dwFlags != dwFlags)
 269     {
 270       node->next = new_node; /* Not in the list, add to end */
 271       node = new_node;
 272       new_node = NULL;
 273     }
 274
 275     RtlLeaveCriticalSection(&NLS_FormatsCS);
 276
 277     if (new_node)
 278     {
 279       /* We raced and lost: The node was already added by another thread.
 280        * node points to the currently cached node, so free new_node.
 281        */
 282       for (i = 0; i < sizeof(NLS_LocaleIndices)/sizeof(NLS_LocaleIndices[0]); i++)
 283         HeapFree(GetProcessHeap(), 0, new_node->lppszStrings[i]);
 284       HeapFree(GetProcessHeap(), 0, new_node->fmt.lpDecimalSep);
 285       HeapFree(GetProcessHeap(), 0, new_node->fmt.lpThousandSep);
 286       HeapFree(GetProcessHeap(), 0, new_node->cyfmt.lpDecimalSep);
 287       HeapFree(GetProcessHeap(), 0, new_node->cyfmt.lpThousandSep);
 288       HeapFree(GetProcessHeap(), 0, new_node->cyfmt.lpCurrencySymbol);
 289       HeapFree(GetProcessHeap(), 0, new_node);
 290     }
 291   }
 292   return node;
 293 }
 294
 295 /**************************************************************************
 296  * NLS_IsUnicodeOnlyLcid <internal>
 297  *
 298  * Determine if a locale is Unicode only, and thus invalid in ASCII calls.
 299  */
 300 BOOL NLS_IsUnicodeOnlyLcid(LCID lcid)
 301 {
 302   lcid = ConvertDefaultLocale(lcid);
 303
 304   switch (PRIMARYLANGID(lcid))
 305   {
 306   case LANG_ARMENIAN:
 307   case LANG_DIVEHI:
 308   case LANG_GEORGIAN:
 309   case LANG_GUJARATI:
 310   case LANG_HINDI:
 311   case LANG_KANNADA:
 312   case LANG_KONKANI:
 313   case LANG_MARATHI:
 314   case LANG_PUNJABI:
 315   case LANG_SANSKRIT:
 316     TRACE("lcid 0x%08x: langid 0x%4x is Unicode Only\n", lcid, PRIMARYLANGID(lcid));
 317     return TRUE;
 318   default:
 319     return FALSE;
 320   }
 321 }
 322
 323 /*
 324  * Formatting of dates, times, numbers and currencies.
 325  */
 326
 327 #define IsLiteralMarker(p) (p == '\'')
 328 #define IsDateFmtChar(p)   (p == 'd'||p == 'M'||p == 'y'||p == 'g')
 329 #define IsTimeFmtChar(p)   (p == 'H'||p == 'h'||p == 'm'||p == 's'||p == 't')
 330
 331 /* Only the following flags can be given if a date/time format is specified */
 332 #define DATE_FORMAT_FLAGS (DATE_DATEVARSONLY|LOCALE_NOUSEROVERRIDE)
 333 #define TIME_FORMAT_FLAGS (TIME_TIMEVARSONLY|TIME_FORCE24HOURFORMAT| \
 334                            TIME_NOMINUTESORSECONDS|TIME_NOSECONDS| \
 335                            TIME_NOTIMEMARKER|LOCALE_NOUSEROVERRIDE)
 336
 337 /******************************************************************************
 338  * NLS_GetDateTimeFormatW <internal>
 339  *
 340  * Performs the formatting for GetDateFormatW/GetTimeFormatW.
 341  *
 342  * FIXME
 343  * DATE_USE_ALT_CALENDAR           - Requires GetCalendarInfo to work first.
 344  * DATE_LTRREADING/DATE_RTLREADING - Not yet implemented.
 345  */
 346 static INT NLS_GetDateTimeFormatW(LCID lcid, DWORD dwFlags,
 347                                   const SYSTEMTIME* lpTime, LPCWSTR lpFormat,
 348                                   LPWSTR lpStr, INT cchOut)
 349 {
 350   const NLS_FORMAT_NODE *node;
 351   SYSTEMTIME st;
 352   INT cchWritten = 0;
 353   INT lastFormatPos = 0;
 354   BOOL bSkipping = FALSE; /* Skipping text around marker? */
 355
 356   /* Verify our arguments */
 357   if ((cchOut && !lpStr) || !(node = NLS_GetFormats(lcid, dwFlags)))
 358   {
 359 NLS_GetDateTimeFormatW_InvalidParameter:
 360     SetLastError(ERROR_INVALID_PARAMETER);
 361     return 0;
 362   }
 363
 364   if (dwFlags & ~(DATE_DATEVARSONLY|TIME_TIMEVARSONLY))
 365   {
 366     if (lpFormat &&
 367         ((dwFlags & DATE_DATEVARSONLY && dwFlags & ~DATE_FORMAT_FLAGS) ||
 368          (dwFlags & TIME_TIMEVARSONLY && dwFlags & ~TIME_FORMAT_FLAGS)))
 369     {
 370 NLS_GetDateTimeFormatW_InvalidFlags:
 371       SetLastError(ERROR_INVALID_FLAGS);
 372       return 0;
 373     }
 374
 375     if (dwFlags & DATE_DATEVARSONLY)
 376     {
 377       if ((dwFlags & (DATE_LTRREADING|DATE_RTLREADING)) == (DATE_LTRREADING|DATE_RTLREADING))
 378         goto NLS_GetDateTimeFormatW_InvalidFlags;
 379       else if (dwFlags & (DATE_LTRREADING|DATE_RTLREADING))
 380         FIXME("Unsupported flags: DATE_LTRREADING/DATE_RTLREADING\n");
 381
 382       switch (dwFlags & (DATE_SHORTDATE|DATE_LONGDATE|DATE_YEARMONTH))
 383       {
 384       case 0:
 385         break;
 386       case DATE_SHORTDATE:
 387       case DATE_LONGDATE:
 388       case DATE_YEARMONTH:
 389         if (lpFormat)
 390           goto NLS_GetDateTimeFormatW_InvalidFlags;
 391         break;
 392       default:
 393         goto NLS_GetDateTimeFormatW_InvalidFlags;
 394       }
 395     }
 396   }
 397
 398   if (!lpFormat)
 399   {
 400     /* Use the appropriate default format */
 401     if (dwFlags & DATE_DATEVARSONLY)
 402     {
 403       if (dwFlags & DATE_YEARMONTH)
 404         lpFormat = GetYearMonth(node);
 405       else if (dwFlags & DATE_LONGDATE)
 406         lpFormat = GetLongDate(node);
 407       else
 408         lpFormat = GetShortDate(node);
 409     }
 410     else
 411       lpFormat = GetTime(node);
 412   }
 413
 414   if (!lpTime)
 415   {
 416     GetLocalTime(&st); /* Default to current time */
 417     lpTime = &st;
 418   }
 419   else
 420   {
 421     if (dwFlags & DATE_DATEVARSONLY)
 422     {
 423       FILETIME ftTmp;
 424
 425       /* Verify the date and correct the D.O.W. if needed */
 426       memset(&st, 0, sizeof(st));
 427       st.wYear = lpTime->wYear;
 428       st.wMonth = lpTime->wMonth;
 429       st.wDay = lpTime->wDay;
 430
 431       if (st.wDay > 31 || st.wMonth > 12 || !SystemTimeToFileTime(&st, &ftTmp))
 432         goto NLS_GetDateTimeFormatW_InvalidParameter;
 433
 434       FileTimeToSystemTime(&ftTmp, &st);
 435       lpTime = &st;
 436     }
 437
 438     if (dwFlags & TIME_TIMEVARSONLY)
 439     {
 440       /* Verify the time */
 441       if (lpTime->wHour > 24 || lpTime->wMinute > 59 || lpTime->wSecond > 59)
 442         goto NLS_GetDateTimeFormatW_InvalidParameter;
 443     }
 444   }
 445
 446   /* Format the output */
 447   while (*lpFormat)
 448   {
 449     if (IsLiteralMarker(*lpFormat))
 450     {
 451       /* Start of a literal string */
 452       lpFormat++;
 453
 454       /* Loop until the end of the literal marker or end of the string */
 455       while (*lpFormat)
 456       {
 457         if (IsLiteralMarker(*lpFormat))
 458         {
 459           lpFormat++;
 460           if (!IsLiteralMarker(*lpFormat))
 461             break; /* Terminating literal marker */
 462         }
 463
 464         if (!cchOut)
 465           cchWritten++;   /* Count size only */
 466         else if (cchWritten >= cchOut)
 467           goto NLS_GetDateTimeFormatW_Overrun;
 468         else if (!bSkipping)
 469         {
 470           lpStr[cchWritten] = *lpFormat;
 471           cchWritten++;
 472         }
 473         lpFormat++;
 474       }
 475     }
 476     else if ((dwFlags & DATE_DATEVARSONLY && IsDateFmtChar(*lpFormat)) ||
 477              (dwFlags & TIME_TIMEVARSONLY && IsTimeFmtChar(*lpFormat)))
 478     {
 479       char  buffA[32];
 480       WCHAR buff[32], fmtChar;
 481       LPCWSTR szAdd = NULL;
 482       DWORD dwVal = 0;
 483       int   count = 0, dwLen;
 484
 485       bSkipping = FALSE;
 486
 487       fmtChar = *lpFormat;
 488       while (*lpFormat == fmtChar)
 489       {
 490         count++;
 491         lpFormat++;
 492       }
 493       buff[0] = '\0';
 494
 495       switch(fmtChar)
 496       {
 497       case 'd':
 498         if (count >= 4)
 499           szAdd = GetLongDay(node, (lpTime->wDayOfWeek + 6) % 7);
 500         else if (count == 3)
 501           szAdd = GetShortDay(node, (lpTime->wDayOfWeek + 6) % 7);
 502         else
 503         {
 504           dwVal = lpTime->wDay;
 505           szAdd = buff;
 506         }
 507         break;
 508
 509       case 'M':
 510         if (count >= 4)
 511           szAdd = GetLongMonth(node, lpTime->wMonth - 1);
 512         else if (count == 3)
 513           szAdd = GetShortMonth(node, lpTime->wMonth - 1);
 514         else
 515         {
 516           dwVal = lpTime->wMonth;
 517           szAdd = buff;
 518         }
 519         break;
 520
 521       case 'y':
 522         if (count >= 4)
 523         {
 524           count = 4;
 525           dwVal = lpTime->wYear;
 526         }
 527         else
 528         {
 529           count = count > 2 ? 2 : count;
 530           dwVal = lpTime->wYear % 100;
 531         }
 532         szAdd = buff;
 533         break;
 534
 535       case 'g':
 536         if (count == 2)
 537         {
 538           /* FIXME: Our GetCalendarInfo() does not yet support CAL_SERASTRING.
 539            *        When it is fixed, this string should be cached in 'node'.
 540            */
 541           FIXME("Should be using GetCalendarInfo(CAL_SERASTRING), defaulting to 'AD'\n");
 542           buff[0] = 'A'; buff[1] = 'D'; buff[2] = '\0';
 543         }
 544         else
 545         {
 546           buff[0] = 'g'; buff[1] = '\0'; /* Add a literal 'g' */
 547         }
 548         szAdd = buff;
 549         break;
 550
 551       case 'h':
 552         if (!(dwFlags & TIME_FORCE24HOURFORMAT))
 553         {
 554           count = count > 2 ? 2 : count;
 555           dwVal = lpTime->wHour == 0 ? 12 : (lpTime->wHour - 1) % 12 + 1;
 556           szAdd = buff;
 557           break;
 558         }
 559         /* .. fall through if we are forced to output in 24 hour format */
 560
 561       case 'H':
 562         count = count > 2 ? 2 : count;
 563         dwVal = lpTime->wHour;
 564         szAdd = buff;
 565         break;
 566
 567       case 'm':
 568         if (dwFlags & TIME_NOMINUTESORSECONDS)
 569         {
 570           cchWritten = lastFormatPos; /* Skip */
 571           bSkipping = TRUE;
 572         }
 573         else
 574         {
 575           count = count > 2 ? 2 : count;
 576           dwVal = lpTime->wMinute;
 577           szAdd = buff;
 578         }
 579         break;
 580
 581       case 's':
 582         if (dwFlags & (TIME_NOSECONDS|TIME_NOMINUTESORSECONDS))
 583         {
 584           cchWritten = lastFormatPos; /* Skip */
 585           bSkipping = TRUE;
 586         }
 587         else
 588         {
 589           count = count > 2 ? 2 : count;
 590           dwVal = lpTime->wSecond;
 591           szAdd = buff;
 592         }
 593         break;
 594
 595       case 't':
 596         if (dwFlags & TIME_NOTIMEMARKER)
 597         {
 598           cchWritten = lastFormatPos; /* Skip */
 599           bSkipping = TRUE;
 600         }
 601         else
 602         {
 603           if (count == 1)
 604             szAdd = lpTime->wHour < 12 ? node->szShortAM : node->szShortPM;
 605           else
 606             szAdd = lpTime->wHour < 12 ? GetAM(node) : GetPM(node);
 607         }
 608         break;
 609       }
 610
 611       if (szAdd == buff && buff[0] == '\0')
 612       {
 613         /* We have a numeric value to add */
 614         sprintf(buffA, "%.*d", count, dwVal);
 615         MultiByteToWideChar(CP_ACP, 0, buffA, -1, buff, sizeof(buff)/sizeof(WCHAR));
 616       }
 617
 618       dwLen = szAdd ? strlenW(szAdd) : 0;
 619
 620       if (cchOut && dwLen)
 621       {
 622         if (cchWritten + dwLen < cchOut)
 623           memcpy(lpStr + cchWritten, szAdd, dwLen * sizeof(WCHAR));
 624         else
 625         {
 626           memcpy(lpStr + cchWritten, szAdd, (cchOut - cchWritten) * sizeof(WCHAR));
 627           goto NLS_GetDateTimeFormatW_Overrun;
 628         }
 629       }
 630       cchWritten += dwLen;
 631       lastFormatPos = cchWritten; /* Save position of last output format text */
 632     }
 633     else
 634     {
 635       /* Literal character */
 636       if (!cchOut)
 637         cchWritten++;   /* Count size only */
 638       else if (cchWritten >= cchOut)
 639         goto NLS_GetDateTimeFormatW_Overrun;
 640       else if (!bSkipping || *lpFormat == ' ')
 641       {
 642         lpStr[cchWritten] = *lpFormat;
 643         cchWritten++;
 644       }
 645       lpFormat++;
 646     }
 647   }
 648
 649   /* Final string terminator and sanity check */
 650   if (cchOut)
 651   {
 652    if (cchWritten >= cchOut)
 653      goto NLS_GetDateTimeFormatW_Overrun;
 654    else
 655      lpStr[cchWritten] = '\0';
 656   }
 657   cchWritten++; /* Include terminating NUL */
 658
 659   TRACE("returning length=%d, ouput='%s'\n", cchWritten, debugstr_w(lpStr));
 660   return cchWritten;
 661
 662 NLS_GetDateTimeFormatW_Overrun:
 663   TRACE("returning 0, (ERROR_INSUFFICIENT_BUFFER)\n");
 664   SetLastError(ERROR_INSUFFICIENT_BUFFER);
 665   return 0;
 666 }
 667
 668 /******************************************************************************
 669  * NLS_GetDateTimeFormatA <internal>
 670  *
 671  * ASCII wrapper for GetDateFormatA/GetTimeFormatA.
 672  */
 673 static INT NLS_GetDateTimeFormatA(LCID lcid, DWORD dwFlags,
 674                                   const SYSTEMTIME* lpTime,
 675                                   LPCSTR lpFormat, LPSTR lpStr, INT cchOut)
 676 {
 677   DWORD cp = CP_ACP;
 678   WCHAR szFormat[128], szOut[128];
 679   INT iRet;
 680
 681   TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n", lcid, dwFlags, lpTime,
 682         debugstr_a(lpFormat), lpStr, cchOut);
 683
 684   if (NLS_IsUnicodeOnlyLcid(lcid))
 685   {
 686 GetDateTimeFormatA_InvalidParameter:
 687     SetLastError(ERROR_INVALID_PARAMETER);
 688     return 0;
 689   }
 690
 691   if (!(dwFlags & LOCALE_USE_CP_ACP))
 692   {
 693     const NLS_FORMAT_NODE *node = NLS_GetFormats(lcid, dwFlags);
 694     if (!node)
 695       goto GetDateTimeFormatA_InvalidParameter;
 696     cp = node->dwCodePage;
 697   }
 698
 699   if (lpFormat)
 700     MultiByteToWideChar(cp, 0, lpFormat, -1, szFormat, sizeof(szFormat)/sizeof(WCHAR));
 701
 702   if (cchOut > (int)(sizeof(szOut)/sizeof(WCHAR)))
 703     cchOut = sizeof(szOut)/sizeof(WCHAR);
 704
 705   szOut[0] = '\0';
 706
 707   iRet = NLS_GetDateTimeFormatW(lcid, dwFlags, lpTime, lpFormat ? szFormat : NULL,
 708                                 lpStr ? szOut : NULL, cchOut);
 709
 710   if (lpStr)
 711   {
 712     if (szOut[0])
 713       WideCharToMultiByte(cp, 0, szOut, iRet ? -1 : cchOut, lpStr, cchOut, 0, 0);
 714     else if (cchOut && iRet)
 715       *lpStr = '\0';
 716   }
 717   return iRet;
 718 }
 719
 720 /******************************************************************************
 721  * GetDateFormatA [KERNEL32.@]
 722  *
 723  * Format a date for a given locale.
 724  *
 725  * PARAMS
 726  *  lcid      [I] Locale to format for
 727  *  dwFlags   [I] LOCALE_ and DATE_ flags from "winnls.h"
 728  *  lpTime    [I] Date to format
 729  *  lpFormat  [I] Format string, or NULL to use the system defaults
 730  *  lpDateStr [O] Destination for formatted string
 731  *  cchOut    [I] Size of lpDateStr, or 0 to calculate the resulting size
 732  *
 733  * NOTES
 734  *  - If lpFormat is NULL, lpDateStr will be formatted according to the format
 735  *    details returned by GetLocaleInfoA() and modified by dwFlags.
 736  *  - lpFormat is a string of characters and formatting tokens. Any characters
 737  *    in the string are copied verbatim to lpDateStr, with tokens being replaced
 738  *    by the date values they represent.
 739  *  - The following tokens have special meanings in a date format string:
 740  *|  Token  Meaning
 741  *|  -----  -------
 742  *|  d      Single digit day of the month (no leading 0)
 743  *|  dd     Double digit day of the month
 744  *|  ddd    Short name for the day of the week
 745  *|  dddd   Long name for the day of the week
 746  *|  M      Single digit month of the year (no leading 0)
 747  *|  MM     Double digit month of the year
 748  *|  MMM    Short name for the month of the year
 749  *|  MMMM   Long name for the month of the year
 750  *|  y      Double digit year number (no leading 0)
 751  *|  yy     Double digit year number
 752  *|  yyyy   Four digit year number
 753  *|  gg     Era string, for example 'AD'.
 754  *  - To output any literal character that could be misidentified as a token,
 755  *    enclose it in single quotes.
 756  *  - The Ascii version of this function fails if lcid is Unicode only.
 757  *
 758  * RETURNS
 759  *  Success: The number of character written to lpDateStr, or that would
 760  *           have been written, if cchOut is 0.
 761  *  Failure: 0. Use GetLastError() to determine the cause.
 762  */
 763 INT WINAPI GetDateFormatA( LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
 764                            LPCSTR lpFormat, LPSTR lpDateStr, INT cchOut)
 765 {
 766   TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
 767         debugstr_a(lpFormat), lpDateStr, cchOut);
 768
 769   return NLS_GetDateTimeFormatA(lcid, dwFlags | DATE_DATEVARSONLY, lpTime,
 770                                 lpFormat, lpDateStr, cchOut);
 771 }
 772
 773
 774 /******************************************************************************
 775  * GetDateFormatW       [KERNEL32.@]
 776  *
 777  * See GetDateFormatA.
 778  */
 779 INT WINAPI GetDateFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
 780                           LPCWSTR lpFormat, LPWSTR lpDateStr, INT cchOut)
 781 {
 782   TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n", lcid, dwFlags, lpTime,
 783         debugstr_w(lpFormat), lpDateStr, cchOut);
 784
 785   return NLS_GetDateTimeFormatW(lcid, dwFlags|DATE_DATEVARSONLY, lpTime,
 786                                 lpFormat, lpDateStr, cchOut);
 787 }
 788
 789 /******************************************************************************
 790  *              GetTimeFormatA  [KERNEL32.@]
 791  *
 792  * Format a time for a given locale.
 793  *
 794  * PARAMS
 795  *  lcid      [I] Locale to format for
 796  *  dwFlags   [I] LOCALE_ and TIME_ flags from "winnls.h"
 797  *  lpTime    [I] Time to format
 798  *  lpFormat  [I] Formatting overrides
 799  *  lpTimeStr [O] Destination for formatted string
 800  *  cchOut    [I] Size of lpTimeStr, or 0 to calculate the resulting size
 801  *
 802  * NOTES
 803  *  - If lpFormat is NULL, lpszValue will be formatted according to the format
 804  *    details returned by GetLocaleInfoA() and modified by dwFlags.
 805  *  - lpFormat is a string of characters and formatting tokens. Any characters
 806  *    in the string are copied verbatim to lpTimeStr, with tokens being replaced
 807  *    by the time values they represent.
 808  *  - The following tokens have special meanings in a time format string:
 809  *|  Token  Meaning
 810  *|  -----  -------
 811  *|  h      Hours with no leading zero (12-hour clock)
 812  *|  hh     Hours with full two digits (12-hour clock)
 813  *|  H      Hours with no leading zero (24-hour clock)
 814  *|  HH     Hours with full two digits (24-hour clock)
 815  *|  m      Minutes with no leading zero
 816  *|  mm     Minutes with full two digits
 817  *|  s      Seconds with no leading zero
 818  *|  ss     Seconds with full two digits
 819  *|  t      Short time marker (e.g. "A" or "P")
 820  *|  tt     Long time marker (e.g. "AM", "PM")
 821  *  - To output any literal character that could be misidentified as a token,
 822  *    enclose it in single quotes.
 823  *  - The Ascii version of this function fails if lcid is Unicode only.
 824  *
 825  * RETURNS
 826  *  Success: The number of character written to lpTimeStr, or that would
 827  *           have been written, if cchOut is 0.
 828  *  Failure: 0. Use GetLastError() to determine the cause.
 829  */
 830 INT WINAPI GetTimeFormatA(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
 831                           LPCSTR lpFormat, LPSTR lpTimeStr, INT cchOut)
 832 {
 833   TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
 834         debugstr_a(lpFormat), lpTimeStr, cchOut);
 835
 836   return NLS_GetDateTimeFormatA(lcid, dwFlags|TIME_TIMEVARSONLY, lpTime,
 837                                 lpFormat, lpTimeStr, cchOut);
 838 }
 839
 840 /******************************************************************************
 841  *              GetTimeFormatW  [KERNEL32.@]
 842  *
 843  * See GetTimeFormatA.
 844  */
 845 INT WINAPI GetTimeFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
 846                           LPCWSTR lpFormat, LPWSTR lpTimeStr, INT cchOut)
 847 {
 848   TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
 849         debugstr_w(lpFormat), lpTimeStr, cchOut);
 850
 851   return NLS_GetDateTimeFormatW(lcid, dwFlags|TIME_TIMEVARSONLY, lpTime,
 852                                 lpFormat, lpTimeStr, cchOut);
 853 }
 854
 855 /**************************************************************************
 856  *              GetNumberFormatA        (KERNEL32.@)
 857  *
 858  * Format a number string for a given locale.
 859  *
 860  * PARAMS
 861  *  lcid        [I] Locale to format for
 862  *  dwFlags     [I] LOCALE_ flags from "winnls.h"
 863  *  lpszValue   [I] String to format
 864  *  lpFormat    [I] Formatting overrides
 865  *  lpNumberStr [O] Destination for formatted string
 866  *  cchOut      [I] Size of lpNumberStr, or 0 to calculate the resulting size
 867  *
 868  * NOTES
 869  *  - lpszValue can contain only '0' - '9', '-' and '.'.
 870  *  - If lpFormat is non-NULL, dwFlags must be 0. In this case lpszValue will
 871  *    be formatted according to the format details returned by GetLocaleInfoA().
 872  *  - This function rounds the number string if the number of decimals exceeds the
 873  *    locales normal number of decimal places.
 874  *  - If cchOut is 0, this function does not write to lpNumberStr.
 875  *  - The Ascii version of this function fails if lcid is Unicode only.
 876  *
 877  * RETURNS
 878  *  Success: The number of character written to lpNumberStr, or that would
 879  *           have been written, if cchOut is 0.
 880  *  Failure: 0. Use GetLastError() to determine the cause.
 881  */
 882 INT WINAPI GetNumberFormatA(LCID lcid, DWORD dwFlags,
 883                             LPCSTR lpszValue,  const NUMBERFMTA *lpFormat,
 884                             LPSTR lpNumberStr, int cchOut)
 885 {
 886   DWORD cp = CP_ACP;
 887   WCHAR szDec[8], szGrp[8], szIn[128], szOut[128];
 888   NUMBERFMTW fmt;
 889   const NUMBERFMTW *pfmt = NULL;
 890   INT iRet;
 891
 892   TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_a(lpszValue),
 893         lpFormat, lpNumberStr, cchOut);
 894
 895   if (NLS_IsUnicodeOnlyLcid(lcid))
 896   {
 897 GetNumberFormatA_InvalidParameter:
 898     SetLastError(ERROR_INVALID_PARAMETER);
 899     return 0;
 900   }
 901
 902   if (!(dwFlags & LOCALE_USE_CP_ACP))
 903   {
 904     const NLS_FORMAT_NODE *node = NLS_GetFormats(lcid, dwFlags);
 905     if (!node)
 906       goto GetNumberFormatA_InvalidParameter;
 907     cp = node->dwCodePage;
 908   }
 909
 910   if (lpFormat)
 911   {
 912     memcpy(&fmt, lpFormat, sizeof(fmt));
 913     pfmt = &fmt;
 914     if (lpFormat->lpDecimalSep)
 915     {
 916       MultiByteToWideChar(cp, 0, lpFormat->lpDecimalSep, -1, szDec, sizeof(szDec)/sizeof(WCHAR));
 917       fmt.lpDecimalSep = szDec;
 918     }
 919     if (lpFormat->lpThousandSep)
 920     {
 921       MultiByteToWideChar(cp, 0, lpFormat->lpThousandSep, -1, szGrp, sizeof(szGrp)/sizeof(WCHAR));
 922       fmt.lpThousandSep = szGrp;
 923     }
 924   }
 925
 926   if (lpszValue)
 927     MultiByteToWideChar(cp, 0, lpszValue, -1, szIn, sizeof(szIn)/sizeof(WCHAR));
 928
 929   if (cchOut > (int)(sizeof(szOut)/sizeof(WCHAR)))
 930     cchOut = sizeof(szOut)/sizeof(WCHAR);
 931
 932   szOut[0] = '\0';
 933
 934   iRet = GetNumberFormatW(lcid, dwFlags, lpszValue ? szIn : NULL, pfmt,
 935                           lpNumberStr ? szOut : NULL, cchOut);
 936
 937   if (szOut[0] && lpNumberStr)
 938     WideCharToMultiByte(cp, 0, szOut, -1, lpNumberStr, cchOut, 0, 0);
 939   return iRet;
 940 }
 941
 942 /* Number parsing state flags */
 943 #define NF_ISNEGATIVE 0x1  /* '-' found */
 944 #define NF_ISREAL     0x2  /* '.' found */
 945 #define NF_DIGITS     0x4  /* '0'-'9' found */
 946 #define NF_DIGITS_OUT 0x8  /* Digits before the '.' found */
 947 #define NF_ROUND      0x10 /* Number needs to be rounded */
 948
 949 /* Formatting options for Numbers */
 950 #define NLS_NEG_PARENS      0 /* "(1.1)" */
 951 #define NLS_NEG_LEFT        1 /* "-1.1"  */
 952 #define NLS_NEG_LEFT_SPACE  2 /* "- 1.1" */
 953 #define NLS_NEG_RIGHT       3 /* "1.1-"  */
 954 #define NLS_NEG_RIGHT_SPACE 4 /* "1.1 -" */
 955
 956 /**************************************************************************
 957  *              GetNumberFormatW        (KERNEL32.@)
 958  *
 959  * See GetNumberFormatA.
 960  */
 961 INT WINAPI GetNumberFormatW(LCID lcid, DWORD dwFlags,
 962                             LPCWSTR lpszValue,  const NUMBERFMTW *lpFormat,
 963                             LPWSTR lpNumberStr, int cchOut)
 964 {
 965   WCHAR szBuff[128], *szOut = szBuff + sizeof(szBuff) / sizeof(WCHAR) - 1;
 966   WCHAR szNegBuff[8];
 967   const WCHAR *lpszNeg = NULL, *lpszNegStart, *szSrc;
 968   DWORD dwState = 0, dwDecimals = 0, dwGroupCount = 0, dwCurrentGroupCount = 0;
 969   INT iRet;
 970
 971   TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_w(lpszValue),
 972         lpFormat, lpNumberStr, cchOut);
 973
 974   if (!lpszValue || cchOut < 0 || (cchOut > 0 && !lpNumberStr) ||
 975       !IsValidLocale(lcid, 0) ||
 976       (lpFormat && (dwFlags || !lpFormat->lpDecimalSep || !lpFormat->lpThousandSep)))
 977   {
 978 GetNumberFormatW_Error:
 979     SetLastError(lpFormat && dwFlags ? ERROR_INVALID_FLAGS : ERROR_INVALID_PARAMETER);
 980     return 0;
 981   }
 982
 983   if (!lpFormat)
 984   {
 985     const NLS_FORMAT_NODE *node = NLS_GetFormats(lcid, dwFlags);
 986
 987     if (!node)
 988       goto GetNumberFormatW_Error;
 989     lpFormat = &node->fmt;
 990     lpszNegStart = lpszNeg = GetNegative(node);
 991   }
 992   else
 993   {
 994     GetLocaleInfoW(lcid, LOCALE_SNEGATIVESIGN|(dwFlags & LOCALE_NOUSEROVERRIDE),
 995                    szNegBuff, sizeof(szNegBuff)/sizeof(WCHAR));
 996     lpszNegStart = lpszNeg = szNegBuff;
 997   }
 998   lpszNeg = lpszNeg + strlenW(lpszNeg) - 1;
 999
1000   dwFlags &= (LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP);
1001
1002   /* Format the number backwards into a temporary buffer */
1003
1004   szSrc = lpszValue;
1005   *szOut-- = '\0';
1006
1007   /* Check the number for validity */
1008   while (*szSrc)
1009   {
1010     if (*szSrc >= '0' && *szSrc <= '9')
1011     {
1012       dwState |= NF_DIGITS;
1013       if (dwState & NF_ISREAL)
1014         dwDecimals++;
1015     }
1016     else if (*szSrc == '-')
1017     {
1018       if (dwState)
1019         goto GetNumberFormatW_Error; /* '-' not first character */
1020       dwState |= NF_ISNEGATIVE;
1021     }
1022     else if (*szSrc == '.')
1023     {
1024       if (dwState & NF_ISREAL)
1025         goto GetNumberFormatW_Error; /* More than one '.' */
1026       dwState |= NF_ISREAL;
1027     }
1028     else
1029       goto GetNumberFormatW_Error; /* Invalid char */
1030     szSrc++;
1031   }
1032   szSrc--; /* Point to last character */
1033
1034   if (!(dwState & NF_DIGITS))
1035     goto GetNumberFormatW_Error; /* No digits */
1036
1037   /* Add any trailing negative sign */
1038   if (dwState & NF_ISNEGATIVE)
1039   {
1040     switch (lpFormat->NegativeOrder)
1041     {
1042     case NLS_NEG_PARENS:
1043       *szOut-- = ')';
1044       break;
1045     case NLS_NEG_RIGHT:
1046     case NLS_NEG_RIGHT_SPACE:
1047       while (lpszNeg >= lpszNegStart)
1048         *szOut-- = *lpszNeg--;
1049      if (lpFormat->NegativeOrder == NLS_NEG_RIGHT_SPACE)
1050        *szOut-- = ' ';
1051       break;
1052     }
1053   }
1054
1055   /* Copy all digits up to the decimal point */
1056   if (!lpFormat->NumDigits)
1057   {
1058     if (dwState & NF_ISREAL)
1059     {
1060       while (*szSrc != '.') /* Don't write any decimals or a separator */
1061       {
1062         if (*szSrc >= '5' || (*szSrc == '4' && (dwState & NF_ROUND)))
1063           dwState |= NF_ROUND;
1064         else
1065           dwState &= ~NF_ROUND;
1066         szSrc--;
1067       }
1068       szSrc--;
1069     }
1070   }
1071   else
1072   {
1073     LPWSTR lpszDec = lpFormat->lpDecimalSep + strlenW(lpFormat->lpDecimalSep) - 1;
1074
1075     if (dwDecimals <= lpFormat->NumDigits)
1076     {
1077       dwDecimals = lpFormat->NumDigits - dwDecimals;
1078       while (dwDecimals--)
1079         *szOut-- = '0'; /* Pad to correct number of dp */
1080     }
1081     else
1082     {
1083       dwDecimals -= lpFormat->NumDigits;
1084       /* Skip excess decimals, and determine if we have to round the number */
1085       while (dwDecimals--)
1086       {
1087         if (*szSrc >= '5' || (*szSrc == '4' && (dwState & NF_ROUND)))
1088           dwState |= NF_ROUND;
1089         else
1090           dwState &= ~NF_ROUND;
1091         szSrc--;
1092       }
1093     }
1094
1095     if (dwState & NF_ISREAL)
1096     {
1097       while (*szSrc != '.')
1098       {
1099         if (dwState & NF_ROUND)
1100         {
1101           if (*szSrc == '9')
1102             *szOut-- = '0'; /* continue rounding */
1103           else
1104           {
1105             dwState &= ~NF_ROUND;
1106             *szOut-- = (*szSrc)+1;
1107           }
1108           szSrc--;
1109         }
1110         else
1111           *szOut-- = *szSrc--; /* Write existing decimals */
1112       }
1113       szSrc--; /* Skip '.' */
1114     }
1115
1116     while (lpszDec >= lpFormat->lpDecimalSep)
1117       *szOut-- = *lpszDec--; /* Write decimal separator */
1118   }
1119
1120   dwGroupCount = lpFormat->Grouping == 32 ? 3 : lpFormat->Grouping;
1121
1122   /* Write the remaining whole number digits, including grouping chars */
1123   while (szSrc >= lpszValue && *szSrc >= '0' && *szSrc <= '9')
1124   {
1125     if (dwState & NF_ROUND)
1126     {
1127       if (*szSrc == '9')
1128         *szOut-- = '0'; /* continue rounding */
1129       else
1130       {
1131         dwState &= ~NF_ROUND;
1132         *szOut-- = (*szSrc)+1;
1133       }
1134       szSrc--;
1135     }
1136     else
1137       *szOut-- = *szSrc--;
1138
1139     dwState |= NF_DIGITS_OUT;
1140     dwCurrentGroupCount++;
1141     if (szSrc >= lpszValue && dwCurrentGroupCount == dwGroupCount && *szSrc != '-')
1142     {
1143       LPWSTR lpszGrp = lpFormat->lpThousandSep + strlenW(lpFormat->lpThousandSep) - 1;
1144
1145       while (lpszGrp >= lpFormat->lpThousandSep)
1146         *szOut-- = *lpszGrp--; /* Write grouping char */
1147
1148       dwCurrentGroupCount = 0;
1149       if (lpFormat->Grouping == 32)
1150         dwGroupCount = 2; /* Indic grouping: 3 then 2 */
1151     }
1152   }
1153   if (dwState & NF_ROUND)
1154   {
1155     *szOut-- = '1'; /* e.g. .6 > 1.0 */
1156   }
1157   else if (!(dwState & NF_DIGITS_OUT) && lpFormat->LeadingZero)
1158     *szOut-- = '0'; /* Add leading 0 if we have no digits before the decimal point */
1159
1160   /* Add any leading negative sign */
1161   if (dwState & NF_ISNEGATIVE)
1162   {
1163     switch (lpFormat->NegativeOrder)
1164     {
1165     case NLS_NEG_PARENS:
1166       *szOut-- = '(';
1167       break;
1168     case NLS_NEG_LEFT_SPACE:
1169       *szOut-- = ' ';
1170       /* Fall through */
1171     case NLS_NEG_LEFT:
1172       while (lpszNeg >= lpszNegStart)
1173         *szOut-- = *lpszNeg--;
1174       break;
1175     }
1176   }
1177   szOut++;
1178
1179   iRet = strlenW(szOut) + 1;
1180   if (cchOut)
1181   {
1182     if (iRet <= cchOut)
1183       memcpy(lpNumberStr, szOut, iRet * sizeof(WCHAR));
1184     else
1185     {
1186       memcpy(lpNumberStr, szOut, cchOut * sizeof(WCHAR));
1187       lpNumberStr[cchOut - 1] = '\0';
1188       SetLastError(ERROR_INSUFFICIENT_BUFFER);
1189       iRet = 0;
1190     }
1191   }
1192   return iRet;
1193 }
1194
1195 /**************************************************************************
1196  *              GetCurrencyFormatA      (KERNEL32.@)
1197  *
1198  * Format a currency string for a given locale.
1199  *
1200  * PARAMS
1201  *  lcid          [I] Locale to format for
1202  *  dwFlags       [I] LOCALE_ flags from "winnls.h"
1203  *  lpszValue     [I] String to format
1204  *  lpFormat      [I] Formatting overrides
1205  *  lpCurrencyStr [O] Destination for formatted string
1206  *  cchOut        [I] Size of lpCurrencyStr, or 0 to calculate the resulting size
1207  *
1208  * NOTES
1209  *  - lpszValue can contain only '0' - '9', '-' and '.'.
1210  *  - If lpFormat is non-NULL, dwFlags must be 0. In this case lpszValue will
1211  *    be formatted according to the format details returned by GetLocaleInfoA().
1212  *  - This function rounds the currency if the number of decimals exceeds the
1213  *    locales number of currency decimal places.
1214  *  - If cchOut is 0, this function does not write to lpCurrencyStr.
1215  *  - The Ascii version of this function fails if lcid is Unicode only.
1216  *
1217  * RETURNS
1218  *  Success: The number of character written to lpNumberStr, or that would
1219  *           have been written, if cchOut is 0.
1220  *  Failure: 0. Use GetLastError() to determine the cause.
1221  */
1222 INT WINAPI GetCurrencyFormatA(LCID lcid, DWORD dwFlags,
1223                               LPCSTR lpszValue,  const CURRENCYFMTA *lpFormat,
1224                               LPSTR lpCurrencyStr, int cchOut)
1225 {
1226   DWORD cp = CP_ACP;
1227   WCHAR szDec[8], szGrp[8], szCy[8], szIn[128], szOut[128];
1228   CURRENCYFMTW fmt;
1229   const CURRENCYFMTW *pfmt = NULL;
1230   INT iRet;
1231
1232   TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_a(lpszValue),
1233         lpFormat, lpCurrencyStr, cchOut);
1234
1235   if (NLS_IsUnicodeOnlyLcid(lcid))
1236   {
1237 GetCurrencyFormatA_InvalidParameter:
1238     SetLastError(ERROR_INVALID_PARAMETER);
1239     return 0;
1240   }
1241
1242   if (!(dwFlags & LOCALE_USE_CP_ACP))
1243   {
1244     const NLS_FORMAT_NODE *node = NLS_GetFormats(lcid, dwFlags);
1245     if (!node)
1246       goto GetCurrencyFormatA_InvalidParameter;
1247     cp = node->dwCodePage;
1248   }
1249
1250   if (lpFormat)
1251   {
1252     memcpy(&fmt, lpFormat, sizeof(fmt));
1253     pfmt = &fmt;
1254     if (lpFormat->lpDecimalSep)
1255     {
1256       MultiByteToWideChar(cp, 0, lpFormat->lpDecimalSep, -1, szDec, sizeof(szDec)/sizeof(WCHAR));
1257       fmt.lpDecimalSep = szDec;
1258     }
1259     if (lpFormat->lpThousandSep)
1260     {
1261       MultiByteToWideChar(cp, 0, lpFormat->lpThousandSep, -1, szGrp, sizeof(szGrp)/sizeof(WCHAR));
1262       fmt.lpThousandSep = szGrp;
1263     }
1264     if (lpFormat->lpCurrencySymbol)
1265     {
1266       MultiByteToWideChar(cp, 0, lpFormat->lpCurrencySymbol, -1, szCy, sizeof(szCy)/sizeof(WCHAR));
1267       fmt.lpCurrencySymbol = szCy;
1268     }
1269   }
1270
1271   if (lpszValue)
1272     MultiByteToWideChar(cp, 0, lpszValue, -1, szIn, sizeof(szIn)/sizeof(WCHAR));
1273
1274   if (cchOut > (int)(sizeof(szOut)/sizeof(WCHAR)))
1275     cchOut = sizeof(szOut)/sizeof(WCHAR);
1276
1277   szOut[0] = '\0';
1278
1279   iRet = GetCurrencyFormatW(lcid, dwFlags, lpszValue ? szIn : NULL, pfmt,
1280                             lpCurrencyStr ? szOut : NULL, cchOut);
1281
1282   if (szOut[0] && lpCurrencyStr)
1283     WideCharToMultiByte(cp, 0, szOut, -1, lpCurrencyStr, cchOut, 0, 0);
1284   return iRet;
1285 }
1286
1287 /* Formatting states for Currencies. We use flags to avoid code duplication. */
1288 #define CF_PARENS       0x1  /* Parentheses      */
1289 #define CF_MINUS_LEFT   0x2  /* '-' to the left  */
1290 #define CF_MINUS_RIGHT  0x4  /* '-' to the right */
1291 #define CF_MINUS_BEFORE 0x8  /* '-' before '$'   */
1292 #define CF_CY_LEFT      0x10 /* '$' to the left  */
1293 #define CF_CY_RIGHT     0x20 /* '$' to the right */
1294 #define CF_CY_SPACE     0x40 /* ' ' by '$'       */
1295
1296 /**************************************************************************
1297  *              GetCurrencyFormatW      (KERNEL32.@)
1298  *
1299  * See GetCurrencyFormatA.
1300  */
1301 INT WINAPI GetCurrencyFormatW(LCID lcid, DWORD dwFlags,
1302                               LPCWSTR lpszValue,  const CURRENCYFMTW *lpFormat,
1303                               LPWSTR lpCurrencyStr, int cchOut)
1304 {
1305   static const BYTE NLS_NegCyFormats[16] =
1306   {
1307     CF_PARENS|CF_CY_LEFT,                       /* ($1.1) */
1308     CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT,   /* -$1.1  */
1309     CF_MINUS_LEFT|CF_CY_LEFT,                   /* $-1.1  */
1310     CF_MINUS_RIGHT|CF_CY_LEFT,                  /* $1.1-  */
1311     CF_PARENS|CF_CY_RIGHT,                      /* (1.1$) */
1312     CF_MINUS_LEFT|CF_CY_RIGHT,                  /* -1.1$  */
1313     CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT, /* 1.1-$  */
1314     CF_MINUS_RIGHT|CF_CY_RIGHT,                 /* 1.1$-  */
1315     CF_MINUS_LEFT|CF_CY_RIGHT|CF_CY_SPACE,      /* -1.1 $ */
1316     CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT|CF_CY_SPACE,   /* -$ 1.1 */
1317     CF_MINUS_RIGHT|CF_CY_RIGHT|CF_CY_SPACE,     /* 1.1 $-  */
1318     CF_MINUS_RIGHT|CF_CY_LEFT|CF_CY_SPACE,      /* $ 1.1-  */
1319     CF_MINUS_LEFT|CF_CY_LEFT|CF_CY_SPACE,       /* $ -1.1  */
1320     CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT|CF_CY_SPACE, /* 1.1- $ */
1321     CF_PARENS|CF_CY_LEFT|CF_CY_SPACE,           /* ($ 1.1) */
1322     CF_PARENS|CF_CY_RIGHT|CF_CY_SPACE,          /* (1.1 $) */
1323   };
1324   static const BYTE NLS_PosCyFormats[4] =
1325   {
1326     CF_CY_LEFT,              /* $1.1  */
1327     CF_CY_RIGHT,             /* 1.1$  */
1328     CF_CY_LEFT|CF_CY_SPACE,  /* $ 1.1 */
1329     CF_CY_RIGHT|CF_CY_SPACE, /* 1.1 $ */
1330   };
1331   WCHAR szBuff[128], *szOut = szBuff + sizeof(szBuff) / sizeof(WCHAR) - 1;
1332   WCHAR szNegBuff[8];
1333   const WCHAR *lpszNeg = NULL, *lpszNegStart, *szSrc, *lpszCy, *lpszCyStart;
1334   DWORD dwState = 0, dwDecimals = 0, dwGroupCount = 0, dwCurrentGroupCount = 0, dwFmt;
1335   INT iRet;
1336
1337   TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_w(lpszValue),
1338         lpFormat, lpCurrencyStr, cchOut);
1339
1340   if (!lpszValue || cchOut < 0 || (cchOut > 0 && !lpCurrencyStr) ||
1341       !IsValidLocale(lcid, 0) ||
1342       (lpFormat && (dwFlags || !lpFormat->lpDecimalSep || !lpFormat->lpThousandSep ||
1343       !lpFormat->lpCurrencySymbol || lpFormat->NegativeOrder > 15 ||
1344       lpFormat->PositiveOrder > 3)))
1345   {
1346 GetCurrencyFormatW_Error:
1347     SetLastError(lpFormat && dwFlags ? ERROR_INVALID_FLAGS : ERROR_INVALID_PARAMETER);
1348     return 0;
1349   }
1350
1351   if (!lpFormat)
1352   {
1353     const NLS_FORMAT_NODE *node = NLS_GetFormats(lcid, dwFlags);
1354
1355     if (!node)
1356       goto GetCurrencyFormatW_Error;
1357     lpFormat = &node->cyfmt;
1358     lpszNegStart = lpszNeg = GetNegative(node);
1359   }
1360   else
1361   {
1362     GetLocaleInfoW(lcid, LOCALE_SNEGATIVESIGN|(dwFlags & LOCALE_NOUSEROVERRIDE),
1363                    szNegBuff, sizeof(szNegBuff)/sizeof(WCHAR));
1364     lpszNegStart = lpszNeg = szNegBuff;
1365   }
1366   dwFlags &= (LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP);
1367
1368   lpszNeg = lpszNeg + strlenW(lpszNeg) - 1;
1369   lpszCyStart = lpFormat->lpCurrencySymbol;
1370   lpszCy = lpszCyStart + strlenW(lpszCyStart) - 1;
1371
1372   /* Format the currency backwards into a temporary buffer */
1373
1374   szSrc = lpszValue;
1375   *szOut-- = '\0';
1376
1377   /* Check the number for validity */
1378   while (*szSrc)
1379   {
1380     if (*szSrc >= '0' && *szSrc <= '9')
1381     {
1382       dwState |= NF_DIGITS;
1383       if (dwState & NF_ISREAL)
1384         dwDecimals++;
1385     }
1386     else if (*szSrc == '-')
1387     {
1388       if (dwState)
1389         goto GetCurrencyFormatW_Error; /* '-' not first character */
1390       dwState |= NF_ISNEGATIVE;
1391     }
1392     else if (*szSrc == '.')
1393     {
1394       if (dwState & NF_ISREAL)
1395         goto GetCurrencyFormatW_Error; /* More than one '.' */
1396       dwState |= NF_ISREAL;
1397     }
1398     else
1399       goto GetCurrencyFormatW_Error; /* Invalid char */
1400     szSrc++;
1401   }
1402   szSrc--; /* Point to last character */
1403
1404   if (!(dwState & NF_DIGITS))
1405     goto GetCurrencyFormatW_Error; /* No digits */
1406
1407   if (dwState & NF_ISNEGATIVE)
1408     dwFmt = NLS_NegCyFormats[lpFormat->NegativeOrder];
1409   else
1410     dwFmt = NLS_PosCyFormats[lpFormat->PositiveOrder];
1411
1412   /* Add any trailing negative or currency signs */
1413   if (dwFmt & CF_PARENS)
1414     *szOut-- = ')';
1415
1416   while (dwFmt & (CF_MINUS_RIGHT|CF_CY_RIGHT))
1417   {
1418     switch (dwFmt & (CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT))
1419     {
1420     case CF_MINUS_RIGHT:
1421     case CF_MINUS_RIGHT|CF_CY_RIGHT:
1422       while (lpszNeg >= lpszNegStart)
1423         *szOut-- = *lpszNeg--;
1424       dwFmt &= ~CF_MINUS_RIGHT;
1425       break;
1426
1427     case CF_CY_RIGHT:
1428     case CF_MINUS_BEFORE|CF_CY_RIGHT:
1429     case CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT:
1430       while (lpszCy >= lpszCyStart)
1431         *szOut-- = *lpszCy--;
1432       if (dwFmt & CF_CY_SPACE)
1433         *szOut-- = ' ';
1434       dwFmt &= ~(CF_CY_RIGHT|CF_MINUS_BEFORE);
1435       break;
1436     }
1437   }
1438
1439   /* Copy all digits up to the decimal point */
1440   if (!lpFormat->NumDigits)
1441   {
1442     if (dwState & NF_ISREAL)
1443     {
1444       while (*szSrc != '.') /* Don't write any decimals or a separator */
1445       {
1446         if (*szSrc >= '5' || (*szSrc == '4' && (dwState & NF_ROUND)))
1447           dwState |= NF_ROUND;
1448         else
1449           dwState &= ~NF_ROUND;
1450         szSrc--;
1451       }
1452       szSrc--;
1453     }
1454   }
1455   else
1456   {
1457     LPWSTR lpszDec = lpFormat->lpDecimalSep + strlenW(lpFormat->lpDecimalSep) - 1;
1458
1459     if (dwDecimals <= lpFormat->NumDigits)
1460     {
1461       dwDecimals = lpFormat->NumDigits - dwDecimals;
1462       while (dwDecimals--)
1463         *szOut-- = '0'; /* Pad to correct number of dp */
1464     }
1465     else
1466     {
1467       dwDecimals -= lpFormat->NumDigits;
1468       /* Skip excess decimals, and determine if we have to round the number */
1469       while (dwDecimals--)
1470       {
1471         if (*szSrc >= '5' || (*szSrc == '4' && (dwState & NF_ROUND)))
1472           dwState |= NF_ROUND;
1473         else
1474           dwState &= ~NF_ROUND;
1475         szSrc--;
1476       }
1477     }
1478
1479     if (dwState & NF_ISREAL)
1480     {
1481       while (*szSrc != '.')
1482       {
1483         if (dwState & NF_ROUND)
1484         {
1485           if (*szSrc == '9')
1486             *szOut-- = '0'; /* continue rounding */
1487           else
1488           {
1489             dwState &= ~NF_ROUND;
1490             *szOut-- = (*szSrc)+1;
1491           }
1492           szSrc--;
1493         }
1494         else
1495           *szOut-- = *szSrc--; /* Write existing decimals */
1496       }
1497       szSrc--; /* Skip '.' */
1498     }
1499     while (lpszDec >= lpFormat->lpDecimalSep)
1500       *szOut-- = *lpszDec--; /* Write decimal separator */
1501   }
1502
1503   dwGroupCount = lpFormat->Grouping;
1504
1505   /* Write the remaining whole number digits, including grouping chars */
1506   while (szSrc >= lpszValue && *szSrc >= '0' && *szSrc <= '9')
1507   {
1508     if (dwState & NF_ROUND)
1509     {
1510       if (*szSrc == '9')
1511         *szOut-- = '0'; /* continue rounding */
1512       else
1513       {
1514         dwState &= ~NF_ROUND;
1515         *szOut-- = (*szSrc)+1;
1516       }
1517       szSrc--;
1518     }
1519     else
1520       *szOut-- = *szSrc--;
1521
1522     dwState |= NF_DIGITS_OUT;
1523     dwCurrentGroupCount++;
1524     if (szSrc >= lpszValue && dwCurrentGroupCount == dwGroupCount)
1525     {
1526       LPWSTR lpszGrp = lpFormat->lpThousandSep + strlenW(lpFormat->lpThousandSep) - 1;
1527
1528       while (lpszGrp >= lpFormat->lpThousandSep)
1529         *szOut-- = *lpszGrp--; /* Write grouping char */
1530
1531       dwCurrentGroupCount = 0;
1532     }
1533   }
1534   if (dwState & NF_ROUND)
1535     *szOut-- = '1'; /* e.g. .6 > 1.0 */
1536   else if (!(dwState & NF_DIGITS_OUT) && lpFormat->LeadingZero)
1537     *szOut-- = '0'; /* Add leading 0 if we have no digits before the decimal point */
1538
1539   /* Add any leading negative or currency sign */
1540   while (dwFmt & (CF_MINUS_LEFT|CF_CY_LEFT))
1541   {
1542     switch (dwFmt & (CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT))
1543     {
1544     case CF_MINUS_LEFT:
1545     case CF_MINUS_LEFT|CF_CY_LEFT:
1546       while (lpszNeg >= lpszNegStart)
1547         *szOut-- = *lpszNeg--;
1548       dwFmt &= ~CF_MINUS_LEFT;
1549       break;
1550
1551     case CF_CY_LEFT:
1552     case CF_CY_LEFT|CF_MINUS_BEFORE:
1553     case CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT:
1554       if (dwFmt & CF_CY_SPACE)
1555         *szOut-- = ' ';
1556       while (lpszCy >= lpszCyStart)
1557         *szOut-- = *lpszCy--;
1558       dwFmt &= ~(CF_CY_LEFT|CF_MINUS_BEFORE);
1559       break;
1560     }
1561   }
1562   if (dwFmt & CF_PARENS)
1563     *szOut-- = '(';
1564   szOut++;
1565
1566   iRet = strlenW(szOut) + 1;
1567   if (cchOut)
1568   {
1569     if (iRet <= cchOut)
1570       memcpy(lpCurrencyStr, szOut, iRet * sizeof(WCHAR));
1571     else
1572     {
1573       memcpy(lpCurrencyStr, szOut, cchOut * sizeof(WCHAR));
1574       lpCurrencyStr[cchOut - 1] = '\0';
1575       SetLastError(ERROR_INSUFFICIENT_BUFFER);
1576       iRet = 0;
1577     }
1578   }
1579   return iRet;
1580 }
1581
1582 /* FIXME: Everything below here needs to move somewhere else along with the
1583  *        other EnumXXX functions, when a method for storing resources for
1584  *        alternate calendars is determined.
1585  */
1586
1587 /**************************************************************************
1588  *              EnumDateFormatsExA    (KERNEL32.@)
1589  *
1590  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1591  * LOCALE_NOUSEROVERRIDE here as well?
1592  */
1593 BOOL WINAPI EnumDateFormatsExA(DATEFMT_ENUMPROCEXA proc, LCID lcid, DWORD flags)
1594 {
1595     CALID cal_id;
1596     char buf[256];
1597
1598     if (!proc)
1599     {
1600         SetLastError(ERROR_INVALID_PARAMETER);
1601         return FALSE;
1602     }
1603
1604     if (!GetLocaleInfoW(lcid, LOCALE_ICALENDARTYPE|LOCALE_RETURN_NUMBER, (LPWSTR)&cal_id, sizeof(cal_id)/sizeof(WCHAR)))
1605         return FALSE;
1606
1607     switch (flags & ~LOCALE_USE_CP_ACP)
1608     {
1609     case 0:
1610     case DATE_SHORTDATE:
1611         if (GetLocaleInfoA(lcid, LOCALE_SSHORTDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1612             proc(buf, cal_id);
1613         break;
1614
1615     case DATE_LONGDATE:
1616         if (GetLocaleInfoA(lcid, LOCALE_SLONGDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1617             proc(buf, cal_id);
1618         break;
1619
1620     case DATE_YEARMONTH:
1621         if (GetLocaleInfoA(lcid, LOCALE_SYEARMONTH | (flags & LOCALE_USE_CP_ACP), buf, 256))
1622             proc(buf, cal_id);
1623         break;
1624
1625     default:
1626         FIXME("Unknown date format (%d)\n", flags);
1627         SetLastError(ERROR_INVALID_PARAMETER);
1628         return FALSE;
1629     }
1630     return TRUE;
1631 }
1632
1633 /**************************************************************************
1634  *              EnumDateFormatsExW    (KERNEL32.@)
1635  */
1636 BOOL WINAPI EnumDateFormatsExW(DATEFMT_ENUMPROCEXW proc, LCID lcid, DWORD flags)
1637 {
1638     CALID cal_id;
1639     WCHAR buf[256];
1640
1641     if (!proc)
1642     {
1643         SetLastError(ERROR_INVALID_PARAMETER);
1644         return FALSE;
1645     }
1646
1647     if (!GetLocaleInfoW(lcid, LOCALE_ICALENDARTYPE|LOCALE_RETURN_NUMBER, (LPWSTR)&cal_id, sizeof(cal_id)/sizeof(WCHAR)))
1648         return FALSE;
1649
1650     switch (flags & ~LOCALE_USE_CP_ACP)
1651     {
1652     case 0:
1653     case DATE_SHORTDATE:
1654         if (GetLocaleInfoW(lcid, LOCALE_SSHORTDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1655             proc(buf, cal_id);
1656         break;
1657
1658     case DATE_LONGDATE:
1659         if (GetLocaleInfoW(lcid, LOCALE_SLONGDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1660             proc(buf, cal_id);
1661         break;
1662
1663     case DATE_YEARMONTH:
1664         if (GetLocaleInfoW(lcid, LOCALE_SYEARMONTH | (flags & LOCALE_USE_CP_ACP), buf, 256))
1665             proc(buf, cal_id);
1666         break;
1667
1668     default:
1669         FIXME("Unknown date format (%d)\n", flags);
1670         SetLastError(ERROR_INVALID_PARAMETER);
1671         return FALSE;
1672     }
1673     return TRUE;
1674 }
1675
1676 /**************************************************************************
1677  *              EnumDateFormatsA        (KERNEL32.@)
1678  *
1679  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1680  * LOCALE_NOUSEROVERRIDE here as well?
1681  */
1682 BOOL WINAPI EnumDateFormatsA(DATEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
1683 {
1684     char buf[256];
1685
1686     if (!proc)
1687     {
1688         SetLastError(ERROR_INVALID_PARAMETER);
1689         return FALSE;
1690     }
1691
1692     switch (flags & ~LOCALE_USE_CP_ACP)
1693     {
1694     case 0:
1695     case DATE_SHORTDATE:
1696         if (GetLocaleInfoA(lcid, LOCALE_SSHORTDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1697             proc(buf);
1698         break;
1699
1700     case DATE_LONGDATE:
1701         if (GetLocaleInfoA(lcid, LOCALE_SLONGDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1702             proc(buf);
1703         break;
1704
1705     case DATE_YEARMONTH:
1706         if (GetLocaleInfoA(lcid, LOCALE_SYEARMONTH | (flags & LOCALE_USE_CP_ACP), buf, 256))
1707             proc(buf);
1708         break;
1709
1710     default:
1711         FIXME("Unknown date format (%d)\n", flags);
1712         SetLastError(ERROR_INVALID_PARAMETER);
1713         return FALSE;
1714     }
1715     return TRUE;
1716 }
1717
1718 /**************************************************************************
1719  *              EnumDateFormatsW        (KERNEL32.@)
1720  */
1721 BOOL WINAPI EnumDateFormatsW(DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)
1722 {
1723     WCHAR buf[256];
1724
1725     if (!proc)
1726     {
1727         SetLastError(ERROR_INVALID_PARAMETER);
1728         return FALSE;
1729     }
1730
1731     switch (flags & ~LOCALE_USE_CP_ACP)
1732     {
1733     case 0:
1734     case DATE_SHORTDATE:
1735         if (GetLocaleInfoW(lcid, LOCALE_SSHORTDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1736             proc(buf);
1737         break;
1738
1739     case DATE_LONGDATE:
1740         if (GetLocaleInfoW(lcid, LOCALE_SLONGDATE | (flags & LOCALE_USE_CP_ACP), buf, 256))
1741             proc(buf);
1742         break;
1743
1744     case DATE_YEARMONTH:
1745         if (GetLocaleInfoW(lcid, LOCALE_SYEARMONTH | (flags & LOCALE_USE_CP_ACP), buf, 256))
1746             proc(buf);
1747         break;
1748
1749     default:
1750         FIXME("Unknown date format (%d)\n", flags);
1751         SetLastError(ERROR_INVALID_PARAMETER);
1752         return FALSE;
1753     }
1754     return TRUE;
1755 }
1756
1757 /**************************************************************************
1758  *              EnumTimeFormatsA        (KERNEL32.@)
1759  *
1760  * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1761  * LOCALE_NOUSEROVERRIDE here as well?
1762  */
1763 BOOL WINAPI EnumTimeFormatsA(TIMEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
1764 {
1765     char buf[256];
1766
1767     if (!proc)
1768     {
1769         SetLastError(ERROR_INVALID_PARAMETER);
1770         return FALSE;
1771     }
1772
1773     switch (flags & ~LOCALE_USE_CP_ACP)
1774     {
1775     case 0:
1776         if (GetLocaleInfoA(lcid, LOCALE_STIMEFORMAT | (flags & LOCALE_USE_CP_ACP), buf, 256))
1777             proc(buf);
1778         break;
1779
1780     default:
1781         FIXME("Unknown time format (%d)\n", flags);
1782         SetLastError(ERROR_INVALID_PARAMETER);
1783         return FALSE;
1784     }
1785     return TRUE;
1786 }
1787
1788 /**************************************************************************
1789  *              EnumTimeFormatsW        (KERNEL32.@)
1790  */
1791 BOOL WINAPI EnumTimeFormatsW(TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)
1792 {
1793     WCHAR buf[256];
1794
1795     if (!proc)
1796     {
1797         SetLastError(ERROR_INVALID_PARAMETER);
1798         return FALSE;
1799     }
1800
1801     switch (flags & ~LOCALE_USE_CP_ACP)
1802     {
1803     case 0:
1804         if (GetLocaleInfoW(lcid, LOCALE_STIMEFORMAT | (flags & LOCALE_USE_CP_ACP), buf, 256))
1805             proc(buf);
1806         break;
1807
1808     default:
1809         FIXME("Unknown time format (%d)\n", flags);
1810         SetLastError(ERROR_INVALID_PARAMETER);
1811         return FALSE;
1812     }
1813     return TRUE;
1814 }
1815
1816 /******************************************************************************
1817  * NLS_EnumCalendarInfoAW <internal>
1818  * Enumerates calendar information for a specified locale.
1819  *
1820  * PARAMS
1821  *    calinfoproc [I] Pointer to the callback
1822  *    locale      [I] The locale for which to retrieve calendar information.
1823  *                    This parameter can be a locale identifier created by the
1824  *                    MAKELCID macro, or one of the following values:
1825  *                        LOCALE_SYSTEM_DEFAULT
1826  *                            Use the default system locale.
1827  *                        LOCALE_USER_DEFAULT
1828  *                            Use the default user locale.
1829  *    calendar    [I] The calendar for which information is requested, or
1830  *                    ENUM_ALL_CALENDARS.
1831  *    caltype     [I] The type of calendar information to be returned. Note
1832  *                    that only one CALTYPE value can be specified per call
1833  *                    of this function, except where noted.
1834  *    unicode     [I] Specifies if the callback expects a unicode string.
1835  *    ex          [I] Specifies if the callback needs the calendar identifier.
1836  *
1837  * RETURNS
1838  *    Success: TRUE.
1839  *    Failure: FALSE. Use GetLastError() to determine the cause.
1840  *
1841  * NOTES
1842  *    When the ANSI version of this function is used with a Unicode-only LCID,
1843  *    the call can succeed because the system uses the system code page.
1844  *    However, characters that are undefined in the system code page appear
1845  *    in the string as a question mark (?).
1846  *
1847  * TODO
1848  *    The above note should be respected by GetCalendarInfoA.
1849  */
1850 static BOOL NLS_EnumCalendarInfoAW(void *calinfoproc, LCID locale,
1851                   CALID calendar, CALTYPE caltype, BOOL unicode, BOOL ex )
1852 {
1853   WCHAR *buf, *opt = NULL, *iter = NULL;
1854   BOOL ret = FALSE;
1855   int bufSz = 200;              /* the size of the buffer */
1856
1857   if (calinfoproc == NULL)
1858   {
1859     SetLastError(ERROR_INVALID_PARAMETER);
1860     return FALSE;
1861   }
1862
1863   buf = HeapAlloc(GetProcessHeap(), 0, bufSz);
1864   if (buf == NULL)
1865   {
1866     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1867     return FALSE;
1868   }
1869
1870   if (calendar == ENUM_ALL_CALENDARS)
1871   {
1872     int optSz = GetLocaleInfoW(locale, LOCALE_IOPTIONALCALENDAR, NULL, 0);
1873     if (optSz > 1)
1874     {
1875       opt = HeapAlloc(GetProcessHeap(), 0, optSz * sizeof(WCHAR));
1876       if (opt == NULL)
1877       {
1878         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1879         goto NLS_EnumCalendarInfoAW_Cleanup;
1880       }
1881       if (GetLocaleInfoW(locale, LOCALE_IOPTIONALCALENDAR, opt, optSz))
1882         iter = opt;
1883     }
1884     calendar = NLS_GetLocaleNumber(locale, LOCALE_ICALENDARTYPE);
1885   }
1886
1887   while (TRUE)                  /* loop through calendars */
1888   {
1889     do                          /* loop until there's no error */
1890     {
1891       if (unicode)
1892         ret = GetCalendarInfoW(locale, calendar, caltype, buf, bufSz / sizeof(WCHAR), NULL);
1893       else ret = GetCalendarInfoA(locale, calendar, caltype, (CHAR*)buf, bufSz / sizeof(CHAR), NULL);
1894
1895       if (!ret)
1896       {
1897         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1898         {                               /* so resize it */
1899           int newSz;
1900           if (unicode)
1901             newSz = GetCalendarInfoW(locale, calendar, caltype, NULL, 0, NULL) * sizeof(WCHAR);
1902           else newSz = GetCalendarInfoA(locale, calendar, caltype, NULL, 0, NULL) * sizeof(CHAR);
1903           if (bufSz >= newSz)
1904           {
1905             ERR("Buffer resizing disorder: was %d, requested %d.\n", bufSz, newSz);
1906             goto NLS_EnumCalendarInfoAW_Cleanup;
1907           }
1908           bufSz = newSz;
1909           WARN("Buffer too small; resizing to %d bytes.\n", bufSz);
1910           buf = HeapReAlloc(GetProcessHeap(), 0, buf, bufSz);
1911           if (buf == NULL)
1912             goto NLS_EnumCalendarInfoAW_Cleanup;
1913         } else goto NLS_EnumCalendarInfoAW_Cleanup;
1914       }
1915     } while (!ret);
1916
1917     /* Here we are. We pass the buffer to the correct version of
1918      * the callback. Because it's not the same number of params,
1919      * we must check for Ex, but we don't care about Unicode
1920      * because the buffer is already in the correct format.
1921      */
1922     if (ex) {
1923       ret = ((CALINFO_ENUMPROCEXW)calinfoproc)(buf, calendar);
1924     } else
1925       ret = ((CALINFO_ENUMPROCW)calinfoproc)(buf);
1926
1927     if (!ret) {                 /* the callback told to stop */
1928       ret = TRUE;
1929       break;
1930     }
1931
1932     if ((iter == NULL) || (*iter == 0)) /* no more calendars */
1933       break;
1934
1935     calendar = 0;
1936     while ((*iter >= '0') && (*iter <= '9'))
1937       calendar = calendar * 10 + *iter++ - '0';
1938
1939     if (*iter++ != 0)
1940     {
1941       SetLastError(ERROR_BADDB);
1942       ret = FALSE;
1943       break;
1944     }
1945   }
1946
1947 NLS_EnumCalendarInfoAW_Cleanup:
1948   HeapFree(GetProcessHeap(), 0, opt);
1949   HeapFree(GetProcessHeap(), 0, buf);
1950   return ret;
1951 }
1952
1953 /******************************************************************************
1954  *              EnumCalendarInfoA       [KERNEL32.@]
1955  *
1956  * See EnumCalendarInfoAW.
1957  */
1958 BOOL WINAPI EnumCalendarInfoA( CALINFO_ENUMPROCA calinfoproc,LCID locale,
1959                                CALID calendar,CALTYPE caltype )
1960 {
1961   TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
1962   return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, FALSE, FALSE);
1963 }
1964
1965 /******************************************************************************
1966  *              EnumCalendarInfoW       [KERNEL32.@]
1967  *
1968  * See EnumCalendarInfoAW.
1969  */
1970 BOOL WINAPI EnumCalendarInfoW( CALINFO_ENUMPROCW calinfoproc,LCID locale,
1971                                CALID calendar,CALTYPE caltype )
1972 {
1973   TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
1974   return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, TRUE, FALSE);
1975 }
1976
1977 /******************************************************************************
1978  *              EnumCalendarInfoExA     [KERNEL32.@]
1979  *
1980  * See EnumCalendarInfoAW.
1981  */
1982 BOOL WINAPI EnumCalendarInfoExA( CALINFO_ENUMPROCEXA calinfoproc,LCID locale,
1983                                  CALID calendar,CALTYPE caltype )
1984 {
1985   TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
1986   return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, FALSE, TRUE);
1987 }
1988
1989 /******************************************************************************
1990  *              EnumCalendarInfoExW     [KERNEL32.@]
1991  *
1992  * See EnumCalendarInfoAW.
1993  */
1994 BOOL WINAPI EnumCalendarInfoExW( CALINFO_ENUMPROCEXW calinfoproc,LCID locale,
1995                                  CALID calendar,CALTYPE caltype )
1996 {
1997   TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
1998   return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, TRUE, TRUE);
1999 }