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