Ignore:
Timestamp:
Sep 15, 2001, 11:32:00 AM (24 years ago)
Author:
sandervl
Message:

restored old version + wine update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/oleaut32/variant.c

    r6689 r6711  
    2828
    2929#include "config.h"
    30 
     30 
    3131#include <string.h>
    3232#include <stdlib.h>
    … …  
    106106
    107107/******************************************************************************
    108  *     DateTimeStringToTm   [INTERNAL]
     108 *         DateTimeStringToTm   [INTERNAL]
    109109 *
    110110 * Converts a string representation of a date and/or time to a tm structure.
    … …  
    122122static BOOL DateTimeStringToTm( OLECHAR* strIn, DWORD dwFlags, struct tm* pTm )
    123123{
    124     BOOL res = FALSE;
    125     double      fsec;
    126     int         tzp;
    127     int         dtype;
    128     int         nf;
    129     char       *field[MAXDATEFIELDS];
    130     int         ftype[MAXDATEFIELDS];
    131     char        lowstr[MAXDATELEN + 1];
    132     char* strDateTime = NULL;
    133 
    134     /* Convert the string to ASCII since this is the only format
    135     * postgesql can handle.
    136     */
    137     strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    138 
    139     if( strDateTime != NULL )
    140     {
    141         /* Make sure we don't go over the maximum length
    142         * accepted by postgesql.
    143         */
    144         if( strlen( strDateTime ) <= MAXDATELEN )
    145         {
    146             if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
    147             {
    148                 if( dwFlags & VAR_DATEVALUEONLY )
    149                 {
    150                     /* Get the date information.
    151                     * It returns 0 if date information was
    152                     * present and 1 if only time information was present.
    153                     * -1 if an error occures.
    154                     */
    155                     if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
    156                     {
    157                         /* Eliminate the time information since we
    158                         * were asked to get date information only.
    159                         */
    160                         pTm->tm_sec = 0;
    161                         pTm->tm_min = 0;
    162                         pTm->tm_hour = 0;
    163                         res = TRUE;
    164                     }
    165                 }
    166                 if( dwFlags & VAR_TIMEVALUEONLY )
    167                 {
    168                     /* Get time information only.
    169                     */
    170                     if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
    171                     {
    172                         res = TRUE;
    173                     }
    174                 }
    175                 else
    176                 {
    177                     /* Get both date and time information.
    178                     * It returns 0 if date information was
    179                     * present and 1 if only time information was present.
    180                     * -1 if an error occures.
    181                     */
    182                     if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
    183                     {
    184                         res = TRUE;
    185                     }
    186                 }
    187             }
    188         }
    189         HeapFree( GetProcessHeap(), 0, strDateTime );
    190     }
    191 
    192     return res;
    193 }
    194 
    195 
    196 
    197 
    198 
    199 
    200 /******************************************************************************
    201  *     TmToDATE     [INTERNAL]
     124        BOOL res = FALSE;
     125        double          fsec;
     126        int             tzp;
     127        int             dtype;
     128        int             nf;
     129        char       *field[MAXDATEFIELDS];
     130        int             ftype[MAXDATEFIELDS];
     131        char            lowstr[MAXDATELEN + 1];
     132        char* strDateTime = NULL;
     133
     134        /* Convert the string to ASCII since this is the only format
     135        * postgesql can handle.
     136        */
     137        strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     138
     139        if( strDateTime != NULL )
     140        {
     141                /* Make sure we don't go over the maximum length
     142                * accepted by postgesql.
     143                */
     144                if( strlen( strDateTime ) <= MAXDATELEN )
     145                {
     146                        if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
     147                        {
     148                                if( dwFlags & VAR_DATEVALUEONLY )
     149                                {
     150                                        /* Get the date information.
     151                                        * It returns 0 if date information was
     152                                        * present and 1 if only time information was present.
     153                                        * -1 if an error occures.
     154                                        */
     155                                        if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
     156                                        {
     157                                                /* Eliminate the time information since we
     158                                                * were asked to get date information only.
     159                                                */
     160                                                pTm->tm_sec = 0;
     161                                                pTm->tm_min = 0;
     162                                                pTm->tm_hour = 0;
     163                                                res = TRUE;
     164                                        }
     165                                }
     166                                if( dwFlags & VAR_TIMEVALUEONLY )
     167                                {
     168                                        /* Get time information only.
     169                                        */
     170                                        if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
     171                                        {
     172                                                res = TRUE;
     173                                        }
     174                                }
     175                                else
     176                                {
     177                                        /* Get both date and time information.
     178                                        * It returns 0 if date information was
     179                                        * present and 1 if only time information was present.
     180                                        * -1 if an error occures.
     181                                        */
     182                                        if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
     183                                        {
     184                                                res = TRUE;
     185                                        }
     186                                }
     187                        }
     188                }
     189                HeapFree( GetProcessHeap(), 0, strDateTime );
     190        }
     191
     192        return res;
     193}
     194
     195
     196
     197
     198
     199
     200/******************************************************************************
     201 *         TmToDATE     [INTERNAL]
    202202 *
    203203 * The date is implemented using an 8 byte floating-point number.
    … …  
    216216 * The tm structure is as follows:
    217217 * struct tm {
    218  *        int tm_sec;      seconds after the minute - [0,59]
    219  *        int tm_min;      minutes after the hour - [0,59]
    220  *        int tm_hour;     hours since midnight - [0,23]
    221  *        int tm_mday;     day of the month - [1,31]
    222  *        int tm_mon;      months since January - [0,11]
    223  *        int tm_year;     years
    224  *        int tm_wday;     days since Sunday - [0,6]
    225  *        int tm_yday;     days since January 1 - [0,365]
    226  *        int tm_isdst;    daylight savings time flag
    227  *        };
     218 *                int tm_sec;      seconds after the minute - [0,59]
     219 *                int tm_min;      minutes after the hour - [0,59]
     220 *                int tm_hour;     hours since midnight - [0,23]
     221 *                int tm_mday;     day of the month - [1,31]
     222 *                int tm_mon;      months since January - [0,11]
     223 *                int tm_year;     years
     224 *                int tm_wday;     days since Sunday - [0,6]
     225 *                int tm_yday;     days since January 1 - [0,365]
     226 *                int tm_isdst;    daylight savings time flag
     227 *                };
    228228 *
    229229 * Note: This function does not use the tm_wday, tm_yday, tm_wday,
    … …  
    235235static BOOL TmToDATE( struct tm* pTm, DATE *pDateOut )
    236236{
    237     if( (pTm->tm_year - 1900) >= 0 )
    238     {
    239         int leapYear = 0;
    240 
    241         /* Start at 1. This is the way DATE is defined.
    242         * January 1, 1900 at Midnight is 1.00.
    243         * January 1, 1900 at 6AM is 1.25.
    244         * and so on.
    245         */
    246         *pDateOut = 1;
    247 
    248         /* Add the number of days corresponding to
    249         * tm_year.
    250         */
    251         *pDateOut += (pTm->tm_year - 1900) * 365;
    252 
    253         /* Add the leap days in the previous years between now and 1900.
    254         * Note a leap year is one that is a multiple of 4
    255         * but not of a 100.  Except if it is a multiple of
    256         * 400 then it is a leap year.
    257         */
    258         *pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
    259         *pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
    260         *pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
    261 
    262         /* Set the leap year flag if the
    263         * current year specified by tm_year is a
    264         * leap year. This will be used to add a day
    265         * to the day count.
    266         */
    267         if( isleap( pTm->tm_year ) )
    268             leapYear = 1;
    269 
    270         /* Add the number of days corresponding to
    271         * the month.
    272         */
    273         switch( pTm->tm_mon )
    274         {
    275         case 2:
    276             *pDateOut += 31;
    277             break;
    278         case 3:
    279             *pDateOut += ( 59 + leapYear );
    280             break;
    281         case 4:
    282             *pDateOut += ( 90 + leapYear );
    283             break;
    284         case 5:
    285             *pDateOut += ( 120 + leapYear );
    286             break;
    287         case 6:
    288             *pDateOut += ( 151 + leapYear );
    289             break;
    290         case 7:
    291             *pDateOut += ( 181 + leapYear );
    292             break;
    293         case 8:
    294             *pDateOut += ( 212 + leapYear );
    295             break;
    296         case 9:
    297             *pDateOut += ( 243 + leapYear );
    298             break;
    299         case 10:
    300             *pDateOut += ( 273 + leapYear );
    301             break;
    302         case 11:
    303             *pDateOut += ( 304 + leapYear );
    304             break;
    305         case 12:
    306             *pDateOut += ( 334 + leapYear );
    307             break;
    308         }
    309         /* Add the number of days in this month.
    310         */
    311         *pDateOut += pTm->tm_mday;
    312 
    313         /* Add the number of seconds, minutes, and hours
    314         * to the DATE. Note these are the fracionnal part
    315         * of the DATE so seconds / number of seconds in a day.
    316         */
    317         *pDateOut += pTm->tm_hour / 24.0;
    318         *pDateOut += pTm->tm_min / 1440.0;
    319         *pDateOut += pTm->tm_sec / 86400.0;
    320         return TRUE;
    321     }
    322     return FALSE;
    323 }
    324 
    325 /******************************************************************************
    326  *     DateToTm     [INTERNAL]
     237        if( (pTm->tm_year - 1900) >= 0 )
     238        {
     239                int leapYear = 0;
     240               
     241                /* Start at 1. This is the way DATE is defined.
     242                * January 1, 1900 at Midnight is 1.00.
     243                * January 1, 1900 at 6AM is 1.25.
     244                * and so on.
     245                */
     246                *pDateOut = 1;
     247
     248                /* Add the number of days corresponding to
     249                * tm_year.
     250                */
     251                *pDateOut += (pTm->tm_year - 1900) * 365;
     252
     253                /* Add the leap days in the previous years between now and 1900.
     254                * Note a leap year is one that is a multiple of 4
     255                * but not of a 100.  Except if it is a multiple of
     256                * 400 then it is a leap year.
     257                */
     258                *pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
     259                *pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
     260                *pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
     261
     262                /* Set the leap year flag if the
     263                * current year specified by tm_year is a
     264                * leap year. This will be used to add a day
     265                * to the day count.
     266                */
     267                if( isleap( pTm->tm_year ) )
     268                        leapYear = 1;
     269               
     270                /* Add the number of days corresponding to
     271                * the month.
     272                */
     273                switch( pTm->tm_mon )
     274                {
     275                case 2:
     276                        *pDateOut += 31;
     277                        break;
     278                case 3:
     279                        *pDateOut += ( 59 + leapYear );
     280                        break;
     281                case 4:
     282                        *pDateOut += ( 90 + leapYear );
     283                        break;
     284                case 5:
     285                        *pDateOut += ( 120 + leapYear );
     286                        break;
     287                case 6:
     288                        *pDateOut += ( 151 + leapYear );
     289                        break;
     290                case 7:
     291                        *pDateOut += ( 181 + leapYear );
     292                        break;
     293                case 8:
     294                        *pDateOut += ( 212 + leapYear );
     295                        break;
     296                case 9:
     297                        *pDateOut += ( 243 + leapYear );
     298                        break;
     299                case 10:
     300                        *pDateOut += ( 273 + leapYear );
     301                        break;
     302                case 11:
     303                        *pDateOut += ( 304 + leapYear );
     304                        break;
     305                case 12:
     306                        *pDateOut += ( 334 + leapYear );
     307                        break;
     308                }
     309                /* Add the number of days in this month.
     310                */
     311                *pDateOut += pTm->tm_mday;
     312       
     313                /* Add the number of seconds, minutes, and hours
     314                * to the DATE. Note these are the fracionnal part
     315                * of the DATE so seconds / number of seconds in a day.
     316                */
     317                *pDateOut += pTm->tm_hour / 24.0;
     318                *pDateOut += pTm->tm_min / 1440.0;
     319                *pDateOut += pTm->tm_sec / 86400.0;
     320                return TRUE;
     321        }
     322        return FALSE;
     323}
     324
     325/******************************************************************************
     326 *         DateToTm     [INTERNAL]
    327327 *
    328328 * This function converts a windows DATE to a tm structure.
    … …  
    339339static BOOL DateToTm( DATE dateIn, DWORD dwFlags, struct tm* pTm )
    340340{
    341     /* Do not process dates smaller than January 1, 1900.
    342     * Which corresponds to 2.0 in the windows DATE format.
    343     */
    344     if( dateIn >= 2.0 )
    345     {
    346         double decimalPart = 0.0;
    347         double wholePart = 0.0;
    348 
    349         memset(pTm,0,sizeof(*pTm));
    350 
    351         /* Because of the nature of DATE format which
    352         * associates 2.0 to January 1, 1900. We will
    353         * remove 1.0 from the whole part of the DATE
    354         * so that in the following code 1.0
    355         * will correspond to January 1, 1900.
    356         * This simplifies the processing of the DATE value.
    357         */
    358         dateIn -= 1.0;
    359 
    360         wholePart = (double) floor( dateIn );
    361         decimalPart = fmod( dateIn, wholePart );
    362 
    363         if( !(dwFlags & VAR_TIMEVALUEONLY) )
    364         {
    365             int nDay = 0;
    366             int leapYear = 0;
    367             double yearsSince1900 = 0;
    368             /* Start at 1900, this is where the DATE time 0.0 starts.
    369             */
    370             pTm->tm_year = 1900;
    371             /* find in what year the day in the "wholePart" falls into.
    372             * add the value to the year field.
    373             */
    374             yearsSince1900 = floor( (wholePart / DAYS_IN_ONE_YEAR) + 0.001 );
    375             pTm->tm_year += yearsSince1900;
    376             /* determine if this is a leap year.
    377             */
    378             if( isleap( pTm->tm_year ) )
    379             {
    380                 leapYear = 1;
    381                 wholePart++;
    382             }
    383 
    384             /* find what day of that year the "wholePart" corresponds to.
    385             * Note: nDay is in [1-366] format
    386             */
    387             nDay = (int) ( wholePart - floor( yearsSince1900 * DAYS_IN_ONE_YEAR ) );
    388             /* Set the tm_yday value.
    389             * Note: The day must be converted from [1-366] to [0-365]
    390             */
    391             /*pTm->tm_yday = nDay - 1;*/
    392             /* find which month this day corresponds to.
    393             */
    394             if( nDay <= 31 )
    395             {
    396                 pTm->tm_mday = nDay;
    397                 pTm->tm_mon = 0;
    398             }
    399             else if( nDay <= ( 59 + leapYear ) )
    400             {
    401                 pTm->tm_mday = nDay - 31;
    402                 pTm->tm_mon = 1;
    403             }
    404             else if( nDay <= ( 90 + leapYear ) )
    405             {
    406                 pTm->tm_mday = nDay - ( 59 + leapYear );
    407                 pTm->tm_mon = 2;
    408             }
    409             else if( nDay <= ( 120 + leapYear ) )
    410             {
    411                 pTm->tm_mday = nDay - ( 90 + leapYear );
    412                 pTm->tm_mon = 3;
    413             }
    414             else if( nDay <= ( 151 + leapYear ) )
    415             {
    416                 pTm->tm_mday = nDay - ( 120 + leapYear );
    417                 pTm->tm_mon = 4;
    418             }
    419             else if( nDay <= ( 181 + leapYear ) )
    420             {
    421                 pTm->tm_mday = nDay - ( 151 + leapYear );
    422                 pTm->tm_mon = 5;
    423             }
    424             else if( nDay <= ( 212 + leapYear ) )
    425             {
    426                 pTm->tm_mday = nDay - ( 181 + leapYear );
    427                 pTm->tm_mon = 6;
    428             }
    429             else if( nDay <= ( 243 + leapYear ) )
    430             {
    431                 pTm->tm_mday = nDay - ( 212 + leapYear );
    432                 pTm->tm_mon = 7;
    433             }
    434             else if( nDay <= ( 273 + leapYear ) )
    435             {
    436                 pTm->tm_mday = nDay - ( 243 + leapYear );
    437                 pTm->tm_mon = 8;
    438             }
    439             else if( nDay <= ( 304 + leapYear ) )
    440             {
    441                 pTm->tm_mday = nDay - ( 273 + leapYear );
    442                 pTm->tm_mon = 9;
    443             }
    444             else if( nDay <= ( 334 + leapYear ) )
    445             {
    446                 pTm->tm_mday = nDay - ( 304 + leapYear );
    447                 pTm->tm_mon = 10;
    448             }
    449             else if( nDay <= ( 365 + leapYear ) )
    450             {
    451                 pTm->tm_mday = nDay - ( 334 + leapYear );
    452                 pTm->tm_mon = 11;
    453             }
    454         }
    455         if( !(dwFlags & VAR_DATEVALUEONLY) )
    456         {
    457             /* find the number of seconds in this day.
    458             * fractional part times, hours, minutes, seconds.
    459             */
    460             pTm->tm_hour = (int) ( decimalPart * 24 );
    461             pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
    462             pTm->tm_sec = (int) ( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 );
    463         }
    464         return TRUE;
    465     }
    466     return FALSE;
    467 }
    468 
    469 
    470 
    471 /******************************************************************************
    472  *     SizeOfVariantData    [INTERNAL]
     341        /* Do not process dates smaller than January 1, 1900.
     342        * Which corresponds to 2.0 in the windows DATE format.
     343        */
     344        if( dateIn >= 2.0 )
     345        {
     346                double decimalPart = 0.0;
     347                double wholePart = 0.0;
     348
     349                memset(pTm,0,sizeof(*pTm));
     350       
     351                /* Because of the nature of DATE format which
     352                * associates 2.0 to January 1, 1900. We will
     353                * remove 1.0 from the whole part of the DATE
     354                * so that in the following code 1.0
     355                * will correspond to January 1, 1900.
     356                * This simplifies the processing of the DATE value.
     357                */
     358                dateIn -= 1.0;
     359
     360                wholePart = (double) floor( dateIn );
     361                decimalPart = fmod( dateIn, wholePart );
     362
     363                if( !(dwFlags & VAR_TIMEVALUEONLY) )
     364                {
     365                        int nDay = 0;
     366                        int leapYear = 0;
     367                        double yearsSince1900 = 0;
     368                        /* Start at 1900, this is where the DATE time 0.0 starts.
     369                        */
     370                        pTm->tm_year = 1900;
     371                        /* find in what year the day in the "wholePart" falls into.
     372                        * add the value to the year field.
     373                        */
     374                        yearsSince1900 = floor( (wholePart / DAYS_IN_ONE_YEAR) + 0.001 );
     375                        pTm->tm_year += yearsSince1900;
     376                        /* determine if this is a leap year.
     377                        */
     378                        if( isleap( pTm->tm_year ) )
     379                        {
     380                                leapYear = 1;
     381                                wholePart++;
     382                        }
     383
     384                        /* find what day of that year the "wholePart" corresponds to.
     385                        * Note: nDay is in [1-366] format
     386                        */
     387                        nDay = (int) ( wholePart - floor( yearsSince1900 * DAYS_IN_ONE_YEAR ) );
     388                        /* Set the tm_yday value.
     389                        * Note: The day must be converted from [1-366] to [0-365]
     390                        */
     391                        /*pTm->tm_yday = nDay - 1;*/
     392                        /* find which month this day corresponds to.
     393                        */
     394                        if( nDay <= 31 )
     395                        {
     396                                pTm->tm_mday = nDay;
     397                                pTm->tm_mon = 0;
     398                        }
     399                        else if( nDay <= ( 59 + leapYear ) )
     400                        {
     401                                pTm->tm_mday = nDay - 31;
     402                                pTm->tm_mon = 1;
     403                        }
     404                        else if( nDay <= ( 90 + leapYear ) )
     405                        {
     406                                pTm->tm_mday = nDay - ( 59 + leapYear );
     407                                pTm->tm_mon = 2;
     408                        }
     409                        else if( nDay <= ( 120 + leapYear ) )
     410                        {
     411                                pTm->tm_mday = nDay - ( 90 + leapYear );
     412                                pTm->tm_mon = 3;
     413                        }
     414                        else if( nDay <= ( 151 + leapYear ) )
     415                        {
     416                                pTm->tm_mday = nDay - ( 120 + leapYear );
     417                                pTm->tm_mon = 4;
     418                        }
     419                        else if( nDay <= ( 181 + leapYear ) )
     420                        {
     421                                pTm->tm_mday = nDay - ( 151 + leapYear );
     422                                pTm->tm_mon = 5;
     423                        }
     424                        else if( nDay <= ( 212 + leapYear ) )
     425                        {
     426                                pTm->tm_mday = nDay - ( 181 + leapYear );
     427                                pTm->tm_mon = 6;
     428                        }
     429                        else if( nDay <= ( 243 + leapYear ) )
     430                        {
     431                                pTm->tm_mday = nDay - ( 212 + leapYear );
     432                                pTm->tm_mon = 7;
     433                        }
     434                        else if( nDay <= ( 273 + leapYear ) )
     435                        {
     436                                pTm->tm_mday = nDay - ( 243 + leapYear );
     437                                pTm->tm_mon = 8;
     438                        }
     439                        else if( nDay <= ( 304 + leapYear ) )
     440                        {
     441                                pTm->tm_mday = nDay - ( 273 + leapYear );
     442                                pTm->tm_mon = 9;
     443                        }
     444                        else if( nDay <= ( 334 + leapYear ) )
     445                        {
     446                                pTm->tm_mday = nDay - ( 304 + leapYear );
     447                                pTm->tm_mon = 10;
     448                        }
     449                        else if( nDay <= ( 365 + leapYear ) )
     450                        {
     451                                pTm->tm_mday = nDay - ( 334 + leapYear );
     452                                pTm->tm_mon = 11;
     453                        }
     454                }
     455                if( !(dwFlags & VAR_DATEVALUEONLY) )
     456                {
     457                        /* find the number of seconds in this day.
     458                        * fractional part times, hours, minutes, seconds.
     459                        */
     460                        pTm->tm_hour = (int) ( decimalPart * 24 );
     461                        pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
     462                        pTm->tm_sec = (int) ( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 );
     463                }
     464                return TRUE;
     465        }
     466        return FALSE;
     467}
     468
     469
     470
     471/******************************************************************************
     472 *         SizeOfVariantData    [INTERNAL]
    473473 *
    474474 * This function finds the size of the data referenced by a Variant based
    … …  
    528528}
    529529/******************************************************************************
    530  *     StringDupAtoBstr     [INTERNAL]
    531  *
     530 *         StringDupAtoBstr             [INTERNAL]
     531 * 
    532532 */
    533533static BSTR StringDupAtoBstr( char* strIn )
    534534{
    535     BSTR bstr = NULL;
    536     OLECHAR* pNewString = NULL;
    537     pNewString = HEAP_strdupAtoW( GetProcessHeap(), 0, strIn );
    538     bstr = SysAllocString( pNewString );
    539     HeapFree( GetProcessHeap(), 0, pNewString );
    540     return bstr;
    541 }
    542 
    543 /******************************************************************************
    544  *      round       [INTERNAL]
     535        BSTR bstr = NULL;
     536        OLECHAR* pNewString = NULL;
     537        pNewString = HEAP_strdupAtoW( GetProcessHeap(), 0, strIn );
     538        bstr = SysAllocString( pNewString );
     539        HeapFree( GetProcessHeap(), 0, pNewString );
     540        return bstr;
     541}
     542
     543/******************************************************************************
     544 *              round           [INTERNAL]
    545545 *
    546546 * Round the double value to the nearest integer value.
    … …  
    556556   nSign = (d >= 0.0) ? 1 : -1;
    557557    d = fabs( d );
    558 
    559     /* Remove the decimals.
    560     */
     558   
     559        /* Remove the decimals.
     560        */
    561561   integerValue = floor( d );
    562562
    … …  
    573573    decimals = d - integerValue;
    574574
    575     /* Note: Ceil returns the smallest integer that is greater that x.
    576     * and floor returns the largest integer that is less than or equal to x.
    577     */
     575        /* Note: Ceil returns the smallest integer that is greater that x.
     576        * and floor returns the largest integer that is less than or equal to x.
     577        */
    578578    if( decimals > 0.5 )
    579579    {
    … …  
    603603    }
    604604
    605     return roundedValue * nSign;
    606 }
    607 
    608 /******************************************************************************
    609  *      RemoveCharacterFromString       [INTERNAL]
     605        return roundedValue * nSign;
     606}
     607
     608/******************************************************************************
     609 *              RemoveCharacterFromString               [INTERNAL]
    610610 *
    611611 * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
    … …  
    613613static void RemoveCharacterFromString( LPSTR str, LPSTR strOfCharToRemove )
    614614{
    615     LPSTR pNewString = NULL;
    616     LPSTR strToken = NULL;
    617 
    618 
    619     /* Check if we have a valid argument
    620     */
    621     if( str != NULL )
    622     {
    623         pNewString = strdup( str );
    624         str[0] = '\0';
    625         strToken = strtok( pNewString, strOfCharToRemove );
    626         while( strToken != NULL ) {
    627             strcat( str, strToken );
    628             strToken = strtok( NULL, strOfCharToRemove );
    629         }
    630         free( pNewString );
    631     }
    632     return;
    633 }
    634 
    635 /******************************************************************************
    636  *      GetValidRealString      [INTERNAL]
     615        LPSTR pNewString = NULL;
     616        LPSTR strToken = NULL;
     617
     618
     619        /* Check if we have a valid argument
     620        */
     621        if( str != NULL )
     622        {
     623                pNewString = strdup( str );
     624                str[0] = '\0';
     625                strToken = strtok( pNewString, strOfCharToRemove );
     626                while( strToken != NULL ) {
     627                        strcat( str, strToken );
     628                        strToken = strtok( NULL, strOfCharToRemove );
     629                }
     630                free( pNewString );
     631        }
     632        return;
     633}
     634
     635/******************************************************************************
     636 *              GetValidRealString              [INTERNAL]
    637637 *
    638638 * Checks if the string is of proper format to be converted to a real value.
    … …  
    640640static BOOL IsValidRealString( LPSTR strRealString )
    641641{
    642     /* Real values that have a decimal point are required to either have
    643     * digits before or after the decimal point.  We will assume that
    644     * we do not have any digits at either position. If we do encounter
    645     * some we will disable this flag.
    646     */
    647     BOOL bDigitsRequired = TRUE;
    648     /* Processed fields in the string representation of the real number.
    649     */
    650     BOOL bWhiteSpaceProcessed = FALSE;
    651     BOOL bFirstSignProcessed = FALSE;
    652     BOOL bFirstDigitsProcessed = FALSE;
    653     BOOL bDecimalPointProcessed = FALSE;
    654     BOOL bSecondDigitsProcessed = FALSE;
    655     BOOL bExponentProcessed = FALSE;
    656     BOOL bSecondSignProcessed = FALSE;
    657     BOOL bThirdDigitsProcessed = FALSE;
    658     /* Assume string parameter "strRealString" is valid and try to disprove it.
    659     */
    660     BOOL bValidRealString = TRUE;
    661 
    662     /* Used to count the number of tokens in the "strRealString".
    663     */
    664     LPSTR strToken = NULL;
    665     int nTokens = 0;
    666     LPSTR pChar = NULL;
    667 
    668     /* Check if we have a valid argument
    669     */
    670     if( strRealString == NULL )
    671     {
    672         bValidRealString = FALSE;
    673     }
    674 
    675     if( bValidRealString == TRUE )
    676     {
    677         /* Make sure we only have ONE token in the string.
    678         */
    679         strToken = strtok( strRealString, " " );
    680         while( strToken != NULL ) {
    681             nTokens++;
    682             strToken = strtok( NULL, " " );
    683         }
    684 
    685         if( nTokens != 1 )
    686         {
    687             bValidRealString = FALSE;
    688         }
    689     }
    690 
    691 
    692     /* Make sure this token contains only valid characters.
    693     * The string argument to atof has the following form:
    694     * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
    695     * Whitespace consists of space and|or <TAB> characters, which are ignored.
     642        /* Real values that have a decimal point are required to either have
     643        * digits before or after the decimal point.  We will assume that
     644        * we do not have any digits at either position. If we do encounter
     645        * some we will disable this flag.
     646        */
     647        BOOL bDigitsRequired = TRUE;
     648        /* Processed fields in the string representation of the real number.
     649        */
     650        BOOL bWhiteSpaceProcessed = FALSE;
     651        BOOL bFirstSignProcessed = FALSE;
     652        BOOL bFirstDigitsProcessed = FALSE;
     653        BOOL bDecimalPointProcessed = FALSE;
     654        BOOL bSecondDigitsProcessed = FALSE;
     655        BOOL bExponentProcessed = FALSE;
     656        BOOL bSecondSignProcessed = FALSE;
     657        BOOL bThirdDigitsProcessed = FALSE;
     658        /* Assume string parameter "strRealString" is valid and try to disprove it.
     659        */
     660        BOOL bValidRealString = TRUE;
     661
     662        /* Used to count the number of tokens in the "strRealString".
     663        */
     664        LPSTR strToken = NULL;
     665        int nTokens = 0;
     666        LPSTR pChar = NULL;
     667       
     668        /* Check if we have a valid argument
     669        */
     670        if( strRealString == NULL )
     671        {
     672                bValidRealString = FALSE;
     673        }
     674
     675        if( bValidRealString == TRUE )
     676        {
     677                /* Make sure we only have ONE token in the string.
     678                */
     679                strToken = strtok( strRealString, " " );
     680                while( strToken != NULL ) {
     681                        nTokens++;             
     682                        strToken = strtok( NULL, " " );
     683                }
     684
     685                if( nTokens != 1 )
     686                {
     687                        bValidRealString = FALSE;
     688                }
     689        }
     690
     691
     692        /* Make sure this token contains only valid characters.
     693        * The string argument to atof has the following form:
     694        * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
     695        * Whitespace consists of space and|or <TAB> characters, which are ignored.
    696696     * Sign is either plus '+' or minus '-'.
    697697     * Digits are one or more decimal digits.
    … …  
    700700     * The decimal digits may be followed by an exponent.
    701701     * An Exponent consists of an introductory letter ( D, d, E, or e) and
    702     * an optionally signed decimal integer.
    703     */
    704     pChar = strRealString;
    705     while( bValidRealString == TRUE && *pChar != '\0' )
    706     {
    707         switch( *pChar )
    708         {
    709         /* If whitespace...
    710         */
    711         case ' ':
    712         case '\t':
    713             if( bWhiteSpaceProcessed ||
    714                 bFirstSignProcessed ||
    715                 bFirstDigitsProcessed ||
    716                 bDecimalPointProcessed ||
    717                 bSecondDigitsProcessed ||
    718                 bExponentProcessed ||
    719                 bSecondSignProcessed ||
    720                 bThirdDigitsProcessed )
    721             {
    722                 bValidRealString = FALSE;
    723             }
    724             break;
    725         /* If sign...
    726         */
    727         case '+':
    728         case '-':
    729             if( bFirstSignProcessed == FALSE )
    730             {
    731                 if( bFirstDigitsProcessed ||
    732                     bDecimalPointProcessed ||
    733                     bSecondDigitsProcessed ||
    734                     bExponentProcessed ||
    735                     bSecondSignProcessed ||
    736                     bThirdDigitsProcessed )
    737                 {
    738                     bValidRealString = FALSE;
    739                 }
    740                 bWhiteSpaceProcessed = TRUE;
    741                 bFirstSignProcessed = TRUE;
    742             }
    743             else if( bSecondSignProcessed == FALSE )
    744             {
     702        * an optionally signed decimal integer.
     703        */
     704        pChar = strRealString;
     705        while( bValidRealString == TRUE && *pChar != '\0' )
     706        {
     707                switch( *pChar )
     708                {
     709                /* If whitespace...
     710                */
     711                case ' ':
     712                case '\t':
     713                        if( bWhiteSpaceProcessed ||
     714                                bFirstSignProcessed ||
     715                                bFirstDigitsProcessed ||
     716                                bDecimalPointProcessed ||
     717                                bSecondDigitsProcessed ||
     718                                bExponentProcessed ||
     719                                bSecondSignProcessed ||
     720                                bThirdDigitsProcessed )
     721                        {
     722                                bValidRealString = FALSE;
     723                        }
     724                        break;
     725                /* If sign...
     726                */
     727                case '+':
     728                case '-':
     729                        if( bFirstSignProcessed == FALSE )
     730                        {
     731                                if( bFirstDigitsProcessed ||
     732                                        bDecimalPointProcessed ||
     733                                        bSecondDigitsProcessed ||
     734                                        bExponentProcessed ||
     735                                        bSecondSignProcessed ||
     736                                        bThirdDigitsProcessed )
     737                                {
     738                                        bValidRealString = FALSE;
     739                                }
     740                                bWhiteSpaceProcessed = TRUE;
     741                                bFirstSignProcessed = TRUE;
     742                        }
     743                        else if( bSecondSignProcessed == FALSE )
     744                        {
    745745                /* Note: The exponent must be present in
    746                 * order to accept the second sign...
    747                 */
    748                 if( bExponentProcessed == FALSE ||
    749                     bThirdDigitsProcessed ||
    750                     bDigitsRequired )
    751                 {
    752                     bValidRealString = FALSE;
    753                 }
    754                 bFirstSignProcessed = TRUE;
    755                 bWhiteSpaceProcessed = TRUE;
    756                 bFirstDigitsProcessed = TRUE;
    757                 bDecimalPointProcessed = TRUE;
    758                 bSecondDigitsProcessed = TRUE;
    759                 bSecondSignProcessed = TRUE;
    760             }
    761             break;
    762 
    763         /* If decimals...
    764         */
    765         case '0':
    766         case '1':
    767         case '2':
    768         case '3':
    769         case '4':
    770         case '5':
    771         case '6':
    772         case '7':
    773         case '8':
    774         case '9':
    775             if( bFirstDigitsProcessed == FALSE )
    776             {
    777                 if( bDecimalPointProcessed ||
    778                     bSecondDigitsProcessed ||
    779                     bExponentProcessed ||
    780                     bSecondSignProcessed ||
    781                     bThirdDigitsProcessed )
    782                 {
    783                     bValidRealString = FALSE;
    784                 }
    785                 bFirstSignProcessed = TRUE;
    786                 bWhiteSpaceProcessed = TRUE;
    787                 /* We have found some digits before the decimal point
    788                 * so disable the "Digits required" flag.
    789                 */
    790                 bDigitsRequired = FALSE;
    791             }
    792             else if( bSecondDigitsProcessed == FALSE )
    793             {
    794                 if( bExponentProcessed ||
    795                     bSecondSignProcessed ||
    796                     bThirdDigitsProcessed )
    797                 {
    798                     bValidRealString = FALSE;
    799                 }
    800                 bFirstSignProcessed = TRUE;
    801                 bWhiteSpaceProcessed = TRUE;
    802                 bFirstDigitsProcessed = TRUE;
    803                 bDecimalPointProcessed = TRUE;
    804                 /* We have found some digits after the decimal point
    805                 * so disable the "Digits required" flag.
    806                 */
    807                 bDigitsRequired = FALSE;
    808             }
    809             else if( bThirdDigitsProcessed == FALSE )
    810             {
    811                 /* Getting here means everything else should be processed.
     746                                * order to accept the second sign...
     747                                */
     748                                if( bExponentProcessed == FALSE ||
     749                                        bThirdDigitsProcessed ||
     750                                        bDigitsRequired )
     751                                {
     752                                        bValidRealString = FALSE;
     753                                }
     754                                bFirstSignProcessed = TRUE;
     755                                bWhiteSpaceProcessed = TRUE;
     756                                bFirstDigitsProcessed = TRUE;
     757                                bDecimalPointProcessed = TRUE;
     758                                bSecondDigitsProcessed = TRUE;
     759                                bSecondSignProcessed = TRUE;
     760                        }
     761                        break;
     762
     763                /* If decimals...
     764                */
     765                case '0':
     766                case '1':
     767                case '2':
     768                case '3':
     769                case '4':
     770                case '5':
     771                case '6':
     772                case '7':
     773                case '8':
     774                case '9':
     775                        if( bFirstDigitsProcessed == FALSE )
     776                        {
     777                                if( bDecimalPointProcessed ||
     778                                        bSecondDigitsProcessed ||
     779                                        bExponentProcessed ||
     780                                        bSecondSignProcessed ||
     781                                        bThirdDigitsProcessed )
     782                                {
     783                                        bValidRealString = FALSE;
     784                                }
     785                                bFirstSignProcessed = TRUE;
     786                                bWhiteSpaceProcessed = TRUE;
     787                                /* We have found some digits before the decimal point
     788                                * so disable the "Digits required" flag.
     789                                */
     790                                bDigitsRequired = FALSE;
     791                        }
     792                        else if( bSecondDigitsProcessed == FALSE )
     793                        {
     794                                if( bExponentProcessed ||
     795                                        bSecondSignProcessed ||
     796                                        bThirdDigitsProcessed )
     797                                {
     798                                        bValidRealString = FALSE;
     799                                }
     800                                bFirstSignProcessed = TRUE;
     801                                bWhiteSpaceProcessed = TRUE;
     802                                bFirstDigitsProcessed = TRUE;
     803                                bDecimalPointProcessed = TRUE;
     804                                /* We have found some digits after the decimal point
     805                                * so disable the "Digits required" flag.
     806                                */
     807                                bDigitsRequired = FALSE;
     808                        }
     809                        else if( bThirdDigitsProcessed == FALSE )
     810                        {
     811                                /* Getting here means everything else should be processed.
    812812                 * If we get anything else than a decimal following this
    813813                 * digit it will be flagged by the other cases, so
    814                 * we do not really need to do anything in here.
    815                 */
    816             }
    817             break;
    818         /* If DecimalPoint...
    819         */
    820         case '.':
    821             if( bDecimalPointProcessed ||
    822                 bSecondDigitsProcessed ||
    823                 bExponentProcessed ||
    824                 bSecondSignProcessed ||
    825                 bThirdDigitsProcessed )
    826             {
    827                 bValidRealString = FALSE;
    828             }
    829             bFirstSignProcessed = TRUE;
    830             bWhiteSpaceProcessed = TRUE;
    831             bFirstDigitsProcessed = TRUE;
    832             bDecimalPointProcessed = TRUE;
    833             break;
    834         /* If Exponent...
    835         */
    836         case 'e':
    837         case 'E':
    838         case 'd':
    839         case 'D':
    840             if( bExponentProcessed ||
    841                 bSecondSignProcessed ||
    842                 bThirdDigitsProcessed ||
    843                 bDigitsRequired )
    844             {
    845                 bValidRealString = FALSE;
    846             }
    847             bFirstSignProcessed = TRUE;
    848             bWhiteSpaceProcessed = TRUE;
    849             bFirstDigitsProcessed = TRUE;
    850             bDecimalPointProcessed = TRUE;
    851             bSecondDigitsProcessed = TRUE;
    852             bExponentProcessed = TRUE;
    853             break;
    854         default:
    855             bValidRealString = FALSE;
    856             break;
    857         }
    858         /* Process next character.
    859         */
    860         pChar++;
    861     }
    862 
    863     /* If the required digits were not present we have an invalid
    864     * string representation of a real number.
    865     */
    866     if( bDigitsRequired == TRUE )
    867     {
    868         bValidRealString = FALSE;
    869     }
    870 
    871     return bValidRealString;
    872 }
    873 
    874 
    875 /******************************************************************************
    876  *      Coerce  [INTERNAL]
     814                                * we do not really need to do anything in here.
     815                                */
     816                        }
     817                        break;
     818                /* If DecimalPoint...
     819                */
     820                case '.':
     821                        if( bDecimalPointProcessed ||
     822                                bSecondDigitsProcessed ||
     823                                bExponentProcessed ||
     824                                bSecondSignProcessed ||
     825                                bThirdDigitsProcessed )
     826                        {
     827                                bValidRealString = FALSE;
     828                        }
     829                        bFirstSignProcessed = TRUE;
     830                        bWhiteSpaceProcessed = TRUE;
     831                        bFirstDigitsProcessed = TRUE;
     832                        bDecimalPointProcessed = TRUE;
     833                        break;
     834                /* If Exponent...
     835                */
     836                case 'e':
     837                case 'E':
     838                case 'd':
     839                case 'D':
     840                        if( bExponentProcessed ||
     841                                bSecondSignProcessed ||
     842                                bThirdDigitsProcessed ||
     843                                bDigitsRequired )
     844                        {
     845                                bValidRealString = FALSE;
     846                        }
     847                        bFirstSignProcessed = TRUE;
     848                        bWhiteSpaceProcessed = TRUE;
     849                        bFirstDigitsProcessed = TRUE;
     850                        bDecimalPointProcessed = TRUE;
     851                        bSecondDigitsProcessed = TRUE;
     852                        bExponentProcessed = TRUE;
     853                        break;
     854                default:
     855                        bValidRealString = FALSE;
     856                        break;
     857                }
     858                /* Process next character.
     859                */
     860                pChar++;
     861        }
     862
     863        /* If the required digits were not present we have an invalid
     864        * string representation of a real number.
     865        */
     866        if( bDigitsRequired == TRUE )
     867        {
     868                bValidRealString = FALSE;
     869        }
     870
     871        return bValidRealString;
     872}
     873
     874
     875/******************************************************************************
     876 *              Coerce  [INTERNAL]
    877877 *
    878878 * This function dispatches execution to the proper conversion API
    … …  
    880880 *
    881881 * FIXME: Passing down dwFlags to the conversion functions is wrong, this
    882  *    is a different flagmask. Check MSDN.
     882 *        is a different flagmask. Check MSDN.
    883883 */
    884884static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt )
    885885{
    886     HRESULT res = S_OK;
    887     unsigned short vtFrom = 0;
    888     vtFrom = V_VT(ps) & VT_TYPEMASK;
    889 
    890 
    891     /* Note: Since "long" and "int" values both have 4 bytes and are
    892     * both signed integers "int" will be treated as "long" in the
    893     * following code.
    894     * The same goes for their unsigned versions.
    895     */
    896 
    897     /* Trivial Case: If the coercion is from two types that are
    898     * identical then we can blindly copy from one argument to another.*/
    899     if ((vt==vtFrom))
    900     {
    901        return VariantCopy(pd,ps);
    902     }
    903 
    904     /* Cases requiring thought*/
    905     switch( vt )
    906     {
     886        HRESULT res = S_OK;
     887        unsigned short vtFrom = 0;
     888        vtFrom = V_VT(ps) & VT_TYPEMASK;
     889
     890       
     891        /* Note: Since "long" and "int" values both have 4 bytes and are
     892        * both signed integers "int" will be treated as "long" in the
     893        * following code.
     894        * The same goes for their unsigned versions.
     895        */
     896
     897        /* Trivial Case: If the coercion is from two types that are
     898        * identical then we can blindly copy from one argument to another.*/
     899        if ((vt==vtFrom))
     900        {
     901           return VariantCopy(pd,ps);
     902        }
     903
     904        /* Cases requiring thought*/
     905        switch( vt )
     906        {
    907907
    908908    case( VT_EMPTY ):
    … …  
    916916        }
    917917        break;
    918     case( VT_I1 ):
    919         switch( vtFrom )
     918        case( VT_I1 ):
     919                switch( vtFrom )
    920920        {
    921921        case( VT_I1 ):
    922922            res = VariantCopy( pd, ps );
    923923            break;
    924         case( VT_I2 ):
    925             res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) );
    926             break;
    927         case( VT_INT ):
    928         case( VT_I4 ):
    929             res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) );
    930             break;
    931         case( VT_UI1 ):
    932             res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) );
    933             break;
    934         case( VT_UI2 ):
    935             res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) );
    936             break;
    937         case( VT_UINT ):
    938         case( VT_UI4 ):
    939             res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) );
    940             break;
    941         case( VT_R4 ):
    942             res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) );
    943             break;
    944         case( VT_R8 ):
    945             res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) );
    946             break;
    947         case( VT_DATE ):
    948             res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) );
    949             break;
    950         case( VT_BOOL ):
    951             res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) );
    952             break;
    953         case( VT_BSTR ):
    954             res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) );
    955             break;
    956         case( VT_CY ):
    957             res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) );
    958             break;
    959         case( VT_DISPATCH ):
    960             /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/
    961         case( VT_DECIMAL ):
    962             /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/
    963         case( VT_UNKNOWN ):
    964         default:
    965             res = DISP_E_TYPEMISMATCH;
    966             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    967             break;
    968         }
    969         break;
    970 
    971     case( VT_I2 ):
    972         switch( vtFrom )
    973         {
    974         case( VT_I1 ):
    975             res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) );
    976             break;
     924                case( VT_I2 ):
     925                        res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) );
     926                        break;
     927                case( VT_INT ):
     928                case( VT_I4 ):
     929                        res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) );
     930                        break;
     931                case( VT_UI1 ):
     932                        res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) );
     933                        break;
     934                case( VT_UI2 ):
     935                        res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) );
     936                        break;
     937                case( VT_UINT ):
     938                case( VT_UI4 ):
     939                        res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) );
     940                        break;
     941                case( VT_R4 ):
     942                        res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) );
     943                        break;
     944                case( VT_R8 ):
     945                        res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) );
     946                        break;
     947                case( VT_DATE ):
     948                        res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) );
     949                        break;
     950                case( VT_BOOL ):
     951                        res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) );
     952                        break;
     953                case( VT_BSTR ):
     954                        res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) );
     955                        break;
     956                case( VT_CY ):
     957                        res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) );
     958                        break;
     959                case( VT_DISPATCH ):
     960                        /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/
     961                case( VT_DECIMAL ):
     962                        /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/
     963                case( VT_UNKNOWN ):
     964                default:
     965                        res = DISP_E_TYPEMISMATCH;
     966                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     967                        break;
     968                }
     969                break;
     970
     971        case( VT_I2 ):
     972                switch( vtFrom )
     973                {
     974                case( VT_I1 ):
     975                        res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) );
     976                        break;
    977977        case( VT_I2 ):
    978978            res = VariantCopy( pd, ps );
    979979            break;
    980         case( VT_INT ):
    981         case( VT_I4 ):
    982             res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) );
    983             break;
    984         case( VT_UI1 ):
    985             res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) );
    986             break;
    987         case( VT_UI2 ):
    988             res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) );
    989             break;
    990         case( VT_UINT ):
    991         case( VT_UI4 ):
    992             res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) );
    993             break;
    994         case( VT_R4 ):
    995             res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) );
    996             break;
    997         case( VT_R8 ):
    998             res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) );
    999             break;
    1000         case( VT_DATE ):
    1001             res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) );
    1002             break;
    1003         case( VT_BOOL ):
    1004             res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) );
    1005             break;
    1006         case( VT_BSTR ):
    1007             res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) );
    1008             break;
    1009         case( VT_CY ):
    1010             res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) );
    1011             break;
    1012         case( VT_DISPATCH ):
    1013             /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/
    1014         case( VT_DECIMAL ):
    1015             /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/
    1016         case( VT_UNKNOWN ):
    1017         default:
    1018             res = DISP_E_TYPEMISMATCH;
    1019             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1020             break;
    1021         }
    1022         break;
    1023 
    1024     case( VT_INT ):
    1025     case( VT_I4 ):
    1026         switch( vtFrom )
    1027         {
    1028         case( VT_I1 ):
    1029             res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) );
    1030             break;
    1031         case( VT_I2 ):
    1032             res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) );
     980                case( VT_INT ):
     981                case( VT_I4 ):
     982                        res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) );
     983                        break;
     984                case( VT_UI1 ):
     985                        res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) );
     986                        break;
     987                case( VT_UI2 ):
     988                        res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) );
     989                        break;
     990                case( VT_UINT ):
     991                case( VT_UI4 ):
     992                        res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) );
     993                        break;
     994                case( VT_R4 ):
     995                        res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) );
     996                        break;
     997                case( VT_R8 ):
     998                        res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) );
     999                        break;
     1000                case( VT_DATE ):
     1001                        res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) );
     1002                        break;
     1003                case( VT_BOOL ):
     1004                        res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) );
     1005                        break;
     1006                case( VT_BSTR ):
     1007                        res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) );
     1008                        break;
     1009                case( VT_CY ):
     1010                        res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) );
     1011                        break;
     1012                case( VT_DISPATCH ):
     1013                        /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/
     1014                case( VT_DECIMAL ):
     1015                        /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/
     1016                case( VT_UNKNOWN ):
     1017                default:
     1018                        res = DISP_E_TYPEMISMATCH;
     1019                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1020                        break;
     1021                }
     1022                break;
     1023
     1024        case( VT_INT ):
     1025        case( VT_I4 ):
     1026                switch( vtFrom )
     1027                {
     1028                case( VT_I1 ):
     1029                        res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) );
     1030                        break;
     1031                case( VT_I2 ):
     1032                        res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) );
    10331033            break;
    10341034        case( VT_INT ):
    … …  
    10391039            res = VariantCopy( pd, ps );
    10401040            break;
    1041         case( VT_UI1 ):
    1042             res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) );
    1043             break;
    1044         case( VT_UI2 ):
    1045             res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) );
    1046             break;
    1047         case( VT_UINT ):
    1048         case( VT_UI4 ):
    1049             res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) );
    1050             break;
    1051         case( VT_R4 ):
    1052             res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) );
    1053             break;
    1054         case( VT_R8 ):
    1055             res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) );
    1056             break;
    1057         case( VT_DATE ):
    1058             res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) );
    1059             break;
    1060         case( VT_BOOL ):
    1061             res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) );
    1062             break;
    1063         case( VT_BSTR ):
    1064             res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) );
    1065             break;
    1066         case( VT_CY ):
    1067             res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) );
    1068             break;
    1069         case( VT_DISPATCH ):
    1070             /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/
    1071         case( VT_DECIMAL ):
    1072             /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/
    1073         case( VT_UNKNOWN ):
    1074         default:
    1075             res = DISP_E_TYPEMISMATCH;
    1076             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1077             break;
    1078         }
    1079         break;
    1080 
    1081     case( VT_UI1 ):
    1082         switch( vtFrom )
    1083         {
    1084         case( VT_I1 ):
    1085             res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) );
    1086             break;
    1087         case( VT_I2 ):
    1088             res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) );
    1089             break;
    1090         case( VT_INT ):
    1091         case( VT_I4 ):
    1092             res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) );
    1093             break;
     1041                case( VT_UI1 ):
     1042                        res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) );
     1043                        break;
     1044                case( VT_UI2 ):
     1045                        res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) );
     1046                        break;
     1047                case( VT_UINT ):
     1048                case( VT_UI4 ):
     1049                        res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) );
     1050                        break;
     1051                case( VT_R4 ):
     1052                        res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) );
     1053                        break;
     1054                case( VT_R8 ):
     1055                        res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) );
     1056                        break;
     1057                case( VT_DATE ):
     1058                        res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) );
     1059                        break;
     1060                case( VT_BOOL ):
     1061                        res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) );
     1062                        break;
     1063                case( VT_BSTR ):
     1064                        res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) );
     1065                        break;
     1066                case( VT_CY ):
     1067                        res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) );
     1068                        break;
     1069                case( VT_DISPATCH ):
     1070                        /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/
     1071                case( VT_DECIMAL ):
     1072                        /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/
     1073                case( VT_UNKNOWN ):
     1074                default:
     1075                        res = DISP_E_TYPEMISMATCH;
     1076                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1077                        break;
     1078                }
     1079                break;
     1080
     1081        case( VT_UI1 ):
     1082                switch( vtFrom )
     1083                {
     1084                case( VT_I1 ):
     1085                        res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) );
     1086                        break;
     1087                case( VT_I2 ):
     1088                        res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) );
     1089                        break;
     1090                case( VT_INT ):
     1091                case( VT_I4 ):
     1092                        res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) );
     1093                        break;
    10941094        case( VT_UI1 ):
    10951095            res = VariantCopy( pd, ps );
    10961096            break;
    1097         case( VT_UI2 ):
    1098             res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) );
    1099             break;
    1100         case( VT_UINT ):
    1101         case( VT_UI4 ):
    1102             res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) );
    1103             break;
    1104         case( VT_R4 ):
    1105             res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) );
    1106             break;
    1107         case( VT_R8 ):
    1108             res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) );
    1109             break;
    1110         case( VT_DATE ):
    1111             res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) );
    1112             break;
    1113         case( VT_BOOL ):
    1114             res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) );
    1115             break;
    1116         case( VT_BSTR ):
    1117             res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) );
    1118             break;
    1119         case( VT_CY ):
    1120             res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) );
    1121             break;
    1122         case( VT_DISPATCH ):
    1123             /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/
    1124         case( VT_DECIMAL ):
    1125             /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/
    1126         case( VT_UNKNOWN ):
    1127         default:
    1128             res = DISP_E_TYPEMISMATCH;
    1129             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1130             break;
    1131         }
    1132         break;
    1133 
    1134     case( VT_UI2 ):
    1135         switch( vtFrom )
    1136         {
    1137         case( VT_I1 ):
    1138             res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) );
    1139             break;
    1140         case( VT_I2 ):
    1141             res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) );
    1142             break;
    1143         case( VT_INT ):
    1144         case( VT_I4 ):
    1145             res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) );
    1146             break;
    1147         case( VT_UI1 ):
    1148             res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) );
    1149             break;
     1097                case( VT_UI2 ):
     1098                        res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) );
     1099                        break;
     1100                case( VT_UINT ):
     1101                case( VT_UI4 ):
     1102                        res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) );
     1103                        break;
     1104                case( VT_R4 ):
     1105                        res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) );
     1106                        break;
     1107                case( VT_R8 ):
     1108                        res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) );
     1109                        break;
     1110                case( VT_DATE ):
     1111                        res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) );
     1112                        break;
     1113                case( VT_BOOL ):
     1114                        res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) );
     1115                        break;
     1116                case( VT_BSTR ):
     1117                        res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) );
     1118                        break;
     1119                case( VT_CY ):
     1120                        res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) );
     1121                        break;
     1122                case( VT_DISPATCH ):
     1123                        /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/
     1124                case( VT_DECIMAL ):
     1125                        /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/
     1126                case( VT_UNKNOWN ):
     1127                default:
     1128                        res = DISP_E_TYPEMISMATCH;
     1129                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1130                        break;
     1131                }
     1132                break;
     1133
     1134        case( VT_UI2 ):
     1135                switch( vtFrom )
     1136                {
     1137                case( VT_I1 ):
     1138                        res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) );
     1139                        break;
     1140                case( VT_I2 ):
     1141                        res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) );
     1142                        break;
     1143                case( VT_INT ):
     1144                case( VT_I4 ):
     1145                        res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) );
     1146                        break;
     1147                case( VT_UI1 ):
     1148                        res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) );
     1149                        break;
    11501150        case( VT_UI2 ):
    11511151            res = VariantCopy( pd, ps );
    11521152            break;
    1153         case( VT_UINT ):
    1154         case( VT_UI4 ):
    1155             res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) );
    1156             break;
    1157         case( VT_R4 ):
    1158             res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) );
    1159             break;
    1160         case( VT_R8 ):
    1161             res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) );
    1162             break;
    1163         case( VT_DATE ):
    1164             res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) );
    1165             break;
    1166         case( VT_BOOL ):
    1167             res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) );
    1168             break;
    1169         case( VT_BSTR ):
    1170             res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) );
    1171             break;
    1172         case( VT_CY ):
    1173             res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) );
    1174             break;
    1175         case( VT_DISPATCH ):
    1176             /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/
    1177         case( VT_DECIMAL ):
    1178             /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/
    1179         case( VT_UNKNOWN ):
    1180         default:
    1181             res = DISP_E_TYPEMISMATCH;
    1182             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1183             break;
    1184         }
    1185         break;
    1186 
    1187     case( VT_UINT ):
    1188     case( VT_UI4 ):
    1189         switch( vtFrom )
    1190         {
    1191         case( VT_I1 ):
    1192             res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) );
    1193             break;
    1194         case( VT_I2 ):
    1195             res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) );
    1196             break;
    1197         case( VT_INT ):
    1198         case( VT_I4 ):
    1199             res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) );
    1200             break;
    1201         case( VT_UI1 ):
    1202             res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) );
    1203             break;
    1204         case( VT_UI2 ):
    1205             res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) );
    1206             break;
     1153                case( VT_UINT ):
     1154                case( VT_UI4 ):
     1155                        res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) );
     1156                        break;
     1157                case( VT_R4 ):
     1158                        res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) );
     1159                        break;
     1160                case( VT_R8 ):
     1161                        res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) );
     1162                        break;
     1163                case( VT_DATE ):
     1164                        res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) );
     1165                        break;
     1166                case( VT_BOOL ):
     1167                        res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) );
     1168                        break;
     1169                case( VT_BSTR ):
     1170                        res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) );
     1171                        break;
     1172                case( VT_CY ):
     1173                        res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) );
     1174                        break;
     1175                case( VT_DISPATCH ):
     1176                        /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/
     1177                case( VT_DECIMAL ):
     1178                        /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/
     1179                case( VT_UNKNOWN ):
     1180                default:
     1181                        res = DISP_E_TYPEMISMATCH;
     1182                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1183                        break;
     1184                }
     1185                break;
     1186
     1187        case( VT_UINT ):
     1188        case( VT_UI4 ):
     1189                switch( vtFrom )
     1190                {
     1191                case( VT_I1 ):
     1192                        res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) );
     1193                        break;
     1194                case( VT_I2 ):
     1195                        res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) );
     1196                        break;
     1197                case( VT_INT ):
     1198                case( VT_I4 ):
     1199                        res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) );
     1200                        break;
     1201                case( VT_UI1 ):
     1202                        res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) );
     1203                        break;
     1204                case( VT_UI2 ):
     1205                        res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) );
     1206                        break;
    12071207        case( VT_UI4 ):
    12081208            res = VariantCopy( pd, ps );
    12091209            break;
    1210         case( VT_R4 ):
    1211             res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) );
    1212             break;
    1213         case( VT_R8 ):
    1214             res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) );
    1215             break;
    1216         case( VT_DATE ):
    1217             res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) );
    1218             break;
    1219         case( VT_BOOL ):
    1220             res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) );
    1221             break;
    1222         case( VT_BSTR ):
    1223             res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) );
    1224             break;
    1225         case( VT_CY ):
    1226             res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) );
    1227             break;
    1228         case( VT_DISPATCH ):
    1229             /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/
    1230         case( VT_DECIMAL ):
    1231             /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/
    1232         case( VT_UNKNOWN ):
    1233         default:
    1234             res = DISP_E_TYPEMISMATCH;
    1235             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1236             break;
    1237         }
    1238         break;
    1239 
    1240     case( VT_R4 ):
    1241         switch( vtFrom )
    1242         {
    1243         case( VT_I1 ):
    1244             res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) );
    1245             break;
    1246         case( VT_I2 ):
    1247             res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) );
    1248             break;
    1249         case( VT_INT ):
    1250         case( VT_I4 ):
    1251             res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) );
    1252             break;
    1253         case( VT_UI1 ):
    1254             res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) );
    1255             break;
    1256         case( VT_UI2 ):
    1257             res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) );
    1258             break;
    1259         case( VT_UINT ):
    1260         case( VT_UI4 ):
    1261             res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) );
    1262             break;
     1210                case( VT_R4 ):
     1211                        res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) );
     1212                        break;
     1213                case( VT_R8 ):
     1214                        res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) );
     1215                        break;
     1216                case( VT_DATE ):
     1217                        res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) );
     1218                        break;
     1219                case( VT_BOOL ):
     1220                        res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) );
     1221                        break;
     1222                case( VT_BSTR ):
     1223                        res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) );
     1224                        break;
     1225                case( VT_CY ):
     1226                        res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) );
     1227                        break;
     1228                case( VT_DISPATCH ):
     1229                        /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/
     1230                case( VT_DECIMAL ):
     1231                        /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/
     1232                case( VT_UNKNOWN ):
     1233                default:
     1234                        res = DISP_E_TYPEMISMATCH;
     1235                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1236                        break;
     1237                }
     1238                break;
     1239               
     1240        case( VT_R4 ):
     1241                switch( vtFrom )
     1242                {
     1243                case( VT_I1 ):
     1244                        res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) );
     1245                        break;
     1246                case( VT_I2 ):
     1247                        res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) );
     1248                        break;
     1249                case( VT_INT ):
     1250                case( VT_I4 ):
     1251                        res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) );
     1252                        break;
     1253                case( VT_UI1 ):
     1254                        res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) );
     1255                        break;
     1256                case( VT_UI2 ):
     1257                        res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) );
     1258                        break;
     1259                case( VT_UINT ):
     1260                case( VT_UI4 ):
     1261                        res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) );
     1262                        break;
    12631263        case( VT_R4 ):
    12641264            res = VariantCopy( pd, ps );
    12651265            break;
    1266         case( VT_R8 ):
    1267             res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) );
    1268             break;
    1269         case( VT_DATE ):
    1270             res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) );
    1271             break;
    1272         case( VT_BOOL ):
    1273             res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) );
    1274             break;
    1275         case( VT_BSTR ):
    1276             res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) );
    1277             break;
    1278         case( VT_CY ):
    1279             res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) );
    1280             break;
    1281         case( VT_DISPATCH ):
    1282             /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/
    1283         case( VT_DECIMAL ):
    1284             /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/
    1285         case( VT_UNKNOWN ):
    1286         default:
    1287             res = DISP_E_TYPEMISMATCH;
    1288             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1289             break;
    1290         }
    1291         break;
    1292 
    1293     case( VT_R8 ):
    1294         switch( vtFrom )
    1295         {
    1296         case( VT_I1 ):
    1297             res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) );
    1298             break;
    1299         case( VT_I2 ):
    1300             res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) );
    1301             break;
    1302         case( VT_INT ):
    1303         case( VT_I4 ):
    1304             res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) );
    1305             break;
    1306         case( VT_UI1 ):
    1307             res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) );
    1308             break;
    1309         case( VT_UI2 ):
    1310             res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) );
    1311             break;
    1312         case( VT_UINT ):
    1313         case( VT_UI4 ):
    1314             res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) );
    1315             break;
    1316         case( VT_R4 ):
    1317             res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) );
    1318             break;
     1266                case( VT_R8 ):
     1267                        res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) );
     1268                        break;
     1269                case( VT_DATE ):
     1270                        res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) );
     1271                        break;
     1272                case( VT_BOOL ):
     1273                        res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) );
     1274                        break;
     1275                case( VT_BSTR ):
     1276                        res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) );
     1277                        break;
     1278                case( VT_CY ):
     1279                        res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) );
     1280                        break;
     1281                case( VT_DISPATCH ):
     1282                        /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/
     1283                case( VT_DECIMAL ):
     1284                        /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/
     1285                case( VT_UNKNOWN ):
     1286                default:
     1287                        res = DISP_E_TYPEMISMATCH;
     1288                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1289                        break;
     1290                }
     1291                break;
     1292
     1293        case( VT_R8 ):
     1294                switch( vtFrom )
     1295                {
     1296                case( VT_I1 ):
     1297                        res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) );
     1298                        break;
     1299                case( VT_I2 ):
     1300                        res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) );
     1301                        break;
     1302                case( VT_INT ):
     1303                case( VT_I4 ):
     1304                        res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) );
     1305                        break;
     1306                case( VT_UI1 ):
     1307                        res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) );
     1308                        break;
     1309                case( VT_UI2 ):
     1310                        res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) );
     1311                        break;
     1312                case( VT_UINT ):
     1313                case( VT_UI4 ):
     1314                        res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) );
     1315                        break;
     1316                case( VT_R4 ):
     1317                        res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) );
     1318                        break;
    13191319        case( VT_R8 ):
    13201320            res = VariantCopy( pd, ps );
    13211321            break;
    1322         case( VT_DATE ):
    1323             res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) );
    1324             break;
    1325         case( VT_BOOL ):
    1326             res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) );
    1327             break;
    1328         case( VT_BSTR ):
    1329             res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) );
    1330             break;
    1331         case( VT_CY ):
    1332             res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) );
    1333             break;
    1334         case( VT_DISPATCH ):
    1335             /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/
    1336         case( VT_DECIMAL ):
    1337             /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/
    1338         case( VT_UNKNOWN ):
    1339         default:
    1340             res = DISP_E_TYPEMISMATCH;
    1341             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1342             break;
    1343         }
    1344         break;
    1345 
    1346     case( VT_DATE ):
    1347         switch( vtFrom )
    1348         {
    1349         case( VT_I1 ):
    1350             res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) );
    1351             break;
    1352         case( VT_I2 ):
    1353             res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) );
    1354             break;
    1355         case( VT_INT ):
    1356             res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) );
    1357             break;
    1358         case( VT_I4 ):
    1359             res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) );
    1360             break;
    1361         case( VT_UI1 ):
    1362             res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) );
    1363             break;
    1364         case( VT_UI2 ):
    1365             res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) );
    1366             break;
    1367         case( VT_UINT ):
    1368             res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) );
    1369             break;
    1370         case( VT_UI4 ):
    1371             res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) );
    1372             break;
    1373         case( VT_R4 ):
    1374             res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) );
    1375             break;
    1376         case( VT_R8 ):
    1377             res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) );
    1378             break;
     1322                case( VT_DATE ):
     1323                        res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) );
     1324                        break;
     1325                case( VT_BOOL ):
     1326                        res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) );
     1327                        break;
     1328                case( VT_BSTR ):
     1329                        res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) );
     1330                        break;
     1331                case( VT_CY ):
     1332                        res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) );
     1333                        break;
     1334                case( VT_DISPATCH ):
     1335                        /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/
     1336                case( VT_DECIMAL ):
     1337                        /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/
     1338                case( VT_UNKNOWN ):
     1339                default:
     1340                        res = DISP_E_TYPEMISMATCH;
     1341                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1342                        break;
     1343                }
     1344                break;
     1345
     1346        case( VT_DATE ):
     1347                switch( vtFrom )
     1348                {
     1349                case( VT_I1 ):
     1350                        res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) );
     1351                        break;
     1352                case( VT_I2 ):
     1353                        res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) );
     1354                        break;
     1355                case( VT_INT ):
     1356                        res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) );
     1357                        break;
     1358                case( VT_I4 ):
     1359                        res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) );
     1360                        break;
     1361                case( VT_UI1 ):
     1362                        res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) );
     1363                        break;
     1364                case( VT_UI2 ):
     1365                        res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) );
     1366                        break;
     1367                case( VT_UINT ):
     1368                        res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) );
     1369                        break;
     1370                case( VT_UI4 ):
     1371                        res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) );
     1372                        break;
     1373                case( VT_R4 ):
     1374                        res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) );
     1375                        break;
     1376                case( VT_R8 ):
     1377                        res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) );
     1378                        break;
    13791379        case( VT_DATE ):
    13801380            res = VariantCopy( pd, ps );
    13811381            break;
    1382         case( VT_BOOL ):
    1383             res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) );
    1384             break;
    1385         case( VT_BSTR ):
    1386             res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) );
    1387             break;
    1388         case( VT_CY ):
    1389             res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) );
    1390             break;
    1391         case( VT_DISPATCH ):
    1392             /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/
    1393         case( VT_DECIMAL ):
    1394             /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/
    1395         case( VT_UNKNOWN ):
    1396         default:
    1397             res = DISP_E_TYPEMISMATCH;
    1398             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1399             break;
    1400         }
    1401         break;
    1402 
    1403     case( VT_BOOL ):
    1404         switch( vtFrom )
    1405         {
    1406         case( VT_I1 ):
    1407             res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
    1408             break;
    1409         case( VT_I2 ):
    1410             res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
    1411             break;
    1412         case( VT_INT ):
    1413             res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
    1414             break;
    1415         case( VT_I4 ):
    1416             res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
    1417             break;
    1418         case( VT_UI1 ):
    1419             res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
    1420             break;
    1421         case( VT_UI2 ):
    1422             res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
    1423             break;
    1424         case( VT_UINT ):
    1425             res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
    1426             break;
    1427         case( VT_UI4 ):
    1428             res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
    1429             break;
    1430         case( VT_R4 ):
    1431             res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
    1432             break;
    1433         case( VT_R8 ):
    1434             res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
    1435             break;
    1436         case( VT_DATE ):
    1437             res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
    1438             break;
     1382                case( VT_BOOL ):
     1383                        res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) );
     1384                        break;
     1385                case( VT_BSTR ):
     1386                        res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) );
     1387                        break;
     1388                case( VT_CY ):
     1389                        res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) );
     1390                        break;
     1391                case( VT_DISPATCH ):
     1392                        /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/
     1393                case( VT_DECIMAL ):
     1394                        /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/
     1395                case( VT_UNKNOWN ):
     1396                default:
     1397                        res = DISP_E_TYPEMISMATCH;
     1398                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1399                        break;
     1400                }
     1401                break;
     1402
     1403        case( VT_BOOL ):
     1404                switch( vtFrom )
     1405                {
     1406                case( VT_I1 ):
     1407                        res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
     1408                        break;
     1409                case( VT_I2 ):
     1410                        res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
     1411                        break;
     1412                case( VT_INT ):
     1413                        res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
     1414                        break;
     1415                case( VT_I4 ):
     1416                        res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
     1417                        break;
     1418                case( VT_UI1 ):
     1419                        res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
     1420                        break;
     1421                case( VT_UI2 ):
     1422                        res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
     1423                        break;
     1424                case( VT_UINT ):
     1425                        res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
     1426                        break;
     1427                case( VT_UI4 ):
     1428                        res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
     1429                        break;
     1430                case( VT_R4 ):
     1431                        res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
     1432                        break;
     1433                case( VT_R8 ):
     1434                        res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
     1435                        break;
     1436                case( VT_DATE ):
     1437                        res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
     1438                        break;
    14391439        case( VT_BOOL ):
    14401440            res = VariantCopy( pd, ps );
    14411441            break;
    1442         case( VT_BSTR ):
    1443             res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
    1444             break;
    1445         case( VT_CY ):
    1446             res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
    1447             break;
    1448         case( VT_DISPATCH ):
    1449             /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
    1450         case( VT_DECIMAL ):
    1451             /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
    1452         case( VT_UNKNOWN ):
    1453         default:
    1454             res = DISP_E_TYPEMISMATCH;
    1455             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1456             break;
    1457         }
    1458         break;
    1459 
    1460     case( VT_BSTR ):
    1461         switch( vtFrom )
    1462         {
    1463         case( VT_EMPTY ):
    1464             if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
    1465                 res = S_OK;
    1466             else
    1467                 res = E_OUTOFMEMORY;
    1468             break;
    1469         case( VT_I1 ):
    1470             res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1471             break;
    1472         case( VT_I2 ):
    1473             res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1474             break;
    1475         case( VT_INT ):
    1476             res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1477             break;
    1478         case( VT_I4 ):
    1479             res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1480             break;
    1481         case( VT_UI1 ):
    1482             res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1483             break;
    1484         case( VT_UI2 ):
    1485             res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1486             break;
    1487         case( VT_UINT ):
    1488             res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1489             break;
    1490         case( VT_UI4 ):
    1491             res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1492             break;
    1493         case( VT_R4 ):
    1494             res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1495             break;
    1496         case( VT_R8 ):
    1497             res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1498             break;
    1499         case( VT_DATE ):
    1500             res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
    1501             break;
    1502         case( VT_BOOL ):
    1503             res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1504             break;
    1505         case( VT_BSTR ):
    1506             res = VariantCopy( pd, ps );
    1507             break;
    1508         case( VT_CY ):
    1509             res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
    1510             break;
    1511         case( VT_DISPATCH ):
    1512             /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
    1513         case( VT_DECIMAL ):
    1514             /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
    1515         case( VT_UNKNOWN ):
    1516         default:
    1517             res = DISP_E_TYPEMISMATCH;
    1518             FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1519             break;
    1520         }
    1521         break;
     1442                case( VT_BSTR ):
     1443                        res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
     1444                        break;
     1445                case( VT_CY ):
     1446                        res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
     1447                        break;
     1448                case( VT_DISPATCH ):
     1449                        /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
     1450                case( VT_DECIMAL ):
     1451                        /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
     1452                case( VT_UNKNOWN ):
     1453                default:
     1454                        res = DISP_E_TYPEMISMATCH;
     1455                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1456                        break;
     1457                }
     1458                break;
     1459
     1460        case( VT_BSTR ):
     1461                switch( vtFrom )
     1462                {
     1463                case( VT_EMPTY ):
     1464                        if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
     1465                                res = S_OK;
     1466                        else
     1467                                res = E_OUTOFMEMORY;
     1468                        break;
     1469                case( VT_I1 ):
     1470                        res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1471                        break;
     1472                case( VT_I2 ):
     1473                        res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1474                        break;
     1475                case( VT_INT ):
     1476                        res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1477                        break;
     1478                case( VT_I4 ):
     1479                        res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1480                        break;
     1481                case( VT_UI1 ):
     1482                        res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1483                        break;
     1484                case( VT_UI2 ):
     1485                        res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1486                        break;
     1487                case( VT_UINT ):
     1488                        res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1489                        break;
     1490                case( VT_UI4 ):
     1491                        res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1492                        break;
     1493                case( VT_R4 ):
     1494                        res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1495                        break;
     1496                case( VT_R8 ):
     1497                        res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1498                        break;
     1499                case( VT_DATE ):
     1500                        res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
     1501                        break;
     1502                case( VT_BOOL ):
     1503                        res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1504                        break;
     1505                case( VT_BSTR ):
     1506                        res = VariantCopy( pd, ps );
     1507                        break;
     1508                case( VT_CY ):
     1509                        res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1510                        break;
     1511                case( VT_DISPATCH ):
     1512                        /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
     1513                case( VT_DECIMAL ):
     1514                        /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
     1515                case( VT_UNKNOWN ):
     1516                default:
     1517                        res = DISP_E_TYPEMISMATCH;
     1518                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1519                        break;
     1520                }
     1521                break;
    15221522
    15231523     case( VT_CY ):
    1524     switch( vtFrom )
    1525       {
    1526       case( VT_I1 ):
    1527          res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
    1528          break;
    1529       case( VT_I2 ):
    1530          res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
    1531          break;
    1532       case( VT_INT ):
    1533          res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
    1534          break;
    1535       case( VT_I4 ):
    1536          res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
    1537          break;
    1538       case( VT_UI1 ):
    1539          res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
    1540          break;
    1541       case( VT_UI2 ):
    1542          res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
    1543          break;
    1544       case( VT_UINT ):
    1545          res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
    1546          break;
    1547       case( VT_UI4 ):
    1548          res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
    1549          break;
    1550       case( VT_R4 ):
    1551          res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
    1552          break;
    1553       case( VT_R8 ):
    1554          res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
    1555          break;
    1556       case( VT_DATE ):
    1557          res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
    1558          break;
    1559       case( VT_BOOL ):
    1560          res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
    1561          break;
    1562       case( VT_CY ):
    1563          res = VariantCopy( pd, ps );
    1564          break;
    1565       case( VT_BSTR ):
    1566          res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
    1567          break;
    1568       case( VT_DISPATCH ):
    1569          /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
    1570       case( VT_DECIMAL ):
    1571          /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
    1572          break;
    1573       case( VT_UNKNOWN ):
    1574       default:
    1575          res = DISP_E_TYPEMISMATCH;
    1576          FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1577          break;
    1578       }
    1579     break;
    1580 
    1581     default:
    1582         res = DISP_E_TYPEMISMATCH;
    1583         FIXME("Coercion from %d to %d\n", vtFrom, vt );
    1584         break;
    1585     }
    1586 
    1587     return res;
    1588 }
    1589 
    1590 /******************************************************************************
    1591  *      ValidateVtRange [INTERNAL]
     1524        switch( vtFrom )
     1525          {
     1526          case( VT_I1 ):
     1527             res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
     1528             break;
     1529          case( VT_I2 ):
     1530             res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
     1531             break;
     1532          case( VT_INT ):
     1533             res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
     1534             break;
     1535          case( VT_I4 ):
     1536             res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
     1537             break;
     1538          case( VT_UI1 ):
     1539             res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
     1540             break;
     1541          case( VT_UI2 ):
     1542             res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
     1543             break;
     1544          case( VT_UINT ):
     1545             res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
     1546             break;
     1547          case( VT_UI4 ):
     1548             res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
     1549             break;
     1550          case( VT_R4 ):
     1551             res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
     1552             break;
     1553          case( VT_R8 ):
     1554             res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
     1555             break;
     1556          case( VT_DATE ):
     1557             res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
     1558             break;
     1559          case( VT_BOOL ):
     1560             res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
     1561             break;
     1562          case( VT_CY ):
     1563             res = VariantCopy( pd, ps );
     1564             break;
     1565          case( VT_BSTR ):
     1566             res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
     1567             break;
     1568          case( VT_DISPATCH ):
     1569             /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
     1570          case( VT_DECIMAL ):
     1571             /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
     1572             break;
     1573          case( VT_UNKNOWN ):
     1574          default:
     1575             res = DISP_E_TYPEMISMATCH;
     1576             FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1577             break;
     1578          }
     1579        break;
     1580
     1581        default:
     1582                res = DISP_E_TYPEMISMATCH;
     1583                FIXME("Coercion from %d to %d\n", vtFrom, vt );
     1584                break;
     1585        }
     1586       
     1587        return res;
     1588}
     1589
     1590/******************************************************************************
     1591 *              ValidateVtRange [INTERNAL]
    15921592 *
    15931593 * Used internally by the hi-level Variant API to determine
    … …  
    16081608
    16091609/******************************************************************************
    1610  *      ValidateVartype [INTERNAL]
     1610 *              ValidateVartype [INTERNAL]
    16111611 *
    16121612 * Used internally by the hi-level Variant API to determine
    … …  
    16151615static HRESULT WINAPI ValidateVariantType( VARTYPE vt )
    16161616{
    1617     HRESULT res = S_OK;
    1618 
    1619     /* check if we have a valid argument.
    1620     */
    1621     if( vt & VT_BYREF )
     1617        HRESULT res = S_OK;
     1618
     1619        /* check if we have a valid argument.
     1620        */
     1621        if( vt & VT_BYREF )
    16221622    {
    16231623        /* if by reference check that the type is in
    … …  
    16261626        if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
    16271627            ( vt & VT_TYPEMASK ) == VT_NULL ||
    1628             ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
    1629         {
    1630             res = E_INVALIDARG;
    1631         }
    1632 
     1628                        ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
     1629                {
     1630                        res = E_INVALIDARG;
     1631                }
     1632                       
    16331633    }
    16341634    else
    … …  
    16361636        res = ValidateVtRange( vt );
    16371637    }
    1638 
    1639     return res;
    1640 }
    1641 
    1642 /******************************************************************************
    1643  *      ValidateVt  [INTERNAL]
     1638               
     1639        return res;
     1640}
     1641
     1642/******************************************************************************
     1643 *              ValidateVt      [INTERNAL]
    16441644 *
    16451645 * Used internally by the hi-level Variant API to determine
    … …  
    16481648static HRESULT WINAPI ValidateVt( VARTYPE vt )
    16491649{
    1650     HRESULT res = S_OK;
    1651 
    1652     /* check if we have a valid argument.
    1653     */
    1654     if( vt & VT_BYREF )
     1650        HRESULT res = S_OK;
     1651
     1652        /* check if we have a valid argument.
     1653        */
     1654        if( vt & VT_BYREF )
    16551655    {
    16561656        /* if by reference check that the type is in
    … …  
    16591659        if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
    16601660            ( vt & VT_TYPEMASK ) == VT_NULL ||
    1661             ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
    1662         {
    1663             res = DISP_E_BADVARTYPE;
    1664         }
    1665 
     1661                        ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
     1662                {
     1663                        res = DISP_E_BADVARTYPE;
     1664                }
     1665                       
    16661666    }
    16671667    else
    … …  
    16691669        res = ValidateVtRange( vt );
    16701670    }
    1671 
    1672     return res;
    1673 }
    1674 
    1675 
    1676 
    1677 
    1678 
    1679 /******************************************************************************
    1680  *      VariantInit [OLEAUT32.8]
     1671               
     1672        return res;
     1673}
     1674
     1675
     1676
     1677
     1678
     1679/******************************************************************************
     1680 *              VariantInit     [OLEAUT32.8]
    16811681 *
    16821682 * Initializes the Variant.  Unlike VariantClear it does not interpret the current
    … …  
    16941694
    16951695/******************************************************************************
    1696  *      VariantClear    [OLEAUT32.9]
     1696 *              VariantClear    [OLEAUT32.9]
    16971697 *
    16981698 * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
    1699  * sets the wReservedX field to 0.  The current contents of the VARIANT are
     1699 * sets the wReservedX field to 0.      The current contents of the VARIANT are
    17001700 * freed.  If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
    17011701 * released. If VT_ARRAY the array is freed.
    … …  
    17161716      if ( (V_VT(pvarg) & VT_ARRAY) != 0)
    17171717      {
    1718     SafeArrayDestroy(V_UNION(pvarg,parray));
     1718        SafeArrayDestroy(V_UNION(pvarg,parray));
    17191719      }
    17201720      else
    17211721      {
    1722     switch( V_VT(pvarg) & VT_TYPEMASK )
    1723     {
    1724       case( VT_BSTR ):
    1725         SysFreeString( V_UNION(pvarg,bstrVal) );
    1726         break;
    1727       case( VT_DISPATCH ):
    1728         if(V_UNION(pvarg,pdispVal)!=NULL)
    1729           ICOM_CALL(Release,V_UNION(pvarg,pdispVal));
    1730         break;
    1731       case( VT_VARIANT ):
    1732         VariantClear(V_UNION(pvarg,pvarVal));
    1733         break;
    1734       case( VT_UNKNOWN ):
    1735         if(V_UNION(pvarg,punkVal)!=NULL)
    1736           ICOM_CALL(Release,V_UNION(pvarg,punkVal));
    1737         break;
    1738       case( VT_SAFEARRAY ):
    1739         SafeArrayDestroy(V_UNION(pvarg,parray));
    1740         break;
    1741       default:
    1742         break;
    1743     }
     1722        switch( V_VT(pvarg) & VT_TYPEMASK )
     1723        {
     1724          case( VT_BSTR ):
     1725            SysFreeString( V_UNION(pvarg,bstrVal) );
     1726            break;
     1727          case( VT_DISPATCH ):
     1728            if(V_UNION(pvarg,pdispVal)!=NULL)
     1729              ICOM_CALL(Release,V_UNION(pvarg,pdispVal));
     1730            break;
     1731          case( VT_VARIANT ):
     1732            VariantClear(V_UNION(pvarg,pvarVal));
     1733            break;
     1734          case( VT_UNKNOWN ):
     1735            if(V_UNION(pvarg,punkVal)!=NULL)
     1736              ICOM_CALL(Release,V_UNION(pvarg,punkVal));
     1737            break;
     1738          case( VT_SAFEARRAY ):
     1739            SafeArrayDestroy(V_UNION(pvarg,parray));
     1740            break;
     1741          default:
     1742            break;
     1743        }
    17441744      }
    17451745    }
    1746 
     1746       
    17471747    /*
    17481748     * Empty all the fields and mark the type as empty.
    … …  
    17561756
    17571757/******************************************************************************
    1758  *      VariantCopy [OLEAUT32.10]
     1758 *              VariantCopy     [OLEAUT32.10]
    17591759 *
    17601760 * Frees up the designation variant and makes a copy of the source.
    … …  
    17741774  {
    17751775    res = VariantClear( pvargDest );
    1776 
     1776               
    17771777    if( res == S_OK )
    17781778    {
    17791779      if( V_VT(pvargSrc) & VT_BYREF )
    17801780      {
    1781     /* In the case of byreference we only need
    1782     * to copy the pointer.
    1783     */
    1784     pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
    1785     V_VT(pvargDest) = V_VT(pvargSrc);
     1781        /* In the case of byreference we only need
     1782        * to copy the pointer.
     1783        */
     1784        pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
     1785        V_VT(pvargDest) = V_VT(pvargSrc);
    17861786      }
    17871787      else
    17881788      {
    1789     /*
    1790     * The VT_ARRAY flag is another way to designate a safe array.
    1791     */
    1792     if (V_VT(pvargSrc) & VT_ARRAY)
    1793     {
    1794       SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
    1795     }
    1796     else
    1797     {
    1798       /* In the case of by value we need to
    1799        * copy the actuall value. In the case of
    1800        * VT_BSTR a copy of the string is made,
    1801        * if VT_DISPATCH or VT_IUNKNOWN AddReff is
    1802        * called to increment the object's reference count.
    1803        */
    1804       switch( V_VT(pvargSrc) & VT_TYPEMASK )
    1805       {
    1806         case( VT_BSTR ):
    1807           V_UNION(pvargDest,bstrVal) = SysAllocString( V_UNION(pvargSrc,bstrVal) );
    1808           break;
    1809         case( VT_DISPATCH ):
    1810           V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
    1811           if (V_UNION(pvargDest,pdispVal)!=NULL)
    1812         ICOM_CALL(AddRef,V_UNION(pvargDest,pdispVal));
    1813           break;
    1814         case( VT_VARIANT ):
    1815           VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
    1816           break;
    1817         case( VT_UNKNOWN ):
    1818           V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
    1819           if (V_UNION(pvargDest,pdispVal)!=NULL)
    1820         ICOM_CALL(AddRef,V_UNION(pvargDest,punkVal));
    1821           break;
    1822         case( VT_SAFEARRAY ):
    1823           SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
    1824           break;
    1825         default:
    1826           pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
    1827           break;
    1828       }
    1829     }
    1830 
    1831     V_VT(pvargDest) = V_VT(pvargSrc);
    1832       }
     1789        /*
     1790        * The VT_ARRAY flag is another way to designate a safe array.
     1791        */
     1792        if (V_VT(pvargSrc) & VT_ARRAY)
     1793        {
     1794          SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
     1795        }
     1796        else
     1797        {
     1798          /* In the case of by value we need to
     1799           * copy the actuall value. In the case of
     1800           * VT_BSTR a copy of the string is made,
     1801           * if VT_DISPATCH or VT_IUNKNOWN AddReff is
     1802           * called to increment the object's reference count.
     1803           */
     1804          switch( V_VT(pvargSrc) & VT_TYPEMASK )
     1805          {
     1806            case( VT_BSTR ):
     1807              V_UNION(pvargDest,bstrVal) = SysAllocString( V_UNION(pvargSrc,bstrVal) );
     1808              break;
     1809            case( VT_DISPATCH ):
     1810              V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
     1811              if (V_UNION(pvargDest,pdispVal)!=NULL)
     1812                ICOM_CALL(AddRef,V_UNION(pvargDest,pdispVal));
     1813              break;
     1814            case( VT_VARIANT ):
     1815              VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
     1816              break;
     1817            case( VT_UNKNOWN ):
     1818              V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
     1819              if (V_UNION(pvargDest,pdispVal)!=NULL)
     1820                ICOM_CALL(AddRef,V_UNION(pvargDest,punkVal));
     1821              break;
     1822            case( VT_SAFEARRAY ):
     1823              SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
     1824              break;
     1825            default:
     1826              pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
     1827              break;
     1828          }
     1829        }
     1830       
     1831        V_VT(pvargDest) = V_VT(pvargSrc);
     1832      }     
    18331833    }
    18341834  }
    … …  
    18391839
    18401840/******************************************************************************
    1841  *      VariantCopyInd  [OLEAUT32.11]
     1841 *              VariantCopyInd  [OLEAUT32.11]
    18421842 *
    18431843 * Frees up the destination variant and makes a copy of the source.  If
    … …  
    18541854  if( res != S_OK )
    18551855    return res;
    1856 
     1856 
    18571857  if( V_VT(pvargSrc) & VT_BYREF )
    18581858  {
    … …  
    18761876      if( res == S_OK )
    18771877      {
    1878     /*
    1879     * The VT_ARRAY flag is another way to designate a safearray variant.
    1880     */
    1881     if ( V_VT(pvargSrc) & VT_ARRAY)
    1882     {
    1883       SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
    1884     }
    1885     else
    1886     {
    1887       /* In the case of by reference we need
    1888        * to copy the date pointed to by the variant.
    1889        */
    1890 
    1891       /* Get the variant type.
    1892        */
    1893       switch( V_VT(pvargSrc) & VT_TYPEMASK )
    1894       {
    1895         case( VT_BSTR ):
    1896           V_UNION(pvargDest,bstrVal) = SysAllocString( *(V_UNION(pvargSrc,pbstrVal)) );
    1897           break;
    1898         case( VT_DISPATCH ):
    1899           break;
    1900         case( VT_VARIANT ):
    1901           {
    1902         /* Prevent from cycling.  According to tests on
    1903         * VariantCopyInd in Windows and the documentation
    1904         * this API dereferences the inner Variants to only one depth.
    1905         * If the inner Variant itself contains an
    1906         * other inner variant the E_INVALIDARG error is
    1907          * returned.
    1908         */
    1909         if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
    1910         {
    1911           /* If we get here we are attempting to deference
    1912            * an inner variant that that is itself contained
    1913            * in an inner variant so report E_INVALIDARG error.
    1914            */
    1915           res = E_INVALIDARG;
    1916         }
    1917         else
    1918         {
    1919           /* Set the processing inner variant flag.
    1920            * We will set this flag in the inner variant
    1921            * that will be passed to the VariantCopyInd function.
    1922            */
    1923           (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
    1924 
    1925           /* Dereference the inner variant.
    1926            */
    1927           res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
    1928           /* We must also copy its type, I think.
    1929            */
    1930           V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
    1931         }
    1932           }
    1933           break;
    1934         case( VT_UNKNOWN ):
    1935           break;
    1936         case( VT_SAFEARRAY ):
    1937           SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
    1938           break;
    1939         default:
    1940           /* This is a by reference Variant which means that the union
    1941            * part of the Variant contains a pointer to some data of
    1942            * type "V_VT(pvargSrc) & VT_TYPEMASK".
    1943            * We will deference this data in a generic fashion using
    1944            * the void pointer "Variant.u.byref".
    1945            * We will copy this data into the union of the destination
    1946            * Variant.
    1947            */
    1948           memcpy( &pvargDest->n1.n2, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
    1949           break;
    1950       }
    1951     }
    1952 
    1953     V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
     1878        /*
     1879        * The VT_ARRAY flag is another way to designate a safearray variant.
     1880        */
     1881        if ( V_VT(pvargSrc) & VT_ARRAY)
     1882        {
     1883          SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
     1884        }
     1885        else
     1886        {
     1887          /* In the case of by reference we need
     1888           * to copy the date pointed to by the variant.
     1889           */
     1890
     1891          /* Get the variant type.
     1892           */
     1893          switch( V_VT(pvargSrc) & VT_TYPEMASK )
     1894          {
     1895            case( VT_BSTR ):
     1896              V_UNION(pvargDest,bstrVal) = SysAllocString( *(V_UNION(pvargSrc,pbstrVal)) );
     1897              break;
     1898            case( VT_DISPATCH ):
     1899              break;
     1900            case( VT_VARIANT ):
     1901              {
     1902                /* Prevent from cycling.  According to tests on
     1903                * VariantCopyInd in Windows and the documentation
     1904                * this API dereferences the inner Variants to only one depth.
     1905                * If the inner Variant itself contains an
     1906                * other inner variant the E_INVALIDARG error is
     1907                 * returned.
     1908                */
     1909                if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
     1910                {
     1911                  /* If we get here we are attempting to deference
     1912                   * an inner variant that that is itself contained
     1913                   * in an inner variant so report E_INVALIDARG error.
     1914                   */
     1915                  res = E_INVALIDARG;
     1916                }
     1917                else
     1918                {
     1919                  /* Set the processing inner variant flag.
     1920                   * We will set this flag in the inner variant
     1921                   * that will be passed to the VariantCopyInd function.
     1922                   */
     1923                  (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
     1924                 
     1925                  /* Dereference the inner variant.
     1926                   */
     1927                  res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
     1928                  /* We must also copy its type, I think.
     1929                   */
     1930                  V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
     1931                }
     1932              }
     1933              break;
     1934            case( VT_UNKNOWN ):
     1935              break;
     1936            case( VT_SAFEARRAY ):
     1937              SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
     1938              break;
     1939            default:
     1940              /* This is a by reference Variant which means that the union
     1941               * part of the Variant contains a pointer to some data of
     1942               * type "V_VT(pvargSrc) & VT_TYPEMASK".
     1943               * We will deference this data in a generic fashion using
     1944               * the void pointer "Variant.u.byref".
     1945               * We will copy this data into the union of the destination
     1946               * Variant.
     1947               */
     1948              memcpy( &pvargDest->n1.n2, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
     1949              break;
     1950          }
     1951        }
     1952       
     1953        V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
    19541954      }
    19551955    }
    … …  
    19681968
    19691969/******************************************************************************
    1970  *      VariantChangeType   [OLEAUT32.12]
     1970 *              VariantChangeType       [OLEAUT32.12]
    19711971 */
    19721972HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
    1973                             USHORT wFlags, VARTYPE vt)
    1974 {
    1975     return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
    1976 }
    1977 
    1978 /******************************************************************************
    1979  *      VariantChangeTypeEx [OLEAUT32.147]
     1973                                                        USHORT wFlags, VARTYPE vt)
     1974{
     1975        return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
     1976}
     1977
     1978/******************************************************************************
     1979 *              VariantChangeTypeEx     [OLEAUT32.147]
    19801980 */
    19811981HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
    1982                               LCID lcid, USHORT wFlags, VARTYPE vt)
    1983 {
    1984     HRESULT res = S_OK;
    1985     VARIANTARG varg;
    1986     VariantInit( &varg );
    1987 
    1988     TRACE("(%p, %p, %ld, %u, %u),stub\n", pvargDest, pvargSrc, lcid, wFlags, vt);
    1989 
    1990     /* validate our source argument.
    1991     */
    1992     res = ValidateVariantType( V_VT(pvargSrc) );
    1993 
    1994     /* validate the vartype.
    1995     */
    1996     if( res == S_OK )
    1997     {
    1998         res = ValidateVt( vt );
    1999     }
    2000 
    2001     /* if we are doing an in-place conversion make a copy of the source.
    2002     */
    2003     if( res == S_OK && pvargDest == pvargSrc )
    2004     {
    2005         res = VariantCopy( &varg, pvargSrc );
    2006         pvargSrc = &varg;
    2007     }
    2008 
    2009     if( res == S_OK )
    2010     {
    2011         /* free up the destination variant.
    2012         */
    2013         res = VariantClear( pvargDest );
    2014     }
    2015 
    2016     if( res == S_OK )
    2017     {
    2018         if( V_VT(pvargSrc) & VT_BYREF )
    2019         {
    2020             /* Convert the source variant to a "byvalue" variant.
    2021             */
    2022             VARIANTARG Variant;
    2023             VariantInit( &Variant );
    2024             res = VariantCopyInd( &Variant, pvargSrc );
    2025             if( res == S_OK )
    2026             {
    2027                 res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
    2028                 /* this should not fail.
    2029                 */
    2030                 VariantClear( &Variant );
    2031             }
    2032 
    2033         }
    2034         else
    2035         {
    2036             /* Use the current "byvalue" source variant.
    2037             */
    2038             res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
    2039         }
    2040     }
    2041     /* this should not fail.
    2042     */
    2043     VariantClear( &varg );
    2044 
    2045     /* set the type of the destination
    2046     */
    2047     if ( res == S_OK )
    2048         V_VT(pvargDest) = vt;
    2049 
    2050     return res;
    2051 }
    2052 
    2053 
    2054 
    2055 
    2056 /******************************************************************************
    2057  *      VarUI1FromI2        [OLEAUT32.130]
     1982                                                          LCID lcid, USHORT wFlags, VARTYPE vt)
     1983{
     1984        HRESULT res = S_OK;
     1985        VARIANTARG varg;
     1986        VariantInit( &varg );
     1987       
     1988        TRACE("(%p, %p, %ld, %u, %u),stub\n", pvargDest, pvargSrc, lcid, wFlags, vt);
     1989
     1990        /* validate our source argument.
     1991        */
     1992        res = ValidateVariantType( V_VT(pvargSrc) );
     1993
     1994        /* validate the vartype.
     1995        */
     1996        if( res == S_OK )
     1997        {
     1998                res = ValidateVt( vt );
     1999        }
     2000
     2001        /* if we are doing an in-place conversion make a copy of the source.
     2002        */
     2003        if( res == S_OK && pvargDest == pvargSrc )
     2004        {
     2005                res = VariantCopy( &varg, pvargSrc );
     2006                pvargSrc = &varg;
     2007        }
     2008
     2009        if( res == S_OK )
     2010        {
     2011                /* free up the destination variant.
     2012                */
     2013                res = VariantClear( pvargDest );
     2014        }
     2015
     2016        if( res == S_OK )
     2017        {
     2018                if( V_VT(pvargSrc) & VT_BYREF )
     2019                {
     2020                        /* Convert the source variant to a "byvalue" variant.
     2021                        */
     2022                        VARIANTARG Variant;
     2023                        VariantInit( &Variant );
     2024                        res = VariantCopyInd( &Variant, pvargSrc );
     2025                        if( res == S_OK )
     2026                        {
     2027                                res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
     2028                                /* this should not fail.
     2029                                */
     2030                                VariantClear( &Variant );
     2031                        }
     2032       
     2033                }
     2034                else
     2035                {
     2036                        /* Use the current "byvalue" source variant.
     2037                        */
     2038                        res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
     2039                }
     2040        }
     2041        /* this should not fail.
     2042        */
     2043        VariantClear( &varg );
     2044       
     2045        /* set the type of the destination
     2046        */
     2047        if ( res == S_OK )
     2048                V_VT(pvargDest) = vt;
     2049
     2050        return res;
     2051}
     2052
     2053
     2054
     2055
     2056/******************************************************************************
     2057 *              VarUI1FromI2            [OLEAUT32.130]
    20582058 */
    20592059HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut)
    20602060{
    2061     TRACE("( %d, %p ), stub\n", sIn, pbOut );
    2062 
    2063     /* Check range of value.
    2064     */
    2065     if( sIn < UI1_MIN || sIn > UI1_MAX )
    2066     {
    2067         return DISP_E_OVERFLOW;
    2068     }
    2069 
    2070     *pbOut = (BYTE) sIn;
    2071 
    2072     return S_OK;
    2073 }
    2074 
    2075 /******************************************************************************
    2076  *      VarUI1FromI4        [OLEAUT32.131]
     2061        TRACE("( %d, %p ), stub\n", sIn, pbOut );
     2062
     2063        /* Check range of value.
     2064        */
     2065        if( sIn < UI1_MIN || sIn > UI1_MAX )
     2066        {
     2067                return DISP_E_OVERFLOW;
     2068        }
     2069
     2070        *pbOut = (BYTE) sIn;
     2071       
     2072        return S_OK;
     2073}
     2074
     2075/******************************************************************************
     2076 *              VarUI1FromI4            [OLEAUT32.131]
    20772077 */
    20782078HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut)
    20792079{
    2080     TRACE("( %ld, %p ), stub\n", lIn, pbOut );
    2081 
    2082     /* Check range of value.
    2083     */
    2084     if( lIn < UI1_MIN || lIn > UI1_MAX )
    2085     {
    2086         return DISP_E_OVERFLOW;
    2087     }
    2088 
    2089     *pbOut = (BYTE) lIn;
    2090 
    2091     return S_OK;
    2092 }
    2093 
    2094 
    2095 /******************************************************************************
    2096  *      VarUI1FromR4        [OLEAUT32.132]
     2080        TRACE("( %ld, %p ), stub\n", lIn, pbOut );
     2081
     2082        /* Check range of value.
     2083        */
     2084        if( lIn < UI1_MIN || lIn > UI1_MAX )
     2085        {
     2086                return DISP_E_OVERFLOW;
     2087        }
     2088
     2089        *pbOut = (BYTE) lIn;
     2090       
     2091        return S_OK;
     2092}
     2093
     2094
     2095/******************************************************************************
     2096 *              VarUI1FromR4            [OLEAUT32.132]
    20972097 */
    20982098HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
    20992099{
    2100     TRACE("( %f, %p ), stub\n", fltIn, pbOut );
    2101 
    2102     /* Check range of value.
     2100        TRACE("( %f, %p ), stub\n", fltIn, pbOut );
     2101
     2102        /* Check range of value.
    21032103     */
    21042104    fltIn = round( fltIn );
    2105     if( fltIn < UI1_MIN || fltIn > UI1_MAX )
    2106     {
    2107         return DISP_E_OVERFLOW;
    2108     }
    2109 
    2110     *pbOut = (BYTE) fltIn;
    2111 
    2112     return S_OK;
    2113 }
    2114 
    2115 /******************************************************************************
    2116  *      VarUI1FromR8        [OLEAUT32.133]
     2105        if( fltIn < UI1_MIN || fltIn > UI1_MAX )
     2106        {
     2107                return DISP_E_OVERFLOW;
     2108        }
     2109
     2110        *pbOut = (BYTE) fltIn;
     2111       
     2112        return S_OK;
     2113}
     2114
     2115/******************************************************************************
     2116 *              VarUI1FromR8            [OLEAUT32.133]
    21172117 */
    21182118HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
    21192119{
    2120     TRACE("( %f, %p ), stub\n", dblIn, pbOut );
    2121 
    2122     /* Check range of value.
     2120        TRACE("( %f, %p ), stub\n", dblIn, pbOut );
     2121
     2122        /* Check range of value.
    21232123     */
    21242124    dblIn = round( dblIn );
    2125     if( dblIn < UI1_MIN || dblIn > UI1_MAX )
    2126     {
    2127         return DISP_E_OVERFLOW;
    2128     }
    2129 
    2130     *pbOut = (BYTE) dblIn;
    2131 
    2132     return S_OK;
    2133 }
    2134 
    2135 /******************************************************************************
    2136  *      VarUI1FromDate      [OLEAUT32.135]
     2125        if( dblIn < UI1_MIN || dblIn > UI1_MAX )
     2126        {
     2127                return DISP_E_OVERFLOW;
     2128        }
     2129
     2130        *pbOut = (BYTE) dblIn;
     2131
     2132        return S_OK;
     2133}
     2134
     2135/******************************************************************************
     2136 *              VarUI1FromDate          [OLEAUT32.135]
    21372137 */
    21382138HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
    21392139{
    2140     TRACE("( %f, %p ), stub\n", dateIn, pbOut );
    2141 
    2142     /* Check range of value.
     2140        TRACE("( %f, %p ), stub\n", dateIn, pbOut );
     2141
     2142        /* Check range of value.
    21432143     */
    21442144    dateIn = round( dateIn );
    2145     if( dateIn < UI1_MIN || dateIn > UI1_MAX )
    2146     {
    2147         return DISP_E_OVERFLOW;
    2148     }
    2149 
    2150     *pbOut = (BYTE) dateIn;
    2151 
    2152     return S_OK;
    2153 }
    2154 
    2155 /******************************************************************************
    2156  *      VarUI1FromBool      [OLEAUT32.138]
     2145        if( dateIn < UI1_MIN || dateIn > UI1_MAX )
     2146        {
     2147                return DISP_E_OVERFLOW;
     2148        }
     2149
     2150        *pbOut = (BYTE) dateIn;
     2151
     2152        return S_OK;
     2153}
     2154
     2155/******************************************************************************
     2156 *              VarUI1FromBool          [OLEAUT32.138]
    21572157 */
    21582158HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
    21592159{
    2160     TRACE("( %d, %p ), stub\n", boolIn, pbOut );
    2161 
    2162     *pbOut = (BYTE) boolIn;
    2163 
    2164     return S_OK;
    2165 }
    2166 
    2167 /******************************************************************************
    2168  *      VarUI1FromI1        [OLEAUT32.237]
     2160        TRACE("( %d, %p ), stub\n", boolIn, pbOut );
     2161
     2162        *pbOut = (BYTE) boolIn;
     2163
     2164        return S_OK;
     2165}
     2166
     2167/******************************************************************************
     2168 *              VarUI1FromI1            [OLEAUT32.237]
    21692169 */
    21702170HRESULT WINAPI VarUI1FromI1(CHAR cIn, BYTE* pbOut)
    21712171{
    2172     TRACE("( %c, %p ), stub\n", cIn, pbOut );
    2173 
    2174     *pbOut = cIn;
    2175 
    2176     return S_OK;
    2177 }
    2178 
    2179 /******************************************************************************
    2180  *      VarUI1FromUI2       [OLEAUT32.238]
     2172        TRACE("( %c, %p ), stub\n", cIn, pbOut );
     2173
     2174        *pbOut = cIn;
     2175
     2176        return S_OK;
     2177}
     2178
     2179/******************************************************************************
     2180 *              VarUI1FromUI2           [OLEAUT32.238]
    21812181 */
    21822182HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut)
    21832183{
    2184     TRACE("( %d, %p ), stub\n", uiIn, pbOut );
    2185 
    2186     /* Check range of value.
    2187     */
    2188     if( uiIn > UI1_MAX )
    2189     {
    2190         return DISP_E_OVERFLOW;
    2191     }
    2192 
    2193     *pbOut = (BYTE) uiIn;
    2194 
    2195     return S_OK;
    2196 }
    2197 
    2198 /******************************************************************************
    2199  *      VarUI1FromUI4       [OLEAUT32.239]
     2184        TRACE("( %d, %p ), stub\n", uiIn, pbOut );
     2185
     2186        /* Check range of value.
     2187        */
     2188        if( uiIn > UI1_MAX )
     2189        {
     2190                return DISP_E_OVERFLOW;
     2191        }
     2192
     2193        *pbOut = (BYTE) uiIn;
     2194
     2195        return S_OK;
     2196}
     2197
     2198/******************************************************************************
     2199 *              VarUI1FromUI4           [OLEAUT32.239]
    22002200 */
    22012201HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
    22022202{
    2203     TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
    2204 
    2205     /* Check range of value.
    2206     */
    2207     if( ulIn > UI1_MAX )
    2208     {
    2209         return DISP_E_OVERFLOW;
    2210     }
    2211 
    2212     *pbOut = (BYTE) ulIn;
    2213 
    2214     return S_OK;
    2215 }
    2216 
    2217 
    2218 /******************************************************************************
    2219  *      VarUI1FromStr       [OLEAUT32.136]
     2203        TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
     2204
     2205        /* Check range of value.
     2206        */
     2207        if( ulIn > UI1_MAX )
     2208        {
     2209                return DISP_E_OVERFLOW;
     2210        }
     2211
     2212        *pbOut = (BYTE) ulIn;
     2213
     2214        return S_OK;
     2215}
     2216
     2217
     2218/******************************************************************************
     2219 *              VarUI1FromStr           [OLEAUT32.136]
    22202220 */
    22212221HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
    22222222{
    2223     double dValue = 0.0;
    2224     LPSTR pNewString = NULL;
    2225 
    2226     TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
    2227 
    2228     /* Check if we have a valid argument
    2229     */
    2230     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    2231     RemoveCharacterFromString( pNewString, "," );
    2232     if( IsValidRealString( pNewString ) == FALSE )
    2233     {
    2234         return DISP_E_TYPEMISMATCH;
    2235     }
    2236 
    2237     /* Convert the valid string to a floating point number.
    2238     */
    2239     dValue = atof( pNewString );
    2240 
    2241     /* We don't need the string anymore so free it.
    2242     */
    2243     HeapFree( GetProcessHeap(), 0 , pNewString );
    2244 
    2245     /* Check range of value.
     2223        double dValue = 0.0;
     2224        LPSTR pNewString = NULL;
     2225
     2226        TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
     2227
     2228        /* Check if we have a valid argument
     2229        */
     2230        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     2231        RemoveCharacterFromString( pNewString, "," );
     2232        if( IsValidRealString( pNewString ) == FALSE )
     2233        {
     2234                return DISP_E_TYPEMISMATCH;
     2235        }
     2236
     2237        /* Convert the valid string to a floating point number.
     2238        */
     2239        dValue = atof( pNewString );
     2240       
     2241        /* We don't need the string anymore so free it.
     2242        */
     2243        HeapFree( GetProcessHeap(), 0 , pNewString );
     2244
     2245        /* Check range of value.
    22462246     */
    22472247    dValue = round( dValue );
    2248     if( dValue < UI1_MIN || dValue > UI1_MAX )
    2249     {
    2250         return DISP_E_OVERFLOW;
    2251     }
    2252 
    2253     *pbOut = (BYTE) dValue;
    2254 
    2255     return S_OK;
     2248        if( dValue < UI1_MIN || dValue > UI1_MAX )
     2249        {
     2250                return DISP_E_OVERFLOW;
     2251        }
     2252
     2253        *pbOut = (BYTE) dValue;
     2254
     2255        return S_OK;
    22562256}
    22572257
    … …  
    22622262HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
    22632263   double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    2264 
     2264   
    22652265   if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
    2266 
     2266   
    22672267   *pbOut = (BYTE)t;
    22682268   return S_OK;
    … …  
    22702270
    22712271/******************************************************************************
    2272  *      VarI2FromUI1        [OLEAUT32.48]
     2272 *              VarI2FromUI1            [OLEAUT32.48]
    22732273 */
    22742274HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut)
    22752275{
    2276     TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
    2277 
    2278     *psOut = (short) bIn;
    2279 
    2280     return S_OK;
    2281 }
    2282 
    2283 /******************************************************************************
    2284  *      VarI2FromI4     [OLEAUT32.49]
     2276        TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
     2277
     2278        *psOut = (short) bIn;
     2279       
     2280        return S_OK;
     2281}
     2282
     2283/******************************************************************************
     2284 *              VarI2FromI4             [OLEAUT32.49]
    22852285 */
    22862286HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut)
    22872287{
    2288     TRACE("( %lx, %p ), stub\n", lIn, psOut );
    2289 
    2290     /* Check range of value.
    2291     */
    2292     if( lIn < I2_MIN || lIn > I2_MAX )
    2293     {
    2294         return DISP_E_OVERFLOW;
    2295     }
    2296 
    2297     *psOut = (short) lIn;
    2298 
    2299     return S_OK;
    2300 }
    2301 
    2302 /******************************************************************************
    2303  *      VarI2FromR4     [OLEAUT32.50]
     2288        TRACE("( %lx, %p ), stub\n", lIn, psOut );
     2289
     2290        /* Check range of value.
     2291        */
     2292        if( lIn < I2_MIN || lIn > I2_MAX )
     2293        {
     2294                return DISP_E_OVERFLOW;
     2295        }
     2296
     2297        *psOut = (short) lIn;
     2298       
     2299        return S_OK;
     2300}
     2301
     2302/******************************************************************************
     2303 *              VarI2FromR4             [OLEAUT32.50]
    23042304 */
    23052305HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut)
    23062306{
    2307     TRACE("( %f, %p ), stub\n", fltIn, psOut );
    2308 
    2309     /* Check range of value.
     2307        TRACE("( %f, %p ), stub\n", fltIn, psOut );
     2308
     2309        /* Check range of value.
    23102310     */
    23112311    fltIn = round( fltIn );
    2312     if( fltIn < I2_MIN || fltIn > I2_MAX )
    2313     {
    2314         return DISP_E_OVERFLOW;
    2315     }
    2316 
    2317     *psOut = (short) fltIn;
    2318 
    2319     return S_OK;
    2320 }
    2321 
    2322 /******************************************************************************
    2323  *      VarI2FromR8     [OLEAUT32.51]
     2312        if( fltIn < I2_MIN || fltIn > I2_MAX )
     2313        {
     2314                return DISP_E_OVERFLOW;
     2315        }
     2316
     2317        *psOut = (short) fltIn;
     2318
     2319        return S_OK;
     2320}
     2321
     2322/******************************************************************************
     2323 *              VarI2FromR8             [OLEAUT32.51]
    23242324 */
    23252325HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut)
    23262326{
    2327     TRACE("( %f, %p ), stub\n", dblIn, psOut );
    2328 
    2329     /* Check range of value.
     2327        TRACE("( %f, %p ), stub\n", dblIn, psOut );
     2328
     2329        /* Check range of value.
    23302330     */
    23312331    dblIn = round( dblIn );
    2332     if( dblIn < I2_MIN || dblIn > I2_MAX )
    2333     {
    2334         return DISP_E_OVERFLOW;
    2335     }
    2336 
    2337     *psOut = (short) dblIn;
    2338 
    2339     return S_OK;
    2340 }
    2341 
    2342 /******************************************************************************
    2343  *      VarI2FromDate       [OLEAUT32.53]
     2332        if( dblIn < I2_MIN || dblIn > I2_MAX )
     2333        {
     2334                return DISP_E_OVERFLOW;
     2335        }
     2336
     2337        *psOut = (short) dblIn;
     2338
     2339        return S_OK;
     2340}
     2341
     2342/******************************************************************************
     2343 *              VarI2FromDate           [OLEAUT32.53]
    23442344 */
    23452345HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut)
    23462346{
    2347     TRACE("( %f, %p ), stub\n", dateIn, psOut );
    2348 
    2349     /* Check range of value.
     2347        TRACE("( %f, %p ), stub\n", dateIn, psOut );
     2348
     2349        /* Check range of value.
    23502350     */
    23512351    dateIn = round( dateIn );
    2352     if( dateIn < I2_MIN || dateIn > I2_MAX )
    2353     {
    2354         return DISP_E_OVERFLOW;
    2355     }
    2356 
    2357     *psOut = (short) dateIn;
    2358 
    2359     return S_OK;
    2360 }
    2361 
    2362 /******************************************************************************
    2363  *      VarI2FromBool       [OLEAUT32.56]
     2352        if( dateIn < I2_MIN || dateIn > I2_MAX )
     2353        {
     2354                return DISP_E_OVERFLOW;
     2355        }
     2356
     2357        *psOut = (short) dateIn;
     2358
     2359        return S_OK;
     2360}
     2361
     2362/******************************************************************************
     2363 *              VarI2FromBool           [OLEAUT32.56]
    23642364 */
    23652365HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut)
    23662366{
    2367     TRACE("( %d, %p ), stub\n", boolIn, psOut );
    2368 
    2369     *psOut = (short) boolIn;
    2370 
    2371     return S_OK;
    2372 }
    2373 
    2374 /******************************************************************************
    2375  *      VarI2FromI1     [OLEAUT32.205]
     2367        TRACE("( %d, %p ), stub\n", boolIn, psOut );
     2368
     2369        *psOut = (short) boolIn;
     2370
     2371        return S_OK;
     2372}
     2373
     2374/******************************************************************************
     2375 *              VarI2FromI1             [OLEAUT32.205]
    23762376 */
    23772377HRESULT WINAPI VarI2FromI1(CHAR cIn, short* psOut)
    23782378{
    2379     TRACE("( %c, %p ), stub\n", cIn, psOut );
    2380 
    2381     *psOut = (short) cIn;
    2382 
    2383     return S_OK;
    2384 }
    2385 
    2386 /******************************************************************************
    2387  *      VarI2FromUI2        [OLEAUT32.206]
     2379        TRACE("( %c, %p ), stub\n", cIn, psOut );
     2380
     2381        *psOut = (short) cIn;
     2382
     2383        return S_OK;
     2384}
     2385
     2386/******************************************************************************
     2387 *              VarI2FromUI2            [OLEAUT32.206]
    23882388 */
    23892389HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut)
    23902390{
    2391     TRACE("( %d, %p ), stub\n", uiIn, psOut );
    2392 
    2393     /* Check range of value.
    2394     */
    2395     if( uiIn > I2_MAX )
    2396     {
    2397         return DISP_E_OVERFLOW;
    2398     }
    2399 
    2400     *psOut = (short) uiIn;
    2401 
    2402     return S_OK;
    2403 }
    2404 
    2405 /******************************************************************************
    2406  *      VarI2FromUI4        [OLEAUT32.207]
     2391        TRACE("( %d, %p ), stub\n", uiIn, psOut );
     2392
     2393        /* Check range of value.
     2394        */
     2395        if( uiIn > I2_MAX )
     2396        {
     2397                return DISP_E_OVERFLOW;
     2398        }
     2399
     2400        *psOut = (short) uiIn;
     2401
     2402        return S_OK;
     2403}
     2404
     2405/******************************************************************************
     2406 *              VarI2FromUI4            [OLEAUT32.207]
    24072407 */
    24082408HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
    24092409{
    2410     TRACE("( %lx, %p ), stub\n", ulIn, psOut );
    2411 
    2412     /* Check range of value.
    2413     */
    2414     if( ulIn < I2_MIN || ulIn > I2_MAX )
    2415     {
    2416         return DISP_E_OVERFLOW;
    2417     }
    2418 
    2419     *psOut = (short) ulIn;
    2420 
    2421     return S_OK;
    2422 }
    2423 
    2424 /******************************************************************************
    2425  *      VarI2FromStr        [OLEAUT32.54]
     2410        TRACE("( %lx, %p ), stub\n", ulIn, psOut );
     2411
     2412        /* Check range of value.
     2413        */
     2414        if( ulIn < I2_MIN || ulIn > I2_MAX )
     2415        {
     2416                return DISP_E_OVERFLOW;
     2417        }
     2418
     2419        *psOut = (short) ulIn;
     2420
     2421        return S_OK;
     2422}
     2423
     2424/******************************************************************************
     2425 *              VarI2FromStr            [OLEAUT32.54]
    24262426 */
    24272427HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut)
    24282428{
    2429     double dValue = 0.0;
    2430     LPSTR pNewString = NULL;
    2431 
    2432     TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, psOut );
    2433 
    2434     /* Check if we have a valid argument
    2435     */
    2436     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    2437     RemoveCharacterFromString( pNewString, "," );
    2438     if( IsValidRealString( pNewString ) == FALSE )
    2439     {
    2440         return DISP_E_TYPEMISMATCH;
    2441     }
    2442 
    2443     /* Convert the valid string to a floating point number.
    2444     */
    2445     dValue = atof( pNewString );
    2446 
    2447     /* We don't need the string anymore so free it.
    2448     */
    2449     HeapFree( GetProcessHeap(), 0, pNewString );
    2450 
    2451     /* Check range of value.
     2429        double dValue = 0.0;
     2430        LPSTR pNewString = NULL;
     2431
     2432        TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, psOut );
     2433
     2434        /* Check if we have a valid argument
     2435        */
     2436        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     2437        RemoveCharacterFromString( pNewString, "," );
     2438        if( IsValidRealString( pNewString ) == FALSE )
     2439        {
     2440                return DISP_E_TYPEMISMATCH;
     2441        }
     2442
     2443        /* Convert the valid string to a floating point number.
     2444        */
     2445        dValue = atof( pNewString );
     2446       
     2447        /* We don't need the string anymore so free it.
     2448        */
     2449        HeapFree( GetProcessHeap(), 0, pNewString );
     2450
     2451        /* Check range of value.
    24522452     */
    24532453    dValue = round( dValue );
    2454     if( dValue < I2_MIN || dValue > I2_MAX )
    2455     {
    2456         return DISP_E_OVERFLOW;
    2457     }
    2458 
    2459     *psOut = (short)  dValue;
    2460 
    2461     return S_OK;
     2454        if( dValue < I2_MIN || dValue > I2_MAX )
     2455        {
     2456                return DISP_E_OVERFLOW;
     2457        }
     2458
     2459        *psOut = (short)  dValue;
     2460
     2461        return S_OK;
    24622462}
    24632463
    … …  
    24682468HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
    24692469   double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    2470 
     2470   
    24712471   if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
    2472 
     2472   
    24732473   *psOut = (SHORT)t;
    24742474   return S_OK;
    … …  
    24762476
    24772477/******************************************************************************
    2478  *      VarI4FromUI1        [OLEAUT32.58]
     2478 *              VarI4FromUI1            [OLEAUT32.58]
    24792479 */
    24802480HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut)
    24812481{
    2482     TRACE("( %X, %p ), stub\n", bIn, plOut );
    2483 
    2484     *plOut = (LONG) bIn;
    2485 
    2486     return S_OK;
    2487 }
    2488 
    2489 
    2490 /******************************************************************************
    2491  *      VarI4FromR4     [OLEAUT32.60]
     2482        TRACE("( %X, %p ), stub\n", bIn, plOut );
     2483
     2484        *plOut = (LONG) bIn;
     2485
     2486        return S_OK;
     2487}
     2488
     2489
     2490/******************************************************************************
     2491 *              VarI4FromR4             [OLEAUT32.60]
    24922492 */
    24932493HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut)
    24942494{
    2495     TRACE("( %f, %p ), stub\n", fltIn, plOut );
    2496 
    2497     /* Check range of value.
     2495        TRACE("( %f, %p ), stub\n", fltIn, plOut );
     2496
     2497        /* Check range of value.
    24982498     */
    24992499    fltIn = round( fltIn );
    2500     if( fltIn < I4_MIN || fltIn > I4_MAX )
    2501     {
    2502         return DISP_E_OVERFLOW;
    2503     }
    2504 
    2505     *plOut = (LONG) fltIn;
    2506 
    2507     return S_OK;
    2508 }
    2509 
    2510 /******************************************************************************
    2511  *      VarI4FromR8     [OLEAUT32.61]
     2500        if( fltIn < I4_MIN || fltIn > I4_MAX )
     2501        {
     2502                return DISP_E_OVERFLOW;
     2503        }
     2504
     2505        *plOut = (LONG) fltIn;
     2506
     2507        return S_OK;
     2508}
     2509
     2510/******************************************************************************
     2511 *              VarI4FromR8             [OLEAUT32.61]
    25122512 */
    25132513HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut)
    25142514{
    2515     TRACE("( %f, %p ), stub\n", dblIn, plOut );
    2516 
    2517     /* Check range of value.
     2515        TRACE("( %f, %p ), stub\n", dblIn, plOut );
     2516
     2517        /* Check range of value.
    25182518     */
    25192519    dblIn = round( dblIn );
    2520     if( dblIn < I4_MIN || dblIn > I4_MAX )
    2521     {
    2522         return DISP_E_OVERFLOW;
    2523     }
    2524 
    2525     *plOut = (LONG) dblIn;
    2526 
    2527     return S_OK;
    2528 }
    2529 
    2530 /******************************************************************************
    2531  *      VarI4FromDate       [OLEAUT32.63]
     2520        if( dblIn < I4_MIN || dblIn > I4_MAX )
     2521        {
     2522                return DISP_E_OVERFLOW;
     2523        }
     2524
     2525        *plOut = (LONG) dblIn;
     2526
     2527        return S_OK;
     2528}
     2529
     2530/******************************************************************************
     2531 *              VarI4FromDate           [OLEAUT32.63]
    25322532 */
    25332533HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut)
    25342534{
    2535     TRACE("( %f, %p ), stub\n", dateIn, plOut );
    2536 
    2537     /* Check range of value.
     2535        TRACE("( %f, %p ), stub\n", dateIn, plOut );
     2536
     2537        /* Check range of value.
    25382538     */
    25392539    dateIn = round( dateIn );
    2540     if( dateIn < I4_MIN || dateIn > I4_MAX )
    2541     {
    2542         return DISP_E_OVERFLOW;
    2543     }
    2544 
    2545     *plOut = (LONG) dateIn;
    2546 
    2547     return S_OK;
    2548 }
    2549 
    2550 /******************************************************************************
    2551  *      VarI4FromBool       [OLEAUT32.66]
     2540        if( dateIn < I4_MIN || dateIn > I4_MAX )
     2541        {
     2542                return DISP_E_OVERFLOW;
     2543        }
     2544
     2545        *plOut = (LONG) dateIn;
     2546
     2547        return S_OK;
     2548}
     2549
     2550/******************************************************************************
     2551 *              VarI4FromBool           [OLEAUT32.66]
    25522552 */
    25532553HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut)
    25542554{
    2555     TRACE("( %d, %p ), stub\n", boolIn, plOut );
    2556 
    2557     *plOut = (LONG) boolIn;
    2558 
    2559     return S_OK;
    2560 }
    2561 
    2562 /******************************************************************************
    2563  *      VarI4FromI1     [OLEAUT32.209]
     2555        TRACE("( %d, %p ), stub\n", boolIn, plOut );
     2556
     2557        *plOut = (LONG) boolIn;
     2558
     2559        return S_OK;
     2560}
     2561
     2562/******************************************************************************
     2563 *              VarI4FromI1             [OLEAUT32.209]
    25642564 */
    25652565HRESULT WINAPI VarI4FromI1(CHAR cIn, LONG* plOut)
    25662566{
    2567     TRACE("( %c, %p ), stub\n", cIn, plOut );
    2568 
    2569     *plOut = (LONG) cIn;
    2570 
    2571     return S_OK;
    2572 }
    2573 
    2574 /******************************************************************************
    2575  *      VarI4FromUI2        [OLEAUT32.210]
     2567        TRACE("( %c, %p ), stub\n", cIn, plOut );
     2568
     2569        *plOut = (LONG) cIn;
     2570
     2571        return S_OK;
     2572}
     2573
     2574/******************************************************************************
     2575 *              VarI4FromUI2            [OLEAUT32.210]
    25762576 */
    25772577HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut)
    25782578{
    2579     TRACE("( %d, %p ), stub\n", uiIn, plOut );
    2580 
    2581     *plOut = (LONG) uiIn;
    2582 
    2583     return S_OK;
    2584 }
    2585 
    2586 /******************************************************************************
    2587  *      VarI4FromUI4        [OLEAUT32.211]
     2579        TRACE("( %d, %p ), stub\n", uiIn, plOut );
     2580
     2581        *plOut = (LONG) uiIn;
     2582
     2583        return S_OK;
     2584}
     2585
     2586/******************************************************************************
     2587 *              VarI4FromUI4            [OLEAUT32.211]
    25882588 */
    25892589HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut)
    25902590{
    2591     TRACE("( %lx, %p ), stub\n", ulIn, plOut );
    2592 
    2593     /* Check range of value.
    2594     */
    2595     if( ulIn < I4_MIN || ulIn > I4_MAX )
    2596     {
    2597         return DISP_E_OVERFLOW;
    2598     }
    2599 
    2600     *plOut = (LONG) ulIn;
    2601 
    2602     return S_OK;
    2603 }
    2604 
    2605 /******************************************************************************
    2606  *      VarI4FromI2     [OLEAUT32.59]
     2591        TRACE("( %lx, %p ), stub\n", ulIn, plOut );
     2592
     2593        /* Check range of value.
     2594        */
     2595        if( ulIn < I4_MIN || ulIn > I4_MAX )
     2596        {
     2597                return DISP_E_OVERFLOW;
     2598        }
     2599
     2600        *plOut = (LONG) ulIn;
     2601
     2602        return S_OK;
     2603}
     2604
     2605/******************************************************************************
     2606 *              VarI4FromI2             [OLEAUT32.59]
    26072607 */
    26082608HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut)
    26092609{
    2610     TRACE("( %d, %p ), stub\n", sIn, plOut );
    2611 
    2612     *plOut = (LONG) sIn;
    2613 
    2614     return S_OK;
    2615 }
    2616 
    2617 /******************************************************************************
    2618  *      VarI4FromStr        [OLEAUT32.64]
     2610        TRACE("( %d, %p ), stub\n", sIn, plOut );
     2611
     2612        *plOut = (LONG) sIn;
     2613
     2614        return S_OK;
     2615}
     2616
     2617/******************************************************************************
     2618 *              VarI4FromStr            [OLEAUT32.64]
    26192619 */
    26202620HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut)
    26212621{
    2622     double dValue = 0.0;
    2623     LPSTR pNewString = NULL;
    2624 
    2625     TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
    2626 
    2627     /* Check if we have a valid argument
    2628     */
    2629     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    2630     RemoveCharacterFromString( pNewString, "," );
    2631     if( IsValidRealString( pNewString ) == FALSE )
    2632     {
    2633         return DISP_E_TYPEMISMATCH;
    2634     }
    2635 
    2636     /* Convert the valid string to a floating point number.
    2637     */
    2638     dValue = atof( pNewString );
    2639 
    2640     /* We don't need the string anymore so free it.
    2641     */
    2642     HeapFree( GetProcessHeap(), 0, pNewString );
    2643 
    2644     /* Check range of value.
     2622        double dValue = 0.0;
     2623        LPSTR pNewString = NULL;
     2624
     2625        TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
     2626
     2627        /* Check if we have a valid argument
     2628        */
     2629        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     2630        RemoveCharacterFromString( pNewString, "," );
     2631        if( IsValidRealString( pNewString ) == FALSE )
     2632        {
     2633                return DISP_E_TYPEMISMATCH;
     2634        }
     2635
     2636        /* Convert the valid string to a floating point number.
     2637        */
     2638        dValue = atof( pNewString );
     2639       
     2640        /* We don't need the string anymore so free it.
     2641        */
     2642        HeapFree( GetProcessHeap(), 0, pNewString );
     2643
     2644        /* Check range of value.
    26452645     */
    26462646    dValue = round( dValue );
    2647     if( dValue < I4_MIN || dValue > I4_MAX )
    2648     {
    2649         return DISP_E_OVERFLOW;
    2650     }
    2651 
    2652     *plOut = (LONG) dValue;
    2653 
    2654     return S_OK;
     2647        if( dValue < I4_MIN || dValue > I4_MAX )
     2648        {
     2649                return DISP_E_OVERFLOW;
     2650        }
     2651
     2652        *plOut = (LONG) dValue;
     2653
     2654        return S_OK;
    26552655}
    26562656
    … …  
    26612661HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
    26622662   double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    2663 
     2663   
    26642664   if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
    2665 
     2665   
    26662666   *plOut = (LONG)t;
    26672667   return S_OK;
    … …  
    26692669
    26702670/******************************************************************************
    2671  *      VarR4FromUI1        [OLEAUT32.68]
     2671 *              VarR4FromUI1            [OLEAUT32.68]
    26722672 */
    26732673HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut)
    26742674{
    2675     TRACE("( %X, %p ), stub\n", bIn, pfltOut );
    2676 
    2677     *pfltOut = (FLOAT) bIn;
    2678 
    2679     return S_OK;
    2680 }
    2681 
    2682 /******************************************************************************
    2683  *      VarR4FromI2     [OLEAUT32.69]
     2675        TRACE("( %X, %p ), stub\n", bIn, pfltOut );
     2676
     2677        *pfltOut = (FLOAT) bIn;
     2678
     2679        return S_OK;
     2680}
     2681
     2682/******************************************************************************
     2683 *              VarR4FromI2             [OLEAUT32.69]
    26842684 */
    26852685HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut)
    26862686{
    2687     TRACE("( %d, %p ), stub\n", sIn, pfltOut );
    2688 
    2689     *pfltOut = (FLOAT) sIn;
    2690 
    2691     return S_OK;
    2692 }
    2693 
    2694 /******************************************************************************
    2695  *      VarR4FromI4     [OLEAUT32.70]
     2687        TRACE("( %d, %p ), stub\n", sIn, pfltOut );
     2688
     2689        *pfltOut = (FLOAT) sIn;
     2690
     2691        return S_OK;
     2692}
     2693
     2694/******************************************************************************
     2695 *              VarR4FromI4             [OLEAUT32.70]
    26962696 */
    26972697HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut)
    26982698{
    2699     TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
    2700 
    2701     *pfltOut = (FLOAT) lIn;
    2702 
    2703     return S_OK;
    2704 }
    2705 
    2706 /******************************************************************************
    2707  *      VarR4FromR8     [OLEAUT32.71]
     2699        TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
     2700
     2701        *pfltOut = (FLOAT) lIn;
     2702
     2703        return S_OK;
     2704}
     2705
     2706/******************************************************************************
     2707 *              VarR4FromR8             [OLEAUT32.71]
    27082708 */
    27092709HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut)
    27102710{
    2711     TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
    2712 
    2713     /* Check range of value.
    2714     */
    2715     if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
    2716     {
    2717         return DISP_E_OVERFLOW;
    2718     }
    2719 
    2720     *pfltOut = (FLOAT) dblIn;
    2721 
    2722     return S_OK;
    2723 }
    2724 
    2725 /******************************************************************************
    2726  *      VarR4FromDate       [OLEAUT32.73]
     2711        TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
     2712
     2713        /* Check range of value.
     2714        */
     2715        if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
     2716        {
     2717                return DISP_E_OVERFLOW;
     2718        }
     2719
     2720        *pfltOut = (FLOAT) dblIn;
     2721
     2722        return S_OK;
     2723}
     2724
     2725/******************************************************************************
     2726 *              VarR4FromDate           [OLEAUT32.73]
    27272727 */
    27282728HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut)
    27292729{
    2730     TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
    2731 
    2732     /* Check range of value.
    2733     */
    2734     if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
    2735     {
    2736         return DISP_E_OVERFLOW;
    2737     }
    2738 
    2739     *pfltOut = (FLOAT) dateIn;
    2740 
    2741     return S_OK;
    2742 }
    2743 
    2744 /******************************************************************************
    2745  *      VarR4FromBool       [OLEAUT32.76]
     2730        TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
     2731
     2732        /* Check range of value.
     2733        */
     2734        if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
     2735        {
     2736                return DISP_E_OVERFLOW;
     2737        }
     2738
     2739        *pfltOut = (FLOAT) dateIn;
     2740
     2741        return S_OK;
     2742}
     2743
     2744/******************************************************************************
     2745 *              VarR4FromBool           [OLEAUT32.76]
    27462746 */
    27472747HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut)
    27482748{
    2749     TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
    2750 
    2751     *pfltOut = (FLOAT) boolIn;
    2752 
    2753     return S_OK;
    2754 }
    2755 
    2756 /******************************************************************************
    2757  *      VarR4FromI1     [OLEAUT32.213]
     2749        TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
     2750
     2751        *pfltOut = (FLOAT) boolIn;
     2752
     2753        return S_OK;
     2754}
     2755
     2756/******************************************************************************
     2757 *              VarR4FromI1             [OLEAUT32.213]
    27582758 */
    27592759HRESULT WINAPI VarR4FromI1(CHAR cIn, FLOAT* pfltOut)
    27602760{
    2761     TRACE("( %c, %p ), stub\n", cIn, pfltOut );
    2762 
    2763     *pfltOut = (FLOAT) cIn;
    2764 
    2765     return S_OK;
    2766 }
    2767 
    2768 /******************************************************************************
    2769  *      VarR4FromUI2        [OLEAUT32.214]
     2761        TRACE("( %c, %p ), stub\n", cIn, pfltOut );
     2762
     2763        *pfltOut = (FLOAT) cIn;
     2764
     2765        return S_OK;
     2766}
     2767
     2768/******************************************************************************
     2769 *              VarR4FromUI2            [OLEAUT32.214]
    27702770 */
    27712771HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut)
    27722772{
    2773     TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
    2774 
    2775     *pfltOut = (FLOAT) uiIn;
    2776 
    2777     return S_OK;
    2778 }
    2779 
    2780 /******************************************************************************
    2781  *      VarR4FromUI4        [OLEAUT32.215]
     2773        TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
     2774
     2775        *pfltOut = (FLOAT) uiIn;
     2776
     2777        return S_OK;
     2778}
     2779
     2780/******************************************************************************
     2781 *              VarR4FromUI4            [OLEAUT32.215]
    27822782 */
    27832783HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut)
    27842784{
    2785     TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
    2786 
    2787     *pfltOut = (FLOAT) ulIn;
    2788 
    2789     return S_OK;
    2790 }
    2791 
    2792 /******************************************************************************
    2793  *      VarR4FromStr        [OLEAUT32.74]
     2785        TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
     2786
     2787        *pfltOut = (FLOAT) ulIn;
     2788
     2789        return S_OK;
     2790}
     2791
     2792/******************************************************************************
     2793 *              VarR4FromStr            [OLEAUT32.74]
    27942794 */
    27952795HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut)
    27962796{
    2797     double dValue = 0.0;
    2798     LPSTR pNewString = NULL;
    2799 
    2800     TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
    2801 
    2802     /* Check if we have a valid argument
    2803     */
    2804     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    2805     RemoveCharacterFromString( pNewString, "," );
    2806     if( IsValidRealString( pNewString ) == FALSE )
    2807     {
    2808         return DISP_E_TYPEMISMATCH;
    2809     }
    2810 
    2811     /* Convert the valid string to a floating point number.
    2812     */
    2813     dValue = atof( pNewString );
    2814 
    2815     /* We don't need the string anymore so free it.
    2816     */
    2817     HeapFree( GetProcessHeap(), 0, pNewString );
    2818 
    2819     /* Check range of value.
    2820     */
    2821     if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
    2822     {
    2823         return DISP_E_OVERFLOW;
    2824     }
    2825 
    2826     *pfltOut = (FLOAT) dValue;
    2827 
    2828     return S_OK;
     2797        double dValue = 0.0;
     2798        LPSTR pNewString = NULL;
     2799
     2800        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
     2801
     2802        /* Check if we have a valid argument
     2803        */
     2804        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     2805        RemoveCharacterFromString( pNewString, "," );
     2806        if( IsValidRealString( pNewString ) == FALSE )
     2807        {
     2808                return DISP_E_TYPEMISMATCH;
     2809        }
     2810
     2811        /* Convert the valid string to a floating point number.
     2812        */
     2813        dValue = atof( pNewString );
     2814       
     2815        /* We don't need the string anymore so free it.
     2816        */
     2817        HeapFree( GetProcessHeap(), 0, pNewString );
     2818
     2819        /* Check range of value.
     2820        */
     2821        if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
     2822        {
     2823                return DISP_E_OVERFLOW;
     2824        }
     2825
     2826        *pfltOut = (FLOAT) dValue;
     2827
     2828        return S_OK;
    28292829}
    28302830
    … …  
    28352835HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
    28362836   *pfltOut = (FLOAT)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    2837 
     2837   
    28382838   return S_OK;
    28392839}
    28402840
    28412841/******************************************************************************
    2842  *      VarR8FromUI1        [OLEAUT32.78]
     2842 *              VarR8FromUI1            [OLEAUT32.78]
    28432843 */
    28442844HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
    28452845{
    2846     TRACE("( %d, %p ), stub\n", bIn, pdblOut );
    2847 
    2848     *pdblOut = (double) bIn;
    2849 
    2850     return S_OK;
    2851 }
    2852 
    2853 /******************************************************************************
    2854  *      VarR8FromI2     [OLEAUT32.79]
     2846        TRACE("( %d, %p ), stub\n", bIn, pdblOut );
     2847
     2848        *pdblOut = (double) bIn;
     2849
     2850        return S_OK;
     2851}
     2852
     2853/******************************************************************************
     2854 *              VarR8FromI2             [OLEAUT32.79]
    28552855 */
    28562856HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
    28572857{
    2858     TRACE("( %d, %p ), stub\n", sIn, pdblOut );
    2859 
    2860     *pdblOut = (double) sIn;
    2861 
    2862     return S_OK;
    2863 }
    2864 
    2865 /******************************************************************************
    2866  *      VarR8FromI4     [OLEAUT32.80]
     2858        TRACE("( %d, %p ), stub\n", sIn, pdblOut );
     2859
     2860        *pdblOut = (double) sIn;
     2861
     2862        return S_OK;
     2863}
     2864
     2865/******************************************************************************
     2866 *              VarR8FromI4             [OLEAUT32.80]
    28672867 */
    28682868HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
    28692869{
    2870     TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
    2871 
    2872     *pdblOut = (double) lIn;
    2873 
    2874     return S_OK;
    2875 }
    2876 
    2877 /******************************************************************************
    2878  *      VarR8FromR4     [OLEAUT32.81]
     2870        TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
     2871
     2872        *pdblOut = (double) lIn;
     2873
     2874        return S_OK;
     2875}
     2876
     2877/******************************************************************************
     2878 *              VarR8FromR4             [OLEAUT32.81]
    28792879 */
    28802880HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut)
    28812881{
    2882     TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
    2883 
    2884     *pdblOut = (double) fltIn;
    2885 
    2886     return S_OK;
    2887 }
    2888 
    2889 /******************************************************************************
    2890  *      VarR8FromDate       [OLEAUT32.83]
     2882        TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
     2883
     2884        *pdblOut = (double) fltIn;
     2885
     2886        return S_OK;
     2887}
     2888
     2889/******************************************************************************
     2890 *              VarR8FromDate           [OLEAUT32.83]
    28912891 */
    28922892HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut)
    28932893{
    2894     TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
    2895 
    2896     *pdblOut = (double) dateIn;
    2897 
    2898     return S_OK;
    2899 }
    2900 
    2901 /******************************************************************************
    2902  *      VarR8FromBool       [OLEAUT32.86]
     2894        TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
     2895
     2896        *pdblOut = (double) dateIn;
     2897
     2898        return S_OK;
     2899}
     2900
     2901/******************************************************************************
     2902 *              VarR8FromBool           [OLEAUT32.86]
    29032903 */
    29042904HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut)
    29052905{
    2906     TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
    2907 
    2908     *pdblOut = (double) boolIn;
    2909 
    2910     return S_OK;
    2911 }
    2912 
    2913 /******************************************************************************
    2914  *      VarR8FromI1     [OLEAUT32.217]
     2906        TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
     2907
     2908        *pdblOut = (double) boolIn;
     2909
     2910        return S_OK;
     2911}
     2912
     2913/******************************************************************************
     2914 *              VarR8FromI1             [OLEAUT32.217]
    29152915 */
    29162916HRESULT WINAPI VarR8FromI1(CHAR cIn, double* pdblOut)
    29172917{
    2918     TRACE("( %c, %p ), stub\n", cIn, pdblOut );
    2919 
    2920     *pdblOut = (double) cIn;
    2921 
    2922     return S_OK;
    2923 }
    2924 
    2925 /******************************************************************************
    2926  *      VarR8FromUI2        [OLEAUT32.218]
     2918        TRACE("( %c, %p ), stub\n", cIn, pdblOut );
     2919
     2920        *pdblOut = (double) cIn;
     2921
     2922        return S_OK;
     2923}
     2924
     2925/******************************************************************************
     2926 *              VarR8FromUI2            [OLEAUT32.218]
    29272927 */
    29282928HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut)
    29292929{
    2930     TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
    2931 
    2932     *pdblOut = (double) uiIn;
    2933 
    2934     return S_OK;
    2935 }
    2936 
    2937 /******************************************************************************
    2938  *      VarR8FromUI4        [OLEAUT32.219]
     2930        TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
     2931
     2932        *pdblOut = (double) uiIn;
     2933
     2934        return S_OK;
     2935}
     2936
     2937/******************************************************************************
     2938 *              VarR8FromUI4            [OLEAUT32.219]
    29392939 */
    29402940HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut)
    29412941{
    2942     TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
    2943 
    2944     *pdblOut = (double) ulIn;
    2945 
    2946     return S_OK;
    2947 }
    2948 
    2949 /******************************************************************************
    2950  *      VarR8FromStr        [OLEAUT32.84]
     2942        TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
     2943
     2944        *pdblOut = (double) ulIn;
     2945
     2946        return S_OK;
     2947}
     2948
     2949/******************************************************************************
     2950 *              VarR8FromStr            [OLEAUT32.84]
    29512951 */
    29522952HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut)
    29532953{
    2954     double dValue = 0.0;
    2955     LPSTR pNewString = NULL;
    2956 
    2957     TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pdblOut );
    2958 
    2959     /* Check if we have a valid argument
    2960     */
    2961     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    2962     RemoveCharacterFromString( pNewString, "," );
    2963     if( IsValidRealString( pNewString ) == FALSE )
    2964     {
    2965         return DISP_E_TYPEMISMATCH;
    2966     }
    2967 
    2968     /* Convert the valid string to a floating point number.
    2969     */
    2970     dValue = atof( pNewString );
    2971 
    2972     /* We don't need the string anymore so free it.
    2973     */
    2974     HeapFree( GetProcessHeap(), 0, pNewString );
    2975 
    2976     *pdblOut = dValue;
    2977 
    2978     return S_OK;
     2954        double dValue = 0.0;
     2955        LPSTR pNewString = NULL;
     2956
     2957        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pdblOut );
     2958
     2959        /* Check if we have a valid argument
     2960        */
     2961        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     2962        RemoveCharacterFromString( pNewString, "," );
     2963        if( IsValidRealString( pNewString ) == FALSE )
     2964        {
     2965                return DISP_E_TYPEMISMATCH;
     2966        }
     2967
     2968        /* Convert the valid string to a floating point number.
     2969        */
     2970        dValue = atof( pNewString );
     2971       
     2972        /* We don't need the string anymore so free it.
     2973        */
     2974        HeapFree( GetProcessHeap(), 0, pNewString );
     2975
     2976        *pdblOut = dValue;
     2977
     2978        return S_OK;
    29792979}
    29802980
    … …  
    29852985HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
    29862986   *pdblOut = (double)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    2987 
     2987   
    29882988   return S_OK;
    29892989}
    29902990
    29912991/******************************************************************************
    2992  *      VarDateFromUI1      [OLEAUT32.88]
     2992 *              VarDateFromUI1          [OLEAUT32.88]
    29932993 */
    29942994HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
    29952995{
    2996     TRACE("( %d, %p ), stub\n", bIn, pdateOut );
    2997 
    2998     *pdateOut = (DATE) bIn;
    2999 
    3000     return S_OK;
    3001 }
    3002 
    3003 /******************************************************************************
    3004  *      VarDateFromI2       [OLEAUT32.89]
     2996        TRACE("( %d, %p ), stub\n", bIn, pdateOut );
     2997
     2998        *pdateOut = (DATE) bIn;
     2999
     3000        return S_OK;
     3001}
     3002
     3003/******************************************************************************
     3004 *              VarDateFromI2           [OLEAUT32.89]
    30053005 */
    30063006HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
    30073007{
    3008     TRACE("( %d, %p ), stub\n", sIn, pdateOut );
    3009 
    3010     *pdateOut = (DATE) sIn;
    3011 
    3012     return S_OK;
    3013 }
    3014 
    3015 /******************************************************************************
    3016  *      VarDateFromI4       [OLEAUT32.90]
     3008        TRACE("( %d, %p ), stub\n", sIn, pdateOut );
     3009
     3010        *pdateOut = (DATE) sIn;
     3011
     3012        return S_OK;
     3013}
     3014
     3015/******************************************************************************
     3016 *              VarDateFromI4           [OLEAUT32.90]
    30173017 */
    30183018HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
    30193019{
    3020     TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
    3021 
    3022     if( lIn < DATE_MIN || lIn > DATE_MAX )
    3023     {
    3024         return DISP_E_OVERFLOW;
    3025     }
    3026 
    3027     *pdateOut = (DATE) lIn;
    3028 
    3029     return S_OK;
    3030 }
    3031 
    3032 /******************************************************************************
    3033  *      VarDateFromR4       [OLEAUT32.91]
     3020        TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
     3021
     3022        if( lIn < DATE_MIN || lIn > DATE_MAX )
     3023        {
     3024                return DISP_E_OVERFLOW;
     3025        }
     3026
     3027        *pdateOut = (DATE) lIn;
     3028
     3029        return S_OK;
     3030}
     3031
     3032/******************************************************************************
     3033 *              VarDateFromR4           [OLEAUT32.91]
    30343034 */
    30353035HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
    … …  
    30383038
    30393039    if( ceil(fltIn) < DATE_MIN || floor(fltIn) > DATE_MAX )
    3040     {
    3041         return DISP_E_OVERFLOW;
    3042     }
    3043 
    3044     *pdateOut = (DATE) fltIn;
    3045 
    3046     return S_OK;
    3047 }
    3048 
    3049 /******************************************************************************
    3050  *      VarDateFromR8       [OLEAUT32.92]
     3040        {
     3041                return DISP_E_OVERFLOW;
     3042        }
     3043
     3044        *pdateOut = (DATE) fltIn;
     3045
     3046        return S_OK;
     3047}
     3048
     3049/******************************************************************************
     3050 *              VarDateFromR8           [OLEAUT32.92]
    30513051 */
    30523052HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
    … …  
    30543054    TRACE("( %f, %p ), stub\n", dblIn, pdateOut );
    30553055
    3056     if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
    3057     {
    3058         return DISP_E_OVERFLOW;
    3059     }
    3060 
    3061     *pdateOut = (DATE) dblIn;
    3062 
    3063     return S_OK;
    3064 }
    3065 
    3066 /******************************************************************************
    3067  *      VarDateFromStr      [OLEAUT32.94]
     3056        if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
     3057        {
     3058                return DISP_E_OVERFLOW;
     3059        }
     3060
     3061        *pdateOut = (DATE) dblIn;
     3062
     3063        return S_OK;
     3064}
     3065
     3066/******************************************************************************
     3067 *              VarDateFromStr          [OLEAUT32.94]
    30683068 * The string representing the date is composed of two parts, a date and time.
    30693069 *
    … …  
    30743074 *
    30753075 * The formats for the date part are has follows:
    3076  * mm/[dd/][yy]yy
     3076 * mm/[dd/][yy]yy 
    30773077 * [dd/]mm/[yy]yy
    3078  * [yy]yy/mm/dd
     3078 * [yy]yy/mm/dd 
    30793079 * January dd[,] [yy]yy
    30803080 * dd January [yy]yy
    … …  
    30833083 *
    30843084 * The formats for the date and time string are has follows.
    3085  * date[whitespace][time]
     3085 * date[whitespace][time] 
    30863086 * [time][whitespace]date
    30873087 *
    … …  
    31113111
    31123112
    3113     return ret;
    3114 }
    3115 
    3116 /******************************************************************************
    3117  *      VarDateFromI1       [OLEAUT32.221]
     3113        return ret;
     3114}
     3115
     3116/******************************************************************************
     3117 *              VarDateFromI1           [OLEAUT32.221]
    31183118 */
    31193119HRESULT WINAPI VarDateFromI1(CHAR cIn, DATE* pdateOut)
    31203120{
    3121     TRACE("( %c, %p ), stub\n", cIn, pdateOut );
    3122 
    3123     *pdateOut = (DATE) cIn;
    3124 
    3125     return S_OK;
    3126 }
    3127 
    3128 /******************************************************************************
    3129  *      VarDateFromUI2      [OLEAUT32.222]
     3121        TRACE("( %c, %p ), stub\n", cIn, pdateOut );
     3122
     3123        *pdateOut = (DATE) cIn;
     3124
     3125        return S_OK;
     3126}
     3127
     3128/******************************************************************************
     3129 *              VarDateFromUI2          [OLEAUT32.222]
    31303130 */
    31313131HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
    31323132{
    3133     TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
    3134 
    3135     if( uiIn > DATE_MAX )
    3136     {
    3137         return DISP_E_OVERFLOW;
    3138     }
    3139 
    3140     *pdateOut = (DATE) uiIn;
    3141 
    3142     return S_OK;
    3143 }
    3144 
    3145 /******************************************************************************
    3146  *      VarDateFromUI4      [OLEAUT32.223]
     3133        TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
     3134
     3135        if( uiIn > DATE_MAX )
     3136        {
     3137                return DISP_E_OVERFLOW;
     3138        }
     3139
     3140        *pdateOut = (DATE) uiIn;
     3141
     3142        return S_OK;
     3143}
     3144
     3145/******************************************************************************
     3146 *              VarDateFromUI4          [OLEAUT32.223]
    31473147 */
    31483148HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
    31493149{
    3150     TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
    3151 
    3152     if( ulIn < DATE_MIN || ulIn > DATE_MAX )
    3153     {
    3154         return DISP_E_OVERFLOW;
    3155     }
    3156 
    3157     *pdateOut = (DATE) ulIn;
    3158 
    3159     return S_OK;
    3160 }
    3161 
    3162 /******************************************************************************
    3163  *      VarDateFromBool     [OLEAUT32.96]
     3150        TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
     3151
     3152        if( ulIn < DATE_MIN || ulIn > DATE_MAX )
     3153        {
     3154                return DISP_E_OVERFLOW;
     3155        }
     3156
     3157        *pdateOut = (DATE) ulIn;
     3158
     3159        return S_OK;
     3160}
     3161
     3162/******************************************************************************
     3163 *              VarDateFromBool         [OLEAUT32.96]
    31643164 */
    31653165HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
    31663166{
    3167     TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
    3168 
    3169     *pdateOut = (DATE) boolIn;
    3170 
    3171     return S_OK;
     3167        TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
     3168
     3169        *pdateOut = (DATE) boolIn;
     3170
     3171        return S_OK;
    31723172}
    31733173
    … …  
    31843184
    31853185/******************************************************************************
    3186  *      VarBstrFromUI1      [OLEAUT32.108]
     3186 *              VarBstrFromUI1          [OLEAUT32.108]
    31873187 */
    31883188HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    31893189{
    3190     TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
    3191     sprintf( pBuffer, "%d", bVal );
    3192 
    3193     *pbstrOut =  StringDupAtoBstr( pBuffer );
    3194 
    3195     return S_OK;
    3196 }
    3197 
    3198 /******************************************************************************
    3199  *      VarBstrFromI2       [OLEAUT32.109]
     3190        TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
     3191        sprintf( pBuffer, "%d", bVal );
     3192
     3193        *pbstrOut =  StringDupAtoBstr( pBuffer );
     3194       
     3195        return S_OK;
     3196}
     3197
     3198/******************************************************************************
     3199 *              VarBstrFromI2           [OLEAUT32.109]
    32003200 */
    32013201HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    32023202{
    3203     TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
    3204     sprintf( pBuffer, "%d", iVal );
    3205     *pbstrOut = StringDupAtoBstr( pBuffer );
    3206 
    3207     return S_OK;
    3208 }
    3209 
    3210 /******************************************************************************
    3211  *      VarBstrFromI4       [OLEAUT32.110]
     3203        TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
     3204        sprintf( pBuffer, "%d", iVal );
     3205        *pbstrOut = StringDupAtoBstr( pBuffer );
     3206
     3207        return S_OK;
     3208}
     3209
     3210/******************************************************************************
     3211 *              VarBstrFromI4           [OLEAUT32.110]
    32123212 */
    32133213HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    32143214{
    3215     TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
    3216 
    3217     sprintf( pBuffer, "%ld", lIn );
    3218     *pbstrOut = StringDupAtoBstr( pBuffer );
    3219 
    3220     return S_OK;
    3221 }
    3222 
    3223 /******************************************************************************
    3224  *      VarBstrFromR4       [OLEAUT32.111]
     3215        TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
     3216
     3217        sprintf( pBuffer, "%ld", lIn );
     3218        *pbstrOut = StringDupAtoBstr( pBuffer );
     3219
     3220        return S_OK;
     3221}
     3222
     3223/******************************************************************************
     3224 *              VarBstrFromR4           [OLEAUT32.111]
    32253225 */
    32263226HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    32273227{
    3228     TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
    3229 
    3230     sprintf( pBuffer, "%.7g", fltIn );
    3231     *pbstrOut = StringDupAtoBstr( pBuffer );
    3232 
    3233     return S_OK;
    3234 }
    3235 
    3236 /******************************************************************************
    3237  *      VarBstrFromR8       [OLEAUT32.112]
     3228        TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
     3229
     3230        sprintf( pBuffer, "%.7g", fltIn );
     3231        *pbstrOut = StringDupAtoBstr( pBuffer );
     3232
     3233        return S_OK;
     3234}
     3235
     3236/******************************************************************************
     3237 *              VarBstrFromR8           [OLEAUT32.112]
    32383238 */
    32393239HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    32403240{
    3241     TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
    3242 
    3243     sprintf( pBuffer, "%.15g", dblIn );
    3244     *pbstrOut = StringDupAtoBstr( pBuffer );
    3245 
    3246     return S_OK;
     3241        TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
     3242
     3243        sprintf( pBuffer, "%.15g", dblIn );
     3244        *pbstrOut = StringDupAtoBstr( pBuffer );
     3245
     3246        return S_OK;
    32473247}
    32483248
    … …  
    32513251 */
    32523252HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut) {
    3253                 /* FIXME */
    3254     return E_NOTIMPL;
    3255 }
    3256 
    3257 
    3258 /******************************************************************************
    3259  *      VarBstrFromDate     [OLEAUT32.114]
     3253                                /* FIXME */
     3254        return E_NOTIMPL;
     3255}
     3256
     3257 
     3258/******************************************************************************
     3259 *              VarBstrFromDate         [OLEAUT32.114]
    32603260 *
    32613261 * The date is implemented using an 8 byte floating-point number.
    … …  
    32743274 * The tm structure is as follows:
    32753275 * struct tm {
    3276  *        int tm_sec;      seconds after the minute - [0,59]
    3277  *        int tm_min;      minutes after the hour - [0,59]
    3278  *        int tm_hour;     hours since midnight - [0,23]
    3279  *        int tm_mday;     day of the month - [1,31]
    3280  *        int tm_mon;      months since January - [0,11]
    3281  *        int tm_year;     years
    3282  *        int tm_wday;     days since Sunday - [0,6]
    3283  *        int tm_yday;     days since January 1 - [0,365]
    3284  *        int tm_isdst;    daylight savings time flag
    3285  *        };
     3276 *                int tm_sec;      seconds after the minute - [0,59]
     3277 *                int tm_min;      minutes after the hour - [0,59]
     3278 *                int tm_hour;     hours since midnight - [0,23]
     3279 *                int tm_mday;     day of the month - [1,31]
     3280 *                int tm_mon;      months since January - [0,11]
     3281 *                int tm_year;     years
     3282 *                int tm_wday;     days since Sunday - [0,6]
     3283 *                int tm_yday;     days since January 1 - [0,365]
     3284 *                int tm_isdst;    daylight savings time flag
     3285 *                };
    32863286 */
    32873287HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    … …  
    32933293
    32943294    if( DateToTm( dateIn, dwFlags, &TM ) == FALSE )
    3295             {
     3295                        {
    32963296        return E_INVALIDARG;
    3297         }
     3297                }
    32983298
    32993299    if( dwFlags & VAR_DATEVALUEONLY )
    3300             strftime( pBuffer, BUFFER_MAX, "%x", &TM );
     3300                        strftime( pBuffer, BUFFER_MAX, "%x", &TM );
    33013301    else if( dwFlags & VAR_TIMEVALUEONLY )
    3302             strftime( pBuffer, BUFFER_MAX, "%X", &TM );
    3303         else
     3302                        strftime( pBuffer, BUFFER_MAX, "%X", &TM );
     3303                else
    33043304        strftime( pBuffer, BUFFER_MAX, "%x %X", &TM );
    33053305
    3306         *pbstrOut = StringDupAtoBstr( pBuffer );
    3307 
    3308     return S_OK;
    3309 }
    3310 
    3311 /******************************************************************************
    3312  *      VarBstrFromBool     [OLEAUT32.116]
     3306                *pbstrOut = StringDupAtoBstr( pBuffer );
     3307
     3308        return S_OK;
     3309}
     3310
     3311/******************************************************************************
     3312 *              VarBstrFromBool         [OLEAUT32.116]
    33133313 */
    33143314HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    33153315{
    3316     TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
    3317 
    3318     if( boolIn == VARIANT_FALSE )
    3319     {
    3320         sprintf( pBuffer, "False" );
    3321     }
    3322     else
    3323     {
    3324         sprintf( pBuffer, "True" );
    3325     }
    3326 
    3327     *pbstrOut = StringDupAtoBstr( pBuffer );
    3328 
    3329     return S_OK;
    3330 }
    3331 
    3332 /******************************************************************************
    3333  *      VarBstrFromI1       [OLEAUT32.229]
     3316        TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
     3317
     3318        if( boolIn == VARIANT_FALSE )
     3319        {
     3320                sprintf( pBuffer, "False" );
     3321        }
     3322        else
     3323        {
     3324                sprintf( pBuffer, "True" );
     3325        }
     3326
     3327        *pbstrOut = StringDupAtoBstr( pBuffer );
     3328
     3329        return S_OK;
     3330}
     3331
     3332/******************************************************************************
     3333 *              VarBstrFromI1           [OLEAUT32.229]
    33343334 */
    33353335HRESULT WINAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    33363336{
    3337     TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
    3338     sprintf( pBuffer, "%d", cIn );
    3339     *pbstrOut = StringDupAtoBstr( pBuffer );
    3340 
    3341     return S_OK;
    3342 }
    3343 
    3344 /******************************************************************************
    3345  *      VarBstrFromUI2      [OLEAUT32.230]
     3337        TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
     3338        sprintf( pBuffer, "%d", cIn );
     3339        *pbstrOut = StringDupAtoBstr( pBuffer );
     3340
     3341        return S_OK;
     3342}
     3343
     3344/******************************************************************************
     3345 *              VarBstrFromUI2          [OLEAUT32.230]
    33463346 */
    33473347HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    33483348{
    3349     TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
    3350     sprintf( pBuffer, "%d", uiIn );
    3351     *pbstrOut = StringDupAtoBstr( pBuffer );
    3352 
    3353     return S_OK;
    3354 }
    3355 
    3356 /******************************************************************************
    3357  *      VarBstrFromUI4      [OLEAUT32.231]
     3349        TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
     3350        sprintf( pBuffer, "%d", uiIn );
     3351        *pbstrOut = StringDupAtoBstr( pBuffer );
     3352
     3353        return S_OK;
     3354}
     3355
     3356/******************************************************************************
     3357 *              VarBstrFromUI4          [OLEAUT32.231]
    33583358 */
    33593359HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
    33603360{
    3361     TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
    3362     sprintf( pBuffer, "%ld", ulIn );
    3363     *pbstrOut = StringDupAtoBstr( pBuffer );
    3364 
    3365     return S_OK;
    3366 }
    3367 
    3368 /******************************************************************************
    3369  *      VarBoolFromUI1      [OLEAUT32.118]
     3361        TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
     3362        sprintf( pBuffer, "%ld", ulIn );
     3363        *pbstrOut = StringDupAtoBstr( pBuffer );
     3364
     3365        return S_OK;
     3366}
     3367
     3368/******************************************************************************
     3369 *              VarBoolFromUI1          [OLEAUT32.118]
    33703370 */
    33713371HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
    33723372{
    3373     TRACE("( %d, %p ), stub\n", bIn, pboolOut );
    3374 
    3375     if( bIn == 0 )
    3376     {
    3377         *pboolOut = VARIANT_FALSE;
    3378     }
    3379     else
    3380     {
    3381         *pboolOut = VARIANT_TRUE;
    3382     }
    3383 
    3384     return S_OK;
    3385 }
    3386 
    3387 /******************************************************************************
    3388  *      VarBoolFromI2       [OLEAUT32.119]
     3373        TRACE("( %d, %p ), stub\n", bIn, pboolOut );
     3374
     3375        if( bIn == 0 )
     3376        {
     3377                *pboolOut = VARIANT_FALSE;
     3378        }
     3379        else
     3380        {
     3381                *pboolOut = VARIANT_TRUE;
     3382        }
     3383
     3384        return S_OK;
     3385}
     3386
     3387/******************************************************************************
     3388 *              VarBoolFromI2           [OLEAUT32.119]
    33893389 */
    33903390HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
    33913391{
    3392     TRACE("( %d, %p ), stub\n", sIn, pboolOut );
    3393 
    3394     if( sIn == 0 )
    3395     {
    3396         *pboolOut = VARIANT_FALSE;
    3397     }
    3398     else
    3399     {
    3400         *pboolOut = VARIANT_TRUE;
    3401     }
    3402 
    3403     return S_OK;
    3404 }
    3405 
    3406 /******************************************************************************
    3407  *      VarBoolFromI4       [OLEAUT32.120]
     3392        TRACE("( %d, %p ), stub\n", sIn, pboolOut );
     3393
     3394        if( sIn == 0 )
     3395        {
     3396                *pboolOut = VARIANT_FALSE;
     3397        }
     3398        else
     3399        {
     3400                *pboolOut = VARIANT_TRUE;
     3401        }
     3402
     3403        return S_OK;
     3404}
     3405
     3406/******************************************************************************
     3407 *              VarBoolFromI4           [OLEAUT32.120]
    34083408 */
    34093409HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
    34103410{
    3411     TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
    3412 
    3413     if( lIn == 0 )
    3414     {
    3415         *pboolOut = VARIANT_FALSE;
    3416     }
    3417     else
    3418     {
    3419         *pboolOut = VARIANT_TRUE;
    3420     }
    3421 
    3422     return S_OK;
    3423 }
    3424 
    3425 /******************************************************************************
    3426  *      VarBoolFromR4       [OLEAUT32.121]
     3411        TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
     3412
     3413        if( lIn == 0 )
     3414        {
     3415                *pboolOut = VARIANT_FALSE;
     3416        }
     3417        else
     3418        {
     3419                *pboolOut = VARIANT_TRUE;
     3420        }
     3421
     3422        return S_OK;
     3423}
     3424
     3425/******************************************************************************
     3426 *              VarBoolFromR4           [OLEAUT32.121]
    34273427 */
    34283428HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
    34293429{
    3430     TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
    3431 
    3432     if( fltIn == 0.0 )
    3433     {
    3434         *pboolOut = VARIANT_FALSE;
    3435     }
    3436     else
    3437     {
    3438         *pboolOut = VARIANT_TRUE;
    3439     }
    3440 
    3441     return S_OK;
    3442 }
    3443 
    3444 /******************************************************************************
    3445  *      VarBoolFromR8       [OLEAUT32.122]
     3430        TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
     3431
     3432        if( fltIn == 0.0 )
     3433        {
     3434                *pboolOut = VARIANT_FALSE;
     3435        }
     3436        else
     3437        {
     3438                *pboolOut = VARIANT_TRUE;
     3439        }
     3440
     3441        return S_OK;
     3442}
     3443
     3444/******************************************************************************
     3445 *              VarBoolFromR8           [OLEAUT32.122]
    34463446 */
    34473447HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
    34483448{
    3449     TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
    3450 
    3451     if( dblIn == 0.0 )
    3452     {
    3453         *pboolOut = VARIANT_FALSE;
    3454     }
    3455     else
    3456     {
    3457         *pboolOut = VARIANT_TRUE;
    3458     }
    3459 
    3460     return S_OK;
    3461 }
    3462 
    3463 /******************************************************************************
    3464  *      VarBoolFromDate     [OLEAUT32.123]
     3449        TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
     3450
     3451        if( dblIn == 0.0 )
     3452        {
     3453                *pboolOut = VARIANT_FALSE;
     3454        }
     3455        else
     3456        {
     3457                *pboolOut = VARIANT_TRUE;
     3458        }
     3459
     3460        return S_OK;
     3461}
     3462
     3463/******************************************************************************
     3464 *              VarBoolFromDate         [OLEAUT32.123]
    34653465 */
    34663466HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
    34673467{
    3468     TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
    3469 
    3470     if( dateIn == 0.0 )
    3471     {
    3472         *pboolOut = VARIANT_FALSE;
    3473     }
    3474     else
    3475     {
    3476         *pboolOut = VARIANT_TRUE;
    3477     }
    3478 
    3479     return S_OK;
    3480 }
    3481 
    3482 /******************************************************************************
    3483  *      VarBoolFromStr      [OLEAUT32.125]
     3468        TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
     3469
     3470        if( dateIn == 0.0 )
     3471        {
     3472                *pboolOut = VARIANT_FALSE;
     3473        }
     3474        else
     3475        {
     3476                *pboolOut = VARIANT_TRUE;
     3477        }
     3478
     3479        return S_OK;
     3480}
     3481
     3482/******************************************************************************
     3483 *              VarBoolFromStr          [OLEAUT32.125]
    34843484 */
    34853485HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
    34863486{
    3487     HRESULT ret = S_OK;
    3488     char* pNewString = NULL;
    3489 
    3490     TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
     3487        HRESULT ret = S_OK;
     3488        char* pNewString = NULL;
     3489
     3490        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
    34913491
    34923492    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    34933493
    3494     if( pNewString == NULL || strlen( pNewString ) == 0 )
    3495     {
    3496         ret = DISP_E_TYPEMISMATCH;
    3497     }
    3498 
    3499     if( ret == S_OK )
    3500     {
    3501         if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
    3502         {
    3503             *pboolOut = VARIANT_TRUE;
    3504         }
    3505         else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
    3506         {
    3507             *pboolOut = VARIANT_FALSE;
    3508         }
    3509         else
    3510         {
    3511             /* Try converting the string to a floating point number.
    3512             */
    3513             double dValue = 0.0;
    3514             HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
    3515             if( res != S_OK )
    3516             {
    3517                 ret = DISP_E_TYPEMISMATCH;
    3518             }
    3519             else if( dValue == 0.0 )
    3520             {
    3521                 *pboolOut = VARIANT_FALSE;
    3522             }
    3523             else
    3524             {
    3525                 *pboolOut = VARIANT_TRUE;
    3526             }
    3527         }
    3528     }
    3529 
    3530     HeapFree( GetProcessHeap(), 0, pNewString );
    3531 
    3532     return ret;
    3533 }
    3534 
    3535 /******************************************************************************
    3536  *      VarBoolFromI1       [OLEAUT32.233]
     3494        if( pNewString == NULL || strlen( pNewString ) == 0 )
     3495        {
     3496                ret = DISP_E_TYPEMISMATCH;
     3497        }
     3498
     3499        if( ret == S_OK )
     3500        {
     3501                if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
     3502                {
     3503                        *pboolOut = VARIANT_TRUE;
     3504                }
     3505                else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
     3506                {
     3507                        *pboolOut = VARIANT_FALSE;
     3508                }
     3509                else
     3510                {
     3511                        /* Try converting the string to a floating point number.
     3512                        */
     3513                        double dValue = 0.0;
     3514                        HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
     3515                        if( res != S_OK )
     3516                        {
     3517                                ret = DISP_E_TYPEMISMATCH;
     3518                        }
     3519                        else if( dValue == 0.0 )
     3520                        {
     3521                                *pboolOut = VARIANT_FALSE;
     3522                        }
     3523                        else
     3524                        {
     3525                                *pboolOut = VARIANT_TRUE;
     3526                        }
     3527                }
     3528        }
     3529
     3530        HeapFree( GetProcessHeap(), 0, pNewString );
     3531       
     3532        return ret;
     3533}
     3534
     3535/******************************************************************************
     3536 *              VarBoolFromI1           [OLEAUT32.233]
    35373537 */
    35383538HRESULT WINAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL* pboolOut)
    35393539{
    3540     TRACE("( %c, %p ), stub\n", cIn, pboolOut );
    3541 
    3542     if( cIn == 0 )
    3543     {
    3544         *pboolOut = VARIANT_FALSE;
    3545     }
    3546     else
    3547     {
    3548         *pboolOut = VARIANT_TRUE;
    3549     }
    3550 
    3551     return S_OK;
    3552 }
    3553 
    3554 /******************************************************************************
    3555  *      VarBoolFromUI2      [OLEAUT32.234]
     3540        TRACE("( %c, %p ), stub\n", cIn, pboolOut );
     3541
     3542        if( cIn == 0 )
     3543        {
     3544                *pboolOut = VARIANT_FALSE;
     3545        }
     3546        else
     3547        {
     3548                *pboolOut = VARIANT_TRUE;
     3549        }
     3550
     3551        return S_OK;
     3552}
     3553
     3554/******************************************************************************
     3555 *              VarBoolFromUI2          [OLEAUT32.234]
    35563556 */
    35573557HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
    35583558{
    3559     TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
    3560 
    3561     if( uiIn == 0 )
    3562     {
    3563         *pboolOut = VARIANT_FALSE;
    3564     }
    3565     else
    3566     {
    3567         *pboolOut = VARIANT_TRUE;
    3568     }
    3569 
    3570     return S_OK;
    3571 }
    3572 
    3573 /******************************************************************************
    3574  *      VarBoolFromUI4      [OLEAUT32.235]
     3559        TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
     3560
     3561        if( uiIn == 0 )
     3562        {
     3563                *pboolOut = VARIANT_FALSE;
     3564        }
     3565        else
     3566        {
     3567                *pboolOut = VARIANT_TRUE;
     3568        }
     3569
     3570        return S_OK;
     3571}
     3572
     3573/******************************************************************************
     3574 *              VarBoolFromUI4          [OLEAUT32.235]
    35753575 */
    35763576HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
    35773577{
    3578     TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
    3579 
    3580     if( ulIn == 0 )
    3581     {
    3582         *pboolOut = VARIANT_FALSE;
    3583     }
    3584     else
    3585     {
    3586         *pboolOut = VARIANT_TRUE;
    3587     }
    3588 
    3589     return S_OK;
     3578        TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
     3579
     3580        if( ulIn == 0 )
     3581        {
     3582                *pboolOut = VARIANT_FALSE;
     3583        }
     3584        else
     3585        {
     3586                *pboolOut = VARIANT_TRUE;
     3587        }
     3588
     3589        return S_OK;
    35903590}
    35913591
    … …  
    35973597      if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
    35983598      else *pboolOut = 0;
    3599 
     3599     
    36003600      return S_OK;
    36013601}
    36023602
    36033603/******************************************************************************
    3604  *      VarI1FromUI1        [OLEAUT32.244]
     3604 *              VarI1FromUI1            [OLEAUT32.244]
    36053605 */
    36063606HRESULT WINAPI VarI1FromUI1(BYTE bIn, CHAR* pcOut)
    36073607{
    3608     TRACE("( %d, %p ), stub\n", bIn, pcOut );
    3609 
    3610     /* Check range of value.
    3611     */
    3612     if( bIn > CHAR_MAX )
    3613     {
    3614         return DISP_E_OVERFLOW;
    3615     }
    3616 
    3617     *pcOut = (CHAR) bIn;
    3618 
    3619     return S_OK;
    3620 }
    3621 
    3622 /******************************************************************************
    3623  *      VarI1FromI2     [OLEAUT32.245]
     3608        TRACE("( %d, %p ), stub\n", bIn, pcOut );
     3609
     3610        /* Check range of value.
     3611        */
     3612        if( bIn > CHAR_MAX )
     3613        {
     3614                return DISP_E_OVERFLOW;
     3615        }
     3616
     3617        *pcOut = (CHAR) bIn;
     3618
     3619        return S_OK;
     3620}
     3621
     3622/******************************************************************************
     3623 *              VarI1FromI2             [OLEAUT32.245]
    36243624 */
    36253625HRESULT WINAPI VarI1FromI2(short uiIn, CHAR* pcOut)
    36263626{
    3627     TRACE("( %d, %p ), stub\n", uiIn, pcOut );
    3628 
    3629     if( uiIn > CHAR_MAX )
    3630     {
    3631         return DISP_E_OVERFLOW;
    3632     }
    3633 
    3634     *pcOut = (CHAR) uiIn;
    3635 
    3636     return S_OK;
    3637 }
    3638 
    3639 /******************************************************************************
    3640  *      VarI1FromI4     [OLEAUT32.246]
     3627        TRACE("( %d, %p ), stub\n", uiIn, pcOut );
     3628
     3629        if( uiIn > CHAR_MAX )
     3630        {
     3631                return DISP_E_OVERFLOW;
     3632        }
     3633
     3634        *pcOut = (CHAR) uiIn;
     3635
     3636        return S_OK;
     3637}
     3638
     3639/******************************************************************************
     3640 *              VarI1FromI4             [OLEAUT32.246]
    36413641 */
    36423642HRESULT WINAPI VarI1FromI4(LONG lIn, CHAR* pcOut)
    36433643{
    3644     TRACE("( %ld, %p ), stub\n", lIn, pcOut );
    3645 
    3646     if( lIn < CHAR_MIN || lIn > CHAR_MAX )
    3647     {
    3648         return DISP_E_OVERFLOW;
    3649     }
    3650 
    3651     *pcOut = (CHAR) lIn;
    3652 
    3653     return S_OK;
    3654 }
    3655 
    3656 /******************************************************************************
    3657  *      VarI1FromR4     [OLEAUT32.247]
     3644        TRACE("( %ld, %p ), stub\n", lIn, pcOut );
     3645
     3646        if( lIn < CHAR_MIN || lIn > CHAR_MAX )
     3647        {
     3648                return DISP_E_OVERFLOW;
     3649        }
     3650
     3651        *pcOut = (CHAR) lIn;
     3652
     3653        return S_OK;
     3654}
     3655
     3656/******************************************************************************
     3657 *              VarI1FromR4             [OLEAUT32.247]
    36583658 */
    36593659HRESULT WINAPI VarI1FromR4(FLOAT fltIn, CHAR* pcOut)
    36603660{
    3661     TRACE("( %f, %p ), stub\n", fltIn, pcOut );
     3661        TRACE("( %f, %p ), stub\n", fltIn, pcOut );
    36623662
    36633663    fltIn = round( fltIn );
    3664     if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
    3665     {
    3666         return DISP_E_OVERFLOW;
    3667     }
    3668 
    3669     *pcOut = (CHAR) fltIn;
    3670 
    3671     return S_OK;
    3672 }
    3673 
    3674 /******************************************************************************
    3675  *      VarI1FromR8     [OLEAUT32.248]
     3664        if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
     3665        {
     3666                return DISP_E_OVERFLOW;
     3667        }
     3668
     3669        *pcOut = (CHAR) fltIn;
     3670
     3671        return S_OK;
     3672}
     3673
     3674/******************************************************************************
     3675 *              VarI1FromR8             [OLEAUT32.248]
    36763676 */
    36773677HRESULT WINAPI VarI1FromR8(double dblIn, CHAR* pcOut)
    36783678{
    3679     TRACE("( %f, %p ), stub\n", dblIn, pcOut );
     3679        TRACE("( %f, %p ), stub\n", dblIn, pcOut );
    36803680
    36813681    dblIn = round( dblIn );
    36823682    if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
    3683     {
    3684         return DISP_E_OVERFLOW;
    3685     }
    3686 
    3687     *pcOut = (CHAR) dblIn;
    3688 
    3689     return S_OK;
    3690 }
    3691 
    3692 /******************************************************************************
    3693  *      VarI1FromDate       [OLEAUT32.249]
     3683        {
     3684                return DISP_E_OVERFLOW;
     3685        }
     3686
     3687        *pcOut = (CHAR) dblIn;
     3688
     3689        return S_OK;
     3690}
     3691
     3692/******************************************************************************
     3693 *              VarI1FromDate           [OLEAUT32.249]
    36943694 */
    36953695HRESULT WINAPI VarI1FromDate(DATE dateIn, CHAR* pcOut)
    36963696{
    3697     TRACE("( %f, %p ), stub\n", dateIn, pcOut );
     3697        TRACE("( %f, %p ), stub\n", dateIn, pcOut );
    36983698
    36993699    dateIn = round( dateIn );
    3700     if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
    3701     {
    3702         return DISP_E_OVERFLOW;
    3703     }
    3704 
    3705     *pcOut = (CHAR) dateIn;
    3706 
    3707     return S_OK;
    3708 }
    3709 
    3710 /******************************************************************************
    3711  *      VarI1FromStr        [OLEAUT32.251]
     3700        if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
     3701        {
     3702                return DISP_E_OVERFLOW;
     3703        }
     3704
     3705        *pcOut = (CHAR) dateIn;
     3706
     3707        return S_OK;
     3708}
     3709
     3710/******************************************************************************
     3711 *              VarI1FromStr            [OLEAUT32.251]
    37123712 */
    37133713HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CHAR* pcOut)
    37143714{
    3715     double dValue = 0.0;
    3716     LPSTR pNewString = NULL;
    3717 
    3718     TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
    3719 
    3720     /* Check if we have a valid argument
    3721     */
    3722     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    3723     RemoveCharacterFromString( pNewString, "," );
    3724     if( IsValidRealString( pNewString ) == FALSE )
    3725     {
    3726         return DISP_E_TYPEMISMATCH;
    3727     }
    3728 
    3729     /* Convert the valid string to a floating point number.
    3730     */
    3731     dValue = atof( pNewString );
    3732 
    3733     /* We don't need the string anymore so free it.
    3734     */
    3735     HeapFree( GetProcessHeap(), 0, pNewString );
    3736 
    3737     /* Check range of value.
     3715        double dValue = 0.0;
     3716        LPSTR pNewString = NULL;
     3717
     3718        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
     3719
     3720        /* Check if we have a valid argument
     3721        */
     3722        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     3723        RemoveCharacterFromString( pNewString, "," );
     3724        if( IsValidRealString( pNewString ) == FALSE )
     3725        {
     3726                return DISP_E_TYPEMISMATCH;
     3727        }
     3728
     3729        /* Convert the valid string to a floating point number.
     3730        */
     3731        dValue = atof( pNewString );
     3732 
     3733        /* We don't need the string anymore so free it.
     3734        */
     3735        HeapFree( GetProcessHeap(), 0, pNewString );
     3736
     3737        /* Check range of value.
    37383738     */
    37393739    dValue = round( dValue );
    3740     if( dValue < CHAR_MIN || dValue > CHAR_MAX )
    3741     {
    3742         return DISP_E_OVERFLOW;
    3743     }
    3744 
    3745     *pcOut = (CHAR) dValue;
    3746 
    3747     return S_OK;
    3748 }
    3749 
    3750 /******************************************************************************
    3751  *      VarI1FromBool       [OLEAUT32.253]
     3740        if( dValue < CHAR_MIN || dValue > CHAR_MAX )
     3741        {
     3742                return DISP_E_OVERFLOW;
     3743        }
     3744
     3745        *pcOut = (CHAR) dValue;
     3746
     3747        return S_OK;
     3748}
     3749
     3750/******************************************************************************
     3751 *              VarI1FromBool           [OLEAUT32.253]
    37523752 */
    37533753HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR* pcOut)
    37543754{
    3755     TRACE("( %d, %p ), stub\n", boolIn, pcOut );
    3756 
    3757     *pcOut = (CHAR) boolIn;
    3758 
    3759     return S_OK;
    3760 }
    3761 
    3762 /******************************************************************************
    3763  *      VarI1FromUI2        [OLEAUT32.254]
     3755        TRACE("( %d, %p ), stub\n", boolIn, pcOut );
     3756
     3757        *pcOut = (CHAR) boolIn;
     3758
     3759        return S_OK;
     3760}
     3761
     3762/******************************************************************************
     3763 *              VarI1FromUI2            [OLEAUT32.254]
    37643764 */
    37653765HRESULT WINAPI VarI1FromUI2(USHORT uiIn, CHAR* pcOut)
    37663766{
    3767     TRACE("( %d, %p ), stub\n", uiIn, pcOut );
    3768 
    3769     if( uiIn > CHAR_MAX )
    3770     {
    3771         return DISP_E_OVERFLOW;
    3772     }
    3773 
    3774     *pcOut = (CHAR) uiIn;
    3775 
    3776     return S_OK;
    3777 }
    3778 
    3779 /******************************************************************************
    3780  *      VarI1FromUI4        [OLEAUT32.255]
     3767        TRACE("( %d, %p ), stub\n", uiIn, pcOut );
     3768
     3769        if( uiIn > CHAR_MAX )
     3770        {
     3771                return DISP_E_OVERFLOW;
     3772        }
     3773
     3774        *pcOut = (CHAR) uiIn;
     3775
     3776        return S_OK;
     3777}
     3778
     3779/******************************************************************************
     3780 *              VarI1FromUI4            [OLEAUT32.255]
    37813781 */
    37823782HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut)
    37833783{
    3784     TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
    3785 
    3786     if( ulIn > CHAR_MAX )
    3787     {
    3788         return DISP_E_OVERFLOW;
    3789     }
    3790 
    3791     *pcOut = (CHAR) ulIn;
    3792 
    3793     return S_OK;
     3784        TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
     3785
     3786        if( ulIn > CHAR_MAX )
     3787        {
     3788                return DISP_E_OVERFLOW;
     3789        }
     3790
     3791        *pcOut = (CHAR) ulIn;
     3792
     3793        return S_OK;
    37943794}
    37953795
    … …  
    38003800HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) {
    38013801   double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    3802 
     3802   
    38033803   if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
    3804 
     3804   
    38053805   *pcOut = (CHAR)t;
    38063806   return S_OK;
    … …  
    38083808
    38093809/******************************************************************************
    3810  *      VarUI2FromUI1       [OLEAUT32.257]
     3810 *              VarUI2FromUI1           [OLEAUT32.257]
    38113811 */
    38123812HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
    38133813{
    3814     TRACE("( %d, %p ), stub\n", bIn, puiOut );
    3815 
    3816     *puiOut = (USHORT) bIn;
    3817 
    3818     return S_OK;
    3819 }
    3820 
    3821 /******************************************************************************
    3822  *      VarUI2FromI2        [OLEAUT32.258]
     3814        TRACE("( %d, %p ), stub\n", bIn, puiOut );
     3815
     3816        *puiOut = (USHORT) bIn;
     3817
     3818        return S_OK;
     3819}
     3820
     3821/******************************************************************************
     3822 *              VarUI2FromI2            [OLEAUT32.258]
    38233823 */
    38243824HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
    38253825{
    3826     TRACE("( %d, %p ), stub\n", uiIn, puiOut );
    3827 
    3828     if( uiIn < UI2_MIN )
    3829     {
    3830         return DISP_E_OVERFLOW;
    3831     }
    3832 
    3833     *puiOut = (USHORT) uiIn;
    3834 
    3835     return S_OK;
    3836 }
    3837 
    3838 /******************************************************************************
    3839  *      VarUI2FromI4        [OLEAUT32.259]
     3826        TRACE("( %d, %p ), stub\n", uiIn, puiOut );
     3827
     3828        if( uiIn < UI2_MIN )
     3829        {
     3830                return DISP_E_OVERFLOW;
     3831        }
     3832
     3833        *puiOut = (USHORT) uiIn;
     3834
     3835        return S_OK;
     3836}
     3837
     3838/******************************************************************************
     3839 *              VarUI2FromI4            [OLEAUT32.259]
    38403840 */
    38413841HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
    38423842{
    3843     TRACE("( %ld, %p ), stub\n", lIn, puiOut );
    3844 
    3845     if( lIn < UI2_MIN || lIn > UI2_MAX )
    3846     {
    3847         return DISP_E_OVERFLOW;
    3848     }
    3849 
    3850     *puiOut = (USHORT) lIn;
    3851 
    3852     return S_OK;
    3853 }
    3854 
    3855 /******************************************************************************
    3856  *      VarUI2FromR4        [OLEAUT32.260]
     3843        TRACE("( %ld, %p ), stub\n", lIn, puiOut );
     3844
     3845        if( lIn < UI2_MIN || lIn > UI2_MAX )
     3846        {
     3847                return DISP_E_OVERFLOW;
     3848        }
     3849
     3850        *puiOut = (USHORT) lIn;
     3851
     3852        return S_OK;
     3853}
     3854
     3855/******************************************************************************
     3856 *              VarUI2FromR4            [OLEAUT32.260]
    38573857 */
    38583858HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
    38593859{
    3860     TRACE("( %f, %p ), stub\n", fltIn, puiOut );
     3860        TRACE("( %f, %p ), stub\n", fltIn, puiOut );
    38613861
    38623862    fltIn = round( fltIn );
    3863     if( fltIn < UI2_MIN || fltIn > UI2_MAX )
    3864     {
    3865         return DISP_E_OVERFLOW;
    3866     }
    3867 
    3868     *puiOut = (USHORT) fltIn;
    3869 
    3870     return S_OK;
    3871 }
    3872 
    3873 /******************************************************************************
    3874  *      VarUI2FromR8        [OLEAUT32.261]
     3863        if( fltIn < UI2_MIN || fltIn > UI2_MAX )
     3864        {
     3865                return DISP_E_OVERFLOW;
     3866        }
     3867
     3868        *puiOut = (USHORT) fltIn;
     3869
     3870        return S_OK;
     3871}
     3872
     3873/******************************************************************************
     3874 *              VarUI2FromR8            [OLEAUT32.261]
    38753875 */
    38763876HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
    38773877{
    3878     TRACE("( %f, %p ), stub\n", dblIn, puiOut );
     3878        TRACE("( %f, %p ), stub\n", dblIn, puiOut );
    38793879
    38803880    dblIn = round( dblIn );
    38813881    if( dblIn < UI2_MIN || dblIn > UI2_MAX )
    3882     {
    3883         return DISP_E_OVERFLOW;
    3884     }
    3885 
    3886     *puiOut = (USHORT) dblIn;
    3887 
    3888     return S_OK;
    3889 }
    3890 
    3891 /******************************************************************************
    3892  *      VarUI2FromDate      [OLEAUT32.262]
     3882        {
     3883                return DISP_E_OVERFLOW;
     3884        }
     3885
     3886        *puiOut = (USHORT) dblIn;
     3887
     3888        return S_OK;
     3889}
     3890
     3891/******************************************************************************
     3892 *              VarUI2FromDate          [OLEAUT32.262]
    38933893 */
    38943894HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
    38953895{
    3896     TRACE("( %f, %p ), stub\n", dateIn, puiOut );
     3896        TRACE("( %f, %p ), stub\n", dateIn, puiOut );
    38973897
    38983898    dateIn = round( dateIn );
    3899     if( dateIn < UI2_MIN || dateIn > UI2_MAX )
    3900     {
    3901         return DISP_E_OVERFLOW;
    3902     }
    3903 
    3904     *puiOut = (USHORT) dateIn;
    3905 
    3906     return S_OK;
    3907 }
    3908 
    3909 /******************************************************************************
    3910  *      VarUI2FromStr       [OLEAUT32.264]
     3899        if( dateIn < UI2_MIN || dateIn > UI2_MAX )
     3900        {
     3901                return DISP_E_OVERFLOW;
     3902        }
     3903
     3904        *puiOut = (USHORT) dateIn;
     3905
     3906        return S_OK;
     3907}
     3908
     3909/******************************************************************************
     3910 *              VarUI2FromStr           [OLEAUT32.264]
    39113911 */
    39123912HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
    39133913{
    3914     double dValue = 0.0;
    3915     LPSTR pNewString = NULL;
    3916 
    3917     TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
    3918 
    3919     /* Check if we have a valid argument
    3920     */
    3921     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    3922     RemoveCharacterFromString( pNewString, "," );
    3923     if( IsValidRealString( pNewString ) == FALSE )
    3924     {
    3925         return DISP_E_TYPEMISMATCH;
    3926     }
    3927 
    3928     /* Convert the valid string to a floating point number.
    3929     */
    3930     dValue = atof( pNewString );
    3931 
    3932     /* We don't need the string anymore so free it.
    3933     */
    3934     HeapFree( GetProcessHeap(), 0, pNewString );
    3935 
    3936     /* Check range of value.
     3914        double dValue = 0.0;
     3915        LPSTR pNewString = NULL;
     3916
     3917        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
     3918
     3919        /* Check if we have a valid argument
     3920        */
     3921        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     3922        RemoveCharacterFromString( pNewString, "," );
     3923        if( IsValidRealString( pNewString ) == FALSE )
     3924        {
     3925                return DISP_E_TYPEMISMATCH;
     3926        }
     3927
     3928        /* Convert the valid string to a floating point number.
     3929        */
     3930        dValue = atof( pNewString );
     3931 
     3932        /* We don't need the string anymore so free it.
     3933        */
     3934        HeapFree( GetProcessHeap(), 0, pNewString );
     3935
     3936        /* Check range of value.
    39373937     */
    39383938    dValue = round( dValue );
    3939     if( dValue < UI2_MIN || dValue > UI2_MAX )
    3940     {
    3941         return DISP_E_OVERFLOW;
    3942     }
    3943 
    3944     *puiOut = (USHORT) dValue;
    3945 
    3946     return S_OK;
    3947 }
    3948 
    3949 /******************************************************************************
    3950  *      VarUI2FromBool      [OLEAUT32.266]
     3939        if( dValue < UI2_MIN || dValue > UI2_MAX )
     3940        {
     3941                return DISP_E_OVERFLOW;
     3942        }
     3943
     3944        *puiOut = (USHORT) dValue;
     3945
     3946        return S_OK;
     3947}
     3948
     3949/******************************************************************************
     3950 *              VarUI2FromBool          [OLEAUT32.266]
    39513951 */
    39523952HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
    39533953{
    3954     TRACE("( %d, %p ), stub\n", boolIn, puiOut );
    3955 
    3956     *puiOut = (USHORT) boolIn;
    3957 
    3958     return S_OK;
    3959 }
    3960 
    3961 /******************************************************************************
    3962  *      VarUI2FromI1        [OLEAUT32.267]
     3954        TRACE("( %d, %p ), stub\n", boolIn, puiOut );
     3955
     3956        *puiOut = (USHORT) boolIn;
     3957
     3958        return S_OK;
     3959}
     3960
     3961/******************************************************************************
     3962 *              VarUI2FromI1            [OLEAUT32.267]
    39633963 */
    39643964HRESULT WINAPI VarUI2FromI1(CHAR cIn, USHORT* puiOut)
    39653965{
    3966     TRACE("( %c, %p ), stub\n", cIn, puiOut );
    3967 
    3968     *puiOut = (USHORT) cIn;
    3969 
    3970     return S_OK;
    3971 }
    3972 
    3973 /******************************************************************************
    3974  *      VarUI2FromUI4       [OLEAUT32.268]
     3966        TRACE("( %c, %p ), stub\n", cIn, puiOut );
     3967
     3968        *puiOut = (USHORT) cIn;
     3969
     3970        return S_OK;
     3971}
     3972
     3973/******************************************************************************
     3974 *              VarUI2FromUI4           [OLEAUT32.268]
    39753975 */
    39763976HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
    39773977{
    3978     TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
    3979 
    3980     if( ulIn < UI2_MIN || ulIn > UI2_MAX )
    3981     {
    3982         return DISP_E_OVERFLOW;
    3983     }
    3984 
    3985     *puiOut = (USHORT) ulIn;
    3986 
    3987     return S_OK;
    3988 }
    3989 
    3990 /******************************************************************************
    3991  *      VarUI4FromStr       [OLEAUT32.277]
     3978        TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
     3979
     3980        if( ulIn < UI2_MIN || ulIn > UI2_MAX )
     3981        {
     3982                return DISP_E_OVERFLOW;
     3983        }
     3984
     3985        *puiOut = (USHORT) ulIn;
     3986
     3987        return S_OK;
     3988}
     3989
     3990/******************************************************************************
     3991 *              VarUI4FromStr           [OLEAUT32.277]
    39923992 */
    39933993HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
    39943994{
    3995     double dValue = 0.0;
    3996     LPSTR pNewString = NULL;
    3997 
    3998     TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
    3999 
    4000     /* Check if we have a valid argument
    4001     */
    4002     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
    4003     RemoveCharacterFromString( pNewString, "," );
    4004     if( IsValidRealString( pNewString ) == FALSE )
    4005     {
    4006         return DISP_E_TYPEMISMATCH;
    4007     }
    4008 
    4009     /* Convert the valid string to a floating point number.
    4010     */
    4011     dValue = atof( pNewString );
    4012 
    4013     /* We don't need the string anymore so free it.
    4014     */
    4015     HeapFree( GetProcessHeap(), 0, pNewString );
    4016 
    4017     /* Check range of value.
     3995        double dValue = 0.0;
     3996        LPSTR pNewString = NULL;
     3997
     3998        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
     3999
     4000        /* Check if we have a valid argument
     4001        */
     4002        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
     4003        RemoveCharacterFromString( pNewString, "," );
     4004        if( IsValidRealString( pNewString ) == FALSE )
     4005        {
     4006                return DISP_E_TYPEMISMATCH;
     4007        }
     4008
     4009        /* Convert the valid string to a floating point number.
     4010        */
     4011        dValue = atof( pNewString );
     4012 
     4013        /* We don't need the string anymore so free it.
     4014        */
     4015        HeapFree( GetProcessHeap(), 0, pNewString );
     4016
     4017        /* Check range of value.
    40184018     */
    40194019    dValue = round( dValue );
    4020     if( dValue < UI4_MIN || dValue > UI4_MAX )
    4021     {
    4022         return DISP_E_OVERFLOW;
    4023     }
    4024 
    4025     *pulOut = (ULONG) dValue;
    4026 
    4027     return S_OK;
     4020        if( dValue < UI4_MIN || dValue > UI4_MAX )
     4021        {
     4022                return DISP_E_OVERFLOW;
     4023        }
     4024
     4025        *pulOut = (ULONG) dValue;
     4026
     4027        return S_OK;
    40284028}
    40294029
    … …  
    40344034HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
    40354035   double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    4036 
     4036   
    40374037   if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
    4038 
     4038     
    40394039   *pusOut = (USHORT)t;
    4040 
     4040   
    40414041   return S_OK;
    40424042}
    40434043
    40444044/******************************************************************************
    4045  *      VarUI4FromUI1       [OLEAUT32.270]
     4045 *              VarUI4FromUI1           [OLEAUT32.270]
    40464046 */
    40474047HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
    40484048{
    4049     TRACE("( %d, %p ), stub\n", bIn, pulOut );
    4050 
    4051     *pulOut = (USHORT) bIn;
    4052 
    4053     return S_OK;
    4054 }
    4055 
    4056 /******************************************************************************
    4057  *      VarUI4FromI2        [OLEAUT32.271]
     4049        TRACE("( %d, %p ), stub\n", bIn, pulOut );
     4050
     4051        *pulOut = (USHORT) bIn;
     4052
     4053        return S_OK;
     4054}
     4055
     4056/******************************************************************************
     4057 *              VarUI4FromI2            [OLEAUT32.271]
    40584058 */
    40594059HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
    40604060{
    4061     TRACE("( %d, %p ), stub\n", uiIn, pulOut );
    4062 
    4063     if( uiIn < UI4_MIN )
    4064     {
    4065         return DISP_E_OVERFLOW;
    4066     }
    4067 
    4068     *pulOut = (ULONG) uiIn;
    4069 
    4070     return S_OK;
    4071 }
    4072 
    4073 /******************************************************************************
    4074  *      VarUI4FromI4        [OLEAUT32.272]
     4061        TRACE("( %d, %p ), stub\n", uiIn, pulOut );
     4062
     4063        if( uiIn < UI4_MIN )
     4064        {
     4065                return DISP_E_OVERFLOW;
     4066        }
     4067
     4068        *pulOut = (ULONG) uiIn;
     4069
     4070        return S_OK;
     4071}
     4072
     4073/******************************************************************************
     4074 *              VarUI4FromI4            [OLEAUT32.272]
    40754075 */
    40764076HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
    40774077{
    4078     TRACE("( %ld, %p ), stub\n", lIn, pulOut );
    4079 
    4080     if( lIn < UI4_MIN )
    4081     {
    4082         return DISP_E_OVERFLOW;
    4083     }
    4084 
    4085     *pulOut = (ULONG) lIn;
    4086 
    4087     return S_OK;
    4088 }
    4089 
    4090 /******************************************************************************
    4091  *      VarUI4FromR4        [OLEAUT32.273]
     4078        TRACE("( %ld, %p ), stub\n", lIn, pulOut );
     4079
     4080        if( lIn < UI4_MIN )
     4081        {
     4082                return DISP_E_OVERFLOW;
     4083        }
     4084
     4085        *pulOut = (ULONG) lIn;
     4086
     4087        return S_OK;
     4088}
     4089
     4090/******************************************************************************
     4091 *              VarUI4FromR4            [OLEAUT32.273]
    40924092 */
    40934093HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
    … …  
    40954095    fltIn = round( fltIn );
    40964096    if( fltIn < UI4_MIN || fltIn > UI4_MAX )
    4097     {
    4098         return DISP_E_OVERFLOW;
     4097        {
     4098                return DISP_E_OVERFLOW;
     4099        }
     4100
     4101        *pulOut = (ULONG) fltIn;
     4102
     4103        return S_OK;
     4104}
     4105
     4106/******************************************************************************
     4107 *              VarUI4FromR8            [OLEAUT32.274]
     4108 */
     4109HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
     4110{
     4111        TRACE("( %f, %p ), stub\n", dblIn, pulOut );
     4112
     4113    dblIn = round( dblIn );
     4114        if( dblIn < UI4_MIN || dblIn > UI4_MAX )
     4115        {
     4116                return DISP_E_OVERFLOW;
    40994117    }
    41004118
    4101     *pulOut = (ULONG) fltIn;
    4102 
    4103     return S_OK;
    4104 }
    4105 
    4106 /******************************************************************************
    4107  *      VarUI4FromR8        [OLEAUT32.274]
    4108  */
    4109 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
    4110 {
    4111     TRACE("( %f, %p ), stub\n", dblIn, pulOut );
    4112 
    4113     dblIn = round( dblIn );
    4114     if( dblIn < UI4_MIN || dblIn > UI4_MAX )
    4115     {
    4116         return DISP_E_OVERFLOW;
    4117     }
    4118 
    4119     *pulOut = (ULONG) dblIn;
    4120 
    4121     return S_OK;
    4122 }
    4123 
    4124 /******************************************************************************
    4125  *      VarUI4FromDate      [OLEAUT32.275]
     4119        *pulOut = (ULONG) dblIn;
     4120
     4121        return S_OK;
     4122}
     4123
     4124/******************************************************************************
     4125 *              VarUI4FromDate          [OLEAUT32.275]
    41264126 */
    41274127HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
    41284128{
    4129     TRACE("( %f, %p ), stub\n", dateIn, pulOut );
     4129        TRACE("( %f, %p ), stub\n", dateIn, pulOut );
    41304130
    41314131    dateIn = round( dateIn );
    41324132    if( dateIn < UI4_MIN || dateIn > UI4_MAX )
    4133     {
    4134         return DISP_E_OVERFLOW;
    4135     }
    4136 
    4137     *pulOut = (ULONG) dateIn;
    4138 
    4139     return S_OK;
    4140 }
    4141 
    4142 /******************************************************************************
    4143  *      VarUI4FromBool      [OLEAUT32.279]
     4133        {
     4134                return DISP_E_OVERFLOW;
     4135        }
     4136
     4137        *pulOut = (ULONG) dateIn;
     4138
     4139        return S_OK;
     4140}
     4141
     4142/******************************************************************************
     4143 *              VarUI4FromBool          [OLEAUT32.279]
    41444144 */
    41454145HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
    41464146{
    4147     TRACE("( %d, %p ), stub\n", boolIn, pulOut );
    4148 
    4149     *pulOut = (ULONG) boolIn;
    4150 
    4151     return S_OK;
    4152 }
    4153 
    4154 /******************************************************************************
    4155  *      VarUI4FromI1        [OLEAUT32.280]
     4147        TRACE("( %d, %p ), stub\n", boolIn, pulOut );
     4148
     4149        *pulOut = (ULONG) boolIn;
     4150
     4151        return S_OK;
     4152}
     4153
     4154/******************************************************************************
     4155 *              VarUI4FromI1            [OLEAUT32.280]
    41564156 */
    41574157HRESULT WINAPI VarUI4FromI1(CHAR cIn, ULONG* pulOut)
    41584158{
    4159     TRACE("( %c, %p ), stub\n", cIn, pulOut );
    4160 
    4161     *pulOut = (ULONG) cIn;
    4162 
    4163     return S_OK;
    4164 }
    4165 
    4166 /******************************************************************************
    4167  *      VarUI4FromUI2       [OLEAUT32.281]
     4159        TRACE("( %c, %p ), stub\n", cIn, pulOut );
     4160
     4161        *pulOut = (ULONG) cIn;
     4162
     4163        return S_OK;
     4164}
     4165
     4166/******************************************************************************
     4167 *              VarUI4FromUI2           [OLEAUT32.281]
    41684168 */
    41694169HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
    41704170{
    4171     TRACE("( %d, %p ), stub\n", uiIn, pulOut );
    4172 
    4173     *pulOut = (ULONG) uiIn;
    4174 
    4175     return S_OK;
     4171        TRACE("( %d, %p ), stub\n", uiIn, pulOut );
     4172
     4173        *pulOut = (ULONG) uiIn;
     4174
     4175        return S_OK;
    41764176}
    41774177
    … …  
    41824182HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
    41834183   double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
    4184 
     4184   
    41854185   if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
    41864186
    … …  
    41974197   pcyOut->s.Hi = 0;
    41984198   pcyOut->s.Lo = ((ULONG)bIn) * 10000;
    4199 
     4199   
    42004200   return S_OK;
    42014201}
    … …  
    42094209   else pcyOut->s.Hi = 0;
    42104210   pcyOut->s.Lo = ((ULONG)sIn) * 10000;
    4211 
     4211   
    42124212   return S_OK;
    42134213}
    … …  
    42224222      pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
    42234223      if (lIn < 0) pcyOut->s.Hi--;
    4224 
     4224   
    42254225      return S_OK;
    42264226}
    … …  
    42354235   pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
    42364236   if (fltIn < 0) pcyOut->s.Hi--;
    4237 
     4237   
    42384238   return S_OK;
    42394239}
    … …  
    42694269 */
    42704270HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
    4271                 /* FIXME */
    4272         return E_NOTIMPL;
    4273 }
    4274 
    4275 
     4271                                /* FIXME */
     4272                return E_NOTIMPL;
     4273}
     4274
     4275 
    42764276/**********************************************************************
    42774277 *              VarCyFromBool [OLEAUT32.106]
    … …  
    42824282   else pcyOut->s.Hi = 0;
    42834283   pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
    4284 
     4284   
    42854285   return S_OK;
    42864286}
    … …  
    42944294   else pcyOut->s.Hi = 0;
    42954295   pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
    4296 
     4296   
    42974297   return S_OK;
    42984298}
    … …  
    43054305   pcyOut->s.Hi = 0;
    43064306   pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
    4307 
     4307   
    43084308   return S_OK;
    43094309}
    … …  
    43174317   pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
    43184318   pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
    4319 
     4319     
    43204320   return S_OK;
    43214321}
    … …  
    43334333
    43344334    TRACE("( 0x%x, 0x%x, 0x%p ), stub\n", wDosDate, wDosTime, pvtime );
    4335 
     4335   
    43364336    t.tm_sec = (wDosTime & 0x001f) * 2;
    43374337    t.tm_min = (wDosTime & 0x07e0) >> 5;
    43384338    t.tm_hour = (wDosTime & 0xf800) >> 11;
    4339 
     4339   
    43404340    t.tm_mday = (wDosDate & 0x001f);
    43414341    t.tm_mon = (wDosDate & 0x01e0) >> 5;
    … …  
    43634363    cDig = 0;
    43644364    for (i=0; strIn[i] ;i++) {
    4365     if ((strIn[i]>='0') && (strIn[i]<='9')) {
    4366         if (pnumprs->cDig > cDig) {
    4367         *(rgbDig++)=strIn[i]-'0';
    4368         cDig++;
    4369         lastent = i;
    4370         }
     4365        if ((strIn[i]>='0') && (strIn[i]<='9')) {
     4366            if (pnumprs->cDig > cDig) {
     4367                *(rgbDig++)=strIn[i]-'0';
     4368                cDig++;
     4369                lastent = i;
     4370            }
     4371        }
    43714372    }
    4372     }
    4373     pnumprs->cDig   = cDig;
     4373    pnumprs->cDig       = cDig;
    43744374
    43754375    /* FIXME: Just patching some values in */
    4376     pnumprs->nPwr10 = 0;
    4377     pnumprs->nBaseShift = 0;
    4378     pnumprs->cchUsed    = lastent;
    4379     pnumprs->dwOutFlags = NUMPRS_DECIMAL;
     4376    pnumprs->nPwr10     = 0;
     4377    pnumprs->nBaseShift = 0;
     4378    pnumprs->cchUsed    = lastent;
     4379    pnumprs->dwOutFlags = NUMPRS_DECIMAL;
    43804380    return S_OK;
    43814381}
    … …  
    43944394    xint = 0;
    43954395    for (i=0;i<pnumprs->cDig;i++)
    4396     xint = xint*10 + rgbDig[i];
     4396        xint = xint*10 + rgbDig[i];
    43974397
    43984398    VariantInit(pvar);
    43994399    if (dwVtBits & VTBIT_I4) {
    4400     V_VT(pvar) = VT_I4;
    4401     V_UNION(pvar,intVal) = xint;
    4402     return S_OK;
     4400        V_VT(pvar) = VT_I4;
     4401        V_UNION(pvar,intVal) = xint;
     4402        return S_OK;
    44034403    }
    44044404    if (dwVtBits & VTBIT_R8) {
    4405     V_VT(pvar) = VT_R8;
    4406     V_UNION(pvar,dblVal) = xint;
    4407     return S_OK;
     4405        V_VT(pvar) = VT_R8;
     4406        V_UNION(pvar,dblVal) = xint;
     4407        return S_OK;
    44084408    } else {
    4409     FIXME("vtbitmask is unsupported %lx\n",dwVtBits);
    4410     return E_FAIL;
     4409        FIXME("vtbitmask is unsupported %lx\n",dwVtBits);
     4410        return E_FAIL;
    44114411    }
    44124412}
    … …  
    46594659 *              VarBstrCmp [OLEAUT32.440]
    46604660 *
    4661  * flags can be:
     4661 * flags can be: 
    46624662 *   NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
    46634663 *   NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
Note: See TracChangeset for help on using the changeset viewer.