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

   1 /*
   2  * VARIANT
   3  *
   4  * Copyright 1998 Jean-Claude Cote
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * NOTES
  21  *   This implements the low-level and hi-level APIs for manipulating VARIANTs.
  22  *   The low-level APIs are used to do data coercion between different data types.
  23  *   The hi-level APIs are built on top of these low-level APIs and handle
  24  *   initialization, copying, destroying and changing the type of VARIANTs.
  25  *
  26  * TODO:
  27  *   - The Variant APIs do not support international languages, currency
  28  *     types, number formating and calendar.  They only support U.S. English format.
  29  *   - The Variant APIs do not the following types: IUknown, IDispatch, DECIMAL and SafeArray.
  30  *     The prototypes for these are commented out in the oleauto.h file.  They need
  31  *     to be implemented and cases need to be added to the switches of the  existing APIs.
  32  *   - The parsing of date for the VarDateFromStr is not complete.
  33  *   - The date manipulations do not support dates prior to 1900.
  34  *   - The parsing does not accept as many formats as the Windows implementation.
  35  */
  36
  37 #include "config.h"
  38
  39 #include <string.h>
  40 #include <stdlib.h>
  41 #include <stdarg.h>
  42 #include <stdio.h>
  43 #include <math.h>
  44 #include <time.h>
  45
  46 #ifdef HAVE_FLOAT_H
  47 # include <float.h>
  48 #endif
  49
  50 #define NONAMELESSUNION
  51 #define NONAMELESSSTRUCT
  52 #include "windef.h"
  53 #include "winbase.h"
  54 #include "oleauto.h"
  55 #include "winreg.h"
  56 #include "heap.h"
  57 #include "wine/debug.h"
  58 #include "winerror.h"
  59 #include "parsedt.h"
  60 #include "typelib.h"
  61 #include "winternl.h"
  62
  63 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  64
  65 #define SYSDUPSTRING(str) SysAllocStringLen((str), SysStringLen(str))
  66
  67 #ifndef FLT_MAX
  68 # ifdef MAXFLOAT
  69 #  define FLT_MAX MAXFLOAT
  70 # else
  71 #  error "Can't find #define for MAXFLOAT/FLT_MAX"
  72 # endif
  73 #endif
  74
  75 #undef CHAR_MAX
  76 #undef CHAR_MIN
  77 static const char CHAR_MAX = 127;
  78 static const char CHAR_MIN = -128;
  79 static const BYTE UI1_MAX = 255;
  80 static const BYTE UI1_MIN = 0;
  81 static const unsigned short UI2_MAX = 65535;
  82 static const unsigned short UI2_MIN = 0;
  83 static const short I2_MAX = 32767;
  84 static const short I2_MIN =  -32768;
  85 static const unsigned long UI4_MAX = 4294967295U;
  86 static const unsigned long UI4_MIN = 0;
  87 static const long I4_MAX = 2147483647;
  88 static const long I4_MIN = -(2147483648U);
  89 static const DATE DATE_MIN = -657434;
  90 static const DATE DATE_MAX = 2958465;
  91
  92 /* the largest valid type
  93  */
  94 #define VT_MAXVALIDTYPE VT_CLSID
  95
  96 /* This mask is used to set a flag in wReserved1 of
  97  * the VARIANTARG structure. The flag indicates if
  98  * the API function is using an inner variant or not.
  99  */
 100 #define PROCESSING_INNER_VARIANT 0x0001
 101
 102 /* General use buffer.
 103  */
 104 #define BUFFER_MAX 1024
 105 static char pBuffer[BUFFER_MAX];
 106
 107 /*
 108  * Note a leap year is one that is a multiple of 4
 109  * but not of a 100.  Except if it is a multiple of
 110  * 400 then it is a leap year.
 111  */
 112
 113 /*
 114  * Use 365 days/year and a manual calculation for leap year days
 115  * to keep arithmetic simple
 116  */
 117 static const double DAYS_IN_ONE_YEAR = 365.0;
 118
 119 /*
 120  * Token definitions for Varient Formatting
 121  * Worked out by experimentation on a w2k machine. Doesnt appear to be
 122  *   documented anywhere obviously so keeping definitions internally
 123  *
 124  */
 125 /* Pre defined tokens */
 126 #define TOK_COPY 0x00
 127 #define TOK_END  0x02
 128 #define LARGEST_TOKENID 6
 129
 130 /* Mapping of token name to id put into the tokenized form
 131    Note testing on W2K shows aaaa and oooo are not parsed??!! */
 132 #define TOK_COLON  0x03
 133 #define TOK_SLASH  0x04
 134 #define TOK_c      0x05
 135 #define TOK_d      0x08
 136 #define TOK_dd     0x09
 137 #define TOK_ddd    0x0a
 138 #define TOK_dddd   0x0b
 139 #define TOK_ddddd  0x0c
 140 #define TOK_dddddd 0x0d
 141 #define TOK_w      0x0f
 142 #define TOK_ww     0x10
 143 #define TOK_m      0x11
 144 #define TOK_mm     0x12
 145 #define TOK_mmm    0x13
 146 #define TOK_mmmm   0x14
 147 #define TOK_q      0x06
 148 #define TOK_y      0x15
 149 #define TOK_yy     0x16
 150 #define TOK_yyyy   0x18
 151 #define TOK_h      0x1e
 152 #define TOK_Hh     0x1f
 153 #define TOK_N      0x1a
 154 #define TOK_Nn     0x1b
 155 #define TOK_S      0x1c
 156 #define TOK_Ss     0x1d
 157 #define TOK_ttttt  0x07
 158 #define TOK_AMsPM  0x2f
 159 #define TOK_amspm  0x32
 160 #define TOK_AsP    0x30
 161 #define TOK_asp    0x33
 162 #define TOK_AMPM   0x2e
 163
 164 typedef struct tagFORMATTOKEN {
 165     char  *str;
 166     BYTE   tokenSize;
 167     BYTE   tokenId;
 168     int    varTypeRequired;
 169 } FORMATTOKEN;
 170
 171 typedef struct tagFORMATHDR {
 172     BYTE   len;
 173     BYTE   hex3;
 174     BYTE   hex6;
 175     BYTE   reserved[8];
 176 } FORMATHDR;
 177
 178 FORMATTOKEN formatTokens[] = {           /* FIXME: Only date formats so far */
 179     {":"     ,   1,  TOK_COLON  , 0},
 180     {"/"     ,   1,  TOK_SLASH  , 0},
 181     {"c"     ,   1,  TOK_c      , VT_DATE},
 182     {"dddddd",   6,  TOK_dddddd , VT_DATE},
 183     {"ddddd" ,   5,  TOK_ddddd  , VT_DATE},
 184     {"dddd"  ,   4,  TOK_dddd   , VT_DATE},
 185     {"ddd"   ,   3,  TOK_ddd    , VT_DATE},
 186     {"dd"    ,   2,  TOK_dd     , VT_DATE},
 187     {"d"     ,   1,  TOK_d      , VT_DATE},
 188     {"ww"    ,   2,  TOK_ww     , VT_DATE},
 189     {"w"     ,   1,  TOK_w      , VT_DATE},
 190     {"mmmm"  ,   4,  TOK_mmmm   , VT_DATE},
 191     {"mmm"   ,   3,  TOK_mmm    , VT_DATE},
 192     {"mm"    ,   2,  TOK_mm     , VT_DATE},
 193     {"m"     ,   1,  TOK_m      , VT_DATE},
 194     {"q"     ,   1,  TOK_q      , VT_DATE},
 195     {"yyyy"  ,   4,  TOK_yyyy   , VT_DATE},
 196     {"yy"    ,   2,  TOK_yy     , VT_DATE},
 197     {"y"     ,   1,  TOK_y      , VT_DATE},
 198     {"h"     ,   1,  TOK_h      , VT_DATE},
 199     {"Hh"    ,   2,  TOK_Hh     , VT_DATE},
 200     {"Nn"    ,   2,  TOK_Nn     , VT_DATE},
 201     {"N"     ,   1,  TOK_N      , VT_DATE},
 202     {"S"     ,   1,  TOK_S      , VT_DATE},
 203     {"Ss"    ,   2,  TOK_Ss     , VT_DATE},
 204     {"ttttt" ,   5,  TOK_ttttt  , VT_DATE},
 205     {"AM/PM" ,   5,  TOK_AMsPM  , VT_DATE},
 206     {"am/pm" ,   5,  TOK_amspm  , VT_DATE},
 207     {"A/P"   ,   3,  TOK_AsP    , VT_DATE},
 208     {"a/p"   ,   3,  TOK_asp    , VT_DATE},
 209     {"AMPM"  ,   4,  TOK_AMPM   , VT_DATE},
 210     {0x00    ,   0,  0          , VT_NULL}
 211 };
 212
 213 /******************************************************************************
 214  *         DateTimeStringToTm   [INTERNAL]
 215  *
 216  * Converts a string representation of a date and/or time to a tm structure.
 217  *
 218  * Note this function uses the postgresql date parsing functions found
 219  * in the parsedt.c file.
 220  *
 221  * Returns TRUE if successful.
 222  *
 223  * Note: This function does not parse the day of the week,
 224  * daylight savings time. It will only fill the followin fields in
 225  * the tm struct, tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
 226  *
 227  ******************************************************************************/
 228 static BOOL DateTimeStringToTm( OLECHAR* strIn, DWORD dwFlags, struct tm* pTm )
 229 {
 230         BOOL res = FALSE;
 231         double          fsec;
 232         int             tzp;
 233         int             dtype;
 234         int             nf;
 235         char       *field[MAXDATEFIELDS];
 236         int             ftype[MAXDATEFIELDS];
 237         char            lowstr[MAXDATELEN + 1];
 238         char* strDateTime = NULL;
 239
 240         /* Convert the string to ASCII since this is the only format
 241          * postgesql can handle.
 242          */
 243         strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
 244
 245         if( strDateTime != NULL )
 246         {
 247                 /* Make sure we don't go over the maximum length
 248                  * accepted by postgesql.
 249                  */
 250                 if( strlen( strDateTime ) <= MAXDATELEN )
 251                 {
 252                         if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
 253                         {
 254                                 if( dwFlags & VAR_DATEVALUEONLY )
 255                                 {
 256                                         /* Get the date information.
 257                                          * It returns 0 if date information was
 258                                          * present and 1 if only time information was present.
 259                                          * -1 if an error occures.
 260                                          */
 261                                         if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
 262                                         {
 263                                                 /* Eliminate the time information since we
 264                                                  * were asked to get date information only.
 265                                                  */
 266                                                 pTm->tm_sec = 0;
 267                                                 pTm->tm_min = 0;
 268                                                 pTm->tm_hour = 0;
 269                                                 res = TRUE;
 270                                         }
 271                                 }
 272                                 if( dwFlags & VAR_TIMEVALUEONLY )
 273                                 {
 274                                         /* Get time information only.
 275                                          */
 276                                         if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
 277                                         {
 278                                                 res = TRUE;
 279                                         }
 280                                 }
 281                                 else
 282                                 {
 283                                         /* Get both date and time information.
 284                                          * It returns 0 if date information was
 285                                          * present and 1 if only time information was present.
 286                                          * -1 if an error occures.
 287                                          */
 288                                         if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
 289                                         {
 290                                                 res = TRUE;
 291                                         }
 292                                 }
 293                         }
 294                 }
 295                 HeapFree( GetProcessHeap(), 0, strDateTime );
 296         }
 297
 298         return res;
 299 }
 300
 301
 302
 303
 304
 305
 306 /******************************************************************************
 307  *         TmToDATE     [INTERNAL]
 308  *
 309  * The date is implemented using an 8 byte floating-point number.
 310  * Days are represented by whole numbers increments starting with 0.00 has
 311  * being December 30 1899, midnight.
 312  * The hours are expressed as the fractional part of the number.
 313  * December 30 1899 at midnight = 0.00
 314  * January 1 1900 at midnight = 2.00
 315  * January 4 1900 at 6 AM = 5.25
 316  * January 4 1900 at noon = 5.50
 317  * December 29 1899 at midnight = -1.00
 318  * December 18 1899 at midnight = -12.00
 319  * December 18 1899 at 6AM = -12.25
 320  * December 18 1899 at 6PM = -12.75
 321  * December 19 1899 at midnight = -11.00
 322  * The tm structure is as follows:
 323  * struct tm {
 324  *                int tm_sec;      seconds after the minute - [0,59]
 325  *                int tm_min;      minutes after the hour - [0,59]
 326  *                int tm_hour;     hours since midnight - [0,23]
 327  *                int tm_mday;     day of the month - [1,31]
 328  *                int tm_mon;      months since January - [0,11]
 329  *                int tm_year;     years
 330  *                int tm_wday;     days since Sunday - [0,6]
 331  *                int tm_yday;     days since January 1 - [0,365]
 332  *                int tm_isdst;    daylight savings time flag
 333  *                };
 334  *
 335  * Note: This function does not use the tm_wday, tm_yday, tm_wday,
 336  * and tm_isdst fields of the tm structure. And only converts years
 337  * after 1900.
 338  *
 339  * Returns TRUE if successful.
 340  */
 341 static BOOL TmToDATE( struct tm* pTm, DATE *pDateOut )
 342 {
 343     int leapYear = 0;
 344
 345     /* Hmmm... An uninitialized Date in VB is December 30 1899 so
 346        Start at 0. This is the way DATE is defined. */
 347
 348     /* Start at 1. This is the way DATE is defined.
 349      * January 1, 1900 at Midnight is 1.00.
 350      * January 1, 1900 at 6AM is 1.25.
 351      * and so on.
 352      */
 353     *pDateOut = 1;
 354
 355     if( (pTm->tm_year - 1900) >= 0 ) {
 356
 357         /* Add the number of days corresponding to
 358          * tm_year.
 359          */
 360         *pDateOut += (pTm->tm_year - 1900) * 365;
 361
 362         /* Add the leap days in the previous years between now and 1900.
 363          * Note a leap year is one that is a multiple of 4
 364          * but not of a 100.  Except if it is a multiple of
 365          * 400 then it is a leap year.
 366          * Copied + reversed functionality into TmToDate
 367          */
 368         *pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
 369         *pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
 370         *pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
 371
 372         /* Set the leap year flag if the
 373          * current year specified by tm_year is a
 374          * leap year. This will be used to add a day
 375          * to the day count.
 376          */
 377         if( isleap( pTm->tm_year ) )
 378             leapYear = 1;
 379
 380         /* Add the number of days corresponding to
 381          * the month. (remember tm_mon is 0..11)
 382          */
 383         switch( pTm->tm_mon )
 384         {
 385         case 1:
 386             *pDateOut += 31;
 387             break;
 388         case 2:
 389             *pDateOut += ( 59 + leapYear );
 390             break;
 391         case 3:
 392             *pDateOut += ( 90 + leapYear );
 393             break;
 394         case 4:
 395             *pDateOut += ( 120 + leapYear );
 396             break;
 397         case 5:
 398             *pDateOut += ( 151 + leapYear );
 399             break;
 400         case 6:
 401             *pDateOut += ( 181 + leapYear );
 402             break;
 403         case 7:
 404             *pDateOut += ( 212 + leapYear );
 405             break;
 406         case 8:
 407             *pDateOut += ( 243 + leapYear );
 408             break;
 409         case 9:
 410             *pDateOut += ( 273 + leapYear );
 411             break;
 412         case 10:
 413             *pDateOut += ( 304 + leapYear );
 414             break;
 415         case 11:
 416             *pDateOut += ( 334 + leapYear );
 417             break;
 418         }
 419         /* Add the number of days in this month.
 420          */
 421         *pDateOut += pTm->tm_mday;
 422
 423         /* Add the number of seconds, minutes, and hours
 424          * to the DATE. Note these are the fractional part
 425          * of the DATE so seconds / number of seconds in a day.
 426          */
 427     } else {
 428         *pDateOut = 0;
 429     }
 430
 431     *pDateOut += pTm->tm_hour / 24.0;
 432     *pDateOut += pTm->tm_min / 1440.0;
 433     *pDateOut += pTm->tm_sec / 86400.0;
 434     return TRUE;
 435 }
 436
 437 /******************************************************************************
 438  *         DateToTm     [INTERNAL]
 439  *
 440  * This function converts a windows DATE to a tm structure.
 441  *
 442  * It does not fill all the fields of the tm structure.
 443  * Here is a list of the fields that are filled:
 444  * tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
 445  *
 446  * Note this function does not support dates before the January 1, 1900
 447  * or ( dateIn < 2.0 ).
 448  *
 449  * Returns TRUE if successful.
 450  */
 451 BOOL DateToTm( DATE dateIn, DWORD dwFlags, struct tm* pTm )
 452 {
 453     double decimalPart = 0.0;
 454     double wholePart = 0.0;
 455
 456     memset(pTm,0,sizeof(*pTm));
 457
 458     /* Because of the nature of DATE format which
 459      * associates 2.0 to January 1, 1900. We will
 460      * remove 1.0 from the whole part of the DATE
 461      * so that in the following code 1.0
 462      * will correspond to January 1, 1900.
 463      * This simplifies the processing of the DATE value.
 464      */
 465     decimalPart = fmod( dateIn, 1.0 ); /* Do this before the -1, otherwise 0.xx goes negative */
 466     dateIn -= 1.0;
 467     wholePart = (double) floor( dateIn );
 468
 469     if( !(dwFlags & VAR_TIMEVALUEONLY) )
 470     {
 471         unsigned int nDay = 0;
 472         int leapYear = 0;
 473         double yearsSince1900 = 0;
 474
 475         /* Hard code dates smaller than January 1, 1900. */
 476         if( dateIn < 2.0 ) {
 477             pTm->tm_year = 1899;
 478             pTm->tm_mon  = 11; /* December as tm_mon is 0..11 */
 479             if( dateIn < 1.0 ) {
 480                 pTm->tm_mday  = 30;
 481                 dateIn = dateIn * -1.0; /* Ensure +ve for time calculation */
 482                 decimalPart = decimalPart * -1.0; /* Ensure +ve for time calculation */
 483             } else {
 484                 pTm->tm_mday  = 31;
 485             }
 486
 487         } else {
 488
 489             /* Start at 1900, this is where the DATE time 0.0 starts.
 490              */
 491             pTm->tm_year = 1900;
 492             /* find in what year the day in the "wholePart" falls into.
 493              * add the value to the year field.
 494              */
 495             yearsSince1900 = floor( (wholePart / DAYS_IN_ONE_YEAR) + 0.001 );
 496             pTm->tm_year += yearsSince1900;
 497             /* determine if this is a leap year.
 498              */
 499             if( isleap( pTm->tm_year ) )
 500             {
 501                 leapYear = 1;
 502                 wholePart++;
 503             }
 504
 505             /* find what day of that year the "wholePart" corresponds to.
 506              * Note: nDay is in [1-366] format
 507              */
 508             nDay = (((unsigned int) wholePart) - ((pTm->tm_year-1900) * DAYS_IN_ONE_YEAR ));
 509
 510             /* Remove the leap days in the previous years between now and 1900.
 511              * Note a leap year is one that is a multiple of 4
 512              * but not of a 100.  Except if it is a multiple of
 513              * 400 then it is a leap year.
 514              * Copied + reversed functionality from TmToDate
 515              */
 516             nDay -= ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
 517             nDay += ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
 518             nDay -= ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
 519
 520             /* Set the tm_yday value.
 521              * Note: The day must be converted from [1-366] to [0-365]
 522              */
 523             /*pTm->tm_yday = nDay - 1;*/
 524             /* find which month this day corresponds to.
 525              */
 526             if( nDay <= 31 )
 527             {
 528                 pTm->tm_mday = nDay;
 529                 pTm->tm_mon = 0;
 530             }
 531             else if( nDay <= ( 59 + leapYear ) )
 532             {
 533                 pTm->tm_mday = nDay - 31;
 534                 pTm->tm_mon = 1;
 535             }
 536             else if( nDay <= ( 90 + leapYear ) )
 537             {
 538                 pTm->tm_mday = nDay - ( 59 + leapYear );
 539                 pTm->tm_mon = 2;
 540             }
 541             else if( nDay <= ( 120 + leapYear ) )
 542             {
 543                 pTm->tm_mday = nDay - ( 90 + leapYear );
 544                 pTm->tm_mon = 3;
 545             }
 546             else if( nDay <= ( 151 + leapYear ) )
 547             {
 548                 pTm->tm_mday = nDay - ( 120 + leapYear );
 549                 pTm->tm_mon = 4;
 550             }
 551             else if( nDay <= ( 181 + leapYear ) )
 552             {
 553                 pTm->tm_mday = nDay - ( 151 + leapYear );
 554                 pTm->tm_mon = 5;
 555             }
 556             else if( nDay <= ( 212 + leapYear ) )
 557             {
 558                 pTm->tm_mday = nDay - ( 181 + leapYear );
 559                 pTm->tm_mon = 6;
 560             }
 561             else if( nDay <= ( 243 + leapYear ) )
 562             {
 563                 pTm->tm_mday = nDay - ( 212 + leapYear );
 564                 pTm->tm_mon = 7;
 565             }
 566             else if( nDay <= ( 273 + leapYear ) )
 567             {
 568                 pTm->tm_mday = nDay - ( 243 + leapYear );
 569                 pTm->tm_mon = 8;
 570             }
 571             else if( nDay <= ( 304 + leapYear ) )
 572             {
 573                 pTm->tm_mday = nDay - ( 273 + leapYear );
 574                 pTm->tm_mon = 9;
 575             }
 576             else if( nDay <= ( 334 + leapYear ) )
 577             {
 578                 pTm->tm_mday = nDay - ( 304 + leapYear );
 579                 pTm->tm_mon = 10;
 580             }
 581             else if( nDay <= ( 365 + leapYear ) )
 582             {
 583                 pTm->tm_mday = nDay - ( 334 + leapYear );
 584                 pTm->tm_mon = 11;
 585             }
 586         }
 587     }
 588     if( !(dwFlags & VAR_DATEVALUEONLY) )
 589     {
 590         /* find the number of seconds in this day.
 591          * fractional part times, hours, minutes, seconds.
 592          * Note: 0.1 is hack to ensure figures come out in whole numbers
 593          *   due to floating point inaccuracies
 594          */
 595         pTm->tm_hour = (int) ( decimalPart * 24 );
 596         pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
 597         /* Note: 0.1 is hack to ensure seconds come out in whole numbers
 598              due to floating point inaccuracies */
 599         pTm->tm_sec = (int) (( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 ) + 0.1);
 600     }
 601     return TRUE;
 602 }
 603
 604
 605
 606 /******************************************************************************
 607  *         SizeOfVariantData    [INTERNAL]
 608  *
 609  * This function finds the size of the data referenced by a Variant based
 610  * the type "vt" of the Variant.
 611  */
 612 static int SizeOfVariantData( VARIANT* parg )
 613 {
 614     int size = 0;
 615     switch( V_VT(parg) & VT_TYPEMASK )
 616     {
 617     case( VT_I2 ):
 618         size = sizeof(short);
 619         break;
 620     case( VT_INT ):
 621         size = sizeof(int);
 622         break;
 623     case( VT_I4 ):
 624         size = sizeof(long);
 625         break;
 626     case( VT_UI1 ):
 627         size = sizeof(BYTE);
 628         break;
 629     case( VT_UI2 ):
 630         size = sizeof(unsigned short);
 631         break;
 632     case( VT_UINT ):
 633         size = sizeof(unsigned int);
 634         break;
 635     case( VT_UI4 ):
 636         size = sizeof(unsigned long);
 637         break;
 638     case( VT_R4 ):
 639         size = sizeof(float);
 640         break;
 641     case( VT_R8 ):
 642         size = sizeof(double);
 643         break;
 644     case( VT_DATE ):
 645         size = sizeof(DATE);
 646         break;
 647     case( VT_BOOL ):
 648         size = sizeof(VARIANT_BOOL);
 649         break;
 650     case( VT_BSTR ):
 651     case( VT_DISPATCH ):
 652     case( VT_UNKNOWN ):
 653         size = sizeof(void*);
 654         break;
 655     case( VT_CY ):
 656         size = sizeof(CY);
 657         break;
 658     case( VT_DECIMAL ):         /* hmm, tricky, DECIMAL is only VT_BYREF */
 659     default:
 660         FIXME("Add size information for type vt=%d\n", V_VT(parg) & VT_TYPEMASK );
 661         break;
 662     }
 663
 664     return size;
 665 }
 666 /******************************************************************************
 667  *         StringDupAtoBstr             [INTERNAL]
 668  *
 669  */
 670 static BSTR StringDupAtoBstr( char* strIn )
 671 {
 672         BSTR bstr = NULL;
 673         OLECHAR* pNewString = NULL;
 674         UNICODE_STRING usBuffer;
 675
 676         RtlCreateUnicodeStringFromAsciiz( &usBuffer, strIn );
 677         pNewString = usBuffer.Buffer;
 678
 679         bstr = SysAllocString( pNewString );
 680         RtlFreeUnicodeString( &usBuffer );
 681         return bstr;
 682 }
 683
 684 /******************************************************************************
 685  *              round           [INTERNAL]
 686  *
 687  * Round the double value to the nearest integer value.
 688  */
 689 static double round( double d )
 690 {
 691    double decimals = 0.0, integerValue = 0.0, roundedValue = 0.0;
 692     BOOL bEvenNumber = FALSE;
 693     int nSign = 0;
 694
 695     /* Save the sign of the number
 696      */
 697    nSign = (d >= 0.0) ? 1 : -1;
 698     d = fabs( d );
 699
 700         /* Remove the decimals.
 701          */
 702    integerValue = floor( d );
 703
 704     /* Set the Even flag.  This is used to round the number when
 705      * the decimals are exactly 1/2.  If the integer part is
 706      * odd the number is rounded up. If the integer part
 707      * is even the number is rounded down.  Using this method
 708      * numbers are rounded up|down half the time.
 709      */
 710    bEvenNumber = (((short)fmod(integerValue, 2)) == 0) ? TRUE : FALSE;
 711
 712     /* Remove the integral part of the number.
 713      */
 714     decimals = d - integerValue;
 715
 716         /* Note: Ceil returns the smallest integer that is greater that x.
 717          * and floor returns the largest integer that is less than or equal to x.
 718          */
 719     if( decimals > 0.5 )
 720     {
 721         /* If the decimal part is greater than 1/2
 722          */
 723         roundedValue = ceil( d );
 724     }
 725     else if( decimals < 0.5 )
 726     {
 727         /* If the decimal part is smaller than 1/2
 728          */
 729         roundedValue = floor( d );
 730     }
 731     else
 732     {
 733         /* the decimals are exactly 1/2 so round according to
 734          * the bEvenNumber flag.
 735          */
 736         if( bEvenNumber )
 737         {
 738             roundedValue = floor( d );
 739         }
 740         else
 741         {
 742             roundedValue = ceil( d );
 743         }
 744     }
 745
 746         return roundedValue * nSign;
 747 }
 748
 749 /******************************************************************************
 750  *              RemoveCharacterFromString               [INTERNAL]
 751  *
 752  * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
 753  */
 754 static void RemoveCharacterFromString( LPSTR str, LPSTR strOfCharToRemove )
 755 {
 756         LPSTR pNewString = NULL;
 757         LPSTR strToken = NULL;
 758
 759         /* Check if we have a valid argument
 760          */
 761         if( str != NULL )
 762         {
 763                 pNewString = strdup( str );
 764                 str[0] = '\0';
 765                 strToken = strtok( pNewString, strOfCharToRemove );
 766                 while( strToken != NULL ) {
 767                         strcat( str, strToken );
 768                         strToken = strtok( NULL, strOfCharToRemove );
 769                 }
 770                 free( pNewString );
 771         }
 772         return;
 773 }
 774
 775 /******************************************************************************
 776  *              GetValidRealString              [INTERNAL]
 777  *
 778  * Checks if the string is of proper format to be converted to a real value.
 779  */
 780 static BOOL IsValidRealString( LPSTR strRealString )
 781 {
 782         /* Real values that have a decimal point are required to either have
 783          * digits before or after the decimal point.  We will assume that
 784          * we do not have any digits at either position. If we do encounter
 785          * some we will disable this flag.
 786          */
 787         BOOL bDigitsRequired = TRUE;
 788         /* Processed fields in the string representation of the real number.
 789          */
 790         BOOL bWhiteSpaceProcessed = FALSE;
 791         BOOL bFirstSignProcessed = FALSE;
 792         BOOL bFirstDigitsProcessed = FALSE;
 793         BOOL bDecimalPointProcessed = FALSE;
 794         BOOL bSecondDigitsProcessed = FALSE;
 795         BOOL bExponentProcessed = FALSE;
 796         BOOL bSecondSignProcessed = FALSE;
 797         BOOL bThirdDigitsProcessed = FALSE;
 798         /* Assume string parameter "strRealString" is valid and try to disprove it.
 799          */
 800         BOOL bValidRealString = TRUE;
 801
 802         /* Used to count the number of tokens in the "strRealString".
 803          */
 804         LPSTR strToken = NULL;
 805         int nTokens = 0;
 806         LPSTR pChar = NULL;
 807
 808         /* Check if we have a valid argument
 809          */
 810         if( strRealString == NULL )
 811         {
 812                 bValidRealString = FALSE;
 813         }
 814
 815         if( bValidRealString == TRUE )
 816         {
 817                 /* Make sure we only have ONE token in the string.
 818                  */
 819                 strToken = strtok( strRealString, " " );
 820                 while( strToken != NULL ) {
 821                         nTokens++;
 822                         strToken = strtok( NULL, " " );
 823                 }
 824
 825                 if( nTokens != 1 )
 826                 {
 827                         bValidRealString = FALSE;
 828                 }
 829         }
 830
 831
 832         /* Make sure this token contains only valid characters.
 833          * The string argument to atof has the following form:
 834          * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
 835          * Whitespace consists of space and|or <TAB> characters, which are ignored.
 836      * Sign is either plus '+' or minus '-'.
 837      * Digits are one or more decimal digits.
 838      * Note: If no digits appear before the decimal point, at least one must
 839      * appear after the decimal point.
 840      * The decimal digits may be followed by an exponent.
 841      * An Exponent consists of an introductory letter ( D, d, E, or e) and
 842          * an optionally signed decimal integer.
 843          */
 844         pChar = strRealString;
 845         while( bValidRealString == TRUE && *pChar != '\0' )
 846         {
 847                 switch( *pChar )
 848                 {
 849                 /* If whitespace...
 850                  */
 851                 case ' ':
 852                 case '\t':
 853                         if( bWhiteSpaceProcessed ||
 854                                 bFirstSignProcessed ||
 855                                 bFirstDigitsProcessed ||
 856                                 bDecimalPointProcessed ||
 857                                 bSecondDigitsProcessed ||
 858                                 bExponentProcessed ||
 859                                 bSecondSignProcessed ||
 860                                 bThirdDigitsProcessed )
 861                         {
 862                                 bValidRealString = FALSE;
 863                         }
 864                         break;
 865                 /* If sign...
 866                  */
 867                 case '+':
 868                 case '-':
 869                         if( bFirstSignProcessed == FALSE )
 870                         {
 871                                 if( bFirstDigitsProcessed ||
 872                                         bDecimalPointProcessed ||
 873                                         bSecondDigitsProcessed ||
 874                                         bExponentProcessed ||
 875                                         bSecondSignProcessed ||
 876                                         bThirdDigitsProcessed )
 877                                 {
 878                                         bValidRealString = FALSE;
 879                                 }
 880                                 bWhiteSpaceProcessed = TRUE;
 881                                 bFirstSignProcessed = TRUE;
 882                         }
 883                         else if( bSecondSignProcessed == FALSE )
 884                         {
 885                 /* Note: The exponent must be present in
 886                                  * order to accept the second sign...
 887                                  */
 888                                 if( bExponentProcessed == FALSE ||
 889                                         bThirdDigitsProcessed ||
 890                                         bDigitsRequired )
 891                                 {
 892                                         bValidRealString = FALSE;
 893                                 }
 894                                 bFirstSignProcessed = TRUE;
 895                                 bWhiteSpaceProcessed = TRUE;
 896                                 bFirstDigitsProcessed = TRUE;
 897                                 bDecimalPointProcessed = TRUE;
 898                                 bSecondDigitsProcessed = TRUE;
 899                                 bSecondSignProcessed = TRUE;
 900                         }
 901                         break;
 902
 903                 /* If decimals...
 904                  */
 905                 case '0':
 906                 case '1':
 907                 case '2':
 908                 case '3':
 909                 case '4':
 910                 case '5':
 911                 case '6':
 912                 case '7':
 913                 case '8':
 914                 case '9':
 915                         if( bFirstDigitsProcessed == FALSE )
 916                         {
 917                                 if( bDecimalPointProcessed ||
 918                                         bSecondDigitsProcessed ||
 919                                         bExponentProcessed ||
 920                                         bSecondSignProcessed ||
 921                                         bThirdDigitsProcessed )
 922                                 {
 923                                         bValidRealString = FALSE;
 924                                 }
 925                                 bFirstSignProcessed = TRUE;
 926                                 bWhiteSpaceProcessed = TRUE;
 927                                 /* We have found some digits before the decimal point
 928                                  * so disable the "Digits required" flag.
 929                                  */
 930                                 bDigitsRequired = FALSE;
 931                         }
 932                         else if( bSecondDigitsProcessed == FALSE )
 933                         {
 934                                 if( bExponentProcessed ||
 935                                         bSecondSignProcessed ||
 936                                         bThirdDigitsProcessed )
 937                                 {
 938                                         bValidRealString = FALSE;
 939                                 }
 940                                 bFirstSignProcessed = TRUE;
 941                                 bWhiteSpaceProcessed = TRUE;
 942                                 bFirstDigitsProcessed = TRUE;
 943                                 bDecimalPointProcessed = TRUE;
 944                                 /* We have found some digits after the decimal point
 945                                  * so disable the "Digits required" flag.
 946                                  */
 947                                 bDigitsRequired = FALSE;
 948                         }
 949                         else if( bThirdDigitsProcessed == FALSE )
 950                         {
 951                                 /* Getting here means everything else should be processed.
 952                  * If we get anything else than a decimal following this
 953                  * digit it will be flagged by the other cases, so
 954                                  * we do not really need to do anything in here.
 955                                  */
 956                         }
 957                         break;
 958                 /* If DecimalPoint...
 959                  */
 960                 case '.':
 961                         if( bDecimalPointProcessed ||
 962                                 bSecondDigitsProcessed ||
 963                                 bExponentProcessed ||
 964                                 bSecondSignProcessed ||
 965                                 bThirdDigitsProcessed )
 966                         {
 967                                 bValidRealString = FALSE;
 968                         }
 969                         bFirstSignProcessed = TRUE;
 970                         bWhiteSpaceProcessed = TRUE;
 971                         bFirstDigitsProcessed = TRUE;
 972                         bDecimalPointProcessed = TRUE;
 973                         break;
 974                 /* If Exponent...
 975                  */
 976                 case 'e':
 977                 case 'E':
 978                 case 'd':
 979                 case 'D':
 980                         if( bExponentProcessed ||
 981                                 bSecondSignProcessed ||
 982                                 bThirdDigitsProcessed ||
 983                                 bDigitsRequired )
 984                         {
 985                                 bValidRealString = FALSE;
 986                         }
 987                         bFirstSignProcessed = TRUE;
 988                         bWhiteSpaceProcessed = TRUE;
 989                         bFirstDigitsProcessed = TRUE;
 990                         bDecimalPointProcessed = TRUE;
 991                         bSecondDigitsProcessed = TRUE;
 992                         bExponentProcessed = TRUE;
 993                         break;
 994                 default:
 995                         bValidRealString = FALSE;
 996                         break;
 997                 }
 998                 /* Process next character.
 999                  */
1000                 pChar++;
1001         }
1002
1003         /* If the required digits were not present we have an invalid
1004          * string representation of a real number.
1005          */
1006         if( bDigitsRequired == TRUE )
1007         {
1008                 bValidRealString = FALSE;
1009         }
1010
1011         return bValidRealString;
1012 }
1013
1014
1015 /******************************************************************************
1016  *              Coerce  [INTERNAL]
1017  *
1018  * This function dispatches execution to the proper conversion API
1019  * to do the necessary coercion.
1020  *
1021  * FIXME: Passing down dwFlags to the conversion functions is wrong, this
1022  *        is a different flagmask. Check MSDN.
1023  */
1024 static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt )
1025 {
1026         HRESULT res = S_OK;
1027         unsigned short vtFrom = 0;
1028         vtFrom = V_VT(ps) & VT_TYPEMASK;
1029
1030
1031         /* Note: Since "long" and "int" values both have 4 bytes and are
1032          * both signed integers "int" will be treated as "long" in the
1033          * following code.
1034          * The same goes for their unsigned versions.
1035          */
1036
1037         /* Trivial Case: If the coercion is from two types that are
1038          * identical then we can blindly copy from one argument to another.*/
1039         if ((vt==vtFrom))
1040            return VariantCopy(pd,ps);
1041
1042         /* Cases requiring thought*/
1043         switch( vt )
1044         {
1045
1046     case( VT_EMPTY ):
1047         res = VariantClear( pd );
1048         break;
1049     case( VT_NULL ):
1050         res = VariantClear( pd );
1051         if( res == S_OK )
1052         {
1053             V_VT(pd) = VT_NULL;
1054         }
1055         break;
1056         case( VT_I1 ):
1057                 switch( vtFrom )
1058         {
1059                 case( VT_I2 ):
1060                         res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) );
1061                         break;
1062                 case( VT_INT ):
1063                 case( VT_I4 ):
1064                         res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) );
1065                         break;
1066                 case( VT_UI1 ):
1067                         res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) );
1068                         break;
1069                 case( VT_UI2 ):
1070                         res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) );
1071                         break;
1072                 case( VT_UINT ):
1073                 case( VT_UI4 ):
1074                         res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) );
1075                         break;
1076                 case( VT_R4 ):
1077                         res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) );
1078                         break;
1079                 case( VT_R8 ):
1080                         res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) );
1081                         break;
1082                 case( VT_DATE ):
1083                         res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) );
1084                         break;
1085                 case( VT_BOOL ):
1086                         res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) );
1087                         break;
1088                 case( VT_BSTR ):
1089                         res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) );
1090                         break;
1091                 case( VT_CY ):
1092                         res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) );
1093                         break;
1094                 case( VT_DISPATCH ):
1095                         /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/
1096                 case( VT_DECIMAL ):
1097                         /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/
1098                 case( VT_UNKNOWN ):
1099                 default:
1100                         res = DISP_E_TYPEMISMATCH;
1101                         FIXME("Coercion from %d to VT_I1\n", vtFrom );
1102                         break;
1103                 }
1104                 break;
1105
1106         case( VT_I2 ):
1107                 switch( vtFrom )
1108                 {
1109                 case( VT_I1 ):
1110                         res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) );
1111                         break;
1112                 case( VT_INT ):
1113                 case( VT_I4 ):
1114                         res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) );
1115                         break;
1116                 case( VT_UI1 ):
1117                         res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) );
1118                         break;
1119                 case( VT_UI2 ):
1120                         res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) );
1121                         break;
1122                 case( VT_UINT ):
1123                 case( VT_UI4 ):
1124                         res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) );
1125                         break;
1126                 case( VT_R4 ):
1127                         res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) );
1128                         break;
1129                 case( VT_R8 ):
1130                         res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) );
1131                         break;
1132                 case( VT_DATE ):
1133                         res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) );
1134                         break;
1135                 case( VT_BOOL ):
1136                         res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) );
1137                         break;
1138                 case( VT_BSTR ):
1139                         res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) );
1140                         break;
1141                 case( VT_CY ):
1142                         res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) );
1143                         break;
1144                 case( VT_DISPATCH ):
1145                         /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/
1146                 case( VT_DECIMAL ):
1147                         /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/
1148                 case( VT_UNKNOWN ):
1149                 default:
1150                         res = DISP_E_TYPEMISMATCH;
1151                         FIXME("Coercion from %d to VT_I2\n", vtFrom);
1152                         break;
1153                 }
1154                 break;
1155
1156         case( VT_INT ):
1157         case( VT_I4 ):
1158                 switch( vtFrom )
1159                 {
1160                 case( VT_EMPTY ):
1161                         V_UNION(pd,lVal) = 0;
1162                         res = S_OK;
1163                         break;
1164                 case( VT_I1 ):
1165                         res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) );
1166                         break;
1167                 case( VT_I2 ):
1168                         res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) );
1169
1170                         break;
1171                 case( VT_ERROR ):
1172                         V_UNION(pd,lVal) = V_UNION(pd,scode);
1173                         res = S_OK;
1174                         break;
1175         case( VT_INT ):
1176         case( VT_I4 ):
1177             res = VariantCopy( pd, ps );
1178             break;
1179                 case( VT_UI1 ):
1180                         res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) );
1181                         break;
1182                 case( VT_UI2 ):
1183                         res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) );
1184                         break;
1185                 case( VT_UINT ):
1186                 case( VT_UI4 ):
1187                         res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) );
1188                         break;
1189                 case( VT_R4 ):
1190                         res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) );
1191                         break;
1192                 case( VT_R8 ):
1193                         res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) );
1194                         break;
1195                 case( VT_DATE ):
1196                         res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) );
1197                         break;
1198                 case( VT_BOOL ):
1199                         res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) );
1200                         break;
1201                 case( VT_BSTR ):
1202                         res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) );
1203                         break;
1204                 case( VT_CY ):
1205                         res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) );
1206                         break;
1207                 case( VT_DISPATCH ):
1208                         /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/
1209                 case( VT_DECIMAL ):
1210                         /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/
1211                 case( VT_UNKNOWN ):
1212                 default:
1213                         res = DISP_E_TYPEMISMATCH;
1214                         FIXME("Coercion from %d to VT_INT/VT_I4\n", vtFrom);
1215                         break;
1216                 }
1217                 break;
1218
1219         case( VT_UI1 ):
1220                 switch( vtFrom )
1221                 {
1222                 case( VT_I1 ):
1223                         res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) );
1224                         break;
1225                 case( VT_I2 ):
1226                         res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) );
1227                         break;
1228                 case( VT_INT ):
1229                 case( VT_I4 ):
1230                         res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) );
1231                         break;
1232         case( VT_UI1 ):
1233             res = VariantCopy( pd, ps );
1234             break;
1235                 case( VT_UI2 ):
1236                         res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) );
1237                         break;
1238                 case( VT_UINT ):
1239                 case( VT_UI4 ):
1240                         res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) );
1241                         break;
1242                 case( VT_R4 ):
1243                         res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) );
1244                         break;
1245                 case( VT_R8 ):
1246                         res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) );
1247                         break;
1248                 case( VT_DATE ):
1249                         res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) );
1250                         break;
1251                 case( VT_BOOL ):
1252                         res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) );
1253                         break;
1254                 case( VT_BSTR ):
1255                         res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) );
1256                         break;
1257                 case( VT_CY ):
1258                         res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) );
1259                         break;
1260                 case( VT_DISPATCH ):
1261                         /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/
1262                 case( VT_DECIMAL ):
1263                         /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/
1264                 case( VT_UNKNOWN ):
1265                 default:
1266                         res = DISP_E_TYPEMISMATCH;
1267                         FIXME("Coercion from %d to VT_UI1\n", vtFrom);
1268                         break;
1269                 }
1270                 break;
1271
1272         case( VT_UI2 ):
1273                 switch( vtFrom )
1274                 {
1275                 case( VT_I1 ):
1276                         res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) );
1277                         break;
1278                 case( VT_I2 ):
1279                         res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) );
1280                         break;
1281                 case( VT_INT ):
1282                 case( VT_I4 ):
1283                         res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) );
1284                         break;
1285                 case( VT_UI1 ):
1286                         res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) );
1287                         break;
1288         case( VT_UI2 ):
1289             res = VariantCopy( pd, ps );
1290             break;
1291                 case( VT_UINT ):
1292                 case( VT_UI4 ):
1293                         res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) );
1294                         break;
1295                 case( VT_R4 ):
1296                         res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) );
1297                         break;
1298                 case( VT_R8 ):
1299                         res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) );
1300                         break;
1301                 case( VT_DATE ):
1302                         res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) );
1303                         break;
1304                 case( VT_BOOL ):
1305                         res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) );
1306                         break;
1307                 case( VT_BSTR ):
1308                         res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) );
1309                         break;
1310                 case( VT_CY ):
1311                         res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) );
1312                         break;
1313                 case( VT_DISPATCH ):
1314                         /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/
1315                 case( VT_DECIMAL ):
1316                         /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/
1317                 case( VT_UNKNOWN ):
1318                 default:
1319                         res = DISP_E_TYPEMISMATCH;
1320                         FIXME("Coercion from %d to VT_UI2\n", vtFrom);
1321                         break;
1322                 }
1323                 break;
1324
1325         case( VT_UINT ):
1326         case( VT_UI4 ):
1327                 switch( vtFrom )
1328                 {
1329                 case( VT_I1 ):
1330                         res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) );
1331                         break;
1332                 case( VT_I2 ):
1333                         res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) );
1334                         break;
1335                 case( VT_INT ):
1336                 case( VT_I4 ):
1337                         res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) );
1338                         break;
1339                 case( VT_UI1 ):
1340                         res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) );
1341                         break;
1342                 case( VT_UI2 ):
1343                         res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) );
1344                         break;
1345         case( VT_UI4 ):
1346             res = VariantCopy( pd, ps );
1347             break;
1348                 case( VT_R4 ):
1349                         res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) );
1350                         break;
1351                 case( VT_R8 ):
1352                         res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) );
1353                         break;
1354                 case( VT_DATE ):
1355                         res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) );
1356                         break;
1357                 case( VT_BOOL ):
1358                         res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) );
1359                         break;
1360                 case( VT_BSTR ):
1361                         res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) );
1362                         break;
1363                 case( VT_CY ):
1364                         res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) );
1365                         break;
1366                 case( VT_DISPATCH ):
1367                         /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/
1368                 case( VT_DECIMAL ):
1369                         /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/
1370                 case( VT_UNKNOWN ):
1371                 default:
1372                         res = DISP_E_TYPEMISMATCH;
1373                         FIXME("Coercion from %d to VT_UINT/VT_UI4\n", vtFrom);
1374                         break;
1375                 }
1376                 break;
1377
1378         case( VT_R4 ):
1379                 switch( vtFrom )
1380                 {
1381                 case( VT_I1 ):
1382                         res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) );
1383                         break;
1384                 case( VT_I2 ):
1385                         res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) );
1386                         break;
1387                 case( VT_INT ):
1388                 case( VT_I4 ):
1389                         res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) );
1390                         break;
1391                 case( VT_UI1 ):
1392                         res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) );
1393                         break;
1394                 case( VT_UI2 ):
1395                         res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) );
1396                         break;
1397                 case( VT_UINT ):
1398                 case( VT_UI4 ):
1399                         res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) );
1400                         break;
1401                 case( VT_R4 ):
1402                     res = VariantCopy( pd, ps );
1403                     break;
1404                 case( VT_R8 ):
1405                         res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) );
1406                         break;
1407                 case( VT_DATE ):
1408                         res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) );
1409                         break;
1410                 case( VT_BOOL ):
1411                         res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) );
1412                         break;
1413                 case( VT_BSTR ):
1414                         res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) );
1415                         break;
1416                 case( VT_CY ):
1417                         res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) );
1418                         break;
1419                 case( VT_ERROR ):
1420                         V_UNION(pd,fltVal) = V_UNION(ps,scode);
1421                         res = S_OK;
1422                         break;
1423                 case( VT_DISPATCH ):
1424                         /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/
1425                 case( VT_DECIMAL ):
1426                         /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/
1427                 case( VT_UNKNOWN ):
1428                 default:
1429                         res = DISP_E_TYPEMISMATCH;
1430                         FIXME("Coercion from %d to VT_R4\n", vtFrom);
1431                         break;
1432                 }
1433                 break;
1434
1435         case( VT_R8 ):
1436                 switch( vtFrom )
1437                 {
1438                 case( VT_I1 ):
1439                         res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) );
1440                         break;
1441                 case( VT_I2 ):
1442                         res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) );
1443                         break;
1444                 case( VT_INT ):
1445                 case( VT_I4 ):
1446                         res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) );
1447                         break;
1448                 case( VT_UI1 ):
1449                         res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) );
1450                         break;
1451                 case( VT_UI2 ):
1452                         res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) );
1453                         break;
1454                 case( VT_UINT ):
1455                 case( VT_UI4 ):
1456                         res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) );
1457                         break;
1458                 case( VT_R4 ):
1459                         res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) );
1460                         break;
1461         case( VT_R8 ):
1462             res = VariantCopy( pd, ps );
1463             break;
1464                 case( VT_DATE ):
1465                         res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) );
1466                         break;
1467                 case( VT_BOOL ):
1468                         res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) );
1469                         break;
1470                 case( VT_BSTR ):
1471                         res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) );
1472                         break;
1473                 case( VT_CY ):
1474                         res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) );
1475                         break;
1476                 case( VT_DISPATCH ):
1477                         /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/
1478                 case( VT_DECIMAL ):
1479                         /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/
1480                 case( VT_UNKNOWN ):
1481                 default:
1482                         res = DISP_E_TYPEMISMATCH;
1483                         FIXME("Coercion from %d to VT_R8\n", vtFrom);
1484                         break;
1485                 }
1486                 break;
1487
1488         case( VT_DATE ):
1489                 switch( vtFrom )
1490                 {
1491                 case( VT_I1 ):
1492                         res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) );
1493                         break;
1494                 case( VT_I2 ):
1495                         res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) );
1496                         break;
1497                 case( VT_INT ):
1498                         res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) );
1499                         break;
1500                 case( VT_I4 ):
1501                         res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) );
1502                         break;
1503                 case( VT_UI1 ):
1504                         res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) );
1505                         break;
1506                 case( VT_UI2 ):
1507                         res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) );
1508                         break;
1509                 case( VT_UINT ):
1510                         res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) );
1511                         break;
1512                 case( VT_UI4 ):
1513                         res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) );
1514                         break;
1515                 case( VT_R4 ):
1516                         res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) );
1517                         break;
1518                 case( VT_R8 ):
1519                         res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) );
1520                         break;
1521                 case( VT_BOOL ):
1522                         res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) );
1523                         break;
1524                 case( VT_BSTR ):
1525                         res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) );
1526                         break;
1527                 case( VT_CY ):
1528                         res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) );
1529                         break;
1530                 case( VT_DISPATCH ):
1531                         /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/
1532                 case( VT_DECIMAL ):
1533                         /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/
1534                 case( VT_UNKNOWN ):
1535                 default:
1536                         res = DISP_E_TYPEMISMATCH;
1537                         FIXME("Coercion from %d to VT_DATE\n", vtFrom);
1538                         break;
1539                 }
1540                 break;
1541
1542         case( VT_BOOL ):
1543                 switch( vtFrom )
1544                 {
1545                 case( VT_NULL ):
1546                 case( VT_EMPTY ):
1547                         res = S_OK;
1548                         V_UNION(pd,boolVal) = VARIANT_FALSE;
1549                         break;
1550                 case( VT_I1 ):
1551                         res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
1552                         break;
1553                 case( VT_I2 ):
1554                         res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
1555                         break;
1556                 case( VT_INT ):
1557                         res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
1558                         break;
1559                 case( VT_I4 ):
1560                         res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
1561                         break;
1562                 case( VT_UI1 ):
1563                         res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
1564                         break;
1565                 case( VT_UI2 ):
1566                         res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
1567                         break;
1568                 case( VT_UINT ):
1569                         res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
1570                         break;
1571                 case( VT_UI4 ):
1572                         res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
1573                         break;
1574                 case( VT_R4 ):
1575                         res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
1576                         break;
1577                 case( VT_R8 ):
1578                         res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
1579                         break;
1580                 case( VT_DATE ):
1581                         res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
1582                         break;
1583                 case( VT_BSTR ):
1584                         res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
1585                         break;
1586                 case( VT_CY ):
1587                         res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
1588                         break;
1589                 case( VT_DISPATCH ):
1590                         /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
1591                 case( VT_DECIMAL ):
1592                         /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
1593                 case( VT_UNKNOWN ):
1594                 default:
1595                         res = DISP_E_TYPEMISMATCH;
1596                         FIXME("Coercion from %d to VT_BOOL\n", vtFrom);
1597                         break;
1598                 }
1599                 break;
1600
1601         case( VT_BSTR ):
1602                 switch( vtFrom )
1603                 {
1604                 case( VT_EMPTY ):
1605                         if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
1606                                 res = S_OK;
1607                         else
1608                                 res = E_OUTOFMEMORY;
1609                         break;
1610                 case( VT_I1 ):
1611                         res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
1612                         break;
1613                 case( VT_I2 ):
1614                         res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
1615                         break;
1616                 case( VT_INT ):
1617                         res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
1618                         break;
1619                 case( VT_I4 ):
1620                         res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
1621                         break;
1622                 case( VT_UI1 ):
1623                         res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
1624                         break;
1625                 case( VT_UI2 ):
1626                         res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
1627                         break;
1628                 case( VT_UINT ):
1629                         res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
1630                         break;
1631                 case( VT_UI4 ):
1632                         res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
1633                         break;
1634                 case( VT_R4 ):
1635                         res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
1636                         break;
1637                 case( VT_R8 ):
1638                         res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
1639                         break;
1640                 case( VT_DATE ):
1641                         res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
1642                         break;
1643                 case( VT_BOOL ):
1644                         res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
1645                         break;
1646                 case( VT_BSTR ):
1647                         res = VariantCopy( pd, ps );
1648                         break;
1649                 case( VT_CY ):
1650                         res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
1651                         break;
1652                 case( VT_DISPATCH ):
1653                         /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
1654                 case( VT_DECIMAL ):
1655                         /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
1656                 case( VT_UNKNOWN ):
1657                 default:
1658                         res = DISP_E_TYPEMISMATCH;
1659                         FIXME("Coercion from %d to VT_BSTR\n", vtFrom);
1660                         break;
1661                 }
1662                 break;
1663
1664      case( VT_CY ):
1665         switch( vtFrom )
1666           {
1667           case( VT_I1 ):
1668              res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
1669              break;
1670           case( VT_I2 ):
1671              res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
1672              break;
1673           case( VT_INT ):
1674              res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
1675              break;
1676           case( VT_I4 ):
1677              res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
1678              break;
1679           case( VT_UI1 ):
1680              res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
1681              break;
1682           case( VT_UI2 ):
1683              res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
1684              break;
1685           case( VT_UINT ):
1686              res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
1687              break;
1688           case( VT_UI4 ):
1689              res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
1690              break;
1691           case( VT_R4 ):
1692              res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
1693              break;
1694           case( VT_R8 ):
1695              res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
1696              break;
1697           case( VT_DATE ):
1698              res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
1699              break;
1700           case( VT_BOOL ):
1701              res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
1702              break;
1703           case( VT_CY ):
1704              res = VariantCopy( pd, ps );
1705              break;
1706           case( VT_BSTR ):
1707              res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
1708              break;
1709           case( VT_DISPATCH ):
1710              /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
1711           case( VT_DECIMAL ):
1712              /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
1713              break;
1714           case( VT_UNKNOWN ):
1715           default:
1716              res = DISP_E_TYPEMISMATCH;
1717              FIXME("Coercion from %d to VT_CY\n", vtFrom);
1718              break;
1719           }
1720         break;
1721
1722         case( VT_UNKNOWN ):
1723             switch (vtFrom) {
1724             case VT_DISPATCH:
1725                 if (V_DISPATCH(ps) == NULL) {
1726                         V_UNKNOWN(pd) = NULL;
1727                 } else {
1728                         res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd));
1729                 }
1730                 break;
1731             case VT_EMPTY: case VT_NULL: case VT_I2: case VT_I4:
1732             case VT_R4: case VT_R8: case VT_CY: case VT_DATE:
1733             case VT_BSTR: case VT_ERROR: case VT_BOOL:
1734             case VT_VARIANT: case VT_DECIMAL: case VT_I1: case VT_UI1:
1735             case VT_UI2: case VT_UI4: case VT_I8: case VT_UI8: case VT_INT:
1736             case VT_UINT: case VT_VOID: case VT_HRESULT: case VT_PTR:
1737             case VT_SAFEARRAY: case VT_CARRAY: case VT_USERDEFINED:
1738             case VT_LPSTR: case VT_LPWSTR: case VT_RECORD: case VT_FILETIME:
1739             case VT_BLOB: case VT_STREAM: case VT_STORAGE:
1740             case VT_STREAMED_OBJECT: case VT_STORED_OBJECT: case VT_BLOB_OBJECT:
1741             case VT_CF: case VT_CLSID:
1742                 res = DISP_E_TYPEMISMATCH;
1743                 break;
1744             default:
1745                 FIXME("Coercion from %d to VT_UNKNOWN unhandled.\n", vtFrom);
1746                 res = DISP_E_BADVARTYPE;
1747                 break;
1748             }
1749             break;
1750
1751         case( VT_DISPATCH ):
1752             switch (vtFrom) {
1753             case VT_UNKNOWN:
1754                 if (V_UNION(ps,punkVal) == NULL) {
1755                         V_UNION(pd,pdispVal) = NULL;
1756                 } else {
1757                         res = IUnknown_QueryInterface(V_UNION(ps,punkVal), &IID_IDispatch, (LPVOID*)&V_UNION(pd,pdispVal));
1758                 }
1759                 break;
1760             case VT_EMPTY: case VT_NULL: case VT_I2: case VT_I4:
1761             case VT_R4: case VT_R8: case VT_CY: case VT_DATE:
1762             case VT_BSTR: case VT_ERROR: case VT_BOOL:
1763             case VT_VARIANT: case VT_DECIMAL: case VT_I1: case VT_UI1:
1764             case VT_UI2: case VT_UI4: case VT_I8: case VT_UI8: case VT_INT:
1765            case VT_UINT: case VT_VOID: case VT_HRESULT:
1766             case VT_SAFEARRAY: case VT_CARRAY: case VT_USERDEFINED:
1767             case VT_LPSTR: case VT_LPWSTR: case VT_RECORD: case VT_FILETIME:
1768             case VT_BLOB: case VT_STREAM: case VT_STORAGE:
1769             case VT_STREAMED_OBJECT: case VT_STORED_OBJECT: case VT_BLOB_OBJECT:
1770             case VT_CF: case VT_CLSID:
1771                 res = DISP_E_TYPEMISMATCH;
1772                 break;
1773            case VT_PTR:
1774                V_UNION(pd,pdispVal) = V_UNION(ps,pdispVal);
1775                break;
1776             default:
1777                 FIXME("Coercion from %d to VT_DISPATCH unhandled.\n", vtFrom);
1778                 res = DISP_E_BADVARTYPE;
1779                 break;
1780             }
1781             break;
1782
1783         default:
1784                 res = DISP_E_TYPEMISMATCH;
1785                 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1786                 break;
1787         }
1788
1789         return res;
1790 }
1791
1792 /******************************************************************************
1793  *              ValidateVtRange [INTERNAL]
1794  *
1795  * Used internally by the hi-level Variant API to determine
1796  * if the vartypes are valid.
1797  */
1798 static HRESULT WINAPI ValidateVtRange( VARTYPE vt )
1799 {
1800     /* if by value we must make sure it is in the
1801      * range of the valid types.
1802      */
1803     if( ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1804     {
1805         return DISP_E_BADVARTYPE;
1806     }
1807     return S_OK;
1808 }
1809
1810
1811 /******************************************************************************
1812  *              ValidateVartype [INTERNAL]
1813  *
1814  * Used internally by the hi-level Variant API to determine
1815  * if the vartypes are valid.
1816  */
1817 static HRESULT WINAPI ValidateVariantType( VARTYPE vt )
1818 {
1819         HRESULT res = S_OK;
1820
1821         /* check if we have a valid argument.
1822          */
1823         if( vt & VT_BYREF )
1824     {
1825         /* if by reference check that the type is in
1826          * the valid range and that it is not of empty or null type
1827          */
1828         if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1829             ( vt & VT_TYPEMASK ) == VT_NULL ||
1830                         ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1831                 {
1832                         res = DISP_E_BADVARTYPE;
1833                 }
1834
1835     }
1836     else
1837     {
1838         res = ValidateVtRange( vt );
1839     }
1840
1841         return res;
1842 }
1843
1844 /******************************************************************************
1845  *              ValidateVt      [INTERNAL]
1846  *
1847  * Used internally by the hi-level Variant API to determine
1848  * if the vartypes are valid.
1849  */
1850 static HRESULT WINAPI ValidateVt( VARTYPE vt )
1851 {
1852         HRESULT res = S_OK;
1853
1854         /* check if we have a valid argument.
1855          */
1856         if( vt & VT_BYREF )
1857     {
1858         /* if by reference check that the type is in
1859          * the valid range and that it is not of empty or null type
1860          */
1861         if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1862             ( vt & VT_TYPEMASK ) == VT_NULL ||
1863                         ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1864                 {
1865                         res = DISP_E_BADVARTYPE;
1866                 }
1867
1868     }
1869     else
1870     {
1871         res = ValidateVtRange( vt );
1872     }
1873
1874         return res;
1875 }
1876
1877
1878
1879
1880
1881 /******************************************************************************
1882  *              VariantInit     [OLEAUT32.8]
1883  *
1884  * Initializes the Variant.  Unlike VariantClear it does not interpret
1885  * the current contents of the Variant.
1886  */
1887 void WINAPI VariantInit(VARIANTARG* pvarg)
1888 {
1889   TRACE("(%p)\n",pvarg);
1890
1891   memset(pvarg, 0, sizeof (VARIANTARG));
1892   V_VT(pvarg) = VT_EMPTY;
1893
1894   return;
1895 }
1896
1897 /******************************************************************************
1898  *              VariantClear    [OLEAUT32.9]
1899  *
1900  * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
1901  * sets the wReservedX field to 0.      The current contents of the VARIANT are
1902  * freed.  If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
1903  * released. If VT_ARRAY the array is freed.
1904  */
1905 HRESULT WINAPI VariantClear(VARIANTARG* pvarg)
1906 {
1907   HRESULT res = S_OK;
1908   TRACE("(%p)\n",pvarg);
1909
1910   res = ValidateVariantType( V_VT(pvarg) );
1911   if( res == S_OK )
1912   {
1913     if( !( V_VT(pvarg) & VT_BYREF ) )
1914     {
1915       /*
1916        * The VT_ARRAY flag is a special case of a safe array.
1917        */
1918       if ( (V_VT(pvarg) & VT_ARRAY) != 0)
1919       {
1920         SafeArrayDestroy(V_UNION(pvarg,parray));
1921       }
1922       else
1923       {
1924         switch( V_VT(pvarg) & VT_TYPEMASK )
1925         {
1926           case( VT_BSTR ):
1927             SysFreeString( V_UNION(pvarg,bstrVal) );
1928             break;
1929           case( VT_DISPATCH ):
1930             if(V_UNION(pvarg,pdispVal)!=NULL)
1931               IDispatch_Release(V_UNION(pvarg,pdispVal));
1932             break;
1933           case( VT_VARIANT ):
1934             VariantClear(V_UNION(pvarg,pvarVal));
1935             break;
1936           case( VT_UNKNOWN ):
1937             if(V_UNION(pvarg,punkVal)!=NULL)
1938               IUnknown_Release(V_UNION(pvarg,punkVal));
1939             break;
1940           case( VT_SAFEARRAY ):
1941             SafeArrayDestroy(V_UNION(pvarg,parray));
1942             break;
1943           default:
1944             break;
1945         }
1946       }
1947     }
1948
1949     /*
1950      * Empty all the fields and mark the type as empty.
1951      */
1952     memset(pvarg, 0, sizeof (VARIANTARG));
1953     V_VT(pvarg) = VT_EMPTY;
1954   }
1955
1956   return res;
1957 }
1958
1959 /******************************************************************************
1960  *              VariantCopy     [OLEAUT32.10]
1961  *
1962  * Frees up the designation variant and makes a copy of the source.
1963  */
1964 HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
1965 {
1966   HRESULT res = S_OK;
1967
1968   TRACE("(%p, %p), vt=%d\n", pvargDest, pvargSrc, V_VT(pvargSrc));
1969
1970   res = ValidateVariantType( V_VT(pvargSrc) );
1971
1972   /* If the pointer are to the same variant we don't need
1973    * to do anything.
1974    */
1975   if( pvargDest != pvargSrc && res == S_OK )
1976   {
1977     VariantClear( pvargDest ); /* result is not checked */
1978
1979     if( V_VT(pvargSrc) & VT_BYREF )
1980     {
1981       /* In the case of byreference we only need
1982        * to copy the pointer.
1983        */
1984       pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
1985       V_VT(pvargDest) = V_VT(pvargSrc);
1986     }
1987     else
1988     {
1989       /*
1990        * The VT_ARRAY flag is another way to designate a safe array.
1991        */
1992       if (V_VT(pvargSrc) & VT_ARRAY)
1993       {
1994         SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
1995       }
1996       else
1997       {
1998         /* In the case of by value we need to
1999          * copy the actual value. In the case of
2000          * VT_BSTR a copy of the string is made,
2001          * if VT_DISPATCH or VT_IUNKNOWN AddRef is
2002          * called to increment the object's reference count.
2003          */
2004         switch( V_VT(pvargSrc) & VT_TYPEMASK )
2005         {
2006           case( VT_BSTR ):
2007             V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( V_UNION(pvargSrc,bstrVal) );
2008             break;
2009           case( VT_DISPATCH ):
2010             V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
2011             if (V_UNION(pvargDest,pdispVal)!=NULL)
2012               IDispatch_AddRef(V_UNION(pvargDest,pdispVal));
2013             break;
2014           case( VT_VARIANT ):
2015             VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
2016             break;
2017           case( VT_UNKNOWN ):
2018             V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
2019             if (V_UNION(pvargDest,pdispVal)!=NULL)
2020               IUnknown_AddRef(V_UNION(pvargDest,punkVal));
2021             break;
2022           case( VT_SAFEARRAY ):
2023             SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
2024             break;
2025           default:
2026             pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
2027             break;
2028         }
2029       }
2030       V_VT(pvargDest) = V_VT(pvargSrc);
2031       dump_Variant(pvargDest);
2032     }
2033   }
2034
2035   return res;
2036 }
2037
2038
2039 /******************************************************************************
2040  *              VariantCopyInd  [OLEAUT32.11]
2041  *
2042  * Frees up the destination variant and makes a copy of the source.  If
2043  * the source is of type VT_BYREF it performs the necessary indirections.
2044  */
2045 HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
2046 {
2047   HRESULT res = S_OK;
2048
2049   TRACE("(%p, %p)\n", pvargDest, pvargSrc);
2050
2051   res = ValidateVariantType( V_VT(pvargSrc) );
2052
2053   if( res != S_OK )
2054     return res;
2055
2056   if( V_VT(pvargSrc) & VT_BYREF )
2057   {
2058     VARIANTARG varg;
2059     VariantInit( &varg );
2060
2061     /* handle the in place copy.
2062      */
2063     if( pvargDest == pvargSrc )
2064     {
2065       /* we will use a copy of the source instead.
2066        */
2067       res = VariantCopy( &varg, pvargSrc );
2068       pvargSrc = &varg;
2069     }
2070
2071     if( res == S_OK )
2072     {
2073       res = VariantClear( pvargDest );
2074
2075       if( res == S_OK )
2076       {
2077         /*
2078          * The VT_ARRAY flag is another way to designate a safearray variant.
2079          */
2080         if ( V_VT(pvargSrc) & VT_ARRAY)
2081         {
2082           SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
2083         }
2084         else
2085         {
2086           /* In the case of by reference we need
2087            * to copy the date pointed to by the variant.
2088            */
2089
2090           /* Get the variant type.
2091            */
2092           switch( V_VT(pvargSrc) & VT_TYPEMASK )
2093           {
2094             case( VT_BSTR ):
2095               V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( *(V_UNION(pvargSrc,pbstrVal)) );
2096               break;
2097             case( VT_DISPATCH ):
2098               V_UNION(pvargDest,pdispVal) = *V_UNION(pvargSrc,ppdispVal);
2099               if (V_UNION(pvargDest,pdispVal)!=NULL)
2100                 IDispatch_AddRef(V_UNION(pvargDest,pdispVal));
2101               break;
2102             case( VT_VARIANT ):
2103               {
2104                 /* Prevent from cycling.  According to tests on
2105                  * VariantCopyInd in Windows and the documentation
2106                  * this API dereferences the inner Variants to only one depth.
2107                  * If the inner Variant itself contains an
2108                  * other inner variant the E_INVALIDARG error is
2109                  * returned.
2110                  */
2111                 if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
2112                 {
2113                   /* If we get here we are attempting to deference
2114                    * an inner variant that that is itself contained
2115                    * in an inner variant so report E_INVALIDARG error.
2116                    */
2117                   res = E_INVALIDARG;
2118                 }
2119                 else
2120                 {
2121                   /* Set the processing inner variant flag.
2122                    * We will set this flag in the inner variant
2123                    * that will be passed to the VariantCopyInd function.
2124                    */
2125                   (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
2126
2127                   /* Dereference the inner variant.
2128                    */
2129                   res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
2130                   /* We must also copy its type, I think.
2131                    */
2132                   V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
2133                 }
2134               }
2135               break;
2136             case( VT_UNKNOWN ):
2137               V_UNION(pvargDest,punkVal) = *V_UNION(pvargSrc,ppunkVal);
2138               if (V_UNION(pvargDest,pdispVal)!=NULL)
2139                 IUnknown_AddRef(V_UNION(pvargDest,punkVal));
2140               break;
2141             case( VT_SAFEARRAY ):
2142               SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
2143               break;
2144             default:
2145               /* This is a by reference Variant which means that the union
2146                * part of the Variant contains a pointer to some data of
2147                * type "V_VT(pvargSrc) & VT_TYPEMASK".
2148                * We will deference this data in a generic fashion using
2149                * the void pointer "Variant.u.byref".
2150                * We will copy this data into the union of the destination
2151                * Variant.
2152                */
2153               memcpy( &pvargDest->n1.n2.n3, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
2154               break;
2155           }
2156         }
2157
2158         if (res == S_OK) V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
2159       }
2160     }
2161
2162     /* this should not fail.
2163      */
2164     VariantClear( &varg );
2165   }
2166   else
2167   {
2168     res = VariantCopy( pvargDest, pvargSrc );
2169   }
2170
2171   return res;
2172 }
2173
2174 /******************************************************************************
2175  * Coerces a full safearray. Not optimal code.
2176  */
2177 static HRESULT
2178 coerce_array(
2179         VARIANTARG* src, VARIANTARG *dst, LCID lcid, USHORT wFlags, VARTYPE vt
2180 ) {
2181         SAFEARRAY       *sarr = V_ARRAY(src);
2182         HRESULT         hres;
2183         LPVOID          data;
2184         VARTYPE         vartype;
2185
2186         SafeArrayGetVartype(sarr,&vartype);
2187         switch (vt) {
2188         case VT_BSTR:
2189                 if (sarr->cDims != 1) {
2190                         FIXME("Can not coerce array with dim %d into BSTR\n", sarr->cDims);
2191                         return E_FAIL;
2192                 }
2193                 switch (V_VT(src) & VT_TYPEMASK) {
2194                 case VT_UI1:
2195                         hres = SafeArrayAccessData(sarr, &data);
2196                         if (FAILED(hres)) return hres;
2197
2198                         /* Yes, just memcpied apparently. */
2199                         V_BSTR(dst) = SysAllocStringByteLen(data, sarr->rgsabound[0].cElements);
2200                         hres = SafeArrayUnaccessData(sarr);
2201                         if (FAILED(hres)) return hres;
2202                         break;
2203                 default:
2204                         FIXME("Cannot coerce array of %d into BSTR yet. Please report!\n", V_VT(src) & VT_TYPEMASK);
2205                         return E_FAIL;
2206                 }
2207                 break;
2208         case VT_SAFEARRAY:
2209                 V_VT(dst) = VT_SAFEARRAY;
2210                 return SafeArrayCopy(sarr, &V_ARRAY(dst));
2211         default:
2212                 FIXME("Cannot coerce array of vt 0x%x/0x%x into vt 0x%x yet. Please report/implement!\n", vartype, V_VT(src), vt);
2213                 return E_FAIL;
2214         }
2215         return S_OK;
2216 }
2217
2218 /******************************************************************************
2219  *              VariantChangeType       [OLEAUT32.12]
2220  */
2221 HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
2222                                                         USHORT wFlags, VARTYPE vt)
2223 {
2224         return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
2225 }
2226
2227 /******************************************************************************
2228  *              VariantChangeTypeEx     [OLEAUT32.147]
2229  */
2230 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
2231                                                           LCID lcid, USHORT wFlags, VARTYPE vt)
2232 {
2233         HRESULT res = S_OK;
2234         VARIANTARG varg;
2235         VariantInit( &varg );
2236
2237         TRACE("(%p, %p, %ld, %u, %u) vt=%d\n", pvargDest, pvargSrc, lcid, wFlags, vt, V_VT(pvargSrc));
2238     TRACE("Src Var:\n");
2239     dump_Variant(pvargSrc);
2240
2241         /* validate our source argument.
2242          */
2243         res = ValidateVariantType( V_VT(pvargSrc) );
2244
2245         /* validate the vartype.
2246          */
2247         if( res == S_OK )
2248         {
2249                 res = ValidateVt( vt );
2250         }
2251
2252         /* if we are doing an in-place conversion make a copy of the source.
2253          */
2254         if( res == S_OK && pvargDest == pvargSrc )
2255         {
2256                 res = VariantCopy( &varg, pvargSrc );
2257                 pvargSrc = &varg;
2258         }
2259
2260         if( res == S_OK )
2261         {
2262                 /* free up the destination variant.
2263                  */
2264                 res = VariantClear( pvargDest );
2265         }
2266
2267         if( res == S_OK )
2268         {
2269                 if( V_VT(pvargSrc) & VT_BYREF )
2270                 {
2271                         /* Convert the source variant to a "byvalue" variant.
2272                          */
2273                         VARIANTARG Variant;
2274
2275                         if ((V_VT(pvargSrc) & 0xf000) != VT_BYREF) {
2276                                 FIXME("VT_TYPEMASK %x is unhandled.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2277                                 return E_FAIL;
2278                         }
2279
2280                         VariantInit( &Variant );
2281                         res = VariantCopyInd( &Variant, pvargSrc );
2282                         if( res == S_OK )
2283                         {
2284                                 res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
2285                                 /* this should not fail.
2286                                  */
2287                                 VariantClear( &Variant );
2288                         }
2289                 } else {
2290                         if (V_VT(pvargSrc) & VT_ARRAY) {
2291                                 if ((V_VT(pvargSrc) & 0xf000) != VT_ARRAY) {
2292                                         FIXME("VT_TYPEMASK %x is unhandled in VT_ARRAY.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2293                                         return E_FAIL;
2294                                 }
2295                                 V_VT(pvargDest) = VT_ARRAY | vt;
2296                                 res = coerce_array(pvargSrc, pvargDest, lcid, wFlags, vt);
2297                         } else {
2298                                 if ((V_VT(pvargSrc) & 0xf000)) {
2299                                         FIXME("VT_TYPEMASK %x is unhandled in normal case.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2300                                         return E_FAIL;
2301                                 }
2302                                 /* Use the current "byvalue" source variant.
2303                                  */
2304                                 res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
2305                         }
2306                 }
2307         }
2308         /* this should not fail.
2309          */
2310         VariantClear( &varg );
2311
2312         /* set the type of the destination
2313          */
2314         if ( res == S_OK )
2315                 V_VT(pvargDest) = vt;
2316
2317     TRACE("Dest Var:\n");
2318     dump_Variant(pvargDest);
2319
2320         return res;
2321 }
2322
2323
2324
2325
2326 /******************************************************************************
2327  *              VarUI1FromI2            [OLEAUT32.130]
2328  */
2329 HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut)
2330 {
2331         TRACE("( %d, %p ), stub\n", sIn, pbOut );
2332
2333         /* Check range of value.
2334          */
2335         if( sIn < UI1_MIN || sIn > UI1_MAX )
2336         {
2337                 return DISP_E_OVERFLOW;
2338         }
2339
2340         *pbOut = (BYTE) sIn;
2341
2342         return S_OK;
2343 }
2344
2345 /******************************************************************************
2346  *              VarUI1FromI4            [OLEAUT32.131]
2347  */
2348 HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut)
2349 {
2350         TRACE("( %ld, %p ), stub\n", lIn, pbOut );
2351
2352         /* Check range of value.
2353          */
2354         if( lIn < UI1_MIN || lIn > UI1_MAX )
2355         {
2356                 return DISP_E_OVERFLOW;
2357         }
2358
2359         *pbOut = (BYTE) lIn;
2360
2361         return S_OK;
2362 }
2363
2364
2365 /******************************************************************************
2366  *              VarUI1FromR4            [OLEAUT32.132]
2367  */
2368 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
2369 {
2370         TRACE("( %f, %p ), stub\n", fltIn, pbOut );
2371
2372         /* Check range of value.
2373      */
2374     fltIn = round( fltIn );
2375         if( fltIn < UI1_MIN || fltIn > UI1_MAX )
2376         {
2377                 return DISP_E_OVERFLOW;
2378         }
2379
2380         *pbOut = (BYTE) fltIn;
2381
2382         return S_OK;
2383 }
2384
2385 /******************************************************************************
2386  *              VarUI1FromR8            [OLEAUT32.133]
2387  */
2388 HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
2389 {
2390         TRACE("( %f, %p ), stub\n", dblIn, pbOut );
2391
2392         /* Check range of value.
2393      */
2394     dblIn = round( dblIn );
2395         if( dblIn < UI1_MIN || dblIn > UI1_MAX )
2396         {
2397                 return DISP_E_OVERFLOW;
2398         }
2399
2400         *pbOut = (BYTE) dblIn;
2401
2402         return S_OK;
2403 }
2404
2405 /******************************************************************************
2406  *              VarUI1FromDate          [OLEAUT32.135]
2407  */
2408 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
2409 {
2410         TRACE("( %f, %p ), stub\n", dateIn, pbOut );
2411
2412         /* Check range of value.
2413      */
2414     dateIn = round( dateIn );
2415         if( dateIn < UI1_MIN || dateIn > UI1_MAX )
2416         {
2417                 return DISP_E_OVERFLOW;
2418         }
2419
2420         *pbOut = (BYTE) dateIn;
2421
2422         return S_OK;
2423 }
2424
2425 /******************************************************************************
2426  *              VarUI1FromBool          [OLEAUT32.138]
2427  */
2428 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
2429 {
2430         TRACE("( %d, %p ), stub\n", boolIn, pbOut );
2431
2432         *pbOut = (BYTE) boolIn;
2433
2434         return S_OK;
2435 }
2436
2437 /******************************************************************************
2438  *              VarUI1FromI1            [OLEAUT32.237]
2439  */
2440 HRESULT WINAPI VarUI1FromI1(signed char cIn, BYTE* pbOut)
2441 {
2442         TRACE("( %c, %p ), stub\n", cIn, pbOut );
2443
2444         *pbOut = cIn;
2445
2446         return S_OK;
2447 }
2448
2449 /******************************************************************************
2450  *              VarUI1FromUI2           [OLEAUT32.238]
2451  */
2452 HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut)
2453 {
2454         TRACE("( %d, %p ), stub\n", uiIn, pbOut );
2455
2456         /* Check range of value.
2457          */
2458         if( uiIn > UI1_MAX )
2459         {
2460                 return DISP_E_OVERFLOW;
2461         }
2462
2463         *pbOut = (BYTE) uiIn;
2464
2465         return S_OK;
2466 }
2467
2468 /******************************************************************************
2469  *              VarUI1FromUI4           [OLEAUT32.239]
2470  */
2471 HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
2472 {
2473         TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
2474
2475         /* Check range of value.
2476          */
2477         if( ulIn > UI1_MAX )
2478         {
2479                 return DISP_E_OVERFLOW;
2480         }
2481
2482         *pbOut = (BYTE) ulIn;
2483
2484         return S_OK;
2485 }
2486
2487
2488 /******************************************************************************
2489  *              VarUI1FromStr           [OLEAUT32.136]
2490  */
2491 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
2492 {
2493         double dValue = 0.0;
2494         LPSTR pNewString = NULL;
2495
2496         TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
2497
2498         /* Check if we have a valid argument
2499          */
2500         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2501         RemoveCharacterFromString( pNewString, "," );
2502         if( IsValidRealString( pNewString ) == FALSE )
2503         {
2504                 return DISP_E_TYPEMISMATCH;
2505         }
2506
2507         /* Convert the valid string to a floating point number.
2508          */
2509         dValue = atof( pNewString );
2510
2511         /* We don't need the string anymore so free it.
2512          */
2513         HeapFree( GetProcessHeap(), 0 , pNewString );
2514
2515         /* Check range of value.
2516      */
2517     dValue = round( dValue );
2518         if( dValue < UI1_MIN || dValue > UI1_MAX )
2519         {
2520                 return DISP_E_OVERFLOW;
2521         }
2522
2523         *pbOut = (BYTE) dValue;
2524
2525         return S_OK;
2526 }
2527
2528 /**********************************************************************
2529  *              VarUI1FromCy [OLEAUT32.134]
2530  * Convert currency to unsigned char
2531  */
2532 HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
2533    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2534
2535    if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
2536
2537    *pbOut = (BYTE)t;
2538    return S_OK;
2539 }
2540
2541 /******************************************************************************
2542  *              VarI2FromUI1            [OLEAUT32.48]
2543  */
2544 HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut)
2545 {
2546         TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
2547
2548         *psOut = (short) bIn;
2549
2550         return S_OK;
2551 }
2552
2553 /******************************************************************************
2554  *              VarI2FromI4             [OLEAUT32.49]
2555  */
2556 HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut)
2557 {
2558         TRACE("( %lx, %p ), stub\n", lIn, psOut );
2559
2560         /* Check range of value.
2561          */
2562         if( lIn < I2_MIN || lIn > I2_MAX )
2563         {
2564                 return DISP_E_OVERFLOW;
2565         }
2566
2567         *psOut = (short) lIn;
2568
2569         return S_OK;
2570 }
2571
2572 /******************************************************************************
2573  *              VarI2FromR4             [OLEAUT32.50]
2574  */
2575 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut)
2576 {
2577         TRACE("( %f, %p ), stub\n", fltIn, psOut );
2578
2579         /* Check range of value.
2580      */
2581     fltIn = round( fltIn );
2582         if( fltIn < I2_MIN || fltIn > I2_MAX )
2583         {
2584                 return DISP_E_OVERFLOW;
2585         }
2586
2587         *psOut = (short) fltIn;
2588
2589         return S_OK;
2590 }
2591
2592 /******************************************************************************
2593  *              VarI2FromR8             [OLEAUT32.51]
2594  */
2595 HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut)
2596 {
2597         TRACE("( %f, %p ), stub\n", dblIn, psOut );
2598
2599         /* Check range of value.
2600      */
2601     dblIn = round( dblIn );
2602         if( dblIn < I2_MIN || dblIn > I2_MAX )
2603         {
2604                 return DISP_E_OVERFLOW;
2605         }
2606
2607         *psOut = (short) dblIn;
2608
2609         return S_OK;
2610 }
2611
2612 /******************************************************************************
2613  *              VarI2FromDate           [OLEAUT32.53]
2614  */
2615 HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut)
2616 {
2617         TRACE("( %f, %p ), stub\n", dateIn, psOut );
2618
2619         /* Check range of value.
2620      */
2621     dateIn = round( dateIn );
2622         if( dateIn < I2_MIN || dateIn > I2_MAX )
2623         {
2624                 return DISP_E_OVERFLOW;
2625         }
2626
2627         *psOut = (short) dateIn;
2628
2629         return S_OK;
2630 }
2631
2632 /******************************************************************************
2633  *              VarI2FromBool           [OLEAUT32.56]
2634  */
2635 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut)
2636 {
2637         TRACE("( %d, %p ), stub\n", boolIn, psOut );
2638
2639         *psOut = (short) boolIn;
2640
2641         return S_OK;
2642 }
2643
2644 /******************************************************************************
2645  *              VarI2FromI1             [OLEAUT32.205]
2646  */
2647 HRESULT WINAPI VarI2FromI1(signed char cIn, short* psOut)
2648 {
2649         TRACE("( %c, %p ), stub\n", cIn, psOut );
2650
2651         *psOut = (short) cIn;
2652
2653         return S_OK;
2654 }
2655
2656 /******************************************************************************
2657  *              VarI2FromUI2            [OLEAUT32.206]
2658  */
2659 HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut)
2660 {
2661         TRACE("( %d, %p ), stub\n", uiIn, psOut );
2662
2663         /* Check range of value.
2664          */
2665         if( uiIn > I2_MAX )
2666         {
2667                 return DISP_E_OVERFLOW;
2668         }
2669
2670         *psOut = (short) uiIn;
2671
2672         return S_OK;
2673 }
2674
2675 /******************************************************************************
2676  *              VarI2FromUI4            [OLEAUT32.207]
2677  */
2678 HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
2679 {
2680         TRACE("( %lx, %p ), stub\n", ulIn, psOut );
2681
2682         /* Check range of value.
2683          */
2684         if( ulIn < I2_MIN || ulIn > I2_MAX )
2685         {
2686                 return DISP_E_OVERFLOW;
2687         }
2688
2689         *psOut = (short) ulIn;
2690
2691         return S_OK;
2692 }
2693
2694 /******************************************************************************
2695  *              VarI2FromStr            [OLEAUT32.54]
2696  */
2697 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut)
2698 {
2699         double dValue = 0.0;
2700         LPSTR pNewString = NULL;
2701
2702         TRACE("( %s, 0x%08lx, 0x%08lx, %p ), stub\n", debugstr_w(strIn), lcid, dwFlags, psOut );
2703
2704         /* Check if we have a valid argument
2705          */
2706         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2707         RemoveCharacterFromString( pNewString, "," );
2708         if( IsValidRealString( pNewString ) == FALSE )
2709         {
2710                 return DISP_E_TYPEMISMATCH;
2711         }
2712
2713         /* Convert the valid string to a floating point number.
2714          */
2715         dValue = atof( pNewString );
2716
2717         /* We don't need the string anymore so free it.
2718          */
2719         HeapFree( GetProcessHeap(), 0, pNewString );
2720
2721         /* Check range of value.
2722      */
2723     dValue = round( dValue );
2724         if( dValue < I2_MIN || dValue > I2_MAX )
2725         {
2726                 return DISP_E_OVERFLOW;
2727         }
2728
2729         *psOut = (short)  dValue;
2730
2731         return S_OK;
2732 }
2733
2734 /**********************************************************************
2735  *              VarI2FromCy [OLEAUT32.52]
2736  * Convert currency to signed short
2737  */
2738 HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
2739    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2740
2741    if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
2742
2743    *psOut = (SHORT)t;
2744    return S_OK;
2745 }
2746
2747 /******************************************************************************
2748  *              VarI4FromUI1            [OLEAUT32.58]
2749  */
2750 HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut)
2751 {
2752         TRACE("( %X, %p ), stub\n", bIn, plOut );
2753
2754         *plOut = (LONG) bIn;
2755
2756         return S_OK;
2757 }
2758
2759
2760 /******************************************************************************
2761  *              VarI4FromR4             [OLEAUT32.60]
2762  */
2763 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut)
2764 {
2765         TRACE("( %f, %p ), stub\n", fltIn, plOut );
2766
2767         /* Check range of value.
2768      */
2769     fltIn = round( fltIn );
2770         if( fltIn < I4_MIN || fltIn > I4_MAX )
2771         {
2772                 return DISP_E_OVERFLOW;
2773         }
2774
2775         *plOut = (LONG) fltIn;
2776
2777         return S_OK;
2778 }
2779
2780 /******************************************************************************
2781  *              VarI4FromR8             [OLEAUT32.61]
2782  */
2783 HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut)
2784 {
2785         TRACE("( %f, %p ), stub\n", dblIn, plOut );
2786
2787         /* Check range of value.
2788      */
2789     dblIn = round( dblIn );
2790         if( dblIn < I4_MIN || dblIn > I4_MAX )
2791         {
2792                 return DISP_E_OVERFLOW;
2793         }
2794
2795         *plOut = (LONG) dblIn;
2796
2797         return S_OK;
2798 }
2799
2800 /******************************************************************************
2801  *              VarI4FromDate           [OLEAUT32.63]
2802  */
2803 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut)
2804 {
2805         TRACE("( %f, %p ), stub\n", dateIn, plOut );
2806
2807         /* Check range of value.
2808      */
2809     dateIn = round( dateIn );
2810         if( dateIn < I4_MIN || dateIn > I4_MAX )
2811         {
2812                 return DISP_E_OVERFLOW;
2813         }
2814
2815         *plOut = (LONG) dateIn;
2816
2817         return S_OK;
2818 }
2819
2820 /******************************************************************************
2821  *              VarI4FromBool           [OLEAUT32.66]
2822  */
2823 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut)
2824 {
2825         TRACE("( %d, %p ), stub\n", boolIn, plOut );
2826
2827         *plOut = (LONG) boolIn;
2828
2829         return S_OK;
2830 }
2831
2832 /******************************************************************************
2833  *              VarI4FromI1             [OLEAUT32.209]
2834  */
2835 HRESULT WINAPI VarI4FromI1(signed char cIn, LONG* plOut)
2836 {
2837         TRACE("( %c, %p ), stub\n", cIn, plOut );
2838
2839         *plOut = (LONG) cIn;
2840
2841         return S_OK;
2842 }
2843
2844 /******************************************************************************
2845  *              VarI4FromUI2            [OLEAUT32.210]
2846  */
2847 HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut)
2848 {
2849         TRACE("( %d, %p ), stub\n", uiIn, plOut );
2850
2851         *plOut = (LONG) uiIn;
2852
2853         return S_OK;
2854 }
2855
2856 /******************************************************************************
2857  *              VarI4FromUI4            [OLEAUT32.211]
2858  */
2859 HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut)
2860 {
2861         TRACE("( %lx, %p ), stub\n", ulIn, plOut );
2862
2863         /* Check range of value.
2864          */
2865         if( ulIn < I4_MIN || ulIn > I4_MAX )
2866         {
2867                 return DISP_E_OVERFLOW;
2868         }
2869
2870         *plOut = (LONG) ulIn;
2871
2872         return S_OK;
2873 }
2874
2875 /******************************************************************************
2876  *              VarI4FromI2             [OLEAUT32.59]
2877  */
2878 HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut)
2879 {
2880         TRACE("( %d, %p ), stub\n", sIn, plOut );
2881
2882         *plOut = (LONG) sIn;
2883
2884         return S_OK;
2885 }
2886
2887 /******************************************************************************
2888  *              VarI4FromStr            [OLEAUT32.64]
2889  */
2890 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut)
2891 {
2892         double dValue = 0.0;
2893         LPSTR pNewString = NULL;
2894
2895         TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
2896
2897         /* Check if we have a valid argument
2898          */
2899         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2900         RemoveCharacterFromString( pNewString, "," );
2901         if( IsValidRealString( pNewString ) == FALSE )
2902         {
2903                 return DISP_E_TYPEMISMATCH;
2904         }
2905
2906         /* Convert the valid string to a floating point number.
2907          */
2908         dValue = atof( pNewString );
2909
2910         /* We don't need the string anymore so free it.
2911          */
2912         HeapFree( GetProcessHeap(), 0, pNewString );
2913
2914         /* Check range of value.
2915      */
2916     dValue = round( dValue );
2917         if( dValue < I4_MIN || dValue > I4_MAX )
2918         {
2919                 return DISP_E_OVERFLOW;
2920         }
2921
2922         *plOut = (LONG) dValue;
2923
2924         return S_OK;
2925 }
2926
2927 /**********************************************************************
2928  *              VarI4FromCy [OLEAUT32.62]
2929  * Convert currency to signed long
2930  */
2931 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
2932    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2933
2934    if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
2935
2936    *plOut = (LONG)t;
2937    return S_OK;
2938 }
2939
2940 /******************************************************************************
2941  *              VarR4FromUI1            [OLEAUT32.68]
2942  */
2943 HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut)
2944 {
2945         TRACE("( %X, %p ), stub\n", bIn, pfltOut );
2946
2947         *pfltOut = (FLOAT) bIn;
2948
2949         return S_OK;
2950 }
2951
2952 /******************************************************************************
2953  *              VarR4FromI2             [OLEAUT32.69]
2954  */
2955 HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut)
2956 {
2957         TRACE("( %d, %p ), stub\n", sIn, pfltOut );
2958
2959         *pfltOut = (FLOAT) sIn;
2960
2961         return S_OK;
2962 }
2963
2964 /******************************************************************************
2965  *              VarR4FromI4             [OLEAUT32.70]
2966  */
2967 HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut)
2968 {
2969         TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
2970
2971         *pfltOut = (FLOAT) lIn;
2972
2973         return S_OK;
2974 }
2975
2976 /******************************************************************************
2977  *              VarR4FromR8             [OLEAUT32.71]
2978  */
2979 HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut)
2980 {
2981         TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
2982
2983         /* Check range of value.
2984          */
2985         if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
2986         {
2987                 return DISP_E_OVERFLOW;
2988         }
2989
2990         *pfltOut = (FLOAT) dblIn;
2991
2992         return S_OK;
2993 }
2994
2995 /******************************************************************************
2996  *              VarR4FromDate           [OLEAUT32.73]
2997  */
2998 HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut)
2999 {
3000         TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
3001
3002         /* Check range of value.
3003          */
3004         if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
3005         {
3006                 return DISP_E_OVERFLOW;
3007         }
3008
3009         *pfltOut = (FLOAT) dateIn;
3010
3011         return S_OK;
3012 }
3013
3014 /******************************************************************************
3015  *              VarR4FromBool           [OLEAUT32.76]
3016  */
3017 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut)
3018 {
3019         TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
3020
3021         *pfltOut = (FLOAT) boolIn;
3022
3023         return S_OK;
3024 }
3025
3026 /******************************************************************************
3027  *              VarR4FromI1             [OLEAUT32.213]
3028  */
3029 HRESULT WINAPI VarR4FromI1(signed char cIn, FLOAT* pfltOut)
3030 {
3031         TRACE("( %c, %p ), stub\n", cIn, pfltOut );
3032
3033         *pfltOut = (FLOAT) cIn;
3034
3035         return S_OK;
3036 }
3037
3038 /******************************************************************************
3039  *              VarR4FromUI2            [OLEAUT32.214]
3040  */
3041 HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut)
3042 {
3043         TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
3044
3045         *pfltOut = (FLOAT) uiIn;
3046
3047         return S_OK;
3048 }
3049
3050 /******************************************************************************
3051  *              VarR4FromUI4            [OLEAUT32.215]
3052  */
3053 HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut)
3054 {
3055         TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
3056
3057         *pfltOut = (FLOAT) ulIn;
3058
3059         return S_OK;
3060 }
3061
3062 /******************************************************************************
3063  *              VarR4FromStr            [OLEAUT32.74]
3064  */
3065 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut)
3066 {
3067         double dValue = 0.0;
3068         LPSTR pNewString = NULL;
3069
3070         TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
3071
3072         /* Check if we have a valid argument
3073          */
3074         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3075         RemoveCharacterFromString( pNewString, "," );
3076         if( IsValidRealString( pNewString ) == FALSE )
3077         {
3078                 return DISP_E_TYPEMISMATCH;
3079         }
3080
3081         /* Convert the valid string to a floating point number.
3082          */
3083         dValue = atof( pNewString );
3084
3085         /* We don't need the string anymore so free it.
3086          */
3087         HeapFree( GetProcessHeap(), 0, pNewString );
3088
3089         /* Check range of value.
3090          */
3091         if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
3092         {
3093                 return DISP_E_OVERFLOW;
3094         }
3095
3096         *pfltOut = (FLOAT) dValue;
3097
3098         return S_OK;
3099 }
3100
3101 /**********************************************************************
3102  *              VarR4FromCy [OLEAUT32.72]
3103  * Convert currency to float
3104  */
3105 HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
3106    *pfltOut = (FLOAT)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3107
3108    return S_OK;
3109 }
3110
3111 /******************************************************************************
3112  *              VarR8FromUI1            [OLEAUT32.78]
3113  */
3114 HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
3115 {
3116         TRACE("( %d, %p ), stub\n", bIn, pdblOut );
3117
3118         *pdblOut = (double) bIn;
3119
3120         return S_OK;
3121 }
3122
3123 /******************************************************************************
3124  *              VarR8FromI2             [OLEAUT32.79]
3125  */
3126 HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
3127 {
3128         TRACE("( %d, %p ), stub\n", sIn, pdblOut );
3129
3130         *pdblOut = (double) sIn;
3131
3132         return S_OK;
3133 }
3134
3135 /******************************************************************************
3136  *              VarR8FromI4             [OLEAUT32.80]
3137  */
3138 HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
3139 {
3140         TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
3141
3142         *pdblOut = (double) lIn;
3143
3144         return S_OK;
3145 }
3146
3147 /******************************************************************************
3148  *              VarR8FromR4             [OLEAUT32.81]
3149  */
3150 HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut)
3151 {
3152         TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
3153
3154         *pdblOut = (double) fltIn;
3155
3156         return S_OK;
3157 }
3158
3159 /******************************************************************************
3160  *              VarR8FromDate           [OLEAUT32.83]
3161  */
3162 HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut)
3163 {
3164         TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
3165
3166         *pdblOut = (double) dateIn;
3167
3168         return S_OK;
3169 }
3170
3171 /******************************************************************************
3172  *              VarR8FromBool           [OLEAUT32.86]
3173  */
3174 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut)
3175 {
3176         TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
3177
3178         *pdblOut = (double) boolIn;
3179
3180         return S_OK;
3181 }
3182
3183 /******************************************************************************
3184  *              VarR8FromI1             [OLEAUT32.217]
3185  */
3186 HRESULT WINAPI VarR8FromI1(signed char cIn, double* pdblOut)
3187 {
3188         TRACE("( %c, %p ), stub\n", cIn, pdblOut );
3189
3190         *pdblOut = (double) cIn;
3191
3192         return S_OK;
3193 }
3194
3195 /******************************************************************************
3196  *              VarR8FromUI2            [OLEAUT32.218]
3197  */
3198 HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut)
3199 {
3200         TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
3201
3202         *pdblOut = (double) uiIn;
3203
3204         return S_OK;
3205 }
3206
3207 /******************************************************************************
3208  *              VarR8FromUI4            [OLEAUT32.219]
3209  */
3210 HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut)
3211 {
3212         TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
3213
3214         *pdblOut = (double) ulIn;
3215
3216         return S_OK;
3217 }
3218
3219 /******************************************************************************
3220  *              VarR8FromStr            [OLEAUT32.84]
3221  */
3222 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut)
3223 {
3224         double dValue = 0.0;
3225         LPSTR pNewString = NULL;
3226
3227         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3228         TRACE("( %s, %ld, %ld, %p ), stub\n", pNewString, lcid, dwFlags, pdblOut );
3229
3230         /* Check if we have a valid argument
3231          */
3232         RemoveCharacterFromString( pNewString, "," );
3233         if( IsValidRealString( pNewString ) == FALSE )
3234         {
3235                 return DISP_E_TYPEMISMATCH;
3236         }
3237
3238         /* Convert the valid string to a floating point number.
3239          */
3240         dValue = atof( pNewString );
3241
3242         /* We don't need the string anymore so free it.
3243          */
3244         HeapFree( GetProcessHeap(), 0, pNewString );
3245
3246         *pdblOut = dValue;
3247
3248         return S_OK;
3249 }
3250
3251 /**********************************************************************
3252  *              VarR8FromCy [OLEAUT32.82]
3253  * Convert currency to double
3254  */
3255 HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
3256    *pdblOut = (double)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3257    TRACE("%lu %ld -> %f\n", cyIn.s.Hi, cyIn.s.Lo, *pdblOut);
3258    return S_OK;
3259 }
3260
3261 /******************************************************************************
3262  *              VarDateFromUI1          [OLEAUT32.88]
3263  */
3264 HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
3265 {
3266         TRACE("( %d, %p ), stub\n", bIn, pdateOut );
3267
3268         *pdateOut = (DATE) bIn;
3269
3270         return S_OK;
3271 }
3272
3273 /******************************************************************************
3274  *              VarDateFromI2           [OLEAUT32.89]
3275  */
3276 HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
3277 {
3278         TRACE("( %d, %p ), stub\n", sIn, pdateOut );
3279
3280         *pdateOut = (DATE) sIn;
3281
3282         return S_OK;
3283 }
3284
3285 /******************************************************************************
3286  *              VarDateFromI4           [OLEAUT32.90]
3287  */
3288 HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
3289 {
3290         TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
3291
3292         if( lIn < DATE_MIN || lIn > DATE_MAX )
3293         {
3294                 return DISP_E_OVERFLOW;
3295         }
3296
3297         *pdateOut = (DATE) lIn;
3298
3299         return S_OK;
3300 }
3301
3302 /******************************************************************************
3303  *              VarDateFromR4           [OLEAUT32.91]
3304  */
3305 HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
3306 {
3307     TRACE("( %f, %p ), stub\n", fltIn, pdateOut );
3308
3309     if( ceil(fltIn) < DATE_MIN || floor(fltIn) > DATE_MAX )
3310         {
3311                 return DISP_E_OVERFLOW;
3312         }
3313
3314         *pdateOut = (DATE) fltIn;
3315
3316         return S_OK;
3317 }
3318
3319 /******************************************************************************
3320  *              VarDateFromR8           [OLEAUT32.92]
3321  */
3322 HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
3323 {
3324     TRACE("( %f, %p ), stub\n", dblIn, pdateOut );
3325
3326         if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
3327         {
3328                 return DISP_E_OVERFLOW;
3329         }
3330
3331         *pdateOut = (DATE) dblIn;
3332
3333         return S_OK;
3334 }
3335
3336 /******************************************************************************
3337  *              VarDateFromStr          [OLEAUT32.94]
3338  * The string representing the date is composed of two parts, a date and time.
3339  *
3340  * The format of the time is has follows:
3341  * hh[:mm][:ss][AM|PM]
3342  * Whitespace can be inserted anywhere between these tokens.  A whitespace consists
3343  * of space and/or tab characters, which are ignored.
3344  *
3345  * The formats for the date part are has follows:
3346  * mm/[dd/][yy]yy
3347  * [dd/]mm/[yy]yy
3348  * [yy]yy/mm/dd
3349  * January dd[,] [yy]yy
3350  * dd January [yy]yy
3351  * [yy]yy January dd
3352  * Whitespace can be inserted anywhere between these tokens.
3353  *
3354  * The formats for the date and time string are has follows.
3355  * date[whitespace][time]
3356  * [time][whitespace]date
3357  *
3358  * These are the only characters allowed in a string representing a date and time:
3359  * [A-Z] [a-z] [0-9] ':' '-' '/' ',' ' ' '\t'
3360  */
3361 HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
3362 {
3363     HRESULT ret = S_OK;
3364     struct tm TM;
3365
3366     memset( &TM, 0, sizeof(TM) );
3367
3368     TRACE("( %p, %lx, %lx, %p ), stub\n", strIn, lcid, dwFlags, pdateOut );
3369
3370     if( DateTimeStringToTm( strIn, dwFlags, &TM ) )
3371     {
3372         if( TmToDATE( &TM, pdateOut ) == FALSE )
3373         {
3374             ret = E_INVALIDARG;
3375         }
3376     }
3377     else
3378     {
3379         ret = DISP_E_TYPEMISMATCH;
3380     }
3381     TRACE("Return value %f\n", *pdateOut);
3382         return ret;
3383 }
3384
3385 /******************************************************************************
3386  *              VarDateFromI1           [OLEAUT32.221]
3387  */
3388 HRESULT WINAPI VarDateFromI1(signed char cIn, DATE* pdateOut)
3389 {
3390         TRACE("( %c, %p ), stub\n", cIn, pdateOut );
3391
3392         *pdateOut = (DATE) cIn;
3393
3394         return S_OK;
3395 }
3396
3397 /******************************************************************************
3398  *              VarDateFromUI2          [OLEAUT32.222]
3399  */
3400 HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
3401 {
3402         TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
3403
3404         if( uiIn > DATE_MAX )
3405         {
3406                 return DISP_E_OVERFLOW;
3407         }
3408
3409         *pdateOut = (DATE) uiIn;
3410
3411         return S_OK;
3412 }
3413
3414 /******************************************************************************
3415  *              VarDateFromUI4          [OLEAUT32.223]
3416  */
3417 HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
3418 {
3419         TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
3420
3421         if( ulIn < DATE_MIN || ulIn > DATE_MAX )
3422         {
3423                 return DISP_E_OVERFLOW;
3424         }
3425
3426         *pdateOut = (DATE) ulIn;
3427
3428         return S_OK;
3429 }
3430
3431 /******************************************************************************
3432  *              VarDateFromBool         [OLEAUT32.96]
3433  */
3434 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
3435 {
3436         TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
3437
3438         *pdateOut = (DATE) boolIn;
3439
3440         return S_OK;
3441 }
3442
3443 /**********************************************************************
3444  *              VarDateFromCy [OLEAUT32.93]
3445  * Convert currency to date
3446  */
3447 HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut) {
3448    *pdateOut = (DATE)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3449
3450    if (*pdateOut > DATE_MAX || *pdateOut < DATE_MIN) return DISP_E_TYPEMISMATCH;
3451    return S_OK;
3452 }
3453
3454 /******************************************************************************
3455  *              VarBstrFromUI1          [OLEAUT32.108]
3456  */
3457 HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3458 {
3459         TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
3460         sprintf( pBuffer, "%d", bVal );
3461
3462         *pbstrOut =  StringDupAtoBstr( pBuffer );
3463
3464         return S_OK;
3465 }
3466
3467 /******************************************************************************
3468  *              VarBstrFromI2           [OLEAUT32.109]
3469  */
3470 HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3471 {
3472         TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
3473         sprintf( pBuffer, "%d", iVal );
3474         *pbstrOut = StringDupAtoBstr( pBuffer );
3475
3476         return S_OK;
3477 }
3478
3479 /******************************************************************************
3480  *              VarBstrFromI4           [OLEAUT32.110]
3481  */
3482 HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3483 {
3484         TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
3485
3486         sprintf( pBuffer, "%ld", lIn );
3487         *pbstrOut = StringDupAtoBstr( pBuffer );
3488
3489         return S_OK;
3490 }
3491
3492 /******************************************************************************
3493  *              VarBstrFromR4           [OLEAUT32.111]
3494  */
3495 HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3496 {
3497         TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
3498
3499         sprintf( pBuffer, "%.7G", fltIn );
3500         *pbstrOut = StringDupAtoBstr( pBuffer );
3501
3502         return S_OK;
3503 }
3504
3505 /******************************************************************************
3506  *              VarBstrFromR8           [OLEAUT32.112]
3507  */
3508 HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3509 {
3510         TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
3511
3512         sprintf( pBuffer, "%.15G", dblIn );
3513         *pbstrOut = StringDupAtoBstr( pBuffer );
3514
3515         return S_OK;
3516 }
3517
3518 /******************************************************************************
3519  *    VarBstrFromCy   [OLEAUT32.113]
3520  */
3521 HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut) {
3522     HRESULT rc = S_OK;
3523     double curVal = 0.0;
3524
3525         TRACE("([cyIn], %08lx, %08lx, %p), partial stub (no flags handled).\n", lcid, dwFlags, pbstrOut);
3526
3527     /* Firstly get the currency in a double, then put it in a buffer */
3528     rc = VarR8FromCy(cyIn, &curVal);
3529     if (rc == S_OK) {
3530         sprintf(pBuffer, "%G", curVal);
3531         *pbstrOut = StringDupAtoBstr( pBuffer );
3532     }
3533         return rc;
3534 }
3535
3536
3537 /******************************************************************************
3538  *              VarBstrFromDate         [OLEAUT32.114]
3539  *
3540  * The date is implemented using an 8 byte floating-point number.
3541  * Days are represented by whole numbers increments starting with 0.00 as
3542  * being December 30 1899, midnight.
3543  * The hours are expressed as the fractional part of the number.
3544  * December 30 1899 at midnight = 0.00
3545  * January 1 1900 at midnight = 2.00
3546  * January 4 1900 at 6 AM = 5.25
3547  * January 4 1900 at noon = 5.50
3548  * December 29 1899 at midnight = -1.00
3549  * December 18 1899 at midnight = -12.00
3550  * December 18 1899 at 6AM = -12.25
3551  * December 18 1899 at 6PM = -12.75
3552  * December 19 1899 at midnight = -11.00
3553  * The tm structure is as follows:
3554  * struct tm {
3555  *                int tm_sec;      seconds after the minute - [0,59]
3556  *                int tm_min;      minutes after the hour - [0,59]
3557  *                int tm_hour;     hours since midnight - [0,23]
3558  *                int tm_mday;     day of the month - [1,31]
3559  *                int tm_mon;      months since January - [0,11]
3560  *                int tm_year;     years
3561  *                int tm_wday;     days since Sunday - [0,6]
3562  *                int tm_yday;     days since January 1 - [0,365]
3563  *                int tm_isdst;    daylight savings time flag
3564  *                };
3565  */
3566 HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3567 {
3568     struct tm TM;
3569     memset( &TM, 0, sizeof(TM) );
3570
3571     TRACE("( %20.20f, %ld, %ld, %p ), stub\n", dateIn, lcid, dwFlags, pbstrOut );
3572
3573     if( DateToTm( dateIn, dwFlags, &TM ) == FALSE )
3574                         {
3575         return E_INVALIDARG;
3576                 }
3577
3578     if( dwFlags & VAR_DATEVALUEONLY )
3579                         strftime( pBuffer, BUFFER_MAX, "%x", &TM );
3580     else if( dwFlags & VAR_TIMEVALUEONLY )
3581                         strftime( pBuffer, BUFFER_MAX, "%X", &TM );
3582                 else
3583         strftime( pBuffer, BUFFER_MAX, "%x %X", &TM );
3584
3585         TRACE("result: %s\n", pBuffer);
3586                 *pbstrOut = StringDupAtoBstr( pBuffer );
3587         return S_OK;
3588 }
3589
3590 /******************************************************************************
3591  *              VarBstrFromBool         [OLEAUT32.116]
3592  */
3593 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3594 {
3595         TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
3596
3597         sprintf( pBuffer, (boolIn == VARIANT_FALSE) ? "False" : "True" );
3598
3599         *pbstrOut = StringDupAtoBstr( pBuffer );
3600
3601         return S_OK;
3602 }
3603
3604 /******************************************************************************
3605  *              VarBstrFromI1           [OLEAUT32.229]
3606  */
3607 HRESULT WINAPI VarBstrFromI1(signed char cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3608 {
3609         TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
3610         sprintf( pBuffer, "%d", cIn );
3611         *pbstrOut = StringDupAtoBstr( pBuffer );
3612
3613         return S_OK;
3614 }
3615
3616 /******************************************************************************
3617  *              VarBstrFromUI2          [OLEAUT32.230]
3618  */
3619 HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3620 {
3621         TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
3622         sprintf( pBuffer, "%d", uiIn );
3623         *pbstrOut = StringDupAtoBstr( pBuffer );
3624
3625         return S_OK;
3626 }
3627
3628 /******************************************************************************
3629  *              VarBstrFromUI4          [OLEAUT32.231]
3630  */
3631 HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3632 {
3633         TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
3634         sprintf( pBuffer, "%ld", ulIn );
3635         *pbstrOut = StringDupAtoBstr( pBuffer );
3636
3637         return S_OK;
3638 }
3639
3640 /******************************************************************************
3641  *              VarBstrFromDec          [OLEAUT32.@]
3642  */
3643 HRESULT WINAPI VarBstrFromDec(DECIMAL* pDecIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3644 {
3645         if(!pDecIn->u.s.sign && !pDecIn->u.s.scale &&
3646            !pDecIn->Hi32 && !pDecIn->u1.s1.Mid32)
3647             return VarBstrFromUI4(pDecIn->u1.s1.Lo32, lcid, dwFlags, pbstrOut);
3648         FIXME("%c%08lx%08lx%08lx E%02x stub\n",
3649         (pDecIn->u.s.sign == DECIMAL_NEG) ? '-' :
3650         (pDecIn->u.s.sign == 0) ? '+' : '?',
3651         pDecIn->Hi32, pDecIn->u1.s1.Mid32, pDecIn->u1.s1.Lo32,
3652         pDecIn->u.s.scale);
3653         return E_INVALIDARG;
3654 }
3655
3656 /******************************************************************************
3657  *              VarBoolFromUI1          [OLEAUT32.118]
3658  */
3659 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
3660 {
3661         TRACE("( %d, %p ), stub\n", bIn, pboolOut );
3662
3663         if( bIn == 0 )
3664         {
3665                 *pboolOut = VARIANT_FALSE;
3666         }
3667         else
3668         {
3669                 *pboolOut = VARIANT_TRUE;
3670         }
3671
3672         return S_OK;
3673 }
3674
3675 /******************************************************************************
3676  *              VarBoolFromI2           [OLEAUT32.119]
3677  */
3678 HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
3679 {
3680         TRACE("( %d, %p ), stub\n", sIn, pboolOut );
3681
3682         *pboolOut = (sIn) ? VARIANT_TRUE : VARIANT_FALSE;
3683
3684         return S_OK;
3685 }
3686
3687 /******************************************************************************
3688  *              VarBoolFromI4           [OLEAUT32.120]
3689  */
3690 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
3691 {
3692         TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
3693
3694         *pboolOut = (lIn) ? VARIANT_TRUE : VARIANT_FALSE;
3695
3696         return S_OK;
3697 }
3698
3699 /******************************************************************************
3700  *              VarBoolFromR4           [OLEAUT32.121]
3701  */
3702 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
3703 {
3704         TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
3705
3706         *pboolOut = (fltIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3707
3708         return S_OK;
3709 }
3710
3711 /******************************************************************************
3712  *              VarBoolFromR8           [OLEAUT32.122]
3713  */
3714 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
3715 {
3716         TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
3717
3718         *pboolOut = (dblIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3719
3720         return S_OK;
3721 }
3722
3723 /******************************************************************************
3724  *              VarBoolFromDate         [OLEAUT32.123]
3725  */
3726 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
3727 {
3728         TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
3729
3730         *pboolOut = (dateIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3731
3732         return S_OK;
3733 }
3734
3735 /******************************************************************************
3736  *              VarBoolFromStr          [OLEAUT32.125]
3737  */
3738 HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
3739 {
3740         HRESULT ret = S_OK;
3741         char* pNewString = NULL;
3742
3743         TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
3744
3745     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3746
3747         if( pNewString == NULL || strlen( pNewString ) == 0 )
3748         {
3749                 ret = DISP_E_TYPEMISMATCH;
3750         }
3751
3752         if( ret == S_OK )
3753         {
3754                 if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
3755                 {
3756                         *pboolOut = VARIANT_TRUE;
3757                 }
3758                 else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
3759                 {
3760                         *pboolOut = VARIANT_FALSE;
3761                 }
3762                 else
3763                 {
3764                         /* Try converting the string to a floating point number.
3765                          */
3766                         double dValue = 0.0;
3767                         HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
3768                         if( res != S_OK )
3769                         {
3770                                 ret = DISP_E_TYPEMISMATCH;
3771                         }
3772                         else
3773                                 *pboolOut = (dValue == 0.0) ?
3774                                                 VARIANT_FALSE : VARIANT_TRUE;
3775                 }
3776         }
3777
3778         HeapFree( GetProcessHeap(), 0, pNewString );
3779
3780         return ret;
3781 }
3782
3783 /******************************************************************************
3784  *              VarBoolFromI1           [OLEAUT32.233]
3785  */
3786 HRESULT WINAPI VarBoolFromI1(signed char cIn, VARIANT_BOOL* pboolOut)
3787 {
3788         TRACE("( %c, %p ), stub\n", cIn, pboolOut );
3789
3790         *pboolOut = (cIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3791
3792         return S_OK;
3793 }
3794
3795 /******************************************************************************
3796  *              VarBoolFromUI2          [OLEAUT32.234]
3797  */
3798 HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
3799 {
3800         TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
3801
3802         *pboolOut = (uiIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3803
3804         return S_OK;
3805 }
3806
3807 /******************************************************************************
3808  *              VarBoolFromUI4          [OLEAUT32.235]
3809  */
3810 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
3811 {
3812         TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
3813
3814         *pboolOut = (ulIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3815
3816         return S_OK;
3817 }
3818
3819 /**********************************************************************
3820  *              VarBoolFromCy [OLEAUT32.124]
3821  * Convert currency to boolean
3822  */
3823 HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) {
3824       if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
3825       else *pboolOut = 0;
3826
3827       return S_OK;
3828 }
3829
3830 /******************************************************************************
3831  *              VarI1FromUI1            [OLEAUT32.244]
3832  */
3833 HRESULT WINAPI VarI1FromUI1(BYTE bIn, signed char *pcOut)
3834 {
3835         TRACE("( %d, %p ), stub\n", bIn, pcOut );
3836
3837         /* Check range of value.
3838          */
3839         if( bIn > CHAR_MAX )
3840         {
3841                 return DISP_E_OVERFLOW;
3842         }
3843
3844         *pcOut = (CHAR) bIn;
3845
3846         return S_OK;
3847 }
3848
3849 /******************************************************************************
3850  *              VarI1FromI2             [OLEAUT32.245]
3851  */
3852 HRESULT WINAPI VarI1FromI2(short uiIn, signed char *pcOut)
3853 {
3854         TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3855
3856         if( uiIn > CHAR_MAX )
3857         {
3858                 return DISP_E_OVERFLOW;
3859         }
3860
3861         *pcOut = (CHAR) uiIn;
3862
3863         return S_OK;
3864 }
3865
3866 /******************************************************************************
3867  *              VarI1FromI4             [OLEAUT32.246]
3868  */
3869 HRESULT WINAPI VarI1FromI4(LONG lIn, signed char *pcOut)
3870 {
3871         TRACE("( %ld, %p ), stub\n", lIn, pcOut );
3872
3873         if( lIn < CHAR_MIN || lIn > CHAR_MAX )
3874         {
3875                 return DISP_E_OVERFLOW;
3876         }
3877
3878         *pcOut = (CHAR) lIn;
3879
3880         return S_OK;
3881 }
3882
3883 /******************************************************************************
3884  *              VarI1FromR4             [OLEAUT32.247]
3885  */
3886 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, signed char *pcOut)
3887 {
3888         TRACE("( %f, %p ), stub\n", fltIn, pcOut );
3889
3890     fltIn = round( fltIn );
3891         if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
3892         {
3893                 return DISP_E_OVERFLOW;
3894         }
3895
3896         *pcOut = (CHAR) fltIn;
3897
3898         return S_OK;
3899 }
3900
3901 /******************************************************************************
3902  *              VarI1FromR8             [OLEAUT32.248]
3903  */
3904 HRESULT WINAPI VarI1FromR8(double dblIn, signed char *pcOut)
3905 {
3906         TRACE("( %f, %p ), stub\n", dblIn, pcOut );
3907
3908     dblIn = round( dblIn );
3909     if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
3910         {
3911                 return DISP_E_OVERFLOW;
3912         }
3913
3914         *pcOut = (CHAR) dblIn;
3915
3916         return S_OK;
3917 }
3918
3919 /******************************************************************************
3920  *              VarI1FromDate           [OLEAUT32.249]
3921  */
3922 HRESULT WINAPI VarI1FromDate(DATE dateIn, signed char *pcOut)
3923 {
3924         TRACE("( %f, %p ), stub\n", dateIn, pcOut );
3925
3926     dateIn = round( dateIn );
3927         if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
3928         {
3929                 return DISP_E_OVERFLOW;
3930         }
3931
3932         *pcOut = (CHAR) dateIn;
3933
3934         return S_OK;
3935 }
3936
3937 /******************************************************************************
3938  *              VarI1FromStr            [OLEAUT32.251]
3939  */
3940 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed char *pcOut)
3941 {
3942         double dValue = 0.0;
3943         LPSTR pNewString = NULL;
3944
3945         TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
3946
3947         /* Check if we have a valid argument
3948          */
3949         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3950         RemoveCharacterFromString( pNewString, "," );
3951         if( IsValidRealString( pNewString ) == FALSE )
3952         {
3953                 return DISP_E_TYPEMISMATCH;
3954         }
3955
3956         /* Convert the valid string to a floating point number.
3957          */
3958         dValue = atof( pNewString );
3959
3960         /* We don't need the string anymore so free it.
3961          */
3962         HeapFree( GetProcessHeap(), 0, pNewString );
3963
3964         /* Check range of value.
3965      */
3966     dValue = round( dValue );
3967         if( dValue < CHAR_MIN || dValue > CHAR_MAX )
3968         {
3969                 return DISP_E_OVERFLOW;
3970         }
3971
3972         *pcOut = (CHAR) dValue;
3973
3974         return S_OK;
3975 }
3976
3977 /******************************************************************************
3978  *              VarI1FromBool           [OLEAUT32.253]
3979  */
3980 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, signed char *pcOut)
3981 {
3982         TRACE("( %d, %p ), stub\n", boolIn, pcOut );
3983
3984         *pcOut = (CHAR) boolIn;
3985
3986         return S_OK;
3987 }
3988
3989 /******************************************************************************
3990  *              VarI1FromUI2            [OLEAUT32.254]
3991  */
3992 HRESULT WINAPI VarI1FromUI2(USHORT uiIn, signed char *pcOut)
3993 {
3994         TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3995
3996         if( uiIn > CHAR_MAX )
3997         {
3998                 return DISP_E_OVERFLOW;
3999         }
4000
4001         *pcOut = (CHAR) uiIn;
4002
4003         return S_OK;
4004 }
4005
4006 /******************************************************************************
4007  *              VarI1FromUI4            [OLEAUT32.255]
4008  */
4009 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, signed char *pcOut)
4010 {
4011         TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
4012
4013         if( ulIn > CHAR_MAX )
4014         {
4015                 return DISP_E_OVERFLOW;
4016         }
4017
4018         *pcOut = (CHAR) ulIn;
4019
4020         return S_OK;
4021 }
4022
4023 /**********************************************************************
4024  *              VarI1FromCy [OLEAUT32.250]
4025  * Convert currency to signed char
4026  */
4027 HRESULT WINAPI VarI1FromCy(CY cyIn, signed char *pcOut) {
4028    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4029
4030    if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
4031
4032    *pcOut = (CHAR)t;
4033    return S_OK;
4034 }
4035
4036 /******************************************************************************
4037  *              VarUI2FromUI1           [OLEAUT32.257]
4038  */
4039 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
4040 {
4041         TRACE("( %d, %p ), stub\n", bIn, puiOut );
4042
4043         *puiOut = (USHORT) bIn;
4044
4045         return S_OK;
4046 }
4047
4048 /******************************************************************************
4049  *              VarUI2FromI2            [OLEAUT32.258]
4050  */
4051 HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
4052 {
4053         TRACE("( %d, %p ), stub\n", uiIn, puiOut );
4054
4055         if( uiIn < UI2_MIN )
4056         {
4057                 return DISP_E_OVERFLOW;
4058         }
4059
4060         *puiOut = (USHORT) uiIn;
4061
4062         return S_OK;
4063 }
4064
4065 /******************************************************************************
4066  *              VarUI2FromI4            [OLEAUT32.259]
4067  */
4068 HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
4069 {
4070         TRACE("( %ld, %p ), stub\n", lIn, puiOut );
4071
4072         if( lIn < UI2_MIN || lIn > UI2_MAX )
4073         {
4074                 return DISP_E_OVERFLOW;
4075         }
4076
4077         *puiOut = (USHORT) lIn;
4078
4079         return S_OK;
4080 }
4081
4082 /******************************************************************************
4083  *              VarUI2FromR4            [OLEAUT32.260]
4084  */
4085 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
4086 {
4087         TRACE("( %f, %p ), stub\n", fltIn, puiOut );
4088
4089     fltIn = round( fltIn );
4090         if( fltIn < UI2_MIN || fltIn > UI2_MAX )
4091         {
4092                 return DISP_E_OVERFLOW;
4093         }
4094
4095         *puiOut = (USHORT) fltIn;
4096
4097         return S_OK;
4098 }
4099
4100 /******************************************************************************
4101  *              VarUI2FromR8            [OLEAUT32.261]
4102  */
4103 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
4104 {
4105         TRACE("( %f, %p ), stub\n", dblIn, puiOut );
4106
4107     dblIn = round( dblIn );
4108     if( dblIn < UI2_MIN || dblIn > UI2_MAX )
4109         {
4110                 return DISP_E_OVERFLOW;
4111         }
4112
4113         *puiOut = (USHORT) dblIn;
4114
4115         return S_OK;
4116 }
4117
4118 /******************************************************************************
4119  *              VarUI2FromDate          [OLEAUT32.262]
4120  */
4121 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
4122 {
4123         TRACE("( %f, %p ), stub\n", dateIn, puiOut );
4124
4125     dateIn = round( dateIn );
4126         if( dateIn < UI2_MIN || dateIn > UI2_MAX )
4127         {
4128                 return DISP_E_OVERFLOW;
4129         }
4130
4131         *puiOut = (USHORT) dateIn;
4132
4133         return S_OK;
4134 }
4135
4136 /******************************************************************************
4137  *              VarUI2FromStr           [OLEAUT32.264]
4138  */
4139 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
4140 {
4141         double dValue = 0.0;
4142         LPSTR pNewString = NULL;
4143
4144         TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
4145
4146         /* Check if we have a valid argument
4147          */
4148         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4149         RemoveCharacterFromString( pNewString, "," );
4150         if( IsValidRealString( pNewString ) == FALSE )
4151         {
4152                 return DISP_E_TYPEMISMATCH;
4153         }
4154
4155         /* Convert the valid string to a floating point number.
4156          */
4157         dValue = atof( pNewString );
4158
4159         /* We don't need the string anymore so free it.
4160          */
4161         HeapFree( GetProcessHeap(), 0, pNewString );
4162
4163         /* Check range of value.
4164      */
4165     dValue = round( dValue );
4166         if( dValue < UI2_MIN || dValue > UI2_MAX )
4167         {
4168                 return DISP_E_OVERFLOW;
4169         }
4170
4171         *puiOut = (USHORT) dValue;
4172
4173         return S_OK;
4174 }
4175
4176 /******************************************************************************
4177  *              VarUI2FromBool          [OLEAUT32.266]
4178  */
4179 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
4180 {
4181         TRACE("( %d, %p ), stub\n", boolIn, puiOut );
4182
4183         *puiOut = (USHORT) boolIn;
4184
4185         return S_OK;
4186 }
4187
4188 /******************************************************************************
4189  *              VarUI2FromI1            [OLEAUT32.267]
4190  */
4191 HRESULT WINAPI VarUI2FromI1(signed char cIn, USHORT* puiOut)
4192 {
4193         TRACE("( %c, %p ), stub\n", cIn, puiOut );
4194
4195         *puiOut = (USHORT) cIn;
4196
4197         return S_OK;
4198 }
4199
4200 /******************************************************************************
4201  *              VarUI2FromUI4           [OLEAUT32.268]
4202  */
4203 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
4204 {
4205         TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
4206
4207         if( ulIn > UI2_MAX )
4208         {
4209                 return DISP_E_OVERFLOW;
4210         }
4211
4212         *puiOut = (USHORT) ulIn;
4213
4214         return S_OK;
4215 }
4216
4217 /******************************************************************************
4218  *              VarUI4FromStr           [OLEAUT32.277]
4219  */
4220 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
4221 {
4222         double dValue = 0.0;
4223         LPSTR pNewString = NULL;
4224
4225         TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
4226
4227         /* Check if we have a valid argument
4228          */
4229         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4230         RemoveCharacterFromString( pNewString, "," );
4231         if( IsValidRealString( pNewString ) == FALSE )
4232         {
4233                 return DISP_E_TYPEMISMATCH;
4234         }
4235
4236         /* Convert the valid string to a floating point number.
4237          */
4238         dValue = atof( pNewString );
4239
4240         /* We don't need the string anymore so free it.
4241          */
4242         HeapFree( GetProcessHeap(), 0, pNewString );
4243
4244         /* Check range of value.
4245      */
4246     dValue = round( dValue );
4247         if( dValue < UI4_MIN || dValue > UI4_MAX )
4248         {
4249                 return DISP_E_OVERFLOW;
4250         }
4251
4252         *pulOut = (ULONG) dValue;
4253
4254         return S_OK;
4255 }
4256
4257 /**********************************************************************
4258  *              VarUI2FromCy [OLEAUT32.263]
4259  * Convert currency to unsigned short
4260  */
4261 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
4262    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4263
4264    if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
4265
4266    *pusOut = (USHORT)t;
4267
4268    return S_OK;
4269 }
4270
4271 /******************************************************************************
4272  *              VarUI4FromUI1           [OLEAUT32.270]
4273  */
4274 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
4275 {
4276         TRACE("( %d, %p ), stub\n", bIn, pulOut );
4277
4278         *pulOut = (USHORT) bIn;
4279
4280         return S_OK;
4281 }
4282
4283 /******************************************************************************
4284  *              VarUI4FromI2            [OLEAUT32.271]
4285  */
4286 HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
4287 {
4288         TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4289
4290         if( uiIn < UI4_MIN )
4291         {
4292                 return DISP_E_OVERFLOW;
4293         }
4294
4295         *pulOut = (ULONG) uiIn;
4296
4297         return S_OK;
4298 }
4299
4300 /******************************************************************************
4301  *              VarUI4FromI4            [OLEAUT32.272]
4302  */
4303 HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
4304 {
4305         TRACE("( %ld, %p ), stub\n", lIn, pulOut );
4306
4307         if( lIn < 0 )
4308         {
4309                 return DISP_E_OVERFLOW;
4310         }
4311
4312         *pulOut = (ULONG) lIn;
4313
4314         return S_OK;
4315 }
4316
4317 /******************************************************************************
4318  *              VarUI4FromR4            [OLEAUT32.273]
4319  */
4320 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
4321 {
4322     fltIn = round( fltIn );
4323     if( fltIn < UI4_MIN || fltIn > UI4_MAX )
4324         {
4325                 return DISP_E_OVERFLOW;
4326         }
4327
4328         *pulOut = (ULONG) fltIn;
4329
4330         return S_OK;
4331 }
4332
4333 /******************************************************************************
4334  *              VarUI4FromR8            [OLEAUT32.274]
4335  */
4336 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
4337 {
4338         TRACE("( %f, %p ), stub\n", dblIn, pulOut );
4339
4340         dblIn = round( dblIn );
4341         if( dblIn < UI4_MIN || dblIn > UI4_MAX )
4342         {
4343                 return DISP_E_OVERFLOW;
4344         }
4345
4346         *pulOut = (ULONG) dblIn;
4347
4348         return S_OK;
4349 }
4350
4351 /******************************************************************************
4352  *              VarUI4FromDate          [OLEAUT32.275]
4353  */
4354 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
4355 {
4356         TRACE("( %f, %p ), stub\n", dateIn, pulOut );
4357
4358         dateIn = round( dateIn );
4359         if( dateIn < UI4_MIN || dateIn > UI4_MAX )
4360         {
4361                 return DISP_E_OVERFLOW;
4362         }
4363
4364         *pulOut = (ULONG) dateIn;
4365
4366         return S_OK;
4367 }
4368
4369 /******************************************************************************
4370  *              VarUI4FromBool          [OLEAUT32.279]
4371  */
4372 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
4373 {
4374         TRACE("( %d, %p ), stub\n", boolIn, pulOut );
4375
4376         *pulOut = (ULONG) boolIn;
4377
4378         return S_OK;
4379 }
4380
4381 /******************************************************************************
4382  *              VarUI4FromI1            [OLEAUT32.280]
4383  */
4384 HRESULT WINAPI VarUI4FromI1(signed char cIn, ULONG* pulOut)
4385 {
4386         TRACE("( %c, %p ), stub\n", cIn, pulOut );
4387
4388         *pulOut = (ULONG) cIn;
4389
4390         return S_OK;
4391 }
4392
4393 /******************************************************************************
4394  *              VarUI4FromUI2           [OLEAUT32.281]
4395  */
4396 HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
4397 {
4398         TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4399
4400         *pulOut = (ULONG) uiIn;
4401
4402         return S_OK;
4403 }
4404
4405 /**********************************************************************
4406  *              VarUI4FromCy [OLEAUT32.276]
4407  * Convert currency to unsigned long
4408  */
4409 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
4410    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4411
4412    if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
4413
4414    *pulOut = (ULONG)t;
4415
4416    return S_OK;
4417 }
4418
4419 /**********************************************************************
4420  *              VarCyFromUI1 [OLEAUT32.98]
4421  * Convert unsigned char to currency
4422  */
4423 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
4424     pcyOut->s.Hi = 0;
4425     pcyOut->s.Lo = ((ULONG)bIn) * 10000;
4426
4427     return S_OK;
4428 }
4429
4430 /**********************************************************************
4431  *              VarCyFromI2 [OLEAUT32.99]
4432  * Convert signed short to currency
4433  */
4434 HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
4435     if (sIn < 0) pcyOut->s.Hi = -1;
4436     else pcyOut->s.Hi = 0;
4437     pcyOut->s.Lo = ((ULONG)sIn) * 10000;
4438
4439     return S_OK;
4440 }
4441
4442 /**********************************************************************
4443  *              VarCyFromI4 [OLEAUT32.100]
4444  * Convert signed long to currency
4445  */
4446 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
4447       double t = (double)lIn * (double)10000;
4448       pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4449       pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4450       if (lIn < 0) pcyOut->s.Hi--;
4451
4452       return S_OK;
4453 }
4454
4455 /**********************************************************************
4456  *              VarCyFromR4 [OLEAUT32.101]
4457  * Convert float to currency
4458  */
4459 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
4460    double t = round((double)fltIn * (double)10000);
4461    pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4462    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4463    if (fltIn < 0) pcyOut->s.Hi--;
4464
4465    return S_OK;
4466 }
4467
4468 /**********************************************************************
4469  *              VarCyFromR8 [OLEAUT32.102]
4470  * Convert double to currency
4471  */
4472 HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
4473    double t = round(dblIn * (double)10000);
4474    pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4475    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4476    if (dblIn < 0) pcyOut->s.Hi--;
4477
4478    return S_OK;
4479 }
4480
4481 /**********************************************************************
4482  *              VarCyFromDate [OLEAUT32.103]
4483  * Convert date to currency
4484  */
4485 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
4486    double t = round((double)dateIn * (double)10000);
4487    pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4488    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4489    if (dateIn < 0) pcyOut->s.Hi--;
4490
4491    return S_OK;
4492 }
4493
4494 /**********************************************************************
4495  *              VarCyFromStr [OLEAUT32.104]
4496  * FIXME: Never tested with decimal separator other than '.'
4497  */
4498 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
4499
4500         LPSTR   pNewString      = NULL;
4501     char   *decSep          = NULL;
4502     char   *strPtr,*curPtr  = NULL;
4503     int size, rc;
4504     double currencyVal = 0.0;
4505
4506
4507         pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4508         TRACE("( '%s', 0x%08lx, 0x%08lx, %p )\n", pNewString, lcid, dwFlags, pcyOut );
4509
4510     /* Get locale information - Decimal Separator (size includes 0x00) */
4511     size = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, NULL, 0);
4512     decSep = (char *) malloc(size);
4513     rc = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, decSep, size);
4514     TRACE("Decimal Separator is '%s'\n", decSep);
4515
4516     /* Now copy to temporary buffer, skipping any character except 0-9 and
4517        the decimal separator */
4518     curPtr = pBuffer;      /* Current position in string being built       */
4519     strPtr = pNewString;   /* Current position in supplied currenct string */
4520
4521     while (*strPtr) {
4522         /* If decimal separator, skip it and put '.' in string */
4523         if (strncmp(strPtr, decSep, (size-1)) == 0) {
4524             strPtr = strPtr + (size-1);
4525             *curPtr = '.';
4526             curPtr++;
4527         } else if ((*strPtr == '+' || *strPtr == '-') ||
4528                    (*strPtr >= '0' && *strPtr <= '9')) {
4529             *curPtr = *strPtr;
4530             strPtr++;
4531             curPtr++;
4532         } else strPtr++;
4533     }
4534     *curPtr = 0x00;
4535
4536     /* Try to get currency into a double */
4537     currencyVal = atof(pBuffer);
4538     TRACE("Converted string '%s' to %f\n", pBuffer, currencyVal);
4539
4540     /* Free allocated storage */
4541     HeapFree( GetProcessHeap(), 0, pNewString );
4542     free(decSep);
4543
4544     /* Convert double -> currency using internal routine */
4545         return VarCyFromR8(currencyVal, pcyOut);
4546 }
4547
4548
4549 /**********************************************************************
4550  *              VarCyFromBool [OLEAUT32.106]
4551  * Convert boolean to currency
4552  */
4553 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
4554    if (boolIn < 0) pcyOut->s.Hi = -1;
4555    else pcyOut->s.Hi = 0;
4556    pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
4557
4558    return S_OK;
4559 }
4560
4561 /**********************************************************************
4562  *              VarCyFromI1 [OLEAUT32.225]
4563  * Convert signed char to currency
4564  */
4565 HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pcyOut) {
4566    if (cIn < 0) pcyOut->s.Hi = -1;
4567    else pcyOut->s.Hi = 0;
4568    pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
4569
4570    return S_OK;
4571 }
4572
4573 /**********************************************************************
4574  *              VarCyFromUI2 [OLEAUT32.226]
4575  * Convert unsigned short to currency
4576  */
4577 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
4578    pcyOut->s.Hi = 0;
4579    pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
4580
4581    return S_OK;
4582 }
4583
4584 /**********************************************************************
4585  *              VarCyFromUI4 [OLEAUT32.227]
4586  * Convert unsigned long to currency
4587  */
4588 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) {
4589    double t = (double)ulIn * (double)10000;
4590    pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4591    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4592
4593    return S_OK;
4594 }
4595
4596 /**********************************************************************
4597  *              VarDecFromStr [OLEAUT32.@]
4598  */
4599 HRESULT WINAPI VarDecFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags,
4600                              DECIMAL* pdecOut)
4601 {   WCHAR *p=strIn;
4602     ULONGLONG t;
4603     ULONG  cy;
4604
4605     DECIMAL_SETZERO(pdecOut);
4606
4607     if(*p == (WCHAR)'-')pdecOut->u.s.sign= DECIMAL_NEG;
4608     if((*p == (WCHAR)'-') || (*p == (WCHAR)'+')) p++;
4609     for(;*p != (WCHAR)0; p++) {
4610         if((*p < (WCHAR)'0')||(*p > (WCHAR)'9')) goto error ;
4611         t = (ULONGLONG)pdecOut->u1.s1.Lo32 *(ULONGLONG)10
4612           + (ULONGLONG)(*p -(WCHAR)'0');
4613         cy = (ULONG)(t >> 32);
4614         pdecOut->u1.s1.Lo32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4615         t = (ULONGLONG)pdecOut->u1.s1.Mid32 * (ULONGLONG)10
4616           + (ULONGLONG)cy;
4617         cy = (ULONG)(t >> 32);
4618         pdecOut->u1.s1.Mid32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4619         t = (ULONGLONG)pdecOut->Hi32 * (ULONGLONG)10
4620           + (ULONGLONG)cy;
4621         cy = (ULONG)(t >> 32);
4622         pdecOut->Hi32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4623         if(cy) goto overflow ;
4624     }
4625     TRACE("%s -> sign %02x,hi %08lx,mid %08lx, lo%08lx, scale %08x\n",
4626           debugstr_w(strIn),
4627           pdecOut->u.s.sign, pdecOut->Hi32, pdecOut->u1.s1.Mid32,
4628           pdecOut->u1.s1.Lo32, pdecOut->u.s.scale);
4629     return S_OK;
4630
4631 overflow:
4632     /* like NT4 SP5 */
4633     pdecOut->Hi32 = pdecOut->u1.s1.Mid32 = pdecOut->u1.s1.Lo32 = 0xffffffff;
4634     return DISP_E_OVERFLOW;
4635
4636 error:
4637     ERR("%s: unknown char at pos %d\n",
4638               debugstr_w(strIn),  p - strIn + 1);
4639     return DISP_E_TYPEMISMATCH;
4640 }
4641
4642 /**********************************************************************
4643  *              DosDateTimeToVariantTime [OLEAUT32.14]
4644  * Convert dos representation of time to the date and time representation
4645  * stored in a variant.
4646  */
4647 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
4648                                     DATE *pvtime)
4649 {
4650     struct tm t;
4651
4652     TRACE("( 0x%x, 0x%x, %p ), stub\n", wDosDate, wDosTime, pvtime );
4653
4654     t.tm_sec = (wDosTime & 0x001f) * 2;
4655     t.tm_min = (wDosTime & 0x07e0) >> 5;
4656     t.tm_hour = (wDosTime & 0xf800) >> 11;
4657
4658     t.tm_mday = (wDosDate & 0x001f);
4659     t.tm_mon = (wDosDate & 0x01e0) >> 5;
4660     t.tm_year = ((wDosDate & 0xfe00) >> 9) + 1980;
4661
4662     return TmToDATE( &t, pvtime );
4663 }
4664
4665
4666 /**********************************************************************
4667  *              VarParseNumFromStr [OLEAUT32.46]
4668  */
4669 HRESULT WINAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags,
4670                                   NUMPARSE * pnumprs, BYTE * rgbDig)
4671 {
4672     int i,lastent=0;
4673     int cDig;
4674     BOOL foundNum=FALSE;
4675
4676     FIXME("(%s,flags=%lx,....), partial stub!\n",debugstr_w(strIn),dwFlags);
4677     FIXME("numparse: cDig=%d, InFlags=%lx\n",pnumprs->cDig,pnumprs->dwInFlags);
4678
4679     /* The other struct components are to be set by us */
4680     memset(rgbDig,0,pnumprs->cDig);
4681
4682     /* FIXME: Just patching some values in */
4683     pnumprs->nPwr10     = 0;
4684     pnumprs->nBaseShift = 0;
4685     pnumprs->cchUsed    = lastent;
4686     pnumprs->dwOutFlags = NUMPRS_DECIMAL;
4687
4688     cDig = 0;
4689     for (i=0; strIn[i] ;i++) {
4690         if ((strIn[i]>='0') && (strIn[i]<='9')) {
4691             foundNum = TRUE;
4692             if (pnumprs->cDig > cDig) {
4693                 *(rgbDig++)=strIn[i]-'0';
4694                 cDig++;
4695                 lastent = i;
4696             }
4697         } else if ((strIn[i]=='-') && (foundNum==FALSE)) {
4698             pnumprs->dwOutFlags |= NUMPRS_NEG;
4699         }
4700     }
4701     pnumprs->cDig       = cDig;
4702     TRACE("numparse out: cDig=%d, OutFlags=%lx\n",pnumprs->cDig,pnumprs->dwOutFlags);
4703     return S_OK;
4704 }
4705
4706
4707 /**********************************************************************
4708  *              VarNumFromParseNum [OLEAUT32.47]
4709  */
4710 HRESULT WINAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig,
4711                                   ULONG dwVtBits, VARIANT * pvar)
4712 {
4713     DWORD xint;
4714     int i;
4715     FIXME("(..,dwVtBits=%lx,....), partial stub!\n",dwVtBits);
4716
4717     xint = 0;
4718     for (i=0;i<pnumprs->cDig;i++)
4719         xint = xint*10 + rgbDig[i];
4720
4721     if (pnumprs->dwOutFlags & NUMPRS_NEG) {
4722         xint = xint * -1;
4723     }
4724
4725     VariantInit(pvar);
4726     if (dwVtBits & VTBIT_I4) {
4727         V_VT(pvar) = VT_I4;
4728         V_UNION(pvar,intVal) = xint;
4729         return S_OK;
4730     }
4731     if (dwVtBits & VTBIT_R8) {
4732         V_VT(pvar) = VT_R8;
4733         V_UNION(pvar,dblVal) = xint;
4734         return S_OK;
4735     }
4736     if (dwVtBits & VTBIT_R4) {
4737         V_VT(pvar) = VT_R4;
4738         V_UNION(pvar,fltVal) = xint;
4739         return S_OK;
4740     }
4741     if (dwVtBits & VTBIT_I2) {
4742         V_VT(pvar) = VT_I2;
4743         V_UNION(pvar,iVal) = xint;
4744         return S_OK;
4745     }
4746     /* FIXME: Currency should be from a double */
4747     if (dwVtBits & VTBIT_CY) {
4748         V_VT(pvar) = VT_CY;
4749         TRACE("Calculated currency is xint=%ld\n", xint);
4750         VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4751         TRACE("Calculated cy is %ld,%lu\n", V_UNION(pvar,cyVal).s.Hi, V_UNION(pvar,cyVal).s.Lo);
4752         return VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4753     }
4754
4755         FIXME("vtbitmask is unsupported %lx, int=%d\n",dwVtBits, (int) xint);
4756         return E_FAIL;
4757 }
4758
4759
4760 /**********************************************************************
4761  *              VarFormatDateTime [OLEAUT32.97]
4762  */
4763 HRESULT WINAPI VarFormatDateTime(LPVARIANT var, INT format, ULONG dwFlags, BSTR *out)
4764 {
4765     FIXME("%p %d %lx %p\n", var, format, dwFlags, out);
4766     return E_NOTIMPL;
4767 }
4768
4769 /**********************************************************************
4770  *              VarFormatCurrency [OLEAUT32.127]
4771  */
4772 HRESULT WINAPI VarFormatCurrency(LPVARIANT var, INT digits, INT lead, INT paren, INT group, ULONG dwFlags, BSTR *out)
4773 {
4774     FIXME("%p %d %d %d %d %lx %p\n", var, digits, lead, paren, group, dwFlags, out);
4775     return E_NOTIMPL;
4776 }
4777
4778 /**********************************************************************
4779  *              VariantTimeToDosDateTime [OLEAUT32.13]
4780  * Convert variant representation of time to the date and time representation
4781  * stored in dos.
4782  */
4783 INT WINAPI VariantTimeToDosDateTime(DATE pvtime, USHORT *wDosDate, USHORT *wDosTime)
4784 {
4785     struct tm t;
4786     *wDosTime = 0;
4787     *wDosDate = 0;
4788
4789     TRACE("( 0x%x, 0x%x, %p ), stub\n", *wDosDate, *wDosTime, &pvtime );
4790
4791     if (DateToTm(pvtime, 0, &t) < 0) return 0;
4792
4793     *wDosTime = *wDosTime | (t.tm_sec / 2);
4794     *wDosTime = *wDosTime | (t.tm_min << 5);
4795     *wDosTime = *wDosTime | (t.tm_hour << 11);
4796
4797     *wDosDate = *wDosDate | t.tm_mday ;
4798     *wDosDate = *wDosDate | t.tm_mon << 5;
4799     *wDosDate = *wDosDate | ((t.tm_year - 1980) << 9) ;
4800
4801     return 1;
4802 }
4803
4804
4805 /***********************************************************************
4806  *              SystemTimeToVariantTime [OLEAUT32.184]
4807  */
4808 HRESULT WINAPI SystemTimeToVariantTime( LPSYSTEMTIME  lpSystemTime, double *pvtime )
4809 {
4810     struct tm t;
4811
4812     TRACE(" %d/%d/%d %d:%d:%d\n",
4813           lpSystemTime->wMonth, lpSystemTime->wDay,
4814           lpSystemTime->wYear, lpSystemTime->wHour,
4815           lpSystemTime->wMinute, lpSystemTime->wSecond);
4816
4817     if (lpSystemTime->wYear >= 1900)
4818     {
4819         t.tm_sec = lpSystemTime->wSecond;
4820         t.tm_min = lpSystemTime->wMinute;
4821         t.tm_hour = lpSystemTime->wHour;
4822
4823         t.tm_mday = lpSystemTime->wDay;
4824         t.tm_mon = lpSystemTime->wMonth - 1; /* tm_mon is 0..11, wMonth is 1..12 */
4825         t.tm_year = lpSystemTime->wYear;
4826
4827         return TmToDATE( &t, pvtime );
4828     }
4829     else
4830     {
4831         double tmpDate;
4832         long firstDayOfNextYear;
4833         long thisDay;
4834         long leftInYear;
4835         long result;
4836
4837         double decimalPart = 0.0;
4838
4839         t.tm_sec = lpSystemTime->wSecond;
4840         t.tm_min = lpSystemTime->wMinute;
4841         t.tm_hour = lpSystemTime->wHour;
4842
4843         /* Step year forward the same number of years before 1900 */
4844         t.tm_year = 1900 + 1899 - lpSystemTime->wYear;
4845         t.tm_mon = lpSystemTime->wMonth - 1;
4846         t.tm_mday = lpSystemTime->wDay;
4847
4848         /* Calculate date */
4849         TmToDATE( &t, pvtime );
4850
4851         thisDay = (double) floor( *pvtime );
4852         decimalPart = fmod( *pvtime, thisDay );
4853
4854         /* Now, calculate the same time for the first of Jan that year */
4855         t.tm_mon = 0;
4856         t.tm_mday = 1;
4857         t.tm_sec = 0;
4858         t.tm_min = 0;
4859         t.tm_hour = 0;
4860         t.tm_year = t.tm_year+1;
4861         TmToDATE( &t, &tmpDate );
4862         firstDayOfNextYear = (long) floor(tmpDate);
4863
4864         /* Finally since we know the size of the year, subtract the two to get
4865            remaining time in the year                                          */
4866         leftInYear = firstDayOfNextYear - thisDay;
4867
4868         /* Now we want full years up to the year in question, and remainder of year
4869            of the year in question */
4870         if (isleap(lpSystemTime->wYear) ) {
4871            TRACE("Extra day due to leap year\n");
4872            result = 2.0 - ((firstDayOfNextYear - 366) + leftInYear - 2.0);
4873         } else {
4874            result = 2.0 - ((firstDayOfNextYear - 365) + leftInYear - 2.0);
4875         }
4876         *pvtime = (double) result + decimalPart;
4877         TRACE("<1899 support: returned %f, 1st day %ld, thisday %ld, left %ld\n", *pvtime, firstDayOfNextYear, thisDay, leftInYear);
4878
4879         return 1;
4880     }
4881
4882     return 0;
4883 }
4884
4885 /***********************************************************************
4886  *              VariantTimeToSystemTime [OLEAUT32.185]
4887  */
4888 HRESULT WINAPI VariantTimeToSystemTime( double vtime, LPSYSTEMTIME  lpSystemTime )
4889 {
4890     double t = 0, timeofday = 0;
4891
4892     static const BYTE Days_Per_Month[] =    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4893     static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4894
4895     /* The Month_Code is used to find the Day of the Week (LY = LeapYear)*/
4896     static const BYTE Month_Code[] =    {0, 1, 4, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4897     static const BYTE Month_Code_LY[] = {0, 0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4898
4899     /* The Century_Code is used to find the Day of the Week */
4900     static const BYTE Century_Code[]  = {0, 6, 4, 2};
4901
4902     struct tm r;
4903
4904     TRACE(" Variant = %f SYSTEMTIME ptr %p\n", vtime, lpSystemTime);
4905
4906     if (vtime >= 0)
4907     {
4908
4909         if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4910
4911         lpSystemTime->wSecond = r.tm_sec;
4912         lpSystemTime->wMinute = r.tm_min;
4913         lpSystemTime->wHour = r.tm_hour;
4914         lpSystemTime->wDay = r.tm_mday;
4915         lpSystemTime->wMonth = r.tm_mon;
4916
4917         if (lpSystemTime->wMonth == 12)
4918             lpSystemTime->wMonth = 1;
4919         else
4920             lpSystemTime->wMonth++;
4921
4922         lpSystemTime->wYear = r.tm_year;
4923     }
4924     else
4925     {
4926         vtime = -1*vtime;
4927
4928         if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4929
4930         lpSystemTime->wSecond = r.tm_sec;
4931         lpSystemTime->wMinute = r.tm_min;
4932         lpSystemTime->wHour = r.tm_hour;
4933
4934         lpSystemTime->wMonth = 13 - r.tm_mon;
4935
4936         if (lpSystemTime->wMonth == 1)
4937             lpSystemTime->wMonth = 12;
4938         else
4939             lpSystemTime->wMonth--;
4940
4941         lpSystemTime->wYear = 1899 - (r.tm_year - 1900);
4942
4943         if (!isleap(lpSystemTime->wYear) )
4944             lpSystemTime->wDay = Days_Per_Month[13 - lpSystemTime->wMonth] - r.tm_mday;
4945         else
4946             lpSystemTime->wDay = Days_Per_Month_LY[13 - lpSystemTime->wMonth] - r.tm_mday;
4947
4948
4949     }
4950
4951     if (!isleap(lpSystemTime->wYear))
4952     {
4953         /*
4954           (Century_Code+Month_Code+Year_Code+Day) % 7
4955
4956           The century code repeats every 400 years , so the array
4957           works out like this,
4958
4959           Century_Code[0] is for 16th/20th Centry
4960           Century_Code[1] is for 17th/21th Centry
4961           Century_Code[2] is for 18th/22th Centry
4962           Century_Code[3] is for 19th/23th Centry
4963
4964           The year code is found with the formula (year + (year / 4))
4965           the "year" must be between 0 and 99 .
4966
4967           The Month Code (Month_Code[1]) starts with January and
4968           ends with December.
4969         */
4970
4971         lpSystemTime->wDayOfWeek = (
4972             Century_Code[(( (lpSystemTime->wYear+100) - lpSystemTime->wYear%100) /100) %4]+
4973             ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4974             Month_Code[lpSystemTime->wMonth]+
4975             lpSystemTime->wDay) % 7;
4976
4977         if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4978         else lpSystemTime->wDayOfWeek -= 1;
4979     }
4980     else
4981     {
4982         lpSystemTime->wDayOfWeek = (
4983             Century_Code[(((lpSystemTime->wYear+100) - lpSystemTime->wYear%100)/100)%4]+
4984             ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4985             Month_Code_LY[lpSystemTime->wMonth]+
4986             lpSystemTime->wDay) % 7;
4987
4988         if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4989         else lpSystemTime->wDayOfWeek -= 1;
4990     }
4991
4992     t = floor(vtime);
4993     timeofday = vtime - t;
4994
4995     lpSystemTime->wMilliseconds = (timeofday
4996                                    - lpSystemTime->wHour*(1/24)
4997                                    - lpSystemTime->wMinute*(1/1440)
4998                                    - lpSystemTime->wSecond*(1/86400) )*(1/5184000);
4999
5000     return 1;
5001 }
5002
5003 /***********************************************************************
5004  *              VarUdateFromDate [OLEAUT32.331]
5005  */
5006 HRESULT WINAPI VarUdateFromDate( DATE datein, ULONG dwFlags, UDATE *pudateout)
5007 {
5008     HRESULT i = 0;
5009     static const BYTE Days_Per_Month[] =    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5010     static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5011
5012     TRACE("DATE = %f\n", (double)datein);
5013     i = VariantTimeToSystemTime(datein, &(pudateout->st) );
5014
5015     if (i)
5016     {
5017         pudateout->wDayOfYear = 0;
5018
5019         if (isleap(pudateout->st.wYear))
5020         {
5021             for (i =1; i<pudateout->st.wMonth; i++)
5022                 pudateout->wDayOfYear += Days_Per_Month[i];
5023         }
5024         else
5025         {
5026             for (i =1; i<pudateout->st.wMonth; i++)
5027                 pudateout->wDayOfYear += Days_Per_Month_LY[i];
5028         }
5029
5030         pudateout->wDayOfYear += pudateout->st.wDay;
5031         dwFlags = 0; /*VAR_VALIDDATE*/
5032     }
5033     else dwFlags = 0;
5034
5035     return i;
5036 }
5037
5038 /***********************************************************************
5039  *              VarDateFromUdate [OLEAUT32.330]
5040  */
5041 HRESULT WINAPI VarDateFromUdate(UDATE *pudateout,
5042                                 ULONG dwFlags, DATE *datein)
5043 {
5044     HRESULT i;
5045     double t = 0;
5046     TRACE(" %d/%d/%d %d:%d:%d\n",
5047           pudateout->st.wMonth, pudateout->st.wDay,
5048           pudateout->st.wYear, pudateout->st.wHour,
5049           pudateout->st.wMinute, pudateout->st.wSecond);
5050
5051
5052     i = SystemTimeToVariantTime(&(pudateout->st), &t);
5053     *datein = t;
5054
5055     if (i) return S_OK;
5056     else return E_INVALIDARG;
5057 }
5058
5059
5060 /**********************************************************************
5061  *              VarBstrCmp [OLEAUT32.314]
5062  *
5063  * flags can be:
5064  *   NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5065  *   NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5066  *
5067  */
5068 HRESULT WINAPI VarBstrCmp(BSTR left, BSTR right, LCID lcid, DWORD flags)
5069 {
5070     INT r;
5071
5072     TRACE("( %s %s %ld %lx ) partial stub\n", debugstr_w(left), debugstr_w(right), lcid, flags);
5073
5074     /* Contrary to the MSDN, this returns eq for null vs null, null vs L"" and L"" vs NULL */
5075     if((!left) || (!right)) {
5076
5077         if (!left && (!right || *right==0)) return VARCMP_EQ;
5078         else if (!right && (!left || *left==0)) return VARCMP_EQ;
5079         else return VARCMP_NULL;
5080     }
5081
5082     if(flags&NORM_IGNORECASE)
5083         r = lstrcmpiW(left,right);
5084     else
5085         r = lstrcmpW(left,right);
5086
5087     if(r<0)
5088         return VARCMP_LT;
5089     if(r>0)
5090         return VARCMP_GT;
5091
5092     return VARCMP_EQ;
5093 }
5094
5095 /**********************************************************************
5096  *              VarBstrCat [OLEAUT32.313]
5097  */
5098 HRESULT WINAPI VarBstrCat(BSTR left, BSTR right, BSTR *out)
5099 {
5100     BSTR result;
5101     int size = 0;
5102
5103     TRACE("( %s %s %p )\n", debugstr_w(left), debugstr_w(right), out);
5104
5105     /* On Windows, NULL parms are still handled (as empty strings) */
5106     if (left)  size=size + lstrlenW(left);
5107     if (right) size=size + lstrlenW(right);
5108
5109     if (out) {
5110         result = SysAllocStringLen(NULL, size);
5111         *out = result;
5112         if (left) lstrcatW(result,left);
5113         if (right) lstrcatW(result,right);
5114         TRACE("result = %s, [%p]\n", debugstr_w(result), result);
5115     }
5116     return S_OK;
5117 }
5118
5119 /**********************************************************************
5120  *              VarCat [OLEAUT32.318]
5121  */
5122 HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out)
5123 {
5124     /* Should we VariantClear out? */
5125     /* Can we handle array, vector, by ref etc. */
5126     if ((V_VT(left)&VT_TYPEMASK) == VT_NULL &&
5127         (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5128     {
5129         V_VT(out) = VT_NULL;
5130         return S_OK;
5131     }
5132
5133     if (V_VT(left) == VT_BSTR && V_VT(right) == VT_BSTR)
5134     {
5135         V_VT(out) = VT_BSTR;
5136         VarBstrCat (V_BSTR(left), V_BSTR(right), &V_BSTR(out));
5137         return S_OK;
5138     }
5139     if (V_VT(left) == VT_BSTR) {
5140         VARIANT bstrvar;
5141         HRESULT hres;
5142
5143         V_VT(out) = VT_BSTR;
5144         hres = VariantChangeTypeEx(&bstrvar,right,0,0,VT_BSTR);
5145         if (hres) {
5146             FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5147             return hres;
5148         }
5149         VarBstrCat (V_BSTR(left), V_BSTR(&bstrvar), &V_BSTR(out));
5150         return S_OK;
5151     }
5152     if (V_VT(right) == VT_BSTR) {
5153         VARIANT bstrvar;
5154         HRESULT hres;
5155
5156         V_VT(out) = VT_BSTR;
5157         hres = VariantChangeTypeEx(&bstrvar,left,0,0,VT_BSTR);
5158         if (hres) {
5159             FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5160             return hres;
5161         }
5162         VarBstrCat (V_BSTR(&bstrvar), V_BSTR(right), &V_BSTR(out));
5163         return S_OK;
5164     }
5165     FIXME ("types %d / %d not supported\n",V_VT(left)&VT_TYPEMASK, V_VT(right)&VT_TYPEMASK);
5166     return S_OK;
5167 }
5168
5169 /**********************************************************************
5170  *              VarCmp [OLEAUT32.176]
5171  *
5172  * flags can be:
5173  *   NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5174  *   NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5175  *
5176  */
5177 HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
5178 {
5179
5180
5181     BOOL        lOk        = TRUE;
5182     BOOL        rOk        = TRUE;
5183     LONGLONG    lVal = -1;
5184     LONGLONG    rVal = -1;
5185     VARIANT     rv,lv;
5186     DWORD       xmask;
5187     HRESULT     rc;
5188
5189     VariantInit(&lv);VariantInit(&rv);
5190     V_VT(right) &= ~0x8000; /* hack since we sometime get this flag.  */
5191     V_VT(left) &= ~0x8000; /* hack since we sometime get this flag. */
5192
5193     TRACE("Left Var:\n");
5194     dump_Variant(left);
5195     TRACE("Right Var:\n");
5196     dump_Variant(right);
5197
5198     /* If either are null, then return VARCMP_NULL */
5199     if ((V_VT(left)&VT_TYPEMASK) == VT_NULL ||
5200         (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5201         return VARCMP_NULL;
5202
5203     /* Strings - use VarBstrCmp */
5204     if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5205         (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5206         return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags);
5207     }
5208
5209     xmask = (1<<(V_VT(left)&VT_TYPEMASK))|(1<<(V_VT(right)&VT_TYPEMASK));
5210     if (xmask & (1<<VT_R8)) {
5211         rc = VariantChangeType(&lv,left,0,VT_R8);
5212         if (FAILED(rc)) return rc;
5213         rc = VariantChangeType(&rv,right,0,VT_R8);
5214         if (FAILED(rc)) return rc;
5215
5216         if (V_R8(&lv) == V_R8(&rv)) return VARCMP_EQ;
5217         if (V_R8(&lv) < V_R8(&rv)) return VARCMP_LT;
5218         if (V_R8(&lv) > V_R8(&rv)) return VARCMP_GT;
5219         return E_FAIL; /* can't get here */
5220     }
5221     if (xmask & (1<<VT_R4)) {
5222         rc = VariantChangeType(&lv,left,0,VT_R4);
5223         if (FAILED(rc)) return rc;
5224         rc = VariantChangeType(&rv,right,0,VT_R4);
5225         if (FAILED(rc)) return rc;
5226
5227         if (V_R4(&lv) == V_R4(&rv)) return VARCMP_EQ;
5228         if (V_R4(&lv) < V_R4(&rv)) return VARCMP_LT;
5229         if (V_R4(&lv) > V_R4(&rv)) return VARCMP_GT;
5230         return E_FAIL; /* can't get here */
5231     }
5232
5233     /* Integers - Ideally like to use VarDecCmp, but no Dec support yet
5234            Use LONGLONG to maximize ranges                              */
5235     lOk = TRUE;
5236     switch (V_VT(left)&VT_TYPEMASK) {
5237     case VT_I1   : lVal = V_UNION(left,cVal); break;
5238     case VT_I2   : lVal = V_UNION(left,iVal); break;
5239     case VT_I4   : lVal = V_UNION(left,lVal); break;
5240     case VT_INT  : lVal = V_UNION(left,lVal); break;
5241     case VT_UI1  : lVal = V_UNION(left,bVal); break;
5242     case VT_UI2  : lVal = V_UNION(left,uiVal); break;
5243     case VT_UI4  : lVal = V_UNION(left,ulVal); break;
5244     case VT_UINT : lVal = V_UNION(left,ulVal); break;
5245     case VT_BOOL : lVal = V_UNION(left,boolVal); break;
5246     default: lOk = FALSE;
5247     }
5248
5249     rOk = TRUE;
5250     switch (V_VT(right)&VT_TYPEMASK) {
5251     case VT_I1   : rVal = V_UNION(right,cVal); break;
5252     case VT_I2   : rVal = V_UNION(right,iVal); break;
5253     case VT_I4   : rVal = V_UNION(right,lVal); break;
5254     case VT_INT  : rVal = V_UNION(right,lVal); break;
5255     case VT_UI1  : rVal = V_UNION(right,bVal); break;
5256     case VT_UI2  : rVal = V_UNION(right,uiVal); break;
5257     case VT_UI4  : rVal = V_UNION(right,ulVal); break;
5258     case VT_UINT : rVal = V_UNION(right,ulVal); break;
5259     case VT_BOOL : rVal = V_UNION(right,boolVal); break;
5260     default: rOk = FALSE;
5261     }
5262
5263     if (lOk && rOk) {
5264         if (lVal < rVal) {
5265             return VARCMP_LT;
5266         } else if (lVal > rVal) {
5267             return VARCMP_GT;
5268         } else {
5269             return VARCMP_EQ;
5270         }
5271     }
5272
5273     /* Strings - use VarBstrCmp */
5274     if ((V_VT(left)&VT_TYPEMASK) == VT_DATE &&
5275         (V_VT(right)&VT_TYPEMASK) == VT_DATE) {
5276
5277         if (floor(V_UNION(left,date)) == floor(V_UNION(right,date))) {
5278             /* Due to floating point rounding errors, calculate varDate in whole numbers) */
5279             double wholePart = 0.0;
5280             double leftR;
5281             double rightR;
5282
5283             /* Get the fraction * 24*60*60 to make it into whole seconds */
5284             wholePart = (double) floor( V_UNION(left,date) );
5285             if (wholePart == 0) wholePart = 1;
5286             leftR = floor(fmod( V_UNION(left,date), wholePart ) * (24*60*60));
5287
5288             wholePart = (double) floor( V_UNION(right,date) );
5289             if (wholePart == 0) wholePart = 1;
5290             rightR = floor(fmod( V_UNION(right,date), wholePart ) * (24*60*60));
5291
5292             if (leftR < rightR) {
5293                 return VARCMP_LT;
5294             } else if (leftR > rightR) {
5295                 return VARCMP_GT;
5296             } else {
5297                 return VARCMP_EQ;
5298             }
5299
5300         } else if (V_UNION(left,date) < V_UNION(right,date)) {
5301             return VARCMP_LT;
5302         } else if (V_UNION(left,date) > V_UNION(right,date)) {
5303             return VARCMP_GT;
5304         }
5305     }
5306     FIXME("VarCmp partial implementation, doesnt support vt 0x%x / 0x%x\n",V_VT(left), V_VT(right));
5307     return E_FAIL;
5308 }
5309
5310 /**********************************************************************
5311  *              VarAnd [OLEAUT32.142]
5312  *
5313  */
5314 HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5315 {
5316     HRESULT rc = E_FAIL;
5317
5318     TRACE("Left Var:\n");
5319     dump_Variant(left);
5320     TRACE("Right Var:\n");
5321     dump_Variant(right);
5322
5323     if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5324         (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5325
5326         V_VT(result) = VT_BOOL;
5327         if (V_BOOL(left) && V_BOOL(right)) {
5328             V_BOOL(result) = VARIANT_TRUE;
5329         } else {
5330             V_BOOL(result) = VARIANT_FALSE;
5331         }
5332         rc = S_OK;
5333
5334     } else {
5335         /* Integers */
5336         BOOL         lOk        = TRUE;
5337         BOOL         rOk        = TRUE;
5338         LONGLONG     lVal = -1;
5339         LONGLONG     rVal = -1;
5340         LONGLONG     res  = -1;
5341         int          resT = 0; /* Testing has shown I2 & I2 == I2, all else
5342                                   becomes I4, even unsigned ints (incl. UI2) */
5343
5344         lOk = TRUE;
5345         switch (V_VT(left)&VT_TYPEMASK) {
5346         case VT_I1   : lVal = V_UNION(left,cVal);  resT=VT_I4; break;
5347         case VT_I2   : lVal = V_UNION(left,iVal);  resT=VT_I2; break;
5348         case VT_I4   : lVal = V_UNION(left,lVal);  resT=VT_I4; break;
5349         case VT_INT  : lVal = V_UNION(left,lVal);  resT=VT_I4; break;
5350         case VT_UI1  : lVal = V_UNION(left,bVal);  resT=VT_I4; break;
5351         case VT_UI2  : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5352         case VT_UI4  : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5353         case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5354         default: lOk = FALSE;
5355         }
5356
5357         rOk = TRUE;
5358         switch (V_VT(right)&VT_TYPEMASK) {
5359         case VT_I1   : rVal = V_UNION(right,cVal);  resT=VT_I4; break;
5360         case VT_I2   : rVal = V_UNION(right,iVal);  resT=max(VT_I2, resT); break;
5361         case VT_I4   : rVal = V_UNION(right,lVal);  resT=VT_I4; break;
5362         case VT_INT  : rVal = V_UNION(right,lVal);  resT=VT_I4; break;
5363         case VT_UI1  : rVal = V_UNION(right,bVal);  resT=VT_I4; break;
5364         case VT_UI2  : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5365         case VT_UI4  : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5366         case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5367         default: rOk = FALSE;
5368         }
5369
5370         if (lOk && rOk) {
5371             res = (lVal & rVal);
5372             V_VT(result) = resT;
5373             switch (resT) {
5374             case VT_I2   : V_UNION(result,iVal)  = res; break;
5375             case VT_I4   : V_UNION(result,lVal)  = res; break;
5376             default:
5377                 FIXME("Unexpected result variant type %x\n", resT);
5378                 V_UNION(result,lVal)  = res;
5379             }
5380             rc = S_OK;
5381
5382         } else {
5383             FIXME("VarAnd stub\n");
5384         }
5385     }
5386
5387     TRACE("rc=%d, Result:\n", (int) rc);
5388     dump_Variant(result);
5389     return rc;
5390 }
5391
5392 /**********************************************************************
5393  *              VarAdd [OLEAUT32.141]
5394  * FIXME: From MSDN: If ... Then
5395  * Both expressions are of the string type Concatenated.
5396  * One expression is a string type and the other a character Addition.
5397  * One expression is numeric and the other is a string Addition.
5398  * Both expressions are numeric Addition.
5399  * Either expression is NULL NULL is returned.
5400  * Both expressions are empty  Integer subtype is returned.
5401  *
5402  */
5403 HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5404 {
5405     HRESULT rc = E_FAIL;
5406
5407     TRACE("Left Var:\n");
5408     dump_Variant(left);
5409     TRACE("Right Var:\n");
5410     dump_Variant(right);
5411
5412     if ((V_VT(left)&VT_TYPEMASK) == VT_EMPTY)
5413         return VariantCopy(result,right);
5414
5415     if ((V_VT(right)&VT_TYPEMASK) == VT_EMPTY)
5416         return VariantCopy(result,left);
5417
5418     if (((V_VT(left)&VT_TYPEMASK) == VT_R8) || ((V_VT(right)&VT_TYPEMASK) == VT_R8)) {
5419         BOOL         lOk        = TRUE;
5420         BOOL         rOk        = TRUE;
5421         double       lVal = -1;
5422         double       rVal = -1;
5423         double       res  = -1;
5424
5425         lOk = TRUE;
5426         switch (V_VT(left)&VT_TYPEMASK) {
5427         case VT_I1   : lVal = V_UNION(left,cVal);   break;
5428         case VT_I2   : lVal = V_UNION(left,iVal);   break;
5429         case VT_I4   : lVal = V_UNION(left,lVal);   break;
5430         case VT_INT  : lVal = V_UNION(left,lVal);   break;
5431         case VT_UI1  : lVal = V_UNION(left,bVal);   break;
5432         case VT_UI2  : lVal = V_UNION(left,uiVal);  break;
5433         case VT_UI4  : lVal = V_UNION(left,ulVal);  break;
5434         case VT_UINT : lVal = V_UNION(left,ulVal);  break;
5435         case VT_R4   : lVal = V_UNION(left,fltVal);  break;
5436         case VT_R8   : lVal = V_UNION(left,dblVal);  break;
5437         case VT_NULL : lVal = 0.0;  break;
5438         default: lOk = FALSE;
5439         }
5440
5441         rOk = TRUE;
5442         switch (V_VT(right)&VT_TYPEMASK) {
5443         case VT_I1   : rVal = V_UNION(right,cVal);  break;
5444         case VT_I2   : rVal = V_UNION(right,iVal);  break;
5445         case VT_I4   : rVal = V_UNION(right,lVal);  break;
5446         case VT_INT  : rVal = V_UNION(right,lVal);  break;
5447         case VT_UI1  : rVal = V_UNION(right,bVal);  break;
5448         case VT_UI2  : rVal = V_UNION(right,uiVal); break;
5449         case VT_UI4  : rVal = V_UNION(right,ulVal); break;
5450         case VT_UINT : rVal = V_UNION(right,ulVal); break;
5451         case VT_R4   : rVal = V_UNION(right,fltVal);break;
5452         case VT_R8   : rVal = V_UNION(right,dblVal);break;
5453         case VT_NULL : rVal = 0.0; break;
5454         default: rOk = FALSE;
5455         }
5456
5457         if (lOk && rOk) {
5458             res = (lVal + rVal);
5459             V_VT(result) = VT_R8;
5460             V_UNION(result,dblVal)  = res;
5461             rc = S_OK;
5462         } else {
5463             FIXME("Unhandled type pair %d / %d in double addition.\n",
5464                 (V_VT(left)&VT_TYPEMASK),
5465                 (V_VT(right)&VT_TYPEMASK)
5466             );
5467         }
5468         return rc;
5469     }
5470
5471     /* Handle strings as concat */
5472     if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5473         (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5474         V_VT(result) = VT_BSTR;
5475         rc = VarBstrCat(V_BSTR(left), V_BSTR(right), &V_BSTR(result));
5476     } else {
5477
5478         /* Integers */
5479         BOOL         lOk        = TRUE;
5480         BOOL         rOk        = TRUE;
5481         LONGLONG     lVal = -1;
5482         LONGLONG     rVal = -1;
5483         LONGLONG     res  = -1;
5484         int          resT = 0; /* Testing has shown I2 + I2 == I2, all else
5485                                   becomes I4                                */
5486
5487         lOk = TRUE;
5488         switch (V_VT(left)&VT_TYPEMASK) {
5489         case VT_I1   : lVal = V_UNION(left,cVal);  resT=VT_I4; break;
5490         case VT_I2   : lVal = V_UNION(left,iVal);  resT=VT_I2; break;
5491         case VT_I4   : lVal = V_UNION(left,lVal);  resT=VT_I4; break;
5492         case VT_INT  : lVal = V_UNION(left,lVal);  resT=VT_I4; break;
5493         case VT_UI1  : lVal = V_UNION(left,bVal);  resT=VT_I4; break;
5494         case VT_UI2  : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5495         case VT_UI4  : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5496         case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5497         case VT_NULL : lVal = 0; resT = VT_I4; break;
5498         default: lOk = FALSE;
5499         }
5500
5501         rOk = TRUE;
5502         switch (V_VT(right)&VT_TYPEMASK) {
5503         case VT_I1   : rVal = V_UNION(right,cVal);  resT=VT_I4; break;
5504         case VT_I2   : rVal = V_UNION(right,iVal);  resT=max(VT_I2, resT); break;
5505         case VT_I4   : rVal = V_UNION(right,lVal);  resT=VT_I4; break;
5506         case VT_INT  : rVal = V_UNION(right,lVal);  resT=VT_I4; break;
5507         case VT_UI1  : rVal = V_UNION(right,bVal);  resT=VT_I4; break;
5508         case VT_UI2  : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5509         case VT_UI4  : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5510         case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5511         case VT_NULL : rVal = 0; resT=VT_I4; break;
5512         default: rOk = FALSE;
5513         }
5514
5515         if (lOk && rOk) {
5516             res = (lVal + rVal);
5517             V_VT(result) = resT;
5518             switch (resT) {
5519             case VT_I2   : V_UNION(result,iVal)  = res; break;
5520             case VT_I4   : V_UNION(result,lVal)  = res; break;
5521             default:
5522                 FIXME("Unexpected result variant type %x\n", resT);
5523                 V_UNION(result,lVal)  = res;
5524             }
5525             rc = S_OK;
5526
5527         } else {
5528             FIXME("unimplemented part (0x%x + 0x%x)\n",V_VT(left), V_VT(right));
5529         }
5530     }
5531
5532     TRACE("rc=%d, Result:\n", (int) rc);
5533     dump_Variant(result);
5534     return rc;
5535 }
5536
5537 /**********************************************************************
5538  *              VarMul [OLEAUT32.156]
5539  *
5540  */
5541 HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5542 {
5543     HRESULT rc = E_FAIL;
5544     VARTYPE lvt,rvt,resvt;
5545     VARIANT lv,rv;
5546     BOOL found;
5547
5548     TRACE("left: ");dump_Variant(left);
5549     TRACE("right: ");dump_Variant(right);
5550
5551     VariantInit(&lv);VariantInit(&rv);
5552     lvt = V_VT(left)&VT_TYPEMASK;
5553     rvt = V_VT(right)&VT_TYPEMASK;
5554     found = FALSE;resvt=VT_VOID;
5555     if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5556         found = TRUE;
5557         resvt = VT_R8;
5558     }
5559     if (!found && (((1<<lvt) | (1<<rvt)) & ((1<<VT_I1)|(1<<VT_I2)|(1<<VT_UI1)|(1<<VT_UI2)|(1<<VT_I4)|(1<<VT_UI4)|(1<<VT_INT)|(1<<VT_UINT)))) {
5560         found = TRUE;
5561         resvt = VT_I4;
5562     }
5563     if (!found) {
5564         FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5565         return E_FAIL;
5566     }
5567     rc = VariantChangeType(&lv, left, 0, resvt);
5568     if (FAILED(rc)) {
5569         FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5570         return rc;
5571     }
5572     rc = VariantChangeType(&rv, right, 0, resvt);
5573     if (FAILED(rc)) {
5574         FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5575         return rc;
5576     }
5577     switch (resvt) {
5578     case VT_R8:
5579         V_VT(result) = resvt;
5580         V_R8(result) = V_R8(&lv) * V_R8(&rv);
5581         rc = S_OK;
5582         break;
5583     case VT_I4:
5584         V_VT(result) = resvt;
5585         V_I4(result) = V_I4(&lv) * V_I4(&rv);
5586         rc = S_OK;
5587         break;
5588     }
5589     TRACE("rc=%d, Result:\n", (int) rc);
5590     dump_Variant(result);
5591     return rc;
5592 }
5593
5594 /**********************************************************************
5595  *              VarDiv [OLEAUT32.143]
5596  *
5597  */
5598 HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5599 {
5600     HRESULT rc = E_FAIL;
5601     VARTYPE lvt,rvt,resvt;
5602     VARIANT lv,rv;
5603     BOOL found;
5604
5605     TRACE("left: ");dump_Variant(left);
5606     TRACE("right: ");dump_Variant(right);
5607
5608     VariantInit(&lv);VariantInit(&rv);
5609     lvt = V_VT(left)&VT_TYPEMASK;
5610     rvt = V_VT(right)&VT_TYPEMASK;
5611     found = FALSE;resvt = VT_VOID;
5612     if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5613         found = TRUE;
5614         resvt = VT_R8;
5615     }
5616     if (!found && (((1<<lvt) | (1<<rvt)) & ((1<<VT_I1)|(1<<VT_I2)|(1<<VT_UI1)|(1<<VT_UI2)|(1<<VT_I4)|(1<<VT_UI4)|(1<<VT_INT)|(1<<VT_UINT)))) {
5617         found = TRUE;
5618         resvt = VT_I4;
5619     }
5620     if (!found) {
5621         FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5622         return E_FAIL;
5623     }
5624     rc = VariantChangeType(&lv, left, 0, resvt);
5625     if (FAILED(rc)) {
5626         FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5627         return rc;
5628     }
5629     rc = VariantChangeType(&rv, right, 0, resvt);
5630     if (FAILED(rc)) {
5631         FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5632         return rc;
5633     }
5634     switch (resvt) {
5635     case VT_R8:
5636         V_VT(result) = resvt;
5637         V_R8(result) = V_R8(&lv) / V_R8(&rv);
5638         rc = S_OK;
5639         break;
5640     case VT_I4:
5641         V_VT(result) = resvt;
5642         V_I4(result) = V_I4(&lv) / V_I4(&rv);
5643         rc = S_OK;
5644         break;
5645     }
5646     TRACE("rc=%d, Result:\n", (int) rc);
5647     dump_Variant(result);
5648     return rc;
5649 }
5650
5651 /**********************************************************************
5652  *              VarSub [OLEAUT32.159]
5653  *
5654  */
5655 HRESULT WINAPI VarSub(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5656 {
5657     HRESULT rc = E_FAIL;
5658     VARTYPE lvt,rvt,resvt;
5659     VARIANT lv,rv;
5660     BOOL found;
5661
5662     TRACE("left: ");dump_Variant(left);
5663     TRACE("right: ");dump_Variant(right);
5664
5665     VariantInit(&lv);VariantInit(&rv);
5666     lvt = V_VT(left)&VT_TYPEMASK;
5667     rvt = V_VT(right)&VT_TYPEMASK;
5668     found = FALSE;resvt = VT_VOID;
5669     if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5670         found = TRUE;
5671         resvt = VT_R8;
5672     }
5673     if (!found && (((1<<lvt) | (1<<rvt)) & ((1<<VT_I1)|(1<<VT_I2)|(1<<VT_UI1)|(1<<VT_UI2)|(1<<VT_I4)|(1<<VT_UI4)|(1<<VT_INT)|(1<<VT_UINT)))) {
5674         found = TRUE;
5675         resvt = VT_I4;
5676     }
5677     if (!found) {
5678         FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5679         return E_FAIL;
5680     }
5681     rc = VariantChangeType(&lv, left, 0, resvt);
5682     if (FAILED(rc)) {
5683         FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5684         return rc;
5685     }
5686     rc = VariantChangeType(&rv, right, 0, resvt);
5687     if (FAILED(rc)) {
5688         FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5689         return rc;
5690     }
5691     switch (resvt) {
5692     case VT_R8:
5693         V_VT(result) = resvt;
5694         V_R8(result) = V_R8(&lv) - V_R8(&rv);
5695         rc = S_OK;
5696         break;
5697     case VT_I4:
5698         V_VT(result) = resvt;
5699         V_I4(result) = V_I4(&lv) - V_I4(&rv);
5700         rc = S_OK;
5701         break;
5702     }
5703     TRACE("rc=%d, Result:\n", (int) rc);
5704     dump_Variant(result);
5705     return rc;
5706 }
5707
5708 /**********************************************************************
5709  *              VarOr [OLEAUT32.157]
5710  *
5711  */
5712 HRESULT WINAPI VarOr(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5713 {
5714     HRESULT rc = E_FAIL;
5715
5716     TRACE("Left Var:\n");
5717     dump_Variant(left);
5718     TRACE("Right Var:\n");
5719     dump_Variant(right);
5720
5721     if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5722         (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5723
5724         V_VT(result) = VT_BOOL;
5725         if (V_BOOL(left) || V_BOOL(right)) {
5726             V_BOOL(result) = VARIANT_TRUE;
5727         } else {
5728             V_BOOL(result) = VARIANT_FALSE;
5729         }
5730         rc = S_OK;
5731
5732     } else {
5733         /* Integers */
5734         BOOL         lOk        = TRUE;
5735         BOOL         rOk        = TRUE;
5736         LONGLONG     lVal = -1;
5737         LONGLONG     rVal = -1;
5738         LONGLONG     res  = -1;
5739         int          resT = 0; /* Testing has shown I2 & I2 == I2, all else
5740                                   becomes I4, even unsigned ints (incl. UI2) */
5741
5742         lOk = TRUE;
5743         switch (V_VT(left)&VT_TYPEMASK) {
5744         case VT_I1   : lVal = V_UNION(left,cVal);  resT=VT_I4; break;
5745         case VT_I2   : lVal = V_UNION(left,iVal);  resT=VT_I2; break;
5746         case VT_I4   : lVal = V_UNION(left,lVal);  resT=VT_I4; break;
5747         case VT_INT  : lVal = V_UNION(left,lVal);  resT=VT_I4; break;
5748         case VT_UI1  : lVal = V_UNION(left,bVal);  resT=VT_I4; break;
5749         case VT_UI2  : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5750         case VT_UI4  : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5751         case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5752         default: lOk = FALSE;
5753         }
5754
5755         rOk = TRUE;
5756         switch (V_VT(right)&VT_TYPEMASK) {
5757         case VT_I1   : rVal = V_UNION(right,cVal);  resT=VT_I4; break;
5758         case VT_I2   : rVal = V_UNION(right,iVal);  resT=max(VT_I2, resT); break;
5759         case VT_I4   : rVal = V_UNION(right,lVal);  resT=VT_I4; break;
5760         case VT_INT  : rVal = V_UNION(right,lVal);  resT=VT_I4; break;
5761         case VT_UI1  : rVal = V_UNION(right,bVal);  resT=VT_I4; break;
5762         case VT_UI2  : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5763         case VT_UI4  : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5764         case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5765         default: rOk = FALSE;
5766         }
5767
5768         if (lOk && rOk) {
5769             res = (lVal | rVal);
5770             V_VT(result) = resT;
5771             switch (resT) {
5772             case VT_I2   : V_UNION(result,iVal)  = res; break;
5773             case VT_I4   : V_UNION(result,lVal)  = res; break;
5774             default:
5775                 FIXME("Unexpected result variant type %x\n", resT);
5776                 V_UNION(result,lVal)  = res;
5777             }
5778             rc = S_OK;
5779
5780         } else {
5781             FIXME("unimplemented part\n");
5782         }
5783     }
5784
5785     TRACE("rc=%d, Result:\n", (int) rc);
5786     dump_Variant(result);
5787     return rc;
5788 }
5789
5790 /**********************************************************************
5791  *              VarNot [OLEAUT32.174]
5792  *
5793  */
5794 HRESULT WINAPI VarNot(LPVARIANT in, LPVARIANT result)
5795 {
5796     HRESULT rc = E_FAIL;
5797
5798     TRACE("Var In:\n");
5799     dump_Variant(in);
5800
5801     if ((V_VT(in)&VT_TYPEMASK) == VT_BOOL) {
5802
5803         V_VT(result) = VT_BOOL;
5804         if (V_BOOL(in)) {
5805             V_BOOL(result) = VARIANT_FALSE;
5806         } else {
5807             V_BOOL(result) = VARIANT_TRUE;
5808         }
5809         rc = S_OK;
5810
5811     } else {
5812         FIXME("VarNot stub\n");
5813     }
5814
5815     TRACE("rc=%d, Result:\n", (int) rc);
5816     dump_Variant(result);
5817     return rc;
5818 }
5819
5820 /**********************************************************************
5821  *              VarTokenizeFormatString [OLEAUT32.140]
5822  *
5823  * From investigation on W2K, a list is built up which is:
5824  *
5825  * <0x00> AA BB - Copy from AA for BB chars (Note 1 byte with wrap!)
5826  * <token> - Insert appropriate token
5827  *
5828  */
5829 HRESULT WINAPI VarTokenizeFormatString(LPOLESTR  format, LPBYTE rgbTok,
5830                      int   cbTok, int iFirstDay, int iFirstWeek,
5831                      LCID  lcid, int *pcbActual) {
5832
5833     FORMATHDR *hdr;
5834     int        realLen, formatLeft;
5835     BYTE      *pData;
5836     LPSTR      pFormatA, pStart;
5837     int        checkStr;
5838     BOOL       insertCopy = FALSE;
5839     LPSTR      copyFrom = NULL;
5840
5841     TRACE("'%s', %p %d %d %d only date support\n", debugstr_w(format), rgbTok, cbTok,
5842                    iFirstDay, iFirstWeek);
5843
5844     /* Big enough for header? */
5845     if (cbTok < sizeof(FORMATHDR)) {
5846         return TYPE_E_BUFFERTOOSMALL;
5847     }
5848
5849     /* Insert header */
5850     hdr = (FORMATHDR *) rgbTok;
5851     memset(hdr, 0x00, sizeof(FORMATHDR));
5852     hdr->hex3 = 0x03; /* No idea what these are */
5853     hdr->hex6 = 0x06;
5854
5855     /* Start parsing string */
5856     realLen    = sizeof(FORMATHDR);
5857     pData      = rgbTok + realLen;
5858     pFormatA   = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5859     pStart     = pFormatA;
5860     formatLeft = strlen(pFormatA);
5861
5862     /* Work through the format */
5863     while (*pFormatA != 0x00) {
5864
5865         checkStr = 0;
5866         while (checkStr>=0 && (formatTokens[checkStr].tokenSize != 0x00)) {
5867             if (formatLeft >= formatTokens[checkStr].tokenSize &&
5868                 strncmp(formatTokens[checkStr].str, pFormatA,
5869                         formatTokens[checkStr].tokenSize) == 0) {
5870                 TRACE("match on '%s'\n", formatTokens[checkStr].str);
5871
5872                 /* Found Match! */
5873
5874                 /* If we have skipped chars, insert the copy */
5875                 if (insertCopy == TRUE) {
5876
5877                     if ((realLen + 3) > cbTok) {
5878                         HeapFree( GetProcessHeap(), 0, pFormatA );
5879                         return TYPE_E_BUFFERTOOSMALL;
5880                     }
5881                     insertCopy = FALSE;
5882                     *pData = TOK_COPY;
5883                     pData++;
5884                     *pData = (BYTE)(copyFrom - pStart);
5885                     pData++;
5886                     *pData = (BYTE)(pFormatA - copyFrom);
5887                     pData++;
5888                     realLen = realLen + 3;
5889                 }
5890
5891
5892                 /* Now insert the token itself */
5893                 if ((realLen + 1) > cbTok) {
5894                     HeapFree( GetProcessHeap(), 0, pFormatA );
5895                     return TYPE_E_BUFFERTOOSMALL;
5896                 }
5897                 *pData = formatTokens[checkStr].tokenId;
5898                 pData = pData + 1;
5899                 realLen = realLen + 1;
5900
5901                 pFormatA = pFormatA + formatTokens[checkStr].tokenSize;
5902                 formatLeft = formatLeft - formatTokens[checkStr].tokenSize;
5903                 checkStr = -1; /* Flag as found and break out of while loop */
5904             } else {
5905                 checkStr++;
5906             }
5907         }
5908
5909         /* Did we ever match a token? */
5910         if (checkStr != -1 && insertCopy == FALSE) {
5911             TRACE("No match - need to insert copy from %p [%p]\n", pFormatA, pStart);
5912             insertCopy = TRUE;
5913             copyFrom   = pFormatA;
5914         } else if (checkStr != -1) {
5915             pFormatA = pFormatA + 1;
5916         }
5917
5918     }
5919
5920     /* Finally, if we have skipped chars, insert the copy */
5921     if (insertCopy == TRUE) {
5922
5923         TRACE("Chars left over, so still copy %p,%p,%p\n", copyFrom, pStart, pFormatA);
5924         if ((realLen + 3) > cbTok) {
5925             HeapFree( GetProcessHeap(), 0, pFormatA );
5926             return TYPE_E_BUFFERTOOSMALL;
5927         }
5928         insertCopy = FALSE;
5929         *pData = TOK_COPY;
5930         pData++;
5931         *pData = (BYTE)(copyFrom - pStart);
5932         pData++;
5933         *pData = (BYTE)(pFormatA - copyFrom);
5934         pData++;
5935         realLen = realLen + 3;
5936     }
5937
5938     /* Finally insert the terminator */
5939     if ((realLen + 1) > cbTok) {
5940         HeapFree( GetProcessHeap(), 0, pFormatA );
5941         return TYPE_E_BUFFERTOOSMALL;
5942     }
5943     *pData++ = TOK_END;
5944     realLen = realLen + 1;
5945
5946     /* Finally fill in the length */
5947     hdr->len = realLen;
5948     *pcbActual = realLen;
5949
5950 #if 0
5951     { int i,j;
5952       for (i=0; i<realLen; i=i+0x10) {
5953           printf(" %4.4x : ", i);
5954           for (j=0; j<0x10 && (i+j < realLen); j++) {
5955               printf("%2.2x ", rgbTok[i+j]);
5956           }
5957           printf("\n");
5958       }
5959     }
5960 #endif
5961     HeapFree( GetProcessHeap(), 0, pFormatA );
5962
5963     return S_OK;
5964 }
5965
5966 /**********************************************************************
5967  *              VarFormatFromTokens [OLEAUT32.139]
5968  * FIXME: No account of flags or iFirstDay etc
5969  */
5970 HRESULT WINAPI VarFormatFromTokens(LPVARIANT varIn, LPOLESTR format,
5971                             LPBYTE pbTokCur, ULONG dwFlags, BSTR *pbstrOut,
5972                             LCID  lcid) {
5973
5974     FORMATHDR   *hdr = (FORMATHDR *)pbTokCur;
5975     BYTE        *pData    = pbTokCur + sizeof (FORMATHDR);
5976     LPSTR        pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5977     char         output[BUFFER_MAX];
5978     char        *pNextPos;
5979     int          size, whichToken;
5980     VARIANTARG   Variant;
5981     struct tm    TM;
5982
5983
5984
5985     TRACE("'%s', %p %lx %p only date support\n", pFormatA, pbTokCur, dwFlags, pbstrOut);
5986     TRACE("varIn:\n");
5987     dump_Variant(varIn);
5988
5989     memset(output, 0x00, BUFFER_MAX);
5990     pNextPos = output;
5991
5992     while (*pData != TOK_END && ((pData - pbTokCur) <= (hdr->len))) {
5993
5994         TRACE("Output looks like : '%s'\n", output);
5995
5996         /* Convert varient to appropriate data type */
5997         whichToken = 0;
5998         while ((formatTokens[whichToken].tokenSize != 0x00) &&
5999                (formatTokens[whichToken].tokenId   != *pData)) {
6000             whichToken++;
6001         }
6002
6003         /* Use Variant local from here downwards as always correct type */
6004         if (formatTokens[whichToken].tokenSize > 0 &&
6005             formatTokens[whichToken].varTypeRequired != 0) {
6006                         VariantInit( &Variant );
6007             if (Coerce( &Variant, lcid, dwFlags, varIn,
6008                         formatTokens[whichToken].varTypeRequired ) != S_OK) {
6009                 HeapFree( GetProcessHeap(), 0, pFormatA );
6010                 return DISP_E_TYPEMISMATCH;
6011             } else if (formatTokens[whichToken].varTypeRequired == VT_DATE) {
6012                 if( DateToTm( V_UNION(&Variant,date), dwFlags, &TM ) == FALSE ) {
6013                     HeapFree( GetProcessHeap(), 0, pFormatA );
6014                     return E_INVALIDARG;
6015                 }
6016             }
6017         }
6018
6019         TRACE("Looking for match on token '%x'\n", *pData);
6020         switch (*pData) {
6021         case TOK_COPY:
6022             TRACE("Copy from %d for %d bytes\n", *(pData+1), *(pData+2));
6023             memcpy(pNextPos, &pFormatA[*(pData+1)], *(pData+2));
6024             pNextPos = pNextPos + *(pData+2);
6025             pData = pData + 3;
6026             break;
6027
6028         case TOK_COLON   :
6029             /* Get locale information - Time Separator */
6030             size = GetLocaleInfoA(lcid, LOCALE_STIME, NULL, 0);
6031             GetLocaleInfoA(lcid, LOCALE_STIME, pNextPos, size);
6032             TRACE("TOK_COLON Time separator is '%s'\n", pNextPos);
6033             pNextPos = pNextPos + size;
6034             pData = pData + 1;
6035             break;
6036
6037         case TOK_SLASH   :
6038             /* Get locale information - Date Separator */
6039             size = GetLocaleInfoA(lcid, LOCALE_SDATE, NULL, 0);
6040             GetLocaleInfoA(lcid, LOCALE_SDATE, pNextPos, size);
6041             TRACE("TOK_COLON Time separator is '%s'\n", pNextPos);
6042             pNextPos = pNextPos + size;
6043             pData = pData + 1;
6044             break;
6045
6046         case TOK_d       :
6047             sprintf(pNextPos, "%d", TM.tm_mday);
6048             pNextPos = pNextPos + strlen(pNextPos);
6049             pData = pData + 1;
6050             break;
6051
6052         case TOK_dd      :
6053             sprintf(pNextPos, "%2.2d", TM.tm_mday);
6054             pNextPos = pNextPos + strlen(pNextPos);
6055             pData = pData + 1;
6056             break;
6057
6058         case TOK_w       :
6059             sprintf(pNextPos, "%d", TM.tm_wday+1);
6060             pNextPos = pNextPos + strlen(pNextPos);
6061             pData = pData + 1;
6062             break;
6063
6064         case TOK_m       :
6065             sprintf(pNextPos, "%d", TM.tm_mon+1);
6066             pNextPos = pNextPos + strlen(pNextPos);
6067             pData = pData + 1;
6068             break;
6069
6070         case TOK_mm      :
6071             sprintf(pNextPos, "%2.2d", TM.tm_mon+1);
6072             pNextPos = pNextPos + strlen(pNextPos);
6073             pData = pData + 1;
6074             break;
6075
6076         case TOK_q       :
6077             sprintf(pNextPos, "%d", ((TM.tm_mon+1)/4)+1);
6078             pNextPos = pNextPos + strlen(pNextPos);
6079             pData = pData + 1;
6080             break;
6081
6082         case TOK_y       :
6083             sprintf(pNextPos, "%2.2d", TM.tm_yday+1);
6084             pNextPos = pNextPos + strlen(pNextPos);
6085             pData = pData + 1;
6086             break;
6087
6088         case TOK_yy      :
6089             sprintf(pNextPos, "%2.2d", TM.tm_year);
6090             pNextPos = pNextPos + strlen(pNextPos);
6091             pData = pData + 1;
6092             break;
6093
6094         case TOK_yyyy    :
6095             sprintf(pNextPos, "%4.4d", TM.tm_year);
6096             pNextPos = pNextPos + strlen(pNextPos);
6097             pData = pData + 1;
6098             break;
6099
6100         case TOK_h       :
6101             sprintf(pNextPos, "%d", TM.tm_hour);
6102             pNextPos = pNextPos + strlen(pNextPos);
6103             pData = pData + 1;
6104             break;
6105
6106         case TOK_Hh      :
6107             sprintf(pNextPos, "%2.2d", TM.tm_hour);
6108             pNextPos = pNextPos + strlen(pNextPos);
6109             pData = pData + 1;
6110             break;
6111
6112         case TOK_N       :
6113             sprintf(pNextPos, "%d", TM.tm_min);
6114             pNextPos = pNextPos + strlen(pNextPos);
6115             pData = pData + 1;
6116             break;
6117
6118         case TOK_Nn      :
6119             sprintf(pNextPos, "%2.2d", TM.tm_min);
6120             pNextPos = pNextPos + strlen(pNextPos);
6121             pData = pData + 1;
6122             break;
6123
6124         case TOK_S       :
6125             sprintf(pNextPos, "%d", TM.tm_sec);
6126             pNextPos = pNextPos + strlen(pNextPos);
6127             pData = pData + 1;
6128             break;
6129
6130         case TOK_Ss      :
6131             sprintf(pNextPos, "%2.2d", TM.tm_sec);
6132             pNextPos = pNextPos + strlen(pNextPos);
6133             pData = pData + 1;
6134             break;
6135
6136         /* FIXME: To Do! */
6137         case TOK_ttttt   :
6138         case TOK_AMsPM   :
6139         case TOK_amspm   :
6140         case TOK_AsP     :
6141         case TOK_asp     :
6142         case TOK_AMPM    :
6143         case TOK_c       :
6144         case TOK_ddd     :
6145         case TOK_dddd    :
6146         case TOK_ddddd   :
6147         case TOK_dddddd  :
6148         case TOK_ww      :
6149         case TOK_mmm     :
6150         case TOK_mmmm    :
6151         default:
6152             FIXME("Unhandled token for VarFormat %d\n", *pData);
6153             HeapFree( GetProcessHeap(), 0, pFormatA );
6154             return E_INVALIDARG;
6155         }
6156
6157     }
6158
6159     *pbstrOut = StringDupAtoBstr( output );
6160     HeapFree( GetProcessHeap(), 0, pFormatA );
6161     return S_OK;
6162 }
6163
6164 /**********************************************************************
6165  *              VarFormat [OLEAUT32.87]
6166  *
6167  */
6168 HRESULT WINAPI VarFormat(LPVARIANT varIn, LPOLESTR format,
6169                          int firstDay, int firstWeek, ULONG dwFlags,
6170                          BSTR *pbstrOut) {
6171
6172     LPSTR   pNewString = NULL;
6173     HRESULT rc = S_OK;
6174
6175     TRACE("mostly stub! format='%s' day=%d, wk=%d, flags=%ld\n",
6176           debugstr_w(format), firstDay, firstWeek, dwFlags);
6177     TRACE("varIn:\n");
6178     dump_Variant(varIn);
6179
6180     /* Note: Must Handle references type Variants (contain ptrs
6181           to values rather than values */
6182
6183     /* Get format string */
6184     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
6185
6186     /* FIXME: Handle some simple pre-definted format strings : */
6187     if (((V_VT(varIn)&VT_TYPEMASK) == VT_CY) && (lstrcmpiA(pNewString, "Currency") == 0)) {
6188
6189         /* Can't use VarBstrFromCy as it does not put currency sign on nor decimal places */
6190         double curVal;
6191
6192
6193         /* Handle references type Variants (contain ptrs to values rather than values */
6194         if (V_VT(varIn)&VT_BYREF) {
6195             rc = VarR8FromCy(*(CY *)V_UNION(varIn,byref), &curVal);
6196         } else {
6197             rc = VarR8FromCy(V_UNION(varIn,cyVal), &curVal);
6198         }
6199
6200         if (rc == S_OK) {
6201             char tmpStr[BUFFER_MAX];
6202             sprintf(tmpStr, "%f", curVal);
6203             if (GetCurrencyFormatA(GetUserDefaultLCID(), dwFlags, tmpStr, NULL, pBuffer, BUFFER_MAX) == 0) {
6204                 return E_FAIL;
6205             } else {
6206                 *pbstrOut = StringDupAtoBstr( pBuffer );
6207             }
6208         }
6209
6210     } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_DATE) {
6211
6212         /* Attempt to do proper formatting! */
6213         int firstToken = -1;
6214
6215         rc = VarTokenizeFormatString(format, pBuffer, sizeof(pBuffer), firstDay,
6216                                   firstWeek, GetUserDefaultLCID(), &firstToken);
6217         if (rc==S_OK) {
6218             rc = VarFormatFromTokens(varIn, format, pBuffer, dwFlags, pbstrOut, GetUserDefaultLCID());
6219         }
6220
6221     } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_R8) {
6222         if (V_VT(varIn)&VT_BYREF) {
6223             sprintf(pBuffer, "%f", *V_UNION(varIn,pdblVal));
6224         } else {
6225             sprintf(pBuffer, "%f", V_UNION(varIn,dblVal));
6226         }
6227         *pbstrOut = StringDupAtoBstr( pBuffer );
6228     } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_I2) {
6229         if (V_VT(varIn)&VT_BYREF) {
6230             sprintf(pBuffer, "%d", *V_UNION(varIn,piVal));
6231         } else {
6232             sprintf(pBuffer, "%d", V_UNION(varIn,iVal));
6233         }
6234         *pbstrOut = StringDupAtoBstr( pBuffer );
6235     } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_BSTR) {
6236         if (V_VT(varIn)&VT_BYREF)
6237             *pbstrOut = SysAllocString( *V_UNION(varIn,pbstrVal) );
6238         else
6239             *pbstrOut = SysAllocString( V_UNION(varIn,bstrVal) );
6240     } else {
6241         FIXME("VarFormat: Unsupported format %d!\n", V_VT(varIn)&VT_TYPEMASK);
6242         *pbstrOut = StringDupAtoBstr( "??" );
6243     }
6244
6245     /* Free allocated storage */
6246     HeapFree( GetProcessHeap(), 0, pNewString );
6247     TRACE("result: '%s'\n", debugstr_w(*pbstrOut));
6248     return rc;
6249 }
6250
6251 /**********************************************************************
6252  *              VarCyMulI4 [OLEAUT32.304]
6253  * Multiply currency value by integer
6254  */
6255 HRESULT WINAPI VarCyMulI4(CY cyIn, LONG mulBy, CY *pcyOut) {
6256
6257     double cyVal = 0;
6258     HRESULT rc = S_OK;
6259
6260     rc = VarR8FromCy(cyIn, &cyVal);
6261     if (rc == S_OK) {
6262         rc = VarCyFromR8((cyVal * (double) mulBy), pcyOut);
6263         TRACE("Multiply %f by %ld = %f [%ld,%lu]\n", cyVal, mulBy, (cyVal * (double) mulBy),
6264                     pcyOut->s.Hi, pcyOut->s.Lo);
6265     }
6266     return rc;
6267 }
6268
6269 /**********************************************************************
6270  *              VarMod [OLEAUT32.154]
6271  *
6272  */
6273 HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
6274 {
6275     FIXME("%p %p %p\n", left, right, result);
6276     return E_FAIL;
6277 }