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