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