/* * VARIANT * * Copyright 1998 Jean-Claude Cote * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * 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 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 dates prior to 1900. * - The parsing does not accept as many formats as the Windows implementation. */ #include "config.h" #include #include #include #include #include #ifdef HAVE_FLOAT_H # include #endif #include "windef.h" #include "oleauto.h" #include "heap.h" #include "wine/debug.h" #include "winerror.h" #include "parsedt.h" #include "typelib.h" WINE_DEFAULT_DEBUG_CHANNEL(ole); #define SYSDUPSTRING(str) SysAllocStringLen((str), SysStringLen(str)) #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. */ /* * Use 365 days/year and a manual calculation for leap year days * to keep arithmetic simple */ static const double DAYS_IN_ONE_YEAR = 365.0; /* * Token definitions for Varient Formatting * Worked out by experimentation on a w2k machine. Doesnt appear to be * documented anywhere obviously so keeping definitions internally * */ /* Pre defined tokens */ #define TOK_COPY 0x00 #define TOK_END 0x02 #define LARGEST_TOKENID 6 /* Mapping of token name to id put into the tokenized form Note testing on W2K shows aaaa and oooo are not parsed??!! */ #define TOK_COLON 0x03 #define TOK_SLASH 0x04 #define TOK_c 0x05 #define TOK_d 0x08 #define TOK_dd 0x09 #define TOK_ddd 0x0a #define TOK_dddd 0x0b #define TOK_ddddd 0x0c #define TOK_dddddd 0x0d #define TOK_w 0x0f #define TOK_ww 0x10 #define TOK_m 0x11 #define TOK_mm 0x12 #define TOK_mmm 0x13 #define TOK_mmmm 0x14 #define TOK_q 0x06 #define TOK_y 0x15 #define TOK_yy 0x16 #define TOK_yyyy 0x18 #define TOK_h 0x1e #define TOK_Hh 0x1f #define TOK_N 0x1a #define TOK_Nn 0x1b #define TOK_S 0x1c #define TOK_Ss 0x1d #define TOK_ttttt 0x07 #define TOK_AMsPM 0x2f #define TOK_amspm 0x32 #define TOK_AsP 0x30 #define TOK_asp 0x33 #define TOK_AMPM 0x2e typedef struct tagFORMATTOKEN { char *str; BYTE tokenSize; BYTE tokenId; int varTypeRequired; } FORMATTOKEN; typedef struct tagFORMATHDR { BYTE len; BYTE hex3; BYTE hex6; BYTE reserved[8]; } FORMATHDR; FORMATTOKEN formatTokens[] = { /* FIXME: Only date formats so far */ {":" , 1, TOK_COLON , 0}, {"/" , 1, TOK_SLASH , 0}, {"c" , 1, TOK_c , VT_DATE}, {"dddddd", 6, TOK_dddddd , VT_DATE}, {"ddddd" , 5, TOK_ddddd , VT_DATE}, {"dddd" , 4, TOK_dddd , VT_DATE}, {"ddd" , 3, TOK_ddd , VT_DATE}, {"dd" , 2, TOK_dd , VT_DATE}, {"d" , 1, TOK_d , VT_DATE}, {"ww" , 2, TOK_ww , VT_DATE}, {"w" , 1, TOK_w , VT_DATE}, {"mmmm" , 4, TOK_mmmm , VT_DATE}, {"mmm" , 3, TOK_mmm , VT_DATE}, {"mm" , 2, TOK_mm , VT_DATE}, {"m" , 1, TOK_m , VT_DATE}, {"q" , 1, TOK_q , VT_DATE}, {"yyyy" , 4, TOK_yyyy , VT_DATE}, {"yy" , 2, TOK_yy , VT_DATE}, {"y" , 1, TOK_y , VT_DATE}, {"h" , 1, TOK_h , VT_DATE}, {"Hh" , 2, TOK_Hh , VT_DATE}, {"Nn" , 2, TOK_Nn , VT_DATE}, {"N" , 1, TOK_N , VT_DATE}, {"S" , 1, TOK_S , VT_DATE}, {"Ss" , 2, TOK_Ss , VT_DATE}, {"ttttt" , 5, TOK_ttttt , VT_DATE}, {"AM/PM" , 5, TOK_AMsPM , VT_DATE}, {"am/pm" , 5, TOK_amspm , VT_DATE}, {"A/P" , 3, TOK_AsP , VT_DATE}, {"a/p" , 3, TOK_asp , VT_DATE}, {"AMPM" , 4, TOK_AMPM , VT_DATE}, {0x00 , 0, 0 , VT_NULL} }; /****************************************************************************** * 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 successful. * * 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, DWORD dwFlags, 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( dwFlags & 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( dwFlags & 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 successful. */ static BOOL TmToDATE( struct tm* pTm, DATE *pDateOut ) { int leapYear = 0; /* Hmmm... An uninitialized Date in VB is December 30 1899 so Start at 0. This is the way DATE is defined. */ /* 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; if( (pTm->tm_year - 1900) >= 0 ) { /* 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. * Copied + reversed functionality into TmToDate */ *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. (remember tm_mon is 0..11) */ switch( pTm->tm_mon ) { case 1: *pDateOut += 31; break; case 2: *pDateOut += ( 59 + leapYear ); break; case 3: *pDateOut += ( 90 + leapYear ); break; case 4: *pDateOut += ( 120 + leapYear ); break; case 5: *pDateOut += ( 151 + leapYear ); break; case 6: *pDateOut += ( 181 + leapYear ); break; case 7: *pDateOut += ( 212 + leapYear ); break; case 8: *pDateOut += ( 243 + leapYear ); break; case 9: *pDateOut += ( 273 + leapYear ); break; case 10: *pDateOut += ( 304 + leapYear ); break; case 11: *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. */ } else { *pDateOut = 0; } *pDateOut += pTm->tm_hour / 24.0; *pDateOut += pTm->tm_min / 1440.0; *pDateOut += pTm->tm_sec / 86400.0; return TRUE; } /****************************************************************************** * DateToTm [INTERNAL] * * This function converts 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 successful. */ BOOL DateToTm( DATE dateIn, DWORD dwFlags, struct tm* pTm ) { double decimalPart = 0.0; double wholePart = 0.0; memset(pTm,0,sizeof(*pTm)); /* Because of the nature of DATE format which * 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 simplifies the processing of the DATE value. */ decimalPart = fmod( dateIn, 1.0 ); /* Do this before the -1, otherwise 0.xx goes negative */ dateIn -= 1.0; wholePart = (double) floor( dateIn ); if( !(dwFlags & VAR_TIMEVALUEONLY) ) { unsigned int nDay = 0; int leapYear = 0; double yearsSince1900 = 0; /* Hard code dates smaller than January 1, 1900. */ if( dateIn < 2.0 ) { pTm->tm_year = 1899; pTm->tm_mon = 11; /* December as tm_mon is 0..11 */ if( dateIn < 1.0 ) { pTm->tm_mday = 30; dateIn = dateIn * -1.0; /* Ensure +ve for time calculation */ decimalPart = decimalPart * -1.0; /* Ensure +ve for time calculation */ } else { pTm->tm_mday = 31; } } else { /* Start at 1900, this is 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) + 0.001 ); pTm->tm_year += yearsSince1900; /* determine if this is a leap year. */ if( isleap( pTm->tm_year ) ) { leapYear = 1; wholePart++; } /* find what day of that year the "wholePart" corresponds to. * Note: nDay is in [1-366] format */ nDay = (((unsigned int) wholePart) - ((pTm->tm_year-1900) * DAYS_IN_ONE_YEAR )); /* Remove 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. * Copied + reversed functionality from TmToDate */ nDay -= ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 ); nDay += ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 ); nDay -= ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 ); /* Set the tm_yday value. * Note: The day must be converted from [1-366] to [0-365] */ /*pTm->tm_yday = nDay - 1;*/ /* find which month 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( !(dwFlags & VAR_DATEVALUEONLY) ) { /* find the number of seconds in this day. * fractional part times, hours, minutes, seconds. * Note: 0.1 is hack to ensure figures come out in whole numbers * due to floating point inaccuracies */ pTm->tm_hour = (int) ( decimalPart * 24 ); pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 ); /* Note: 0.1 is hack to ensure seconds come out in whole numbers due to floating point inaccuracies */ pTm->tm_sec = (int) (( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 ) + 0.1); } return TRUE; } /****************************************************************************** * 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( V_VT(parg) & 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 ): case( VT_DISPATCH ): case( VT_UNKNOWN ): size = sizeof(void*); break; case( VT_CY ): size = sizeof(CY); break; case( VT_DECIMAL ): /* hmm, tricky, DECIMAL is only VT_BYREF */ default: FIXME("Add size information for type vt=%d\n", V_VT(parg) & 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 rnd( 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 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. * * FIXME: Passing down dwFlags to the conversion functions is wrong, this * is a different flagmask. Check MSDN. */ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt ) { HRESULT res = S_OK; unsigned short vtFrom = 0; vtFrom = V_VT(ps) & 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 their unsigned versions. */ /* Trivial Case: If the coercion is from two types that are * identical then we can blindly copy from one argument to another.*/ if ((vt==vtFrom)) { return VariantCopy(pd,ps); } /* Cases requiring thought*/ switch( vt ) { case( VT_EMPTY ): res = VariantClear( pd ); break; case( VT_NULL ): res = VariantClear( pd ); if( res == S_OK ) { V_VT(pd) = VT_NULL; } break; case( VT_I1 ): switch( vtFrom ) { case( VT_I1 ): res = VariantCopy( pd, ps ); break; case( VT_I2 ): res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) ); break; case( VT_INT ): case( VT_I4 ): res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) ); break; case( VT_UI1 ): res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) ); break; case( VT_UI2 ): res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) ); break; case( VT_UINT ): case( VT_UI4 ): res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) ); break; case( VT_R4 ): res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) ); break; case( VT_R8 ): res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) ); break; case( VT_DATE ): res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) ); break; case( VT_BOOL ): res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) ); break; case( VT_BSTR ): res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) ); break; case( VT_CY ): res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) ); break; case( VT_DISPATCH ): /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/ case( VT_DECIMAL ): /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_I2 ): switch( vtFrom ) { case( VT_I1 ): res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) ); break; case( VT_I2 ): res = VariantCopy( pd, ps ); break; case( VT_INT ): case( VT_I4 ): res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) ); break; case( VT_UI1 ): res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) ); break; case( VT_UI2 ): res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) ); break; case( VT_UINT ): case( VT_UI4 ): res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) ); break; case( VT_R4 ): res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) ); break; case( VT_R8 ): res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) ); break; case( VT_DATE ): res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) ); break; case( VT_BOOL ): res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) ); break; case( VT_BSTR ): res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) ); break; case( VT_CY ): res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) ); break; case( VT_DISPATCH ): /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/ case( VT_DECIMAL ): /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_INT ): case( VT_I4 ): switch( vtFrom ) { case( VT_EMPTY ): V_UNION(pd,lVal) = 0; res = S_OK; break; case( VT_I1 ): res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) ); break; case( VT_I2 ): res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) ); break; case( VT_INT ): case( VT_I4 ): #ifdef __WIN32OS2__ case( VT_HRESULT ): #endif res = VariantCopy( pd, ps ); break; case( VT_UI1 ): res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) ); break; case( VT_UI2 ): res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) ); break; case( VT_UINT ): case( VT_UI4 ): res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) ); break; case( VT_R4 ): res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) ); break; case( VT_R8 ): res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) ); break; case( VT_DATE ): res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) ); break; case( VT_BOOL ): res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) ); break; case( VT_BSTR ): res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) ); break; case( VT_CY ): res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) ); break; case( VT_DISPATCH ): /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/ case( VT_DECIMAL ): /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_UI1 ): switch( vtFrom ) { case( VT_I1 ): res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) ); break; case( VT_I2 ): res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) ); break; case( VT_INT ): case( VT_I4 ): res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) ); break; case( VT_UI1 ): res = VariantCopy( pd, ps ); break; case( VT_UI2 ): res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) ); break; case( VT_UINT ): case( VT_UI4 ): res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) ); break; case( VT_R4 ): res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) ); break; case( VT_R8 ): res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) ); break; case( VT_DATE ): res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) ); break; case( VT_BOOL ): res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) ); break; case( VT_BSTR ): res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) ); break; case( VT_CY ): res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) ); break; case( VT_DISPATCH ): /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/ case( VT_DECIMAL ): /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_UI2 ): switch( vtFrom ) { case( VT_I1 ): res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) ); break; case( VT_I2 ): res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) ); break; case( VT_INT ): case( VT_I4 ): res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) ); break; case( VT_UI1 ): res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) ); break; case( VT_UI2 ): res = VariantCopy( pd, ps ); break; case( VT_UINT ): case( VT_UI4 ): res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) ); break; case( VT_R4 ): res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) ); break; case( VT_R8 ): res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) ); break; case( VT_DATE ): res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) ); break; case( VT_BOOL ): res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) ); break; case( VT_BSTR ): res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) ); break; case( VT_CY ): res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) ); break; case( VT_DISPATCH ): /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/ case( VT_DECIMAL ): /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_UINT ): case( VT_UI4 ): switch( vtFrom ) { case( VT_I1 ): res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) ); break; case( VT_I2 ): res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) ); break; case( VT_INT ): case( VT_I4 ): res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) ); break; case( VT_UI1 ): res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) ); break; case( VT_UI2 ): res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) ); break; case( VT_UI4 ): res = VariantCopy( pd, ps ); break; case( VT_R4 ): res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) ); break; case( VT_R8 ): res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) ); break; case( VT_DATE ): res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) ); break; case( VT_BOOL ): res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) ); break; case( VT_BSTR ): res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) ); break; case( VT_CY ): res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) ); break; case( VT_DISPATCH ): /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/ case( VT_DECIMAL ): /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_R4 ): switch( vtFrom ) { case( VT_I1 ): res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) ); break; case( VT_I2 ): res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) ); break; case( VT_INT ): case( VT_I4 ): res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) ); break; case( VT_UI1 ): res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) ); break; case( VT_UI2 ): res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) ); break; case( VT_UINT ): case( VT_UI4 ): res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) ); break; case( VT_R4 ): res = VariantCopy( pd, ps ); break; case( VT_R8 ): res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) ); break; case( VT_DATE ): res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) ); break; case( VT_BOOL ): res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) ); break; case( VT_BSTR ): res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) ); break; case( VT_CY ): res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) ); break; case( VT_DISPATCH ): /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/ case( VT_DECIMAL ): /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_R8 ): switch( vtFrom ) { case( VT_I1 ): res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) ); break; case( VT_I2 ): res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) ); break; case( VT_INT ): case( VT_I4 ): res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) ); break; case( VT_UI1 ): res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) ); break; case( VT_UI2 ): res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) ); break; case( VT_UINT ): case( VT_UI4 ): res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) ); break; case( VT_R4 ): res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) ); break; case( VT_R8 ): res = VariantCopy( pd, ps ); break; case( VT_DATE ): res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) ); break; case( VT_BOOL ): res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) ); break; case( VT_BSTR ): res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) ); break; case( VT_CY ): res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) ); break; case( VT_DISPATCH ): /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/ case( VT_DECIMAL ): /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_DATE ): switch( vtFrom ) { case( VT_I1 ): res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) ); break; case( VT_I2 ): res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) ); break; case( VT_INT ): res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) ); break; case( VT_I4 ): res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) ); break; case( VT_UI1 ): res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) ); break; case( VT_UI2 ): res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) ); break; case( VT_UINT ): res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) ); break; case( VT_UI4 ): res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) ); break; case( VT_R4 ): res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) ); break; case( VT_R8 ): res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) ); break; case( VT_DATE ): res = VariantCopy( pd, ps ); break; case( VT_BOOL ): res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) ); break; case( VT_BSTR ): res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) ); break; case( VT_CY ): res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) ); break; case( VT_DISPATCH ): /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/ case( VT_DECIMAL ): /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_BOOL ): switch( vtFrom ) { case( VT_EMPTY ): res = S_OK; V_UNION(pd,boolVal) = VARIANT_FALSE; break; case( VT_I1 ): res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) ); break; case( VT_I2 ): res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) ); break; case( VT_INT ): res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) ); break; case( VT_I4 ): res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) ); break; case( VT_UI1 ): res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) ); break; case( VT_UI2 ): res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) ); break; case( VT_UINT ): res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) ); break; case( VT_UI4 ): res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) ); break; case( VT_R4 ): res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) ); break; case( VT_R8 ): res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) ); break; case( VT_DATE ): res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) ); break; case( VT_BOOL ): res = VariantCopy( pd, ps ); break; case( VT_BSTR ): res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) ); break; case( VT_CY ): res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) ); break; case( VT_DISPATCH ): /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/ case( VT_DECIMAL ): /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_BSTR ): switch( vtFrom ) { case( VT_EMPTY ): if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0))) res = S_OK; else res = E_OUTOFMEMORY; break; case( VT_I1 ): res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_I2 ): res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_INT ): res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_I4 ): res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UI1 ): res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UI2 ): res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UINT ): res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UI4 ): res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_R4 ): res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_R8 ): res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_DATE ): res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_BOOL ): res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_BSTR ): res = VariantCopy( pd, ps ); break; case( VT_CY ): res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_DISPATCH ): /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/ case( VT_DECIMAL ): /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_CY ): switch( vtFrom ) { case( VT_I1 ): res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) ); break; case( VT_I2 ): res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) ); break; case( VT_INT ): res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) ); break; case( VT_I4 ): res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) ); break; case( VT_UI1 ): res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) ); break; case( VT_UI2 ): res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) ); break; case( VT_UINT ): res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) ); break; case( VT_UI4 ): res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) ); break; case( VT_R4 ): res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) ); break; case( VT_R8 ): res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) ); break; case( VT_DATE ): res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) ); break; case( VT_BOOL ): res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) ); break; case( VT_CY ): res = VariantCopy( pd, ps ); break; case( VT_BSTR ): res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) ); break; case( VT_DISPATCH ): /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/ case( VT_DECIMAL ): /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/ break; case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); break; } break; case( VT_UNKNOWN ): if (vtFrom == VT_DISPATCH) { res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd)); } else { res = DISP_E_TYPEMISMATCH; FIXME("Coercion from %d to %d\n", vtFrom, vt ); } break; default: res = DISP_E_TYPEMISMATCH; FIXME("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 = DISP_E_BADVARTYPE; } } 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; } /****************************************************************************** * VariantInit [OLEAUT32.8] * * Initializes the Variant. Unlike VariantClear it does not interpret * the current contents of the Variant. */ void WINAPI VariantInit(VARIANTARG* pvarg) { TRACE("(%p)\n",pvarg); memset(pvarg, 0, sizeof (VARIANTARG)); V_VT(pvarg) = VT_EMPTY; return; } /****************************************************************************** * VariantClear [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("(%p)\n",pvarg); res = ValidateVariantType( V_VT(pvarg) ); if( res == S_OK ) { if( !( V_VT(pvarg) & VT_BYREF ) ) { /* * The VT_ARRAY flag is a special case of a safe array. */ if ( (V_VT(pvarg) & VT_ARRAY) != 0) { SafeArrayDestroy(V_UNION(pvarg,parray)); } else { switch( V_VT(pvarg) & VT_TYPEMASK ) { case( VT_BSTR ): SysFreeString( V_UNION(pvarg,bstrVal) ); break; case( VT_DISPATCH ): if(V_UNION(pvarg,pdispVal)!=NULL) ICOM_CALL(Release,V_UNION(pvarg,pdispVal)); break; case( VT_VARIANT ): VariantClear(V_UNION(pvarg,pvarVal)); break; case( VT_UNKNOWN ): if(V_UNION(pvarg,punkVal)!=NULL) ICOM_CALL(Release,V_UNION(pvarg,punkVal)); break; case( VT_SAFEARRAY ): SafeArrayDestroy(V_UNION(pvarg,parray)); break; default: break; } } } /* * Empty all the fields and mark the type as empty. */ memset(pvarg, 0, sizeof (VARIANTARG)); V_VT(pvarg) = VT_EMPTY; } return res; } /****************************************************************************** * VariantCopy [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("(%p, %p), vt=%d\n", pvargDest, pvargSrc, V_VT(pvargSrc)); res = ValidateVariantType( V_VT(pvargSrc) ); /* 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( V_VT(pvargSrc) & VT_BYREF ) { /* In the case of byreference we only need * to copy the pointer. */ pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3; V_VT(pvargDest) = V_VT(pvargSrc); } else { /* * The VT_ARRAY flag is another way to designate a safe array. */ if (V_VT(pvargSrc) & VT_ARRAY) { SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray)); } else { /* In the case of by value we need to * copy the actual value. In the case of * VT_BSTR a copy of the string is made, * if VT_DISPATCH or VT_IUNKNOWN AddRef is * called to increment the object's reference count. */ switch( V_VT(pvargSrc) & VT_TYPEMASK ) { case( VT_BSTR ): V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( V_UNION(pvargSrc,bstrVal) ); break; case( VT_DISPATCH ): V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal); if (V_UNION(pvargDest,pdispVal)!=NULL) ICOM_CALL(AddRef,V_UNION(pvargDest,pdispVal)); break; case( VT_VARIANT ): VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal)); break; case( VT_UNKNOWN ): V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal); if (V_UNION(pvargDest,pdispVal)!=NULL) ICOM_CALL(AddRef,V_UNION(pvargDest,punkVal)); break; case( VT_SAFEARRAY ): SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray)); break; default: pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3; break; } } V_VT(pvargDest) = V_VT(pvargSrc); } } } return res; } /****************************************************************************** * VariantCopyInd [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("(%p, %p)\n", pvargDest, pvargSrc); res = ValidateVariantType( V_VT(pvargSrc) ); if( res != S_OK ) return res; if( V_VT(pvargSrc) & 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 ( V_VT(pvargSrc) & VT_ARRAY) { SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray)); } else { /* In the case of by reference we need * to copy the date pointed to by the variant. */ /* Get the variant type. */ switch( V_VT(pvargSrc) & VT_TYPEMASK ) { case( VT_BSTR ): V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( *(V_UNION(pvargSrc,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->n1.n2.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. */ (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT; /* Dereference the inner variant. */ res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) ); /* We must also copy its type, I think. */ V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal)); } } break; case( VT_UNKNOWN ): break; case( VT_SAFEARRAY ): SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,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 "V_VT(pvargSrc) & 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->n1.n2.n3, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) ); break; } } if (res == S_OK) V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK; } } /* this should not fail. */ VariantClear( &varg ); } else { res = VariantCopy( pvargDest, pvargSrc ); } return res; } /****************************************************************************** * VariantChangeType [OLEAUT32.12] */ HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, USHORT wFlags, VARTYPE vt) { return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt ); } /****************************************************************************** * VariantChangeTypeEx [OLEAUT32.147] */ HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt) { HRESULT res = S_OK; VARIANTARG varg; VariantInit( &varg ); TRACE("(%p, %p, %ld, %u, %u) vt=%d\n", pvargDest, pvargSrc, lcid, wFlags, vt, V_VT(pvargSrc)); TRACE("Src Var:\n"); dump_Variant(pvargSrc); /* validate our source argument. */ res = ValidateVariantType( V_VT(pvargSrc) ); /* 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( V_VT(pvargSrc) & 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 ) V_VT(pvargDest) = vt; TRACE("Dest Var:\n"); dump_Variant(pvargDest); return res; } /****************************************************************************** * VarUI1FromI2 [OLEAUT32.130] */ HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut) { TRACE("( %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; } /****************************************************************************** * VarUI1FromI4 [OLEAUT32.131] */ HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut) { TRACE("( %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; } /****************************************************************************** * VarUI1FromR4 [OLEAUT32.132] */ HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut) { TRACE("( %f, %p ), stub\n", fltIn, pbOut ); /* Check range of value. */ fltIn = rnd( fltIn ); if( fltIn < UI1_MIN || fltIn > UI1_MAX ) { return DISP_E_OVERFLOW; } *pbOut = (BYTE) fltIn; return S_OK; } /****************************************************************************** * VarUI1FromR8 [OLEAUT32.133] */ HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut) { TRACE("( %f, %p ), stub\n", dblIn, pbOut ); /* Check range of value. */ dblIn = rnd( dblIn ); if( dblIn < UI1_MIN || dblIn > UI1_MAX ) { return DISP_E_OVERFLOW; } *pbOut = (BYTE) dblIn; return S_OK; } /****************************************************************************** * VarUI1FromDate [OLEAUT32.135] */ HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut) { TRACE("( %f, %p ), stub\n", dateIn, pbOut ); /* Check range of value. */ dateIn = rnd( dateIn ); if( dateIn < UI1_MIN || dateIn > UI1_MAX ) { return DISP_E_OVERFLOW; } *pbOut = (BYTE) dateIn; return S_OK; } /****************************************************************************** * VarUI1FromBool [OLEAUT32.138] */ HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut) { TRACE("( %d, %p ), stub\n", boolIn, pbOut ); *pbOut = (BYTE) boolIn; return S_OK; } /****************************************************************************** * VarUI1FromI1 [OLEAUT32.237] */ HRESULT WINAPI VarUI1FromI1(CHAR cIn, BYTE* pbOut) { TRACE("( %c, %p ), stub\n", cIn, pbOut ); *pbOut = cIn; return S_OK; } /****************************************************************************** * VarUI1FromUI2 [OLEAUT32.238] */ HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut) { TRACE("( %d, %p ), stub\n", uiIn, pbOut ); /* Check range of value. */ if( uiIn > UI1_MAX ) { return DISP_E_OVERFLOW; } *pbOut = (BYTE) uiIn; return S_OK; } /****************************************************************************** * VarUI1FromUI4 [OLEAUT32.239] */ HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut) { TRACE("( %ld, %p ), stub\n", ulIn, pbOut ); /* Check range of value. */ if( ulIn > UI1_MAX ) { return DISP_E_OVERFLOW; } *pbOut = (BYTE) ulIn; return S_OK; } /****************************************************************************** * VarUI1FromStr [OLEAUT32.136] */ HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut) { double dValue = 0.0; LPSTR pNewString = NULL; TRACE("( %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 = rnd( dValue ); if( dValue < UI1_MIN || dValue > UI1_MAX ) { return DISP_E_OVERFLOW; } *pbOut = (BYTE) dValue; return S_OK; } /********************************************************************** * VarUI1FromCy [OLEAUT32.134] * Convert currency to unsigned char */ HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) { double t = rnd((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW; *pbOut = (BYTE)t; return S_OK; } /****************************************************************************** * VarI2FromUI1 [OLEAUT32.48] */ HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut) { TRACE("( 0x%08x, %p ), stub\n", bIn, psOut ); *psOut = (short) bIn; return S_OK; } /****************************************************************************** * VarI2FromI4 [OLEAUT32.49] */ HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut) { TRACE("( %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; } /****************************************************************************** * VarI2FromR4 [OLEAUT32.50] */ HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut) { TRACE("( %f, %p ), stub\n", fltIn, psOut ); /* Check range of value. */ fltIn = rnd( fltIn ); if( fltIn < I2_MIN || fltIn > I2_MAX ) { return DISP_E_OVERFLOW; } *psOut = (short) fltIn; return S_OK; } /****************************************************************************** * VarI2FromR8 [OLEAUT32.51] */ HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut) { TRACE("( %f, %p ), stub\n", dblIn, psOut ); /* Check range of value. */ dblIn = rnd( dblIn ); if( dblIn < I2_MIN || dblIn > I2_MAX ) { return DISP_E_OVERFLOW; } *psOut = (short) dblIn; return S_OK; } /****************************************************************************** * VarI2FromDate [OLEAUT32.53] */ HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut) { TRACE("( %f, %p ), stub\n", dateIn, psOut ); /* Check range of value. */ dateIn = rnd( dateIn ); if( dateIn < I2_MIN || dateIn > I2_MAX ) { return DISP_E_OVERFLOW; } *psOut = (short) dateIn; return S_OK; } /****************************************************************************** * VarI2FromBool [OLEAUT32.56] */ HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut) { TRACE("( %d, %p ), stub\n", boolIn, psOut ); *psOut = (short) boolIn; return S_OK; } /****************************************************************************** * VarI2FromI1 [OLEAUT32.205] */ HRESULT WINAPI VarI2FromI1(CHAR cIn, short* psOut) { TRACE("( %c, %p ), stub\n", cIn, psOut ); *psOut = (short) cIn; return S_OK; } /****************************************************************************** * VarI2FromUI2 [OLEAUT32.206] */ HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut) { TRACE("( %d, %p ), stub\n", uiIn, psOut ); /* Check range of value. */ if( uiIn > I2_MAX ) { return DISP_E_OVERFLOW; } *psOut = (short) uiIn; return S_OK; } /****************************************************************************** * VarI2FromUI4 [OLEAUT32.207] */ HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut) { TRACE("( %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; } /****************************************************************************** * VarI2FromStr [OLEAUT32.54] */ HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut) { double dValue = 0.0; LPSTR pNewString = NULL; TRACE("( %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 = rnd( dValue ); if( dValue < I2_MIN || dValue > I2_MAX ) { return DISP_E_OVERFLOW; } *psOut = (short) dValue; return S_OK; } /********************************************************************** * VarI2FromCy [OLEAUT32.52] * Convert currency to signed short */ HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) { double t = rnd((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW; *psOut = (SHORT)t; return S_OK; } /****************************************************************************** * VarI4FromUI1 [OLEAUT32.58] */ HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut) { TRACE("( %X, %p ), stub\n", bIn, plOut ); *plOut = (LONG) bIn; return S_OK; } /****************************************************************************** * VarI4FromR4 [OLEAUT32.60] */ HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut) { TRACE("( %f, %p ), stub\n", fltIn, plOut ); /* Check range of value. */ fltIn = rnd( fltIn ); if( fltIn < I4_MIN || fltIn > I4_MAX ) { return DISP_E_OVERFLOW; } *plOut = (LONG) fltIn; return S_OK; } /****************************************************************************** * VarI4FromR8 [OLEAUT32.61] */ HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut) { TRACE("( %f, %p ), stub\n", dblIn, plOut ); /* Check range of value. */ dblIn = rnd( dblIn ); if( dblIn < I4_MIN || dblIn > I4_MAX ) { return DISP_E_OVERFLOW; } *plOut = (LONG) dblIn; return S_OK; } /****************************************************************************** * VarI4FromDate [OLEAUT32.63] */ HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut) { TRACE("( %f, %p ), stub\n", dateIn, plOut ); /* Check range of value. */ dateIn = rnd( dateIn ); if( dateIn < I4_MIN || dateIn > I4_MAX ) { return DISP_E_OVERFLOW; } *plOut = (LONG) dateIn; return S_OK; } /****************************************************************************** * VarI4FromBool [OLEAUT32.66] */ HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut) { TRACE("( %d, %p ), stub\n", boolIn, plOut ); *plOut = (LONG) boolIn; return S_OK; } /****************************************************************************** * VarI4FromI1 [OLEAUT32.209] */ HRESULT WINAPI VarI4FromI1(CHAR cIn, LONG* plOut) { TRACE("( %c, %p ), stub\n", cIn, plOut ); *plOut = (LONG) cIn; return S_OK; } /****************************************************************************** * VarI4FromUI2 [OLEAUT32.210] */ HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut) { TRACE("( %d, %p ), stub\n", uiIn, plOut ); *plOut = (LONG) uiIn; return S_OK; } /****************************************************************************** * VarI4FromUI4 [OLEAUT32.211] */ HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut) { TRACE("( %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; } /****************************************************************************** * VarI4FromI2 [OLEAUT32.59] */ HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut) { TRACE("( %d, %p ), stub\n", sIn, plOut ); *plOut = (LONG) sIn; return S_OK; } /****************************************************************************** * VarI4FromStr [OLEAUT32.64] */ HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut) { double dValue = 0.0; LPSTR pNewString = NULL; TRACE("( %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 = rnd( dValue ); if( dValue < I4_MIN || dValue > I4_MAX ) { return DISP_E_OVERFLOW; } *plOut = (LONG) dValue; return S_OK; } /********************************************************************** * VarI4FromCy [OLEAUT32.62] * Convert currency to signed long */ HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) { double t = rnd((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW; *plOut = (LONG)t; return S_OK; } /****************************************************************************** * VarR4FromUI1 [OLEAUT32.68] */ HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut) { TRACE("( %X, %p ), stub\n", bIn, pfltOut ); *pfltOut = (FLOAT) bIn; return S_OK; } /****************************************************************************** * VarR4FromI2 [OLEAUT32.69] */ HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut) { TRACE("( %d, %p ), stub\n", sIn, pfltOut ); *pfltOut = (FLOAT) sIn; return S_OK; } /****************************************************************************** * VarR4FromI4 [OLEAUT32.70] */ HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut) { TRACE("( %lx, %p ), stub\n", lIn, pfltOut ); *pfltOut = (FLOAT) lIn; return S_OK; } /****************************************************************************** * VarR4FromR8 [OLEAUT32.71] */ HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut) { TRACE("( %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; } /****************************************************************************** * VarR4FromDate [OLEAUT32.73] */ HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut) { TRACE("( %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; } /****************************************************************************** * VarR4FromBool [OLEAUT32.76] */ HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut) { TRACE("( %d, %p ), stub\n", boolIn, pfltOut ); *pfltOut = (FLOAT) boolIn; return S_OK; } /****************************************************************************** * VarR4FromI1 [OLEAUT32.213] */ HRESULT WINAPI VarR4FromI1(CHAR cIn, FLOAT* pfltOut) { TRACE("( %c, %p ), stub\n", cIn, pfltOut ); *pfltOut = (FLOAT) cIn; return S_OK; } /****************************************************************************** * VarR4FromUI2 [OLEAUT32.214] */ HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut) { TRACE("( %d, %p ), stub\n", uiIn, pfltOut ); *pfltOut = (FLOAT) uiIn; return S_OK; } /****************************************************************************** * VarR4FromUI4 [OLEAUT32.215] */ HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut) { TRACE("( %ld, %p ), stub\n", ulIn, pfltOut ); *pfltOut = (FLOAT) ulIn; return S_OK; } /****************************************************************************** * VarR4FromStr [OLEAUT32.74] */ HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut) { double dValue = 0.0; LPSTR pNewString = NULL; TRACE("( %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; } /********************************************************************** * VarR4FromCy [OLEAUT32.72] * Convert currency to float */ HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) { *pfltOut = (FLOAT)((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); return S_OK; } /****************************************************************************** * VarR8FromUI1 [OLEAUT32.78] */ HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut) { TRACE("( %d, %p ), stub\n", bIn, pdblOut ); *pdblOut = (double) bIn; return S_OK; } /****************************************************************************** * VarR8FromI2 [OLEAUT32.79] */ HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut) { TRACE("( %d, %p ), stub\n", sIn, pdblOut ); *pdblOut = (double) sIn; return S_OK; } /****************************************************************************** * VarR8FromI4 [OLEAUT32.80] */ HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut) { TRACE("( %ld, %p ), stub\n", lIn, pdblOut ); *pdblOut = (double) lIn; return S_OK; } /****************************************************************************** * VarR8FromR4 [OLEAUT32.81] */ HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut) { TRACE("( %f, %p ), stub\n", fltIn, pdblOut ); *pdblOut = (double) fltIn; return S_OK; } /****************************************************************************** * VarR8FromDate [OLEAUT32.83] */ HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut) { TRACE("( %f, %p ), stub\n", dateIn, pdblOut ); *pdblOut = (double) dateIn; return S_OK; } /****************************************************************************** * VarR8FromBool [OLEAUT32.86] */ HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut) { TRACE("( %d, %p ), stub\n", boolIn, pdblOut ); *pdblOut = (double) boolIn; return S_OK; } /****************************************************************************** * VarR8FromI1 [OLEAUT32.217] */ HRESULT WINAPI VarR8FromI1(CHAR cIn, double* pdblOut) { TRACE("( %c, %p ), stub\n", cIn, pdblOut ); *pdblOut = (double) cIn; return S_OK; } /****************************************************************************** * VarR8FromUI2 [OLEAUT32.218] */ HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut) { TRACE("( %d, %p ), stub\n", uiIn, pdblOut ); *pdblOut = (double) uiIn; return S_OK; } /****************************************************************************** * VarR8FromUI4 [OLEAUT32.219] */ HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut) { TRACE("( %ld, %p ), stub\n", ulIn, pdblOut ); *pdblOut = (double) ulIn; return S_OK; } /****************************************************************************** * VarR8FromStr [OLEAUT32.84] */ HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut) { double dValue = 0.0; LPSTR pNewString = NULL; pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn ); TRACE("( %s, %ld, %ld, %p ), stub\n", pNewString, lcid, dwFlags, pdblOut ); /* Check if we have a valid argument */ 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; } /********************************************************************** * VarR8FromCy [OLEAUT32.82] * Convert currency to double */ HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) { *pdblOut = (double)((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); TRACE("%lu %ld -> %f\n", cyIn.DUMMYSTRUCTNAME_DOT Hi, cyIn.DUMMYSTRUCTNAME_DOT Lo, *pdblOut); return S_OK; } /****************************************************************************** * VarDateFromUI1 [OLEAUT32.88] */ HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut) { TRACE("( %d, %p ), stub\n", bIn, pdateOut ); *pdateOut = (DATE) bIn; return S_OK; } /****************************************************************************** * VarDateFromI2 [OLEAUT32.89] */ HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut) { TRACE("( %d, %p ), stub\n", sIn, pdateOut ); *pdateOut = (DATE) sIn; return S_OK; } /****************************************************************************** * VarDateFromI4 [OLEAUT32.90] */ HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut) { TRACE("( %ld, %p ), stub\n", lIn, pdateOut ); if( lIn < DATE_MIN || lIn > DATE_MAX ) { return DISP_E_OVERFLOW; } *pdateOut = (DATE) lIn; return S_OK; } /****************************************************************************** * VarDateFromR4 [OLEAUT32.91] */ HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut) { TRACE("( %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; } /****************************************************************************** * VarDateFromR8 [OLEAUT32.92] */ HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut) { TRACE("( %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; } /****************************************************************************** * VarDateFromStr [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; memset( &TM, 0, sizeof(TM) ); TRACE("( %p, %lx, %lx, %p ), stub\n", strIn, lcid, dwFlags, pdateOut ); if( DateTimeStringToTm( strIn, dwFlags, &TM ) ) { if( TmToDATE( &TM, pdateOut ) == FALSE ) { ret = E_INVALIDARG; } } else { ret = DISP_E_TYPEMISMATCH; } TRACE("Return value %f\n", *pdateOut); return ret; } /****************************************************************************** * VarDateFromI1 [OLEAUT32.221] */ HRESULT WINAPI VarDateFromI1(CHAR cIn, DATE* pdateOut) { TRACE("( %c, %p ), stub\n", cIn, pdateOut ); *pdateOut = (DATE) cIn; return S_OK; } /****************************************************************************** * VarDateFromUI2 [OLEAUT32.222] */ HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut) { TRACE("( %d, %p ), stub\n", uiIn, pdateOut ); if( uiIn > DATE_MAX ) { return DISP_E_OVERFLOW; } *pdateOut = (DATE) uiIn; return S_OK; } /****************************************************************************** * VarDateFromUI4 [OLEAUT32.223] */ HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut) { TRACE("( %ld, %p ), stub\n", ulIn, pdateOut ); if( ulIn < DATE_MIN || ulIn > DATE_MAX ) { return DISP_E_OVERFLOW; } *pdateOut = (DATE) ulIn; return S_OK; } /****************************************************************************** * VarDateFromBool [OLEAUT32.96] */ HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut) { TRACE("( %d, %p ), stub\n", boolIn, pdateOut ); *pdateOut = (DATE) boolIn; return S_OK; } /********************************************************************** * VarDateFromCy [OLEAUT32.93] * Convert currency to date */ HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut) { *pdateOut = (DATE)((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); if (*pdateOut > DATE_MAX || *pdateOut < DATE_MIN) return DISP_E_TYPEMISMATCH; return S_OK; } /****************************************************************************** * VarBstrFromUI1 [OLEAUT32.108] */ HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%d", bVal ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromI2 [OLEAUT32.109] */ HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%d", iVal ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromI4 [OLEAUT32.110] */ HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%ld", lIn ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromR4 [OLEAUT32.111] */ HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%.7g", fltIn ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromR8 [OLEAUT32.112] */ HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%.15g", dblIn ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromCy [OLEAUT32.113] */ HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut) { HRESULT rc = S_OK; double curVal = 0.0; TRACE("([cyIn], %08lx, %08lx, %p), partial stub (no flags handled).\n", lcid, dwFlags, pbstrOut); /* Firstly get the currency in a double, then put it in a buffer */ rc = VarR8FromCy(cyIn, &curVal); if (rc == S_OK) { sprintf(pBuffer, "%g", curVal); *pbstrOut = StringDupAtoBstr( pBuffer ); } return rc; } /****************************************************************************** * VarBstrFromDate [OLEAUT32.114] * * The date is implemented using an 8 byte floating-point number. * Days are represented by whole numbers increments starting with 0.00 as * 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; memset( &TM, 0, sizeof(TM) ); TRACE("( %20.20f, %ld, %ld, %p ), stub\n", dateIn, lcid, dwFlags, pbstrOut ); if( DateToTm( dateIn, dwFlags, &TM ) == FALSE ) { return E_INVALIDARG; } if( dwFlags & VAR_DATEVALUEONLY ) strftime( pBuffer, BUFFER_MAX, "%x", &TM ); else if( dwFlags & VAR_TIMEVALUEONLY ) strftime( pBuffer, BUFFER_MAX, "%X", &TM ); else strftime( pBuffer, BUFFER_MAX, "%x %X", &TM ); TRACE("result: %s\n", pBuffer); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromBool [OLEAUT32.116] */ HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, (boolIn == VARIANT_FALSE) ? "False" : "True" ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromI1 [OLEAUT32.229] */ HRESULT WINAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%d", cIn ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromUI2 [OLEAUT32.230] */ HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%d", uiIn ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBstrFromUI4 [OLEAUT32.231] */ HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut) { TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut ); sprintf( pBuffer, "%ld", ulIn ); *pbstrOut = StringDupAtoBstr( pBuffer ); return S_OK; } /****************************************************************************** * VarBoolFromUI1 [OLEAUT32.118] */ HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut) { TRACE("( %d, %p ), stub\n", bIn, pboolOut ); if( bIn == 0 ) { *pboolOut = VARIANT_FALSE; } else { *pboolOut = VARIANT_TRUE; } return S_OK; } /****************************************************************************** * VarBoolFromI2 [OLEAUT32.119] */ HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut) { TRACE("( %d, %p ), stub\n", sIn, pboolOut ); *pboolOut = (sIn) ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } /****************************************************************************** * VarBoolFromI4 [OLEAUT32.120] */ HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut) { TRACE("( %ld, %p ), stub\n", lIn, pboolOut ); *pboolOut = (lIn) ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } /****************************************************************************** * VarBoolFromR4 [OLEAUT32.121] */ HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut) { TRACE("( %f, %p ), stub\n", fltIn, pboolOut ); *pboolOut = (fltIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE; return S_OK; } /****************************************************************************** * VarBoolFromR8 [OLEAUT32.122] */ HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut) { TRACE("( %f, %p ), stub\n", dblIn, pboolOut ); *pboolOut = (dblIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE; return S_OK; } /****************************************************************************** * VarBoolFromDate [OLEAUT32.123] */ HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut) { TRACE("( %f, %p ), stub\n", dateIn, pboolOut ); *pboolOut = (dateIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE; return S_OK; } /****************************************************************************** * VarBoolFromStr [OLEAUT32.125] */ HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut) { HRESULT ret = S_OK; char* pNewString = NULL; TRACE("( %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 *pboolOut = (dValue == 0.0) ? VARIANT_FALSE : VARIANT_TRUE; } } HeapFree( GetProcessHeap(), 0, pNewString ); return ret; } /****************************************************************************** * VarBoolFromI1 [OLEAUT32.233] */ HRESULT WINAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL* pboolOut) { TRACE("( %c, %p ), stub\n", cIn, pboolOut ); *pboolOut = (cIn == 0) ? VARIANT_FALSE : VARIANT_TRUE; return S_OK; } /****************************************************************************** * VarBoolFromUI2 [OLEAUT32.234] */ HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut) { TRACE("( %d, %p ), stub\n", uiIn, pboolOut ); *pboolOut = (uiIn == 0) ? VARIANT_FALSE : VARIANT_TRUE; return S_OK; } /****************************************************************************** * VarBoolFromUI4 [OLEAUT32.235] */ HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut) { TRACE("( %ld, %p ), stub\n", ulIn, pboolOut ); *pboolOut = (ulIn == 0) ? VARIANT_FALSE : VARIANT_TRUE; return S_OK; } /********************************************************************** * VarBoolFromCy [OLEAUT32.124] * Convert currency to boolean */ HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) { if (cyIn.DUMMYSTRUCTNAME_DOT Hi || cyIn.DUMMYSTRUCTNAME_DOT Lo) *pboolOut = -1; else *pboolOut = 0; return S_OK; } /****************************************************************************** * VarI1FromUI1 [OLEAUT32.244] */ HRESULT WINAPI VarI1FromUI1(BYTE bIn, CHAR* pcOut) { TRACE("( %d, %p ), stub\n", bIn, pcOut ); /* Check range of value. */ if( bIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) bIn; return S_OK; } /****************************************************************************** * VarI1FromI2 [OLEAUT32.245] */ HRESULT WINAPI VarI1FromI2(short uiIn, CHAR* pcOut) { TRACE("( %d, %p ), stub\n", uiIn, pcOut ); if( uiIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) uiIn; return S_OK; } /****************************************************************************** * VarI1FromI4 [OLEAUT32.246] */ HRESULT WINAPI VarI1FromI4(LONG lIn, CHAR* pcOut) { TRACE("( %ld, %p ), stub\n", lIn, pcOut ); if( lIn < CHAR_MIN || lIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) lIn; return S_OK; } /****************************************************************************** * VarI1FromR4 [OLEAUT32.247] */ HRESULT WINAPI VarI1FromR4(FLOAT fltIn, CHAR* pcOut) { TRACE("( %f, %p ), stub\n", fltIn, pcOut ); fltIn = rnd( fltIn ); if( fltIn < CHAR_MIN || fltIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) fltIn; return S_OK; } /****************************************************************************** * VarI1FromR8 [OLEAUT32.248] */ HRESULT WINAPI VarI1FromR8(double dblIn, CHAR* pcOut) { TRACE("( %f, %p ), stub\n", dblIn, pcOut ); dblIn = rnd( dblIn ); if( dblIn < CHAR_MIN || dblIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) dblIn; return S_OK; } /****************************************************************************** * VarI1FromDate [OLEAUT32.249] */ HRESULT WINAPI VarI1FromDate(DATE dateIn, CHAR* pcOut) { TRACE("( %f, %p ), stub\n", dateIn, pcOut ); dateIn = rnd( dateIn ); if( dateIn < CHAR_MIN || dateIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) dateIn; return S_OK; } /****************************************************************************** * VarI1FromStr [OLEAUT32.251] */ HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CHAR* pcOut) { double dValue = 0.0; LPSTR pNewString = NULL; TRACE("( %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 = rnd( dValue ); if( dValue < CHAR_MIN || dValue > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) dValue; return S_OK; } /****************************************************************************** * VarI1FromBool [OLEAUT32.253] */ HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR* pcOut) { TRACE("( %d, %p ), stub\n", boolIn, pcOut ); *pcOut = (CHAR) boolIn; return S_OK; } /****************************************************************************** * VarI1FromUI2 [OLEAUT32.254] */ HRESULT WINAPI VarI1FromUI2(USHORT uiIn, CHAR* pcOut) { TRACE("( %d, %p ), stub\n", uiIn, pcOut ); if( uiIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) uiIn; return S_OK; } /****************************************************************************** * VarI1FromUI4 [OLEAUT32.255] */ HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut) { TRACE("( %ld, %p ), stub\n", ulIn, pcOut ); if( ulIn > CHAR_MAX ) { return DISP_E_OVERFLOW; } *pcOut = (CHAR) ulIn; return S_OK; } /********************************************************************** * VarI1FromCy [OLEAUT32.250] * Convert currency to signed char */ HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) { double t = rnd((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW; *pcOut = (CHAR)t; return S_OK; } /****************************************************************************** * VarUI2FromUI1 [OLEAUT32.257] */ HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut) { TRACE("( %d, %p ), stub\n", bIn, puiOut ); *puiOut = (USHORT) bIn; return S_OK; } /****************************************************************************** * VarUI2FromI2 [OLEAUT32.258] */ HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut) { TRACE("( %d, %p ), stub\n", uiIn, puiOut ); if( uiIn < UI2_MIN ) { return DISP_E_OVERFLOW; } *puiOut = (USHORT) uiIn; return S_OK; } /****************************************************************************** * VarUI2FromI4 [OLEAUT32.259] */ HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut) { TRACE("( %ld, %p ), stub\n", lIn, puiOut ); if( lIn < UI2_MIN || lIn > UI2_MAX ) { return DISP_E_OVERFLOW; } *puiOut = (USHORT) lIn; return S_OK; } /****************************************************************************** * VarUI2FromR4 [OLEAUT32.260] */ HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut) { TRACE("( %f, %p ), stub\n", fltIn, puiOut ); fltIn = rnd( fltIn ); if( fltIn < UI2_MIN || fltIn > UI2_MAX ) { return DISP_E_OVERFLOW; } *puiOut = (USHORT) fltIn; return S_OK; } /****************************************************************************** * VarUI2FromR8 [OLEAUT32.261] */ HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut) { TRACE("( %f, %p ), stub\n", dblIn, puiOut ); dblIn = rnd( dblIn ); if( dblIn < UI2_MIN || dblIn > UI2_MAX ) { return DISP_E_OVERFLOW; } *puiOut = (USHORT) dblIn; return S_OK; } /****************************************************************************** * VarUI2FromDate [OLEAUT32.262] */ HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut) { TRACE("( %f, %p ), stub\n", dateIn, puiOut ); dateIn = rnd( dateIn ); if( dateIn < UI2_MIN || dateIn > UI2_MAX ) { return DISP_E_OVERFLOW; } *puiOut = (USHORT) dateIn; return S_OK; } /****************************************************************************** * VarUI2FromStr [OLEAUT32.264] */ HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut) { double dValue = 0.0; LPSTR pNewString = NULL; TRACE("( %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 = rnd( dValue ); if( dValue < UI2_MIN || dValue > UI2_MAX ) { return DISP_E_OVERFLOW; } *puiOut = (USHORT) dValue; return S_OK; } /****************************************************************************** * VarUI2FromBool [OLEAUT32.266] */ HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut) { TRACE("( %d, %p ), stub\n", boolIn, puiOut ); *puiOut = (USHORT) boolIn; return S_OK; } /****************************************************************************** * VarUI2FromI1 [OLEAUT32.267] */ HRESULT WINAPI VarUI2FromI1(CHAR cIn, USHORT* puiOut) { TRACE("( %c, %p ), stub\n", cIn, puiOut ); *puiOut = (USHORT) cIn; return S_OK; } /****************************************************************************** * VarUI2FromUI4 [OLEAUT32.268] */ HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut) { TRACE("( %ld, %p ), stub\n", ulIn, puiOut ); if( ulIn > UI2_MAX ) { return DISP_E_OVERFLOW; } *puiOut = (USHORT) ulIn; return S_OK; } /****************************************************************************** * VarUI4FromStr [OLEAUT32.277] */ HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut) { double dValue = 0.0; LPSTR pNewString = NULL; TRACE("( %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 = rnd( dValue ); if( dValue < UI4_MIN || dValue > UI4_MAX ) { return DISP_E_OVERFLOW; } *pulOut = (ULONG) dValue; return S_OK; } /********************************************************************** * VarUI2FromCy [OLEAUT32.263] * Convert currency to unsigned short */ HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) { double t = rnd((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW; *pusOut = (USHORT)t; return S_OK; } /****************************************************************************** * VarUI4FromUI1 [OLEAUT32.270] */ HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut) { TRACE("( %d, %p ), stub\n", bIn, pulOut ); *pulOut = (USHORT) bIn; return S_OK; } /****************************************************************************** * VarUI4FromI2 [OLEAUT32.271] */ HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut) { TRACE("( %d, %p ), stub\n", uiIn, pulOut ); if( uiIn < UI4_MIN ) { return DISP_E_OVERFLOW; } *pulOut = (ULONG) uiIn; return S_OK; } /****************************************************************************** * VarUI4FromI4 [OLEAUT32.272] */ HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut) { TRACE("( %ld, %p ), stub\n", lIn, pulOut ); if( lIn < 0 ) { return DISP_E_OVERFLOW; } *pulOut = (ULONG) lIn; return S_OK; } /****************************************************************************** * VarUI4FromR4 [OLEAUT32.273] */ HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut) { fltIn = rnd( fltIn ); if( fltIn < UI4_MIN || fltIn > UI4_MAX ) { return DISP_E_OVERFLOW; } *pulOut = (ULONG) fltIn; return S_OK; } /****************************************************************************** * VarUI4FromR8 [OLEAUT32.274] */ HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut) { TRACE("( %f, %p ), stub\n", dblIn, pulOut ); dblIn = rnd( dblIn ); if( dblIn < UI4_MIN || dblIn > UI4_MAX ) { return DISP_E_OVERFLOW; } *pulOut = (ULONG) dblIn; return S_OK; } /****************************************************************************** * VarUI4FromDate [OLEAUT32.275] */ HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut) { TRACE("( %f, %p ), stub\n", dateIn, pulOut ); dateIn = rnd( dateIn ); if( dateIn < UI4_MIN || dateIn > UI4_MAX ) { return DISP_E_OVERFLOW; } *pulOut = (ULONG) dateIn; return S_OK; } /****************************************************************************** * VarUI4FromBool [OLEAUT32.279] */ HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut) { TRACE("( %d, %p ), stub\n", boolIn, pulOut ); *pulOut = (ULONG) boolIn; return S_OK; } /****************************************************************************** * VarUI4FromI1 [OLEAUT32.280] */ HRESULT WINAPI VarUI4FromI1(CHAR cIn, ULONG* pulOut) { TRACE("( %c, %p ), stub\n", cIn, pulOut ); *pulOut = (ULONG) cIn; return S_OK; } /****************************************************************************** * VarUI4FromUI2 [OLEAUT32.281] */ HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut) { TRACE("( %d, %p ), stub\n", uiIn, pulOut ); *pulOut = (ULONG) uiIn; return S_OK; } /********************************************************************** * VarUI4FromCy [OLEAUT32.276] * Convert currency to unsigned long */ HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) { double t = rnd((((double)cyIn.DUMMYSTRUCTNAME_DOT Hi * 4294967296.0) + (double)cyIn.DUMMYSTRUCTNAME_DOT Lo) / 10000); if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW; *pulOut = (ULONG)t; return S_OK; } /********************************************************************** * VarCyFromUI1 [OLEAUT32.98] * Convert unsigned char to currency */ HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) { pcyOut->DUMMYSTRUCTNAME_DOT Hi = 0; pcyOut->DUMMYSTRUCTNAME_DOT Lo = ((ULONG)bIn) * 10000; return S_OK; } /********************************************************************** * VarCyFromI2 [OLEAUT32.99] * Convert signed short to currency */ HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) { if (sIn < 0) pcyOut->DUMMYSTRUCTNAME_DOT Hi = -1; else pcyOut->DUMMYSTRUCTNAME_DOT Hi = 0; pcyOut->DUMMYSTRUCTNAME_DOT Lo = ((ULONG)sIn) * 10000; return S_OK; } /********************************************************************** * VarCyFromI4 [OLEAUT32.100] * Convert signed long to currency */ HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) { double t = (double)lIn * (double)10000; pcyOut->DUMMYSTRUCTNAME_DOT Hi = (LONG)(t / (double)4294967296.0); pcyOut->DUMMYSTRUCTNAME_DOT Lo = (ULONG)fmod(t, (double)4294967296.0); if (lIn < 0) pcyOut->DUMMYSTRUCTNAME_DOT Hi--; return S_OK; } /********************************************************************** * VarCyFromR4 [OLEAUT32.101] * Convert float to currency */ HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) { double t = rnd((double)fltIn * (double)10000); pcyOut->DUMMYSTRUCTNAME_DOT Hi = (LONG)(t / (double)4294967296.0); pcyOut->DUMMYSTRUCTNAME_DOT Lo = (ULONG)fmod(t, (double)4294967296.0); if (fltIn < 0) pcyOut->DUMMYSTRUCTNAME_DOT Hi--; return S_OK; } /********************************************************************** * VarCyFromR8 [OLEAUT32.102] * Convert double to currency */ HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) { double t = rnd(dblIn * (double)10000); pcyOut->DUMMYSTRUCTNAME_DOT Hi = (LONG)(t / (double)4294967296.0); pcyOut->DUMMYSTRUCTNAME_DOT Lo = (ULONG)fmod(t, (double)4294967296.0); if (dblIn < 0) pcyOut->DUMMYSTRUCTNAME_DOT Hi--; return S_OK; } /********************************************************************** * VarCyFromDate [OLEAUT32.103] * Convert date to currency */ HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) { double t = rnd((double)dateIn * (double)10000); pcyOut->DUMMYSTRUCTNAME_DOT Hi = (LONG)(t / (double)4294967296.0); pcyOut->DUMMYSTRUCTNAME_DOT Lo = (ULONG)fmod(t, (double)4294967296.0); if (dateIn < 0) pcyOut->DUMMYSTRUCTNAME_DOT Hi--; return S_OK; } /********************************************************************** * VarCyFromStr [OLEAUT32.104] * FIXME: Never tested with decimal seperator other than '.' */ HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) { LPSTR pNewString = NULL; char *decSep = NULL; char *strPtr,*curPtr = NULL; int size, rc; double currencyVal = 0.0; pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn ); TRACE("( '%s', 0x%08lx, 0x%08lx, %p )\n", pNewString, lcid, dwFlags, pcyOut ); /* Get locale information - Decimal Seperator (size includes 0x00) */ size = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, NULL, 0); decSep = (char *) malloc(size); rc = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, decSep, size); TRACE("Decimal Seperator is '%s'\n", decSep); /* Now copy to temporary buffer, skipping any character except 0-9 and the decimal seperator */ curPtr = pBuffer; /* Current position in string being built */ strPtr = pNewString; /* Current position in supplied currenct string */ while (*strPtr) { /* If decimal seperator, skip it and put '.' in string */ if (strncmp(strPtr, decSep, (size-1)) == 0) { strPtr = strPtr + (size-1); *curPtr = '.'; curPtr++; } else if ((*strPtr == '+' || *strPtr == '-') || (*strPtr >= '0' && *strPtr <= '9')) { *curPtr = *strPtr; strPtr++; curPtr++; } else strPtr++; } *curPtr = 0x00; /* Try to get currency into a double */ currencyVal = atof(pBuffer); TRACE("Converted string '%s' to %f\n", pBuffer, currencyVal); /* Free allocated storage */ HeapFree( GetProcessHeap(), 0, pNewString ); free(decSep); /* Convert double -> currency using internal routine */ return VarCyFromR8(currencyVal, pcyOut); } /********************************************************************** * VarCyFromBool [OLEAUT32.106] * Convert boolean to currency */ HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) { if (boolIn < 0) pcyOut->DUMMYSTRUCTNAME_DOT Hi = -1; else pcyOut->DUMMYSTRUCTNAME_DOT Hi = 0; pcyOut->DUMMYSTRUCTNAME_DOT Lo = (ULONG)boolIn * (ULONG)10000; return S_OK; } /********************************************************************** * VarCyFromI1 [OLEAUT32.225] * Convert signed char to currency */ HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pcyOut) { if (cIn < 0) pcyOut->DUMMYSTRUCTNAME_DOT Hi = -1; else pcyOut->DUMMYSTRUCTNAME_DOT Hi = 0; pcyOut->DUMMYSTRUCTNAME_DOT Lo = (ULONG)cIn * (ULONG)10000; return S_OK; } /********************************************************************** * VarCyFromUI2 [OLEAUT32.226] * Convert unsigned short to currency */ HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) { pcyOut->DUMMYSTRUCTNAME_DOT Hi = 0; pcyOut->DUMMYSTRUCTNAME_DOT Lo = (ULONG)usIn * (ULONG)10000; return S_OK; } /********************************************************************** * VarCyFromUI4 [OLEAUT32.227] * Convert unsigned long to currency */ HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) { double t = (double)ulIn * (double)10000; pcyOut->DUMMYSTRUCTNAME_DOT Hi = (LONG)(t / (double)4294967296.0); pcyOut->DUMMYSTRUCTNAME_DOT 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("( 0x%x, 0x%x, %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 ); } /********************************************************************** * VarParseNumFromStr [OLEAUT32.46] */ HRESULT WINAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, NUMPARSE * pnumprs, BYTE * rgbDig) { int i,lastent=0; int cDig; BOOL foundNum=FALSE; FIXME("(%s,flags=%lx,....), partial stub!\n",debugstr_w(strIn),dwFlags); FIXME("numparse: cDig=%d, InFlags=%lx\n",pnumprs->cDig,pnumprs->dwInFlags); /* The other struct components are to be set by us */ memset(rgbDig,0,pnumprs->cDig); /* FIXME: Just patching some values in */ pnumprs->nPwr10 = 0; pnumprs->nBaseShift = 0; pnumprs->cchUsed = lastent; pnumprs->dwOutFlags = NUMPRS_DECIMAL; cDig = 0; for (i=0; strIn[i] ;i++) { if ((strIn[i]>='0') && (strIn[i]<='9')) { foundNum = TRUE; if (pnumprs->cDig > cDig) { *(rgbDig++)=strIn[i]-'0'; cDig++; lastent = i; } } else if ((strIn[i]=='-') && (foundNum==FALSE)) { pnumprs->dwOutFlags |= NUMPRS_NEG; } } pnumprs->cDig = cDig; TRACE("numparse out: cDig=%d, OutFlags=%lx\n",pnumprs->cDig,pnumprs->dwOutFlags); return S_OK; } /********************************************************************** * VarNumFromParseNum [OLEAUT32.47] */ HRESULT WINAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig, ULONG dwVtBits, VARIANT * pvar) { DWORD xint; int i; FIXME("(..,dwVtBits=%lx,....), partial stub!\n",dwVtBits); xint = 0; for (i=0;icDig;i++) xint = xint*10 + rgbDig[i]; if (pnumprs->dwOutFlags & NUMPRS_NEG) { xint = xint * -1; } VariantInit(pvar); if (dwVtBits & VTBIT_I4) { V_VT(pvar) = VT_I4; V_UNION(pvar,intVal) = xint; return S_OK; } if (dwVtBits & VTBIT_R8) { V_VT(pvar) = VT_R8; V_UNION(pvar,dblVal) = xint; return S_OK; } if (dwVtBits & VTBIT_R4) { V_VT(pvar) = VT_R4; V_UNION(pvar,fltVal) = xint; return S_OK; } if (dwVtBits & VTBIT_I2) { V_VT(pvar) = VT_I2; V_UNION(pvar,iVal) = xint; return S_OK; } /* FIXME: Currency should be from a double */ if (dwVtBits & VTBIT_CY) { V_VT(pvar) = VT_CY; TRACE("Calculated currency is xint=%ld\n", xint); VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) ); TRACE("Calculated cy is %ld,%lu\n", V_UNION(pvar,cyVal).DUMMYSTRUCTNAME_DOT Hi, V_UNION(pvar,cyVal).DUMMYSTRUCTNAME_DOT Lo); return VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) ); } FIXME("vtbitmask is unsupported %lx, int=%d\n",dwVtBits, (int) xint); return E_FAIL; } /********************************************************************** * VarFormatDateTime [OLEAUT32.97] */ HRESULT WINAPI VarFormatDateTime(LPVARIANT var, INT format, ULONG dwFlags, BSTR *out) { FIXME("%p %d %lx %p\n", var, format, dwFlags, out); return E_NOTIMPL; } /********************************************************************** * VarFormatCurrency [OLEAUT32.127] */ HRESULT WINAPI VarFormatCurrency(LPVARIANT var, INT digits, INT lead, INT paren, INT group, ULONG dwFlags, BSTR *out) { FIXME("%p %d %d %d %d %lx %p\n", var, digits, lead, paren, group, dwFlags, out); return E_NOTIMPL; } /********************************************************************** * VariantTimeToDosDateTime [OLEAUT32.13] * Convert variant representation of time to the date and time representation * stored in dos. */ INT WINAPI VariantTimeToDosDateTime(DATE pvtime, USHORT *wDosDate, USHORT *wDosTime) { struct tm t; *wDosTime = 0; *wDosDate = 0; TRACE("( 0x%x, 0x%x, %p ), stub\n", *wDosDate, *wDosTime, &pvtime ); if (DateToTm(pvtime, 0, &t) < 0) return 0; *wDosTime = *wDosTime | (t.tm_sec / 2); *wDosTime = *wDosTime | (t.tm_min << 5); *wDosTime = *wDosTime | (t.tm_hour << 11); *wDosDate = *wDosDate | t.tm_mday ; *wDosDate = *wDosDate | t.tm_mon << 5; *wDosDate = *wDosDate | ((t.tm_year - 1980) << 9) ; return 1; } /*********************************************************************** * SystemTimeToVariantTime [OLEAUT32.184] */ HRESULT WINAPI SystemTimeToVariantTime( LPSYSTEMTIME lpSystemTime, double *pvtime ) { struct tm t; TRACE(" %d/%d/%d %d:%d:%d\n", lpSystemTime->wMonth, lpSystemTime->wDay, lpSystemTime->wYear, lpSystemTime->wHour, lpSystemTime->wMinute, lpSystemTime->wSecond); if (lpSystemTime->wYear >= 1900) { t.tm_sec = lpSystemTime->wSecond; t.tm_min = lpSystemTime->wMinute; t.tm_hour = lpSystemTime->wHour; t.tm_mday = lpSystemTime->wDay; t.tm_mon = lpSystemTime->wMonth - 1; /* tm_mon is 0..11, wMonth is 1..12 */ t.tm_year = lpSystemTime->wYear; return TmToDATE( &t, pvtime ); } else { double tmpDate; long firstDayOfNextYear; long thisDay; long leftInYear; long result; double decimalPart = 0.0; t.tm_sec = lpSystemTime->wSecond; t.tm_min = lpSystemTime->wMinute; t.tm_hour = lpSystemTime->wHour; /* Step year forward the same number of years before 1900 */ t.tm_year = 1900 + 1899 - lpSystemTime->wYear; t.tm_mon = lpSystemTime->wMonth - 1; t.tm_mday = lpSystemTime->wDay; /* Calculate date */ TmToDATE( &t, pvtime ); thisDay = (double) floor( *pvtime ); decimalPart = fmod( *pvtime, thisDay ); /* Now, calculate the same time for the first of Jan that year */ t.tm_mon = 0; t.tm_mday = 1; t.tm_sec = 0; t.tm_min = 0; t.tm_hour = 0; t.tm_year = t.tm_year+1; TmToDATE( &t, &tmpDate ); firstDayOfNextYear = (long) floor(tmpDate); /* Finally since we know the size of the year, subtract the two to get remaining time in the year */ leftInYear = firstDayOfNextYear - thisDay; /* Now we want full years up to the year in question, and remainder of year of the year in question */ if (isleap(lpSystemTime->wYear) ) { TRACE("Extra day due to leap year\n"); result = 2.0 - ((firstDayOfNextYear - 366) + leftInYear - 2.0); } else { result = 2.0 - ((firstDayOfNextYear - 365) + leftInYear - 2.0); } *pvtime = (double) result + decimalPart; TRACE("<1899 support: returned %f, 1st day %ld, thisday %ld, left %ld\n", *pvtime, firstDayOfNextYear, thisDay, leftInYear); return 1; } return 0; } /*********************************************************************** * VariantTimeToSystemTime [OLEAUT32.185] */ HRESULT WINAPI VariantTimeToSystemTime( double vtime, LPSYSTEMTIME lpSystemTime ) { double t = 0, timeofday = 0; static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; /* The Month_Code is used to find the Day of the Week (LY = LeapYear)*/ static const BYTE Month_Code[] = {0, 1, 4, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6}; static const BYTE Month_Code_LY[] = {0, 0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6}; /* The Century_Code is used to find the Day of the Week */ static const BYTE Century_Code[] = {0, 6, 4, 2}; struct tm r; TRACE(" Variant = %f SYSTEMTIME ptr %p\n", vtime, lpSystemTime); if (vtime >= 0) { if (DateToTm(vtime, 0, &r ) <= 0) return 0; lpSystemTime->wSecond = r.tm_sec; lpSystemTime->wMinute = r.tm_min; lpSystemTime->wHour = r.tm_hour; lpSystemTime->wDay = r.tm_mday; lpSystemTime->wMonth = r.tm_mon; if (lpSystemTime->wMonth == 12) lpSystemTime->wMonth = 1; else lpSystemTime->wMonth++; lpSystemTime->wYear = r.tm_year; } else { vtime = -1*vtime; if (DateToTm(vtime, 0, &r ) <= 0) return 0; lpSystemTime->wSecond = r.tm_sec; lpSystemTime->wMinute = r.tm_min; lpSystemTime->wHour = r.tm_hour; lpSystemTime->wMonth = 13 - r.tm_mon; if (lpSystemTime->wMonth == 1) lpSystemTime->wMonth = 12; else lpSystemTime->wMonth--; lpSystemTime->wYear = 1899 - (r.tm_year - 1900); if (!isleap(lpSystemTime->wYear) ) lpSystemTime->wDay = Days_Per_Month[13 - lpSystemTime->wMonth] - r.tm_mday; else lpSystemTime->wDay = Days_Per_Month_LY[13 - lpSystemTime->wMonth] - r.tm_mday; } if (!isleap(lpSystemTime->wYear)) { /* (Century_Code+Month_Code+Year_Code+Day) % 7 The century code repeats every 400 years , so the array works out like this, Century_Code[0] is for 16th/20th Centry Century_Code[1] is for 17th/21th Centry Century_Code[2] is for 18th/22th Centry Century_Code[3] is for 19th/23th Centry The year code is found with the formula (year + (year / 4)) the "year" must be between 0 and 99 . The Month Code (Month_Code[1]) starts with January and ends with December. */ lpSystemTime->wDayOfWeek = ( Century_Code[(( (lpSystemTime->wYear+100) - lpSystemTime->wYear%100) /100) %4]+ ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+ Month_Code[lpSystemTime->wMonth]+ lpSystemTime->wDay) % 7; if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7; else lpSystemTime->wDayOfWeek -= 1; } else { lpSystemTime->wDayOfWeek = ( Century_Code[(((lpSystemTime->wYear+100) - lpSystemTime->wYear%100)/100)%4]+ ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+ Month_Code_LY[lpSystemTime->wMonth]+ lpSystemTime->wDay) % 7; if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7; else lpSystemTime->wDayOfWeek -= 1; } t = floor(vtime); timeofday = vtime - t; lpSystemTime->wMilliseconds = (timeofday - lpSystemTime->wHour*(1/24) - lpSystemTime->wMinute*(1/1440) - lpSystemTime->wSecond*(1/86400) )*(1/5184000); return 1; } /*********************************************************************** * VarUdateFromDate [OLEAUT32.331] */ HRESULT WINAPI VarUdateFromDate( DATE datein, ULONG dwFlags, UDATE *pudateout) { HRESULT i = 0; static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; TRACE("DATE = %f\n", (double)datein); i = VariantTimeToSystemTime(datein, &(pudateout->st) ); if (i) { pudateout->wDayOfYear = 0; if (isleap(pudateout->st.wYear)) { for (i =1; ist.wMonth; i++) pudateout->wDayOfYear += Days_Per_Month[i]; } else { for (i =1; ist.wMonth; i++) pudateout->wDayOfYear += Days_Per_Month_LY[i]; } pudateout->wDayOfYear += pudateout->st.wDay; dwFlags = 0; /*VAR_VALIDDATE*/ } else dwFlags = 0; return i; } /*********************************************************************** * VarDateFromUdate [OLEAUT32.330] */ HRESULT WINAPI VarDateFromUdate(UDATE *pudateout, ULONG dwFlags, DATE *datein) { HRESULT i; double t = 0; TRACE(" %d/%d/%d %d:%d:%d\n", pudateout->st.wMonth, pudateout->st.wDay, pudateout->st.wYear, pudateout->st.wHour, pudateout->st.wMinute, pudateout->st.wSecond); i = SystemTimeToVariantTime(&(pudateout->st), &t); *datein = t; if (i) return S_OK; else return E_INVALIDARG; } /********************************************************************** * VarBstrCmp [OLEAUT32.314] * * flags can be: * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS * NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA * */ HRESULT WINAPI VarBstrCmp(BSTR left, BSTR right, LCID lcid, DWORD flags) { INT r; TRACE("( %s %s %ld %lx ) partial stub\n", debugstr_w(left), debugstr_w(right), lcid, flags); /* Contrary to the MSDN, this returns eq for null vs null, null vs L"" and L"" vs NULL */ if((!left) || (!right)) { if (!left && (!right || *right==0)) return VARCMP_EQ; else if (!right && (!left || *left==0)) return VARCMP_EQ; else return VARCMP_NULL; } if(flags&NORM_IGNORECASE) r = lstrcmpiW(left,right); else r = lstrcmpW(left,right); if(r<0) return VARCMP_LT; if(r>0) return VARCMP_GT; return VARCMP_EQ; } /********************************************************************** * VarBstrCat [OLEAUT32.313] */ HRESULT WINAPI VarBstrCat(BSTR left, BSTR right, BSTR *out) { BSTR result; int size = 0; TRACE("( %s %s %p )\n", debugstr_w(left), debugstr_w(right), out); /* On Windows, NULL parms are still handled (as empty strings) */ if (left) size=size + lstrlenW(left); if (right) size=size + lstrlenW(right); if (out) { result = SysAllocStringLen(NULL, size); *out = result; if (left) lstrcatW(result,left); if (right) lstrcatW(result,right); TRACE("result = %s, [%p]\n", debugstr_w(result), result); } return S_OK; } /********************************************************************** * VarCat [OLEAUT32.318] */ HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out) { /* Should we VariantClear out? */ /* Can we handle array, vector, by ref etc. */ if ((V_VT(left)&VT_TYPEMASK) == VT_NULL && (V_VT(right)&VT_TYPEMASK) == VT_NULL) { V_VT(out) = VT_NULL; return S_OK; } else if (V_VT(left) == VT_BSTR && V_VT(right) == VT_BSTR) { V_VT(out) = VT_BSTR; VarBstrCat (V_BSTR(left), V_BSTR(right), &V_BSTR(out)); return S_OK; } else FIXME ("types not supported\n"); return S_OK; } /********************************************************************** * VarCmp [OLEAUT32.176] * * flags can be: * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS * NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA * */ HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags) { BOOL lOk = TRUE; BOOL rOk = TRUE; LONGLONG lVal = -1; LONGLONG rVal = -1; TRACE("Left Var:\n"); dump_Variant(left); TRACE("Right Var:\n"); dump_Variant(right); /* If either are null, then return VARCMP_NULL */ if ((V_VT(left)&VT_TYPEMASK) == VT_NULL || (V_VT(right)&VT_TYPEMASK) == VT_NULL) return VARCMP_NULL; /* Strings - use VarBstrCmp */ if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR && (V_VT(right)&VT_TYPEMASK) == VT_BSTR) { return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags); } /* Integers - Ideally like to use VarDecCmp, but no Dec support yet Use LONGLONG to maximize ranges */ lOk = TRUE; switch (V_VT(left)&VT_TYPEMASK) { case VT_I1 : lVal = V_UNION(left,cVal); break; case VT_I2 : lVal = V_UNION(left,iVal); break; case VT_I4 : lVal = V_UNION(left,lVal); break; case VT_INT : lVal = V_UNION(left,lVal); break; case VT_UI1 : lVal = V_UNION(left,bVal); break; case VT_UI2 : lVal = V_UNION(left,uiVal); break; case VT_UI4 : lVal = V_UNION(left,ulVal); break; case VT_UINT : lVal = V_UNION(left,ulVal); break; default: lOk = FALSE; } rOk = TRUE; switch (V_VT(right)&VT_TYPEMASK) { case VT_I1 : rVal = V_UNION(right,cVal); break; case VT_I2 : rVal = V_UNION(right,iVal); break; case VT_I4 : rVal = V_UNION(right,lVal); break; case VT_INT : rVal = V_UNION(right,lVal); break; case VT_UI1 : rVal = V_UNION(right,bVal); break; case VT_UI2 : rVal = V_UNION(right,uiVal); break; case VT_UI4 : rVal = V_UNION(right,ulVal); break; case VT_UINT : rVal = V_UNION(right,ulVal); break; default: rOk = FALSE; } if (lOk && rOk) { if (lVal < rVal) { return VARCMP_LT; } else if (lVal > rVal) { return VARCMP_GT; } else { return VARCMP_EQ; } } /* Strings - use VarBstrCmp */ if ((V_VT(left)&VT_TYPEMASK) == VT_DATE && (V_VT(right)&VT_TYPEMASK) == VT_DATE) { if (floor(V_UNION(left,date)) == floor(V_UNION(right,date))) { /* Due to floating point rounding errors, calculate varDate in whole numbers) */ double wholePart = 0.0; double leftR; double rightR; /* Get the fraction * 24*60*60 to make it into whole seconds */ wholePart = (double) floor( V_UNION(left,date) ); if (wholePart == 0) wholePart = 1; leftR = floor(fmod( V_UNION(left,date), wholePart ) * (24*60*60)); wholePart = (double) floor( V_UNION(right,date) ); if (wholePart == 0) wholePart = 1; rightR = floor(fmod( V_UNION(right,date), wholePart ) * (24*60*60)); if (leftR < rightR) { return VARCMP_LT; } else if (leftR > rightR) { return VARCMP_GT; } else { return VARCMP_EQ; } } else if (V_UNION(left,date) < V_UNION(right,date)) { return VARCMP_LT; } else if (V_UNION(left,date) > V_UNION(right,date)) { return VARCMP_GT; } } FIXME("VarCmp partial implementation, doesnt support these pair of variant types"); return E_FAIL; } /********************************************************************** * VarAnd [OLEAUT32.142] * */ HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result) { HRESULT rc = E_FAIL; TRACE("Left Var:\n"); dump_Variant(left); TRACE("Right Var:\n"); dump_Variant(right); if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL && (V_VT(right)&VT_TYPEMASK) == VT_BOOL) { V_VT(result) = VT_BOOL; if (V_BOOL(left) && V_BOOL(right)) { V_BOOL(result) = VARIANT_TRUE; } else { V_BOOL(result) = VARIANT_FALSE; } rc = S_OK; } else { FIXME("VarAnd stub\n"); } TRACE("rc=%d, Result:\n", (int) rc); dump_Variant(result); return rc; } /********************************************************************** * VarNot [OLEAUT32.174] * */ HRESULT WINAPI VarNot(LPVARIANT in, LPVARIANT result) { HRESULT rc = E_FAIL; TRACE("Var In:\n"); dump_Variant(in); if ((V_VT(in)&VT_TYPEMASK) == VT_BOOL) { V_VT(result) = VT_BOOL; if (V_BOOL(in)) { V_BOOL(result) = VARIANT_FALSE; } else { V_BOOL(result) = VARIANT_TRUE; } rc = S_OK; } else { FIXME("VarNot stub\n"); } TRACE("rc=%d, Result:\n", (int) rc); dump_Variant(result); return rc; } /********************************************************************** * VarTokenizeFormatString [OLEAUT32.140] * * From investigation on W2K, a list is built up which is: * * <0x00> AA BB - Copy from AA for BB chars (Note 1 byte with wrap!) * - Insert appropriate token * */ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR format, LPBYTE rgbTok, int cbTok, int iFirstDay, int iFirstWeek, LCID lcid, int *pcbActual) { FORMATHDR *hdr; int realLen, formatLeft; BYTE *pData; LPSTR pFormatA, pStart; int checkStr; BOOL insertCopy = FALSE; LPSTR copyFrom = NULL; TRACE("'%s', %p %d %d %d only date support\n", debugstr_w(format), rgbTok, cbTok, iFirstDay, iFirstWeek); /* Big enough for header? */ if (cbTok < sizeof(FORMATHDR)) { return TYPE_E_BUFFERTOOSMALL; } /* Insert header */ hdr = (FORMATHDR *) rgbTok; memset(hdr, 0x00, sizeof(FORMATHDR)); hdr->hex3 = 0x03; /* No idea what these are */ hdr->hex6 = 0x06; /* Start parsing string */ realLen = sizeof(FORMATHDR); pData = rgbTok + realLen; pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format ); pStart = pFormatA; formatLeft = strlen(pFormatA); /* Work through the format */ while (*pFormatA != 0x00) { checkStr = 0; while (checkStr>=0 && (formatTokens[checkStr].tokenSize != 0x00)) { if (formatLeft >= formatTokens[checkStr].tokenSize && strncmp(formatTokens[checkStr].str, pFormatA, formatTokens[checkStr].tokenSize) == 0) { TRACE("match on '%s'\n", formatTokens[checkStr].str); /* Found Match! */ /* If we have skipped chars, insert the copy */ if (insertCopy == TRUE) { if ((realLen + 3) > cbTok) { HeapFree( GetProcessHeap(), 0, pFormatA ); return TYPE_E_BUFFERTOOSMALL; } insertCopy = FALSE; *pData = TOK_COPY; pData++; *pData = (BYTE)(copyFrom - pStart); pData++; *pData = (BYTE)(pFormatA - copyFrom); pData++; realLen = realLen + 3; } /* Now insert the token itself */ if ((realLen + 1) > cbTok) { HeapFree( GetProcessHeap(), 0, pFormatA ); return TYPE_E_BUFFERTOOSMALL; } *pData = formatTokens[checkStr].tokenId; pData = pData + 1; realLen = realLen + 1; pFormatA = pFormatA + formatTokens[checkStr].tokenSize; formatLeft = formatLeft - formatTokens[checkStr].tokenSize; checkStr = -1; /* Flag as found and break out of while loop */ } else { checkStr++; } } /* Did we ever match a token? */ if (checkStr != -1 && insertCopy == FALSE) { TRACE("No match - need to insert copy from %p [%p]\n", pFormatA, pStart); insertCopy = TRUE; copyFrom = pFormatA; } else if (checkStr != -1) { pFormatA = pFormatA + 1; } } /* Finally, if we have skipped chars, insert the copy */ if (insertCopy == TRUE) { TRACE("Chars left over, so still copy %p,%p,%p\n", copyFrom, pStart, pFormatA); if ((realLen + 3) > cbTok) { HeapFree( GetProcessHeap(), 0, pFormatA ); return TYPE_E_BUFFERTOOSMALL; } insertCopy = FALSE; *pData = TOK_COPY; pData++; *pData = (BYTE)(copyFrom - pStart); pData++; *pData = (BYTE)(pFormatA - copyFrom); pData++; realLen = realLen + 3; } /* Finally insert the terminator */ if ((realLen + 1) > cbTok) { HeapFree( GetProcessHeap(), 0, pFormatA ); return TYPE_E_BUFFERTOOSMALL; } *pData++ = TOK_END; realLen = realLen + 1; /* Finally fill in the length */ hdr->len = realLen; *pcbActual = realLen; #if 0 { int i,j; for (i=0; ilen))) { TRACE("Output looks like : '%s'\n", output); /* Convert varient to appropriate data type */ whichToken = 0; while ((formatTokens[whichToken].tokenSize != 0x00) && (formatTokens[whichToken].tokenId != *pData)) { whichToken++; } /* Use Variant local from here downwards as always correct type */ if (formatTokens[whichToken].tokenSize > 0 && formatTokens[whichToken].varTypeRequired != 0) { VariantInit( &Variant ); if (Coerce( &Variant, lcid, dwFlags, varIn, formatTokens[whichToken].varTypeRequired ) != S_OK) { HeapFree( GetProcessHeap(), 0, pFormatA ); return DISP_E_TYPEMISMATCH; } else if (formatTokens[whichToken].varTypeRequired == VT_DATE) { if( DateToTm( V_UNION(&Variant,date), dwFlags, &TM ) == FALSE ) { HeapFree( GetProcessHeap(), 0, pFormatA ); return E_INVALIDARG; } } } TRACE("Looking for match on token '%x'\n", *pData); switch (*pData) { case TOK_COPY: TRACE("Copy from %d for %d bytes\n", *(pData+1), *(pData+2)); memcpy(pNextPos, &pFormatA[*(pData+1)], *(pData+2)); pNextPos = pNextPos + *(pData+2); pData = pData + 3; break; case TOK_COLON : /* Get locale information - Time Seperator */ size = GetLocaleInfoA(lcid, LOCALE_STIME, NULL, 0); GetLocaleInfoA(lcid, LOCALE_STIME, pNextPos, size); TRACE("TOK_COLON Time seperator is '%s'\n", pNextPos); pNextPos = pNextPos + size; pData = pData + 1; break; case TOK_SLASH : /* Get locale information - Date Seperator */ size = GetLocaleInfoA(lcid, LOCALE_SDATE, NULL, 0); GetLocaleInfoA(lcid, LOCALE_SDATE, pNextPos, size); TRACE("TOK_COLON Time seperator is '%s'\n", pNextPos); pNextPos = pNextPos + size; pData = pData + 1; break; case TOK_d : sprintf(pNextPos, "%d", TM.tm_mday); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_dd : sprintf(pNextPos, "%2.2d", TM.tm_mday); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_w : sprintf(pNextPos, "%d", TM.tm_wday+1); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_m : sprintf(pNextPos, "%d", TM.tm_mon+1); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_mm : sprintf(pNextPos, "%2.2d", TM.tm_mon+1); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_q : sprintf(pNextPos, "%d", ((TM.tm_mon+1)/4)+1); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_y : sprintf(pNextPos, "%2.2d", TM.tm_yday+1); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_yy : sprintf(pNextPos, "%2.2d", TM.tm_year); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_yyyy : sprintf(pNextPos, "%4.4d", TM.tm_year); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_h : sprintf(pNextPos, "%d", TM.tm_hour); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_Hh : sprintf(pNextPos, "%2.2d", TM.tm_hour); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_N : sprintf(pNextPos, "%d", TM.tm_min); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_Nn : sprintf(pNextPos, "%2.2d", TM.tm_min); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_S : sprintf(pNextPos, "%d", TM.tm_sec); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; case TOK_Ss : sprintf(pNextPos, "%2.2d", TM.tm_sec); pNextPos = pNextPos + strlen(pNextPos); pData = pData + 1; break; /* FIXME: To Do! */ case TOK_ttttt : case TOK_AMsPM : case TOK_amspm : case TOK_AsP : case TOK_asp : case TOK_AMPM : case TOK_c : case TOK_ddd : case TOK_dddd : case TOK_ddddd : case TOK_dddddd : case TOK_ww : case TOK_mmm : case TOK_mmmm : default: FIXME("Unhandled token for VarFormat %d\n", *pData); HeapFree( GetProcessHeap(), 0, pFormatA ); return E_INVALIDARG; } } *pbstrOut = StringDupAtoBstr( output ); HeapFree( GetProcessHeap(), 0, pFormatA ); return S_OK; } /********************************************************************** * VarFormat [OLEAUT32.87] * */ HRESULT WINAPI VarFormat(LPVARIANT varIn, LPOLESTR format, int firstDay, int firstWeek, ULONG dwFlags, BSTR *pbstrOut) { LPSTR pNewString = NULL; HRESULT rc = S_OK; TRACE("mostly stub! format='%s' day=%d, wk=%d, flags=%ld\n", debugstr_w(format), firstDay, firstWeek, dwFlags); TRACE("varIn:\n"); dump_Variant(varIn); /* Note: Must Handle references type Variants (contain ptrs to values rather than values */ /* Get format string */ pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, format ); /* FIXME: Handle some simple pre-definted format strings : */ if (((V_VT(varIn)&VT_TYPEMASK) == VT_CY) && (lstrcmpiA(pNewString, "Currency") == 0)) { /* Can't use VarBstrFromCy as it does not put currency sign on nor decimal places */ double curVal; /* Handle references type Variants (contain ptrs to values rather than values */ if (V_VT(varIn)&VT_BYREF) { rc = VarR8FromCy(*(CY *)V_UNION(varIn,byref), &curVal); } else { rc = VarR8FromCy(V_UNION(varIn,cyVal), &curVal); } if (rc == S_OK) { char tmpStr[BUFFER_MAX]; sprintf(tmpStr, "%f", curVal); if (GetCurrencyFormatA(GetUserDefaultLCID(), dwFlags, tmpStr, NULL, pBuffer, BUFFER_MAX) == 0) { return E_FAIL; } else { *pbstrOut = StringDupAtoBstr( pBuffer ); } } } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_DATE) { /* Attempt to do proper formatting! */ int firstToken = -1; rc = VarTokenizeFormatString(format, pBuffer, sizeof(pBuffer), firstDay, firstWeek, GetUserDefaultLCID(), &firstToken); if (rc==S_OK) { rc = VarFormatFromTokens(varIn, format, pBuffer, dwFlags, pbstrOut, GetUserDefaultLCID()); } } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_R8) { if (V_VT(varIn)&VT_BYREF) { sprintf(pBuffer, "%f", *(double *)V_UNION(varIn,byref)); } else { sprintf(pBuffer, "%f", V_UNION(varIn,dblVal)); } *pbstrOut = StringDupAtoBstr( pBuffer ); } else { FIXME("VarFormat: Unsupported format %d!\n", V_VT(varIn)&VT_TYPEMASK); *pbstrOut = StringDupAtoBstr( "??" ); } /* Free allocated storage */ HeapFree( GetProcessHeap(), 0, pNewString ); TRACE("result: '%s'\n", debugstr_w(*pbstrOut)); return rc; } /********************************************************************** * VarCyMulI4 [OLEAUT32.304] * Multiply currency value by integer */ HRESULT WINAPI VarCyMulI4(CY cyIn, LONG mulBy, CY *pcyOut) { double cyVal = 0; HRESULT rc = S_OK; rc = VarR8FromCy(cyIn, &cyVal); if (rc == S_OK) { rc = VarCyFromR8((cyVal * (double) mulBy), pcyOut); TRACE("Multiply %f by %ld = %f [%ld,%lu]\n", cyVal, mulBy, (cyVal * (double) mulBy), pcyOut->DUMMYSTRUCTNAME_DOT Hi, pcyOut->DUMMYSTRUCTNAME_DOT Lo); } return rc; }