?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push decde5eed3d79f9d889b4d757f73e86ce6ff9241
[wine/hacks.git] / dlls / oleaut32 / varformat.c
blob83f075f0724f32d9a49a610a856e905b651ff5d6
1 /*
2 * Variant formatting functions
3 *
4 * Copyright 2003 Jon Griffiths
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * NOTES
21 * Since the formatting functions aren't properly documented, I used the
22 * Visual Basic documentation as a guide to implementing these functions. This
23 * means that some named or user-defined formats may work slightly differently.
24 * Please submit a test case if you find a difference.
25 */
26
27 #include "config.h"
28
29 #include <string.h>
30 #include <stdlib.h>
31 #include <stdarg.h>
32 #include <stdio.h>
33
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
36 #include "windef.h"
37 #include "winbase.h"
38 #include "wine/unicode.h"
39 #include "winerror.h"
40 #include "variant.h"
41 #include "wine/debug.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(variant);
44
45 /* Make sure internal conversions to strings use the '.','+'/'-' and ','
46 * format chars from the US locale. This enables us to parse the created
47 * strings to determine the number of decimal places, exponent, etc.
48 */
49 #define LCID_US MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT)
50
51 static const WCHAR szPercent_d[] = { '%','d','\0' };
52 static const WCHAR szPercentZeroTwo_d[] = { '%','0','2','d','\0' };
53 static const WCHAR szPercentZeroStar_d[] = { '%','0','*','d','\0' };
54
55 #if 0
56 #define dump_tokens(rgb) do { \
57 int i_; TRACE("Tokens->{\n"); \
58 for (i_ = 0; i_ < rgb[0]; i_++) \
59 TRACE("%s0x%02x", i_?",":"",rgb[i_]); \
60 TRACE(" }\n"); \
61 } while(0)
62 #endif
63
64 /******************************************************************************
65 * Variant-Formats {OLEAUT32}
66 *
67 * NOTES
68 * When formatting a variant a variety of format strings may be used to generate
69 * different kinds of formatted output. A format string consists of either a named
70 * format, or a user-defined format.
71 *
72 * The following named formats are defined:
73 *| Name Description
74 *| ---- -----------
75 *| General Date Display Date, and time for non-integer values
76 *| Short Date Short date format as defined by locale settings
77 *| Medium Date Medium date format as defined by locale settings
78 *| Long Date Long date format as defined by locale settings
79 *| Short Time Short Time format as defined by locale settings
80 *| Medium Time Medium time format as defined by locale settings
81 *| Long Time Long time format as defined by locale settings
82 *| True/False Localised text of "True" or "False"
83 *| Yes/No Localised text of "Yes" or "No"
84 *| On/Off Localised text of "On" or "Off"
85 *| General Number No thousands separator. No decimal points for integers
86 *| Currency General currency format using localised characters
87 *| Fixed At least one whole and two fractional digits
88 *| Standard Same as 'Fixed', but including decimal separators
89 *| Percent Multiply by 100 and display a trailing '%' character
90 *| Scientific Display with exponent
91 *
92 * User-defined formats consist of a combination of tokens and literal
93 * characters. Literal characters are copied unmodified to the formatted
94 * output at the position they occupy in the format string. Any character
95 * that is not recognised as a token is treated as a literal. A literal can
96 * also be specified by preceding it with a backslash character
97 * (e.g. "\L\i\t\e\r\a\l") or enclosing it in double quotes.
98 *
99 * A user-defined format can have up to 4 sections, depending on the type of
100 * format. The following table lists sections and their meaning:
101 *| Format Type Sections Meaning
102 *| ----------- -------- -------
103 *| Number 1 Use the same format for all numbers
104 *| Number 2 Use format 1 for positive and 2 for negative numbers
105 *| Number 3 Use format 1 for positive, 2 for zero, and 3
106 *| for negative numbers.
107 *| Number 4 Use format 1 for positive, 2 for zero, 3 for
108 *| negative, and 4 for null numbers.
109 *| String 1 Use the same format for all strings
110 *| String 2 Use format 2 for null and empty strings, otherwise
111 *| use format 1.
112 *| Date 1 Use the same format for all dates
113 *
114 * The formatting tokens fall into several categories depending on the type
115 * of formatted output. For more information on each type, see
116 * VarFormat-Dates(), VarFormat-Strings() and VarFormat-Numbers().
117 *
118 * SEE ALSO
119 * VarTokenizeFormatString(), VarFormatFromTokens(), VarFormat(),
120 * VarFormatDateTime(), VarFormatNumber(), VarFormatCurrency().
121 */
122
123 /******************************************************************************
124 * VarFormat-Strings {OLEAUT32}
125 *
126 * NOTES
127 * When formatting a variant as a string, it is first converted to a VT_BSTR.
128 * The user-format string defines which characters are copied into which
129 * positions in the output string. Literals may be inserted in the format
130 * string. When creating the formatted string, excess characters in the string
131 * (those not consumed by a token) are appended to the end of the output. If
132 * there are more tokens than characters in the string to format, spaces will
133 * be inserted at the start of the string if the '@' token was used.
134 *
135 * By default strings are converted to lowercase, or uppercase if the '>' token
136 * is encountered. This applies to the whole string: it is not possible to
137 * generate a mixed-case output string.
138 *
139 * In user-defined string formats, the following tokens are recognised:
140 *| Token Description
141 *| ----- -----------
142 *| '@' Copy a char from the source, or a space if no chars are left.
143 *| '&' Copy a char from the source, or write nothing if no chars are left.
144 *| '<' Output the whole string as lower-case (the default).
145 *| '>' Output the whole string as upper-case.
146 *| '!' MSDN indicates that this character should cause right-to-left
147 *| copying, however tests show that it is tokenised but not processed.
148 */
149
150 /*
151 * Common format definitions
152 */
153
154 /* Format types */
155 #define FMT_TYPE_UNKNOWN 0x0
156 #define FMT_TYPE_GENERAL 0x1
157 #define FMT_TYPE_NUMBER 0x2
158 #define FMT_TYPE_DATE 0x3
159 #define FMT_TYPE_STRING 0x4
160
161 #define FMT_TO_STRING 0x0 /* If header->size == this, act like VB's Str() fn */
162
163 typedef struct tagFMT_SHORT_HEADER
164 {
165 BYTE size; /* Size of tokenised block (including header), or FMT_TO_STRING */
166 BYTE type; /* Allowable types (FMT_TYPE_*) */
167 BYTE offset[1]; /* Offset of the first (and only) format section */
168 } FMT_SHORT_HEADER;
169
170 typedef struct tagFMT_HEADER
171 {
172 BYTE size; /* Total size of the whole tokenised block (including header) */
173 BYTE type; /* Allowable types (FMT_TYPE_*) */
174 BYTE starts[4]; /* Offset of each of the 4 format sections, or 0 if none */
175 } FMT_HEADER;
176
177 #define FmtGetPositive(x) (x->starts[0])
178 #define FmtGetNegative(x) (x->starts[1] ? x->starts[1] : x->starts[0])
179 #define FmtGetZero(x) (x->starts[2] ? x->starts[2] : x->starts[0])
180 #define FmtGetNull(x) (x->starts[3] ? x->starts[3] : x->starts[0])
181
182 /*
183 * String formats
184 */
185
186 #define FMT_FLAG_LT 0x1 /* Has '<' (lower case) */
187 #define FMT_FLAG_GT 0x2 /* Has '>' (upper case) */
188 #define FMT_FLAG_RTL 0x4 /* Has '!' (Copy right to left) */
189
190 typedef struct tagFMT_STRING_HEADER
191 {
192 BYTE flags; /* LT, GT, RTL */
193 BYTE unknown1;
194 BYTE unknown2;
195 BYTE copy_chars; /* Number of chars to be copied */
196 BYTE unknown3;
197 } FMT_STRING_HEADER;
198
199 /*
200 * Number formats
201 */
202
203 #define FMT_FLAG_PERCENT 0x1 /* Has '%' (Percentage) */
204 #define FMT_FLAG_EXPONENT 0x2 /* Has 'e' (Exponent/Scientific notation) */
205 #define FMT_FLAG_THOUSANDS 0x4 /* Has ',' (Standard use of the thousands separator) */
206 #define FMT_FLAG_BOOL 0x20 /* Boolean format */
207
208 typedef struct tagFMT_NUMBER_HEADER
209 {
210 BYTE flags; /* PERCENT, EXPONENT, THOUSANDS, BOOL */
211 BYTE multiplier; /* Multiplier, 100 for percentages */
212 BYTE divisor; /* Divisor, 1000 if '%%' was used */
213 BYTE whole; /* Number of digits before the decimal point */
214 BYTE fractional; /* Number of digits after the decimal point */
215 } FMT_NUMBER_HEADER;
216
217 /*
218 * Date Formats
219 */
220 typedef struct tagFMT_DATE_HEADER
221 {
222 BYTE flags;
223 BYTE unknown1;
224 BYTE unknown2;
225 BYTE unknown3;
226 BYTE unknown4;
227 } FMT_DATE_HEADER;
228
229 /*
230 * Format token values
231 */
232 #define FMT_GEN_COPY 0x00 /* \n, "lit" => 0,pos,len: Copy len chars from input+pos */
233 #define FMT_GEN_INLINE 0x01 /* => 1,len,[chars]: Copy len chars from token stream */
234 #define FMT_GEN_END 0x02 /* \0,; => 2: End of the tokenised format */
235 #define FMT_DATE_TIME_SEP 0x03 /* Time separator char */
236 #define FMT_DATE_DATE_SEP 0x04 /* Date separator char */
237 #define FMT_DATE_GENERAL 0x05 /* General format date */
238 #define FMT_DATE_QUARTER 0x06 /* Quarter of the year from 1-4 */
239 #define FMT_DATE_TIME_SYS 0x07 /* System long time format */
240 #define FMT_DATE_DAY 0x08 /* Day with no leading 0 */
241 #define FMT_DATE_DAY_0 0x09 /* Day with leading 0 */
242 #define FMT_DATE_DAY_SHORT 0x0A /* Short day name */
243 #define FMT_DATE_DAY_LONG 0x0B /* Long day name */
244 #define FMT_DATE_SHORT 0x0C /* Short date format */
245 #define FMT_DATE_LONG 0x0D /* Long date format */
246 #define FMT_DATE_MEDIUM 0x0E /* Medium date format */
247 #define FMT_DATE_DAY_WEEK 0x0F /* First day of the week */
248 #define FMT_DATE_WEEK_YEAR 0x10 /* First week of the year */
249 #define FMT_DATE_MON 0x11 /* Month with no leading 0 */
250 #define FMT_DATE_MON_0 0x12 /* Month with leading 0 */
251 #define FMT_DATE_MON_SHORT 0x13 /* Short month name */
252 #define FMT_DATE_MON_LONG 0x14 /* Long month name */
253 #define FMT_DATE_YEAR_DOY 0x15 /* Day of the year with no leading 0 */
254 #define FMT_DATE_YEAR_0 0x16 /* 2 digit year with leading 0 */
255 /* NOTE: token 0x17 is not defined, 'yyy' is not valid */
256 #define FMT_DATE_YEAR_LONG 0x18 /* 4 digit year */
257 #define FMT_DATE_MIN 0x1A /* Minutes with no leading 0 */
258 #define FMT_DATE_MIN_0 0x1B /* Minutes with leading 0 */
259 #define FMT_DATE_SEC 0x1C /* Seconds with no leading 0 */
260 #define FMT_DATE_SEC_0 0x1D /* Seconds with leading 0 */
261 #define FMT_DATE_HOUR 0x1E /* Hours with no leading 0 */
262 #define FMT_DATE_HOUR_0 0x1F /* Hours with leading 0 */
263 #define FMT_DATE_HOUR_12 0x20 /* Hours with no leading 0, 12 hour clock */
264 #define FMT_DATE_HOUR_12_0 0x21 /* Hours with leading 0, 12 hour clock */
265 #define FMT_DATE_TIME_UNK2 0x23
266 /* FIXME: probably missing some here */
267 #define FMT_DATE_AMPM_SYS1 0x2E /* AM/PM as defined by system settings */
268 #define FMT_DATE_AMPM_UPPER 0x2F /* Upper-case AM or PM */
269 #define FMT_DATE_A_UPPER 0x30 /* Upper-case A or P */
270 #define FMT_DATE_AMPM_SYS2 0x31 /* AM/PM as defined by system settings */
271 #define FMT_DATE_AMPM_LOWER 0x32 /* Lower-case AM or PM */
272 #define FMT_DATE_A_LOWER 0x33 /* Lower-case A or P */
273 #define FMT_NUM_COPY_ZERO 0x34 /* Copy 1 digit or 0 if no digit */
274 #define FMT_NUM_COPY_SKIP 0x35 /* Copy 1 digit or skip if no digit */
275 #define FMT_NUM_DECIMAL 0x36 /* Decimal separator */
276 #define FMT_NUM_EXP_POS_U 0x37 /* Scientific notation, uppercase, + sign */
277 #define FMT_NUM_EXP_NEG_U 0x38 /* Scientific notation, uppercase, - sign */
278 #define FMT_NUM_EXP_POS_L 0x39 /* Scientific notation, lowercase, + sign */
279 #define FMT_NUM_EXP_NEG_L 0x3A /* Scientific notation, lowercase, - sign */
280 #define FMT_NUM_CURRENCY 0x3B /* Currency symbol */
281 #define FMT_NUM_TRUE_FALSE 0x3D /* Convert to "True" or "False" */
282 #define FMT_NUM_YES_NO 0x3E /* Convert to "Yes" or "No" */
283 #define FMT_NUM_ON_OFF 0x3F /* Convert to "On" or "Off" */
284 #define FMT_STR_COPY_SPACE 0x40 /* Copy len chars with space if no char */
285 #define FMT_STR_COPY_SKIP 0x41 /* Copy len chars or skip if no char */
286 /* Wine additions */
287 #define FMT_WINE_HOURS_12 0x81 /* Hours using 12 hour clock */
288
289 /* Named Formats and their tokenised values */
290 static const WCHAR szGeneralDate[] = { 'G','e','n','e','r','a','l',' ','D','a','t','e','\0' };
291 static const BYTE fmtGeneralDate[0x0a] =
292 {
293 0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
294 0x0,0x0,0x0,0x0,0x0,
295 FMT_DATE_GENERAL,FMT_GEN_END
296 };
297
298 static const WCHAR szShortDate[] = { 'S','h','o','r','t',' ','D','a','t','e','\0' };
299 static const BYTE fmtShortDate[0x0a] =
300 {
301 0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
302 0x0,0x0,0x0,0x0,0x0,
303 FMT_DATE_SHORT,FMT_GEN_END
304 };
305
306 static const WCHAR szMediumDate[] = { 'M','e','d','i','u','m',' ','D','a','t','e','\0' };
307 static const BYTE fmtMediumDate[0x0a] =
308 {
309 0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
310 0x0,0x0,0x0,0x0,0x0,
311 FMT_DATE_MEDIUM,FMT_GEN_END
312 };
313
314 static const WCHAR szLongDate[] = { 'L','o','n','g',' ','D','a','t','e','\0' };
315 static const BYTE fmtLongDate[0x0a] =
316 {
317 0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
318 0x0,0x0,0x0,0x0,0x0,
319 FMT_DATE_LONG,FMT_GEN_END
320 };
321
322 static const WCHAR szShortTime[] = { 'S','h','o','r','t',' ','T','i','m','e','\0' };
323 static const BYTE fmtShortTime[0x0c] =
324 {
325 0x0c,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
326 0x0,0x0,0x0,0x0,0x0,
327 FMT_DATE_TIME_UNK2,FMT_DATE_TIME_SEP,FMT_DATE_MIN_0,FMT_GEN_END
328 };
329
330 static const WCHAR szMediumTime[] = { 'M','e','d','i','u','m',' ','T','i','m','e','\0' };
331 static const BYTE fmtMediumTime[0x11] =
332 {
333 0x11,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
334 0x0,0x0,0x0,0x0,0x0,
335 FMT_DATE_HOUR_12_0,FMT_DATE_TIME_SEP,FMT_DATE_MIN_0,
336 FMT_GEN_INLINE,0x01,' ','\0',FMT_DATE_AMPM_SYS1,FMT_GEN_END
337 };
338
339 static const WCHAR szLongTime[] = { 'L','o','n','g',' ','T','i','m','e','\0' };
340 static const BYTE fmtLongTime[0x0d] =
341 {
342 0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
343 0x0,0x0,0x0,0x0,0x0,
344 FMT_DATE_TIME_SYS,FMT_GEN_END
345 };
346
347 static const WCHAR szTrueFalse[] = { 'T','r','u','e','/','F','a','l','s','e','\0' };
348 static const BYTE fmtTrueFalse[0x0d] =
349 {
350 0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
351 FMT_FLAG_BOOL,0x0,0x0,0x0,0x0,
352 FMT_NUM_TRUE_FALSE,FMT_GEN_END
353 };
354
355 static const WCHAR szYesNo[] = { 'Y','e','s','/','N','o','\0' };
356 static const BYTE fmtYesNo[0x0d] =
357 {
358 0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
359 FMT_FLAG_BOOL,0x0,0x0,0x0,0x0,
360 FMT_NUM_YES_NO,FMT_GEN_END
361 };
362
363 static const WCHAR szOnOff[] = { 'O','n','/','O','f','f','\0' };
364 static const BYTE fmtOnOff[0x0d] =
365 {
366 0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
367 FMT_FLAG_BOOL,0x0,0x0,0x0,0x0,
368 FMT_NUM_ON_OFF,FMT_GEN_END
369 };
370
371 static const WCHAR szGeneralNumber[] = { 'G','e','n','e','r','a','l',' ','N','u','m','b','e','r','\0' };
372 static const BYTE fmtGeneralNumber[sizeof(FMT_HEADER)] =
373 {
374 sizeof(FMT_HEADER),FMT_TYPE_GENERAL,sizeof(FMT_HEADER),0x0,0x0,0x0
375 };
376
377 static const WCHAR szCurrency[] = { 'C','u','r','r','e','n','c','y','\0' };
378 static const BYTE fmtCurrency[0x26] =
379 {
380 0x26,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x12,0x0,0x0,
381 /* Positive numbers */
382 FMT_FLAG_THOUSANDS,0xcc,0x0,0x1,0x2,
383 FMT_NUM_CURRENCY,FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,
384 FMT_GEN_END,
385 /* Negative numbers */
386 FMT_FLAG_THOUSANDS,0xcc,0x0,0x1,0x2,
387 FMT_GEN_INLINE,0x1,'(','\0',FMT_NUM_CURRENCY,FMT_NUM_COPY_ZERO,0x1,
388 FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_GEN_INLINE,0x1,')','\0',
389 FMT_GEN_END
390 };
391
392 static const WCHAR szFixed[] = { 'F','i','x','e','d','\0' };
393 static const BYTE fmtFixed[0x11] =
394 {
395 0x11,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
396 0x0,0x0,0x0,0x1,0x2,
397 FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_GEN_END
398 };
399
400 static const WCHAR szStandard[] = { 'S','t','a','n','d','a','r','d','\0' };
401 static const BYTE fmtStandard[0x11] =
402 {
403 0x11,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
404 FMT_FLAG_THOUSANDS,0x0,0x0,0x1,0x2,
405 FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_GEN_END
406 };
407
408 static const WCHAR szPercent[] = { 'P','e','r','c','e','n','t','\0' };
409 static const BYTE fmtPercent[0x15] =
410 {
411 0x15,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
412 FMT_FLAG_PERCENT,0x1,0x0,0x1,0x2,
413 FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,
414 FMT_GEN_INLINE,0x1,'%','\0',FMT_GEN_END
415 };
416
417 static const WCHAR szScientific[] = { 'S','c','i','e','n','t','i','f','i','c','\0' };
418 static const BYTE fmtScientific[0x13] =
419 {
420 0x13,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
421 FMT_FLAG_EXPONENT,0x0,0x0,0x1,0x2,
422 FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_NUM_EXP_POS_U,0x2,FMT_GEN_END
423 };
424
425 typedef struct tagNAMED_FORMAT
426 {
427 LPCWSTR name;
428 const BYTE* format;
429 } NAMED_FORMAT;
430
431 /* Format name to tokenised format. Must be kept sorted by name */
432 static const NAMED_FORMAT VARIANT_NamedFormats[] =
433 {
434 { szCurrency, fmtCurrency },
435 { szFixed, fmtFixed },
436 { szGeneralDate, fmtGeneralDate },
437 { szGeneralNumber, fmtGeneralNumber },
438 { szLongDate, fmtLongDate },
439 { szLongTime, fmtLongTime },
440 { szMediumDate, fmtMediumDate },
441 { szMediumTime, fmtMediumTime },
442 { szOnOff, fmtOnOff },
443 { szPercent, fmtPercent },
444 { szScientific, fmtScientific },
445 { szShortDate, fmtShortDate },
446 { szShortTime, fmtShortTime },
447 { szStandard, fmtStandard },
448 { szTrueFalse, fmtTrueFalse },
449 { szYesNo, fmtYesNo }
450 };
451 typedef const NAMED_FORMAT *LPCNAMED_FORMAT;
452
453 static int FormatCompareFn(const void *l, const void *r)
454 {
455 return strcmpiW(((LPCNAMED_FORMAT)l)->name, ((LPCNAMED_FORMAT)r)->name);
456 }
457
458 static inline const BYTE *VARIANT_GetNamedFormat(LPCWSTR lpszFormat)
459 {
460 NAMED_FORMAT key;
461 LPCNAMED_FORMAT fmt;
462
463 key.name = lpszFormat;
464 fmt = (LPCNAMED_FORMAT)bsearch(&key, VARIANT_NamedFormats,
465 sizeof(VARIANT_NamedFormats)/sizeof(NAMED_FORMAT),
466 sizeof(NAMED_FORMAT), FormatCompareFn);
467 return fmt ? fmt->format : NULL;
468 }
469
470 /* Return an error if the token for the value will not fit in the destination */
471 #define NEED_SPACE(x) if (cbTok < (int)(x)) return TYPE_E_BUFFERTOOSMALL; cbTok -= (x)
472
473 /* Non-zero if the format is unknown or a given type */
474 #define COULD_BE(typ) ((!fmt_number && header->type==FMT_TYPE_UNKNOWN)||header->type==typ)
475
476 /* State during tokenising */
477 #define FMT_STATE_OPEN_COPY 0x1 /* Last token written was a copy */
478 #define FMT_STATE_WROTE_DECIMAL 0x2 /* Already wrote a decimal separator */
479 #define FMT_STATE_SEEN_HOURS 0x4 /* See the hh specifier */
480 #define FMT_STATE_WROTE_MINUTES 0x8 /* Wrote minutes */
481
482 /**********************************************************************
483 * VarTokenizeFormatString [OLEAUT32.140]
484 *
485 * Convert a format string into tokenised form.
486 *
487 * PARAMS
488 * lpszFormat [I] Format string to tokenise
489 * rgbTok [O] Destination for tokenised format
490 * cbTok [I] Size of rgbTok in bytes
491 * nFirstDay [I] First day of the week (1-7, or 0 for current system default)
492 * nFirstWeek [I] How to treat the first week (see notes)
493 * lcid [I] Locale Id of the format string
494 * pcbActual [O] If non-NULL, filled with the first token generated
495 *
496 * RETURNS
497 * Success: S_OK. rgbTok contains the tokenised format.
498 * Failure: E_INVALIDARG, if any argument is invalid.
499 * TYPE_E_BUFFERTOOSMALL, if rgbTok is not large enough.
500 *
501 * NOTES
502 * Valid values for the nFirstWeek parameter are:
503 *| Value Meaning
504 *| ----- -------
505 *| 0 Use the current system default
506 *| 1 The first week is that containing Jan 1
507 *| 2 Four or more days of the first week are in the current year
508 *| 3 The first week is 7 days long
509 * See Variant-Formats(), VarFormatFromTokens().
510 */
511 HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok,
512 int cbTok, int nFirstDay, int nFirstWeek,
513 LCID lcid, int *pcbActual)
514 {
515 /* Note: none of these strings should be NUL terminated */
516 static const WCHAR szTTTTT[] = { 't','t','t','t','t' };
517 static const WCHAR szAMPM[] = { 'A','M','P','M' };
518 static const WCHAR szampm[] = { 'a','m','p','m' };
519 static const WCHAR szAMSlashPM[] = { 'A','M','/','P','M' };
520 static const WCHAR szamSlashpm[] = { 'a','m','/','p','m' };
521 const BYTE *namedFmt;
522 FMT_HEADER *header = (FMT_HEADER*)rgbTok;
523 FMT_STRING_HEADER *str_header = (FMT_STRING_HEADER*)(rgbTok + sizeof(FMT_HEADER));
524 FMT_NUMBER_HEADER *num_header = (FMT_NUMBER_HEADER*)str_header;
525 BYTE* pOut = rgbTok + sizeof(FMT_HEADER) + sizeof(FMT_STRING_HEADER);
526 BYTE* pLastHours = NULL;
527 BYTE fmt_number = 0;
528 DWORD fmt_state = 0;
529 LPCWSTR pFormat = lpszFormat;
530
531 TRACE("(%s,%p,%d,%d,%d,0x%08x,%p)\n", debugstr_w(lpszFormat), rgbTok, cbTok,
532 nFirstDay, nFirstWeek, lcid, pcbActual);
533
534 if (!rgbTok ||
535 nFirstDay < 0 || nFirstDay > 7 || nFirstWeek < 0 || nFirstWeek > 3)
536 return E_INVALIDARG;
537
538 if (!lpszFormat || !*lpszFormat)
539 {
540 /* An empty string means 'general format' */
541 NEED_SPACE(sizeof(BYTE));
542 *rgbTok = FMT_TO_STRING;
543 if (pcbActual)
544 *pcbActual = FMT_TO_STRING;
545 return S_OK;
546 }
547
548 if (cbTok > 255)
549 cbTok = 255; /* Ensure we error instead of wrapping */
550
551 /* Named formats */
552 namedFmt = VARIANT_GetNamedFormat(lpszFormat);
553 if (namedFmt)
554 {
555 NEED_SPACE(namedFmt[0]);
556 memcpy(rgbTok, namedFmt, namedFmt[0]);
557 TRACE("Using pre-tokenised named format %s\n", debugstr_w(lpszFormat));
558 /* FIXME: pcbActual */
559 return S_OK;
560 }
561
562 /* Insert header */
563 NEED_SPACE(sizeof(FMT_HEADER) + sizeof(FMT_STRING_HEADER));
564 memset(header, 0, sizeof(FMT_HEADER));
565 memset(str_header, 0, sizeof(FMT_STRING_HEADER));
566
567 header->starts[fmt_number] = sizeof(FMT_HEADER);
568
569 while (*pFormat)
570 {
571 /* --------------
572 * General tokens
573 * --------------
574 */
575 if (*pFormat == ';')
576 {
577 while (*pFormat == ';')
578 {
579 TRACE(";\n");
580 if (++fmt_number > 3)
581 return E_INVALIDARG; /* too many formats */
582 pFormat++;
583 }
584 if (*pFormat)
585 {
586 TRACE("New header\n");
587 NEED_SPACE(sizeof(BYTE) + sizeof(FMT_STRING_HEADER));
588 *pOut++ = FMT_GEN_END;
589
590 header->starts[fmt_number] = pOut - rgbTok;
591 str_header = (FMT_STRING_HEADER*)pOut;
592 num_header = (FMT_NUMBER_HEADER*)pOut;
593 memset(str_header, 0, sizeof(FMT_STRING_HEADER));
594 pOut += sizeof(FMT_STRING_HEADER);
595 fmt_state = 0;
596 pLastHours = NULL;
597 }
598 }
599 else if (*pFormat == '\\')
600 {
601 /* Escaped character */
602 if (pFormat[1])
603 {
604 NEED_SPACE(3 * sizeof(BYTE));
605 pFormat++;
606 *pOut++ = FMT_GEN_COPY;
607 *pOut++ = pFormat - lpszFormat;
608 *pOut++ = 0x1;
609 fmt_state |= FMT_STATE_OPEN_COPY;
610 TRACE("'\\'\n");
611 }
612 else
613 fmt_state &= ~FMT_STATE_OPEN_COPY;
614 pFormat++;
615 }
616 else if (*pFormat == '"')
617 {
618 /* Escaped string
619 * Note: Native encodes "" as a copy of length zero. That's just dumb, so
620 * here we avoid encoding anything in this case.
621 */
622 if (!pFormat[1])
623 pFormat++;
624 else if (pFormat[1] == '"')
625 {
626 pFormat += 2;
627 }
628 else
629 {
630 LPCWSTR start = ++pFormat;
631 while (*pFormat && *pFormat != '"')
632 pFormat++;
633 NEED_SPACE(3 * sizeof(BYTE));
634 *pOut++ = FMT_GEN_COPY;
635 *pOut++ = start - lpszFormat;
636 *pOut++ = pFormat - start;
637 if (*pFormat == '"')
638 pFormat++;
639 TRACE("Quoted string pos %d, len %d\n", pOut[-2], pOut[-1]);
640 }
641 fmt_state &= ~FMT_STATE_OPEN_COPY;
642 }
643 /* -------------
644 * Number tokens
645 * -------------
646 */
647 else if (*pFormat == '0' && COULD_BE(FMT_TYPE_NUMBER))
648 {
649 /* Number formats: Digit from number or '0' if no digits
650 * Other formats: Literal
651 * Types the format if found
652 */
653 header->type = FMT_TYPE_NUMBER;
654 NEED_SPACE(2 * sizeof(BYTE));
655 *pOut++ = FMT_NUM_COPY_ZERO;
656 *pOut = 0x0;
657 while (*pFormat == '0')
658 {
659 *pOut = *pOut + 1;
660 pFormat++;
661 }
662 if (fmt_state & FMT_STATE_WROTE_DECIMAL)
663 num_header->fractional += *pOut;
664 else
665 num_header->whole += *pOut;
666 TRACE("%d 0's\n", *pOut);
667 pOut++;
668 fmt_state &= ~FMT_STATE_OPEN_COPY;
669 }
670 else if (*pFormat == '#' && COULD_BE(FMT_TYPE_NUMBER))
671 {
672 /* Number formats: Digit from number or blank if no digits
673 * Other formats: Literal
674 * Types the format if found
675 */
676 header->type = FMT_TYPE_NUMBER;
677 NEED_SPACE(2 * sizeof(BYTE));
678 *pOut++ = FMT_NUM_COPY_SKIP;
679 *pOut = 0x0;
680 while (*pFormat == '#')
681 {
682 *pOut = *pOut + 1;
683 pFormat++;
684 }
685 if (fmt_state & FMT_STATE_WROTE_DECIMAL)
686 num_header->fractional += *pOut;
687 else
688 num_header->whole += *pOut;
689 TRACE("%d #'s\n", *pOut);
690 pOut++;
691 fmt_state &= ~FMT_STATE_OPEN_COPY;
692 }
693 else if (*pFormat == '.' && COULD_BE(FMT_TYPE_NUMBER) &&
694 !(fmt_state & FMT_STATE_WROTE_DECIMAL))
695 {
696 /* Number formats: Decimal separator when 1st seen, literal thereafter
697 * Other formats: Literal
698 * Types the format if found
699 */
700 header->type = FMT_TYPE_NUMBER;
701 NEED_SPACE(sizeof(BYTE));
702 *pOut++ = FMT_NUM_DECIMAL;
703 fmt_state |= FMT_STATE_WROTE_DECIMAL;
704 fmt_state &= ~FMT_STATE_OPEN_COPY;
705 pFormat++;
706 TRACE("decimal sep\n");
707 }
708 else if ((*pFormat == 'e' || *pFormat == 'E') && (pFormat[1] == '-' ||
709 pFormat[1] == '+') && header->type == FMT_TYPE_NUMBER)
710 {
711 /* Number formats: Exponent specifier
712 * Other formats: Literal
713 */
714 num_header->flags |= FMT_FLAG_EXPONENT;
715 NEED_SPACE(2 * sizeof(BYTE));
716 if (*pFormat == 'e') {
717 if (pFormat[1] == '+')
718 *pOut = FMT_NUM_EXP_POS_L;
719 else
720 *pOut = FMT_NUM_EXP_NEG_L;
721 } else {
722 if (pFormat[1] == '+')
723 *pOut = FMT_NUM_EXP_POS_U;
724 else
725 *pOut = FMT_NUM_EXP_NEG_U;
726 }
727 pFormat += 2;
728 *++pOut = 0x0;
729 while (*pFormat == '0')
730 {
731 *pOut = *pOut + 1;
732 pFormat++;
733 }
734 pOut++;
735 TRACE("exponent\n");
736 }
737 /* FIXME: %% => Divide by 1000 */
738 else if (*pFormat == ',' && header->type == FMT_TYPE_NUMBER)
739 {
740 /* Number formats: Use the thousands separator
741 * Other formats: Literal
742 */
743 num_header->flags |= FMT_FLAG_THOUSANDS;
744 pFormat++;
745 fmt_state &= ~FMT_STATE_OPEN_COPY;
746 TRACE("thousands sep\n");
747 }
748 /* -----------
749 * Date tokens
750 * -----------
751 */
752 else if (*pFormat == '/' && COULD_BE(FMT_TYPE_DATE))
753 {
754 /* Date formats: Date separator
755 * Other formats: Literal
756 * Types the format if found
757 */
758 header->type = FMT_TYPE_DATE;
759 NEED_SPACE(sizeof(BYTE));
760 *pOut++ = FMT_DATE_DATE_SEP;
761 pFormat++;
762 fmt_state &= ~FMT_STATE_OPEN_COPY;
763 TRACE("date sep\n");
764 }
765 else if (*pFormat == ':' && COULD_BE(FMT_TYPE_DATE))
766 {
767 /* Date formats: Time separator
768 * Other formats: Literal
769 * Types the format if found
770 */
771 header->type = FMT_TYPE_DATE;
772 NEED_SPACE(sizeof(BYTE));
773 *pOut++ = FMT_DATE_TIME_SEP;
774 pFormat++;
775 fmt_state &= ~FMT_STATE_OPEN_COPY;
776 TRACE("time sep\n");
777 }
778 else if ((*pFormat == 'a' || *pFormat == 'A') &&
779 !strncmpiW(pFormat, szAMPM, sizeof(szAMPM)/sizeof(WCHAR)))
780 {
781 /* Date formats: System AM/PM designation
782 * Other formats: Literal
783 * Types the format if found
784 */
785 header->type = FMT_TYPE_DATE;
786 NEED_SPACE(sizeof(BYTE));
787 pFormat += sizeof(szAMPM)/sizeof(WCHAR);
788 if (!strncmpW(pFormat, szampm, sizeof(szampm)/sizeof(WCHAR)))
789 *pOut++ = FMT_DATE_AMPM_SYS2;
790 else
791 *pOut++ = FMT_DATE_AMPM_SYS1;
792 if (pLastHours)
793 *pLastHours = *pLastHours + 2;
794 TRACE("ampm\n");
795 }
796 else if (*pFormat == 'a' && pFormat[1] == '/' &&
797 (pFormat[2] == 'p' || pFormat[2] == 'P'))
798 {
799 /* Date formats: lowercase a or p designation
800 * Other formats: Literal
801 * Types the format if found
802 */
803 header->type = FMT_TYPE_DATE;
804 NEED_SPACE(sizeof(BYTE));
805 pFormat += 3;
806 *pOut++ = FMT_DATE_A_LOWER;
807 if (pLastHours)
808 *pLastHours = *pLastHours + 2;
809 TRACE("a/p\n");
810 }
811 else if (*pFormat == 'A' && pFormat[1] == '/' &&
812 (pFormat[2] == 'p' || pFormat[2] == 'P'))
813 {
814 /* Date formats: Uppercase a or p designation
815 * Other formats: Literal
816 * Types the format if found
817 */
818 header->type = FMT_TYPE_DATE;
819 NEED_SPACE(sizeof(BYTE));
820 pFormat += 3;
821 *pOut++ = FMT_DATE_A_UPPER;
822 if (pLastHours)
823 *pLastHours = *pLastHours + 2;
824 TRACE("A/P\n");
825 }
826 else if (*pFormat == 'a' &&
827 !strncmpW(pFormat, szamSlashpm, sizeof(szamSlashpm)/sizeof(WCHAR)))
828 {
829 /* Date formats: lowercase AM or PM designation
830 * Other formats: Literal
831 * Types the format if found
832 */
833 header->type = FMT_TYPE_DATE;
834 NEED_SPACE(sizeof(BYTE));
835 pFormat += sizeof(szamSlashpm)/sizeof(WCHAR);
836 *pOut++ = FMT_DATE_AMPM_LOWER;
837 if (pLastHours)
838 *pLastHours = *pLastHours + 2;
839 TRACE("AM/PM\n");
840 }
841 else if (*pFormat == 'A' &&
842 !strncmpW(pFormat, szAMSlashPM, sizeof(szAMSlashPM)/sizeof(WCHAR)))
843 {
844 /* Date formats: Uppercase AM or PM designation
845 * Other formats: Literal
846 * Types the format if found
847 */
848 header->type = FMT_TYPE_DATE;
849 NEED_SPACE(sizeof(BYTE));
850 pFormat += sizeof(szAMSlashPM)/sizeof(WCHAR);
851 *pOut++ = FMT_DATE_AMPM_UPPER;
852 TRACE("AM/PM\n");
853 }
854 else if (*pFormat == 'c' || *pFormat == 'C')
855 {
856 /* Date formats: General date format
857 * Other formats: Literal
858 * Types the format if found
859 */
860 header->type = FMT_TYPE_DATE;
861 NEED_SPACE(sizeof(BYTE));
862 pFormat += sizeof(szAMSlashPM)/sizeof(WCHAR);
863 *pOut++ = FMT_DATE_GENERAL;
864 TRACE("gen date\n");
865 }
866 else if ((*pFormat == 'd' || *pFormat == 'D') && COULD_BE(FMT_TYPE_DATE))
867 {
868 /* Date formats: Day specifier
869 * Other formats: Literal
870 * Types the format if found
871 */
872 int count = -1;
873 header->type = FMT_TYPE_DATE;
874 while ((*pFormat == 'd' || *pFormat == 'D') && count < 6)
875 {
876 pFormat++;
877 count++;
878 }
879 NEED_SPACE(sizeof(BYTE));
880 *pOut++ = FMT_DATE_DAY + count;
881 fmt_state &= ~FMT_STATE_OPEN_COPY;
882 /* When we find the days token, reset the seen hours state so that
883 * 'mm' is again written as month when encountered.
884 */
885 fmt_state &= ~FMT_STATE_SEEN_HOURS;
886 TRACE("%d d's\n", count + 1);
887 }
888 else if ((*pFormat == 'h' || *pFormat == 'H') && COULD_BE(FMT_TYPE_DATE))
889 {
890 /* Date formats: Hour specifier
891 * Other formats: Literal
892 * Types the format if found
893 */
894 header->type = FMT_TYPE_DATE;
895 NEED_SPACE(sizeof(BYTE));
896 pFormat++;
897 /* Record the position of the hours specifier - if we encounter
898 * an am/pm specifier we will change the hours from 24 to 12.
899 */
900 pLastHours = pOut;
901 if (*pFormat == 'h' || *pFormat == 'H')
902 {
903 pFormat++;
904 *pOut++ = FMT_DATE_HOUR_0;
905 TRACE("hh\n");
906 }
907 else
908 {
909 *pOut++ = FMT_DATE_HOUR;
910 TRACE("h\n");
911 }
912 fmt_state &= ~FMT_STATE_OPEN_COPY;
913 /* Note that now we have seen an hours token, the next occurrence of
914 * 'mm' indicates minutes, not months.
915 */
916 fmt_state |= FMT_STATE_SEEN_HOURS;
917 }
918 else if ((*pFormat == 'm' || *pFormat == 'M') && COULD_BE(FMT_TYPE_DATE))
919 {
920 /* Date formats: Month specifier (or Minute specifier, after hour specifier)
921 * Other formats: Literal
922 * Types the format if found
923 */
924 int count = -1;
925 header->type = FMT_TYPE_DATE;
926 while ((*pFormat == 'm' || *pFormat == 'M') && count < 4)
927 {
928 pFormat++;
929 count++;
930 }
931 NEED_SPACE(sizeof(BYTE));
932 if (count <= 1 && fmt_state & FMT_STATE_SEEN_HOURS &&
933 !(fmt_state & FMT_STATE_WROTE_MINUTES))
934 {
935 /* We have seen an hours specifier and not yet written a minutes
936 * specifier. Write this as minutes and thereafter as months.
937 */
938 *pOut++ = count == 1 ? FMT_DATE_MIN_0 : FMT_DATE_MIN;
939 fmt_state |= FMT_STATE_WROTE_MINUTES; /* Hereafter write months */
940 }
941 else
942 *pOut++ = FMT_DATE_MON + count; /* Months */
943 fmt_state &= ~FMT_STATE_OPEN_COPY;
944 TRACE("%d m's\n", count + 1);
945 }
946 else if ((*pFormat == 'n' || *pFormat == 'N') && COULD_BE(FMT_TYPE_DATE))
947 {
948 /* Date formats: Minute specifier
949 * Other formats: Literal
950 * Types the format if found
951 */
952 header->type = FMT_TYPE_DATE;
953 NEED_SPACE(sizeof(BYTE));
954 pFormat++;
955 if (*pFormat == 'n' || *pFormat == 'N')
956 {
957 pFormat++;
958 *pOut++ = FMT_DATE_MIN_0;
959 TRACE("nn\n");
960 }
961 else
962 {
963 *pOut++ = FMT_DATE_MIN;
964 TRACE("n\n");
965 }
966 fmt_state &= ~FMT_STATE_OPEN_COPY;
967 }
968 else if ((*pFormat == 'q' || *pFormat == 'q') && COULD_BE(FMT_TYPE_DATE))
969 {
970 /* Date formats: Quarter specifier
971 * Other formats: Literal
972 * Types the format if found
973 */
974 header->type = FMT_TYPE_DATE;
975 NEED_SPACE(sizeof(BYTE));
976 *pOut++ = FMT_DATE_QUARTER;
977 pFormat++;
978 fmt_state &= ~FMT_STATE_OPEN_COPY;
979 TRACE("quarter\n");
980 }
981 else if ((*pFormat == 's' || *pFormat == 'S') && COULD_BE(FMT_TYPE_DATE))
982 {
983 /* Date formats: Second specifier
984 * Other formats: Literal
985 * Types the format if found
986 */
987 header->type = FMT_TYPE_DATE;
988 NEED_SPACE(sizeof(BYTE));
989 pFormat++;
990 if (*pFormat == 's' || *pFormat == 'S')
991 {
992 pFormat++;
993 *pOut++ = FMT_DATE_SEC_0;
994 TRACE("ss\n");
995 }
996 else
997 {
998 *pOut++ = FMT_DATE_SEC;
999 TRACE("s\n");
1000 }
1001 fmt_state &= ~FMT_STATE_OPEN_COPY;
1002 }
1003 else if ((*pFormat == 't' || *pFormat == 'T') &&
1004 !strncmpiW(pFormat, szTTTTT, sizeof(szTTTTT)/sizeof(WCHAR)))
1005 {
1006 /* Date formats: System time specifier
1007 * Other formats: Literal
1008 * Types the format if found
1009 */
1010 header->type = FMT_TYPE_DATE;
1011 pFormat += sizeof(szTTTTT)/sizeof(WCHAR);
1012 NEED_SPACE(sizeof(BYTE));
1013 *pOut++ = FMT_DATE_TIME_SYS;
1014 fmt_state &= ~FMT_STATE_OPEN_COPY;
1015 }
1016 else if ((*pFormat == 'w' || *pFormat == 'W') && COULD_BE(FMT_TYPE_DATE))
1017 {
1018 /* Date formats: Week of the year/Day of the week
1019 * Other formats: Literal
1020 * Types the format if found
1021 */
1022 header->type = FMT_TYPE_DATE;
1023 pFormat++;
1024 if (*pFormat == 'w' || *pFormat == 'W')
1025 {
1026 NEED_SPACE(3 * sizeof(BYTE));
1027 pFormat++;
1028 *pOut++ = FMT_DATE_WEEK_YEAR;
1029 *pOut++ = nFirstDay;
1030 *pOut++ = nFirstWeek;
1031 TRACE("ww\n");
1032 }
1033 else
1034 {
1035 NEED_SPACE(2 * sizeof(BYTE));
1036 *pOut++ = FMT_DATE_DAY_WEEK;
1037 *pOut++ = nFirstDay;
1038 TRACE("w\n");
1039 }
1040
1041 fmt_state &= ~FMT_STATE_OPEN_COPY;
1042 }
1043 else if ((*pFormat == 'y' || *pFormat == 'Y') && COULD_BE(FMT_TYPE_DATE))
1044 {
1045 /* Date formats: Day of year/Year specifier
1046 * Other formats: Literal
1047 * Types the format if found
1048 */
1049 int count = -1;
1050 header->type = FMT_TYPE_DATE;
1051 while ((*pFormat == 'y' || *pFormat == 'Y') && count < 4)
1052 {
1053 pFormat++;
1054 count++;
1055 }
1056 if (count == 2)
1057 {
1058 count--; /* 'yyy' has no meaning, despite what MSDN says */
1059 pFormat--;
1060 }
1061 NEED_SPACE(sizeof(BYTE));
1062 *pOut++ = FMT_DATE_YEAR_DOY + count;
1063 fmt_state &= ~FMT_STATE_OPEN_COPY;
1064 TRACE("%d y's\n", count + 1);
1065 }
1066 /* -------------
1067 * String tokens
1068 * -------------
1069 */
1070 else if (*pFormat == '@' && COULD_BE(FMT_TYPE_STRING))
1071 {
1072 /* String formats: Character from string or space if no char
1073 * Other formats: Literal
1074 * Types the format if found
1075 */
1076 header->type = FMT_TYPE_STRING;
1077 NEED_SPACE(2 * sizeof(BYTE));
1078 *pOut++ = FMT_STR_COPY_SPACE;
1079 *pOut = 0x0;
1080 while (*pFormat == '@')
1081 {
1082 *pOut = *pOut + 1;
1083 str_header->copy_chars++;
1084 pFormat++;
1085 }
1086 TRACE("%d @'s\n", *pOut);
1087 pOut++;
1088 fmt_state &= ~FMT_STATE_OPEN_COPY;
1089 }
1090 else if (*pFormat == '&' && COULD_BE(FMT_TYPE_STRING))
1091 {
1092 /* String formats: Character from string or skip if no char
1093 * Other formats: Literal
1094 * Types the format if found
1095 */
1096 header->type = FMT_TYPE_STRING;
1097 NEED_SPACE(2 * sizeof(BYTE));
1098 *pOut++ = FMT_STR_COPY_SKIP;
1099 *pOut = 0x0;
1100 while (*pFormat == '&')
1101 {
1102 *pOut = *pOut + 1;
1103 str_header->copy_chars++;
1104 pFormat++;
1105 }
1106 TRACE("%d &'s\n", *pOut);
1107 pOut++;
1108 fmt_state &= ~FMT_STATE_OPEN_COPY;
1109 }
1110 else if ((*pFormat == '<' || *pFormat == '>') && COULD_BE(FMT_TYPE_STRING))
1111 {
1112 /* String formats: Use upper/lower case
1113 * Other formats: Literal
1114 * Types the format if found
1115 */
1116 header->type = FMT_TYPE_STRING;
1117 if (*pFormat == '<')
1118 str_header->flags |= FMT_FLAG_LT;
1119 else
1120 str_header->flags |= FMT_FLAG_GT;
1121 TRACE("to %s case\n", *pFormat == '<' ? "lower" : "upper");
1122 pFormat++;
1123 fmt_state &= ~FMT_STATE_OPEN_COPY;
1124 }
1125 else if (*pFormat == '!' && COULD_BE(FMT_TYPE_STRING))
1126 {
1127 /* String formats: Copy right to left
1128 * Other formats: Literal
1129 * Types the format if found
1130 */
1131 header->type = FMT_TYPE_STRING;
1132 str_header->flags |= FMT_FLAG_RTL;
1133 pFormat++;
1134 fmt_state &= ~FMT_STATE_OPEN_COPY;
1135 TRACE("copy right-to-left\n");
1136 }
1137 /* --------
1138 * Literals
1139 * --------
1140 */
1141 /* FIXME: [ seems to be ignored */
1142 else
1143 {
1144 if (*pFormat == '%' && header->type == FMT_TYPE_NUMBER)
1145 {
1146 /* Number formats: Percentage indicator, also a literal
1147 * Other formats: Literal
1148 * Doesn't type the format
1149 */
1150 num_header->flags |= FMT_FLAG_PERCENT;
1151 }
1152
1153 if (fmt_state & FMT_STATE_OPEN_COPY)
1154 {
1155 pOut[-1] = pOut[-1] + 1; /* Increase the length of the open copy */
1156 TRACE("extend copy (char '%c'), length now %d\n", *pFormat, pOut[-1]);
1157 }
1158 else
1159 {
1160 /* Create a new open copy */
1161 TRACE("New copy (char '%c')\n", *pFormat);
1162 NEED_SPACE(3 * sizeof(BYTE));
1163 *pOut++ = FMT_GEN_COPY;
1164 *pOut++ = pFormat - lpszFormat;
1165 *pOut++ = 0x1;
1166 fmt_state |= FMT_STATE_OPEN_COPY;
1167 }
1168 pFormat++;
1169 }
1170 }
1171
1172 *pOut++ = FMT_GEN_END;
1173
1174 header->size = pOut - rgbTok;
1175 if (pcbActual)
1176 *pcbActual = header->size;
1177
1178 return S_OK;
1179 }
1180
1181 /* Number formatting state flags */
1182 #define NUM_WROTE_DEC 0x01 /* Written the decimal separator */
1183 #define NUM_WRITE_ON 0x02 /* Started to write the number */
1184
1185 /* Format a variant using a number format */
1186 static HRESULT VARIANT_FormatNumber(LPVARIANT pVarIn, LPOLESTR lpszFormat,
1187 LPBYTE rgbTok, ULONG dwFlags,
1188 BSTR *pbstrOut, LCID lcid)
1189 {
1190 BYTE rgbDig[256], *prgbDig;
1191 NUMPARSE np;
1192 int have_int, need_int = 0, have_frac, need_frac, exponent = 0, pad = 0;
1193 WCHAR buff[256], *pBuff = buff;
1194 VARIANT vString, vBool;
1195 DWORD dwState = 0;
1196 FMT_HEADER *header = (FMT_HEADER*)rgbTok;
1197 FMT_NUMBER_HEADER *numHeader;
1198 const BYTE* pToken = NULL;
1199 HRESULT hRes = S_OK;
1200
1201 TRACE("(%p->(%s%s),%s,%p,0x%08x,%p,0x%08x)\n", pVarIn, debugstr_VT(pVarIn),
1202 debugstr_VF(pVarIn), debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut,
1203 lcid);
1204
1205 V_VT(&vString) = VT_EMPTY;
1206 V_VT(&vBool) = VT_BOOL;
1207
1208 if (V_TYPE(pVarIn) == VT_EMPTY || V_TYPE(pVarIn) == VT_NULL)
1209 {
1210 have_int = have_frac = 0;
1211 numHeader = (FMT_NUMBER_HEADER*)(rgbTok + FmtGetNull(header));
1212 V_BOOL(&vBool) = VARIANT_FALSE;
1213 }
1214 else
1215 {
1216 /* Get a number string from pVarIn, and parse it */
1217 hRes = VariantChangeTypeEx(&vString, pVarIn, LCID_US, VARIANT_NOUSEROVERRIDE, VT_BSTR);
1218 if (FAILED(hRes))
1219 return hRes;
1220
1221 np.cDig = sizeof(rgbDig);
1222 np.dwInFlags = NUMPRS_STD;
1223 hRes = VarParseNumFromStr(V_BSTR(&vString), LCID_US, 0, &np, rgbDig);
1224 if (FAILED(hRes))
1225 return hRes;
1226
1227 have_int = np.cDig;
1228 have_frac = 0;
1229 exponent = np.nPwr10;
1230
1231 /* Figure out which format to use */
1232 if (np.dwOutFlags & NUMPRS_NEG)
1233 {
1234 numHeader = (FMT_NUMBER_HEADER*)(rgbTok + FmtGetNegative(header));
1235 V_BOOL(&vBool) = VARIANT_TRUE;
1236 }
1237 else if (have_int == 1 && !exponent && rgbDig[0] == 0)
1238 {
1239 numHeader = (FMT_NUMBER_HEADER*)(rgbTok + FmtGetZero(header));
1240 V_BOOL(&vBool) = VARIANT_FALSE;
1241 }
1242 else
1243 {
1244 numHeader = (FMT_NUMBER_HEADER*)(rgbTok + FmtGetPositive(header));
1245 V_BOOL(&vBool) = VARIANT_TRUE;
1246 }
1247
1248 TRACE("num header: flags = 0x%x, mult=%d, div=%d, whole=%d, fract=%d\n",
1249 numHeader->flags, numHeader->multiplier, numHeader->divisor,
1250 numHeader->whole, numHeader->fractional);
1251
1252 need_int = numHeader->whole;
1253 need_frac = numHeader->fractional;
1254
1255 if (numHeader->flags & FMT_FLAG_PERCENT &&
1256 !(have_int == 1 && !exponent && rgbDig[0] == 0))
1257 exponent += 2;
1258
1259 if (numHeader->flags & FMT_FLAG_EXPONENT)
1260 {
1261 /* Exponent format: length of the integral number part is fixed and
1262 specified by the format. */
1263 pad = need_int - have_int;
1264 if (pad >= 0)
1265 exponent -= pad;
1266 else
1267 {
1268 have_int = need_int;
1269 have_frac -= pad;
1270 exponent -= pad;
1271 pad = 0;
1272 }
1273 }
1274 else
1275 {
1276 /* Convert the exponent */
1277 pad = max(exponent, -have_int);
1278 exponent -= pad;
1279 if (pad < 0)
1280 {
1281 have_int += pad;
1282 have_frac = -pad;
1283 pad = 0;
1284 }
1285 }
1286
1287 /* Rounding the number */
1288 if (have_frac > need_frac)
1289 {
1290 prgbDig = &rgbDig[have_int + need_frac];
1291 have_frac = need_frac;
1292 if (*prgbDig >= 5)
1293 {
1294 while (prgbDig-- > rgbDig && *prgbDig == 9)
1295 *prgbDig = 0;
1296 if (prgbDig < rgbDig)
1297 {
1298 /* We reached the first digit and that was also a 9 */
1299 rgbDig[0] = 1;
1300 if (numHeader->flags & FMT_FLAG_EXPONENT)
1301 exponent++;
1302 else
1303 {
1304 rgbDig[have_int + need_frac] = 0;
1305 have_int++;
1306 }
1307 }
1308 else
1309 (*prgbDig)++;
1310 }
1311 }
1312 TRACE("have_int=%d,need_int=%d,have_frac=%d,need_frac=%d,pad=%d,exp=%d\n",
1313 have_int, need_int, have_frac, need_frac, pad, exponent);
1314 }
1315
1316 pToken = (const BYTE*)numHeader + sizeof(FMT_NUMBER_HEADER);
1317 prgbDig = rgbDig;
1318
1319 while (SUCCEEDED(hRes) && *pToken != FMT_GEN_END)
1320 {
1321 WCHAR defaultChar = '?';
1322 DWORD boolFlag, localeValue = 0;
1323
1324 if (pToken - rgbTok > header->size)
1325 {
1326 ERR("Ran off the end of the format!\n");
1327 hRes = E_INVALIDARG;
1328 goto VARIANT_FormatNumber_Exit;
1329 }
1330
1331 switch (*pToken)
1332 {
1333 case FMT_GEN_COPY:
1334 TRACE("copy %s\n", debugstr_wn(lpszFormat + pToken[1], pToken[2]));
1335 memcpy(pBuff, lpszFormat + pToken[1], pToken[2] * sizeof(WCHAR));
1336 pBuff += pToken[2];
1337 pToken += 2;
1338 break;
1339
1340 case FMT_GEN_INLINE:
1341 pToken += 2;
1342 TRACE("copy %s\n", debugstr_a((LPCSTR)pToken));
1343 while (*pToken)
1344 *pBuff++ = *pToken++;
1345 break;
1346
1347 case FMT_NUM_YES_NO:
1348 boolFlag = VAR_BOOLYESNO;
1349 goto VARIANT_FormatNumber_Bool;
1350
1351 case FMT_NUM_ON_OFF:
1352 boolFlag = VAR_BOOLONOFF;
1353 goto VARIANT_FormatNumber_Bool;
1354
1355 case FMT_NUM_TRUE_FALSE:
1356 boolFlag = VAR_LOCALBOOL;
1357
1358 VARIANT_FormatNumber_Bool:
1359 {
1360 BSTR boolStr = NULL;
1361
1362 if (pToken[1] != FMT_GEN_END)
1363 {
1364 ERR("Boolean token not at end of format!\n");
1365 hRes = E_INVALIDARG;
1366 goto VARIANT_FormatNumber_Exit;
1367 }
1368 hRes = VarBstrFromBool(V_BOOL(&vBool), lcid, boolFlag, &boolStr);
1369 if (SUCCEEDED(hRes))
1370 {
1371 strcpyW(pBuff, boolStr);
1372 SysFreeString(boolStr);
1373 while (*pBuff)
1374 pBuff++;
1375 }
1376 }
1377 break;
1378
1379 case FMT_NUM_DECIMAL:
1380 TRACE("write decimal separator\n");
1381 localeValue = LOCALE_SDECIMAL;
1382 defaultChar = '.';
1383 dwState |= NUM_WROTE_DEC;
1384 break;
1385
1386 case FMT_NUM_CURRENCY:
1387 TRACE("write currency symbol\n");
1388 localeValue = LOCALE_SCURRENCY;
1389 defaultChar = '$';
1390 break;
1391
1392 case FMT_NUM_EXP_POS_U:
1393 case FMT_NUM_EXP_POS_L:
1394 case FMT_NUM_EXP_NEG_U:
1395 case FMT_NUM_EXP_NEG_L:
1396 if (*pToken == FMT_NUM_EXP_POS_L || *pToken == FMT_NUM_EXP_NEG_L)
1397 *pBuff++ = 'e';
1398 else
1399 *pBuff++ = 'E';
1400 if (exponent < 0)
1401 {
1402 *pBuff++ = '-';
1403 sprintfW(pBuff, szPercentZeroStar_d, pToken[1], -exponent);
1404 }
1405 else
1406 {
1407 if (*pToken == FMT_NUM_EXP_POS_L || *pToken == FMT_NUM_EXP_POS_U)
1408 *pBuff++ = '+';
1409 sprintfW(pBuff, szPercentZeroStar_d, pToken[1], exponent);
1410 }
1411 while (*pBuff)
1412 pBuff++;
1413 pToken++;
1414 break;
1415
1416 case FMT_NUM_COPY_ZERO:
1417 dwState |= NUM_WRITE_ON;
1418 /* Fall through */
1419
1420 case FMT_NUM_COPY_SKIP:
1421 TRACE("write %d %sdigits or %s\n", pToken[1],
1422 dwState & NUM_WROTE_DEC ? "fractional " : "",
1423 *pToken == FMT_NUM_COPY_ZERO ? "0" : "skip");
1424
1425 if (dwState & NUM_WROTE_DEC)
1426 {
1427 int count, i;
1428
1429 if (!(numHeader->flags & FMT_FLAG_EXPONENT) && exponent < 0)
1430 {
1431 /* Pad with 0 before writing the fractional digits */
1432 pad = max(exponent, -pToken[1]);
1433 exponent -= pad;
1434 count = min(have_frac, pToken[1] + pad);
1435 for (i = 0; i > pad; i--)
1436 *pBuff++ = '0';
1437 }
1438 else
1439 count = min(have_frac, pToken[1]);
1440
1441 pad += pToken[1] - count;
1442 have_frac -= count;
1443 while (count--)
1444 *pBuff++ = '0' + *prgbDig++;
1445 if (*pToken == FMT_NUM_COPY_ZERO)
1446 {
1447 for (; pad > 0; pad--)
1448 *pBuff++ = '0'; /* Write zeros for missing trailing digits */
1449 }
1450 }
1451 else
1452 {
1453 int count, count_max;
1454
1455 need_int -= pToken[1];
1456 count_max = have_int + pad - need_int;
1457 if (count_max < 0)
1458 count_max = 0;
1459 if (dwState & NUM_WRITE_ON)
1460 {
1461 count = pToken[1] - count_max;
1462 TRACE("write %d leading zeros\n", count);
1463 while (count-- > 0)
1464 *pBuff++ = '0';
1465 }
1466 if (*pToken == FMT_NUM_COPY_ZERO || have_int > 1 ||
1467 (have_int > 0 && *prgbDig > 0))
1468 {
1469 dwState |= NUM_WRITE_ON;
1470 count = min(count_max, have_int);
1471 count_max -= count;
1472 have_int -= count;
1473 TRACE("write %d whole number digits\n", count);
1474 while (count--)
1475 *pBuff++ = '0' + *prgbDig++;
1476 }
1477 count = min(count_max, pad);
1478 count_max -= count;
1479 pad -= count;
1480 TRACE("write %d whole trailing 0's\n", count);
1481 while (count--)
1482 *pBuff++ = '0';
1483 }
1484 pToken++;
1485 break;
1486
1487 default:
1488 ERR("Unknown token 0x%02x!\n", *pToken);
1489 hRes = E_INVALIDARG;
1490 goto VARIANT_FormatNumber_Exit;
1491 }
1492 if (localeValue)
1493 {
1494 if (GetLocaleInfoW(lcid, localeValue, pBuff,
1495 sizeof(buff)/sizeof(WCHAR)-(pBuff-buff)))
1496 {
1497 TRACE("added %s\n", debugstr_w(pBuff));
1498 while (*pBuff)
1499 pBuff++;
1500 }
1501 else
1502 {
1503 TRACE("added %d '%c'\n", defaultChar, defaultChar);
1504 *pBuff++ = defaultChar;
1505 }
1506 }
1507 pToken++;
1508 }
1509
1510 VARIANT_FormatNumber_Exit:
1511 VariantClear(&vString);
1512 *pBuff = '\0';
1513 TRACE("buff is %s\n", debugstr_w(buff));
1514 if (SUCCEEDED(hRes))
1515 {
1516 *pbstrOut = SysAllocString(buff);
1517 if (!*pbstrOut)
1518 hRes = E_OUTOFMEMORY;
1519 }
1520 return hRes;
1521 }
1522
1523 /* Format a variant using a date format */
1524 static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
1525 LPBYTE rgbTok, ULONG dwFlags,
1526 BSTR *pbstrOut, LCID lcid)
1527 {
1528 WCHAR buff[256], *pBuff = buff;
1529 VARIANT vDate;
1530 UDATE udate;
1531 FMT_HEADER *header = (FMT_HEADER*)rgbTok;
1532 FMT_DATE_HEADER *dateHeader;
1533 const BYTE* pToken = NULL;
1534 HRESULT hRes;
1535
1536 TRACE("(%p->(%s%s),%s,%p,0x%08x,%p,0x%08x)\n", pVarIn, debugstr_VT(pVarIn),
1537 debugstr_VF(pVarIn), debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut,
1538 lcid);
1539
1540 V_VT(&vDate) = VT_EMPTY;
1541
1542 if (V_TYPE(pVarIn) == VT_EMPTY || V_TYPE(pVarIn) == VT_NULL)
1543 {
1544 dateHeader = (FMT_DATE_HEADER*)(rgbTok + FmtGetNegative(header));
1545 V_DATE(&vDate) = 0;
1546 }
1547 else
1548 {
1549 USHORT usFlags = dwFlags & VARIANT_CALENDAR_HIJRI ? VAR_CALENDAR_HIJRI : 0;
1550
1551 hRes = VariantChangeTypeEx(&vDate, pVarIn, LCID_US, usFlags, VT_DATE);
1552 if (FAILED(hRes))
1553 return hRes;
1554 dateHeader = (FMT_DATE_HEADER*)(rgbTok + FmtGetPositive(header));
1555 }
1556
1557 hRes = VarUdateFromDate(V_DATE(&vDate), 0 /* FIXME: flags? */, &udate);
1558 if (FAILED(hRes))
1559 return hRes;
1560 pToken = (const BYTE*)dateHeader + sizeof(FMT_DATE_HEADER);
1561
1562 while (*pToken != FMT_GEN_END)
1563 {
1564 DWORD dwVal = 0, localeValue = 0, dwFmt = 0;
1565 LPCWSTR szPrintFmt = NULL;
1566 WCHAR defaultChar = '?';
1567
1568 if (pToken - rgbTok > header->size)
1569 {
1570 ERR("Ran off the end of the format!\n");
1571 hRes = E_INVALIDARG;
1572 goto VARIANT_FormatDate_Exit;
1573 }
1574
1575 switch (*pToken)
1576 {
1577 case FMT_GEN_COPY:
1578 TRACE("copy %s\n", debugstr_wn(lpszFormat + pToken[1], pToken[2]));
1579 memcpy(pBuff, lpszFormat + pToken[1], pToken[2] * sizeof(WCHAR));
1580 pBuff += pToken[2];
1581 pToken += 2;
1582 break;
1583
1584 case FMT_DATE_TIME_SEP:
1585 TRACE("time separator\n");
1586 localeValue = LOCALE_STIME;
1587 defaultChar = ':';
1588 break;
1589
1590 case FMT_DATE_DATE_SEP:
1591 TRACE("date separator\n");
1592 localeValue = LOCALE_SDATE;
1593 defaultChar = '/';
1594 break;
1595
1596 case FMT_DATE_GENERAL:
1597 {
1598 BSTR date = NULL;
1599 WCHAR *pDate;
1600 hRes = VarBstrFromDate(V_DATE(&vDate), lcid, 0, &date);
1601 if (FAILED(hRes))
1602 goto VARIANT_FormatDate_Exit;
1603 pDate = date;
1604 while (*pDate)
1605 *pBuff++ = *pDate++;
1606 SysFreeString(date);
1607 }
1608 break;
1609
1610 case FMT_DATE_QUARTER:
1611 if (udate.st.wMonth <= 3)
1612 *pBuff++ = '1';
1613 else if (udate.st.wMonth <= 6)
1614 *pBuff++ = '2';
1615 else if (udate.st.wMonth <= 9)
1616 *pBuff++ = '3';
1617 else
1618 *pBuff++ = '4';
1619 break;
1620
1621 case FMT_DATE_TIME_SYS:
1622 {
1623 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1624 BSTR date = NULL;
1625 WCHAR *pDate;
1626 hRes = VarBstrFromDate(V_DATE(&vDate), lcid, VAR_TIMEVALUEONLY, &date);
1627 if (FAILED(hRes))
1628 goto VARIANT_FormatDate_Exit;
1629 pDate = date;
1630 while (*pDate)
1631 *pBuff++ = *pDate++;
1632 SysFreeString(date);
1633 }
1634 break;
1635
1636 case FMT_DATE_DAY:
1637 szPrintFmt = szPercent_d;
1638 dwVal = udate.st.wDay;
1639 break;
1640
1641 case FMT_DATE_DAY_0:
1642 szPrintFmt = szPercentZeroTwo_d;
1643 dwVal = udate.st.wDay;
1644 break;
1645
1646 case FMT_DATE_DAY_SHORT:
1647 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1648 TRACE("short day\n");
1649 localeValue = LOCALE_SABBREVDAYNAME1 + udate.st.wMonth - 1;
1650 defaultChar = '?';
1651 break;
1652
1653 case FMT_DATE_DAY_LONG:
1654 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1655 TRACE("long day\n");
1656 localeValue = LOCALE_SDAYNAME1 + udate.st.wMonth - 1;
1657 defaultChar = '?';
1658 break;
1659
1660 case FMT_DATE_SHORT:
1661 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1662 dwFmt = LOCALE_SSHORTDATE;
1663 break;
1664
1665 case FMT_DATE_LONG:
1666 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1667 dwFmt = LOCALE_SLONGDATE;
1668 break;
1669
1670 case FMT_DATE_MEDIUM:
1671 FIXME("Medium date treated as long date\n");
1672 dwFmt = LOCALE_SLONGDATE;
1673 break;
1674
1675 case FMT_DATE_DAY_WEEK:
1676 szPrintFmt = szPercent_d;
1677 if (pToken[1])
1678 dwVal = udate.st.wDayOfWeek + 2 - pToken[1];
1679 else
1680 {
1681 GetLocaleInfoW(lcid,LOCALE_RETURN_NUMBER|LOCALE_IFIRSTDAYOFWEEK,
1682 (LPWSTR)&dwVal, sizeof(dwVal)/sizeof(WCHAR));
1683 dwVal = udate.st.wDayOfWeek + 1 - dwVal;
1684 }
1685 pToken++;
1686 break;
1687
1688 case FMT_DATE_WEEK_YEAR:
1689 szPrintFmt = szPercent_d;
1690 dwVal = udate.wDayOfYear / 7 + 1;
1691 pToken += 2;
1692 FIXME("Ignoring nFirstDay of %d, nFirstWeek of %d\n", pToken[0], pToken[1]);
1693 break;
1694
1695 case FMT_DATE_MON:
1696 szPrintFmt = szPercent_d;
1697 dwVal = udate.st.wMonth;
1698 break;
1699
1700 case FMT_DATE_MON_0:
1701 szPrintFmt = szPercentZeroTwo_d;
1702 dwVal = udate.st.wMonth;
1703 break;
1704
1705 case FMT_DATE_MON_SHORT:
1706 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1707 TRACE("short month\n");
1708 localeValue = LOCALE_SABBREVMONTHNAME1 + udate.st.wMonth - 1;
1709 defaultChar = '?';
1710 break;
1711
1712 case FMT_DATE_MON_LONG:
1713 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1714 TRACE("long month\n");
1715 localeValue = LOCALE_SMONTHNAME1 + udate.st.wMonth - 1;
1716 defaultChar = '?';
1717 break;
1718
1719 case FMT_DATE_YEAR_DOY:
1720 szPrintFmt = szPercent_d;
1721 dwVal = udate.wDayOfYear;
1722 break;
1723
1724 case FMT_DATE_YEAR_0:
1725 szPrintFmt = szPercentZeroTwo_d;
1726 dwVal = udate.st.wYear % 100;
1727 break;
1728
1729 case FMT_DATE_YEAR_LONG:
1730 szPrintFmt = szPercent_d;
1731 dwVal = udate.st.wYear;
1732 break;
1733
1734 case FMT_DATE_MIN:
1735 szPrintFmt = szPercent_d;
1736 dwVal = udate.st.wMinute;
1737 break;
1738
1739 case FMT_DATE_MIN_0:
1740 szPrintFmt = szPercentZeroTwo_d;
1741 dwVal = udate.st.wMinute;
1742 break;
1743
1744 case FMT_DATE_SEC:
1745 szPrintFmt = szPercent_d;
1746 dwVal = udate.st.wSecond;
1747 break;
1748
1749 case FMT_DATE_SEC_0:
1750 szPrintFmt = szPercentZeroTwo_d;
1751 dwVal = udate.st.wSecond;
1752 break;
1753
1754 case FMT_DATE_HOUR:
1755 szPrintFmt = szPercent_d;
1756 dwVal = udate.st.wHour;
1757 break;
1758
1759 case FMT_DATE_HOUR_0:
1760 szPrintFmt = szPercentZeroTwo_d;
1761 dwVal = udate.st.wHour;
1762 break;
1763
1764 case FMT_DATE_HOUR_12:
1765 szPrintFmt = szPercent_d;
1766 dwVal = udate.st.wHour ? udate.st.wHour > 12 ? udate.st.wHour - 12 : udate.st.wHour : 12;
1767 break;
1768
1769 case FMT_DATE_HOUR_12_0:
1770 szPrintFmt = szPercentZeroTwo_d;
1771 dwVal = udate.st.wHour ? udate.st.wHour > 12 ? udate.st.wHour - 12 : udate.st.wHour : 12;
1772 break;
1773
1774 case FMT_DATE_AMPM_SYS1:
1775 case FMT_DATE_AMPM_SYS2:
1776 localeValue = udate.st.wHour < 12 ? LOCALE_S1159 : LOCALE_S2359;
1777 defaultChar = '?';
1778 break;
1779
1780 case FMT_DATE_AMPM_UPPER:
1781 *pBuff++ = udate.st.wHour < 12 ? 'A' : 'P';
1782 *pBuff++ = 'M';
1783 break;
1784
1785 case FMT_DATE_A_UPPER:
1786 *pBuff++ = udate.st.wHour < 12 ? 'A' : 'P';
1787 break;
1788
1789 case FMT_DATE_AMPM_LOWER:
1790 *pBuff++ = udate.st.wHour < 12 ? 'a' : 'p';
1791 *pBuff++ = 'm';
1792 break;
1793
1794 case FMT_DATE_A_LOWER:
1795 *pBuff++ = udate.st.wHour < 12 ? 'a' : 'p';
1796 break;
1797
1798 default:
1799 ERR("Unknown token 0x%02x!\n", *pToken);
1800 hRes = E_INVALIDARG;
1801 goto VARIANT_FormatDate_Exit;
1802 }
1803 if (localeValue)
1804 {
1805 *pBuff = '\0';
1806 if (GetLocaleInfoW(lcid, localeValue, pBuff,
1807 sizeof(buff)/sizeof(WCHAR)-(pBuff-buff)))
1808 {
1809 TRACE("added %s\n", debugstr_w(pBuff));
1810 while (*pBuff)
1811 pBuff++;
1812 }
1813 else
1814 {
1815 TRACE("added %d %c\n", defaultChar, defaultChar);
1816 *pBuff++ = defaultChar;
1817 }
1818 }
1819 else if (dwFmt)
1820 {
1821 WCHAR fmt_buff[80];
1822
1823 if (!GetLocaleInfoW(lcid, dwFmt, fmt_buff, sizeof(fmt_buff)/sizeof(WCHAR)) ||
1824 !GetDateFormatW(lcid, 0, &udate.st, fmt_buff, pBuff,
1825 sizeof(buff)/sizeof(WCHAR)-(pBuff-buff)))
1826 {
1827 hRes = E_INVALIDARG;
1828 goto VARIANT_FormatDate_Exit;
1829 }
1830 while (*pBuff)
1831 pBuff++;
1832 }
1833 else if (szPrintFmt)
1834 {
1835 sprintfW(pBuff, szPrintFmt, dwVal);
1836 while (*pBuff)
1837 pBuff++;
1838 }
1839 pToken++;
1840 }
1841
1842 VARIANT_FormatDate_Exit:
1843 *pBuff = '\0';
1844 TRACE("buff is %s\n", debugstr_w(buff));
1845 if (SUCCEEDED(hRes))
1846 {
1847 *pbstrOut = SysAllocString(buff);
1848 if (!*pbstrOut)
1849 hRes = E_OUTOFMEMORY;
1850 }
1851 return hRes;
1852 }
1853
1854 /* Format a variant using a string format */
1855 static HRESULT VARIANT_FormatString(LPVARIANT pVarIn, LPOLESTR lpszFormat,
1856 LPBYTE rgbTok, ULONG dwFlags,
1857 BSTR *pbstrOut, LCID lcid)
1858 {
1859 static WCHAR szEmpty[] = { '\0' };
1860 WCHAR buff[256], *pBuff = buff;
1861 WCHAR *pSrc;
1862 FMT_HEADER *header = (FMT_HEADER*)rgbTok;
1863 FMT_STRING_HEADER *strHeader;
1864 const BYTE* pToken = NULL;
1865 VARIANT vStr;
1866 int blanks_first;
1867 BOOL bUpper = FALSE;
1868 HRESULT hRes = S_OK;
1869
1870 TRACE("(%p->(%s%s),%s,%p,0x%08x,%p,0x%08x)\n", pVarIn, debugstr_VT(pVarIn),
1871 debugstr_VF(pVarIn), debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut,
1872 lcid);
1873
1874 V_VT(&vStr) = VT_EMPTY;
1875
1876 if (V_TYPE(pVarIn) == VT_EMPTY || V_TYPE(pVarIn) == VT_NULL)
1877 {
1878 strHeader = (FMT_STRING_HEADER*)(rgbTok + FmtGetNegative(header));
1879 V_BSTR(&vStr) = szEmpty;
1880 }
1881 else
1882 {
1883 hRes = VariantChangeTypeEx(&vStr, pVarIn, LCID_US, VARIANT_NOUSEROVERRIDE, VT_BSTR);
1884 if (FAILED(hRes))
1885 return hRes;
1886
1887 if (V_BSTR(pVarIn)[0] == '\0')
1888 strHeader = (FMT_STRING_HEADER*)(rgbTok + FmtGetNegative(header));
1889 else
1890 strHeader = (FMT_STRING_HEADER*)(rgbTok + FmtGetPositive(header));
1891 }
1892 pSrc = V_BSTR(&vStr);
1893 if ((strHeader->flags & (FMT_FLAG_LT|FMT_FLAG_GT)) == FMT_FLAG_GT)
1894 bUpper = TRUE;
1895 blanks_first = strHeader->copy_chars - strlenW(pSrc);
1896 pToken = (const BYTE*)strHeader + sizeof(FMT_DATE_HEADER);
1897
1898 while (*pToken != FMT_GEN_END)
1899 {
1900 int dwCount = 0;
1901
1902 if (pToken - rgbTok > header->size)
1903 {
1904 ERR("Ran off the end of the format!\n");
1905 hRes = E_INVALIDARG;
1906 goto VARIANT_FormatString_Exit;
1907 }
1908
1909 switch (*pToken)
1910 {
1911 case FMT_GEN_COPY:
1912 TRACE("copy %s\n", debugstr_wn(lpszFormat + pToken[1], pToken[2]));
1913 memcpy(pBuff, lpszFormat + pToken[1], pToken[2] * sizeof(WCHAR));
1914 pBuff += pToken[2];
1915 pToken += 2;
1916 break;
1917
1918 case FMT_STR_COPY_SPACE:
1919 case FMT_STR_COPY_SKIP:
1920 dwCount = pToken[1];
1921 if (*pToken == FMT_STR_COPY_SPACE && blanks_first > 0)
1922 {
1923 TRACE("insert %d initial spaces\n", blanks_first);
1924 while (dwCount > 0 && blanks_first > 0)
1925 {
1926 *pBuff++ = ' ';
1927 dwCount--;
1928 blanks_first--;
1929 }
1930 }
1931 TRACE("copy %d chars%s\n", dwCount,
1932 *pToken == FMT_STR_COPY_SPACE ? " with space" :"");
1933 while (dwCount > 0 && *pSrc)
1934 {
1935 if (bUpper)
1936 *pBuff++ = toupperW(*pSrc);
1937 else
1938 *pBuff++ = tolowerW(*pSrc);
1939 dwCount--;
1940 pSrc++;
1941 }
1942 if (*pToken == FMT_STR_COPY_SPACE && dwCount > 0)
1943 {
1944 TRACE("insert %d spaces\n", dwCount);
1945 while (dwCount-- > 0)
1946 *pBuff++ = ' ';
1947 }
1948 pToken++;
1949 break;
1950
1951 default:
1952 ERR("Unknown token 0x%02x!\n", *pToken);
1953 hRes = E_INVALIDARG;
1954 goto VARIANT_FormatString_Exit;
1955 }
1956 pToken++;
1957 }
1958
1959 VARIANT_FormatString_Exit:
1960 /* Copy out any remaining chars */
1961 while (*pSrc)
1962 {
1963 if (bUpper)
1964 *pBuff++ = toupperW(*pSrc);
1965 else
1966 *pBuff++ = tolowerW(*pSrc);
1967 pSrc++;
1968 }
1969 VariantClear(&vStr);
1970 *pBuff = '\0';
1971 TRACE("buff is %s\n", debugstr_w(buff));
1972 if (SUCCEEDED(hRes))
1973 {
1974 *pbstrOut = SysAllocString(buff);
1975 if (!*pbstrOut)
1976 hRes = E_OUTOFMEMORY;
1977 }
1978 return hRes;
1979 }
1980
1981 #define NUMBER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2| \
1982 VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8| \
1983 VTBIT_R4|VTBIT_R8|VTBIT_CY|VTBIT_DECIMAL| \
1984 VTBIT_BOOL|VTBIT_INT|VTBIT_UINT)
1985
1986 /**********************************************************************
1987 * VarFormatFromTokens [OLEAUT32.139]
1988 */
1989 HRESULT WINAPI VarFormatFromTokens(LPVARIANT pVarIn, LPOLESTR lpszFormat,
1990 LPBYTE rgbTok, ULONG dwFlags,
1991 BSTR *pbstrOut, LCID lcid)
1992 {
1993 FMT_SHORT_HEADER *header = (FMT_SHORT_HEADER *)rgbTok;
1994 VARIANT vTmp;
1995 HRESULT hres;
1996
1997 TRACE("(%p,%s,%p,%x,%p,0x%08x)\n", pVarIn, debugstr_w(lpszFormat),
1998 rgbTok, dwFlags, pbstrOut, lcid);
1999
2000 if (!pbstrOut)
2001 return E_INVALIDARG;
2002
2003 *pbstrOut = NULL;
2004
2005 if (!pVarIn || !rgbTok)
2006 return E_INVALIDARG;
2007
2008 if (V_VT(pVarIn) == VT_NULL)
2009 return S_OK;
2010
2011 if (*rgbTok == FMT_TO_STRING || header->type == FMT_TYPE_GENERAL)
2012 {
2013 /* According to MSDN, general format acts somewhat like the 'Str'
2014 * function in Visual Basic.
2015 */
2016 VarFormatFromTokens_AsStr:
2017 V_VT(&vTmp) = VT_EMPTY;
2018 hres = VariantChangeTypeEx(&vTmp, pVarIn, lcid, dwFlags, VT_BSTR);
2019 *pbstrOut = V_BSTR(&vTmp);
2020 }
2021 else
2022 {
2023 if (header->type == FMT_TYPE_NUMBER ||
2024 (header->type == FMT_TYPE_UNKNOWN && ((1 << V_TYPE(pVarIn)) & NUMBER_VTBITS)))
2025 {
2026 hres = VARIANT_FormatNumber(pVarIn, lpszFormat, rgbTok, dwFlags, pbstrOut, lcid);
2027 }
2028 else if (header->type == FMT_TYPE_DATE ||
2029 (header->type == FMT_TYPE_UNKNOWN && V_TYPE(pVarIn) == VT_DATE))
2030 {
2031 hres = VARIANT_FormatDate(pVarIn, lpszFormat, rgbTok, dwFlags, pbstrOut, lcid);
2032 }
2033 else if (header->type == FMT_TYPE_STRING || V_TYPE(pVarIn) == VT_BSTR)
2034 {
2035 hres = VARIANT_FormatString(pVarIn, lpszFormat, rgbTok, dwFlags, pbstrOut, lcid);
2036 }
2037 else
2038 {
2039 ERR("unrecognised format type 0x%02x\n", header->type);
2040 return E_INVALIDARG;
2041 }
2042 /* If the coercion failed, still try to create output, unless the
2043 * VAR_FORMAT_NOSUBSTITUTE flag is set.
2044 */
2045 if ((hres == DISP_E_OVERFLOW || hres == DISP_E_TYPEMISMATCH) &&
2046 !(dwFlags & VAR_FORMAT_NOSUBSTITUTE))
2047 goto VarFormatFromTokens_AsStr;
2048 }
2049
2050 return hres;
2051 }
2052
2053 /**********************************************************************
2054 * VarFormat [OLEAUT32.87]
2055 *
2056 * Format a variant from a format string.
2057 *
2058 * PARAMS
2059 * pVarIn [I] Variant to format
2060 * lpszFormat [I] Format string (see notes)
2061 * nFirstDay [I] First day of the week, (See VarTokenizeFormatString() for details)
2062 * nFirstWeek [I] First week of the year (See VarTokenizeFormatString() for details)
2063 * dwFlags [I] Flags for the format (VAR_ flags from "oleauto.h")
2064 * pbstrOut [O] Destination for formatted string.
2065 *
2066 * RETURNS
2067 * Success: S_OK. pbstrOut contains the formatted value.
2068 * Failure: E_INVALIDARG, if any parameter is invalid.
2069 * E_OUTOFMEMORY, if enough memory cannot be allocated.
2070 * DISP_E_TYPEMISMATCH, if the variant cannot be formatted.
2071 *
2072 * NOTES
2073 * - See Variant-Formats for details concerning creating format strings.
2074 * - This function uses LOCALE_USER_DEFAULT when calling VarTokenizeFormatString()
2075 * and VarFormatFromTokens().
2076 */
2077 HRESULT WINAPI VarFormat(LPVARIANT pVarIn, LPOLESTR lpszFormat,
2078 int nFirstDay, int nFirstWeek, ULONG dwFlags,
2079 BSTR *pbstrOut)
2080 {
2081 BYTE buff[256];
2082 HRESULT hres;
2083
2084 TRACE("(%p->(%s%s),%s,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
2085 debugstr_VF(pVarIn), debugstr_w(lpszFormat), nFirstDay, nFirstWeek,
2086 dwFlags, pbstrOut);
2087
2088 if (!pbstrOut)
2089 return E_INVALIDARG;
2090 *pbstrOut = NULL;
2091
2092 hres = VarTokenizeFormatString(lpszFormat, buff, sizeof(buff), nFirstDay,
2093 nFirstWeek, LOCALE_USER_DEFAULT, NULL);
2094 if (SUCCEEDED(hres))
2095 hres = VarFormatFromTokens(pVarIn, lpszFormat, buff, dwFlags,
2096 pbstrOut, LOCALE_USER_DEFAULT);
2097 TRACE("returning 0x%08x, %s\n", hres, debugstr_w(*pbstrOut));
2098 return hres;
2099 }
2100
2101 /**********************************************************************
2102 * VarFormatDateTime [OLEAUT32.97]
2103 *
2104 * Format a variant value as a date and/or time.
2105 *
2106 * PARAMS
2107 * pVarIn [I] Variant to format
2108 * nFormat [I] Format type (see notes)
2109 * dwFlags [I] Flags for the format (VAR_ flags from "oleauto.h")
2110 * pbstrOut [O] Destination for formatted string.
2111 *
2112 * RETURNS
2113 * Success: S_OK. pbstrOut contains the formatted value.
2114 * Failure: E_INVALIDARG, if any parameter is invalid.
2115 * E_OUTOFMEMORY, if enough memory cannot be allocated.
2116 * DISP_E_TYPEMISMATCH, if the variant cannot be formatted.
2117 *
2118 * NOTES
2119 * This function uses LOCALE_USER_DEFAULT when determining the date format
2120 * characters to use.
2121 * Possible values for the nFormat parameter are:
2122 *| Value Meaning
2123 *| ----- -------
2124 *| 0 General date format
2125 *| 1 Long date format
2126 *| 2 Short date format
2127 *| 3 Long time format
2128 *| 4 Short time format
2129 */
2130 HRESULT WINAPI VarFormatDateTime(LPVARIANT pVarIn, INT nFormat, ULONG dwFlags, BSTR *pbstrOut)
2131 {
2132 static WCHAR szEmpty[] = { '\0' };
2133 const BYTE* lpFmt = NULL;
2134
2135 TRACE("(%p->(%s%s),%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
2136 debugstr_VF(pVarIn), nFormat, dwFlags, pbstrOut);
2137
2138 if (!pVarIn || !pbstrOut || nFormat < 0 || nFormat > 4)
2139 return E_INVALIDARG;
2140
2141 switch (nFormat)
2142 {
2143 case 0: lpFmt = fmtGeneralDate; break;
2144 case 1: lpFmt = fmtLongDate; break;
2145 case 2: lpFmt = fmtShortDate; break;
2146 case 3: lpFmt = fmtLongTime; break;
2147 case 4: lpFmt = fmtShortTime; break;
2148 }
2149 return VarFormatFromTokens(pVarIn, szEmpty, (BYTE*)lpFmt, dwFlags,
2150 pbstrOut, LOCALE_USER_DEFAULT);
2151 }
2152
2153 #define GETLOCALENUMBER(type,field) GetLocaleInfoW(LOCALE_USER_DEFAULT, \
2154 type|LOCALE_RETURN_NUMBER, \
2155 (LPWSTR)&numfmt.field, \
2156 sizeof(numfmt.field)/sizeof(WCHAR))
2157
2158 /**********************************************************************
2159 * VarFormatNumber [OLEAUT32.107]
2160 *
2161 * Format a variant value as a number.
2162 *
2163 * PARAMS
2164 * pVarIn [I] Variant to format
2165 * nDigits [I] Number of digits following the decimal point (-1 = user default)
2166 * nLeading [I] Use a leading zero (-2 = user default, -1 = yes, 0 = no)
2167 * nParens [I] Use brackets for values < 0 (-2 = user default, -1 = yes, 0 = no)
2168 * nGrouping [I] Use grouping characters (-2 = user default, -1 = yes, 0 = no)
2169 * dwFlags [I] Currently unused, set to zero
2170 * pbstrOut [O] Destination for formatted string.
2171 *
2172 * RETURNS
2173 * Success: S_OK. pbstrOut contains the formatted value.
2174 * Failure: E_INVALIDARG, if any parameter is invalid.
2175 * E_OUTOFMEMORY, if enough memory cannot be allocated.
2176 * DISP_E_TYPEMISMATCH, if the variant cannot be formatted.
2177 *
2178 * NOTES
2179 * This function uses LOCALE_USER_DEFAULT when determining the number format
2180 * characters to use.
2181 */
2182 HRESULT WINAPI VarFormatNumber(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT nParens,
2183 INT nGrouping, ULONG dwFlags, BSTR *pbstrOut)
2184 {
2185 HRESULT hRet;
2186 VARIANT vStr;
2187
2188 TRACE("(%p->(%s%s),%d,%d,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
2189 debugstr_VF(pVarIn), nDigits, nLeading, nParens, nGrouping, dwFlags, pbstrOut);
2190
2191 if (!pVarIn || !pbstrOut || nDigits > 9)
2192 return E_INVALIDARG;
2193
2194 *pbstrOut = NULL;
2195
2196 V_VT(&vStr) = VT_EMPTY;
2197 hRet = VariantCopyInd(&vStr, pVarIn);
2198
2199 if (SUCCEEDED(hRet))
2200 hRet = VariantChangeTypeEx(&vStr, &vStr, LCID_US, 0, VT_BSTR);
2201
2202 if (SUCCEEDED(hRet))
2203 {
2204 WCHAR buff[256], decimal[8], thousands[8];
2205 NUMBERFMTW numfmt;
2206
2207 /* Although MSDN makes it clear that the native versions of these functions
2208 * are implemented using VarTokenizeFormatString()/VarFormatFromTokens(),
2209 * using NLS gives us the same result.
2210 */
2211 if (nDigits < 0)
2212 GETLOCALENUMBER(LOCALE_IDIGITS, NumDigits);
2213 else
2214 numfmt.NumDigits = nDigits;
2215
2216 if (nLeading == -2)
2217 GETLOCALENUMBER(LOCALE_ILZERO, LeadingZero);
2218 else if (nLeading == -1)
2219 numfmt.LeadingZero = 1;
2220 else
2221 numfmt.LeadingZero = 0;
2222
2223 if (nGrouping == -2)
2224 {
2225 WCHAR grouping[16];
2226 grouping[2] = '\0';
2227 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, grouping,
2228 sizeof(grouping)/sizeof(WCHAR));
2229 numfmt.Grouping = grouping[2] == '2' ? 32 : grouping[0] - '0';
2230 }
2231 else if (nGrouping == -1)
2232 numfmt.Grouping = 3; /* 3 = "n,nnn.nn" */
2233 else
2234 numfmt.Grouping = 0; /* 0 = No grouping */
2235
2236 if (nParens == -2)
2237 GETLOCALENUMBER(LOCALE_INEGNUMBER, NegativeOrder);
2238 else if (nParens == -1)
2239 numfmt.NegativeOrder = 0; /* 0 = "(xxx)" */
2240 else
2241 numfmt.NegativeOrder = 1; /* 1 = "-xxx" */
2242
2243 numfmt.lpDecimalSep = decimal;
2244 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimal,
2245 sizeof(decimal)/sizeof(WCHAR));
2246 numfmt.lpThousandSep = thousands;
2247 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, thousands,
2248 sizeof(thousands)/sizeof(WCHAR));
2249
2250 if (GetNumberFormatW(LOCALE_USER_DEFAULT, 0, V_BSTR(&vStr), &numfmt,
2251 buff, sizeof(buff)/sizeof(WCHAR)))
2252 {
2253 *pbstrOut = SysAllocString(buff);
2254 if (!*pbstrOut)
2255 hRet = E_OUTOFMEMORY;
2256 }
2257 else
2258 hRet = DISP_E_TYPEMISMATCH;
2259
2260 SysFreeString(V_BSTR(&vStr));
2261 }
2262 return hRet;
2263 }
2264
2265 /**********************************************************************
2266 * VarFormatPercent [OLEAUT32.117]
2267 *
2268 * Format a variant value as a percentage.
2269 *
2270 * PARAMS
2271 * pVarIn [I] Variant to format
2272 * nDigits [I] Number of digits following the decimal point (-1 = user default)
2273 * nLeading [I] Use a leading zero (-2 = user default, -1 = yes, 0 = no)
2274 * nParens [I] Use brackets for values < 0 (-2 = user default, -1 = yes, 0 = no)
2275 * nGrouping [I] Use grouping characters (-2 = user default, -1 = yes, 0 = no)
2276 * dwFlags [I] Currently unused, set to zero
2277 * pbstrOut [O] Destination for formatted string.
2278 *
2279 * RETURNS
2280 * Success: S_OK. pbstrOut contains the formatted value.
2281 * Failure: E_INVALIDARG, if any parameter is invalid.
2282 * E_OUTOFMEMORY, if enough memory cannot be allocated.
2283 * DISP_E_OVERFLOW, if overflow occurs during the conversion.
2284 * DISP_E_TYPEMISMATCH, if the variant cannot be formatted.
2285 *
2286 * NOTES
2287 * This function uses LOCALE_USER_DEFAULT when determining the number format
2288 * characters to use.
2289 */
2290 HRESULT WINAPI VarFormatPercent(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT nParens,
2291 INT nGrouping, ULONG dwFlags, BSTR *pbstrOut)
2292 {
2293 static const WCHAR szPercent[] = { '%','\0' };
2294 static const WCHAR szPercentBracket[] = { '%',')','\0' };
2295 WCHAR buff[256];
2296 HRESULT hRet;
2297 VARIANT vDbl;
2298
2299 TRACE("(%p->(%s%s),%d,%d,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
2300 debugstr_VF(pVarIn), nDigits, nLeading, nParens, nGrouping,
2301 dwFlags, pbstrOut);
2302
2303 if (!pVarIn || !pbstrOut || nDigits > 9)
2304 return E_INVALIDARG;
2305
2306 *pbstrOut = NULL;
2307
2308 V_VT(&vDbl) = VT_EMPTY;
2309 hRet = VariantCopyInd(&vDbl, pVarIn);
2310
2311 if (SUCCEEDED(hRet))
2312 {
2313 hRet = VariantChangeTypeEx(&vDbl, &vDbl, LOCALE_USER_DEFAULT, 0, VT_R8);
2314
2315 if (SUCCEEDED(hRet))
2316 {
2317 if (V_R8(&vDbl) > (R8_MAX / 100.0))
2318 return DISP_E_OVERFLOW;
2319
2320 V_R8(&vDbl) *= 100.0;
2321 hRet = VarFormatNumber(&vDbl, nDigits, nLeading, nParens,
2322 nGrouping, dwFlags, pbstrOut);
2323
2324 if (SUCCEEDED(hRet))
2325 {
2326 DWORD dwLen = strlenW(*pbstrOut);
2327 BOOL bBracket = (*pbstrOut)[dwLen] == ')' ? TRUE : FALSE;
2328
2329 dwLen -= bBracket;
2330 memcpy(buff, *pbstrOut, dwLen * sizeof(WCHAR));
2331 strcpyW(buff + dwLen, bBracket ? szPercentBracket : szPercent);
2332 SysFreeString(*pbstrOut);
2333 *pbstrOut = SysAllocString(buff);
2334 if (!*pbstrOut)
2335 hRet = E_OUTOFMEMORY;
2336 }
2337 }
2338 }
2339 return hRet;
2340 }
2341
2342 /**********************************************************************
2343 * VarFormatCurrency [OLEAUT32.127]
2344 *
2345 * Format a variant value as a currency.
2346 *
2347 * PARAMS
2348 * pVarIn [I] Variant to format
2349 * nDigits [I] Number of digits following the decimal point (-1 = user default)
2350 * nLeading [I] Use a leading zero (-2 = user default, -1 = yes, 0 = no)
2351 * nParens [I] Use brackets for values < 0 (-2 = user default, -1 = yes, 0 = no)
2352 * nGrouping [I] Use grouping characters (-2 = user default, -1 = yes, 0 = no)
2353 * dwFlags [I] Currently unused, set to zero
2354 * pbstrOut [O] Destination for formatted string.
2355 *
2356 * RETURNS
2357 * Success: S_OK. pbstrOut contains the formatted value.
2358 * Failure: E_INVALIDARG, if any parameter is invalid.
2359 * E_OUTOFMEMORY, if enough memory cannot be allocated.
2360 * DISP_E_TYPEMISMATCH, if the variant cannot be formatted.
2361 *
2362 * NOTES
2363 * This function uses LOCALE_USER_DEFAULT when determining the currency format
2364 * characters to use.
2365 */
2366 HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading,
2367 INT nParens, INT nGrouping, ULONG dwFlags,
2368 BSTR *pbstrOut)
2369 {
2370 HRESULT hRet;
2371 VARIANT vStr;
2372
2373 TRACE("(%p->(%s%s),%d,%d,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
2374 debugstr_VF(pVarIn), nDigits, nLeading, nParens, nGrouping, dwFlags, pbstrOut);
2375
2376 if (!pVarIn || !pbstrOut || nDigits > 9)
2377 return E_INVALIDARG;
2378
2379 *pbstrOut = NULL;
2380
2381 V_VT(&vStr) = VT_EMPTY;
2382 hRet = VariantCopyInd(&vStr, pVarIn);
2383
2384 if (SUCCEEDED(hRet))
2385 hRet = VariantChangeTypeEx(&vStr, &vStr, LOCALE_USER_DEFAULT, 0, VT_BSTR);
2386
2387 if (SUCCEEDED(hRet))
2388 {
2389 WCHAR buff[256], decimal[8], thousands[8], currency[8];
2390 CURRENCYFMTW numfmt;
2391
2392 if (nDigits < 0)
2393 GETLOCALENUMBER(LOCALE_IDIGITS, NumDigits);
2394 else
2395 numfmt.NumDigits = nDigits;
2396
2397 if (nLeading == -2)
2398 GETLOCALENUMBER(LOCALE_ILZERO, LeadingZero);
2399 else if (nLeading == -1)
2400 numfmt.LeadingZero = 1;
2401 else
2402 numfmt.LeadingZero = 0;
2403
2404 if (nGrouping == -2)
2405 {
2406 WCHAR nGrouping[16];
2407 nGrouping[2] = '\0';
2408 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, nGrouping,
2409 sizeof(nGrouping)/sizeof(WCHAR));
2410 numfmt.Grouping = nGrouping[2] == '2' ? 32 : nGrouping[0] - '0';
2411 }
2412 else if (nGrouping == -1)
2413 numfmt.Grouping = 3; /* 3 = "n,nnn.nn" */
2414 else
2415 numfmt.Grouping = 0; /* 0 = No grouping */
2416
2417 if (nParens == -2)
2418 GETLOCALENUMBER(LOCALE_INEGCURR, NegativeOrder);
2419 else if (nParens == -1)
2420 numfmt.NegativeOrder = 0; /* 0 = "(xxx)" */
2421 else
2422 numfmt.NegativeOrder = 1; /* 1 = "-xxx" */
2423
2424 GETLOCALENUMBER(LOCALE_ICURRENCY, PositiveOrder);
2425
2426 numfmt.lpDecimalSep = decimal;
2427 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimal,
2428 sizeof(decimal)/sizeof(WCHAR));
2429 numfmt.lpThousandSep = thousands;
2430 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, thousands,
2431 sizeof(thousands)/sizeof(WCHAR));
2432 numfmt.lpCurrencySymbol = currency;
2433 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, currency,
2434 sizeof(currency)/sizeof(WCHAR));
2435
2436 /* use NLS as per VarFormatNumber() */
2437 if (GetCurrencyFormatW(LOCALE_USER_DEFAULT, 0, V_BSTR(&vStr), &numfmt,
2438 buff, sizeof(buff)/sizeof(WCHAR)))
2439 {
2440 *pbstrOut = SysAllocString(buff);
2441 if (!*pbstrOut)
2442 hRet = E_OUTOFMEMORY;
2443 }
2444 else
2445 hRet = DISP_E_TYPEMISMATCH;
2446
2447 SysFreeString(V_BSTR(&vStr));
2448 }
2449 return hRet;
2450 }
2451
2452 /**********************************************************************
2453 * VarMonthName [OLEAUT32.129]
2454 *
2455 * Print the specified month as localized name.
2456 *
2457 * PARAMS
2458 * iMonth [I] month number 1..12
2459 * fAbbrev [I] 0 - full name, !0 - abbreviated name
2460 * dwFlags [I] flag stuff. only VAR_CALENDAR_HIJRI possible.
2461 * pbstrOut [O] Destination for month name
2462 *
2463 * RETURNS
2464 * Success: S_OK. pbstrOut contains the name.
2465 * Failure: E_INVALIDARG, if any parameter is invalid.
2466 * E_OUTOFMEMORY, if enough memory cannot be allocated.
2467 */
2468 HRESULT WINAPI VarMonthName(INT iMonth, INT fAbbrev, ULONG dwFlags, BSTR *pbstrOut)
2469 {
2470 DWORD localeValue;
2471 INT size;
2472
2473 if ((iMonth < 1) || (iMonth > 12))
2474 return E_INVALIDARG;
2475
2476 if (dwFlags)
2477 FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags);
2478
2479 if (fAbbrev)
2480 localeValue = LOCALE_SABBREVMONTHNAME1 + iMonth - 1;
2481 else
2482 localeValue = LOCALE_SMONTHNAME1 + iMonth - 1;
2483
2484 size = GetLocaleInfoW(LOCALE_USER_DEFAULT,localeValue, NULL, 0);
2485 if (!size) {
2486 ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
2487 return HRESULT_FROM_WIN32(GetLastError());
2488 }
2489 *pbstrOut = SysAllocStringLen(NULL,size - 1);
2490 if (!*pbstrOut)
2491 return E_OUTOFMEMORY;
2492 size = GetLocaleInfoW(LOCALE_USER_DEFAULT,localeValue, *pbstrOut, size);
2493 if (!size) {
2494 ERR("GetLocaleInfo of 0x%x failed in 2nd stage?!\n", localeValue);
2495 SysFreeString(*pbstrOut);
2496 return HRESULT_FROM_WIN32(GetLastError());
2497 }
2498 return S_OK;
2499 }
2500
2501 /**********************************************************************
2502 * VarWeekdayName [OLEAUT32.129]
2503 *
2504 * Print the specified weekday as localized name.
2505 *
2506 * PARAMS
2507 * iWeekday [I] day of week, 1..7, 1="the first day of the week"
2508 * fAbbrev [I] 0 - full name, !0 - abbreviated name
2509 * iFirstDay [I] first day of week,
2510 * 0=system default, 1=Sunday, 2=Monday, .. (contrary to MSDN)
2511 * dwFlags [I] flag stuff. only VAR_CALENDAR_HIJRI possible.
2512 * pbstrOut [O] Destination for weekday name.
2513 *
2514 * RETURNS
2515 * Success: S_OK, pbstrOut contains the name.
2516 * Failure: E_INVALIDARG, if any parameter is invalid.
2517 * E_OUTOFMEMORY, if enough memory cannot be allocated.
2518 */
2519 HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
2520 ULONG dwFlags, BSTR *pbstrOut)
2521 {
2522 DWORD localeValue;
2523 INT size;
2524
2525 /* Windows XP oleaut32.dll doesn't allow iWekday==0, contrary to MSDN */
2526 if (iWeekday < 1 || iWeekday > 7)
2527 return E_INVALIDARG;
2528 if (iFirstDay < 0 || iFirstDay > 7)
2529 return E_INVALIDARG;
2530 if (!pbstrOut)
2531 return E_INVALIDARG;
2532
2533 if (dwFlags)
2534 FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags);
2535
2536 /* If we have to use the default firstDay, find which one it is */
2537 if (iFirstDay == 0) {
2538 DWORD firstDay;
2539 localeValue = LOCALE_RETURN_NUMBER | LOCALE_IFIRSTDAYOFWEEK;
2540 size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue,
2541 (LPWSTR)&firstDay, sizeof(firstDay) / sizeof(WCHAR));
2542 if (!size) {
2543 ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
2544 return HRESULT_FROM_WIN32(GetLastError());
2545 }
2546 iFirstDay = firstDay + 2;
2547 }
2548
2549 /* Determine what we need to return */
2550 localeValue = fAbbrev ? LOCALE_SABBREVDAYNAME1 : LOCALE_SDAYNAME1;
2551 localeValue += (7 + iWeekday - 1 + iFirstDay - 2) % 7;
2552
2553 /* Determine the size of the data, allocate memory and retrieve the data */
2554 size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, NULL, 0);
2555 if (!size) {
2556 ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
2557 return HRESULT_FROM_WIN32(GetLastError());
2558 }
2559 *pbstrOut = SysAllocStringLen(NULL, size - 1);
2560 if (!*pbstrOut)
2561 return E_OUTOFMEMORY;
2562 size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, *pbstrOut, size);
2563 if (!size) {
2564 ERR("GetLocaleInfo 0x%x failed in 2nd stage?!\n", localeValue);
2565 SysFreeString(*pbstrOut);
2566 return HRESULT_FROM_WIN32(GetLastError());
2567 }
2568 return S_OK;
2569 }
useful hacks and other patches not (yet) suitable for mainline