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