wine/dlls/oleaut32/varformat.c

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Wine Cross Reference
wine/dlls/oleaut32/varformat.c

Version: ~ [ wine-1.1.33 ] ~ [ wine-1.1.32 ] ~ [ wine-1.1.31 ] ~ [ wine-1.1.30 ] ~ [ wine-1.1.29 ] ~ [ wine-1.1.28 ] ~ [ wine-1.1.27 ] ~ [ wine-1.1.26 ] ~ [ wine-1.1.25 ] ~ [ wine-1.1.24 ] ~ [ wine-1.1.23 ] ~ [ wine-1.1.22 ] ~ [ wine-1.1.21 ] ~ [ wine-1.1.20 ] ~ [ wine-1.1.19 ] ~ [ wine-1.1.18 ] ~ [ wine-1.1.17 ] ~ [ wine-1.1.16 ] ~ [ wine-1.1.15 ] ~ [ wine-1.1.14 ] ~ [ wine-1.1.13 ] ~ [ wine-1.1.12 ] ~ [ wine-1.1.11 ] ~ [ wine-1.1.10 ] ~ [ wine-1.1.9 ] ~ [ wine-1.1.8 ] ~ [ wine-1.1.7 ] ~ [ wine-1.0.1 ] ~ [ wine-1.1.6 ] ~ [ wine-1.1.5 ] ~ [ wine-1.1.4 ] ~ [ wine-1.1.3 ] ~ [ wine-1.1.2 ] ~ [ wine-1.1.1 ] ~ [ wine-1.1.0 ] ~ [ wine-1.0 ] ~

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[] = { '%','','2','d','\0' }; 53 static const WCHAR szPercentZeroStar_d[] = { '%','','*','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 == '' && COULD_BE(FMT_TYPE_NUMBER)) 648 { 649 /* Number formats: Digit from number or '' 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 == '') 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 == '') 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 ? "" : "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++ = ''; 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++ = '' + *prgbDig++; 1445 if (*pToken == FMT_NUM_COPY_ZERO) 1446 { 1447 for (; pad > 0; pad--) 1448 *pBuff++ = ''; /* 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++ = ''; 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++ = '' + *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++ = ''; 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] - ''; 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] - ''; 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 } 2569

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Wine Cross Reference wine/dlls/oleaut32/varformat.c

Wine Cross Reference
wine/dlls/oleaut32/varformat.c