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