2 * Variant formatting functions
4 * Copyright 2003 Jon Griffiths
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.
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.
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
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.
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
38 #include "wine/unicode.h"
41 #include "wine/debug.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(variant
);
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.
49 #define LCID_US MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT)
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' };
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_]); \
64 /******************************************************************************
65 * Variant-Formats {OLEAUT32}
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.
72 * The following named formats are defined:
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
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.
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
112 *| Date 1 Use the same format for all dates
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().
119 * VarTokenizeFormatString(), VarFormatFromTokens(), VarFormat(),
120 * VarFormatDateTime(), VarFormatNumber(), VarFormatCurrency().
123 /******************************************************************************
124 * VarFormat-Strings {OLEAUT32}
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.
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.
139 * In user-defined string formats, the following tokens are recognised:
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.
151 * Common format definitions
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
161 #define FMT_TO_STRING 0x0 /* If header->size == this, act like VB's Str() fn */
163 typedef struct tagFMT_SHORT_HEADER
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 */
170 typedef struct tagFMT_HEADER
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 */
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])
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) */
190 typedef struct tagFMT_STRING_HEADER
192 BYTE flags
; /* LT, GT, RTL */
195 BYTE copy_chars
; /* Number of chars to be copied */
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 */
208 typedef struct tagFMT_NUMBER_HEADER
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 */
220 typedef struct tagFMT_DATE_HEADER
230 * Format token values
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 */
287 #define FMT_WINE_HOURS_12 0x81 /* Hours using 12 hour clock */
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] =
293 0x0a,FMT_TYPE_DATE
,sizeof(FMT_SHORT_HEADER
),
295 FMT_DATE_GENERAL
,FMT_GEN_END
298 static const WCHAR szShortDate
[] = { 'S','h','o','r','t',' ','D','a','t','e','\0' };
299 static const BYTE fmtShortDate
[0x0a] =
301 0x0a,FMT_TYPE_DATE
,sizeof(FMT_SHORT_HEADER
),
303 FMT_DATE_SHORT
,FMT_GEN_END
306 static const WCHAR szMediumDate
[] = { 'M','e','d','i','u','m',' ','D','a','t','e','\0' };
307 static const BYTE fmtMediumDate
[0x0a] =
309 0x0a,FMT_TYPE_DATE
,sizeof(FMT_SHORT_HEADER
),
311 FMT_DATE_MEDIUM
,FMT_GEN_END
314 static const WCHAR szLongDate
[] = { 'L','o','n','g',' ','D','a','t','e','\0' };
315 static const BYTE fmtLongDate
[0x0a] =
317 0x0a,FMT_TYPE_DATE
,sizeof(FMT_SHORT_HEADER
),
319 FMT_DATE_LONG
,FMT_GEN_END
322 static const WCHAR szShortTime
[] = { 'S','h','o','r','t',' ','T','i','m','e','\0' };
323 static const BYTE fmtShortTime
[0x0c] =
325 0x0c,FMT_TYPE_DATE
,sizeof(FMT_SHORT_HEADER
),
327 FMT_DATE_TIME_UNK2
,FMT_DATE_TIME_SEP
,FMT_DATE_MIN_0
,FMT_GEN_END
330 static const WCHAR szMediumTime
[] = { 'M','e','d','i','u','m',' ','T','i','m','e','\0' };
331 static const BYTE fmtMediumTime
[0x11] =
333 0x11,FMT_TYPE_DATE
,sizeof(FMT_SHORT_HEADER
),
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
339 static const WCHAR szLongTime
[] = { 'L','o','n','g',' ','T','i','m','e','\0' };
340 static const BYTE fmtLongTime
[0x0d] =
342 0x0a,FMT_TYPE_DATE
,sizeof(FMT_SHORT_HEADER
),
344 FMT_DATE_TIME_SYS
,FMT_GEN_END
347 static const WCHAR szTrueFalse
[] = { 'T','r','u','e','/','F','a','l','s','e','\0' };
348 static const BYTE fmtTrueFalse
[0x0d] =
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
355 static const WCHAR szYesNo
[] = { 'Y','e','s','/','N','o','\0' };
356 static const BYTE fmtYesNo
[0x0d] =
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
363 static const WCHAR szOnOff
[] = { 'O','n','/','O','f','f','\0' };
364 static const BYTE fmtOnOff
[0x0d] =
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
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
)] =
374 sizeof(FMT_HEADER
),FMT_TYPE_GENERAL
,sizeof(FMT_HEADER
),0x0,0x0,0x0
377 static const WCHAR szCurrency
[] = { 'C','u','r','r','e','n','c','y','\0' };
378 static const BYTE fmtCurrency
[0x26] =
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,
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',
392 static const WCHAR szFixed
[] = { 'F','i','x','e','d','\0' };
393 static const BYTE fmtFixed
[0x11] =
395 0x11,FMT_TYPE_NUMBER
,sizeof(FMT_HEADER
),0x0,0x0,0x0,
397 FMT_NUM_COPY_ZERO
,0x1,FMT_NUM_DECIMAL
,FMT_NUM_COPY_ZERO
,0x2,FMT_GEN_END
400 static const WCHAR szStandard
[] = { 'S','t','a','n','d','a','r','d','\0' };
401 static const BYTE fmtStandard
[0x11] =
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
408 static const WCHAR szPercent
[] = { 'P','e','r','c','e','n','t','\0' };
409 static const BYTE fmtPercent
[0x15] =
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
417 static const WCHAR szScientific
[] = { 'S','c','i','e','n','t','i','f','i','c','\0' };
418 static const BYTE fmtScientific
[0x13] =
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
425 typedef struct tagNAMED_FORMAT
431 /* Format name to tokenised format. Must be kept sorted by name */
432 static const NAMED_FORMAT VARIANT_NamedFormats
[] =
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
}
451 typedef const NAMED_FORMAT
*LPCNAMED_FORMAT
;
453 static int FormatCompareFn(const void *l
, const void *r
)
455 return strcmpiW(((LPCNAMED_FORMAT
)l
)->name
, ((LPCNAMED_FORMAT
)r
)->name
);
458 static inline const BYTE
*VARIANT_GetNamedFormat(LPCWSTR lpszFormat
)
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
;
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)
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)
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 */
482 /**********************************************************************
483 * VarTokenizeFormatString [OLEAUT32.140]
485 * Convert a format string into tokenised form.
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
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.
502 * Valid values for the nFirstWeek parameter are:
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().
511 HRESULT WINAPI
VarTokenizeFormatString(LPOLESTR lpszFormat
, LPBYTE rgbTok
,
512 int cbTok
, int nFirstDay
, int nFirstWeek
,
513 LCID lcid
, int *pcbActual
)
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
;
529 LPCWSTR pFormat
= lpszFormat
;
531 TRACE("(%s,%p,%d,%d,%d,0x%08x,%p)\n", debugstr_w(lpszFormat
), rgbTok
, cbTok
,
532 nFirstDay
, nFirstWeek
, lcid
, pcbActual
);
535 nFirstDay
< 0 || nFirstDay
> 7 || nFirstWeek
< 0 || nFirstWeek
> 3)
538 if (!lpszFormat
|| !*lpszFormat
)
540 /* An empty string means 'general format' */
541 NEED_SPACE(sizeof(BYTE
));
542 *rgbTok
= FMT_TO_STRING
;
544 *pcbActual
= FMT_TO_STRING
;
549 cbTok
= 255; /* Ensure we error instead of wrapping */
552 namedFmt
= VARIANT_GetNamedFormat(lpszFormat
);
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 */
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
));
567 header
->starts
[fmt_number
] = sizeof(FMT_HEADER
);
577 while (*pFormat
== ';')
580 if (++fmt_number
> 3)
581 return E_INVALIDARG
; /* too many formats */
586 TRACE("New header\n");
587 NEED_SPACE(sizeof(BYTE
) + sizeof(FMT_STRING_HEADER
));
588 *pOut
++ = FMT_GEN_END
;
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
);
599 else if (*pFormat
== '\\')
601 /* Escaped character */
604 NEED_SPACE(3 * sizeof(BYTE
));
606 *pOut
++ = FMT_GEN_COPY
;
607 *pOut
++ = pFormat
- lpszFormat
;
609 fmt_state
|= FMT_STATE_OPEN_COPY
;
613 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
616 else if (*pFormat
== '"')
619 * Note: Native encodes "" as a copy of length zero. That's just dumb, so
620 * here we avoid encoding anything in this case.
624 else if (pFormat
[1] == '"')
630 LPCWSTR start
= ++pFormat
;
631 while (*pFormat
&& *pFormat
!= '"')
633 NEED_SPACE(3 * sizeof(BYTE
));
634 *pOut
++ = FMT_GEN_COPY
;
635 *pOut
++ = start
- lpszFormat
;
636 *pOut
++ = pFormat
- start
;
639 TRACE("Quoted string pos %d, len %d\n", pOut
[-2], pOut
[-1]);
641 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
647 else if (*pFormat
== '0' && COULD_BE(FMT_TYPE_NUMBER
))
649 /* Number formats: Digit from number or '0' if no digits
650 * Other formats: Literal
651 * Types the format if found
653 header
->type
= FMT_TYPE_NUMBER
;
654 NEED_SPACE(2 * sizeof(BYTE
));
655 *pOut
++ = FMT_NUM_COPY_ZERO
;
657 while (*pFormat
== '0')
662 if (fmt_state
& FMT_STATE_WROTE_DECIMAL
)
663 num_header
->fractional
+= *pOut
;
665 num_header
->whole
+= *pOut
;
666 TRACE("%d 0's\n", *pOut
);
668 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
670 else if (*pFormat
== '#' && COULD_BE(FMT_TYPE_NUMBER
))
672 /* Number formats: Digit from number or blank if no digits
673 * Other formats: Literal
674 * Types the format if found
676 header
->type
= FMT_TYPE_NUMBER
;
677 NEED_SPACE(2 * sizeof(BYTE
));
678 *pOut
++ = FMT_NUM_COPY_SKIP
;
680 while (*pFormat
== '#')
685 if (fmt_state
& FMT_STATE_WROTE_DECIMAL
)
686 num_header
->fractional
+= *pOut
;
688 num_header
->whole
+= *pOut
;
689 TRACE("%d #'s\n", *pOut
);
691 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
693 else if (*pFormat
== '.' && COULD_BE(FMT_TYPE_NUMBER
) &&
694 !(fmt_state
& FMT_STATE_WROTE_DECIMAL
))
696 /* Number formats: Decimal separator when 1st seen, literal thereafter
697 * Other formats: Literal
698 * Types the format if found
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
;
706 TRACE("decimal sep\n");
708 else if ((*pFormat
== 'e' || *pFormat
== 'E') && (pFormat
[1] == '-' ||
709 pFormat
[1] == '+') && header
->type
== FMT_TYPE_NUMBER
)
711 /* Number formats: Exponent specifier
712 * Other formats: Literal
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
;
720 *pOut
= FMT_NUM_EXP_NEG_L
;
722 if (pFormat
[1] == '+')
723 *pOut
= FMT_NUM_EXP_POS_U
;
725 *pOut
= FMT_NUM_EXP_NEG_U
;
729 while (*pFormat
== '0')
737 /* FIXME: %% => Divide by 1000 */
738 else if (*pFormat
== ',' && header
->type
== FMT_TYPE_NUMBER
)
740 /* Number formats: Use the thousands separator
741 * Other formats: Literal
743 num_header
->flags
|= FMT_FLAG_THOUSANDS
;
745 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
746 TRACE("thousands sep\n");
752 else if (*pFormat
== '/' && COULD_BE(FMT_TYPE_DATE
))
754 /* Date formats: Date separator
755 * Other formats: Literal
756 * Types the format if found
758 header
->type
= FMT_TYPE_DATE
;
759 NEED_SPACE(sizeof(BYTE
));
760 *pOut
++ = FMT_DATE_DATE_SEP
;
762 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
765 else if (*pFormat
== ':' && COULD_BE(FMT_TYPE_DATE
))
767 /* Date formats: Time separator
768 * Other formats: Literal
769 * Types the format if found
771 header
->type
= FMT_TYPE_DATE
;
772 NEED_SPACE(sizeof(BYTE
));
773 *pOut
++ = FMT_DATE_TIME_SEP
;
775 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
778 else if ((*pFormat
== 'a' || *pFormat
== 'A') &&
779 !strncmpiW(pFormat
, szAMPM
, sizeof(szAMPM
)/sizeof(WCHAR
)))
781 /* Date formats: System AM/PM designation
782 * Other formats: Literal
783 * Types the format if found
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
;
791 *pOut
++ = FMT_DATE_AMPM_SYS1
;
793 *pLastHours
= *pLastHours
+ 2;
796 else if (*pFormat
== 'a' && pFormat
[1] == '/' &&
797 (pFormat
[2] == 'p' || pFormat
[2] == 'P'))
799 /* Date formats: lowercase a or p designation
800 * Other formats: Literal
801 * Types the format if found
803 header
->type
= FMT_TYPE_DATE
;
804 NEED_SPACE(sizeof(BYTE
));
806 *pOut
++ = FMT_DATE_A_LOWER
;
808 *pLastHours
= *pLastHours
+ 2;
811 else if (*pFormat
== 'A' && pFormat
[1] == '/' &&
812 (pFormat
[2] == 'p' || pFormat
[2] == 'P'))
814 /* Date formats: Uppercase a or p designation
815 * Other formats: Literal
816 * Types the format if found
818 header
->type
= FMT_TYPE_DATE
;
819 NEED_SPACE(sizeof(BYTE
));
821 *pOut
++ = FMT_DATE_A_UPPER
;
823 *pLastHours
= *pLastHours
+ 2;
826 else if (*pFormat
== 'a' &&
827 !strncmpW(pFormat
, szamSlashpm
, sizeof(szamSlashpm
)/sizeof(WCHAR
)))
829 /* Date formats: lowercase AM or PM designation
830 * Other formats: Literal
831 * Types the format if found
833 header
->type
= FMT_TYPE_DATE
;
834 NEED_SPACE(sizeof(BYTE
));
835 pFormat
+= sizeof(szamSlashpm
)/sizeof(WCHAR
);
836 *pOut
++ = FMT_DATE_AMPM_LOWER
;
838 *pLastHours
= *pLastHours
+ 2;
841 else if (*pFormat
== 'A' &&
842 !strncmpW(pFormat
, szAMSlashPM
, sizeof(szAMSlashPM
)/sizeof(WCHAR
)))
844 /* Date formats: Uppercase AM or PM designation
845 * Other formats: Literal
846 * Types the format if found
848 header
->type
= FMT_TYPE_DATE
;
849 NEED_SPACE(sizeof(BYTE
));
850 pFormat
+= sizeof(szAMSlashPM
)/sizeof(WCHAR
);
851 *pOut
++ = FMT_DATE_AMPM_UPPER
;
854 else if (*pFormat
== 'c' || *pFormat
== 'C')
856 /* Date formats: General date format
857 * Other formats: Literal
858 * Types the format if found
860 header
->type
= FMT_TYPE_DATE
;
861 NEED_SPACE(sizeof(BYTE
));
862 pFormat
+= sizeof(szAMSlashPM
)/sizeof(WCHAR
);
863 *pOut
++ = FMT_DATE_GENERAL
;
866 else if ((*pFormat
== 'd' || *pFormat
== 'D') && COULD_BE(FMT_TYPE_DATE
))
868 /* Date formats: Day specifier
869 * Other formats: Literal
870 * Types the format if found
873 header
->type
= FMT_TYPE_DATE
;
874 while ((*pFormat
== 'd' || *pFormat
== 'D') && count
< 6)
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.
885 fmt_state
&= ~FMT_STATE_SEEN_HOURS
;
886 TRACE("%d d's\n", count
+ 1);
888 else if ((*pFormat
== 'h' || *pFormat
== 'H') && COULD_BE(FMT_TYPE_DATE
))
890 /* Date formats: Hour specifier
891 * Other formats: Literal
892 * Types the format if found
894 header
->type
= FMT_TYPE_DATE
;
895 NEED_SPACE(sizeof(BYTE
));
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.
901 if (*pFormat
== 'h' || *pFormat
== 'H')
904 *pOut
++ = FMT_DATE_HOUR_0
;
909 *pOut
++ = FMT_DATE_HOUR
;
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.
916 fmt_state
|= FMT_STATE_SEEN_HOURS
;
918 else if ((*pFormat
== 'm' || *pFormat
== 'M') && COULD_BE(FMT_TYPE_DATE
))
920 /* Date formats: Month specifier (or Minute specifier, after hour specifier)
921 * Other formats: Literal
922 * Types the format if found
925 header
->type
= FMT_TYPE_DATE
;
926 while ((*pFormat
== 'm' || *pFormat
== 'M') && count
< 4)
931 NEED_SPACE(sizeof(BYTE
));
932 if (count
<= 1 && fmt_state
& FMT_STATE_SEEN_HOURS
&&
933 !(fmt_state
& FMT_STATE_WROTE_MINUTES
))
935 /* We have seen an hours specifier and not yet written a minutes
936 * specifier. Write this as minutes and thereafter as months.
938 *pOut
++ = count
== 1 ? FMT_DATE_MIN_0
: FMT_DATE_MIN
;
939 fmt_state
|= FMT_STATE_WROTE_MINUTES
; /* Hereafter write months */
942 *pOut
++ = FMT_DATE_MON
+ count
; /* Months */
943 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
944 TRACE("%d m's\n", count
+ 1);
946 else if ((*pFormat
== 'n' || *pFormat
== 'N') && COULD_BE(FMT_TYPE_DATE
))
948 /* Date formats: Minute specifier
949 * Other formats: Literal
950 * Types the format if found
952 header
->type
= FMT_TYPE_DATE
;
953 NEED_SPACE(sizeof(BYTE
));
955 if (*pFormat
== 'n' || *pFormat
== 'N')
958 *pOut
++ = FMT_DATE_MIN_0
;
963 *pOut
++ = FMT_DATE_MIN
;
966 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
968 else if ((*pFormat
== 'q' || *pFormat
== 'q') && COULD_BE(FMT_TYPE_DATE
))
970 /* Date formats: Quarter specifier
971 * Other formats: Literal
972 * Types the format if found
974 header
->type
= FMT_TYPE_DATE
;
975 NEED_SPACE(sizeof(BYTE
));
976 *pOut
++ = FMT_DATE_QUARTER
;
978 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
981 else if ((*pFormat
== 's' || *pFormat
== 'S') && COULD_BE(FMT_TYPE_DATE
))
983 /* Date formats: Second specifier
984 * Other formats: Literal
985 * Types the format if found
987 header
->type
= FMT_TYPE_DATE
;
988 NEED_SPACE(sizeof(BYTE
));
990 if (*pFormat
== 's' || *pFormat
== 'S')
993 *pOut
++ = FMT_DATE_SEC_0
;
998 *pOut
++ = FMT_DATE_SEC
;
1001 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
1003 else if ((*pFormat
== 't' || *pFormat
== 'T') &&
1004 !strncmpiW(pFormat
, szTTTTT
, sizeof(szTTTTT
)/sizeof(WCHAR
)))
1006 /* Date formats: System time specifier
1007 * Other formats: Literal
1008 * Types the format if found
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
;
1016 else if ((*pFormat
== 'w' || *pFormat
== 'W') && COULD_BE(FMT_TYPE_DATE
))
1018 /* Date formats: Week of the year/Day of the week
1019 * Other formats: Literal
1020 * Types the format if found
1022 header
->type
= FMT_TYPE_DATE
;
1024 if (*pFormat
== 'w' || *pFormat
== 'W')
1026 NEED_SPACE(3 * sizeof(BYTE
));
1028 *pOut
++ = FMT_DATE_WEEK_YEAR
;
1029 *pOut
++ = nFirstDay
;
1030 *pOut
++ = nFirstWeek
;
1035 NEED_SPACE(2 * sizeof(BYTE
));
1036 *pOut
++ = FMT_DATE_DAY_WEEK
;
1037 *pOut
++ = nFirstDay
;
1041 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
1043 else if ((*pFormat
== 'y' || *pFormat
== 'Y') && COULD_BE(FMT_TYPE_DATE
))
1045 /* Date formats: Day of year/Year specifier
1046 * Other formats: Literal
1047 * Types the format if found
1050 header
->type
= FMT_TYPE_DATE
;
1051 while ((*pFormat
== 'y' || *pFormat
== 'Y') && count
< 4)
1058 count
--; /* 'yyy' has no meaning, despite what MSDN says */
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);
1070 else if (*pFormat
== '@' && COULD_BE(FMT_TYPE_STRING
))
1072 /* String formats: Character from string or space if no char
1073 * Other formats: Literal
1074 * Types the format if found
1076 header
->type
= FMT_TYPE_STRING
;
1077 NEED_SPACE(2 * sizeof(BYTE
));
1078 *pOut
++ = FMT_STR_COPY_SPACE
;
1080 while (*pFormat
== '@')
1083 str_header
->copy_chars
++;
1086 TRACE("%d @'s\n", *pOut
);
1088 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
1090 else if (*pFormat
== '&' && COULD_BE(FMT_TYPE_STRING
))
1092 /* String formats: Character from string or skip if no char
1093 * Other formats: Literal
1094 * Types the format if found
1096 header
->type
= FMT_TYPE_STRING
;
1097 NEED_SPACE(2 * sizeof(BYTE
));
1098 *pOut
++ = FMT_STR_COPY_SKIP
;
1100 while (*pFormat
== '&')
1103 str_header
->copy_chars
++;
1106 TRACE("%d &'s\n", *pOut
);
1108 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
1110 else if ((*pFormat
== '<' || *pFormat
== '>') && COULD_BE(FMT_TYPE_STRING
))
1112 /* String formats: Use upper/lower case
1113 * Other formats: Literal
1114 * Types the format if found
1116 header
->type
= FMT_TYPE_STRING
;
1117 if (*pFormat
== '<')
1118 str_header
->flags
|= FMT_FLAG_LT
;
1120 str_header
->flags
|= FMT_FLAG_GT
;
1121 TRACE("to %s case\n", *pFormat
== '<' ? "lower" : "upper");
1123 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
1125 else if (*pFormat
== '!' && COULD_BE(FMT_TYPE_STRING
))
1127 /* String formats: Copy right to left
1128 * Other formats: Literal
1129 * Types the format if found
1131 header
->type
= FMT_TYPE_STRING
;
1132 str_header
->flags
|= FMT_FLAG_RTL
;
1134 fmt_state
&= ~FMT_STATE_OPEN_COPY
;
1135 TRACE("copy right-to-left\n");
1141 /* FIXME: [ seems to be ignored */
1144 if (*pFormat
== '%' && header
->type
== FMT_TYPE_NUMBER
)
1146 /* Number formats: Percentage indicator, also a literal
1147 * Other formats: Literal
1148 * Doesn't type the format
1150 num_header
->flags
|= FMT_FLAG_PERCENT
;
1153 if (fmt_state
& FMT_STATE_OPEN_COPY
)
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]);
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
;
1166 fmt_state
|= FMT_STATE_OPEN_COPY
;
1172 *pOut
++ = FMT_GEN_END
;
1174 header
->size
= pOut
- rgbTok
;
1176 *pcbActual
= header
->size
;
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 */
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
)
1190 BYTE rgbDig
[256], *prgbDig
;
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
;
1196 FMT_HEADER
*header
= (FMT_HEADER
*)rgbTok
;
1197 FMT_NUMBER_HEADER
*numHeader
;
1198 const BYTE
* pToken
= NULL
;
1199 HRESULT hRes
= S_OK
;
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
,
1205 V_VT(&vString
) = VT_EMPTY
;
1206 V_VT(&vBool
) = VT_BOOL
;
1208 if (V_TYPE(pVarIn
) == VT_EMPTY
|| V_TYPE(pVarIn
) == VT_NULL
)
1210 have_int
= have_frac
= 0;
1211 numHeader
= (FMT_NUMBER_HEADER
*)(rgbTok
+ FmtGetNull(header
));
1212 V_BOOL(&vBool
) = VARIANT_FALSE
;
1216 /* Get a number string from pVarIn, and parse it */
1217 hRes
= VariantChangeTypeEx(&vString
, pVarIn
, LCID_US
, VARIANT_NOUSEROVERRIDE
, VT_BSTR
);
1221 np
.cDig
= sizeof(rgbDig
);
1222 np
.dwInFlags
= NUMPRS_STD
;
1223 hRes
= VarParseNumFromStr(V_BSTR(&vString
), LCID_US
, 0, &np
, rgbDig
);
1229 exponent
= np
.nPwr10
;
1231 /* Figure out which format to use */
1232 if (np
.dwOutFlags
& NUMPRS_NEG
)
1234 numHeader
= (FMT_NUMBER_HEADER
*)(rgbTok
+ FmtGetNegative(header
));
1235 V_BOOL(&vBool
) = VARIANT_TRUE
;
1237 else if (have_int
== 1 && !exponent
&& rgbDig
[0] == 0)
1239 numHeader
= (FMT_NUMBER_HEADER
*)(rgbTok
+ FmtGetZero(header
));
1240 V_BOOL(&vBool
) = VARIANT_FALSE
;
1244 numHeader
= (FMT_NUMBER_HEADER
*)(rgbTok
+ FmtGetPositive(header
));
1245 V_BOOL(&vBool
) = VARIANT_TRUE
;
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
);
1252 need_int
= numHeader
->whole
;
1253 need_frac
= numHeader
->fractional
;
1255 if (numHeader
->flags
& FMT_FLAG_PERCENT
&&
1256 !(have_int
== 1 && !exponent
&& rgbDig
[0] == 0))
1259 if (numHeader
->flags
& FMT_FLAG_EXPONENT
)
1261 /* Exponent format: length of the integral number part is fixed and
1262 specified by the format. */
1263 pad
= need_int
- have_int
;
1268 have_int
= need_int
;
1276 /* Convert the exponent */
1277 pad
= max(exponent
, -have_int
);
1287 /* Rounding the number */
1288 if (have_frac
> need_frac
)
1290 prgbDig
= &rgbDig
[have_int
+ need_frac
];
1291 have_frac
= need_frac
;
1294 while (prgbDig
-- > rgbDig
&& *prgbDig
== 9)
1296 if (prgbDig
< rgbDig
)
1298 /* We reached the first digit and that was also a 9 */
1300 if (numHeader
->flags
& FMT_FLAG_EXPONENT
)
1304 rgbDig
[have_int
+ need_frac
] = 0;
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
);
1316 pToken
= (const BYTE
*)numHeader
+ sizeof(FMT_NUMBER_HEADER
);
1319 while (SUCCEEDED(hRes
) && *pToken
!= FMT_GEN_END
)
1321 WCHAR defaultChar
= '?';
1322 DWORD boolFlag
, localeValue
= 0;
1324 if (pToken
- rgbTok
> header
->size
)
1326 ERR("Ran off the end of the format!\n");
1327 hRes
= E_INVALIDARG
;
1328 goto VARIANT_FormatNumber_Exit
;
1334 TRACE("copy %s\n", debugstr_wn(lpszFormat
+ pToken
[1], pToken
[2]));
1335 memcpy(pBuff
, lpszFormat
+ pToken
[1], pToken
[2] * sizeof(WCHAR
));
1340 case FMT_GEN_INLINE
:
1342 TRACE("copy %s\n", debugstr_a((LPCSTR
)pToken
));
1344 *pBuff
++ = *pToken
++;
1347 case FMT_NUM_YES_NO
:
1348 boolFlag
= VAR_BOOLYESNO
;
1349 goto VARIANT_FormatNumber_Bool
;
1351 case FMT_NUM_ON_OFF
:
1352 boolFlag
= VAR_BOOLONOFF
;
1353 goto VARIANT_FormatNumber_Bool
;
1355 case FMT_NUM_TRUE_FALSE
:
1356 boolFlag
= VAR_LOCALBOOL
;
1358 VARIANT_FormatNumber_Bool
:
1360 BSTR boolStr
= NULL
;
1362 if (pToken
[1] != FMT_GEN_END
)
1364 ERR("Boolean token not at end of format!\n");
1365 hRes
= E_INVALIDARG
;
1366 goto VARIANT_FormatNumber_Exit
;
1368 hRes
= VarBstrFromBool(V_BOOL(&vBool
), lcid
, boolFlag
, &boolStr
);
1369 if (SUCCEEDED(hRes
))
1371 strcpyW(pBuff
, boolStr
);
1372 SysFreeString(boolStr
);
1379 case FMT_NUM_DECIMAL
:
1380 TRACE("write decimal separator\n");
1381 localeValue
= LOCALE_SDECIMAL
;
1383 dwState
|= NUM_WROTE_DEC
;
1386 case FMT_NUM_CURRENCY
:
1387 TRACE("write currency symbol\n");
1388 localeValue
= LOCALE_SCURRENCY
;
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
)
1403 sprintfW(pBuff
, szPercentZeroStar_d
, pToken
[1], -exponent
);
1407 if (*pToken
== FMT_NUM_EXP_POS_L
|| *pToken
== FMT_NUM_EXP_POS_U
)
1409 sprintfW(pBuff
, szPercentZeroStar_d
, pToken
[1], exponent
);
1416 case FMT_NUM_COPY_ZERO
:
1417 dwState
|= NUM_WRITE_ON
;
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");
1425 if (dwState
& NUM_WROTE_DEC
)
1429 if (!(numHeader
->flags
& FMT_FLAG_EXPONENT
) && exponent
< 0)
1431 /* Pad with 0 before writing the fractional digits */
1432 pad
= max(exponent
, -pToken
[1]);
1434 count
= min(have_frac
, pToken
[1] + pad
);
1435 for (i
= 0; i
> pad
; i
--)
1439 count
= min(have_frac
, pToken
[1]);
1441 pad
+= pToken
[1] - count
;
1444 *pBuff
++ = '0' + *prgbDig
++;
1445 if (*pToken
== FMT_NUM_COPY_ZERO
)
1447 for (; pad
> 0; pad
--)
1448 *pBuff
++ = '0'; /* Write zeros for missing trailing digits */
1453 int count
, count_max
;
1455 need_int
-= pToken
[1];
1456 count_max
= have_int
+ pad
- need_int
;
1459 if (dwState
& NUM_WRITE_ON
)
1461 count
= pToken
[1] - count_max
;
1462 TRACE("write %d leading zeros\n", count
);
1466 if (*pToken
== FMT_NUM_COPY_ZERO
|| have_int
> 1 ||
1467 (have_int
> 0 && *prgbDig
> 0))
1469 dwState
|= NUM_WRITE_ON
;
1470 count
= min(count_max
, have_int
);
1473 TRACE("write %d whole number digits\n", count
);
1475 *pBuff
++ = '0' + *prgbDig
++;
1477 count
= min(count_max
, pad
);
1480 TRACE("write %d whole trailing 0's\n", count
);
1488 ERR("Unknown token 0x%02x!\n", *pToken
);
1489 hRes
= E_INVALIDARG
;
1490 goto VARIANT_FormatNumber_Exit
;
1494 if (GetLocaleInfoW(lcid
, localeValue
, pBuff
,
1495 sizeof(buff
)/sizeof(WCHAR
)-(pBuff
-buff
)))
1497 TRACE("added %s\n", debugstr_w(pBuff
));
1503 TRACE("added %d '%c'\n", defaultChar
, defaultChar
);
1504 *pBuff
++ = defaultChar
;
1510 VARIANT_FormatNumber_Exit
:
1511 VariantClear(&vString
);
1513 TRACE("buff is %s\n", debugstr_w(buff
));
1514 if (SUCCEEDED(hRes
))
1516 *pbstrOut
= SysAllocString(buff
);
1518 hRes
= E_OUTOFMEMORY
;
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
)
1528 WCHAR buff
[256], *pBuff
= buff
;
1531 FMT_HEADER
*header
= (FMT_HEADER
*)rgbTok
;
1532 FMT_DATE_HEADER
*dateHeader
;
1533 const BYTE
* pToken
= NULL
;
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
,
1540 V_VT(&vDate
) = VT_EMPTY
;
1542 if (V_TYPE(pVarIn
) == VT_EMPTY
|| V_TYPE(pVarIn
) == VT_NULL
)
1544 dateHeader
= (FMT_DATE_HEADER
*)(rgbTok
+ FmtGetNegative(header
));
1549 USHORT usFlags
= dwFlags
& VARIANT_CALENDAR_HIJRI
? VAR_CALENDAR_HIJRI
: 0;
1551 hRes
= VariantChangeTypeEx(&vDate
, pVarIn
, LCID_US
, usFlags
, VT_DATE
);
1554 dateHeader
= (FMT_DATE_HEADER
*)(rgbTok
+ FmtGetPositive(header
));
1557 hRes
= VarUdateFromDate(V_DATE(&vDate
), 0 /* FIXME: flags? */, &udate
);
1560 pToken
= (const BYTE
*)dateHeader
+ sizeof(FMT_DATE_HEADER
);
1562 while (*pToken
!= FMT_GEN_END
)
1564 DWORD dwVal
= 0, localeValue
= 0, dwFmt
= 0;
1565 LPCWSTR szPrintFmt
= NULL
;
1566 WCHAR defaultChar
= '?';
1568 if (pToken
- rgbTok
> header
->size
)
1570 ERR("Ran off the end of the format!\n");
1571 hRes
= E_INVALIDARG
;
1572 goto VARIANT_FormatDate_Exit
;
1578 TRACE("copy %s\n", debugstr_wn(lpszFormat
+ pToken
[1], pToken
[2]));
1579 memcpy(pBuff
, lpszFormat
+ pToken
[1], pToken
[2] * sizeof(WCHAR
));
1584 case FMT_DATE_TIME_SEP
:
1585 TRACE("time separator\n");
1586 localeValue
= LOCALE_STIME
;
1590 case FMT_DATE_DATE_SEP
:
1591 TRACE("date separator\n");
1592 localeValue
= LOCALE_SDATE
;
1596 case FMT_DATE_GENERAL
:
1600 hRes
= VarBstrFromDate(V_DATE(&vDate
), lcid
, 0, &date
);
1602 goto VARIANT_FormatDate_Exit
;
1605 *pBuff
++ = *pDate
++;
1606 SysFreeString(date
);
1610 case FMT_DATE_QUARTER
:
1611 if (udate
.st
.wMonth
<= 3)
1613 else if (udate
.st
.wMonth
<= 6)
1615 else if (udate
.st
.wMonth
<= 9)
1621 case FMT_DATE_TIME_SYS
:
1623 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1626 hRes
= VarBstrFromDate(V_DATE(&vDate
), lcid
, VAR_TIMEVALUEONLY
, &date
);
1628 goto VARIANT_FormatDate_Exit
;
1631 *pBuff
++ = *pDate
++;
1632 SysFreeString(date
);
1637 szPrintFmt
= szPercent_d
;
1638 dwVal
= udate
.st
.wDay
;
1641 case FMT_DATE_DAY_0
:
1642 szPrintFmt
= szPercentZeroTwo_d
;
1643 dwVal
= udate
.st
.wDay
;
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;
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;
1660 case FMT_DATE_SHORT
:
1661 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1662 dwFmt
= LOCALE_SSHORTDATE
;
1666 /* FIXME: VARIANT_CALENDAR HIJRI should cause Hijri output */
1667 dwFmt
= LOCALE_SLONGDATE
;
1670 case FMT_DATE_MEDIUM
:
1671 FIXME("Medium date treated as long date\n");
1672 dwFmt
= LOCALE_SLONGDATE
;
1675 case FMT_DATE_DAY_WEEK
:
1676 szPrintFmt
= szPercent_d
;
1678 dwVal
= udate
.st
.wDayOfWeek
+ 2 - pToken
[1];
1681 GetLocaleInfoW(lcid
,LOCALE_RETURN_NUMBER
|LOCALE_IFIRSTDAYOFWEEK
,
1682 (LPWSTR
)&dwVal
, sizeof(dwVal
)/sizeof(WCHAR
));
1683 dwVal
= udate
.st
.wDayOfWeek
+ 1 - dwVal
;
1688 case FMT_DATE_WEEK_YEAR
:
1689 szPrintFmt
= szPercent_d
;
1690 dwVal
= udate
.wDayOfYear
/ 7 + 1;
1692 FIXME("Ignoring nFirstDay of %d, nFirstWeek of %d\n", pToken
[0], pToken
[1]);
1696 szPrintFmt
= szPercent_d
;
1697 dwVal
= udate
.st
.wMonth
;
1700 case FMT_DATE_MON_0
:
1701 szPrintFmt
= szPercentZeroTwo_d
;
1702 dwVal
= udate
.st
.wMonth
;
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;
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;
1719 case FMT_DATE_YEAR_DOY
:
1720 szPrintFmt
= szPercent_d
;
1721 dwVal
= udate
.wDayOfYear
;
1724 case FMT_DATE_YEAR_0
:
1725 szPrintFmt
= szPercentZeroTwo_d
;
1726 dwVal
= udate
.st
.wYear
% 100;
1729 case FMT_DATE_YEAR_LONG
:
1730 szPrintFmt
= szPercent_d
;
1731 dwVal
= udate
.st
.wYear
;
1735 szPrintFmt
= szPercent_d
;
1736 dwVal
= udate
.st
.wMinute
;
1739 case FMT_DATE_MIN_0
:
1740 szPrintFmt
= szPercentZeroTwo_d
;
1741 dwVal
= udate
.st
.wMinute
;
1745 szPrintFmt
= szPercent_d
;
1746 dwVal
= udate
.st
.wSecond
;
1749 case FMT_DATE_SEC_0
:
1750 szPrintFmt
= szPercentZeroTwo_d
;
1751 dwVal
= udate
.st
.wSecond
;
1755 szPrintFmt
= szPercent_d
;
1756 dwVal
= udate
.st
.wHour
;
1759 case FMT_DATE_HOUR_0
:
1760 szPrintFmt
= szPercentZeroTwo_d
;
1761 dwVal
= udate
.st
.wHour
;
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;
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;
1774 case FMT_DATE_AMPM_SYS1
:
1775 case FMT_DATE_AMPM_SYS2
:
1776 localeValue
= udate
.st
.wHour
< 12 ? LOCALE_S1159
: LOCALE_S2359
;
1780 case FMT_DATE_AMPM_UPPER
:
1781 *pBuff
++ = udate
.st
.wHour
< 12 ? 'A' : 'P';
1785 case FMT_DATE_A_UPPER
:
1786 *pBuff
++ = udate
.st
.wHour
< 12 ? 'A' : 'P';
1789 case FMT_DATE_AMPM_LOWER
:
1790 *pBuff
++ = udate
.st
.wHour
< 12 ? 'a' : 'p';
1794 case FMT_DATE_A_LOWER
:
1795 *pBuff
++ = udate
.st
.wHour
< 12 ? 'a' : 'p';
1799 ERR("Unknown token 0x%02x!\n", *pToken
);
1800 hRes
= E_INVALIDARG
;
1801 goto VARIANT_FormatDate_Exit
;
1806 if (GetLocaleInfoW(lcid
, localeValue
, pBuff
,
1807 sizeof(buff
)/sizeof(WCHAR
)-(pBuff
-buff
)))
1809 TRACE("added %s\n", debugstr_w(pBuff
));
1815 TRACE("added %d %c\n", defaultChar
, defaultChar
);
1816 *pBuff
++ = defaultChar
;
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
)))
1827 hRes
= E_INVALIDARG
;
1828 goto VARIANT_FormatDate_Exit
;
1833 else if (szPrintFmt
)
1835 sprintfW(pBuff
, szPrintFmt
, dwVal
);
1842 VARIANT_FormatDate_Exit
:
1844 TRACE("buff is %s\n", debugstr_w(buff
));
1845 if (SUCCEEDED(hRes
))
1847 *pbstrOut
= SysAllocString(buff
);
1849 hRes
= E_OUTOFMEMORY
;
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
)
1859 static WCHAR szEmpty
[] = { '\0' };
1860 WCHAR buff
[256], *pBuff
= buff
;
1862 FMT_HEADER
*header
= (FMT_HEADER
*)rgbTok
;
1863 FMT_STRING_HEADER
*strHeader
;
1864 const BYTE
* pToken
= NULL
;
1867 BOOL bUpper
= FALSE
;
1868 HRESULT hRes
= S_OK
;
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
,
1874 V_VT(&vStr
) = VT_EMPTY
;
1876 if (V_TYPE(pVarIn
) == VT_EMPTY
|| V_TYPE(pVarIn
) == VT_NULL
)
1878 strHeader
= (FMT_STRING_HEADER
*)(rgbTok
+ FmtGetNegative(header
));
1879 V_BSTR(&vStr
) = szEmpty
;
1883 hRes
= VariantChangeTypeEx(&vStr
, pVarIn
, LCID_US
, VARIANT_NOUSEROVERRIDE
, VT_BSTR
);
1887 if (V_BSTR(pVarIn
)[0] == '\0')
1888 strHeader
= (FMT_STRING_HEADER
*)(rgbTok
+ FmtGetNegative(header
));
1890 strHeader
= (FMT_STRING_HEADER
*)(rgbTok
+ FmtGetPositive(header
));
1892 pSrc
= V_BSTR(&vStr
);
1893 if ((strHeader
->flags
& (FMT_FLAG_LT
|FMT_FLAG_GT
)) == FMT_FLAG_GT
)
1895 blanks_first
= strHeader
->copy_chars
- strlenW(pSrc
);
1896 pToken
= (const BYTE
*)strHeader
+ sizeof(FMT_DATE_HEADER
);
1898 while (*pToken
!= FMT_GEN_END
)
1902 if (pToken
- rgbTok
> header
->size
)
1904 ERR("Ran off the end of the format!\n");
1905 hRes
= E_INVALIDARG
;
1906 goto VARIANT_FormatString_Exit
;
1912 TRACE("copy %s\n", debugstr_wn(lpszFormat
+ pToken
[1], pToken
[2]));
1913 memcpy(pBuff
, lpszFormat
+ pToken
[1], pToken
[2] * sizeof(WCHAR
));
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)
1923 TRACE("insert %d initial spaces\n", blanks_first
);
1924 while (dwCount
> 0 && blanks_first
> 0)
1931 TRACE("copy %d chars%s\n", dwCount
,
1932 *pToken
== FMT_STR_COPY_SPACE
? " with space" :"");
1933 while (dwCount
> 0 && *pSrc
)
1936 *pBuff
++ = toupperW(*pSrc
);
1938 *pBuff
++ = tolowerW(*pSrc
);
1942 if (*pToken
== FMT_STR_COPY_SPACE
&& dwCount
> 0)
1944 TRACE("insert %d spaces\n", dwCount
);
1945 while (dwCount
-- > 0)
1952 ERR("Unknown token 0x%02x!\n", *pToken
);
1953 hRes
= E_INVALIDARG
;
1954 goto VARIANT_FormatString_Exit
;
1959 VARIANT_FormatString_Exit
:
1960 /* Copy out any remaining chars */
1964 *pBuff
++ = toupperW(*pSrc
);
1966 *pBuff
++ = tolowerW(*pSrc
);
1969 VariantClear(&vStr
);
1971 TRACE("buff is %s\n", debugstr_w(buff
));
1972 if (SUCCEEDED(hRes
))
1974 *pbstrOut
= SysAllocString(buff
);
1976 hRes
= E_OUTOFMEMORY
;
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)
1986 /**********************************************************************
1987 * VarFormatFromTokens [OLEAUT32.139]
1989 HRESULT WINAPI
VarFormatFromTokens(LPVARIANT pVarIn
, LPOLESTR lpszFormat
,
1990 LPBYTE rgbTok
, ULONG dwFlags
,
1991 BSTR
*pbstrOut
, LCID lcid
)
1993 FMT_SHORT_HEADER
*header
= (FMT_SHORT_HEADER
*)rgbTok
;
1997 TRACE("(%p,%s,%p,%x,%p,0x%08x)\n", pVarIn
, debugstr_w(lpszFormat
),
1998 rgbTok
, dwFlags
, pbstrOut
, lcid
);
2001 return E_INVALIDARG
;
2005 if (!pVarIn
|| !rgbTok
)
2006 return E_INVALIDARG
;
2008 if (V_VT(pVarIn
) == VT_NULL
)
2011 if (*rgbTok
== FMT_TO_STRING
|| header
->type
== FMT_TYPE_GENERAL
)
2013 /* According to MSDN, general format acts somewhat like the 'Str'
2014 * function in Visual Basic.
2016 VarFormatFromTokens_AsStr
:
2017 V_VT(&vTmp
) = VT_EMPTY
;
2018 hres
= VariantChangeTypeEx(&vTmp
, pVarIn
, lcid
, dwFlags
, VT_BSTR
);
2019 *pbstrOut
= V_BSTR(&vTmp
);
2023 if (header
->type
== FMT_TYPE_NUMBER
||
2024 (header
->type
== FMT_TYPE_UNKNOWN
&& ((1 << V_TYPE(pVarIn
)) & NUMBER_VTBITS
)))
2026 hres
= VARIANT_FormatNumber(pVarIn
, lpszFormat
, rgbTok
, dwFlags
, pbstrOut
, lcid
);
2028 else if (header
->type
== FMT_TYPE_DATE
||
2029 (header
->type
== FMT_TYPE_UNKNOWN
&& V_TYPE(pVarIn
) == VT_DATE
))
2031 hres
= VARIANT_FormatDate(pVarIn
, lpszFormat
, rgbTok
, dwFlags
, pbstrOut
, lcid
);
2033 else if (header
->type
== FMT_TYPE_STRING
|| V_TYPE(pVarIn
) == VT_BSTR
)
2035 hres
= VARIANT_FormatString(pVarIn
, lpszFormat
, rgbTok
, dwFlags
, pbstrOut
, lcid
);
2039 ERR("unrecognised format type 0x%02x\n", header
->type
);
2040 return E_INVALIDARG
;
2042 /* If the coercion failed, still try to create output, unless the
2043 * VAR_FORMAT_NOSUBSTITUTE flag is set.
2045 if ((hres
== DISP_E_OVERFLOW
|| hres
== DISP_E_TYPEMISMATCH
) &&
2046 !(dwFlags
& VAR_FORMAT_NOSUBSTITUTE
))
2047 goto VarFormatFromTokens_AsStr
;
2053 /**********************************************************************
2054 * VarFormat [OLEAUT32.87]
2056 * Format a variant from a format string.
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.
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.
2073 * - See Variant-Formats for details concerning creating format strings.
2074 * - This function uses LOCALE_USER_DEFAULT when calling VarTokenizeFormatString()
2075 * and VarFormatFromTokens().
2077 HRESULT WINAPI
VarFormat(LPVARIANT pVarIn
, LPOLESTR lpszFormat
,
2078 int nFirstDay
, int nFirstWeek
, ULONG dwFlags
,
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
,
2089 return E_INVALIDARG
;
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
));
2101 /**********************************************************************
2102 * VarFormatDateTime [OLEAUT32.97]
2104 * Format a variant value as a date and/or time.
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.
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.
2119 * This function uses LOCALE_USER_DEFAULT when determining the date format
2120 * characters to use.
2121 * Possible values for the nFormat parameter are:
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
2130 HRESULT WINAPI
VarFormatDateTime(LPVARIANT pVarIn
, INT nFormat
, ULONG dwFlags
, BSTR
*pbstrOut
)
2132 static WCHAR szEmpty
[] = { '\0' };
2133 const BYTE
* lpFmt
= NULL
;
2135 TRACE("(%p->(%s%s),%d,0x%08x,%p)\n", pVarIn
, debugstr_VT(pVarIn
),
2136 debugstr_VF(pVarIn
), nFormat
, dwFlags
, pbstrOut
);
2138 if (!pVarIn
|| !pbstrOut
|| nFormat
< 0 || nFormat
> 4)
2139 return E_INVALIDARG
;
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;
2149 return VarFormatFromTokens(pVarIn
, szEmpty
, (BYTE
*)lpFmt
, dwFlags
,
2150 pbstrOut
, LOCALE_USER_DEFAULT
);
2153 #define GETLOCALENUMBER(type,field) GetLocaleInfoW(LOCALE_USER_DEFAULT, \
2154 type|LOCALE_RETURN_NUMBER, \
2155 (LPWSTR)&numfmt.field, \
2156 sizeof(numfmt.field)/sizeof(WCHAR))
2158 /**********************************************************************
2159 * VarFormatNumber [OLEAUT32.107]
2161 * Format a variant value as a number.
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.
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.
2179 * This function uses LOCALE_USER_DEFAULT when determining the number format
2180 * characters to use.
2182 HRESULT WINAPI
VarFormatNumber(LPVARIANT pVarIn
, INT nDigits
, INT nLeading
, INT nParens
,
2183 INT nGrouping
, ULONG dwFlags
, BSTR
*pbstrOut
)
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
);
2191 if (!pVarIn
|| !pbstrOut
|| nDigits
> 9)
2192 return E_INVALIDARG
;
2196 V_VT(&vStr
) = VT_EMPTY
;
2197 hRet
= VariantCopyInd(&vStr
, pVarIn
);
2199 if (SUCCEEDED(hRet
))
2200 hRet
= VariantChangeTypeEx(&vStr
, &vStr
, LCID_US
, 0, VT_BSTR
);
2202 if (SUCCEEDED(hRet
))
2204 WCHAR buff
[256], decimal
[8], thousands
[8];
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.
2212 GETLOCALENUMBER(LOCALE_IDIGITS
, NumDigits
);
2214 numfmt
.NumDigits
= nDigits
;
2217 GETLOCALENUMBER(LOCALE_ILZERO
, LeadingZero
);
2218 else if (nLeading
== -1)
2219 numfmt
.LeadingZero
= 1;
2221 numfmt
.LeadingZero
= 0;
2223 if (nGrouping
== -2)
2227 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_SDECIMAL
, grouping
,
2228 sizeof(grouping
)/sizeof(WCHAR
));
2229 numfmt
.Grouping
= grouping
[2] == '2' ? 32 : grouping
[0] - '0';
2231 else if (nGrouping
== -1)
2232 numfmt
.Grouping
= 3; /* 3 = "n,nnn.nn" */
2234 numfmt
.Grouping
= 0; /* 0 = No grouping */
2237 GETLOCALENUMBER(LOCALE_INEGNUMBER
, NegativeOrder
);
2238 else if (nParens
== -1)
2239 numfmt
.NegativeOrder
= 0; /* 0 = "(xxx)" */
2241 numfmt
.NegativeOrder
= 1; /* 1 = "-xxx" */
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
));
2250 if (GetNumberFormatW(LOCALE_USER_DEFAULT
, 0, V_BSTR(&vStr
), &numfmt
,
2251 buff
, sizeof(buff
)/sizeof(WCHAR
)))
2253 *pbstrOut
= SysAllocString(buff
);
2255 hRet
= E_OUTOFMEMORY
;
2258 hRet
= DISP_E_TYPEMISMATCH
;
2260 SysFreeString(V_BSTR(&vStr
));
2265 /**********************************************************************
2266 * VarFormatPercent [OLEAUT32.117]
2268 * Format a variant value as a percentage.
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.
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.
2287 * This function uses LOCALE_USER_DEFAULT when determining the number format
2288 * characters to use.
2290 HRESULT WINAPI
VarFormatPercent(LPVARIANT pVarIn
, INT nDigits
, INT nLeading
, INT nParens
,
2291 INT nGrouping
, ULONG dwFlags
, BSTR
*pbstrOut
)
2293 static const WCHAR szPercent
[] = { '%','\0' };
2294 static const WCHAR szPercentBracket
[] = { '%',')','\0' };
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
,
2303 if (!pVarIn
|| !pbstrOut
|| nDigits
> 9)
2304 return E_INVALIDARG
;
2308 V_VT(&vDbl
) = VT_EMPTY
;
2309 hRet
= VariantCopyInd(&vDbl
, pVarIn
);
2311 if (SUCCEEDED(hRet
))
2313 hRet
= VariantChangeTypeEx(&vDbl
, &vDbl
, LOCALE_USER_DEFAULT
, 0, VT_R8
);
2315 if (SUCCEEDED(hRet
))
2317 if (V_R8(&vDbl
) > (R8_MAX
/ 100.0))
2318 return DISP_E_OVERFLOW
;
2320 V_R8(&vDbl
) *= 100.0;
2321 hRet
= VarFormatNumber(&vDbl
, nDigits
, nLeading
, nParens
,
2322 nGrouping
, dwFlags
, pbstrOut
);
2324 if (SUCCEEDED(hRet
))
2326 DWORD dwLen
= strlenW(*pbstrOut
);
2327 BOOL bBracket
= (*pbstrOut
)[dwLen
] == ')' ? TRUE
: FALSE
;
2330 memcpy(buff
, *pbstrOut
, dwLen
* sizeof(WCHAR
));
2331 strcpyW(buff
+ dwLen
, bBracket
? szPercentBracket
: szPercent
);
2332 SysFreeString(*pbstrOut
);
2333 *pbstrOut
= SysAllocString(buff
);
2335 hRet
= E_OUTOFMEMORY
;
2342 /**********************************************************************
2343 * VarFormatCurrency [OLEAUT32.127]
2345 * Format a variant value as a currency.
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.
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.
2363 * This function uses LOCALE_USER_DEFAULT when determining the currency format
2364 * characters to use.
2366 HRESULT WINAPI
VarFormatCurrency(LPVARIANT pVarIn
, INT nDigits
, INT nLeading
,
2367 INT nParens
, INT nGrouping
, ULONG dwFlags
,
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
);
2376 if (!pVarIn
|| !pbstrOut
|| nDigits
> 9)
2377 return E_INVALIDARG
;
2381 V_VT(&vStr
) = VT_EMPTY
;
2382 hRet
= VariantCopyInd(&vStr
, pVarIn
);
2384 if (SUCCEEDED(hRet
))
2385 hRet
= VariantChangeTypeEx(&vStr
, &vStr
, LOCALE_USER_DEFAULT
, 0, VT_BSTR
);
2387 if (SUCCEEDED(hRet
))
2389 WCHAR buff
[256], decimal
[8], thousands
[8], currency
[8];
2390 CURRENCYFMTW numfmt
;
2393 GETLOCALENUMBER(LOCALE_IDIGITS
, NumDigits
);
2395 numfmt
.NumDigits
= nDigits
;
2398 GETLOCALENUMBER(LOCALE_ILZERO
, LeadingZero
);
2399 else if (nLeading
== -1)
2400 numfmt
.LeadingZero
= 1;
2402 numfmt
.LeadingZero
= 0;
2404 if (nGrouping
== -2)
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';
2412 else if (nGrouping
== -1)
2413 numfmt
.Grouping
= 3; /* 3 = "n,nnn.nn" */
2415 numfmt
.Grouping
= 0; /* 0 = No grouping */
2418 GETLOCALENUMBER(LOCALE_INEGCURR
, NegativeOrder
);
2419 else if (nParens
== -1)
2420 numfmt
.NegativeOrder
= 0; /* 0 = "(xxx)" */
2422 numfmt
.NegativeOrder
= 1; /* 1 = "-xxx" */
2424 GETLOCALENUMBER(LOCALE_ICURRENCY
, PositiveOrder
);
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
));
2436 /* use NLS as per VarFormatNumber() */
2437 if (GetCurrencyFormatW(LOCALE_USER_DEFAULT
, 0, V_BSTR(&vStr
), &numfmt
,
2438 buff
, sizeof(buff
)/sizeof(WCHAR
)))
2440 *pbstrOut
= SysAllocString(buff
);
2442 hRet
= E_OUTOFMEMORY
;
2445 hRet
= DISP_E_TYPEMISMATCH
;
2447 SysFreeString(V_BSTR(&vStr
));
2452 /**********************************************************************
2453 * VarMonthName [OLEAUT32.129]
2455 * Print the specified month as localized name.
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
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.
2468 HRESULT WINAPI
VarMonthName(INT iMonth
, INT fAbbrev
, ULONG dwFlags
, BSTR
*pbstrOut
)
2473 if ((iMonth
< 1) || (iMonth
> 12))
2474 return E_INVALIDARG
;
2477 FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags
);
2480 localeValue
= LOCALE_SABBREVMONTHNAME1
+ iMonth
- 1;
2482 localeValue
= LOCALE_SMONTHNAME1
+ iMonth
- 1;
2484 size
= GetLocaleInfoW(LOCALE_USER_DEFAULT
,localeValue
, NULL
, 0);
2486 ERR("GetLocaleInfo 0x%x failed.\n", localeValue
);
2487 return HRESULT_FROM_WIN32(GetLastError());
2489 *pbstrOut
= SysAllocStringLen(NULL
,size
- 1);
2491 return E_OUTOFMEMORY
;
2492 size
= GetLocaleInfoW(LOCALE_USER_DEFAULT
,localeValue
, *pbstrOut
, size
);
2494 ERR("GetLocaleInfo of 0x%x failed in 2nd stage?!\n", localeValue
);
2495 SysFreeString(*pbstrOut
);
2496 return HRESULT_FROM_WIN32(GetLastError());
2501 /**********************************************************************
2502 * VarWeekdayName [OLEAUT32.129]
2504 * Print the specified weekday as localized name.
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.
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.
2519 HRESULT WINAPI
VarWeekdayName(INT iWeekday
, INT fAbbrev
, INT iFirstDay
,
2520 ULONG dwFlags
, BSTR
*pbstrOut
)
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
;
2531 return E_INVALIDARG
;
2534 FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags
);
2536 /* If we have to use the default firstDay, find which one it is */
2537 if (iFirstDay
== 0) {
2539 localeValue
= LOCALE_RETURN_NUMBER
| LOCALE_IFIRSTDAYOFWEEK
;
2540 size
= GetLocaleInfoW(LOCALE_USER_DEFAULT
, localeValue
,
2541 (LPWSTR
)&firstDay
, sizeof(firstDay
) / sizeof(WCHAR
));
2543 ERR("GetLocaleInfo 0x%x failed.\n", localeValue
);
2544 return HRESULT_FROM_WIN32(GetLastError());
2546 iFirstDay
= firstDay
+ 2;
2549 /* Determine what we need to return */
2550 localeValue
= fAbbrev
? LOCALE_SABBREVDAYNAME1
: LOCALE_SDAYNAME1
;
2551 localeValue
+= (7 + iWeekday
- 1 + iFirstDay
- 2) % 7;
2553 /* Determine the size of the data, allocate memory and retrieve the data */
2554 size
= GetLocaleInfoW(LOCALE_USER_DEFAULT
, localeValue
, NULL
, 0);
2556 ERR("GetLocaleInfo 0x%x failed.\n", localeValue
);
2557 return HRESULT_FROM_WIN32(GetLastError());
2559 *pbstrOut
= SysAllocStringLen(NULL
, size
- 1);
2561 return E_OUTOFMEMORY
;
2562 size
= GetLocaleInfoW(LOCALE_USER_DEFAULT
, localeValue
, *pbstrOut
, size
);
2564 ERR("GetLocaleInfo 0x%x failed in 2nd stage?!\n", localeValue
);
2565 SysFreeString(*pbstrOut
);
2566 return HRESULT_FROM_WIN32(GetLastError());