git.oblomov.eu Git - wine/blob - dlls/oleaut32/varformat.c

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