ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/ole/variant.c

4270 lines
103 KiB
C
Raw Blame History

/*
* VARIANT
*
* Copyright 1998 Jean-Claude Cote
*
* NOTES
* This implements the low-level and hi-level APIs for manipulating VARIANTs.
* The low-level APIs are used to do data coercion between different data types.
* The hi-level APIs are built on top of these low-level APIs and handle
* initialization, copying, destroying and changing the type of VARIANTs.
*
* TODO:
* - The Variant APIs are do not support international languages, currency
* types, number formating and calendar. They only support U.S. English format.
* - The Variant APIs do not the following types: IUknown, IDispatch, DECIMAL and SafeArray.
* The prototypes for these are commented out in the oleauto.h file. They need
* to be implemented and cases need to be added to the switches of the existing APIs.
* - The parsing of date for the VarDateFromStr is not complete.
* - The date manipulations do not support date prior to 1900.
* - The parsing does not accept has many formats has the Windows implementation.
*/
#include "windef.h"
#include "oleauto.h"
#include "heap.h"
#include "debug.h"
#include "winerror.h"
#include "parsedt.h"
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#ifdef HAVE_FLOAT_H
# include <float.h>
#endif
#ifndef FLT_MAX
# ifdef MAXFLOAT
# define FLT_MAX MAXFLOAT
# else
# error "Can't find #define for MAXFLOAT/FLT_MAX"
# endif
#endif
#undef CHAR_MAX
#undef CHAR_MIN
static const char CHAR_MAX = 127;
static const char CHAR_MIN = -128;
static const BYTE UI1_MAX = 255;
static const BYTE UI1_MIN = 0;
static const unsigned short UI2_MAX = 65535;
static const unsigned short UI2_MIN = 0;
static const short I2_MAX = 32767;
static const short I2_MIN = -32768;
static const unsigned long UI4_MAX = 4294967295U;
static const unsigned long UI4_MIN = 0;
static const long I4_MAX = 2147483647;
static const long I4_MIN = -(2147483648U);
static const DATE DATE_MIN = -657434;
static const DATE DATE_MAX = 2958465;
/* This mask is used to set a flag in wReserved1 of
* the VARIANTARG structure. The flag indicates if
* the API function is using an inner variant or not.
*/
#define PROCESSING_INNER_VARIANT 0x0001
/* General use buffer.
*/
#define BUFFER_MAX 1024
static char pBuffer[BUFFER_MAX];
/*
* Note a leap year is one that is a multiple of 4
* but not of a 100. Except if it is a multiple of
* 400 then it is a leap year.
*/
/* According to postgeSQL date parsing functions there is
* a leap year when this expression is true.
* (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
* So according to this there is 365.2515 days in one year.
* One + every four years: 1/4 -> 365.25
* One - every 100 years: 1/100 -> 365.001
* One + every 400 years: 1/400 -> 365.0025
*/
static const double DAYS_IN_ONE_YEAR = 365.2515;
/******************************************************************************
* DateTimeStringToTm [INTERNAL]
*
* Converts a string representation of a date and/or time to a tm structure.
*
* Note this function uses the postgresql date parsing functions found
* in the parsedt.c file.
*
* Returns TRUE if successfull.
*
* Note: This function does not parse the day of the week,
* daylight savings time. It will only fill the followin fields in
* the tm struct, tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
*
******************************************************************************/
static BOOL DateTimeStringToTm( OLECHAR* strIn, LCID lcid, struct tm* pTm )
{
BOOL res = FALSE;
double fsec;
int tzp;
int dtype;
int nf;
char *field[MAXDATEFIELDS];
int ftype[MAXDATEFIELDS];
char lowstr[MAXDATELEN + 1];
char* strDateTime = NULL;
/* Convert the string to ASCII since this is the only format
* postgesql can handle.
*/
strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
if( strDateTime != NULL )
{
/* Make sure we don't go over the maximum length
* accepted by postgesql.
*/
if( strlen( strDateTime ) <= MAXDATELEN )
{
if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
{
if( lcid & VAR_DATEVALUEONLY )
{
/* Get the date information.
* It returns 0 if date information was
* present and 1 if only time information was present.
* -1 if an error occures.
*/
if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
{
/* Eliminate the time information since we
* were asked to get date information only.
*/
pTm->tm_sec = 0;
pTm->tm_min = 0;
pTm->tm_hour = 0;
res = TRUE;
}
}
if( lcid & VAR_TIMEVALUEONLY )
{
/* Get time information only.
*/
if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
{
res = TRUE;
}
}
else
{
/* Get both date and time information.
* It returns 0 if date information was
* present and 1 if only time information was present.
* -1 if an error occures.
*/
if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
{
res = TRUE;
}
}
}
}
HeapFree( GetProcessHeap(), 0, strDateTime );
}
return res;
}
/******************************************************************************
* TmToDATE [INTERNAL]
*
* The date is implemented using an 8 byte floating-point number.
* Days are represented by whole numbers increments starting with 0.00 has
* being December 30 1899, midnight.
* The hours are expressed as the fractional part of the number.
* December 30 1899 at midnight = 0.00
* January 1 1900 at midnight = 2.00
* January 4 1900 at 6 AM = 5.25
* January 4 1900 at noon = 5.50
* December 29 1899 at midnight = -1.00
* December 18 1899 at midnight = -12.00
* December 18 1899 at 6AM = -12.25
* December 18 1899 at 6PM = -12.75
* December 19 1899 at midnight = -11.00
* The tm structure is as follows:
* struct tm {
* int tm_sec; seconds after the minute - [0,59]
* int tm_min; minutes after the hour - [0,59]
* int tm_hour; hours since midnight - [0,23]
* int tm_mday; day of the month - [1,31]
* int tm_mon; months since January - [0,11]
* int tm_year; years
* int tm_wday; days since Sunday - [0,6]
* int tm_yday; days since January 1 - [0,365]
* int tm_isdst; daylight savings time flag
* };
*
* Note: This function does not use the tm_wday, tm_yday, tm_wday,
* and tm_isdst fields of the tm structure. And only converts years
* after 1900.
*
* Returns TRUE if successfull.
*/
static BOOL TmToDATE( struct tm* pTm, DATE *pDateOut )
{
if( (pTm->tm_year - 1900) >= 0 )
{
int leapYear = 0;
/* Start at 1. This is the way DATE is defined.
* January 1, 1900 at Midnight is 1.00.
* January 1, 1900 at 6AM is 1.25.
* and so on.
*/
*pDateOut = 1;
/* Add the number of days corresponding to
* tm_year.
*/
*pDateOut += (pTm->tm_year - 1900) * 365;
/* Add the leap days in the previous years between now and 1900.
* Note a leap year is one that is a multiple of 4
* but not of a 100. Except if it is a multiple of
* 400 then it is a leap year.
*/
*pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
*pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
*pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
/* Set the leap year flag if the
* current year specified by tm_year is a
* leap year. This will be used to add a day
* to the day count.
*/
if( isleap( pTm->tm_year ) )
leapYear = 1;
/* Add the number of days corresponding to
* the month.
*/
switch( pTm->tm_mon )
{
case 2:
*pDateOut += 31;
break;
case 3:
*pDateOut += ( 59 + leapYear );
break;
case 4:
*pDateOut += ( 90 + leapYear );
break;
case 5:
*pDateOut += ( 120 + leapYear );
break;
case 6:
*pDateOut += ( 151 + leapYear );
break;
case 7:
*pDateOut += ( 181 + leapYear );
break;
case 8:
*pDateOut += ( 212 + leapYear );
break;
case 9:
*pDateOut += ( 243 + leapYear );
break;
case 10:
*pDateOut += ( 273 + leapYear );
break;
case 11:
*pDateOut += ( 304 + leapYear );
break;
case 12:
*pDateOut += ( 334 + leapYear );
break;
}
/* Add the number of days in this month.
*/
*pDateOut += pTm->tm_mday;
/* Add the number of seconds, minutes, and hours
* to the DATE. Note these are the fracionnal part
* of the DATE so seconds / number of seconds in a day.
*/
*pDateOut += pTm->tm_hour / 24.0;
*pDateOut += pTm->tm_min / 1440.0;
*pDateOut += pTm->tm_sec / 86400.0;
return TRUE;
}
return FALSE;
}
/******************************************************************************
* DateToTm [INTERNAL]
*
* This function converst a windows DATE to a tm structure.
*
* It does not fill all the fields of the tm structure.
* Here is a list of the fields that are filled:
* tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
*
* Note this function does not support dates before the January 1, 1900
* or ( dateIn < 2.0 ).
*
* Returns TRUE if successfull.
*/
static BOOL DateToTm( DATE dateIn, LCID lcid, struct tm* pTm )
{
/* Do not process dates smaller than January 1, 1900.
* Which corresponds to 2.0 in the windows DATE format.
*/
if( dateIn >= 2.0 )
{
double decimalPart = 0.0;
double wholePart = 0.0;
memset(pTm,0,sizeof(*pTm));
/* Because of the nature of DATE format witch
* associates 2.0 to January 1, 1900. We will
* remove 1.0 from the whole part of the DATE
* so that in the following code 1.0
* will correspond to January 1, 1900.
* This simplyfies the processing of the DATE value.
*/
dateIn -= 1.0;
wholePart = (double) floor( dateIn );
decimalPart = fmod( dateIn, wholePart );
if( !(lcid & VAR_TIMEVALUEONLY) )
{
int nDay = 0;
int leapYear = 0;
double yearsSince1900 = 0;
/* Start at 1900, this where the DATE time 0.0 starts.
*/
pTm->tm_year = 1900;
/* find in what year the day in the "wholePart" falls into.
* add the value to the year field.
*/
yearsSince1900 = floor( wholePart / DAYS_IN_ONE_YEAR );
pTm->tm_year += yearsSince1900;
/* determine if this is a leap year.
*/
if( isleap( pTm->tm_year ) )
leapYear = 1;
/* find what day of that year does the "wholePart" corresponds to.
* Note: nDay is in [1-366] format
*/
nDay = (int) ( wholePart - floor( yearsSince1900 * DAYS_IN_ONE_YEAR ) );
/* Set the tm_yday value.
* Note: The day is must be converted from [1-366] to [0-365]
*/
/*pTm->tm_yday = nDay - 1;*/
/* find which mount this day corresponds to.
*/
if( nDay <= 31 )
{
pTm->tm_mday = nDay;
pTm->tm_mon = 0;
}
else if( nDay <= ( 59 + leapYear ) )
{
pTm->tm_mday = nDay - 31;
pTm->tm_mon = 1;
}
else if( nDay <= ( 90 + leapYear ) )
{
pTm->tm_mday = nDay - ( 59 + leapYear );
pTm->tm_mon = 2;
}
else if( nDay <= ( 120 + leapYear ) )
{
pTm->tm_mday = nDay - ( 90 + leapYear );
pTm->tm_mon = 3;
}
else if( nDay <= ( 151 + leapYear ) )
{
pTm->tm_mday = nDay - ( 120 + leapYear );
pTm->tm_mon = 4;
}
else if( nDay <= ( 181 + leapYear ) )
{
pTm->tm_mday = nDay - ( 151 + leapYear );
pTm->tm_mon = 5;
}
else if( nDay <= ( 212 + leapYear ) )
{
pTm->tm_mday = nDay - ( 181 + leapYear );
pTm->tm_mon = 6;
}
else if( nDay <= ( 243 + leapYear ) )
{
pTm->tm_mday = nDay - ( 212 + leapYear );
pTm->tm_mon = 7;
}
else if( nDay <= ( 273 + leapYear ) )
{
pTm->tm_mday = nDay - ( 243 + leapYear );
pTm->tm_mon = 8;
}
else if( nDay <= ( 304 + leapYear ) )
{
pTm->tm_mday = nDay - ( 273 + leapYear );
pTm->tm_mon = 9;
}
else if( nDay <= ( 334 + leapYear ) )
{
pTm->tm_mday = nDay - ( 304 + leapYear );
pTm->tm_mon = 10;
}
else if( nDay <= ( 365 + leapYear ) )
{
pTm->tm_mday = nDay - ( 334 + leapYear );
pTm->tm_mon = 11;
}
}
if( !(lcid & VAR_DATEVALUEONLY) )
{
/* find the number of seconds in this day.
* fractional part times, hours, minutes, seconds.
*/
pTm->tm_hour = (int) ( decimalPart * 24 );
pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
pTm->tm_sec = (int) ( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 );
}
return TRUE;
}
return FALSE;
}
/******************************************************************************
* SizeOfVariantData [INTERNAL]
*
* This function finds the size of the data referenced by a Variant based
* the type "vt" of the Variant.
*/
static int SizeOfVariantData( VARIANT* parg )
{
int size = 0;
switch( parg->vt & VT_TYPEMASK )
{
case( VT_I2 ):
size = sizeof(short);
break;
case( VT_INT ):
size = sizeof(int);
break;
case( VT_I4 ):
size = sizeof(long);
break;
case( VT_UI1 ):
size = sizeof(BYTE);
break;
case( VT_UI2 ):
size = sizeof(unsigned short);
break;
case( VT_UINT ):
size = sizeof(unsigned int);
break;
case( VT_UI4 ):
size = sizeof(unsigned long);
break;
case( VT_R4 ):
size = sizeof(float);
break;
case( VT_R8 ):
size = sizeof(double);
break;
case( VT_DATE ):
size = sizeof(DATE);
break;
case( VT_BOOL ):
size = sizeof(VARIANT_BOOL);
break;
case( VT_BSTR ):
size = sizeof(void*);
break;
case( VT_CY ):
case( VT_DISPATCH ):
case( VT_UNKNOWN ):
case( VT_DECIMAL ):
default:
FIXME(ole,"Add size information for type vt=%d\n", parg->vt & VT_TYPEMASK );
break;
}
return size;
}
/******************************************************************************
* StringDupAtoBstr [INTERNAL]
*
*/
static BSTR StringDupAtoBstr( char* strIn )
{
BSTR bstr = NULL;
OLECHAR* pNewString = NULL;
pNewString = HEAP_strdupAtoW( GetProcessHeap(), 0, strIn );
bstr = SysAllocString( pNewString );
HeapFree( GetProcessHeap(), 0, pNewString );
return bstr;
}
/******************************************************************************
* round [INTERNAL]
*
* Round the double value to the nearest integer value.
*/
static double round( double d )
{
double decimals = 0.0, integerValue = 0.0, roundedValue = 0.0;
BOOL bEvenNumber = FALSE;
int nSign = 0;
/* Save the sign of the number
*/
nSign = (d >= 0.0) ? 1 : -1;
d = fabs( d );
/* Remove the decimals.
*/
integerValue = floor( d );
/* Set the Even flag. This is used to round the number when
* the decimals are exactly 1/2. If the integer part is
* odd the number is rounded up. If the integer part
* is even the number is rounded down. Using this method
* numbers are rounded up|down half the time.
*/
bEvenNumber = (((short)fmod(integerValue, 2)) == 0) ? TRUE : FALSE;
/* Remove the integral part of the number.
*/
decimals = d - integerValue;
/* Note: Ceil returns the smallest integer that is greater that x.
* and floor returns the largest integer that is less than or equal to x.
*/
if( decimals > 0.5 )
{
/* If the decimal part is greater than 1/2
*/
roundedValue = ceil( d );
}
else if( decimals < 0.5 )
{
/* If the decimal part is smaller than 1/2
*/
roundedValue = floor( d );
}
else
{
/* the decimals are exactly 1/2 so round according to
* the bEvenNumber flag.
*/
if( bEvenNumber )
{
roundedValue = floor( d );
}
else
{
roundedValue = ceil( d );
}
}
return roundedValue * nSign;
}
/******************************************************************************
* RemoveCharacterFromString [INTERNAL]
*
* Removes any of the characters in "strOfCharToRemove" from the "str" argument.
*/
static void RemoveCharacterFromString( LPSTR str, LPSTR strOfCharToRemove )
{
LPSTR pNewString = NULL;
LPSTR strToken = NULL;
/* Check if we have a valid argument
*/
if( str != NULL )
{
pNewString = strdup( str );
str[0] = '\0';
strToken = strtok( pNewString, strOfCharToRemove );
while( strToken != NULL ) {
strcat( str, strToken );
strToken = strtok( NULL, strOfCharToRemove );
}
free( pNewString );
}
return;
}
/******************************************************************************
* GetValidRealString [INTERNAL]
*
* Checks if the string is of proper format to be converted to a real value.
*/
static BOOL IsValidRealString( LPSTR strRealString )
{
/* Real values that have a decimal point are required to either have
* digits before or after the decimal point. We will assume that
* we do not have any digits at either position. If we do encounter
* some we will disable this flag.
*/
BOOL bDigitsRequired = TRUE;
/* Processed fields in the string representation of the real number.
*/
BOOL bWhiteSpaceProcessed = FALSE;
BOOL bFirstSignProcessed = FALSE;
BOOL bFirstDigitsProcessed = FALSE;
BOOL bDecimalPointProcessed = FALSE;
BOOL bSecondDigitsProcessed = FALSE;
BOOL bExponentProcessed = FALSE;
BOOL bSecondSignProcessed = FALSE;
BOOL bThirdDigitsProcessed = FALSE;
/* Assume string parameter "strRealString" is valid and try to disprove it.
*/
BOOL bValidRealString = TRUE;
/* Used to count the number of tokens in the "strRealString".
*/
LPSTR strToken = NULL;
int nTokens = 0;
LPSTR pChar = NULL;
/* Check if we have a valid argument
*/
if( strRealString == NULL )
{
bValidRealString = FALSE;
}
if( bValidRealString == TRUE )
{
/* Make sure we only have ONE token in the string.
*/
strToken = strtok( strRealString, " " );
while( strToken != NULL ) {
nTokens++;
strToken = strtok( NULL, " " );
}
if( nTokens != 1 )
{
bValidRealString = FALSE;
}
}
/* Make sure this token contains only valid characters.
* The string argument to atof has the following form:
* [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
* Whitespace consists of space and|or <TAB> characters, which are ignored.
* Sign is either plus '+' or minus '-'.
* Digits are one or more decimal digits.
* Note: If no digits appear before the decimal point, at least one must
* appear after the decimal point.
* The decimal digits may be followed by an exponent.
* An Exponent consists of an introductory letter ( D, d, E, or e) and
* an optionally signed decimal integer.
*/
pChar = strRealString;
while( bValidRealString == TRUE && *pChar != '\0' )
{
switch( *pChar )
{
/* If whitespace...
*/
case ' ':
case '\t':
if( bWhiteSpaceProcessed ||
bFirstSignProcessed ||
bFirstDigitsProcessed ||
bDecimalPointProcessed ||
bSecondDigitsProcessed ||
bExponentProcessed ||
bSecondSignProcessed ||
bThirdDigitsProcessed )
{
bValidRealString = FALSE;
}
break;
/* If sign...
*/
case '+':
case '-':
if( bFirstSignProcessed == FALSE )
{
if( bFirstDigitsProcessed ||
bDecimalPointProcessed ||
bSecondDigitsProcessed ||
bExponentProcessed ||
bSecondSignProcessed ||
bThirdDigitsProcessed )
{
bValidRealString = FALSE;
}
bWhiteSpaceProcessed = TRUE;
bFirstSignProcessed = TRUE;
}
else if( bSecondSignProcessed == FALSE )
{
/* Note: The exponent must be present in
* order to accept the second sign...
*/
if( bExponentProcessed == FALSE ||
bThirdDigitsProcessed ||
bDigitsRequired )
{
bValidRealString = FALSE;
}
bFirstSignProcessed = TRUE;
bWhiteSpaceProcessed = TRUE;
bFirstDigitsProcessed = TRUE;
bDecimalPointProcessed = TRUE;
bSecondDigitsProcessed = TRUE;
bSecondSignProcessed = TRUE;
}
break;
/* If decimals...
*/
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if( bFirstDigitsProcessed == FALSE )
{
if( bDecimalPointProcessed ||
bSecondDigitsProcessed ||
bExponentProcessed ||
bSecondSignProcessed ||
bThirdDigitsProcessed )
{
bValidRealString = FALSE;
}
bFirstSignProcessed = TRUE;
bWhiteSpaceProcessed = TRUE;
/* We have found some digits before the decimal point
* so disable the "Digits required" flag.
*/
bDigitsRequired = FALSE;
}
else if( bSecondDigitsProcessed == FALSE )
{
if( bExponentProcessed ||
bSecondSignProcessed ||
bThirdDigitsProcessed )
{
bValidRealString = FALSE;
}
bFirstSignProcessed = TRUE;
bWhiteSpaceProcessed = TRUE;
bFirstDigitsProcessed = TRUE;
bDecimalPointProcessed = TRUE;
/* We have found some digits after the decimal point
* so disable the "Digits required" flag.
*/
bDigitsRequired = FALSE;
}
else if( bThirdDigitsProcessed == FALSE )
{
/* Getting here means everything else should be processed.
* If we get anything else than a decimal following this
* digit it will be flagged by the other cases, so
* we do not really need to do anything in here.
*/
}
break;
/* If DecimalPoint...
*/
case '.':
if( bDecimalPointProcessed ||
bSecondDigitsProcessed ||
bExponentProcessed ||
bSecondSignProcessed ||
bThirdDigitsProcessed )
{
bValidRealString = FALSE;
}
bFirstSignProcessed = TRUE;
bWhiteSpaceProcessed = TRUE;
bFirstDigitsProcessed = TRUE;
bDecimalPointProcessed = TRUE;
break;
/* If Exponent...
*/
case 'e':
case 'E':
case 'd':
case 'D':
if( bExponentProcessed ||
bSecondSignProcessed ||
bThirdDigitsProcessed ||
bDigitsRequired )
{
bValidRealString = FALSE;
}
bFirstSignProcessed = TRUE;
bWhiteSpaceProcessed = TRUE;
bFirstDigitsProcessed = TRUE;
bDecimalPointProcessed = TRUE;
bSecondDigitsProcessed = TRUE;
bExponentProcessed = TRUE;
break;
default:
bValidRealString = FALSE;
break;
}
/* Process next character.
*/
pChar++;
}
/* If the required digits were not present we have an invalid
* string representation of a real number.
*/
if( bDigitsRequired == TRUE )
{
bValidRealString = FALSE;
}
return bValidRealString;
}
/******************************************************************************
* Coerce [INTERNAL]
*
* This function dispatches execution to the proper conversion API
* to do the necessary coercion.
*/
static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt )
{
HRESULT res = S_OK;
unsigned short vtFrom = 0;
vtFrom = ps->vt & VT_TYPEMASK;
/* Note: Since "long" and "int" values both have 4 bytes and are both signed integers
* "int" will be treated as "long" in the following code.
* The same goes for there unsigned versions.
*/
switch( vt )
{
case( VT_EMPTY ):
res = VariantClear( pd );
break;
case( VT_NULL ):
res = VariantClear( pd );
if( res == S_OK )
{
pd->vt = VT_NULL;
}
break;
case( VT_I1 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VariantCopy( pd, ps );
break;
case( VT_I2 ):
res = VarI1FromI2( ps->u.iVal, &(pd->u.cVal) );
break;
case( VT_INT ):
case( VT_I4 ):
res = VarI1FromI4( ps->u.lVal, &(pd->u.cVal) );
break;
case( VT_UI1 ):
res = VarI1FromUI1( ps->u.bVal, &(pd->u.cVal) );
break;
case( VT_UI2 ):
res = VarI1FromUI2( ps->u.uiVal, &(pd->u.cVal) );
break;
case( VT_UINT ):
case( VT_UI4 ):
res = VarI1FromUI4( ps->u.ulVal, &(pd->u.cVal) );
break;
case( VT_R4 ):
res = VarI1FromR4( ps->u.fltVal, &(pd->u.cVal) );
break;
case( VT_R8 ):
res = VarI1FromR8( ps->u.dblVal, &(pd->u.cVal) );
break;
case( VT_DATE ):
res = VarI1FromDate( ps->u.date, &(pd->u.cVal) );
break;
case( VT_BOOL ):
res = VarI1FromBool( ps->u.boolVal, &(pd->u.cVal) );
break;
case( VT_BSTR ):
res = VarI1FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cVal) );
break;
case( VT_CY ):
res = VarI1FromCy( ps->u.cyVal, &(pd->u.cVal) );
case( VT_DISPATCH ):
/*res = VarI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.cVal) );*/
case( VT_UNKNOWN ):
/*res = VarI1From32( ps->u.lVal, &(pd->u.cVal) );*/
case( VT_DECIMAL ):
/*res = VarI1FromDec32( ps->u.decVal, &(pd->u.cVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_I2 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarI2FromI1( ps->u.cVal, &(pd->u.iVal) );
break;
case( VT_I2 ):
res = VariantCopy( pd, ps );
break;
case( VT_INT ):
case( VT_I4 ):
res = VarI2FromI4( ps->u.lVal, &(pd->u.iVal) );
break;
case( VT_UI1 ):
res = VarI2FromUI1( ps->u.bVal, &(pd->u.iVal) );
break;
case( VT_UI2 ):
res = VarI2FromUI2( ps->u.uiVal, &(pd->u.iVal) );
break;
case( VT_UINT ):
case( VT_UI4 ):
res = VarI2FromUI4( ps->u.ulVal, &(pd->u.iVal) );
break;
case( VT_R4 ):
res = VarI2FromR4( ps->u.fltVal, &(pd->u.iVal) );
break;
case( VT_R8 ):
res = VarI2FromR8( ps->u.dblVal, &(pd->u.iVal) );
break;
case( VT_DATE ):
res = VarI2FromDate( ps->u.date, &(pd->u.iVal) );
break;
case( VT_BOOL ):
res = VarI2FromBool( ps->u.boolVal, &(pd->u.iVal) );
break;
case( VT_BSTR ):
res = VarI2FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.iVal) );
break;
case( VT_CY ):
res = VarI2FromCy( ps->u.cyVal, &(pd->u.iVal) );
case( VT_DISPATCH ):
/*res = VarI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.iVal) );*/
case( VT_UNKNOWN ):
/*res = VarI2From32( ps->u.lVal, &(pd->u.iVal) );*/
case( VT_DECIMAL ):
/*res = VarI2FromDec32( ps->u.deiVal, &(pd->u.iVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_INT ):
case( VT_I4 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarI4FromI1( ps->u.cVal, &(pd->u.lVal) );
break;
case( VT_I2 ):
res = VarI4FromI2( ps->u.iVal, &(pd->u.lVal) );
break;
case( VT_INT ):
case( VT_I4 ):
res = VariantCopy( pd, ps );
break;
case( VT_UI1 ):
res = VarI4FromUI1( ps->u.bVal, &(pd->u.lVal) );
break;
case( VT_UI2 ):
res = VarI4FromUI2( ps->u.uiVal, &(pd->u.lVal) );
break;
case( VT_UINT ):
case( VT_UI4 ):
res = VarI4FromUI4( ps->u.ulVal, &(pd->u.lVal) );
break;
case( VT_R4 ):
res = VarI4FromR4( ps->u.fltVal, &(pd->u.lVal) );
break;
case( VT_R8 ):
res = VarI4FromR8( ps->u.dblVal, &(pd->u.lVal) );
break;
case( VT_DATE ):
res = VarI4FromDate( ps->u.date, &(pd->u.lVal) );
break;
case( VT_BOOL ):
res = VarI4FromBool( ps->u.boolVal, &(pd->u.lVal) );
break;
case( VT_BSTR ):
res = VarI4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.lVal) );
break;
case( VT_CY ):
res = VarI4FromCy( ps->u.cyVal, &(pd->u.lVal) );
case( VT_DISPATCH ):
/*res = VarI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.lVal) );*/
case( VT_UNKNOWN ):
/*res = VarI4From32( ps->u.lVal, &(pd->u.lVal) );*/
case( VT_DECIMAL ):
/*res = VarI4FromDec32( ps->u.deiVal, &(pd->u.lVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_UI1 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarUI1FromI1( ps->u.cVal, &(pd->u.bVal) );
break;
case( VT_I2 ):
res = VarUI1FromI2( ps->u.iVal, &(pd->u.bVal) );
break;
case( VT_INT ):
case( VT_I4 ):
res = VarUI1FromI4( ps->u.lVal, &(pd->u.bVal) );
break;
case( VT_UI1 ):
res = VariantCopy( pd, ps );
break;
case( VT_UI2 ):
res = VarUI1FromUI2( ps->u.uiVal, &(pd->u.bVal) );
break;
case( VT_UINT ):
case( VT_UI4 ):
res = VarUI1FromUI4( ps->u.ulVal, &(pd->u.bVal) );
break;
case( VT_R4 ):
res = VarUI1FromR4( ps->u.fltVal, &(pd->u.bVal) );
break;
case( VT_R8 ):
res = VarUI1FromR8( ps->u.dblVal, &(pd->u.bVal) );
break;
case( VT_DATE ):
res = VarUI1FromDate( ps->u.date, &(pd->u.bVal) );
break;
case( VT_BOOL ):
res = VarUI1FromBool( ps->u.boolVal, &(pd->u.bVal) );
break;
case( VT_BSTR ):
res = VarUI1FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.bVal) );
break;
case( VT_CY ):
res = VarUI1FromCy( ps->u.cyVal, &(pd->u.bVal) );
case( VT_DISPATCH ):
/*res = VarUI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.bVal) );*/
case( VT_UNKNOWN ):
/*res = VarUI1From32( ps->u.lVal, &(pd->u.bVal) );*/
case( VT_DECIMAL ):
/*res = VarUI1FromDec32( ps->u.deiVal, &(pd->u.bVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_UI2 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarUI2FromI1( ps->u.cVal, &(pd->u.uiVal) );
break;
case( VT_I2 ):
res = VarUI2FromI2( ps->u.iVal, &(pd->u.uiVal) );
break;
case( VT_INT ):
case( VT_I4 ):
res = VarUI2FromI4( ps->u.lVal, &(pd->u.uiVal) );
break;
case( VT_UI1 ):
res = VarUI2FromUI1( ps->u.bVal, &(pd->u.uiVal) );
break;
case( VT_UI2 ):
res = VariantCopy( pd, ps );
break;
case( VT_UINT ):
case( VT_UI4 ):
res = VarUI2FromUI4( ps->u.ulVal, &(pd->u.uiVal) );
break;
case( VT_R4 ):
res = VarUI2FromR4( ps->u.fltVal, &(pd->u.uiVal) );
break;
case( VT_R8 ):
res = VarUI2FromR8( ps->u.dblVal, &(pd->u.uiVal) );
break;
case( VT_DATE ):
res = VarUI2FromDate( ps->u.date, &(pd->u.uiVal) );
break;
case( VT_BOOL ):
res = VarUI2FromBool( ps->u.boolVal, &(pd->u.uiVal) );
break;
case( VT_BSTR ):
res = VarUI2FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.uiVal) );
break;
case( VT_CY ):
res = VarUI2FromCy( ps->u.cyVal, &(pd->u.uiVal) );
case( VT_DISPATCH ):
/*res = VarUI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.uiVal) );*/
case( VT_UNKNOWN ):
/*res = VarUI2From32( ps->u.lVal, &(pd->u.uiVal) );*/
case( VT_DECIMAL ):
/*res = VarUI2FromDec32( ps->u.deiVal, &(pd->u.uiVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_UINT ):
case( VT_UI4 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarUI4FromI1( ps->u.cVal, &(pd->u.ulVal) );
break;
case( VT_I2 ):
res = VarUI4FromI2( ps->u.iVal, &(pd->u.ulVal) );
break;
case( VT_INT ):
case( VT_I4 ):
res = VarUI4FromI4( ps->u.lVal, &(pd->u.ulVal) );
break;
case( VT_UI1 ):
res = VarUI4FromUI1( ps->u.bVal, &(pd->u.ulVal) );
break;
case( VT_UI2 ):
res = VarUI4FromUI2( ps->u.uiVal, &(pd->u.ulVal) );
break;
case( VT_UI4 ):
res = VariantCopy( pd, ps );
break;
case( VT_R4 ):
res = VarUI4FromR4( ps->u.fltVal, &(pd->u.ulVal) );
break;
case( VT_R8 ):
res = VarUI4FromR8( ps->u.dblVal, &(pd->u.ulVal) );
break;
case( VT_DATE ):
res = VarUI4FromDate( ps->u.date, &(pd->u.ulVal) );
break;
case( VT_BOOL ):
res = VarUI4FromBool( ps->u.boolVal, &(pd->u.ulVal) );
break;
case( VT_BSTR ):
res = VarUI4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.ulVal) );
break;
case( VT_CY ):
res = VarUI4FromCy( ps->u.cyVal, &(pd->u.ulVal) );
case( VT_DISPATCH ):
/*res = VarUI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.ulVal) );*/
case( VT_UNKNOWN ):
/*res = VarUI4From32( ps->u.lVal, &(pd->u.ulVal) );*/
case( VT_DECIMAL ):
/*res = VarUI4FromDec32( ps->u.deiVal, &(pd->u.ulVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_R4 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarR4FromI1( ps->u.cVal, &(pd->u.fltVal) );
break;
case( VT_I2 ):
res = VarR4FromI2( ps->u.iVal, &(pd->u.fltVal) );
break;
case( VT_INT ):
case( VT_I4 ):
res = VarR4FromI4( ps->u.lVal, &(pd->u.fltVal) );
break;
case( VT_UI1 ):
res = VarR4FromUI1( ps->u.bVal, &(pd->u.fltVal) );
break;
case( VT_UI2 ):
res = VarR4FromUI2( ps->u.uiVal, &(pd->u.fltVal) );
break;
case( VT_UINT ):
case( VT_UI4 ):
res = VarR4FromUI4( ps->u.ulVal, &(pd->u.fltVal) );
break;
case( VT_R4 ):
res = VariantCopy( pd, ps );
break;
case( VT_R8 ):
res = VarR4FromR8( ps->u.dblVal, &(pd->u.fltVal) );
break;
case( VT_DATE ):
res = VarR4FromDate( ps->u.date, &(pd->u.fltVal) );
break;
case( VT_BOOL ):
res = VarR4FromBool( ps->u.boolVal, &(pd->u.fltVal) );
break;
case( VT_BSTR ):
res = VarR4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.fltVal) );
break;
case( VT_CY ):
res = VarR4FromCy( ps->u.cyVal, &(pd->u.fltVal) );
case( VT_DISPATCH ):
/*res = VarR4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.fltVal) );*/
case( VT_UNKNOWN ):
/*res = VarR4From32( ps->u.lVal, &(pd->u.fltVal) );*/
case( VT_DECIMAL ):
/*res = VarR4FromDec32( ps->u.deiVal, &(pd->u.fltVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_R8 ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarR8FromI1( ps->u.cVal, &(pd->u.dblVal) );
break;
case( VT_I2 ):
res = VarR8FromI2( ps->u.iVal, &(pd->u.dblVal) );
break;
case( VT_INT ):
case( VT_I4 ):
res = VarR8FromI4( ps->u.lVal, &(pd->u.dblVal) );
break;
case( VT_UI1 ):
res = VarR8FromUI1( ps->u.bVal, &(pd->u.dblVal) );
break;
case( VT_UI2 ):
res = VarR8FromUI2( ps->u.uiVal, &(pd->u.dblVal) );
break;
case( VT_UINT ):
case( VT_UI4 ):
res = VarR8FromUI4( ps->u.ulVal, &(pd->u.dblVal) );
break;
case( VT_R4 ):
res = VarR8FromR4( ps->u.fltVal, &(pd->u.dblVal) );
break;
case( VT_R8 ):
res = VariantCopy( pd, ps );
break;
case( VT_DATE ):
res = VarR8FromDate( ps->u.date, &(pd->u.dblVal) );
break;
case( VT_BOOL ):
res = VarR8FromBool( ps->u.boolVal, &(pd->u.dblVal) );
break;
case( VT_BSTR ):
res = VarR8FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.dblVal) );
break;
case( VT_CY ):
res = VarR8FromCy( ps->u.cyVal, &(pd->u.dblVal) );
case( VT_DISPATCH ):
/*res = VarR8FromDisp32( ps->u.pdispVal, lcid, &(pd->u.dblVal) );*/
case( VT_UNKNOWN ):
/*res = VarR8From32( ps->u.lVal, &(pd->u.dblVal) );*/
case( VT_DECIMAL ):
/*res = VarR8FromDec32( ps->u.deiVal, &(pd->u.dblVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_DATE ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarDateFromI1( ps->u.cVal, &(pd->u.date) );
break;
case( VT_I2 ):
res = VarDateFromI2( ps->u.iVal, &(pd->u.date) );
break;
case( VT_INT ):
res = VarDateFromInt( ps->u.intVal, &(pd->u.date) );
break;
case( VT_I4 ):
res = VarDateFromI4( ps->u.lVal, &(pd->u.date) );
break;
case( VT_UI1 ):
res = VarDateFromUI1( ps->u.bVal, &(pd->u.date) );
break;
case( VT_UI2 ):
res = VarDateFromUI2( ps->u.uiVal, &(pd->u.date) );
break;
case( VT_UINT ):
res = VarDateFromUint( ps->u.uintVal, &(pd->u.date) );
break;
case( VT_UI4 ):
res = VarDateFromUI4( ps->u.ulVal, &(pd->u.date) );
break;
case( VT_R4 ):
res = VarDateFromR4( ps->u.fltVal, &(pd->u.date) );
break;
case( VT_R8 ):
res = VarDateFromR8( ps->u.dblVal, &(pd->u.date) );
break;
case( VT_DATE ):
res = VariantCopy( pd, ps );
break;
case( VT_BOOL ):
res = VarDateFromBool( ps->u.boolVal, &(pd->u.date) );
break;
case( VT_BSTR ):
res = VarDateFromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.date) );
break;
case( VT_CY ):
res = VarDateFromCy( ps->u.cyVal, &(pd->u.date) );
case( VT_DISPATCH ):
/*res = VarDateFromDisp32( ps->u.pdispVal, lcid, &(pd->u.date) );*/
case( VT_UNKNOWN ):
/*res = VarDateFrom32( ps->u.lVal, &(pd->u.date) );*/
case( VT_DECIMAL ):
/*res = VarDateFromDec32( ps->u.deiVal, &(pd->u.date) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_BOOL ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarBoolFromI1( ps->u.cVal, &(pd->u.boolVal) );
break;
case( VT_I2 ):
res = VarBoolFromI2( ps->u.iVal, &(pd->u.boolVal) );
break;
case( VT_INT ):
res = VarBoolFromInt( ps->u.intVal, &(pd->u.boolVal) );
break;
case( VT_I4 ):
res = VarBoolFromI4( ps->u.lVal, &(pd->u.boolVal) );
break;
case( VT_UI1 ):
res = VarBoolFromUI1( ps->u.bVal, &(pd->u.boolVal) );
break;
case( VT_UI2 ):
res = VarBoolFromUI2( ps->u.uiVal, &(pd->u.boolVal) );
break;
case( VT_UINT ):
res = VarBoolFromUint( ps->u.uintVal, &(pd->u.boolVal) );
break;
case( VT_UI4 ):
res = VarBoolFromUI4( ps->u.ulVal, &(pd->u.boolVal) );
break;
case( VT_R4 ):
res = VarBoolFromR4( ps->u.fltVal, &(pd->u.boolVal) );
break;
case( VT_R8 ):
res = VarBoolFromR8( ps->u.dblVal, &(pd->u.boolVal) );
break;
case( VT_DATE ):
res = VarBoolFromDate( ps->u.date, &(pd->u.boolVal) );
break;
case( VT_BOOL ):
res = VariantCopy( pd, ps );
break;
case( VT_BSTR ):
res = VarBoolFromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.boolVal) );
break;
case( VT_CY ):
res = VarBoolFromCy( ps->u.cyVal, &(pd->u.boolVal) );
case( VT_DISPATCH ):
/*res = VarBoolFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
case( VT_UNKNOWN ):
/*res = VarBoolFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
case( VT_DECIMAL ):
/*res = VarBoolFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_BSTR ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarBstrFromI1( ps->u.cVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_I2 ):
res = VarBstrFromI2( ps->u.iVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_INT ):
res = VarBstrFromInt( ps->u.intVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_I4 ):
res = VarBstrFromI4( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_UI1 ):
res = VarBstrFromUI1( ps->u.bVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_UI2 ):
res = VarBstrFromUI2( ps->u.uiVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_UINT ):
res = VarBstrFromUint( ps->u.uintVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_UI4 ):
res = VarBstrFromUI4( ps->u.ulVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_R4 ):
res = VarBstrFromR4( ps->u.fltVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_R8 ):
res = VarBstrFromR8( ps->u.dblVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_DATE ):
res = VarBstrFromDate( ps->u.date, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_BOOL ):
res = VarBstrFromBool( ps->u.boolVal, lcid, dwFlags, &(pd->u.bstrVal) );
break;
case( VT_BSTR ):
res = VariantCopy( pd, ps );
break;
case( VT_CY ):
/*res = VarBstrFromCy32( ps->u.cyVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
case( VT_DISPATCH ):
/*res = VarBstrFromDisp32( ps->u.pdispVal, lcid, lcid, dwFlags, &(pd->u.bstrVal) );*/
case( VT_UNKNOWN ):
/*res = VarBstrFrom32( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
case( VT_DECIMAL ):
/*res = VarBstrFromDec32( ps->u.deiVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
case( VT_CY ):
switch( vtFrom )
{
case( VT_I1 ):
res = VarCyFromI1( ps->u.cVal, &(pd->u.cyVal) );
break;
case( VT_I2 ):
res = VarCyFromI2( ps->u.iVal, &(pd->u.cyVal) );
break;
case( VT_INT ):
res = VarCyFromInt( ps->u.intVal, &(pd->u.cyVal) );
break;
case( VT_I4 ):
res = VarCyFromI4( ps->u.lVal, &(pd->u.cyVal) );
break;
case( VT_UI1 ):
res = VarCyFromUI1( ps->u.bVal, &(pd->u.cyVal) );
break;
case( VT_UI2 ):
res = VarCyFromUI2( ps->u.uiVal, &(pd->u.cyVal) );
break;
case( VT_UINT ):
res = VarCyFromUint( ps->u.uintVal, &(pd->u.cyVal) );
break;
case( VT_UI4 ):
res = VarCyFromUI4( ps->u.ulVal, &(pd->u.cyVal) );
break;
case( VT_R4 ):
res = VarCyFromR4( ps->u.fltVal, &(pd->u.cyVal) );
break;
case( VT_R8 ):
res = VarCyFromR8( ps->u.dblVal, &(pd->u.cyVal) );
break;
case( VT_DATE ):
res = VarCyFromDate( ps->u.date, &(pd->u.cyVal) );
break;
case( VT_BOOL ):
res = VarCyFromBool( ps->u.date, &(pd->u.cyVal) );
break;
case( VT_CY ):
res = VariantCopy( pd, ps );
break;
case( VT_BSTR ):
/*res = VarCyFromStr32( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cyVal) );*/
case( VT_DISPATCH ):
/*res = VarCyFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
case( VT_UNKNOWN ):
/*res = VarCyFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
case( VT_DECIMAL ):
/*res = VarCyFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
break;
default:
res = DISP_E_TYPEMISMATCH;
FIXME(ole,"Coercion from %d to %d\n", vtFrom, vt );
break;
}
return res;
}
/******************************************************************************
* ValidateVtRange [INTERNAL]
*
* Used internally by the hi-level Variant API to determine
* if the vartypes are valid.
*/
static HRESULT WINAPI ValidateVtRange( VARTYPE vt )
{
/* if by value we must make sure it is in the
* range of the valid types.
*/
if( ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
{
return DISP_E_BADVARTYPE;
}
return S_OK;
}
/******************************************************************************
* ValidateVartype [INTERNAL]
*
* Used internally by the hi-level Variant API to determine
* if the vartypes are valid.
*/
static HRESULT WINAPI ValidateVariantType( VARTYPE vt )
{
HRESULT res = S_OK;
/* check if we have a valid argument.
*/
if( vt & VT_BYREF )
{
/* if by reference check that the type is in
* the valid range and that it is not of empty or null type
*/
if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
( vt & VT_TYPEMASK ) == VT_NULL ||
( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
{
res = E_INVALIDARG;
}
}
else
{
res = ValidateVtRange( vt );
}
return res;
}
/******************************************************************************
* ValidateVt [INTERNAL]
*
* Used internally by the hi-level Variant API to determine
* if the vartypes are valid.
*/
static HRESULT WINAPI ValidateVt( VARTYPE vt )
{
HRESULT res = S_OK;
/* check if we have a valid argument.
*/
if( vt & VT_BYREF )
{
/* if by reference check that the type is in
* the valid range and that it is not of empty or null type
*/
if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
( vt & VT_TYPEMASK ) == VT_NULL ||
( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
{
res = DISP_E_BADVARTYPE;
}
}
else
{
res = ValidateVtRange( vt );
}
return res;
}
/******************************************************************************
* VariantInit32 [OLEAUT32.8]
*
* Initializes the Variant. Unlike VariantClear it does not interpret the current
* contents of the Variant.
*/
void WINAPI VariantInit(VARIANTARG* pvarg)
{
TRACE(ole,"(%p),stub\n",pvarg);
memset(pvarg, 0, sizeof (VARIANTARG));
pvarg->vt = VT_EMPTY;
return;
}
/******************************************************************************
* VariantClear32 [OLEAUT32.9]
*
* This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
* sets the wReservedX field to 0. The current contents of the VARIANT are
* freed. If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
* released. If VT_ARRAY the array is freed.
*/
HRESULT WINAPI VariantClear(VARIANTARG* pvarg)
{
HRESULT res = S_OK;
TRACE(ole,"(%p)\n",pvarg);
res = ValidateVariantType( pvarg->vt );
if( res == S_OK )
{
if( !( pvarg->vt & VT_BYREF ) )
{
/*
* The VT_ARRAY flag is a special case of a safe array.
*/
if ( (pvarg->vt & VT_ARRAY) != 0)
{
SafeArrayDestroy(pvarg->u.parray);
}
else
{
switch( pvarg->vt & VT_TYPEMASK )
{
case( VT_BSTR ):
SysFreeString( pvarg->u.bstrVal );
break;
case( VT_DISPATCH ):
break;
case( VT_VARIANT ):
break;
case( VT_UNKNOWN ):
break;
case( VT_SAFEARRAY ):
SafeArrayDestroy(pvarg->u.parray);
break;
default:
break;
}
}
}
/*
* Empty all the fields and mark the type as empty.
*/
memset(pvarg, 0, sizeof (VARIANTARG));
pvarg->vt = VT_EMPTY;
}
return res;
}
/******************************************************************************
* VariantCopy32 [OLEAUT32.10]
*
* Frees up the designation variant and makes a copy of the source.
*/
HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
{
HRESULT res = S_OK;
TRACE(ole,"(%p, %p)\n", pvargDest, pvargSrc);
res = ValidateVariantType( pvargSrc->vt );
/* If the pointer are to the same variant we don't need
* to do anything.
*/
if( pvargDest != pvargSrc && res == S_OK )
{
res = VariantClear( pvargDest );
if( res == S_OK )
{
if( pvargSrc->vt & VT_BYREF )
{
/* In the case of byreference we only need
* to copy the pointer.
*/
pvargDest->u = pvargSrc->u;
pvargDest->vt = pvargSrc->vt;
}
else
{
/*
* The VT_ARRAY flag is another way to designate a safe array.
*/
if (pvargSrc->vt & VT_ARRAY)
{
SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray);
}
else
{
/* In the case of by value we need to
* copy the actuall value. In the case of
* VT_BSTR a copy of the string is made,
* if VT_DISPATCH or VT_IUNKNOWN AddReff is
* called to increment the object's reference count.
*/
switch( pvargSrc->vt & VT_TYPEMASK )
{
case( VT_BSTR ):
pvargDest->u.bstrVal = SysAllocString( pvargSrc->u.bstrVal );
break;
case( VT_DISPATCH ):
break;
case( VT_VARIANT ):
break;
case( VT_UNKNOWN ):
break;
case( VT_SAFEARRAY ):
SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray);
break;
default:
pvargDest->u = pvargSrc->u;
break;
}
}
pvargDest->vt = pvargSrc->vt;
}
}
}
return res;
}
/******************************************************************************
* VariantCopyInd32 [OLEAUT32.11]
*
* Frees up the destination variant and makes a copy of the source. If
* the source is of type VT_BYREF it performs the necessary indirections.
*/
HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
{
HRESULT res = S_OK;
TRACE(ole,"(%p, %p)\n", pvargDest, pvargSrc);
res = ValidateVariantType( pvargSrc->vt );
if( res != S_OK )
return res;
if( pvargSrc->vt & VT_BYREF )
{
VARIANTARG varg;
VariantInit( &varg );
/* handle the in place copy.
*/
if( pvargDest == pvargSrc )
{
/* we will use a copy of the source instead.
*/
res = VariantCopy( &varg, pvargSrc );
pvargSrc = &varg;
}
if( res == S_OK )
{
res = VariantClear( pvargDest );
if( res == S_OK )
{
/*
* The VT_ARRAY flag is another way to designate a safearray variant.
*/
if ( pvargSrc->vt & VT_ARRAY)
{
SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray);
}
else
{
/* In the case of by reference we need
* to copy the date pointed to by the variant.
*/
/* Get the variant type.
*/
switch( pvargSrc->vt & VT_TYPEMASK )
{
case( VT_BSTR ):
pvargDest->u.bstrVal = SysAllocString( *(pvargSrc->u.pbstrVal) );
break;
case( VT_DISPATCH ):
break;
case( VT_VARIANT ):
{
/* Prevent from cycling. According to tests on
* VariantCopyInd in Windows and the documentation
* this API dereferences the inner Variants to only one depth.
* If the inner Variant itself contains an
* other inner variant the E_INVALIDARG error is
* returned.
*/
if( pvargSrc->wReserved1 & PROCESSING_INNER_VARIANT )
{
/* If we get here we are attempting to deference
* an inner variant that that is itself contained
* in an inner variant so report E_INVALIDARG error.
*/
res = E_INVALIDARG;
}
else
{
/* Set the processing inner variant flag.
* We will set this flag in the inner variant
* that will be passed to the VariantCopyInd function.
*/
(pvargSrc->u.pvarVal)->wReserved1 |= PROCESSING_INNER_VARIANT;
/* Dereference the inner variant.
*/
res = VariantCopyInd( pvargDest, pvargSrc->u.pvarVal );
}
}
break;
case( VT_UNKNOWN ):
break;
case( VT_SAFEARRAY ):
SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray);
break;
default:
/* This is a by reference Variant which means that the union
* part of the Variant contains a pointer to some data of
* type "pvargSrc->vt & VT_TYPEMASK".
* We will deference this data in a generic fashion using
* the void pointer "Variant.u.byref".
* We will copy this data into the union of the destination
* Variant.
*/
memcpy( &pvargDest->u, pvargSrc->u.byref, SizeOfVariantData( pvargSrc ) );
break;
}
}
pvargDest->vt = pvargSrc->vt & VT_TYPEMASK;
}
}
/* this should not fail.
*/
VariantClear( &varg );
}
else
{
res = VariantCopy( pvargDest, pvargSrc );
}
return res;
}
/******************************************************************************
* VariantChangeType32 [OLEAUT32.12]
*/
HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
USHORT wFlags, VARTYPE vt)
{
return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
}
/******************************************************************************
* VariantChangeTypeEx32 [OLEAUT32.147]
*/
HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
LCID lcid, USHORT wFlags, VARTYPE vt)
{
HRESULT res = S_OK;
VARIANTARG varg;
VariantInit( &varg );
TRACE(ole,"(%p, %p, %ld, %u, %u),stub\n", pvargDest, pvargSrc, lcid, wFlags, vt);
/* validate our source argument.
*/
res = ValidateVariantType( pvargSrc->vt );
/* validate the vartype.
*/
if( res == S_OK )
{
res = ValidateVt( vt );
}
/* if we are doing an in-place conversion make a copy of the source.
*/
if( res == S_OK && pvargDest == pvargSrc )
{
res = VariantCopy( &varg, pvargSrc );
pvargSrc = &varg;
}
if( res == S_OK )
{
/* free up the destination variant.
*/
res = VariantClear( pvargDest );
}
if( res == S_OK )
{
if( pvargSrc->vt & VT_BYREF )
{
/* Convert the source variant to a "byvalue" variant.
*/
VARIANTARG Variant;
VariantInit( &Variant );
res = VariantCopyInd( &Variant, pvargSrc );
if( res == S_OK )
{
res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
/* this should not fail.
*/
VariantClear( &Variant );
}
}
else
{
/* Use the current "byvalue" source variant.
*/
res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
}
}
/* this should not fail.
*/
VariantClear( &varg );
/* set the type of the destination
*/
if ( res == S_OK )
pvargDest->vt = vt;
return res;
}
/******************************************************************************
* VarUI1FromI232 [OLEAUT32.130]
*/
HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut)
{
TRACE( ole, "( %d, %p ), stub\n", sIn, pbOut );
/* Check range of value.
*/
if( sIn < UI1_MIN || sIn > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) sIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromI432 [OLEAUT32.131]
*/
HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut)
{
TRACE( ole, "( %ld, %p ), stub\n", lIn, pbOut );
/* Check range of value.
*/
if( lIn < UI1_MIN || lIn > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) lIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromR432 [OLEAUT32.132]
*/
HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, pbOut );
/* Check range of value.
*/
fltIn = round( fltIn );
if( fltIn < UI1_MIN || fltIn > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) fltIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromR832 [OLEAUT32.133]
*/
HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, pbOut );
/* Check range of value.
*/
dblIn = round( dblIn );
if( dblIn < UI1_MIN || dblIn > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) dblIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromDate32 [OLEAUT32.135]
*/
HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, pbOut );
/* Check range of value.
*/
dateIn = round( dateIn );
if( dateIn < UI1_MIN || dateIn > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) dateIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromBool32 [OLEAUT32.138]
*/
HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, pbOut );
*pbOut = (BYTE) boolIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromI132 [OLEAUT32.237]
*/
HRESULT WINAPI VarUI1FromI1(CHAR cIn, BYTE* pbOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, pbOut );
*pbOut = cIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromUI232 [OLEAUT32.238]
*/
HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pbOut );
/* Check range of value.
*/
if( uiIn > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) uiIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromUI432 [OLEAUT32.239]
*/
HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
{
TRACE( ole, "( %ld, %p ), stub\n", ulIn, pbOut );
/* Check range of value.
*/
if( ulIn > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) ulIn;
return S_OK;
}
/******************************************************************************
* VarUI1FromStr32 [OLEAUT32.54]
*/
HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0 , pNewString );
/* Check range of value.
*/
dValue = round( dValue );
if( dValue < UI1_MIN || dValue > UI1_MAX )
{
return DISP_E_OVERFLOW;
}
*pbOut = (BYTE) dValue;
return S_OK;
}
/**********************************************************************
* VarUI1FromCy32 [OLEAUT32.134]
* Convert currency to unsigned char
*/
HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
*pbOut = (BYTE)t;
return S_OK;
}
/******************************************************************************
* VarI2FromUI132 [OLEAUT32.48]
*/
HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut)
{
TRACE( ole, "( 0x%08x, %p ), stub\n", bIn, psOut );
*psOut = (short) bIn;
return S_OK;
}
/******************************************************************************
* VarI2FromI432 [OLEAUT32.49]
*/
HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut)
{
TRACE( ole, "( %lx, %p ), stub\n", lIn, psOut );
/* Check range of value.
*/
if( lIn < I2_MIN || lIn > I2_MAX )
{
return DISP_E_OVERFLOW;
}
*psOut = (short) lIn;
return S_OK;
}
/******************************************************************************
* VarI2FromR432 [OLEAUT32.50]
*/
HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, psOut );
/* Check range of value.
*/
fltIn = round( fltIn );
if( fltIn < I2_MIN || fltIn > I2_MAX )
{
return DISP_E_OVERFLOW;
}
*psOut = (short) fltIn;
return S_OK;
}
/******************************************************************************
* VarI2FromR832 [OLEAUT32.51]
*/
HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, psOut );
/* Check range of value.
*/
dblIn = round( dblIn );
if( dblIn < I2_MIN || dblIn > I2_MAX )
{
return DISP_E_OVERFLOW;
}
*psOut = (short) dblIn;
return S_OK;
}
/******************************************************************************
* VarI2FromDate32 [OLEAUT32.53]
*/
HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, psOut );
/* Check range of value.
*/
dateIn = round( dateIn );
if( dateIn < I2_MIN || dateIn > I2_MAX )
{
return DISP_E_OVERFLOW;
}
*psOut = (short) dateIn;
return S_OK;
}
/******************************************************************************
* VarI2FromBool32 [OLEAUT32.56]
*/
HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, psOut );
*psOut = (short) boolIn;
return S_OK;
}
/******************************************************************************
* VarI2FromI132 [OLEAUT32.48]
*/
HRESULT WINAPI VarI2FromI1(CHAR cIn, short* psOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, psOut );
*psOut = (short) cIn;
return S_OK;
}
/******************************************************************************
* VarI2FromUI232 [OLEAUT32.206]
*/
HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, psOut );
/* Check range of value.
*/
if( uiIn > I2_MAX )
{
return DISP_E_OVERFLOW;
}
*psOut = (short) uiIn;
return S_OK;
}
/******************************************************************************
* VarI2FromUI432 [OLEAUT32.49]
*/
HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
{
TRACE( ole, "( %lx, %p ), stub\n", ulIn, psOut );
/* Check range of value.
*/
if( ulIn < I2_MIN || ulIn > I2_MAX )
{
return DISP_E_OVERFLOW;
}
*psOut = (short) ulIn;
return S_OK;
}
/******************************************************************************
* VarI2FromStr32 [OLEAUT32.54]
*/
HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, psOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0, pNewString );
/* Check range of value.
*/
dValue = round( dValue );
if( dValue < I2_MIN || dValue > I2_MAX )
{
return DISP_E_OVERFLOW;
}
*psOut = (short) dValue;
return S_OK;
}
/**********************************************************************
* VarI2FromCy32 [OLEAUT32.52]
* Convert currency to signed short
*/
HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
*psOut = (SHORT)t;
return S_OK;
}
/******************************************************************************
* VarI4FromUI132 [OLEAUT32.58]
*/
HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut)
{
TRACE( ole, "( %X, %p ), stub\n", bIn, plOut );
*plOut = (LONG) bIn;
return S_OK;
}
/******************************************************************************
* VarI4FromR432 [OLEAUT32.60]
*/
HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, plOut );
/* Check range of value.
*/
fltIn = round( fltIn );
if( fltIn < I4_MIN || fltIn > I4_MAX )
{
return DISP_E_OVERFLOW;
}
*plOut = (LONG) fltIn;
return S_OK;
}
/******************************************************************************
* VarI4FromR832 [OLEAUT32.61]
*/
HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, plOut );
/* Check range of value.
*/
dblIn = round( dblIn );
if( dblIn < I4_MIN || dblIn > I4_MAX )
{
return DISP_E_OVERFLOW;
}
*plOut = (LONG) dblIn;
return S_OK;
}
/******************************************************************************
* VarI4FromDate32 [OLEAUT32.63]
*/
HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, plOut );
/* Check range of value.
*/
dateIn = round( dateIn );
if( dateIn < I4_MIN || dateIn > I4_MAX )
{
return DISP_E_OVERFLOW;
}
*plOut = (LONG) dateIn;
return S_OK;
}
/******************************************************************************
* VarI4FromBool32 [OLEAUT32.66]
*/
HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, plOut );
*plOut = (LONG) boolIn;
return S_OK;
}
/******************************************************************************
* VarI4FromI132 [OLEAUT32.209]
*/
HRESULT WINAPI VarI4FromI1(CHAR cIn, LONG* plOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, plOut );
*plOut = (LONG) cIn;
return S_OK;
}
/******************************************************************************
* VarI4FromUI232 [OLEAUT32.210]
*/
HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, plOut );
*plOut = (LONG) uiIn;
return S_OK;
}
/******************************************************************************
* VarI4FromUI432 [OLEAUT32.211]
*/
HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut)
{
TRACE( ole, "( %lx, %p ), stub\n", ulIn, plOut );
/* Check range of value.
*/
if( ulIn < I4_MIN || ulIn > I4_MAX )
{
return DISP_E_OVERFLOW;
}
*plOut = (LONG) ulIn;
return S_OK;
}
/******************************************************************************
* VarI4FromI232 [OLEAUT32.59]
*/
HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut)
{
TRACE( ole, "( %d, %p ), stub\n", sIn, plOut );
*plOut = (LONG) sIn;
return S_OK;
}
/******************************************************************************
* VarI4FromStr32 [OLEAUT32.64]
*/
HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0, pNewString );
/* Check range of value.
*/
dValue = round( dValue );
if( dValue < I4_MIN || dValue > I4_MAX )
{
return DISP_E_OVERFLOW;
}
*plOut = (LONG) dValue;
return S_OK;
}
/**********************************************************************
* VarI4FromCy32 [OLEAUT32.62]
* Convert currency to signed long
*/
HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
*plOut = (LONG)t;
return S_OK;
}
/******************************************************************************
* VarR4FromUI132 [OLEAUT32.68]
*/
HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut)
{
TRACE( ole, "( %X, %p ), stub\n", bIn, pfltOut );
*pfltOut = (FLOAT) bIn;
return S_OK;
}
/******************************************************************************
* VarR4FromI232 [OLEAUT32.69]
*/
HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut)
{
TRACE( ole, "( %d, %p ), stub\n", sIn, pfltOut );
*pfltOut = (FLOAT) sIn;
return S_OK;
}
/******************************************************************************
* VarR4FromI432 [OLEAUT32.70]
*/
HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut)
{
TRACE( ole, "( %lx, %p ), stub\n", lIn, pfltOut );
*pfltOut = (FLOAT) lIn;
return S_OK;
}
/******************************************************************************
* VarR4FromR832 [OLEAUT32.71]
*/
HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, pfltOut );
/* Check range of value.
*/
if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
{
return DISP_E_OVERFLOW;
}
*pfltOut = (FLOAT) dblIn;
return S_OK;
}
/******************************************************************************
* VarR4FromDate32 [OLEAUT32.73]
*/
HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, pfltOut );
/* Check range of value.
*/
if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
{
return DISP_E_OVERFLOW;
}
*pfltOut = (FLOAT) dateIn;
return S_OK;
}
/******************************************************************************
* VarR4FromBool32 [OLEAUT32.76]
*/
HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, pfltOut );
*pfltOut = (FLOAT) boolIn;
return S_OK;
}
/******************************************************************************
* VarR4FromI132 [OLEAUT32.213]
*/
HRESULT WINAPI VarR4FromI1(CHAR cIn, FLOAT* pfltOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, pfltOut );
*pfltOut = (FLOAT) cIn;
return S_OK;
}
/******************************************************************************
* VarR4FromUI232 [OLEAUT32.214]
*/
HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pfltOut );
*pfltOut = (FLOAT) uiIn;
return S_OK;
}
/******************************************************************************
* VarR4FromUI432 [OLEAUT32.215]
*/
HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut)
{
TRACE( ole, "( %ld, %p ), stub\n", ulIn, pfltOut );
*pfltOut = (FLOAT) ulIn;
return S_OK;
}
/******************************************************************************
* VarR4FromStr32 [OLEAUT32.74]
*/
HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0, pNewString );
/* Check range of value.
*/
if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
{
return DISP_E_OVERFLOW;
}
*pfltOut = (FLOAT) dValue;
return S_OK;
}
/**********************************************************************
* VarR4FromCy32 [OLEAUT32.72]
* Convert currency to float
*/
HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
*pfltOut = (FLOAT)((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
return S_OK;
}
/******************************************************************************
* VarR8FromUI132 [OLEAUT32.68]
*/
HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
{
TRACE( ole, "( %d, %p ), stub\n", bIn, pdblOut );
*pdblOut = (double) bIn;
return S_OK;
}
/******************************************************************************
* VarR8FromI232 [OLEAUT32.69]
*/
HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
{
TRACE( ole, "( %d, %p ), stub\n", sIn, pdblOut );
*pdblOut = (double) sIn;
return S_OK;
}
/******************************************************************************
* VarR8FromI432 [OLEAUT32.70]
*/
HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
{
TRACE( ole, "( %ld, %p ), stub\n", lIn, pdblOut );
*pdblOut = (double) lIn;
return S_OK;
}
/******************************************************************************
* VarR8FromR432 [OLEAUT32.81]
*/
HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, pdblOut );
*pdblOut = (double) fltIn;
return S_OK;
}
/******************************************************************************
* VarR8FromDate32 [OLEAUT32.83]
*/
HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, pdblOut );
*pdblOut = (double) dateIn;
return S_OK;
}
/******************************************************************************
* VarR8FromBool32 [OLEAUT32.86]
*/
HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, pdblOut );
*pdblOut = (double) boolIn;
return S_OK;
}
/******************************************************************************
* VarR8FromI132 [OLEAUT32.217]
*/
HRESULT WINAPI VarR8FromI1(CHAR cIn, double* pdblOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, pdblOut );
*pdblOut = (double) cIn;
return S_OK;
}
/******************************************************************************
* VarR8FromUI232 [OLEAUT32.218]
*/
HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pdblOut );
*pdblOut = (double) uiIn;
return S_OK;
}
/******************************************************************************
* VarR8FromUI432 [OLEAUT32.219]
*/
HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut)
{
TRACE( ole, "( %ld, %p ), stub\n", ulIn, pdblOut );
*pdblOut = (double) ulIn;
return S_OK;
}
/******************************************************************************
* VarR8FromStr32 [OLEAUT32.84]
*/
HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pdblOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0, pNewString );
*pdblOut = dValue;
return S_OK;
}
/**********************************************************************
* VarR8FromCy32 [OLEAUT32.82]
* Convert currency to double
*/
HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
*pdblOut = (double)((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
return S_OK;
}
/******************************************************************************
* VarDateFromUI132 [OLEAUT32.]
*/
HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
{
TRACE( ole, "( %d, %p ), stub\n", bIn, pdateOut );
*pdateOut = (DATE) bIn;
return S_OK;
}
/******************************************************************************
* VarDateFromI232 [OLEAUT32.222]
*/
HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
{
TRACE( ole, "( %d, %p ), stub\n", sIn, pdateOut );
*pdateOut = (DATE) sIn;
return S_OK;
}
/******************************************************************************
* VarDateFromI432 [OLEAUT32.90]
*/
HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
{
TRACE( ole, "( %ld, %p ), stub\n", lIn, pdateOut );
if( lIn < DATE_MIN || lIn > DATE_MAX )
{
return DISP_E_OVERFLOW;
}
*pdateOut = (DATE) lIn;
return S_OK;
}
/******************************************************************************
* VarDateFromR432 [OLEAUT32.91]
*/
HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, pdateOut );
if( ceil(fltIn) < DATE_MIN || floor(fltIn) > DATE_MAX )
{
return DISP_E_OVERFLOW;
}
*pdateOut = (DATE) fltIn;
return S_OK;
}
/******************************************************************************
* VarDateFromR832 [OLEAUT32.92]
*/
HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, pdateOut );
if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
{
return DISP_E_OVERFLOW;
}
*pdateOut = (DATE) dblIn;
return S_OK;
}
/******************************************************************************
* VarDateFromStr32 [OLEAUT32.94]
* The string representing the date is composed of two parts, a date and time.
*
* The format of the time is has follows:
* hh[:mm][:ss][AM|PM]
* Whitespace can be inserted anywhere between these tokens. A whitespace consists
* of space and/or tab characters, which are ignored.
*
* The formats for the date part are has follows:
* mm/[dd/][yy]yy
* [dd/]mm/[yy]yy
* [yy]yy/mm/dd
* January dd[,] [yy]yy
* dd January [yy]yy
* [yy]yy January dd
* Whitespace can be inserted anywhere between these tokens.
*
* The formats for the date and time string are has follows.
* date[whitespace][time]
* [time][whitespace]date
*
* These are the only characters allowed in a string representing a date and time:
* [A-Z] [a-z] [0-9] ':' '-' '/' ',' ' ' '\t'
*/
HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
{
HRESULT ret = S_OK;
struct tm TM = { 0,0,0,0,0,0,0,0,0 };
TRACE( ole, "( %p, %lx, %lx, %p ), stub\n", strIn, lcid, dwFlags, pdateOut );
if( DateTimeStringToTm( strIn, lcid, &TM ) )
{
if( TmToDATE( &TM, pdateOut ) == FALSE )
{
ret = E_INVALIDARG;
}
}
else
{
ret = DISP_E_TYPEMISMATCH;
}
return ret;
}
/******************************************************************************
* VarDateFromI132 [OLEAUT32.221]
*/
HRESULT WINAPI VarDateFromI1(CHAR cIn, DATE* pdateOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, pdateOut );
*pdateOut = (DATE) cIn;
return S_OK;
}
/******************************************************************************
* VarDateFromUI232 [OLEAUT32.222]
*/
HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pdateOut );
if( uiIn > DATE_MAX )
{
return DISP_E_OVERFLOW;
}
*pdateOut = (DATE) uiIn;
return S_OK;
}
/******************************************************************************
* VarDateFromUI432 [OLEAUT32.223]
*/
HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
{
TRACE( ole, "( %ld, %p ), stub\n", ulIn, pdateOut );
if( ulIn < DATE_MIN || ulIn > DATE_MAX )
{
return DISP_E_OVERFLOW;
}
*pdateOut = (DATE) ulIn;
return S_OK;
}
/******************************************************************************
* VarDateFromBool32 [OLEAUT32.96]
*/
HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, pdateOut );
*pdateOut = (DATE) boolIn;
return S_OK;
}
/**********************************************************************
* VarDateFromCy32 [OLEAUT32.93]
* Convert currency to date
*/
HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut) {
*pdateOut = (DATE)((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
if (*pdateOut > DATE_MAX || *pdateOut < DATE_MIN) return DISP_E_TYPEMISMATCH;
return S_OK;
}
/******************************************************************************
* VarBstrFromUI132 [OLEAUT32.108]
*/
HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%d", bVal );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromI232 [OLEAUT32.109]
*/
HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%d", iVal );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromI432 [OLEAUT32.110]
*/
HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%ld", lIn );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromR432 [OLEAUT32.111]
*/
HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%.7g", fltIn );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromR832 [OLEAUT32.112]
*/
HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%.15g", dblIn );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromDate32 [OLEAUT32.114]
*
* The date is implemented using an 8 byte floating-point number.
* Days are represented by whole numbers increments starting with 0.00 has
* being December 30 1899, midnight.
* The hours are expressed as the fractional part of the number.
* December 30 1899 at midnight = 0.00
* January 1 1900 at midnight = 2.00
* January 4 1900 at 6 AM = 5.25
* January 4 1900 at noon = 5.50
* December 29 1899 at midnight = -1.00
* December 18 1899 at midnight = -12.00
* December 18 1899 at 6AM = -12.25
* December 18 1899 at 6PM = -12.75
* December 19 1899 at midnight = -11.00
* The tm structure is as follows:
* struct tm {
* int tm_sec; seconds after the minute - [0,59]
* int tm_min; minutes after the hour - [0,59]
* int tm_hour; hours since midnight - [0,23]
* int tm_mday; day of the month - [1,31]
* int tm_mon; months since January - [0,11]
* int tm_year; years
* int tm_wday; days since Sunday - [0,6]
* int tm_yday; days since January 1 - [0,365]
* int tm_isdst; daylight savings time flag
* };
*/
HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
struct tm TM = {0,0,0,0,0,0,0,0,0};
TRACE( ole, "( %f, %ld, %ld, %p ), stub\n", dateIn, lcid, dwFlags, pbstrOut );
if( DateToTm( dateIn, lcid, &TM ) == FALSE )
{
return E_INVALIDARG;
}
if( lcid & VAR_DATEVALUEONLY )
strftime( pBuffer, BUFFER_MAX, "%x", &TM );
else if( lcid & VAR_TIMEVALUEONLY )
strftime( pBuffer, BUFFER_MAX, "%X", &TM );
else
strftime( pBuffer, BUFFER_MAX, "%x %X", &TM );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromBool32 [OLEAUT32.116]
*/
HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
if( boolIn == VARIANT_FALSE )
{
sprintf( pBuffer, "False" );
}
else
{
sprintf( pBuffer, "True" );
}
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromI132 [OLEAUT32.229]
*/
HRESULT WINAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%d", cIn );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromUI232 [OLEAUT32.230]
*/
HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%d", uiIn );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBstrFromUI432 [OLEAUT32.231]
*/
HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
{
TRACE( ole, "( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
sprintf( pBuffer, "%ld", ulIn );
*pbstrOut = StringDupAtoBstr( pBuffer );
return S_OK;
}
/******************************************************************************
* VarBoolFromUI132 [OLEAUT32.118]
*/
HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %d, %p ), stub\n", bIn, pboolOut );
if( bIn == 0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromI232 [OLEAUT32.119]
*/
HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %d, %p ), stub\n", sIn, pboolOut );
if( sIn == 0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromI432 [OLEAUT32.120]
*/
HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %ld, %p ), stub\n", lIn, pboolOut );
if( lIn == 0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromR432 [OLEAUT32.121]
*/
HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, pboolOut );
if( fltIn == 0.0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromR832 [OLEAUT32.122]
*/
HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, pboolOut );
if( dblIn == 0.0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromDate32 [OLEAUT32.123]
*/
HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, pboolOut );
if( dateIn == 0.0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromStr32 [OLEAUT32.125]
*/
HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
{
HRESULT ret = S_OK;
char* pNewString = NULL;
TRACE( ole, "( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
if( pNewString == NULL || strlen( pNewString ) == 0 )
{
ret = DISP_E_TYPEMISMATCH;
}
if( ret == S_OK )
{
if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
{
*pboolOut = VARIANT_TRUE;
}
else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
/* Try converting the string to a floating point number.
*/
double dValue = 0.0;
HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
if( res != S_OK )
{
ret = DISP_E_TYPEMISMATCH;
}
else if( dValue == 0.0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
}
}
HeapFree( GetProcessHeap(), 0, pNewString );
return ret;
}
/******************************************************************************
* VarBoolFromI132 [OLEAUT32.233]
*/
HRESULT WINAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, pboolOut );
if( cIn == 0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromUI232 [OLEAUT32.234]
*/
HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pboolOut );
if( uiIn == 0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/******************************************************************************
* VarBoolFromUI432 [OLEAUT32.235]
*/
HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
{
TRACE( ole, "( %ld, %p ), stub\n", ulIn, pboolOut );
if( ulIn == 0 )
{
*pboolOut = VARIANT_FALSE;
}
else
{
*pboolOut = VARIANT_TRUE;
}
return S_OK;
}
/**********************************************************************
* VarBoolFromCy32 [OLEAUT32.124]
* Convert currency to boolean
*/
HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) {
if (cyIn.u.Hi || cyIn.u.Lo) *pboolOut = -1;
else *pboolOut = 0;
return S_OK;
}
/******************************************************************************
* VarI1FromUI132 [OLEAUT32.244]
*/
HRESULT WINAPI VarI1FromUI1(BYTE bIn, CHAR* pcOut)
{
TRACE( ole, "( %d, %p ), stub\n", bIn, pcOut );
/* Check range of value.
*/
if( bIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) bIn;
return S_OK;
}
/******************************************************************************
* VarI1FromI232 [OLEAUT32.245]
*/
HRESULT WINAPI VarI1FromI2(short uiIn, CHAR* pcOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pcOut );
if( uiIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) uiIn;
return S_OK;
}
/******************************************************************************
* VarI1FromI432 [OLEAUT32.246]
*/
HRESULT WINAPI VarI1FromI4(LONG lIn, CHAR* pcOut)
{
TRACE( ole, "( %ld, %p ), stub\n", lIn, pcOut );
if( lIn < CHAR_MIN || lIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) lIn;
return S_OK;
}
/******************************************************************************
* VarI1FromR432 [OLEAUT32.247]
*/
HRESULT WINAPI VarI1FromR4(FLOAT fltIn, CHAR* pcOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, pcOut );
fltIn = round( fltIn );
if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) fltIn;
return S_OK;
}
/******************************************************************************
* VarI1FromR832 [OLEAUT32.248]
*/
HRESULT WINAPI VarI1FromR8(double dblIn, CHAR* pcOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, pcOut );
dblIn = round( dblIn );
if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) dblIn;
return S_OK;
}
/******************************************************************************
* VarI1FromDate32 [OLEAUT32.249]
*/
HRESULT WINAPI VarI1FromDate(DATE dateIn, CHAR* pcOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, pcOut );
dateIn = round( dateIn );
if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) dateIn;
return S_OK;
}
/******************************************************************************
* VarI1FromStr32 [OLEAUT32.251]
*/
HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CHAR* pcOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0, pNewString );
/* Check range of value.
*/
dValue = round( dValue );
if( dValue < CHAR_MIN || dValue > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) dValue;
return S_OK;
}
/******************************************************************************
* VarI1FromBool32 [OLEAUT32.253]
*/
HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR* pcOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, pcOut );
*pcOut = (CHAR) boolIn;
return S_OK;
}
/******************************************************************************
* VarI1FromUI232 [OLEAUT32.254]
*/
HRESULT WINAPI VarI1FromUI2(USHORT uiIn, CHAR* pcOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pcOut );
if( uiIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) uiIn;
return S_OK;
}
/******************************************************************************
* VarI1FromUI432 [OLEAUT32.255]
*/
HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut)
{
TRACE( ole, "( %ld, %p ), stub\n", ulIn, pcOut );
if( ulIn > CHAR_MAX )
{
return DISP_E_OVERFLOW;
}
*pcOut = (CHAR) ulIn;
return S_OK;
}
/**********************************************************************
* VarI1FromCy32 [OLEAUT32.250]
* Convert currency to signed char
*/
HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
*pcOut = (CHAR)t;
return S_OK;
}
/******************************************************************************
* VarUI2FromUI132 [OLEAUT32.257]
*/
HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
{
TRACE( ole, "( %d, %p ), stub\n", bIn, puiOut );
*puiOut = (USHORT) bIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromI232 [OLEAUT32.258]
*/
HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, puiOut );
if( uiIn < UI2_MIN )
{
return DISP_E_OVERFLOW;
}
*puiOut = (USHORT) uiIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromI432 [OLEAUT32.259]
*/
HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
{
TRACE( ole, "( %ld, %p ), stub\n", lIn, puiOut );
if( lIn < UI2_MIN || lIn > UI2_MAX )
{
return DISP_E_OVERFLOW;
}
*puiOut = (USHORT) lIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromR432 [OLEAUT32.260]
*/
HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
{
TRACE( ole, "( %f, %p ), stub\n", fltIn, puiOut );
fltIn = round( fltIn );
if( fltIn < UI2_MIN || fltIn > UI2_MAX )
{
return DISP_E_OVERFLOW;
}
*puiOut = (USHORT) fltIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromR832 [OLEAUT32.261]
*/
HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, puiOut );
dblIn = round( dblIn );
if( dblIn < UI2_MIN || dblIn > UI2_MAX )
{
return DISP_E_OVERFLOW;
}
*puiOut = (USHORT) dblIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromDate32 [OLEAUT32.262]
*/
HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, puiOut );
dateIn = round( dateIn );
if( dateIn < UI2_MIN || dateIn > UI2_MAX )
{
return DISP_E_OVERFLOW;
}
*puiOut = (USHORT) dateIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromStr32 [OLEAUT32.264]
*/
HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0, pNewString );
/* Check range of value.
*/
dValue = round( dValue );
if( dValue < UI2_MIN || dValue > UI2_MAX )
{
return DISP_E_OVERFLOW;
}
*puiOut = (USHORT) dValue;
return S_OK;
}
/******************************************************************************
* VarUI2FromBool32 [OLEAUT32.266]
*/
HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, puiOut );
*puiOut = (USHORT) boolIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromI132 [OLEAUT32.267]
*/
HRESULT WINAPI VarUI2FromI1(CHAR cIn, USHORT* puiOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, puiOut );
*puiOut = (USHORT) cIn;
return S_OK;
}
/******************************************************************************
* VarUI2FromUI432 [OLEAUT32.268]
*/
HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
{
TRACE( ole, "( %ld, %p ), stub\n", ulIn, puiOut );
if( ulIn < UI2_MIN || ulIn > UI2_MAX )
{
return DISP_E_OVERFLOW;
}
*puiOut = (USHORT) ulIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromStr32 [OLEAUT32.277]
*/
HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
{
double dValue = 0.0;
LPSTR pNewString = NULL;
TRACE( ole, "( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
/* Check if we have a valid argument
*/
pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
RemoveCharacterFromString( pNewString, "," );
if( IsValidRealString( pNewString ) == FALSE )
{
return DISP_E_TYPEMISMATCH;
}
/* Convert the valid string to a floating point number.
*/
dValue = atof( pNewString );
/* We don't need the string anymore so free it.
*/
HeapFree( GetProcessHeap(), 0, pNewString );
/* Check range of value.
*/
dValue = round( dValue );
if( dValue < UI4_MIN || dValue > UI4_MAX )
{
return DISP_E_OVERFLOW;
}
*pulOut = (ULONG) dValue;
return S_OK;
}
/**********************************************************************
* VarUI2FromCy32 [OLEAUT32.263]
* Convert currency to unsigned short
*/
HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
*pusOut = (USHORT)t;
return S_OK;
}
/******************************************************************************
* VarUI4FromUI132 [OLEAUT32.270]
*/
HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
{
TRACE( ole, "( %d, %p ), stub\n", bIn, pulOut );
*pulOut = (USHORT) bIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromI232 [OLEAUT32.271]
*/
HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pulOut );
if( uiIn < UI4_MIN )
{
return DISP_E_OVERFLOW;
}
*pulOut = (ULONG) uiIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromI432 [OLEAUT32.272]
*/
HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
{
TRACE( ole, "( %ld, %p ), stub\n", lIn, pulOut );
if( lIn < UI4_MIN )
{
return DISP_E_OVERFLOW;
}
*pulOut = (ULONG) lIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromR432 [OLEAUT32.273]
*/
HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
{
fltIn = round( fltIn );
if( fltIn < UI4_MIN || fltIn > UI4_MAX )
{
return DISP_E_OVERFLOW;
}
*pulOut = (ULONG) fltIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromR832 [OLEAUT32.274]
*/
HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
{
TRACE( ole, "( %f, %p ), stub\n", dblIn, pulOut );
dblIn = round( dblIn );
if( dblIn < UI4_MIN || dblIn > UI4_MAX )
{
return DISP_E_OVERFLOW;
}
*pulOut = (ULONG) dblIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromDate32 [OLEAUT32.275]
*/
HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
{
TRACE( ole, "( %f, %p ), stub\n", dateIn, pulOut );
dateIn = round( dateIn );
if( dateIn < UI4_MIN || dateIn > UI4_MAX )
{
return DISP_E_OVERFLOW;
}
*pulOut = (ULONG) dateIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromBool32 [OLEAUT32.279]
*/
HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
{
TRACE( ole, "( %d, %p ), stub\n", boolIn, pulOut );
*pulOut = (ULONG) boolIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromI132 [OLEAUT32.280]
*/
HRESULT WINAPI VarUI4FromI1(CHAR cIn, ULONG* pulOut)
{
TRACE( ole, "( %c, %p ), stub\n", cIn, pulOut );
*pulOut = (ULONG) cIn;
return S_OK;
}
/******************************************************************************
* VarUI4FromUI232 [OLEAUT32.281]
*/
HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
{
TRACE( ole, "( %d, %p ), stub\n", uiIn, pulOut );
*pulOut = (ULONG) uiIn;
return S_OK;
}
/**********************************************************************
* VarUI4FromCy32 [OLEAUT32.276]
* Convert currency to unsigned long
*/
HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
*pulOut = (ULONG)t;
return S_OK;
}
/**********************************************************************
* VarCyFromUI132 [OLEAUT32.98]
* Convert unsigned char to currency
*/
HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
pcyOut->u.Hi = 0;
pcyOut->u.Lo = ((ULONG)bIn) * 10000;
return S_OK;
}
/**********************************************************************
* VarCyFromI232 [OLEAUT32.99]
* Convert signed short to currency
*/
HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
if (sIn < 0) pcyOut->u.Hi = -1;
else pcyOut->u.Hi = 0;
pcyOut->u.Lo = ((ULONG)sIn) * 10000;
return S_OK;
}
/**********************************************************************
* VarCyFromI432 [OLEAUT32.100]
* Convert signed long to currency
*/
HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
double t = (double)lIn * (double)10000;
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (lIn < 0) pcyOut->u.Hi--;
return S_OK;
}
/**********************************************************************
* VarCyFromR432 [OLEAUT32.101]
* Convert float to currency
*/
HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
double t = round((double)fltIn * (double)10000);
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (fltIn < 0) pcyOut->u.Hi--;
return S_OK;
}
/**********************************************************************
* VarCyFromR832 [OLEAUT32.102]
* Convert double to currency
*/
HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
double t = round(dblIn * (double)10000);
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (dblIn < 0) pcyOut->u.Hi--;
return S_OK;
}
/**********************************************************************
* VarCyFromDate32 [OLEAUT32.103]
* Convert date to currency
*/
HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
double t = round((double)dateIn * (double)10000);
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (dateIn < 0) pcyOut->u.Hi--;
return S_OK;
}
/**********************************************************************
* VarCyFromBool32 [OLEAUT32.106]
* Convert boolean to currency
*/
HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
if (boolIn < 0) pcyOut->u.Hi = -1;
else pcyOut->u.Hi = 0;
pcyOut->u.Lo = (ULONG)boolIn * (ULONG)10000;
return S_OK;
}
/**********************************************************************
* VarCyFromI132 [OLEAUT32.225]
* Convert signed char to currency
*/
HRESULT WINAPI VarCyFromI1(CHAR cIn, CY* pcyOut) {
if (cIn < 0) pcyOut->u.Hi = -1;
else pcyOut->u.Hi = 0;
pcyOut->u.Lo = (ULONG)cIn * (ULONG)10000;
return S_OK;
}
/**********************************************************************
* VarCyFromUI232 [OLEAUT32.226]
* Convert unsigned short to currency
*/
HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
pcyOut->u.Hi = 0;
pcyOut->u.Lo = (ULONG)usIn * (ULONG)10000;
return S_OK;
}
/**********************************************************************
* VarCyFromUI432 [OLEAUT32.227]
* Convert unsigned long to currency
*/
HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) {
double t = (double)ulIn * (double)10000;
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
return S_OK;
}
/**********************************************************************
* DosDateTimeToVariantTime [OLEAUT32.14]
* Convert dos representation of time to the date and time representation
* stored in a variant.
*/
INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
DATE *pvtime)
{
struct tm t;
TRACE( ole, "( 0x%x, 0x%x, 0x%p ), stub\n", wDosDate, wDosTime, pvtime );
t.tm_sec = (wDosTime & 0x001f) * 2;
t.tm_min = (wDosTime & 0x07e0) >> 5;
t.tm_hour = (wDosTime & 0xf800) >> 11;
t.tm_mday = (wDosDate & 0x001f);
t.tm_mon = (wDosDate & 0x01e0) >> 5;
t.tm_year = ((wDosDate & 0xfe00) >> 9) + 1980;
return TmToDATE( &t, pvtime );
}
Reference in New Issue View Git Blame Copy Permalink