?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d9/tests: Add a test for cube texture mipmap autogeneration.
[wine.git] / dlls / kernel32 / lcformat.c
blobecadd435d4d545d656e82a8b9906648a912717be
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 == '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 * GetNumberFormatEx (KERNEL32.@)
1349 */
1350 INT WINAPI GetNumberFormatEx(LPCWSTR name, DWORD flags,
1351 LPCWSTR value, const NUMBERFMTW *format,
1352 LPWSTR number, int numout)
1353 {
1354 LCID lcid;
1355
1356 TRACE("(%s,0x%08x,%s,%p,%p,%d)\n", debugstr_w(name), flags,
1357 debugstr_w(value), format, number, numout);
1358
1359 lcid = LocaleNameToLCID(name, 0);
1360 if (!lcid)
1361 return 0;
1362
1363 return GetNumberFormatW(lcid, flags, value, format, number, numout);
1364 }
1365
1366 /**************************************************************************
1367 * GetCurrencyFormatA (KERNEL32.@)
1368 *
1369 * Format a currency string for a given locale.
1370 *
1371 * PARAMS
1372 * lcid [I] Locale to format for
1373 * dwFlags [I] LOCALE_ flags from "winnls.h"
1374 * lpszValue [I] String to format
1375 * lpFormat [I] Formatting overrides
1376 * lpCurrencyStr [O] Destination for formatted string
1377 * cchOut [I] Size of lpCurrencyStr, or 0 to calculate the resulting size
1378 *
1379 * NOTES
1380 * - lpszValue can contain only '0' - '9', '-' and '.'.
1381 * - If lpFormat is non-NULL, dwFlags must be 0. In this case lpszValue will
1382 * be formatted according to the format details returned by GetLocaleInfoA().
1383 * - This function rounds the currency if the number of decimals exceeds the
1384 * locales number of currency decimal places.
1385 * - If cchOut is 0, this function does not write to lpCurrencyStr.
1386 * - The Ascii version of this function fails if lcid is Unicode only.
1387 *
1388 * RETURNS
1389 * Success: The number of character written to lpNumberStr, or that would
1390 * have been written, if cchOut is 0.
1391 * Failure: 0. Use GetLastError() to determine the cause.
1392 */
1393 INT WINAPI GetCurrencyFormatA(LCID lcid, DWORD dwFlags,
1394 LPCSTR lpszValue, const CURRENCYFMTA *lpFormat,
1395 LPSTR lpCurrencyStr, int cchOut)
1396 {
1397 DWORD cp = CP_ACP;
1398 WCHAR szDec[8], szGrp[8], szCy[8], szIn[128], szOut[128];
1399 CURRENCYFMTW fmt;
1400 const CURRENCYFMTW *pfmt = NULL;
1401 INT iRet;
1402
1403 TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_a(lpszValue),
1404 lpFormat, lpCurrencyStr, cchOut);
1405
1406 if (NLS_IsUnicodeOnlyLcid(lcid))
1407 {
1408 SetLastError(ERROR_INVALID_PARAMETER);
1409 return 0;
1410 }
1411
1412 if (!(dwFlags & LOCALE_USE_CP_ACP))
1413 {
1414 const NLS_FORMAT_NODE *node = NLS_GetFormats(lcid, dwFlags);
1415 if (!node)
1416 {
1417 SetLastError(ERROR_INVALID_PARAMETER);
1418 return 0;
1419 }
1420
1421 cp = node->dwCodePage;
1422 }
1423
1424 if (lpFormat)
1425 {
1426 memcpy(&fmt, lpFormat, sizeof(fmt));
1427 pfmt = &fmt;
1428 if (lpFormat->lpDecimalSep)
1429 {
1430 MultiByteToWideChar(cp, 0, lpFormat->lpDecimalSep, -1, szDec, sizeof(szDec)/sizeof(WCHAR));
1431 fmt.lpDecimalSep = szDec;
1432 }
1433 if (lpFormat->lpThousandSep)
1434 {
1435 MultiByteToWideChar(cp, 0, lpFormat->lpThousandSep, -1, szGrp, sizeof(szGrp)/sizeof(WCHAR));
1436 fmt.lpThousandSep = szGrp;
1437 }
1438 if (lpFormat->lpCurrencySymbol)
1439 {
1440 MultiByteToWideChar(cp, 0, lpFormat->lpCurrencySymbol, -1, szCy, sizeof(szCy)/sizeof(WCHAR));
1441 fmt.lpCurrencySymbol = szCy;
1442 }
1443 }
1444
1445 if (lpszValue)
1446 MultiByteToWideChar(cp, 0, lpszValue, -1, szIn, sizeof(szIn)/sizeof(WCHAR));
1447
1448 if (cchOut > (int)(sizeof(szOut)/sizeof(WCHAR)))
1449 cchOut = sizeof(szOut)/sizeof(WCHAR);
1450
1451 szOut[0] = '\0';
1452
1453 iRet = GetCurrencyFormatW(lcid, dwFlags, lpszValue ? szIn : NULL, pfmt,
1454 lpCurrencyStr ? szOut : NULL, cchOut);
1455
1456 if (szOut[0] && lpCurrencyStr)
1457 WideCharToMultiByte(cp, 0, szOut, -1, lpCurrencyStr, cchOut, 0, 0);
1458 return iRet;
1459 }
1460
1461 /* Formatting states for Currencies. We use flags to avoid code duplication. */
1462 #define CF_PARENS 0x1 /* Parentheses */
1463 #define CF_MINUS_LEFT 0x2 /* '-' to the left */
1464 #define CF_MINUS_RIGHT 0x4 /* '-' to the right */
1465 #define CF_MINUS_BEFORE 0x8 /* '-' before '$' */
1466 #define CF_CY_LEFT 0x10 /* '$' to the left */
1467 #define CF_CY_RIGHT 0x20 /* '$' to the right */
1468 #define CF_CY_SPACE 0x40 /* ' ' by '$' */
1469
1470 /**************************************************************************
1471 * GetCurrencyFormatW (KERNEL32.@)
1472 *
1473 * See GetCurrencyFormatA.
1474 */
1475 INT WINAPI GetCurrencyFormatW(LCID lcid, DWORD dwFlags,
1476 LPCWSTR lpszValue, const CURRENCYFMTW *lpFormat,
1477 LPWSTR lpCurrencyStr, int cchOut)
1478 {
1479 static const BYTE NLS_NegCyFormats[16] =
1480 {
1481 CF_PARENS|CF_CY_LEFT, /* ($1.1) */
1482 CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT, /* -$1.1 */
1483 CF_MINUS_LEFT|CF_CY_LEFT, /* $-1.1 */
1484 CF_MINUS_RIGHT|CF_CY_LEFT, /* $1.1- */
1485 CF_PARENS|CF_CY_RIGHT, /* (1.1$) */
1486 CF_MINUS_LEFT|CF_CY_RIGHT, /* -1.1$ */
1487 CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT, /* 1.1-$ */
1488 CF_MINUS_RIGHT|CF_CY_RIGHT, /* 1.1$- */
1489 CF_MINUS_LEFT|CF_CY_RIGHT|CF_CY_SPACE, /* -1.1 $ */
1490 CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT|CF_CY_SPACE, /* -$ 1.1 */
1491 CF_MINUS_RIGHT|CF_CY_RIGHT|CF_CY_SPACE, /* 1.1 $- */
1492 CF_MINUS_RIGHT|CF_CY_LEFT|CF_CY_SPACE, /* $ 1.1- */
1493 CF_MINUS_LEFT|CF_CY_LEFT|CF_CY_SPACE, /* $ -1.1 */
1494 CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT|CF_CY_SPACE, /* 1.1- $ */
1495 CF_PARENS|CF_CY_LEFT|CF_CY_SPACE, /* ($ 1.1) */
1496 CF_PARENS|CF_CY_RIGHT|CF_CY_SPACE, /* (1.1 $) */
1497 };
1498 static const BYTE NLS_PosCyFormats[4] =
1499 {
1500 CF_CY_LEFT, /* $1.1 */
1501 CF_CY_RIGHT, /* 1.1$ */
1502 CF_CY_LEFT|CF_CY_SPACE, /* $ 1.1 */
1503 CF_CY_RIGHT|CF_CY_SPACE, /* 1.1 $ */
1504 };
1505 WCHAR szBuff[128], *szOut = szBuff + sizeof(szBuff) / sizeof(WCHAR) - 1;
1506 WCHAR szNegBuff[8];
1507 const WCHAR *lpszNeg = NULL, *lpszNegStart, *szSrc, *lpszCy, *lpszCyStart;
1508 DWORD dwState = 0, dwDecimals = 0, dwGroupCount = 0, dwCurrentGroupCount = 0, dwFmt;
1509 INT iRet;
1510
1511 TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_w(lpszValue),
1512 lpFormat, lpCurrencyStr, cchOut);
1513
1514 if (!lpszValue || cchOut < 0 || (cchOut > 0 && !lpCurrencyStr) ||
1515 !IsValidLocale(lcid, 0) ||
1516 (lpFormat && (dwFlags || !lpFormat->lpDecimalSep || !lpFormat->lpThousandSep ||
1517 !lpFormat->lpCurrencySymbol || lpFormat->NegativeOrder > 15 ||
1518 lpFormat->PositiveOrder > 3)))
1519 {
1520 goto error;
1521 }
1522
1523 if (!lpFormat)
1524 {
1525 const NLS_FORMAT_NODE *node = NLS_GetFormats(lcid, dwFlags);
1526
1527 if (!node)
1528 goto error;
1529
1530 lpFormat = &node->cyfmt;
1531 lpszNegStart = lpszNeg = GetNegative(node);
1532 }
1533 else
1534 {
1535 GetLocaleInfoW(lcid, LOCALE_SNEGATIVESIGN|(dwFlags & LOCALE_NOUSEROVERRIDE),
1536 szNegBuff, sizeof(szNegBuff)/sizeof(WCHAR));
1537 lpszNegStart = lpszNeg = szNegBuff;
1538 }
1539 dwFlags &= (LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP);
1540
1541 lpszNeg = lpszNeg + strlenW(lpszNeg) - 1;
1542 lpszCyStart = lpFormat->lpCurrencySymbol;
1543 lpszCy = lpszCyStart + strlenW(lpszCyStart) - 1;
1544
1545 /* Format the currency backwards into a temporary buffer */
1546
1547 szSrc = lpszValue;
1548 *szOut-- = '\0';
1549
1550 /* Check the number for validity */
1551 while (*szSrc)
1552 {
1553 if (*szSrc >= '0' && *szSrc <= '9')
1554 {
1555 dwState |= NF_DIGITS;
1556 if (dwState & NF_ISREAL)
1557 dwDecimals++;
1558 }
1559 else if (*szSrc == '-')
1560 {
1561 if (dwState)
1562 goto error; /* '-' not first character */
1563 dwState |= NF_ISNEGATIVE;
1564 }
1565 else if (*szSrc == '.')
1566 {
1567 if (dwState & NF_ISREAL)
1568 goto error; /* More than one '.' */
1569 dwState |= NF_ISREAL;
1570 }
1571 else
1572 goto error; /* Invalid char */
1573 szSrc++;
1574 }
1575 szSrc--; /* Point to last character */
1576
1577 if (!(dwState & NF_DIGITS))
1578 goto error; /* No digits */
1579
1580 if (dwState & NF_ISNEGATIVE)
1581 dwFmt = NLS_NegCyFormats[lpFormat->NegativeOrder];
1582 else
1583 dwFmt = NLS_PosCyFormats[lpFormat->PositiveOrder];
1584
1585 /* Add any trailing negative or currency signs */
1586 if (dwFmt & CF_PARENS)
1587 *szOut-- = ')';
1588
1589 while (dwFmt & (CF_MINUS_RIGHT|CF_CY_RIGHT))
1590 {
1591 switch (dwFmt & (CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT))
1592 {
1593 case CF_MINUS_RIGHT:
1594 case CF_MINUS_RIGHT|CF_CY_RIGHT:
1595 while (lpszNeg >= lpszNegStart)
1596 *szOut-- = *lpszNeg--;
1597 dwFmt &= ~CF_MINUS_RIGHT;
1598 break;
1599
1600 case CF_CY_RIGHT:
1601 case CF_MINUS_BEFORE|CF_CY_RIGHT:
1602 case CF_MINUS_RIGHT|CF_MINUS_BEFORE|CF_CY_RIGHT:
1603 while (lpszCy >= lpszCyStart)
1604 *szOut-- = *lpszCy--;
1605 if (dwFmt & CF_CY_SPACE)
1606 *szOut-- = ' ';
1607 dwFmt &= ~(CF_CY_RIGHT|CF_MINUS_BEFORE);
1608 break;
1609 }
1610 }
1611
1612 /* Copy all digits up to the decimal point */
1613 if (!lpFormat->NumDigits)
1614 {
1615 if (dwState & NF_ISREAL)
1616 {
1617 while (*szSrc != '.') /* Don't write any decimals or a separator */
1618 {
1619 if (*szSrc >= '5' || (*szSrc == '4' && (dwState & NF_ROUND)))
1620 dwState |= NF_ROUND;
1621 else
1622 dwState &= ~NF_ROUND;
1623 szSrc--;
1624 }
1625 szSrc--;
1626 }
1627 }
1628 else
1629 {
1630 LPWSTR lpszDec = lpFormat->lpDecimalSep + strlenW(lpFormat->lpDecimalSep) - 1;
1631
1632 if (dwDecimals <= lpFormat->NumDigits)
1633 {
1634 dwDecimals = lpFormat->NumDigits - dwDecimals;
1635 while (dwDecimals--)
1636 *szOut-- = '0'; /* Pad to correct number of dp */
1637 }
1638 else
1639 {
1640 dwDecimals -= lpFormat->NumDigits;
1641 /* Skip excess decimals, and determine if we have to round the number */
1642 while (dwDecimals--)
1643 {
1644 if (*szSrc >= '5' || (*szSrc == '4' && (dwState & NF_ROUND)))
1645 dwState |= NF_ROUND;
1646 else
1647 dwState &= ~NF_ROUND;
1648 szSrc--;
1649 }
1650 }
1651
1652 if (dwState & NF_ISREAL)
1653 {
1654 while (*szSrc != '.')
1655 {
1656 if (dwState & NF_ROUND)
1657 {
1658 if (*szSrc == '9')
1659 *szOut-- = '0'; /* continue rounding */
1660 else
1661 {
1662 dwState &= ~NF_ROUND;
1663 *szOut-- = (*szSrc)+1;
1664 }
1665 szSrc--;
1666 }
1667 else
1668 *szOut-- = *szSrc--; /* Write existing decimals */
1669 }
1670 szSrc--; /* Skip '.' */
1671 }
1672 while (lpszDec >= lpFormat->lpDecimalSep)
1673 *szOut-- = *lpszDec--; /* Write decimal separator */
1674 }
1675
1676 dwGroupCount = lpFormat->Grouping;
1677
1678 /* Write the remaining whole number digits, including grouping chars */
1679 while (szSrc >= lpszValue && *szSrc >= '0' && *szSrc <= '9')
1680 {
1681 if (dwState & NF_ROUND)
1682 {
1683 if (*szSrc == '9')
1684 *szOut-- = '0'; /* continue rounding */
1685 else
1686 {
1687 dwState &= ~NF_ROUND;
1688 *szOut-- = (*szSrc)+1;
1689 }
1690 szSrc--;
1691 }
1692 else
1693 *szOut-- = *szSrc--;
1694
1695 dwState |= NF_DIGITS_OUT;
1696 dwCurrentGroupCount++;
1697 if (szSrc >= lpszValue && dwCurrentGroupCount == dwGroupCount && *szSrc != '-')
1698 {
1699 LPWSTR lpszGrp = lpFormat->lpThousandSep + strlenW(lpFormat->lpThousandSep) - 1;
1700
1701 while (lpszGrp >= lpFormat->lpThousandSep)
1702 *szOut-- = *lpszGrp--; /* Write grouping char */
1703
1704 dwCurrentGroupCount = 0;
1705 }
1706 }
1707 if (dwState & NF_ROUND)
1708 *szOut-- = '1'; /* e.g. .6 > 1.0 */
1709 else if (!(dwState & NF_DIGITS_OUT) && lpFormat->LeadingZero)
1710 *szOut-- = '0'; /* Add leading 0 if we have no digits before the decimal point */
1711
1712 /* Add any leading negative or currency sign */
1713 while (dwFmt & (CF_MINUS_LEFT|CF_CY_LEFT))
1714 {
1715 switch (dwFmt & (CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT))
1716 {
1717 case CF_MINUS_LEFT:
1718 case CF_MINUS_LEFT|CF_CY_LEFT:
1719 while (lpszNeg >= lpszNegStart)
1720 *szOut-- = *lpszNeg--;
1721 dwFmt &= ~CF_MINUS_LEFT;
1722 break;
1723
1724 case CF_CY_LEFT:
1725 case CF_CY_LEFT|CF_MINUS_BEFORE:
1726 case CF_MINUS_LEFT|CF_MINUS_BEFORE|CF_CY_LEFT:
1727 if (dwFmt & CF_CY_SPACE)
1728 *szOut-- = ' ';
1729 while (lpszCy >= lpszCyStart)
1730 *szOut-- = *lpszCy--;
1731 dwFmt &= ~(CF_CY_LEFT|CF_MINUS_BEFORE);
1732 break;
1733 }
1734 }
1735 if (dwFmt & CF_PARENS)
1736 *szOut-- = '(';
1737 szOut++;
1738
1739 iRet = strlenW(szOut) + 1;
1740 if (cchOut)
1741 {
1742 if (iRet <= cchOut)
1743 memcpy(lpCurrencyStr, szOut, iRet * sizeof(WCHAR));
1744 else
1745 {
1746 memcpy(lpCurrencyStr, szOut, cchOut * sizeof(WCHAR));
1747 lpCurrencyStr[cchOut - 1] = '\0';
1748 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1749 iRet = 0;
1750 }
1751 }
1752 return iRet;
1753
1754 error:
1755 SetLastError(lpFormat && dwFlags ? ERROR_INVALID_FLAGS : ERROR_INVALID_PARAMETER);
1756 return 0;
1757 }
1758
1759 /* FIXME: Everything below here needs to move somewhere else along with the
1760 * other EnumXXX functions, when a method for storing resources for
1761 * alternate calendars is determined.
1762 */
1763
1764 enum enum_callback_type {
1765 CALLBACK_ENUMPROC,
1766 CALLBACK_ENUMPROCEX,
1767 CALLBACK_ENUMPROCEXEX
1768 };
1769
1770 struct enumdateformats_context {
1771 enum enum_callback_type type; /* callback kind */
1772 union {
1773 DATEFMT_ENUMPROCW callback; /* user callback pointer */
1774 DATEFMT_ENUMPROCEXW callbackex;
1775 DATEFMT_ENUMPROCEXEX callbackexex;
1776 } u;
1777 LCID lcid; /* locale of interest */
1778 DWORD flags;
1779 LPARAM lParam;
1780 BOOL unicode; /* A vs W callback type, only for regular and Ex callbacks */
1781 };
1782
1783 /******************************************************************************
1784 * NLS_EnumDateFormats <internal>
1785 * Enumerates date formats for a specified locale.
1786 *
1787 * PARAMS
1788 * ctxt [I] enumeration context, see 'struct enumdateformats_context'
1789 *
1790 * RETURNS
1791 * Success: TRUE.
1792 * Failure: FALSE. Use GetLastError() to determine the cause.
1793 */
1794 static BOOL NLS_EnumDateFormats(const struct enumdateformats_context *ctxt)
1795 {
1796 WCHAR bufW[256];
1797 char bufA[256];
1798 LCTYPE lctype;
1799 CALID cal_id;
1800 INT ret;
1801
1802 if (!ctxt->u.callback)
1803 {
1804 SetLastError(ERROR_INVALID_PARAMETER);
1805 return FALSE;
1806 }
1807
1808 if (!GetLocaleInfoW(ctxt->lcid, LOCALE_ICALENDARTYPE|LOCALE_RETURN_NUMBER, (LPWSTR)&cal_id, sizeof(cal_id)/sizeof(WCHAR)))
1809 return FALSE;
1810
1811 switch (ctxt->flags & ~LOCALE_USE_CP_ACP)
1812 {
1813 case 0:
1814 case DATE_SHORTDATE:
1815 lctype = LOCALE_SSHORTDATE;
1816 break;
1817 case DATE_LONGDATE:
1818 lctype = LOCALE_SLONGDATE;
1819 break;
1820 case DATE_YEARMONTH:
1821 lctype = LOCALE_SYEARMONTH;
1822 break;
1823 default:
1824 FIXME("Unknown date format (0x%08x)\n", ctxt->flags);
1825 SetLastError(ERROR_INVALID_PARAMETER);
1826 return FALSE;
1827 }
1828
1829 lctype |= ctxt->flags & LOCALE_USE_CP_ACP;
1830 if (ctxt->unicode)
1831 ret = GetLocaleInfoW(ctxt->lcid, lctype, bufW, sizeof(bufW)/sizeof(bufW[0]));
1832 else
1833 ret = GetLocaleInfoA(ctxt->lcid, lctype, bufA, sizeof(bufA)/sizeof(bufA[0]));
1834
1835 if (ret)
1836 {
1837 switch (ctxt->type)
1838 {
1839 case CALLBACK_ENUMPROC:
1840 ctxt->u.callback(ctxt->unicode ? bufW : (WCHAR*)bufA);
1841 break;
1842 case CALLBACK_ENUMPROCEX:
1843 ctxt->u.callbackex(ctxt->unicode ? bufW : (WCHAR*)bufA, cal_id);
1844 break;
1845 case CALLBACK_ENUMPROCEXEX:
1846 ctxt->u.callbackexex(bufW, cal_id, ctxt->lParam);
1847 break;
1848 default:
1849 ;
1850 }
1851 }
1852
1853 return TRUE;
1854 }
1855
1856 /**************************************************************************
1857 * EnumDateFormatsExA (KERNEL32.@)
1858 *
1859 * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1860 * LOCALE_NOUSEROVERRIDE here as well?
1861 */
1862 BOOL WINAPI EnumDateFormatsExA(DATEFMT_ENUMPROCEXA proc, LCID lcid, DWORD flags)
1863 {
1864 struct enumdateformats_context ctxt;
1865
1866 ctxt.type = CALLBACK_ENUMPROCEX;
1867 ctxt.u.callbackex = (DATEFMT_ENUMPROCEXW)proc;
1868 ctxt.lcid = lcid;
1869 ctxt.flags = flags;
1870 ctxt.unicode = FALSE;
1871
1872 return NLS_EnumDateFormats(&ctxt);
1873 }
1874
1875 /**************************************************************************
1876 * EnumDateFormatsExW (KERNEL32.@)
1877 */
1878 BOOL WINAPI EnumDateFormatsExW(DATEFMT_ENUMPROCEXW proc, LCID lcid, DWORD flags)
1879 {
1880 struct enumdateformats_context ctxt;
1881
1882 ctxt.type = CALLBACK_ENUMPROCEX;
1883 ctxt.u.callbackex = proc;
1884 ctxt.lcid = lcid;
1885 ctxt.flags = flags;
1886 ctxt.unicode = TRUE;
1887
1888 return NLS_EnumDateFormats(&ctxt);
1889 }
1890
1891 /**************************************************************************
1892 * EnumDateFormatsA (KERNEL32.@)
1893 *
1894 * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1895 * LOCALE_NOUSEROVERRIDE here as well?
1896 */
1897 BOOL WINAPI EnumDateFormatsA(DATEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
1898 {
1899 struct enumdateformats_context ctxt;
1900
1901 ctxt.type = CALLBACK_ENUMPROC;
1902 ctxt.u.callback = (DATEFMT_ENUMPROCW)proc;
1903 ctxt.lcid = lcid;
1904 ctxt.flags = flags;
1905 ctxt.unicode = FALSE;
1906
1907 return NLS_EnumDateFormats(&ctxt);
1908 }
1909
1910 /**************************************************************************
1911 * EnumDateFormatsW (KERNEL32.@)
1912 */
1913 BOOL WINAPI EnumDateFormatsW(DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)
1914 {
1915 struct enumdateformats_context ctxt;
1916
1917 ctxt.type = CALLBACK_ENUMPROC;
1918 ctxt.u.callback = proc;
1919 ctxt.lcid = lcid;
1920 ctxt.flags = flags;
1921 ctxt.unicode = TRUE;
1922
1923 return NLS_EnumDateFormats(&ctxt);
1924 }
1925
1926 /**************************************************************************
1927 * EnumDateFormatsExEx (KERNEL32.@)
1928 */
1929 BOOL WINAPI EnumDateFormatsExEx(DATEFMT_ENUMPROCEXEX proc, const WCHAR *locale, DWORD flags, LPARAM lParam)
1930 {
1931 struct enumdateformats_context ctxt;
1932
1933 ctxt.type = CALLBACK_ENUMPROCEXEX;
1934 ctxt.u.callbackexex = proc;
1935 ctxt.lcid = LocaleNameToLCID(locale, 0);
1936 ctxt.flags = flags;
1937 ctxt.lParam = lParam;
1938 ctxt.unicode = TRUE;
1939
1940 return NLS_EnumDateFormats(&ctxt);
1941 }
1942
1943 struct enumtimeformats_context {
1944 enum enum_callback_type type; /* callback kind */
1945 union {
1946 TIMEFMT_ENUMPROCW callback; /* user callback pointer */
1947 TIMEFMT_ENUMPROCEX callbackex;
1948 } u;
1949 LCID lcid; /* locale of interest */
1950 DWORD flags;
1951 LPARAM lParam;
1952 BOOL unicode; /* A vs W callback type, only for regular and Ex callbacks */
1953 };
1954
1955 static BOOL NLS_EnumTimeFormats(struct enumtimeformats_context *ctxt)
1956 {
1957 WCHAR bufW[256];
1958 char bufA[256];
1959 LCTYPE lctype;
1960 INT ret;
1961
1962 if (!ctxt->u.callback)
1963 {
1964 SetLastError(ERROR_INVALID_PARAMETER);
1965 return FALSE;
1966 }
1967
1968 switch (ctxt->flags & ~LOCALE_USE_CP_ACP)
1969 {
1970 case 0:
1971 lctype = LOCALE_STIMEFORMAT;
1972 break;
1973 case TIME_NOSECONDS:
1974 lctype = LOCALE_SSHORTTIME;
1975 break;
1976 default:
1977 FIXME("Unknown time format (%d)\n", ctxt->flags);
1978 SetLastError(ERROR_INVALID_PARAMETER);
1979 return FALSE;
1980 }
1981
1982 lctype |= ctxt->flags & LOCALE_USE_CP_ACP;
1983 if (ctxt->unicode)
1984 ret = GetLocaleInfoW(ctxt->lcid, lctype, bufW, sizeof(bufW)/sizeof(bufW[0]));
1985 else
1986 ret = GetLocaleInfoA(ctxt->lcid, lctype, bufA, sizeof(bufA)/sizeof(bufA[0]));
1987
1988 if (ret)
1989 {
1990 switch (ctxt->type)
1991 {
1992 case CALLBACK_ENUMPROC:
1993 ctxt->u.callback(ctxt->unicode ? bufW : (WCHAR*)bufA);
1994 break;
1995 case CALLBACK_ENUMPROCEX:
1996 ctxt->u.callbackex(bufW, ctxt->lParam);
1997 break;
1998 default:
1999 ;
2000 }
2001 }
2002
2003 return TRUE;
2004 }
2005
2006 /**************************************************************************
2007 * EnumTimeFormatsA (KERNEL32.@)
2008 *
2009 * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
2010 * LOCALE_NOUSEROVERRIDE here as well?
2011 */
2012 BOOL WINAPI EnumTimeFormatsA(TIMEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
2013 {
2014 struct enumtimeformats_context ctxt;
2015
2016 /* EnumTimeFormatsA doesn't support flags, EnumTimeFormatsW does. */
2017 if (flags & ~LOCALE_USE_CP_ACP)
2018 {
2019 SetLastError(ERROR_INVALID_FLAGS);
2020 return FALSE;
2021 }
2022
2023 ctxt.type = CALLBACK_ENUMPROC;
2024 ctxt.u.callback = (TIMEFMT_ENUMPROCW)proc;
2025 ctxt.lcid = lcid;
2026 ctxt.flags = flags;
2027 ctxt.unicode = FALSE;
2028
2029 return NLS_EnumTimeFormats(&ctxt);
2030 }
2031
2032 /**************************************************************************
2033 * EnumTimeFormatsW (KERNEL32.@)
2034 */
2035 BOOL WINAPI EnumTimeFormatsW(TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)
2036 {
2037 struct enumtimeformats_context ctxt;
2038
2039 ctxt.type = CALLBACK_ENUMPROC;
2040 ctxt.u.callback = proc;
2041 ctxt.lcid = lcid;
2042 ctxt.flags = flags;
2043 ctxt.unicode = TRUE;
2044
2045 return NLS_EnumTimeFormats(&ctxt);
2046 }
2047
2048 /**************************************************************************
2049 * EnumTimeFormatsEx (KERNEL32.@)
2050 */
2051 BOOL WINAPI EnumTimeFormatsEx(TIMEFMT_ENUMPROCEX proc, const WCHAR *locale, DWORD flags, LPARAM lParam)
2052 {
2053 struct enumtimeformats_context ctxt;
2054
2055 ctxt.type = CALLBACK_ENUMPROCEX;
2056 ctxt.u.callbackex = proc;
2057 ctxt.lcid = LocaleNameToLCID(locale, 0);
2058 ctxt.flags = flags;
2059 ctxt.lParam = lParam;
2060 ctxt.unicode = TRUE;
2061
2062 return NLS_EnumTimeFormats(&ctxt);
2063 }
2064
2065 struct enumcalendar_context {
2066 enum enum_callback_type type; /* callback kind */
2067 union {
2068 CALINFO_ENUMPROCW callback; /* user callback pointer */
2069 CALINFO_ENUMPROCEXW callbackex;
2070 CALINFO_ENUMPROCEXEX callbackexex;
2071 } u;
2072 LCID lcid; /* locale of interest */
2073 CALID calendar; /* specific calendar or ENUM_ALL_CALENDARS */
2074 CALTYPE caltype; /* calendar information type */
2075 LPARAM lParam; /* user input parameter passed to callback, for ExEx case only */
2076 BOOL unicode; /* A vs W callback type, only for regular and Ex callbacks */
2077 };
2078
2079 /******************************************************************************
2080 * NLS_EnumCalendarInfo <internal>
2081 * Enumerates calendar information for a specified locale.
2082 *
2083 * PARAMS
2084 * ctxt [I] enumeration context, see 'struct enumcalendar_context'
2085 *
2086 * RETURNS
2087 * Success: TRUE.
2088 * Failure: FALSE. Use GetLastError() to determine the cause.
2089 *
2090 * NOTES
2091 * When the ANSI version of this function is used with a Unicode-only LCID,
2092 * the call can succeed because the system uses the system code page.
2093 * However, characters that are undefined in the system code page appear
2094 * in the string as a question mark (?).
2095 *
2096 * TODO
2097 * The above note should be respected by GetCalendarInfoA.
2098 */
2099 static BOOL NLS_EnumCalendarInfo(const struct enumcalendar_context *ctxt)
2100 {
2101 WCHAR *buf, *opt = NULL, *iter = NULL;
2102 CALID calendar = ctxt->calendar;
2103 BOOL ret = FALSE;
2104 int bufSz = 200; /* the size of the buffer */
2105
2106 if (ctxt->u.callback == NULL)
2107 {
2108 SetLastError(ERROR_INVALID_PARAMETER);
2109 return FALSE;
2110 }
2111
2112 buf = HeapAlloc(GetProcessHeap(), 0, bufSz);
2113 if (buf == NULL)
2114 {
2115 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2116 return FALSE;
2117 }
2118
2119 if (calendar == ENUM_ALL_CALENDARS)
2120 {
2121 int optSz = GetLocaleInfoW(ctxt->lcid, LOCALE_IOPTIONALCALENDAR, NULL, 0);
2122 if (optSz > 1)
2123 {
2124 opt = HeapAlloc(GetProcessHeap(), 0, optSz * sizeof(WCHAR));
2125 if (opt == NULL)
2126 {
2127 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2128 goto cleanup;
2129 }
2130 if (GetLocaleInfoW(ctxt->lcid, LOCALE_IOPTIONALCALENDAR, opt, optSz))
2131 iter = opt;
2132 }
2133 calendar = NLS_GetLocaleNumber(ctxt->lcid, LOCALE_ICALENDARTYPE);
2134 }
2135
2136 while (TRUE) /* loop through calendars */
2137 {
2138 do /* loop until there's no error */
2139 {
2140 if (ctxt->caltype & CAL_RETURN_NUMBER)
2141 ret = GetCalendarInfoW(ctxt->lcid, calendar, ctxt->caltype, NULL, bufSz / sizeof(WCHAR), (LPDWORD)buf);
2142 else if (ctxt->unicode)
2143 ret = GetCalendarInfoW(ctxt->lcid, calendar, ctxt->caltype, buf, bufSz / sizeof(WCHAR), NULL);
2144 else ret = GetCalendarInfoA(ctxt->lcid, calendar, ctxt->caltype, (CHAR*)buf, bufSz / sizeof(CHAR), NULL);
2145
2146 if (!ret)
2147 {
2148 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
2149 { /* so resize it */
2150 int newSz;
2151 if (ctxt->unicode)
2152 newSz = GetCalendarInfoW(ctxt->lcid, calendar, ctxt->caltype, NULL, 0, NULL) * sizeof(WCHAR);
2153 else newSz = GetCalendarInfoA(ctxt->lcid, calendar, ctxt->caltype, NULL, 0, NULL) * sizeof(CHAR);
2154 if (bufSz >= newSz)
2155 {
2156 ERR("Buffer resizing disorder: was %d, requested %d.\n", bufSz, newSz);
2157 goto cleanup;
2158 }
2159 bufSz = newSz;
2160 WARN("Buffer too small; resizing to %d bytes.\n", bufSz);
2161 buf = HeapReAlloc(GetProcessHeap(), 0, buf, bufSz);
2162 if (buf == NULL)
2163 goto cleanup;
2164 } else goto cleanup;
2165 }
2166 } while (!ret);
2167
2168 /* Here we are. We pass the buffer to the correct version of
2169 * the callback. Because it's not the same number of params,
2170 * we must check for Ex, but we don't care about Unicode
2171 * because the buffer is already in the correct format.
2172 */
2173 switch (ctxt->type)
2174 {
2175 case CALLBACK_ENUMPROC:
2176 ret = ctxt->u.callback(buf);
2177 break;
2178 case CALLBACK_ENUMPROCEX:
2179 ret = ctxt->u.callbackex(buf, calendar);
2180 break;
2181 case CALLBACK_ENUMPROCEXEX:
2182 ret = ctxt->u.callbackexex(buf, calendar, NULL, ctxt->lParam);
2183 break;
2184 default:
2185 ;
2186 }
2187
2188 if (!ret) { /* the callback told to stop */
2189 ret = TRUE;
2190 break;
2191 }
2192
2193 if ((iter == NULL) || (*iter == 0)) /* no more calendars */
2194 break;
2195
2196 calendar = 0;
2197 while ((*iter >= '0') && (*iter <= '9'))
2198 calendar = calendar * 10 + *iter++ - '0';
2199
2200 if (*iter++ != 0)
2201 {
2202 SetLastError(ERROR_BADDB);
2203 ret = FALSE;
2204 break;
2205 }
2206 }
2207
2208 cleanup:
2209 HeapFree(GetProcessHeap(), 0, opt);
2210 HeapFree(GetProcessHeap(), 0, buf);
2211 return ret;
2212 }
2213
2214 /******************************************************************************
2215 * EnumCalendarInfoA [KERNEL32.@]
2216 */
2217 BOOL WINAPI EnumCalendarInfoA( CALINFO_ENUMPROCA calinfoproc,LCID locale,
2218 CALID calendar,CALTYPE caltype )
2219 {
2220 struct enumcalendar_context ctxt;
2221
2222 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
2223
2224 ctxt.type = CALLBACK_ENUMPROC;
2225 ctxt.u.callback = (CALINFO_ENUMPROCW)calinfoproc;
2226 ctxt.lcid = locale;
2227 ctxt.calendar = calendar;
2228 ctxt.caltype = caltype;
2229 ctxt.lParam = 0;
2230 ctxt.unicode = FALSE;
2231 return NLS_EnumCalendarInfo(&ctxt);
2232 }
2233
2234 /******************************************************************************
2235 * EnumCalendarInfoW [KERNEL32.@]
2236 */
2237 BOOL WINAPI EnumCalendarInfoW( CALINFO_ENUMPROCW calinfoproc,LCID locale,
2238 CALID calendar,CALTYPE caltype )
2239 {
2240 struct enumcalendar_context ctxt;
2241
2242 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
2243
2244 ctxt.type = CALLBACK_ENUMPROC;
2245 ctxt.u.callback = calinfoproc;
2246 ctxt.lcid = locale;
2247 ctxt.calendar = calendar;
2248 ctxt.caltype = caltype;
2249 ctxt.lParam = 0;
2250 ctxt.unicode = TRUE;
2251 return NLS_EnumCalendarInfo(&ctxt);
2252 }
2253
2254 /******************************************************************************
2255 * EnumCalendarInfoExA [KERNEL32.@]
2256 */
2257 BOOL WINAPI EnumCalendarInfoExA( CALINFO_ENUMPROCEXA calinfoproc,LCID locale,
2258 CALID calendar,CALTYPE caltype )
2259 {
2260 struct enumcalendar_context ctxt;
2261
2262 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
2263
2264 ctxt.type = CALLBACK_ENUMPROCEX;
2265 ctxt.u.callbackex = (CALINFO_ENUMPROCEXW)calinfoproc;
2266 ctxt.lcid = locale;
2267 ctxt.calendar = calendar;
2268 ctxt.caltype = caltype;
2269 ctxt.lParam = 0;
2270 ctxt.unicode = FALSE;
2271 return NLS_EnumCalendarInfo(&ctxt);
2272 }
2273
2274 /******************************************************************************
2275 * EnumCalendarInfoExW [KERNEL32.@]
2276 */
2277 BOOL WINAPI EnumCalendarInfoExW( CALINFO_ENUMPROCEXW calinfoproc,LCID locale,
2278 CALID calendar,CALTYPE caltype )
2279 {
2280 struct enumcalendar_context ctxt;
2281
2282 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
2283
2284 ctxt.type = CALLBACK_ENUMPROCEX;
2285 ctxt.u.callbackex = calinfoproc;
2286 ctxt.lcid = locale;
2287 ctxt.calendar = calendar;
2288 ctxt.caltype = caltype;
2289 ctxt.lParam = 0;
2290 ctxt.unicode = TRUE;
2291 return NLS_EnumCalendarInfo(&ctxt);
2292 }
2293
2294 /******************************************************************************
2295 * EnumCalendarInfoExEx [KERNEL32.@]
2296 */
2297 BOOL WINAPI EnumCalendarInfoExEx( CALINFO_ENUMPROCEXEX calinfoproc, LPCWSTR locale, CALID calendar,
2298 LPCWSTR reserved, CALTYPE caltype, LPARAM lParam)
2299 {
2300 struct enumcalendar_context ctxt;
2301
2302 TRACE("(%p,%s,0x%08x,%p,0x%08x,0x%ld)\n", calinfoproc, debugstr_w(locale), calendar, reserved, caltype, lParam);
2303
2304 ctxt.type = CALLBACK_ENUMPROCEXEX;
2305 ctxt.u.callbackexex = calinfoproc;
2306 ctxt.lcid = LocaleNameToLCID(locale, 0);
2307 ctxt.calendar = calendar;
2308 ctxt.caltype = caltype;
2309 ctxt.lParam = lParam;
2310 ctxt.unicode = TRUE;
2311 return NLS_EnumCalendarInfo(&ctxt);
2312 }
Windows API implementation