2 * Locale-dependent format handling
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
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.
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.
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
26 #include "wine/port.h"
35 #include "wine/unicode.h"
36 #include "wine/debug.h"
39 #include "kernel_private.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(nls
);
43 #define DATE_DATEVARSONLY 0x0100 /* only date stuff: yMdg */
44 #define TIME_TIMEVARSONLY 0x0200 /* only time stuff: hHmst */
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.
53 * Our cache takes the form of a singly linked list, whose node is below:
55 #define NLS_NUM_CACHED_STRINGS 57
57 typedef struct _NLS_FORMAT_NODE
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
;
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]
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]
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
=
90 { &NLS_FormatsCS_debug
.ProcessLocksList
,
91 &NLS_FormatsCS_debug
.ProcessLocksList
},
92 0, 0, { (DWORD_PTR
)(__FILE__
": NLS_Formats") }
94 static CRITICAL_SECTION NLS_FormatsCS
= { &NLS_FormatsCS_debug
, -1, 0, 0, 0, 0 };
96 /**************************************************************************
97 * NLS_GetLocaleNumber <internal>
99 * Get a numeric locale format value.
101 static DWORD
NLS_GetLocaleNumber(LCID lcid
, DWORD dwFlags
)
107 GetLocaleInfoW(lcid
, dwFlags
, szBuff
, sizeof(szBuff
) / sizeof(WCHAR
));
109 if (szBuff
[0] && szBuff
[1] == ';' && szBuff
[2] != '0')
110 dwVal
= (szBuff
[0] - '0') * 10 + (szBuff
[2] - '0');
113 const WCHAR
* iter
= szBuff
;
115 while(*iter
>= '0' && *iter
<= '9')
116 dwVal
= dwVal
* 10 + (*iter
++ - '0');
121 /**************************************************************************
122 * NLS_GetLocaleString <internal>
124 * Get a string locale format value.
126 static WCHAR
* NLS_GetLocaleString(LCID lcid
, DWORD dwFlags
)
128 WCHAR szBuff
[80], *str
;
132 GetLocaleInfoW(lcid
, dwFlags
, szBuff
, sizeof(szBuff
) / sizeof(WCHAR
));
133 dwLen
= strlenW(szBuff
) + 1;
134 str
= HeapAlloc(GetProcessHeap(), 0, dwLen
* sizeof(WCHAR
));
136 memcpy(str
, szBuff
, dwLen
* sizeof(WCHAR
));
140 #define GET_LOCALE_NUMBER(num, type) num = NLS_GetLocaleNumber(lcid, type|dwFlags); \
141 TRACE( #type ": %d (%08x)\n", (DWORD)num, (DWORD)num)
143 #define GET_LOCALE_STRING(str, type) str = NLS_GetLocaleString(lcid, type|dwFlags); \
144 TRACE( #type ": %s\n", debugstr_w(str))
146 /**************************************************************************
147 * NLS_GetFormats <internal>
149 * Calculate (and cache) the number formats for a locale.
151 static const NLS_FORMAT_NODE
*NLS_GetFormats(LCID lcid
, DWORD dwFlags
)
153 /* GetLocaleInfo() identifiers for cached formatting strings */
154 static const LCTYPE NLS_LocaleIndices
[] = {
155 LOCALE_SNEGATIVESIGN
,
156 LOCALE_SLONGDATE
, LOCALE_SSHORTDATE
,
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
,
186 static NLS_FORMAT_NODE
*NLS_CachedFormats
= NULL
;
187 NLS_FORMAT_NODE
*node
= NLS_CachedFormats
;
189 dwFlags
&= LOCALE_NOUSEROVERRIDE
;
191 TRACE("(0x%04x,0x%08x)\n", lcid
, dwFlags
);
193 /* See if we have already cached the locales number format */
194 while (node
&& (node
->lcid
!= lcid
|| node
->dwFlags
!= dwFlags
) && node
->next
)
197 if (!node
|| node
->lcid
!= lcid
|| node
->dwFlags
!= dwFlags
)
199 NLS_FORMAT_NODE
*new_node
;
202 TRACE("Creating new cache entry\n");
204 if (!(new_node
= HeapAlloc(GetProcessHeap(), 0, sizeof(NLS_FORMAT_NODE
))))
207 GET_LOCALE_NUMBER(new_node
->dwCodePage
, LOCALE_IDEFAULTANSICODEPAGE
);
210 new_node
->lcid
= lcid
;
211 new_node
->dwFlags
= dwFlags
;
212 new_node
->next
= NULL
;
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
);
218 GET_LOCALE_NUMBER(new_node
->fmt
.Grouping
, LOCALE_SGROUPING
);
219 if (new_node
->fmt
.Grouping
> 9 && new_node
->fmt
.Grouping
!= 32)
221 WARN("LOCALE_SGROUPING (%d) unhandled, please report!\n",
222 new_node
->fmt
.Grouping
);
223 new_node
->fmt
.Grouping
= 0;
226 GET_LOCALE_STRING(new_node
->fmt
.lpDecimalSep
, LOCALE_SDECIMAL
);
227 GET_LOCALE_STRING(new_node
->fmt
.lpThousandSep
, LOCALE_STHOUSAND
);
229 /* Currency Format */
230 new_node
->cyfmt
.NumDigits
= new_node
->fmt
.NumDigits
;
231 new_node
->cyfmt
.LeadingZero
= new_node
->fmt
.LeadingZero
;
233 GET_LOCALE_NUMBER(new_node
->cyfmt
.Grouping
, LOCALE_SGROUPING
);
235 if (new_node
->cyfmt
.Grouping
> 9)
237 WARN("LOCALE_SMONGROUPING (%d) unhandled, please report!\n",
238 new_node
->cyfmt
.Grouping
);
239 new_node
->cyfmt
.Grouping
= 0;
242 GET_LOCALE_NUMBER(new_node
->cyfmt
.NegativeOrder
, LOCALE_INEGCURR
);
243 if (new_node
->cyfmt
.NegativeOrder
> 15)
245 WARN("LOCALE_INEGCURR (%d) unhandled, please report!\n",
246 new_node
->cyfmt
.NegativeOrder
);
247 new_node
->cyfmt
.NegativeOrder
= 0;
249 GET_LOCALE_NUMBER(new_node
->cyfmt
.PositiveOrder
, LOCALE_ICURRENCY
);
250 if (new_node
->cyfmt
.PositiveOrder
> 3)
252 WARN("LOCALE_IPOSCURR (%d) unhandled,please report!\n",
253 new_node
->cyfmt
.PositiveOrder
);
254 new_node
->cyfmt
.PositiveOrder
= 0;
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
);
260 /* Date/Time Format info, negative character, etc */
261 for (i
= 0; i
< sizeof(NLS_LocaleIndices
)/sizeof(NLS_LocaleIndices
[0]); i
++)
263 GET_LOCALE_STRING(new_node
->lppszStrings
[i
], NLS_LocaleIndices
[i
]);
265 /* Save some memory if month genitive name is the same or not present */
266 for (i
= 0; i
< 12; i
++)
268 if (strcmpW(GetLongMonth(new_node
, i
), GetGenitiveMonth(new_node
, i
)) == 0)
270 HeapFree(GetProcessHeap(), 0, GetGenitiveMonth(new_node
, i
));
271 GetGenitiveMonth(new_node
, i
) = NULL
;
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';
278 /* Now add the computed format to the cache */
279 RtlEnterCriticalSection(&NLS_FormatsCS
);
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
)
288 node
= NLS_CachedFormats
= new_node
; /* Empty list */
291 else if (node
->lcid
!= lcid
|| node
->dwFlags
!= dwFlags
)
293 node
->next
= new_node
; /* Not in the list, add to end */
298 RtlLeaveCriticalSection(&NLS_FormatsCS
);
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.
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
);
318 /**************************************************************************
319 * NLS_IsUnicodeOnlyLcid <internal>
321 * Determine if a locale is Unicode only, and thus invalid in ASCII calls.
323 BOOL
NLS_IsUnicodeOnlyLcid(LCID lcid
)
325 lcid
= ConvertDefaultLocale(lcid
);
327 switch (PRIMARYLANGID(lcid
))
339 TRACE("lcid 0x%08x: langid 0x%4x is Unicode Only\n", lcid
, PRIMARYLANGID(lcid
));
347 * Formatting of dates, times, numbers and currencies.
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')
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| \
360 /******************************************************************************
361 * NLS_GetDateTimeFormatW <internal>
363 * Performs the formatting for GetDateFormatW/GetTimeFormatW.
366 * DATE_USE_ALT_CALENDAR - Requires GetCalendarInfo to work first.
367 * DATE_LTRREADING/DATE_RTLREADING - Not yet implemented.
369 static INT
NLS_GetDateTimeFormatW(LCID lcid
, DWORD dwFlags
,
370 const SYSTEMTIME
* lpTime
, LPCWSTR lpFormat
,
371 LPWSTR lpStr
, INT cchOut
)
373 const NLS_FORMAT_NODE
*node
;
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 */
380 /* Verify our arguments */
381 if ((cchOut
&& !lpStr
) || !(node
= NLS_GetFormats(lcid
, dwFlags
)))
382 goto invalid_parameter
;
384 if (dwFlags
& ~(DATE_DATEVARSONLY
|TIME_TIMEVARSONLY
))
387 ((dwFlags
& DATE_DATEVARSONLY
&& dwFlags
& ~DATE_FORMAT_FLAGS
) ||
388 (dwFlags
& TIME_TIMEVARSONLY
&& dwFlags
& ~TIME_FORMAT_FLAGS
)))
393 if (dwFlags
& DATE_DATEVARSONLY
)
395 if ((dwFlags
& (DATE_LTRREADING
|DATE_RTLREADING
)) == (DATE_LTRREADING
|DATE_RTLREADING
))
397 else if (dwFlags
& (DATE_LTRREADING
|DATE_RTLREADING
))
398 FIXME("Unsupported flags: DATE_LTRREADING/DATE_RTLREADING\n");
400 switch (dwFlags
& (DATE_SHORTDATE
|DATE_LONGDATE
|DATE_YEARMONTH
))
418 /* Use the appropriate default format */
419 if (dwFlags
& DATE_DATEVARSONLY
)
421 if (dwFlags
& DATE_YEARMONTH
)
422 lpFormat
= GetYearMonth(node
);
423 else if (dwFlags
& DATE_LONGDATE
)
424 lpFormat
= GetLongDate(node
);
426 lpFormat
= GetShortDate(node
);
429 lpFormat
= GetTime(node
);
434 GetLocalTime(&st
); /* Default to current time */
439 if (dwFlags
& DATE_DATEVARSONLY
)
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
;
449 if (st
.wDay
> 31 || st
.wMonth
> 12 || !SystemTimeToFileTime(&st
, &ftTmp
))
450 goto invalid_parameter
;
452 FileTimeToSystemTime(&ftTmp
, &st
);
456 if (dwFlags
& TIME_TIMEVARSONLY
)
458 /* Verify the time */
459 if (lpTime
->wHour
> 24 || lpTime
->wMinute
> 59 || lpTime
->wSecond
> 59)
460 goto invalid_parameter
;
464 /* Format the output */
467 if (IsLiteralMarker(*lpFormat
))
469 /* Start of a literal string */
472 /* Loop until the end of the literal marker or end of the string */
475 if (IsLiteralMarker(*lpFormat
))
478 if (!IsLiteralMarker(*lpFormat
))
479 break; /* Terminating literal marker */
483 cchWritten
++; /* Count size only */
484 else if (cchWritten
>= cchOut
)
488 lpStr
[cchWritten
] = *lpFormat
;
494 else if ((dwFlags
& DATE_DATEVARSONLY
&& IsDateFmtChar(*lpFormat
)) ||
495 (dwFlags
& TIME_TIMEVARSONLY
&& IsTimeFmtChar(*lpFormat
)))
497 WCHAR buff
[32], fmtChar
;
498 LPCWSTR szAdd
= NULL
;
500 int count
= 0, dwLen
;
505 while (*lpFormat
== fmtChar
)
512 if (fmtChar
!= 'M') d_dd_formatted
= FALSE
;
517 szAdd
= GetLongDay(node
, (lpTime
->wDayOfWeek
+ 6) % 7);
519 szAdd
= GetShortDay(node
, (lpTime
->wDayOfWeek
+ 6) % 7);
522 dwVal
= lpTime
->wDay
;
524 d_dd_formatted
= TRUE
;
531 LPCWSTR genitive
= GetGenitiveMonth(node
, lpTime
->wMonth
- 1);
541 LPCWSTR format
= lpFormat
;
542 /* Look forward now, if next format pattern is for day genitive
543 name should be used */
546 /* Skip parts within markers */
547 if (IsLiteralMarker(*format
))
552 if (IsLiteralMarker(*format
))
555 if (!IsLiteralMarker(*format
)) break;
559 if (*format
!= ' ') break;
562 /* Only numeric day form matters */
563 if (*format
&& *format
== 'd')
566 while (*++format
== 'd') dcount
++;
575 szAdd
= GetLongMonth(node
, lpTime
->wMonth
- 1);
578 szAdd
= GetShortMonth(node
, lpTime
->wMonth
- 1);
581 dwVal
= lpTime
->wMonth
;
590 dwVal
= lpTime
->wYear
;
594 count
= count
> 2 ? 2 : count
;
595 dwVal
= lpTime
->wYear
% 100;
603 /* FIXME: Our GetCalendarInfo() does not yet support CAL_SERASTRING.
604 * When it is fixed, this string should be cached in 'node'.
606 FIXME("Should be using GetCalendarInfo(CAL_SERASTRING), defaulting to 'AD'\n");
607 buff
[0] = 'A'; buff
[1] = 'D'; buff
[2] = '\0';
611 buff
[0] = 'g'; buff
[1] = '\0'; /* Add a literal 'g' */
617 if (!(dwFlags
& TIME_FORCE24HOURFORMAT
))
619 count
= count
> 2 ? 2 : count
;
620 dwVal
= lpTime
->wHour
== 0 ? 12 : (lpTime
->wHour
- 1) % 12 + 1;
624 /* .. fall through if we are forced to output in 24 hour format */
627 count
= count
> 2 ? 2 : count
;
628 dwVal
= lpTime
->wHour
;
633 if (dwFlags
& TIME_NOMINUTESORSECONDS
)
635 cchWritten
= lastFormatPos
; /* Skip */
640 count
= count
> 2 ? 2 : count
;
641 dwVal
= lpTime
->wMinute
;
647 if (dwFlags
& (TIME_NOSECONDS
|TIME_NOMINUTESORSECONDS
))
649 cchWritten
= lastFormatPos
; /* Skip */
654 count
= count
> 2 ? 2 : count
;
655 dwVal
= lpTime
->wSecond
;
661 if (dwFlags
& TIME_NOTIMEMARKER
)
663 cchWritten
= lastFormatPos
; /* Skip */
669 szAdd
= lpTime
->wHour
< 12 ? node
->szShortAM
: node
->szShortPM
;
671 szAdd
= lpTime
->wHour
< 12 ? GetAM(node
) : GetPM(node
);
676 if (szAdd
== buff
&& buff
[0] == '\0')
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
);
683 dwLen
= szAdd
? strlenW(szAdd
) : 0;
687 if (cchWritten
+ dwLen
< cchOut
)
688 memcpy(lpStr
+ cchWritten
, szAdd
, dwLen
* sizeof(WCHAR
));
691 memcpy(lpStr
+ cchWritten
, szAdd
, (cchOut
- cchWritten
) * sizeof(WCHAR
));
696 lastFormatPos
= cchWritten
; /* Save position of last output format text */
700 /* Literal character */
702 cchWritten
++; /* Count size only */
703 else if (cchWritten
>= cchOut
)
705 else if (!bSkipping
|| *lpFormat
== ' ')
707 lpStr
[cchWritten
] = *lpFormat
;
714 /* Final string terminator and sanity check */
717 if (cchWritten
>= cchOut
)
720 lpStr
[cchWritten
] = '\0';
722 cchWritten
++; /* Include terminating NUL */
724 TRACE("returning length=%d, ouput=%s\n", cchWritten
, debugstr_w(lpStr
));
728 TRACE("returning 0, (ERROR_INSUFFICIENT_BUFFER)\n");
729 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
733 SetLastError(ERROR_INVALID_PARAMETER
);
737 SetLastError(ERROR_INVALID_FLAGS
);
741 /******************************************************************************
742 * NLS_GetDateTimeFormatA <internal>
744 * ASCII wrapper for GetDateFormatA/GetTimeFormatA.
746 static INT
NLS_GetDateTimeFormatA(LCID lcid
, DWORD dwFlags
,
747 const SYSTEMTIME
* lpTime
,
748 LPCSTR lpFormat
, LPSTR lpStr
, INT cchOut
)
751 WCHAR szFormat
[128], szOut
[128];
754 TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n", lcid
, dwFlags
, lpTime
,
755 debugstr_a(lpFormat
), lpStr
, cchOut
);
757 if (NLS_IsUnicodeOnlyLcid(lcid
))
759 GetDateTimeFormatA_InvalidParameter
:
760 SetLastError(ERROR_INVALID_PARAMETER
);
764 if (!(dwFlags
& LOCALE_USE_CP_ACP
))
766 const NLS_FORMAT_NODE
*node
= NLS_GetFormats(lcid
, dwFlags
);
768 goto GetDateTimeFormatA_InvalidParameter
;
769 cp
= node
->dwCodePage
;
773 MultiByteToWideChar(cp
, 0, lpFormat
, -1, szFormat
, sizeof(szFormat
)/sizeof(WCHAR
));
775 if (cchOut
> (int)(sizeof(szOut
)/sizeof(WCHAR
)))
776 cchOut
= sizeof(szOut
)/sizeof(WCHAR
);
780 iRet
= NLS_GetDateTimeFormatW(lcid
, dwFlags
, lpTime
, lpFormat
? szFormat
: NULL
,
781 lpStr
? szOut
: NULL
, cchOut
);
786 WideCharToMultiByte(cp
, 0, szOut
, iRet
? -1 : cchOut
, lpStr
, cchOut
, 0, 0);
787 else if (cchOut
&& iRet
)
793 /******************************************************************************
794 * GetDateFormatA [KERNEL32.@]
796 * Format a date for a given locale.
799 * lcid [I] Locale to format for
800 * dwFlags [I] LOCALE_ and DATE_ flags from "winnls.h"
801 * lpTime [I] Date to format
802 * lpFormat [I] Format string, or NULL to use the system defaults
803 * lpDateStr [O] Destination for formatted string
804 * cchOut [I] Size of lpDateStr, or 0 to calculate the resulting size
807 * - If lpFormat is NULL, lpDateStr will be formatted according to the format
808 * details returned by GetLocaleInfoA() and modified by dwFlags.
809 * - lpFormat is a string of characters and formatting tokens. Any characters
810 * in the string are copied verbatim to lpDateStr, with tokens being replaced
811 * by the date values they represent.
812 * - The following tokens have special meanings in a date format string:
815 *| d Single digit day of the month (no leading 0)
816 *| dd Double digit day of the month
817 *| ddd Short name for the day of the week
818 *| dddd Long name for the day of the week
819 *| M Single digit month of the year (no leading 0)
820 *| MM Double digit month of the year
821 *| MMM Short name for the month of the year
822 *| MMMM Long name for the month of the year
823 *| y Double digit year number (no leading 0)
824 *| yy Double digit year number
825 *| yyyy Four digit year number
826 *| gg Era string, for example 'AD'.
827 * - To output any literal character that could be misidentified as a token,
828 * enclose it in single quotes.
829 * - The Ascii version of this function fails if lcid is Unicode only.
832 * Success: The number of character written to lpDateStr, or that would
833 * have been written, if cchOut is 0.
834 * Failure: 0. Use GetLastError() to determine the cause.
836 INT WINAPI
GetDateFormatA( LCID lcid
, DWORD dwFlags
, const SYSTEMTIME
* lpTime
,
837 LPCSTR lpFormat
, LPSTR lpDateStr
, INT cchOut
)
839 TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid
, dwFlags
, lpTime
,
840 debugstr_a(lpFormat
), lpDateStr
, cchOut
);
842 return NLS_GetDateTimeFormatA(lcid
, dwFlags
| DATE_DATEVARSONLY
, lpTime
,
843 lpFormat
, lpDateStr
, cchOut
);
847 /******************************************************************************
848 * GetDateFormatW [KERNEL32.@]
850 * See GetDateFormatA.
852 INT WINAPI
GetDateFormatW(LCID lcid
, DWORD dwFlags
, const SYSTEMTIME
* lpTime
,
853 LPCWSTR lpFormat
, LPWSTR lpDateStr
, INT cchOut
)
855 TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n", lcid
, dwFlags
, lpTime
,
856 debugstr_w(lpFormat
), lpDateStr
, cchOut
);
858 return NLS_GetDateTimeFormatW(lcid
, dwFlags
|DATE_DATEVARSONLY
, lpTime
,
859 lpFormat
, lpDateStr
, cchOut
);
862 /******************************************************************************
863 * GetTimeFormatA [KERNEL32.@]
865 * Format a time for a given locale.
868 * lcid [I] Locale to format for
869 * dwFlags [I] LOCALE_ and TIME_ flags from "winnls.h"
870 * lpTime [I] Time to format
871 * lpFormat [I] Formatting overrides
872 * lpTimeStr [O] Destination for formatted string
873 * cchOut [I] Size of lpTimeStr, or 0 to calculate the resulting size
876 * - If lpFormat is NULL, lpszValue will be formatted according to the format
877 * details returned by GetLocaleInfoA() and modified by dwFlags.
878 * - lpFormat is a string of characters and formatting tokens. Any characters
879 * in the string are copied verbatim to lpTimeStr, with tokens being replaced
880 * by the time values they represent.
881 * - The following tokens have special meanings in a time format string:
884 *| h Hours with no leading zero (12-hour clock)
885 *| hh Hours with full two digits (12-hour clock)
886 *| H Hours with no leading zero (24-hour clock)
887 *| HH Hours with full two digits (24-hour clock)
888 *| m Minutes with no leading zero
889 *| mm Minutes with full two digits
890 *| s Seconds with no leading zero
891 *| ss Seconds with full two digits
892 *| t Short time marker (e.g. "A" or "P")
893 *| tt Long time marker (e.g. "AM", "PM")
894 * - To output any literal character that could be misidentified as a token,
895 * enclose it in single quotes.
896 * - The Ascii version of this function fails if lcid is Unicode only.
899 * Success: The number of character written to lpTimeStr, or that would
900 * have been written, if cchOut is 0.
901 * Failure: 0. Use GetLastError() to determine the cause.
903 INT WINAPI
GetTimeFormatA(LCID lcid
, DWORD dwFlags
, const SYSTEMTIME
* lpTime
,
904 LPCSTR lpFormat
, LPSTR lpTimeStr
, INT cchOut
)
906 TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid
, dwFlags
, lpTime
,
907 debugstr_a(lpFormat
), lpTimeStr
, cchOut
);
909 return NLS_GetDateTimeFormatA(lcid
, dwFlags
|TIME_TIMEVARSONLY
, lpTime
,
910 lpFormat
, lpTimeStr
, cchOut
);
913 /******************************************************************************
914 * GetTimeFormatW [KERNEL32.@]
916 * See GetTimeFormatA.
918 INT WINAPI
GetTimeFormatW(LCID lcid
, DWORD dwFlags
, const SYSTEMTIME
* lpTime
,
919 LPCWSTR lpFormat
, LPWSTR lpTimeStr
, INT cchOut
)
921 TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid
, dwFlags
, lpTime
,
922 debugstr_w(lpFormat
), lpTimeStr
, cchOut
);
924 return NLS_GetDateTimeFormatW(lcid
, dwFlags
|TIME_TIMEVARSONLY
, lpTime
,
925 lpFormat
, lpTimeStr
, cchOut
);
928 /**************************************************************************
929 * GetNumberFormatA (KERNEL32.@)
931 * Format a number string for a given locale.
934 * lcid [I] Locale to format for
935 * dwFlags [I] LOCALE_ flags from "winnls.h"
936 * lpszValue [I] String to format
937 * lpFormat [I] Formatting overrides
938 * lpNumberStr [O] Destination for formatted string
939 * cchOut [I] Size of lpNumberStr, or 0 to calculate the resulting size
942 * - lpszValue can contain only '0' - '9', '-' and '.'.
943 * - If lpFormat is non-NULL, dwFlags must be 0. In this case lpszValue will
944 * be formatted according to the format details returned by GetLocaleInfoA().
945 * - This function rounds the number string if the number of decimals exceeds the
946 * locales normal number of decimal places.
947 * - If cchOut is 0, this function does not write to lpNumberStr.
948 * - The Ascii version of this function fails if lcid is Unicode only.
951 * Success: The number of character written to lpNumberStr, or that would
952 * have been written, if cchOut is 0.
953 * Failure: 0. Use GetLastError() to determine the cause.
955 INT WINAPI
GetNumberFormatA(LCID lcid
, DWORD dwFlags
,
956 LPCSTR lpszValue
, const NUMBERFMTA
*lpFormat
,
957 LPSTR lpNumberStr
, int cchOut
)
960 WCHAR szDec
[8], szGrp
[8], szIn
[128], szOut
[128];
962 const NUMBERFMTW
*pfmt
= NULL
;
965 TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid
, dwFlags
, debugstr_a(lpszValue
),
966 lpFormat
, lpNumberStr
, cchOut
);
968 if (NLS_IsUnicodeOnlyLcid(lcid
))
970 GetNumberFormatA_InvalidParameter
:
971 SetLastError(ERROR_INVALID_PARAMETER
);
975 if (!(dwFlags
& LOCALE_USE_CP_ACP
))
977 const NLS_FORMAT_NODE
*node
= NLS_GetFormats(lcid
, dwFlags
);
979 goto GetNumberFormatA_InvalidParameter
;
980 cp
= node
->dwCodePage
;
985 memcpy(&fmt
, lpFormat
, sizeof(fmt
));
987 if (lpFormat
->lpDecimalSep
)
989 MultiByteToWideChar(cp
, 0, lpFormat
->lpDecimalSep
, -1, szDec
, sizeof(szDec
)/sizeof(WCHAR
));
990 fmt
.lpDecimalSep
= szDec
;
992 if (lpFormat
->lpThousandSep
)
994 MultiByteToWideChar(cp
, 0, lpFormat
->lpThousandSep
, -1, szGrp
, sizeof(szGrp
)/sizeof(WCHAR
));
995 fmt
.lpThousandSep
= szGrp
;
1000 MultiByteToWideChar(cp
, 0, lpszValue
, -1, szIn
, sizeof(szIn
)/sizeof(WCHAR
));
1002 if (cchOut
> (int)(sizeof(szOut
)/sizeof(WCHAR
)))
1003 cchOut
= sizeof(szOut
)/sizeof(WCHAR
);
1007 iRet
= GetNumberFormatW(lcid
, dwFlags
, lpszValue
? szIn
: NULL
, pfmt
,
1008 lpNumberStr
? szOut
: NULL
, cchOut
);
1010 if (szOut
[0] && lpNumberStr
)
1011 WideCharToMultiByte(cp
, 0, szOut
, -1, lpNumberStr
, cchOut
, 0, 0);
1015 /* Number parsing state flags */
1016 #define NF_ISNEGATIVE 0x1 /* '-' found */
1017 #define NF_ISREAL 0x2 /* '.' found */
1018 #define NF_DIGITS 0x4 /* '0'-'9' found */
1019 #define NF_DIGITS_OUT 0x8 /* Digits before the '.' found */
1020 #define NF_ROUND 0x10 /* Number needs to be rounded */
1022 /* Formatting options for Numbers */
1023 #define NLS_NEG_PARENS 0 /* "(1.1)" */
1024 #define NLS_NEG_LEFT 1 /* "-1.1" */
1025 #define NLS_NEG_LEFT_SPACE 2 /* "- 1.1" */
1026 #define NLS_NEG_RIGHT 3 /* "1.1-" */
1027 #define NLS_NEG_RIGHT_SPACE 4 /* "1.1 -" */
1029 /**************************************************************************
1030 * GetNumberFormatW (KERNEL32.@)
1032 * See GetNumberFormatA.
1034 INT WINAPI
GetNumberFormatW(LCID lcid
, DWORD dwFlags
,
1035 LPCWSTR lpszValue
, const NUMBERFMTW
*lpFormat
,
1036 LPWSTR lpNumberStr
, int cchOut
)
1038 WCHAR szBuff
[128], *szOut
= szBuff
+ sizeof(szBuff
) / sizeof(WCHAR
) - 1;
1040 const WCHAR
*lpszNeg
= NULL
, *lpszNegStart
, *szSrc
;
1041 DWORD dwState
= 0, dwDecimals
= 0, dwGroupCount
= 0, dwCurrentGroupCount
= 0;
1044 TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid
, dwFlags
, debugstr_w(lpszValue
),
1045 lpFormat
, lpNumberStr
, cchOut
);
1047 if (!lpszValue
|| cchOut
< 0 || (cchOut
> 0 && !lpNumberStr
) ||
1048 !IsValidLocale(lcid
, 0) ||
1049 (lpFormat
&& (dwFlags
|| !lpFormat
->lpDecimalSep
|| !lpFormat
->lpThousandSep
)))
1051 GetNumberFormatW_Error
:
1052 SetLastError(lpFormat
&& dwFlags
? ERROR_INVALID_FLAGS
: ERROR_INVALID_PARAMETER
);
1058 const NLS_FORMAT_NODE
*node
= NLS_GetFormats(lcid
, dwFlags
);
1061 goto GetNumberFormatW_Error
;
1062 lpFormat
= &node
->fmt
;
1063 lpszNegStart
= lpszNeg
= GetNegative(node
);
1067 GetLocaleInfoW(lcid
, LOCALE_SNEGATIVESIGN
|(dwFlags
& LOCALE_NOUSEROVERRIDE
),
1068 szNegBuff
, sizeof(szNegBuff
)/sizeof(WCHAR
));
1069 lpszNegStart
= lpszNeg
= szNegBuff
;
1071 lpszNeg
= lpszNeg
+ strlenW(lpszNeg
) - 1;
1073 dwFlags
&= (LOCALE_NOUSEROVERRIDE
|LOCALE_USE_CP_ACP
);
1075 /* Format the number backwards into a temporary buffer */
1080 /* Check the number for validity */
1083 if (*szSrc
>= '0' && *szSrc
<= '9')
1085 dwState
|= NF_DIGITS
;
1086 if (dwState
& NF_ISREAL
)
1089 else if (*szSrc
== '-')
1092 goto GetNumberFormatW_Error
; /* '-' not first character */
1093 dwState
|= NF_ISNEGATIVE
;
1095 else if (*szSrc
== '.')
1097 if (dwState
& NF_ISREAL
)
1098 goto GetNumberFormatW_Error
; /* More than one '.' */
1099 dwState
|= NF_ISREAL
;
1102 goto GetNumberFormatW_Error
; /* Invalid char */
1105 szSrc
--; /* Point to last character */
1107 if (!(dwState
& NF_DIGITS
))
1108 goto GetNumberFormatW_Error
; /* No digits */
1110 /* Add any trailing negative sign */
1111 if (dwState
& NF_ISNEGATIVE
)
1113 switch (lpFormat
->NegativeOrder
)
1115 case NLS_NEG_PARENS
:
1119 case NLS_NEG_RIGHT_SPACE
:
1120 while (lpszNeg
>= lpszNegStart
)
1121 *szOut
-- = *lpszNeg
--;
1122 if (lpFormat
->NegativeOrder
== NLS_NEG_RIGHT_SPACE
)
1128 /* Copy all digits up to the decimal point */
1129 if (!lpFormat
->NumDigits
)
1131 if (dwState
& NF_ISREAL
)
1133 while (*szSrc
!= '.') /* Don't write any decimals or a separator */
1135 if (*szSrc
>= '5' || (*szSrc
== '4' && (dwState
& NF_ROUND
)))
1136 dwState
|= NF_ROUND
;
1138 dwState
&= ~NF_ROUND
;
1146 LPWSTR lpszDec
= lpFormat
->lpDecimalSep
+ strlenW(lpFormat
->lpDecimalSep
) - 1;
1148 if (dwDecimals
<= lpFormat
->NumDigits
)
1150 dwDecimals
= lpFormat
->NumDigits
- dwDecimals
;
1151 while (dwDecimals
--)
1152 *szOut
-- = '0'; /* Pad to correct number of dp */
1156 dwDecimals
-= lpFormat
->NumDigits
;
1157 /* Skip excess decimals, and determine if we have to round the number */
1158 while (dwDecimals
--)
1160 if (*szSrc
>= '5' || (*szSrc
== '4' && (dwState
& NF_ROUND
)))
1161 dwState
|= NF_ROUND
;
1163 dwState
&= ~NF_ROUND
;
1168 if (dwState
& NF_ISREAL
)
1170 while (*szSrc
!= '.')
1172 if (dwState
& NF_ROUND
)
1175 *szOut
-- = '0'; /* continue rounding */
1178 dwState
&= ~NF_ROUND
;
1179 *szOut
-- = (*szSrc
)+1;
1184 *szOut
-- = *szSrc
--; /* Write existing decimals */
1186 szSrc
--; /* Skip '.' */
1189 while (lpszDec
>= lpFormat
->lpDecimalSep
)
1190 *szOut
-- = *lpszDec
--; /* Write decimal separator */
1193 dwGroupCount
= lpFormat
->Grouping
== 32 ? 3 : lpFormat
->Grouping
;
1195 /* Write the remaining whole number digits, including grouping chars */
1196 while (szSrc
>= lpszValue
&& *szSrc
>= '0' && *szSrc
<= '9')
1198 if (dwState
& NF_ROUND
)
1201 *szOut
-- = '0'; /* continue rounding */
1204 dwState
&= ~NF_ROUND
;
1205 *szOut
-- = (*szSrc
)+1;
1210 *szOut
-- = *szSrc
--;
1212 dwState
|= NF_DIGITS_OUT
;
1213 dwCurrentGroupCount
++;
1214 if (szSrc
>= lpszValue
&& dwCurrentGroupCount
== dwGroupCount
&& *szSrc
!= '-')
1216 LPWSTR lpszGrp
= lpFormat
->lpThousandSep
+ strlenW(lpFormat
->lpThousandSep
) - 1;
1218 while (lpszGrp
>= lpFormat
->lpThousandSep
)
1219 *szOut
-- = *lpszGrp
--; /* Write grouping char */
1221 dwCurrentGroupCount
= 0;
1222 if (lpFormat
->Grouping
== 32)
1223 dwGroupCount
= 2; /* Indic grouping: 3 then 2 */
1226 if (dwState
& NF_ROUND
)
1228 *szOut
-- = '1'; /* e.g. .6 > 1.0 */
1230 else if (!(dwState
& NF_DIGITS_OUT
) && lpFormat
->LeadingZero
)
1231 *szOut
-- = '0'; /* Add leading 0 if we have no digits before the decimal point */
1233 /* Add any leading negative sign */
1234 if (dwState
& NF_ISNEGATIVE
)
1236 switch (lpFormat
->NegativeOrder
)
1238 case NLS_NEG_PARENS
:
1241 case NLS_NEG_LEFT_SPACE
:
1245 while (lpszNeg
>= lpszNegStart
)
1246 *szOut
-- = *lpszNeg
--;
1252 iRet
= strlenW(szOut
) + 1;
1256 memcpy(lpNumberStr
, szOut
, iRet
* sizeof(WCHAR
));
1259 memcpy(lpNumberStr
, szOut
, cchOut
* sizeof(WCHAR
));
1260 lpNumberStr
[cchOut
- 1] = '\0';
1261 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
1268 /**************************************************************************
1269 * GetCurrencyFormatA (KERNEL32.@)
1271 * Format a currency string for a given locale.
1274 * lcid [I] Locale to format for
1275 * dwFlags [I] LOCALE_ flags from "winnls.h"
1276 * lpszValue [I] String to format
1277 * lpFormat [I] Formatting overrides
1278 * lpCurrencyStr [O] Destination for formatted string
1279 * cchOut [I] Size of lpCurrencyStr, or 0 to calculate the resulting size
1282 * - lpszValue can contain only '0' - '9', '-' and '.'.
1283 * - If lpFormat is non-NULL, dwFlags must be 0. In this case lpszValue will
1284 * be formatted according to the format details returned by GetLocaleInfoA().
1285 * - This function rounds the currency if the number of decimals exceeds the
1286 * locales number of currency decimal places.
1287 * - If cchOut is 0, this function does not write to lpCurrencyStr.
1288 * - The Ascii version of this function fails if lcid is Unicode only.
1291 * Success: The number of character written to lpNumberStr, or that would
1292 * have been written, if cchOut is 0.
1293 * Failure: 0. Use GetLastError() to determine the cause.
1295 INT WINAPI
GetCurrencyFormatA(LCID lcid
, DWORD dwFlags
,
1296 LPCSTR lpszValue
, const CURRENCYFMTA
*lpFormat
,
1297 LPSTR lpCurrencyStr
, int cchOut
)
1300 WCHAR szDec
[8], szGrp
[8], szCy
[8], szIn
[128], szOut
[128];
1302 const CURRENCYFMTW
*pfmt
= NULL
;
1305 TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid
, dwFlags
, debugstr_a(lpszValue
),
1306 lpFormat
, lpCurrencyStr
, cchOut
);
1308 if (NLS_IsUnicodeOnlyLcid(lcid
))
1310 GetCurrencyFormatA_InvalidParameter
:
1311 SetLastError(ERROR_INVALID_PARAMETER
);
1315 if (!(dwFlags
& LOCALE_USE_CP_ACP
))
1317 const NLS_FORMAT_NODE
*node
= NLS_GetFormats(lcid
, dwFlags
);
1319 goto GetCurrencyFormatA_InvalidParameter
;
1320 cp
= node
->dwCodePage
;
1325 memcpy(&fmt
, lpFormat
, sizeof(fmt
));
1327 if (lpFormat
->lpDecimalSep
)
1329 MultiByteToWideChar(cp
, 0, lpFormat
->lpDecimalSep
, -1, szDec
, sizeof(szDec
)/sizeof(WCHAR
));
1330 fmt
.lpDecimalSep
= szDec
;
1332 if (lpFormat
->lpThousandSep
)
1334 MultiByteToWideChar(cp
, 0, lpFormat
->lpThousandSep
, -1, szGrp
, sizeof(szGrp
)/sizeof(WCHAR
));
1335 fmt
.lpThousandSep
= szGrp
;
1337 if (lpFormat
->lpCurrencySymbol
)
1339 MultiByteToWideChar(cp
, 0, lpFormat
->lpCurrencySymbol
, -1, szCy
, sizeof(szCy
)/sizeof(WCHAR
));
1340 fmt
.lpCurrencySymbol
= szCy
;
1345 MultiByteToWideChar(cp
, 0, lpszValue
, -1, szIn
, sizeof(szIn
)/sizeof(WCHAR
));
1347 if (cchOut
> (int)(sizeof(szOut
)/sizeof(WCHAR
)))
1348 cchOut
= sizeof(szOut
)/sizeof(WCHAR
);
1352 iRet
= GetCurrencyFormatW(lcid
, dwFlags
, lpszValue
? szIn
: NULL
, pfmt
,
1353 lpCurrencyStr
? szOut
: NULL
, cchOut
);
1355 if (szOut
[0] && lpCurrencyStr
)
1356 WideCharToMultiByte(cp
, 0, szOut
, -1, lpCurrencyStr
, cchOut
, 0, 0);
1360 /* Formatting states for Currencies. We use flags to avoid code duplication. */
1361 #define CF_PARENS 0x1 /* Parentheses */
1362 #define CF_MINUS_LEFT 0x2 /* '-' to the left */
1363 #define CF_MINUS_RIGHT 0x4 /* '-' to the right */
1364 #define CF_MINUS_BEFORE 0x8 /* '-' before '$' */
1365 #define CF_CY_LEFT 0x10 /* '$' to the left */
1366 #define CF_CY_RIGHT 0x20 /* '$' to the right */
1367 #define CF_CY_SPACE 0x40 /* ' ' by '$' */
1369 /**************************************************************************
1370 * GetCurrencyFormatW (KERNEL32.@)
1372 * See GetCurrencyFormatA.
1374 INT WINAPI
GetCurrencyFormatW(LCID lcid
, DWORD dwFlags
,
1375 LPCWSTR lpszValue
, const CURRENCYFMTW
*lpFormat
,
1376 LPWSTR lpCurrencyStr
, int cchOut
)
1378 static const BYTE NLS_NegCyFormats
[16] =
1380 CF_PARENS
|CF_CY_LEFT
, /* ($1.1) */
1381 CF_MINUS_LEFT
|CF_MINUS_BEFORE
|CF_CY_LEFT
, /* -$1.1 */
1382 CF_MINUS_LEFT
|CF_CY_LEFT
, /* $-1.1 */
1383 CF_MINUS_RIGHT
|CF_CY_LEFT
, /* $1.1- */
1384 CF_PARENS
|CF_CY_RIGHT
, /* (1.1$) */
1385 CF_MINUS_LEFT
|CF_CY_RIGHT
, /* -1.1$ */
1386 CF_MINUS_RIGHT
|CF_MINUS_BEFORE
|CF_CY_RIGHT
, /* 1.1-$ */
1387 CF_MINUS_RIGHT
|CF_CY_RIGHT
, /* 1.1$- */
1388 CF_MINUS_LEFT
|CF_CY_RIGHT
|CF_CY_SPACE
, /* -1.1 $ */
1389 CF_MINUS_LEFT
|CF_MINUS_BEFORE
|CF_CY_LEFT
|CF_CY_SPACE
, /* -$ 1.1 */
1390 CF_MINUS_RIGHT
|CF_CY_RIGHT
|CF_CY_SPACE
, /* 1.1 $- */
1391 CF_MINUS_RIGHT
|CF_CY_LEFT
|CF_CY_SPACE
, /* $ 1.1- */
1392 CF_MINUS_LEFT
|CF_CY_LEFT
|CF_CY_SPACE
, /* $ -1.1 */
1393 CF_MINUS_RIGHT
|CF_MINUS_BEFORE
|CF_CY_RIGHT
|CF_CY_SPACE
, /* 1.1- $ */
1394 CF_PARENS
|CF_CY_LEFT
|CF_CY_SPACE
, /* ($ 1.1) */
1395 CF_PARENS
|CF_CY_RIGHT
|CF_CY_SPACE
, /* (1.1 $) */
1397 static const BYTE NLS_PosCyFormats
[4] =
1399 CF_CY_LEFT
, /* $1.1 */
1400 CF_CY_RIGHT
, /* 1.1$ */
1401 CF_CY_LEFT
|CF_CY_SPACE
, /* $ 1.1 */
1402 CF_CY_RIGHT
|CF_CY_SPACE
, /* 1.1 $ */
1404 WCHAR szBuff
[128], *szOut
= szBuff
+ sizeof(szBuff
) / sizeof(WCHAR
) - 1;
1406 const WCHAR
*lpszNeg
= NULL
, *lpszNegStart
, *szSrc
, *lpszCy
, *lpszCyStart
;
1407 DWORD dwState
= 0, dwDecimals
= 0, dwGroupCount
= 0, dwCurrentGroupCount
= 0, dwFmt
;
1410 TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid
, dwFlags
, debugstr_w(lpszValue
),
1411 lpFormat
, lpCurrencyStr
, cchOut
);
1413 if (!lpszValue
|| cchOut
< 0 || (cchOut
> 0 && !lpCurrencyStr
) ||
1414 !IsValidLocale(lcid
, 0) ||
1415 (lpFormat
&& (dwFlags
|| !lpFormat
->lpDecimalSep
|| !lpFormat
->lpThousandSep
||
1416 !lpFormat
->lpCurrencySymbol
|| lpFormat
->NegativeOrder
> 15 ||
1417 lpFormat
->PositiveOrder
> 3)))
1419 GetCurrencyFormatW_Error
:
1420 SetLastError(lpFormat
&& dwFlags
? ERROR_INVALID_FLAGS
: ERROR_INVALID_PARAMETER
);
1426 const NLS_FORMAT_NODE
*node
= NLS_GetFormats(lcid
, dwFlags
);
1429 goto GetCurrencyFormatW_Error
;
1430 lpFormat
= &node
->cyfmt
;
1431 lpszNegStart
= lpszNeg
= GetNegative(node
);
1435 GetLocaleInfoW(lcid
, LOCALE_SNEGATIVESIGN
|(dwFlags
& LOCALE_NOUSEROVERRIDE
),
1436 szNegBuff
, sizeof(szNegBuff
)/sizeof(WCHAR
));
1437 lpszNegStart
= lpszNeg
= szNegBuff
;
1439 dwFlags
&= (LOCALE_NOUSEROVERRIDE
|LOCALE_USE_CP_ACP
);
1441 lpszNeg
= lpszNeg
+ strlenW(lpszNeg
) - 1;
1442 lpszCyStart
= lpFormat
->lpCurrencySymbol
;
1443 lpszCy
= lpszCyStart
+ strlenW(lpszCyStart
) - 1;
1445 /* Format the currency backwards into a temporary buffer */
1450 /* Check the number for validity */
1453 if (*szSrc
>= '0' && *szSrc
<= '9')
1455 dwState
|= NF_DIGITS
;
1456 if (dwState
& NF_ISREAL
)
1459 else if (*szSrc
== '-')
1462 goto GetCurrencyFormatW_Error
; /* '-' not first character */
1463 dwState
|= NF_ISNEGATIVE
;
1465 else if (*szSrc
== '.')
1467 if (dwState
& NF_ISREAL
)
1468 goto GetCurrencyFormatW_Error
; /* More than one '.' */
1469 dwState
|= NF_ISREAL
;
1472 goto GetCurrencyFormatW_Error
; /* Invalid char */
1475 szSrc
--; /* Point to last character */
1477 if (!(dwState
& NF_DIGITS
))
1478 goto GetCurrencyFormatW_Error
; /* No digits */
1480 if (dwState
& NF_ISNEGATIVE
)
1481 dwFmt
= NLS_NegCyFormats
[lpFormat
->NegativeOrder
];
1483 dwFmt
= NLS_PosCyFormats
[lpFormat
->PositiveOrder
];
1485 /* Add any trailing negative or currency signs */
1486 if (dwFmt
& CF_PARENS
)
1489 while (dwFmt
& (CF_MINUS_RIGHT
|CF_CY_RIGHT
))
1491 switch (dwFmt
& (CF_MINUS_RIGHT
|CF_MINUS_BEFORE
|CF_CY_RIGHT
))
1493 case CF_MINUS_RIGHT
:
1494 case CF_MINUS_RIGHT
|CF_CY_RIGHT
:
1495 while (lpszNeg
>= lpszNegStart
)
1496 *szOut
-- = *lpszNeg
--;
1497 dwFmt
&= ~CF_MINUS_RIGHT
;
1501 case CF_MINUS_BEFORE
|CF_CY_RIGHT
:
1502 case CF_MINUS_RIGHT
|CF_MINUS_BEFORE
|CF_CY_RIGHT
:
1503 while (lpszCy
>= lpszCyStart
)
1504 *szOut
-- = *lpszCy
--;
1505 if (dwFmt
& CF_CY_SPACE
)
1507 dwFmt
&= ~(CF_CY_RIGHT
|CF_MINUS_BEFORE
);
1512 /* Copy all digits up to the decimal point */
1513 if (!lpFormat
->NumDigits
)
1515 if (dwState
& NF_ISREAL
)
1517 while (*szSrc
!= '.') /* Don't write any decimals or a separator */
1519 if (*szSrc
>= '5' || (*szSrc
== '4' && (dwState
& NF_ROUND
)))
1520 dwState
|= NF_ROUND
;
1522 dwState
&= ~NF_ROUND
;
1530 LPWSTR lpszDec
= lpFormat
->lpDecimalSep
+ strlenW(lpFormat
->lpDecimalSep
) - 1;
1532 if (dwDecimals
<= lpFormat
->NumDigits
)
1534 dwDecimals
= lpFormat
->NumDigits
- dwDecimals
;
1535 while (dwDecimals
--)
1536 *szOut
-- = '0'; /* Pad to correct number of dp */
1540 dwDecimals
-= lpFormat
->NumDigits
;
1541 /* Skip excess decimals, and determine if we have to round the number */
1542 while (dwDecimals
--)
1544 if (*szSrc
>= '5' || (*szSrc
== '4' && (dwState
& NF_ROUND
)))
1545 dwState
|= NF_ROUND
;
1547 dwState
&= ~NF_ROUND
;
1552 if (dwState
& NF_ISREAL
)
1554 while (*szSrc
!= '.')
1556 if (dwState
& NF_ROUND
)
1559 *szOut
-- = '0'; /* continue rounding */
1562 dwState
&= ~NF_ROUND
;
1563 *szOut
-- = (*szSrc
)+1;
1568 *szOut
-- = *szSrc
--; /* Write existing decimals */
1570 szSrc
--; /* Skip '.' */
1572 while (lpszDec
>= lpFormat
->lpDecimalSep
)
1573 *szOut
-- = *lpszDec
--; /* Write decimal separator */
1576 dwGroupCount
= lpFormat
->Grouping
;
1578 /* Write the remaining whole number digits, including grouping chars */
1579 while (szSrc
>= lpszValue
&& *szSrc
>= '0' && *szSrc
<= '9')
1581 if (dwState
& NF_ROUND
)
1584 *szOut
-- = '0'; /* continue rounding */
1587 dwState
&= ~NF_ROUND
;
1588 *szOut
-- = (*szSrc
)+1;
1593 *szOut
-- = *szSrc
--;
1595 dwState
|= NF_DIGITS_OUT
;
1596 dwCurrentGroupCount
++;
1597 if (szSrc
>= lpszValue
&& dwCurrentGroupCount
== dwGroupCount
&& *szSrc
!= '-')
1599 LPWSTR lpszGrp
= lpFormat
->lpThousandSep
+ strlenW(lpFormat
->lpThousandSep
) - 1;
1601 while (lpszGrp
>= lpFormat
->lpThousandSep
)
1602 *szOut
-- = *lpszGrp
--; /* Write grouping char */
1604 dwCurrentGroupCount
= 0;
1607 if (dwState
& NF_ROUND
)
1608 *szOut
-- = '1'; /* e.g. .6 > 1.0 */
1609 else if (!(dwState
& NF_DIGITS_OUT
) && lpFormat
->LeadingZero
)
1610 *szOut
-- = '0'; /* Add leading 0 if we have no digits before the decimal point */
1612 /* Add any leading negative or currency sign */
1613 while (dwFmt
& (CF_MINUS_LEFT
|CF_CY_LEFT
))
1615 switch (dwFmt
& (CF_MINUS_LEFT
|CF_MINUS_BEFORE
|CF_CY_LEFT
))
1618 case CF_MINUS_LEFT
|CF_CY_LEFT
:
1619 while (lpszNeg
>= lpszNegStart
)
1620 *szOut
-- = *lpszNeg
--;
1621 dwFmt
&= ~CF_MINUS_LEFT
;
1625 case CF_CY_LEFT
|CF_MINUS_BEFORE
:
1626 case CF_MINUS_LEFT
|CF_MINUS_BEFORE
|CF_CY_LEFT
:
1627 if (dwFmt
& CF_CY_SPACE
)
1629 while (lpszCy
>= lpszCyStart
)
1630 *szOut
-- = *lpszCy
--;
1631 dwFmt
&= ~(CF_CY_LEFT
|CF_MINUS_BEFORE
);
1635 if (dwFmt
& CF_PARENS
)
1639 iRet
= strlenW(szOut
) + 1;
1643 memcpy(lpCurrencyStr
, szOut
, iRet
* sizeof(WCHAR
));
1646 memcpy(lpCurrencyStr
, szOut
, cchOut
* sizeof(WCHAR
));
1647 lpCurrencyStr
[cchOut
- 1] = '\0';
1648 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
1655 /* FIXME: Everything below here needs to move somewhere else along with the
1656 * other EnumXXX functions, when a method for storing resources for
1657 * alternate calendars is determined.
1660 /**************************************************************************
1661 * EnumDateFormatsExA (KERNEL32.@)
1663 * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1664 * LOCALE_NOUSEROVERRIDE here as well?
1666 BOOL WINAPI
EnumDateFormatsExA(DATEFMT_ENUMPROCEXA proc
, LCID lcid
, DWORD flags
)
1673 SetLastError(ERROR_INVALID_PARAMETER
);
1677 if (!GetLocaleInfoW(lcid
, LOCALE_ICALENDARTYPE
|LOCALE_RETURN_NUMBER
, (LPWSTR
)&cal_id
, sizeof(cal_id
)/sizeof(WCHAR
)))
1680 switch (flags
& ~LOCALE_USE_CP_ACP
)
1683 case DATE_SHORTDATE
:
1684 if (GetLocaleInfoA(lcid
, LOCALE_SSHORTDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1689 if (GetLocaleInfoA(lcid
, LOCALE_SLONGDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1693 case DATE_YEARMONTH
:
1694 if (GetLocaleInfoA(lcid
, LOCALE_SYEARMONTH
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1699 FIXME("Unknown date format (%d)\n", flags
);
1700 SetLastError(ERROR_INVALID_PARAMETER
);
1706 /**************************************************************************
1707 * EnumDateFormatsExW (KERNEL32.@)
1709 BOOL WINAPI
EnumDateFormatsExW(DATEFMT_ENUMPROCEXW proc
, LCID lcid
, DWORD flags
)
1716 SetLastError(ERROR_INVALID_PARAMETER
);
1720 if (!GetLocaleInfoW(lcid
, LOCALE_ICALENDARTYPE
|LOCALE_RETURN_NUMBER
, (LPWSTR
)&cal_id
, sizeof(cal_id
)/sizeof(WCHAR
)))
1723 switch (flags
& ~LOCALE_USE_CP_ACP
)
1726 case DATE_SHORTDATE
:
1727 if (GetLocaleInfoW(lcid
, LOCALE_SSHORTDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1732 if (GetLocaleInfoW(lcid
, LOCALE_SLONGDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1736 case DATE_YEARMONTH
:
1737 if (GetLocaleInfoW(lcid
, LOCALE_SYEARMONTH
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1742 FIXME("Unknown date format (%d)\n", flags
);
1743 SetLastError(ERROR_INVALID_PARAMETER
);
1749 /**************************************************************************
1750 * EnumDateFormatsA (KERNEL32.@)
1752 * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1753 * LOCALE_NOUSEROVERRIDE here as well?
1755 BOOL WINAPI
EnumDateFormatsA(DATEFMT_ENUMPROCA proc
, LCID lcid
, DWORD flags
)
1761 SetLastError(ERROR_INVALID_PARAMETER
);
1765 switch (flags
& ~LOCALE_USE_CP_ACP
)
1768 case DATE_SHORTDATE
:
1769 if (GetLocaleInfoA(lcid
, LOCALE_SSHORTDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1774 if (GetLocaleInfoA(lcid
, LOCALE_SLONGDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1778 case DATE_YEARMONTH
:
1779 if (GetLocaleInfoA(lcid
, LOCALE_SYEARMONTH
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1784 FIXME("Unknown date format (%d)\n", flags
);
1785 SetLastError(ERROR_INVALID_PARAMETER
);
1791 /**************************************************************************
1792 * EnumDateFormatsW (KERNEL32.@)
1794 BOOL WINAPI
EnumDateFormatsW(DATEFMT_ENUMPROCW proc
, LCID lcid
, DWORD flags
)
1800 SetLastError(ERROR_INVALID_PARAMETER
);
1804 switch (flags
& ~LOCALE_USE_CP_ACP
)
1807 case DATE_SHORTDATE
:
1808 if (GetLocaleInfoW(lcid
, LOCALE_SSHORTDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1813 if (GetLocaleInfoW(lcid
, LOCALE_SLONGDATE
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1817 case DATE_YEARMONTH
:
1818 if (GetLocaleInfoW(lcid
, LOCALE_SYEARMONTH
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1823 FIXME("Unknown date format (%d)\n", flags
);
1824 SetLastError(ERROR_INVALID_PARAMETER
);
1830 /**************************************************************************
1831 * EnumTimeFormatsA (KERNEL32.@)
1833 * FIXME: MSDN mentions only LOCALE_USE_CP_ACP, should we handle
1834 * LOCALE_NOUSEROVERRIDE here as well?
1836 BOOL WINAPI
EnumTimeFormatsA(TIMEFMT_ENUMPROCA proc
, LCID lcid
, DWORD flags
)
1842 SetLastError(ERROR_INVALID_PARAMETER
);
1846 switch (flags
& ~LOCALE_USE_CP_ACP
)
1849 if (GetLocaleInfoA(lcid
, LOCALE_STIMEFORMAT
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1854 FIXME("Unknown time format (%d)\n", flags
);
1855 SetLastError(ERROR_INVALID_PARAMETER
);
1861 /**************************************************************************
1862 * EnumTimeFormatsW (KERNEL32.@)
1864 BOOL WINAPI
EnumTimeFormatsW(TIMEFMT_ENUMPROCW proc
, LCID lcid
, DWORD flags
)
1870 SetLastError(ERROR_INVALID_PARAMETER
);
1874 switch (flags
& ~LOCALE_USE_CP_ACP
)
1877 if (GetLocaleInfoW(lcid
, LOCALE_STIMEFORMAT
| (flags
& LOCALE_USE_CP_ACP
), buf
, 256))
1882 FIXME("Unknown time format (%d)\n", flags
);
1883 SetLastError(ERROR_INVALID_PARAMETER
);
1889 /******************************************************************************
1890 * NLS_EnumCalendarInfoAW <internal>
1891 * Enumerates calendar information for a specified locale.
1894 * calinfoproc [I] Pointer to the callback
1895 * locale [I] The locale for which to retrieve calendar information.
1896 * This parameter can be a locale identifier created by the
1897 * MAKELCID macro, or one of the following values:
1898 * LOCALE_SYSTEM_DEFAULT
1899 * Use the default system locale.
1900 * LOCALE_USER_DEFAULT
1901 * Use the default user locale.
1902 * calendar [I] The calendar for which information is requested, or
1903 * ENUM_ALL_CALENDARS.
1904 * caltype [I] The type of calendar information to be returned. Note
1905 * that only one CALTYPE value can be specified per call
1906 * of this function, except where noted.
1907 * unicode [I] Specifies if the callback expects a unicode string.
1908 * ex [I] Specifies if the callback needs the calendar identifier.
1912 * Failure: FALSE. Use GetLastError() to determine the cause.
1915 * When the ANSI version of this function is used with a Unicode-only LCID,
1916 * the call can succeed because the system uses the system code page.
1917 * However, characters that are undefined in the system code page appear
1918 * in the string as a question mark (?).
1921 * The above note should be respected by GetCalendarInfoA.
1923 static BOOL
NLS_EnumCalendarInfoAW(void *calinfoproc
, LCID locale
,
1924 CALID calendar
, CALTYPE caltype
, BOOL unicode
, BOOL ex
)
1926 WCHAR
*buf
, *opt
= NULL
, *iter
= NULL
;
1928 int bufSz
= 200; /* the size of the buffer */
1930 if (calinfoproc
== NULL
)
1932 SetLastError(ERROR_INVALID_PARAMETER
);
1936 buf
= HeapAlloc(GetProcessHeap(), 0, bufSz
);
1939 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1943 if (calendar
== ENUM_ALL_CALENDARS
)
1945 int optSz
= GetLocaleInfoW(locale
, LOCALE_IOPTIONALCALENDAR
, NULL
, 0);
1948 opt
= HeapAlloc(GetProcessHeap(), 0, optSz
* sizeof(WCHAR
));
1951 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1952 goto NLS_EnumCalendarInfoAW_Cleanup
;
1954 if (GetLocaleInfoW(locale
, LOCALE_IOPTIONALCALENDAR
, opt
, optSz
))
1957 calendar
= NLS_GetLocaleNumber(locale
, LOCALE_ICALENDARTYPE
);
1960 while (TRUE
) /* loop through calendars */
1962 do /* loop until there's no error */
1965 ret
= GetCalendarInfoW(locale
, calendar
, caltype
, buf
, bufSz
/ sizeof(WCHAR
), NULL
);
1966 else ret
= GetCalendarInfoA(locale
, calendar
, caltype
, (CHAR
*)buf
, bufSz
/ sizeof(CHAR
), NULL
);
1970 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1971 { /* so resize it */
1974 newSz
= GetCalendarInfoW(locale
, calendar
, caltype
, NULL
, 0, NULL
) * sizeof(WCHAR
);
1975 else newSz
= GetCalendarInfoA(locale
, calendar
, caltype
, NULL
, 0, NULL
) * sizeof(CHAR
);
1978 ERR("Buffer resizing disorder: was %d, requested %d.\n", bufSz
, newSz
);
1979 goto NLS_EnumCalendarInfoAW_Cleanup
;
1982 WARN("Buffer too small; resizing to %d bytes.\n", bufSz
);
1983 buf
= HeapReAlloc(GetProcessHeap(), 0, buf
, bufSz
);
1985 goto NLS_EnumCalendarInfoAW_Cleanup
;
1986 } else goto NLS_EnumCalendarInfoAW_Cleanup
;
1990 /* Here we are. We pass the buffer to the correct version of
1991 * the callback. Because it's not the same number of params,
1992 * we must check for Ex, but we don't care about Unicode
1993 * because the buffer is already in the correct format.
1996 ret
= ((CALINFO_ENUMPROCEXW
)calinfoproc
)(buf
, calendar
);
1998 ret
= ((CALINFO_ENUMPROCW
)calinfoproc
)(buf
);
2000 if (!ret
) { /* the callback told to stop */
2005 if ((iter
== NULL
) || (*iter
== 0)) /* no more calendars */
2009 while ((*iter
>= '0') && (*iter
<= '9'))
2010 calendar
= calendar
* 10 + *iter
++ - '0';
2014 SetLastError(ERROR_BADDB
);
2020 NLS_EnumCalendarInfoAW_Cleanup
:
2021 HeapFree(GetProcessHeap(), 0, opt
);
2022 HeapFree(GetProcessHeap(), 0, buf
);
2026 /******************************************************************************
2027 * EnumCalendarInfoA [KERNEL32.@]
2029 * See EnumCalendarInfoAW.
2031 BOOL WINAPI
EnumCalendarInfoA( CALINFO_ENUMPROCA calinfoproc
,LCID locale
,
2032 CALID calendar
,CALTYPE caltype
)
2034 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc
, locale
, calendar
, caltype
);
2035 return NLS_EnumCalendarInfoAW(calinfoproc
, locale
, calendar
, caltype
, FALSE
, FALSE
);
2038 /******************************************************************************
2039 * EnumCalendarInfoW [KERNEL32.@]
2041 * See EnumCalendarInfoAW.
2043 BOOL WINAPI
EnumCalendarInfoW( CALINFO_ENUMPROCW calinfoproc
,LCID locale
,
2044 CALID calendar
,CALTYPE caltype
)
2046 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc
, locale
, calendar
, caltype
);
2047 return NLS_EnumCalendarInfoAW(calinfoproc
, locale
, calendar
, caltype
, TRUE
, FALSE
);
2050 /******************************************************************************
2051 * EnumCalendarInfoExA [KERNEL32.@]
2053 * See EnumCalendarInfoAW.
2055 BOOL WINAPI
EnumCalendarInfoExA( CALINFO_ENUMPROCEXA calinfoproc
,LCID locale
,
2056 CALID calendar
,CALTYPE caltype
)
2058 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc
, locale
, calendar
, caltype
);
2059 return NLS_EnumCalendarInfoAW(calinfoproc
, locale
, calendar
, caltype
, FALSE
, TRUE
);
2062 /******************************************************************************
2063 * EnumCalendarInfoExW [KERNEL32.@]
2065 * See EnumCalendarInfoAW.
2067 BOOL WINAPI
EnumCalendarInfoExW( CALINFO_ENUMPROCEXW calinfoproc
,LCID locale
,
2068 CALID calendar
,CALTYPE caltype
)
2070 TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc
, locale
, calendar
, caltype
);
2071 return NLS_EnumCalendarInfoAW(calinfoproc
, locale
, calendar
, caltype
, TRUE
, TRUE
);