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