4 * Copyright 1998 Jean-Claude Cote
7 * This implements the low-level and hi-level APIs for manipulating VARIANTs.
8 * The low-level APIs are used to do data coercion between different data types.
9 * The hi-level APIs are built on top of these low-level APIs and handle
10 * initialization, copying, destroying and changing the type of VARIANTs.
13 * - The Variant APIs are do not support international languages, currency
14 * types, number formating and calendar. They only support U.S. English format.
15 * - The Variant APIs do not the following types: IUknown, IDispatch, DECIMAL and SafeArray.
16 * The prototypes for these are commented out in the oleauto.h file. They need
17 * to be implemented and cases need to be added to the switches of the existing APIs.
18 * - The parsing of date for the VarDateFromStr is not complete.
19 * - The date manipulations do not support date prior to 1900.
20 * - The parsing does not accept has many formats has the Windows implementation.
41 # define FLT_MAX MAXFLOAT
43 # error "Can't find #define for MAXFLOAT/FLT_MAX"
49 static const char CHAR_MAX
= 127;
50 static const char CHAR_MIN
= -128;
51 static const BYTE UI1_MAX
= 255;
52 static const BYTE UI1_MIN
= 0;
53 static const unsigned short UI2_MAX
= 65535;
54 static const unsigned short UI2_MIN
= 0;
55 static const short I2_MAX
= 32767;
56 static const short I2_MIN
= -32768;
57 static const unsigned long UI4_MAX
= 4294967295U;
58 static const unsigned long UI4_MIN
= 0;
59 static const long I4_MAX
= 2147483647;
60 static const long I4_MIN
= -(2147483648U);
61 static const DATE DATE_MIN
= -657434;
62 static const DATE DATE_MAX
= 2958465;
65 /* This mask is used to set a flag in wReserved1 of
66 * the VARIANTARG structure. The flag indicates if
67 * the API function is using an inner variant or not.
69 #define PROCESSING_INNER_VARIANT 0x0001
71 /* General use buffer.
73 #define BUFFER_MAX 1024
74 static char pBuffer
[BUFFER_MAX
];
77 * Note a leap year is one that is a multiple of 4
78 * but not of a 100. Except if it is a multiple of
79 * 400 then it is a leap year.
81 /* According to postgeSQL date parsing functions there is
82 * a leap year when this expression is true.
83 * (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
84 * So according to this there is 365.2515 days in one year.
85 * One + every four years: 1/4 -> 365.25
86 * One - every 100 years: 1/100 -> 365.001
87 * One + every 400 years: 1/400 -> 365.0025
89 static const double DAYS_IN_ONE_YEAR
= 365.2515;
93 /******************************************************************************
94 * DateTimeStringToTm [INTERNAL]
96 * Converts a string representation of a date and/or time to a tm structure.
98 * Note this function uses the postgresql date parsing functions found
99 * in the parsedt.c file.
101 * Returns TRUE if successfull.
103 * Note: This function does not parse the day of the week,
104 * daylight savings time. It will only fill the followin fields in
105 * the tm struct, tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
107 ******************************************************************************/
108 static BOOL
DateTimeStringToTm( OLECHAR
* strIn
, LCID lcid
, struct tm
* pTm
)
115 char *field
[MAXDATEFIELDS
];
116 int ftype
[MAXDATEFIELDS
];
117 char lowstr
[MAXDATELEN
+ 1];
118 char* strDateTime
= NULL
;
120 /* Convert the string to ASCII since this is the only format
121 * postgesql can handle.
123 strDateTime
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
125 if( strDateTime
!= NULL
)
127 /* Make sure we don't go over the maximum length
128 * accepted by postgesql.
130 if( strlen( strDateTime
) <= MAXDATELEN
)
132 if( ParseDateTime( strDateTime
, lowstr
, field
, ftype
, MAXDATEFIELDS
, &nf
) == 0 )
134 if( lcid
& VAR_DATEVALUEONLY
)
136 /* Get the date information.
137 * It returns 0 if date information was
138 * present and 1 if only time information was present.
139 * -1 if an error occures.
141 if( DecodeDateTime(field
, ftype
, nf
, &dtype
, pTm
, &fsec
, &tzp
) == 0 )
143 /* Eliminate the time information since we
144 * were asked to get date information only.
152 if( lcid
& VAR_TIMEVALUEONLY
)
154 /* Get time information only.
156 if( DecodeTimeOnly(field
, ftype
, nf
, &dtype
, pTm
, &fsec
) == 0 )
163 /* Get both date and time information.
164 * It returns 0 if date information was
165 * present and 1 if only time information was present.
166 * -1 if an error occures.
168 if( DecodeDateTime(field
, ftype
, nf
, &dtype
, pTm
, &fsec
, &tzp
) != -1 )
175 HeapFree( GetProcessHeap(), 0, strDateTime
);
186 /******************************************************************************
187 * TmToDATE [INTERNAL]
189 * The date is implemented using an 8 byte floating-point number.
190 * Days are represented by whole numbers increments starting with 0.00 has
191 * being December 30 1899, midnight.
192 * The hours are expressed as the fractional part of the number.
193 * December 30 1899 at midnight = 0.00
194 * January 1 1900 at midnight = 2.00
195 * January 4 1900 at 6 AM = 5.25
196 * January 4 1900 at noon = 5.50
197 * December 29 1899 at midnight = -1.00
198 * December 18 1899 at midnight = -12.00
199 * December 18 1899 at 6AM = -12.25
200 * December 18 1899 at 6PM = -12.75
201 * December 19 1899 at midnight = -11.00
202 * The tm structure is as follows:
204 * int tm_sec; seconds after the minute - [0,59]
205 * int tm_min; minutes after the hour - [0,59]
206 * int tm_hour; hours since midnight - [0,23]
207 * int tm_mday; day of the month - [1,31]
208 * int tm_mon; months since January - [0,11]
210 * int tm_wday; days since Sunday - [0,6]
211 * int tm_yday; days since January 1 - [0,365]
212 * int tm_isdst; daylight savings time flag
215 * Note: This function does not use the tm_wday, tm_yday, tm_wday,
216 * and tm_isdst fields of the tm structure. And only converts years
219 * Returns TRUE if successfull.
221 static BOOL
TmToDATE( struct tm
* pTm
, DATE
*pDateOut
)
223 if( (pTm
->tm_year
- 1900) >= 0 )
227 /* Start at 1. This is the way DATE is defined.
228 * January 1, 1900 at Midnight is 1.00.
229 * January 1, 1900 at 6AM is 1.25.
234 /* Add the number of days corresponding to
237 *pDateOut
+= (pTm
->tm_year
- 1900) * 365;
239 /* Add the leap days in the previous years between now and 1900.
240 * Note a leap year is one that is a multiple of 4
241 * but not of a 100. Except if it is a multiple of
242 * 400 then it is a leap year.
244 *pDateOut
+= ( (pTm
->tm_year
- 1) / 4 ) - ( 1900 / 4 );
245 *pDateOut
-= ( (pTm
->tm_year
- 1) / 100 ) - ( 1900 / 100 );
246 *pDateOut
+= ( (pTm
->tm_year
- 1) / 400 ) - ( 1900 / 400 );
248 /* Set the leap year flag if the
249 * current year specified by tm_year is a
250 * leap year. This will be used to add a day
253 if( isleap( pTm
->tm_year
) )
256 /* Add the number of days corresponding to
259 switch( pTm
->tm_mon
)
265 *pDateOut
+= ( 59 + leapYear
);
268 *pDateOut
+= ( 90 + leapYear
);
271 *pDateOut
+= ( 120 + leapYear
);
274 *pDateOut
+= ( 151 + leapYear
);
277 *pDateOut
+= ( 181 + leapYear
);
280 *pDateOut
+= ( 212 + leapYear
);
283 *pDateOut
+= ( 243 + leapYear
);
286 *pDateOut
+= ( 273 + leapYear
);
289 *pDateOut
+= ( 304 + leapYear
);
292 *pDateOut
+= ( 334 + leapYear
);
295 /* Add the number of days in this month.
297 *pDateOut
+= pTm
->tm_mday
;
299 /* Add the number of seconds, minutes, and hours
300 * to the DATE. Note these are the fracionnal part
301 * of the DATE so seconds / number of seconds in a day.
303 *pDateOut
+= pTm
->tm_hour
/ 24.0;
304 *pDateOut
+= pTm
->tm_min
/ 1440.0;
305 *pDateOut
+= pTm
->tm_sec
/ 86400.0;
311 /******************************************************************************
312 * DateToTm [INTERNAL]
314 * This function converst a windows DATE to a tm structure.
316 * It does not fill all the fields of the tm structure.
317 * Here is a list of the fields that are filled:
318 * tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
320 * Note this function does not support dates before the January 1, 1900
321 * or ( dateIn < 2.0 ).
323 * Returns TRUE if successfull.
325 static BOOL
DateToTm( DATE dateIn
, LCID lcid
, struct tm
* pTm
)
327 /* Do not process dates smaller than January 1, 1900.
328 * Which corresponds to 2.0 in the windows DATE format.
332 double decimalPart
= 0.0;
333 double wholePart
= 0.0;
335 memset(pTm
,0,sizeof(*pTm
));
337 /* Because of the nature of DATE format witch
338 * associates 2.0 to January 1, 1900. We will
339 * remove 1.0 from the whole part of the DATE
340 * so that in the following code 1.0
341 * will correspond to January 1, 1900.
342 * This simplyfies the processing of the DATE value.
346 wholePart
= (double) floor( dateIn
);
347 decimalPart
= fmod( dateIn
, wholePart
);
349 if( !(lcid
& VAR_TIMEVALUEONLY
) )
353 double yearsSince1900
= 0;
354 /* Start at 1900, this where the DATE time 0.0 starts.
357 /* find in what year the day in the "wholePart" falls into.
358 * add the value to the year field.
360 yearsSince1900
= floor( wholePart
/ DAYS_IN_ONE_YEAR
);
361 pTm
->tm_year
+= yearsSince1900
;
362 /* determine if this is a leap year.
364 if( isleap( pTm
->tm_year
) )
366 /* find what day of that year does the "wholePart" corresponds to.
367 * Note: nDay is in [1-366] format
369 nDay
= (int) ( wholePart
- floor( yearsSince1900
* DAYS_IN_ONE_YEAR
) );
370 /* Set the tm_yday value.
371 * Note: The day is must be converted from [1-366] to [0-365]
373 /*pTm->tm_yday = nDay - 1;*/
374 /* find which mount this day corresponds to.
381 else if( nDay
<= ( 59 + leapYear
) )
383 pTm
->tm_mday
= nDay
- 31;
386 else if( nDay
<= ( 90 + leapYear
) )
388 pTm
->tm_mday
= nDay
- ( 59 + leapYear
);
391 else if( nDay
<= ( 120 + leapYear
) )
393 pTm
->tm_mday
= nDay
- ( 90 + leapYear
);
396 else if( nDay
<= ( 151 + leapYear
) )
398 pTm
->tm_mday
= nDay
- ( 120 + leapYear
);
401 else if( nDay
<= ( 181 + leapYear
) )
403 pTm
->tm_mday
= nDay
- ( 151 + leapYear
);
406 else if( nDay
<= ( 212 + leapYear
) )
408 pTm
->tm_mday
= nDay
- ( 181 + leapYear
);
411 else if( nDay
<= ( 243 + leapYear
) )
413 pTm
->tm_mday
= nDay
- ( 212 + leapYear
);
416 else if( nDay
<= ( 273 + leapYear
) )
418 pTm
->tm_mday
= nDay
- ( 243 + leapYear
);
421 else if( nDay
<= ( 304 + leapYear
) )
423 pTm
->tm_mday
= nDay
- ( 273 + leapYear
);
426 else if( nDay
<= ( 334 + leapYear
) )
428 pTm
->tm_mday
= nDay
- ( 304 + leapYear
);
431 else if( nDay
<= ( 365 + leapYear
) )
433 pTm
->tm_mday
= nDay
- ( 334 + leapYear
);
437 if( !(lcid
& VAR_DATEVALUEONLY
) )
439 /* find the number of seconds in this day.
440 * fractional part times, hours, minutes, seconds.
442 pTm
->tm_hour
= (int) ( decimalPart
* 24 );
443 pTm
->tm_min
= (int) ( ( ( decimalPart
* 24 ) - pTm
->tm_hour
) * 60 );
444 pTm
->tm_sec
= (int) ( ( ( decimalPart
* 24 * 60 ) - ( pTm
->tm_hour
* 60 ) - pTm
->tm_min
) * 60 );
453 /******************************************************************************
454 * SizeOfVariantData [INTERNAL]
456 * This function finds the size of the data referenced by a Variant based
457 * the type "vt" of the Variant.
459 static int SizeOfVariantData( VARIANT
* parg
)
462 switch( parg
->vt
& VT_TYPEMASK
)
465 size
= sizeof(short);
477 size
= sizeof(unsigned short);
480 size
= sizeof(unsigned int);
483 size
= sizeof(unsigned long);
486 size
= sizeof(float);
489 size
= sizeof(double);
495 size
= sizeof(VARIANT_BOOL
);
498 size
= sizeof(void*);
505 FIXME(ole
,"Add size information for type vt=%d\n", parg
->vt
& VT_TYPEMASK
);
511 /******************************************************************************
512 * StringDupAtoBstr [INTERNAL]
515 static BSTR
StringDupAtoBstr( char* strIn
)
518 OLECHAR
* pNewString
= NULL
;
519 pNewString
= HEAP_strdupAtoW( GetProcessHeap(), 0, strIn
);
520 bstr
= SysAllocString( pNewString
);
521 HeapFree( GetProcessHeap(), 0, pNewString
);
525 /******************************************************************************
528 * Round the double value to the nearest integer value.
530 static double round( double d
)
532 double decimals
= 0.0, integerValue
= 0.0, roundedValue
= 0.0;
533 BOOL bEvenNumber
= FALSE
;
536 /* Save the sign of the number
538 nSign
= (d
>= 0.0) ? 1 : -1;
541 /* Remove the decimals.
543 integerValue
= floor( d
);
545 /* Set the Even flag. This is used to round the number when
546 * the decimals are exactly 1/2. If the integer part is
547 * odd the number is rounded up. If the integer part
548 * is even the number is rounded down. Using this method
549 * numbers are rounded up|down half the time.
551 bEvenNumber
= (((short)fmod(integerValue
, 2)) == 0) ? TRUE
: FALSE
;
553 /* Remove the integral part of the number.
555 decimals
= d
- integerValue
;
557 /* Note: Ceil returns the smallest integer that is greater that x.
558 * and floor returns the largest integer that is less than or equal to x.
562 /* If the decimal part is greater than 1/2
564 roundedValue
= ceil( d
);
566 else if( decimals
< 0.5 )
568 /* If the decimal part is smaller than 1/2
570 roundedValue
= floor( d
);
574 /* the decimals are exactly 1/2 so round according to
575 * the bEvenNumber flag.
579 roundedValue
= floor( d
);
583 roundedValue
= ceil( d
);
587 return roundedValue
* nSign
;
590 /******************************************************************************
591 * RemoveCharacterFromString [INTERNAL]
593 * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
595 static void RemoveCharacterFromString( LPSTR str
, LPSTR strOfCharToRemove
)
597 LPSTR pNewString
= NULL
;
598 LPSTR strToken
= NULL
;
601 /* Check if we have a valid argument
605 pNewString
= strdup( str
);
607 strToken
= strtok( pNewString
, strOfCharToRemove
);
608 while( strToken
!= NULL
) {
609 strcat( str
, strToken
);
610 strToken
= strtok( NULL
, strOfCharToRemove
);
617 /******************************************************************************
618 * GetValidRealString [INTERNAL]
620 * Checks if the string is of proper format to be converted to a real value.
622 static BOOL
IsValidRealString( LPSTR strRealString
)
624 /* Real values that have a decimal point are required to either have
625 * digits before or after the decimal point. We will assume that
626 * we do not have any digits at either position. If we do encounter
627 * some we will disable this flag.
629 BOOL bDigitsRequired
= TRUE
;
630 /* Processed fields in the string representation of the real number.
632 BOOL bWhiteSpaceProcessed
= FALSE
;
633 BOOL bFirstSignProcessed
= FALSE
;
634 BOOL bFirstDigitsProcessed
= FALSE
;
635 BOOL bDecimalPointProcessed
= FALSE
;
636 BOOL bSecondDigitsProcessed
= FALSE
;
637 BOOL bExponentProcessed
= FALSE
;
638 BOOL bSecondSignProcessed
= FALSE
;
639 BOOL bThirdDigitsProcessed
= FALSE
;
640 /* Assume string parameter "strRealString" is valid and try to disprove it.
642 BOOL bValidRealString
= TRUE
;
644 /* Used to count the number of tokens in the "strRealString".
646 LPSTR strToken
= NULL
;
650 /* Check if we have a valid argument
652 if( strRealString
== NULL
)
654 bValidRealString
= FALSE
;
657 if( bValidRealString
== TRUE
)
659 /* Make sure we only have ONE token in the string.
661 strToken
= strtok( strRealString
, " " );
662 while( strToken
!= NULL
) {
664 strToken
= strtok( NULL
, " " );
669 bValidRealString
= FALSE
;
674 /* Make sure this token contains only valid characters.
675 * The string argument to atof has the following form:
676 * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
677 * Whitespace consists of space and|or <TAB> characters, which are ignored.
678 * Sign is either plus '+' or minus '-'.
679 * Digits are one or more decimal digits.
680 * Note: If no digits appear before the decimal point, at least one must
681 * appear after the decimal point.
682 * The decimal digits may be followed by an exponent.
683 * An Exponent consists of an introductory letter ( D, d, E, or e) and
684 * an optionally signed decimal integer.
686 pChar
= strRealString
;
687 while( bValidRealString
== TRUE
&& *pChar
!= '\0' )
695 if( bWhiteSpaceProcessed
||
696 bFirstSignProcessed
||
697 bFirstDigitsProcessed
||
698 bDecimalPointProcessed
||
699 bSecondDigitsProcessed
||
700 bExponentProcessed
||
701 bSecondSignProcessed
||
702 bThirdDigitsProcessed
)
704 bValidRealString
= FALSE
;
711 if( bFirstSignProcessed
== FALSE
)
713 if( bFirstDigitsProcessed
||
714 bDecimalPointProcessed
||
715 bSecondDigitsProcessed
||
716 bExponentProcessed
||
717 bSecondSignProcessed
||
718 bThirdDigitsProcessed
)
720 bValidRealString
= FALSE
;
722 bWhiteSpaceProcessed
= TRUE
;
723 bFirstSignProcessed
= TRUE
;
725 else if( bSecondSignProcessed
== FALSE
)
727 /* Note: The exponent must be present in
728 * order to accept the second sign...
730 if( bExponentProcessed
== FALSE
||
731 bThirdDigitsProcessed
||
734 bValidRealString
= FALSE
;
736 bFirstSignProcessed
= TRUE
;
737 bWhiteSpaceProcessed
= TRUE
;
738 bFirstDigitsProcessed
= TRUE
;
739 bDecimalPointProcessed
= TRUE
;
740 bSecondDigitsProcessed
= TRUE
;
741 bSecondSignProcessed
= TRUE
;
757 if( bFirstDigitsProcessed
== FALSE
)
759 if( bDecimalPointProcessed
||
760 bSecondDigitsProcessed
||
761 bExponentProcessed
||
762 bSecondSignProcessed
||
763 bThirdDigitsProcessed
)
765 bValidRealString
= FALSE
;
767 bFirstSignProcessed
= TRUE
;
768 bWhiteSpaceProcessed
= TRUE
;
769 /* We have found some digits before the decimal point
770 * so disable the "Digits required" flag.
772 bDigitsRequired
= FALSE
;
774 else if( bSecondDigitsProcessed
== FALSE
)
776 if( bExponentProcessed
||
777 bSecondSignProcessed
||
778 bThirdDigitsProcessed
)
780 bValidRealString
= FALSE
;
782 bFirstSignProcessed
= TRUE
;
783 bWhiteSpaceProcessed
= TRUE
;
784 bFirstDigitsProcessed
= TRUE
;
785 bDecimalPointProcessed
= TRUE
;
786 /* We have found some digits after the decimal point
787 * so disable the "Digits required" flag.
789 bDigitsRequired
= FALSE
;
791 else if( bThirdDigitsProcessed
== FALSE
)
793 /* Getting here means everything else should be processed.
794 * If we get anything else than a decimal following this
795 * digit it will be flagged by the other cases, so
796 * we do not really need to do anything in here.
800 /* If DecimalPoint...
803 if( bDecimalPointProcessed
||
804 bSecondDigitsProcessed
||
805 bExponentProcessed
||
806 bSecondSignProcessed
||
807 bThirdDigitsProcessed
)
809 bValidRealString
= FALSE
;
811 bFirstSignProcessed
= TRUE
;
812 bWhiteSpaceProcessed
= TRUE
;
813 bFirstDigitsProcessed
= TRUE
;
814 bDecimalPointProcessed
= TRUE
;
822 if( bExponentProcessed
||
823 bSecondSignProcessed
||
824 bThirdDigitsProcessed
||
827 bValidRealString
= FALSE
;
829 bFirstSignProcessed
= TRUE
;
830 bWhiteSpaceProcessed
= TRUE
;
831 bFirstDigitsProcessed
= TRUE
;
832 bDecimalPointProcessed
= TRUE
;
833 bSecondDigitsProcessed
= TRUE
;
834 bExponentProcessed
= TRUE
;
837 bValidRealString
= FALSE
;
840 /* Process next character.
845 /* If the required digits were not present we have an invalid
846 * string representation of a real number.
848 if( bDigitsRequired
== TRUE
)
850 bValidRealString
= FALSE
;
853 return bValidRealString
;
857 /******************************************************************************
860 * This function dispatches execution to the proper conversion API
861 * to do the necessary coercion.
863 static HRESULT
Coerce( VARIANTARG
* pd
, LCID lcid
, ULONG dwFlags
, VARIANTARG
* ps
, VARTYPE vt
)
866 unsigned short vtFrom
= 0;
867 vtFrom
= ps
->vt
& VT_TYPEMASK
;
869 /* Note: Since "long" and "int" values both have 4 bytes and are both signed integers
870 * "int" will be treated as "long" in the following code.
871 * The same goes for there unsigned versions.
878 res
= VariantClear( pd
);
881 res
= VariantClear( pd
);
891 res
= VariantCopy( pd
, ps
);
894 res
= VarI1FromI2( ps
->u
.iVal
, &(pd
->u
.cVal
) );
898 res
= VarI1FromI4( ps
->u
.lVal
, &(pd
->u
.cVal
) );
901 res
= VarI1FromUI1( ps
->u
.bVal
, &(pd
->u
.cVal
) );
904 res
= VarI1FromUI2( ps
->u
.uiVal
, &(pd
->u
.cVal
) );
908 res
= VarI1FromUI4( ps
->u
.ulVal
, &(pd
->u
.cVal
) );
911 res
= VarI1FromR4( ps
->u
.fltVal
, &(pd
->u
.cVal
) );
914 res
= VarI1FromR8( ps
->u
.dblVal
, &(pd
->u
.cVal
) );
917 res
= VarI1FromDate( ps
->u
.date
, &(pd
->u
.cVal
) );
920 res
= VarI1FromBool( ps
->u
.boolVal
, &(pd
->u
.cVal
) );
923 res
= VarI1FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.cVal
) );
926 res
= VarI1FromCy( ps
->u
.cyVal
, &(pd
->u
.cVal
) );
928 /*res = VarI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.cVal) );*/
930 /*res = VarI1From32( ps->u.lVal, &(pd->u.cVal) );*/
932 /*res = VarI1FromDec32( ps->u.decVal, &(pd->u.cVal) );*/
934 res
= DISP_E_TYPEMISMATCH
;
935 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
944 res
= VarI2FromI1( ps
->u
.cVal
, &(pd
->u
.iVal
) );
947 res
= VariantCopy( pd
, ps
);
951 res
= VarI2FromI4( ps
->u
.lVal
, &(pd
->u
.iVal
) );
954 res
= VarI2FromUI1( ps
->u
.bVal
, &(pd
->u
.iVal
) );
957 res
= VarI2FromUI2( ps
->u
.uiVal
, &(pd
->u
.iVal
) );
961 res
= VarI2FromUI4( ps
->u
.ulVal
, &(pd
->u
.iVal
) );
964 res
= VarI2FromR4( ps
->u
.fltVal
, &(pd
->u
.iVal
) );
967 res
= VarI2FromR8( ps
->u
.dblVal
, &(pd
->u
.iVal
) );
970 res
= VarI2FromDate( ps
->u
.date
, &(pd
->u
.iVal
) );
973 res
= VarI2FromBool( ps
->u
.boolVal
, &(pd
->u
.iVal
) );
976 res
= VarI2FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.iVal
) );
979 res
= VarI2FromCy( ps
->u
.cyVal
, &(pd
->u
.iVal
) );
981 /*res = VarI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.iVal) );*/
983 /*res = VarI2From32( ps->u.lVal, &(pd->u.iVal) );*/
985 /*res = VarI2FromDec32( ps->u.deiVal, &(pd->u.iVal) );*/
987 res
= DISP_E_TYPEMISMATCH
;
988 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
998 res
= VarI4FromI1( ps
->u
.cVal
, &(pd
->u
.lVal
) );
1001 res
= VarI4FromI2( ps
->u
.iVal
, &(pd
->u
.lVal
) );
1005 res
= VariantCopy( pd
, ps
);
1008 res
= VarI4FromUI1( ps
->u
.bVal
, &(pd
->u
.lVal
) );
1011 res
= VarI4FromUI2( ps
->u
.uiVal
, &(pd
->u
.lVal
) );
1015 res
= VarI4FromUI4( ps
->u
.ulVal
, &(pd
->u
.lVal
) );
1018 res
= VarI4FromR4( ps
->u
.fltVal
, &(pd
->u
.lVal
) );
1021 res
= VarI4FromR8( ps
->u
.dblVal
, &(pd
->u
.lVal
) );
1024 res
= VarI4FromDate( ps
->u
.date
, &(pd
->u
.lVal
) );
1027 res
= VarI4FromBool( ps
->u
.boolVal
, &(pd
->u
.lVal
) );
1030 res
= VarI4FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.lVal
) );
1033 res
= VarI4FromCy( ps
->u
.cyVal
, &(pd
->u
.lVal
) );
1034 case( VT_DISPATCH
):
1035 /*res = VarI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.lVal) );*/
1037 /*res = VarI4From32( ps->u.lVal, &(pd->u.lVal) );*/
1039 /*res = VarI4FromDec32( ps->u.deiVal, &(pd->u.lVal) );*/
1041 res
= DISP_E_TYPEMISMATCH
;
1042 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1051 res
= VarUI1FromI1( ps
->u
.cVal
, &(pd
->u
.bVal
) );
1054 res
= VarUI1FromI2( ps
->u
.iVal
, &(pd
->u
.bVal
) );
1058 res
= VarUI1FromI4( ps
->u
.lVal
, &(pd
->u
.bVal
) );
1061 res
= VariantCopy( pd
, ps
);
1064 res
= VarUI1FromUI2( ps
->u
.uiVal
, &(pd
->u
.bVal
) );
1068 res
= VarUI1FromUI4( ps
->u
.ulVal
, &(pd
->u
.bVal
) );
1071 res
= VarUI1FromR4( ps
->u
.fltVal
, &(pd
->u
.bVal
) );
1074 res
= VarUI1FromR8( ps
->u
.dblVal
, &(pd
->u
.bVal
) );
1077 res
= VarUI1FromDate( ps
->u
.date
, &(pd
->u
.bVal
) );
1080 res
= VarUI1FromBool( ps
->u
.boolVal
, &(pd
->u
.bVal
) );
1083 res
= VarUI1FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.bVal
) );
1086 res
= VarUI1FromCy( ps
->u
.cyVal
, &(pd
->u
.bVal
) );
1087 case( VT_DISPATCH
):
1088 /*res = VarUI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.bVal) );*/
1090 /*res = VarUI1From32( ps->u.lVal, &(pd->u.bVal) );*/
1092 /*res = VarUI1FromDec32( ps->u.deiVal, &(pd->u.bVal) );*/
1094 res
= DISP_E_TYPEMISMATCH
;
1095 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1104 res
= VarUI2FromI1( ps
->u
.cVal
, &(pd
->u
.uiVal
) );
1107 res
= VarUI2FromI2( ps
->u
.iVal
, &(pd
->u
.uiVal
) );
1111 res
= VarUI2FromI4( ps
->u
.lVal
, &(pd
->u
.uiVal
) );
1114 res
= VarUI2FromUI1( ps
->u
.bVal
, &(pd
->u
.uiVal
) );
1117 res
= VariantCopy( pd
, ps
);
1121 res
= VarUI2FromUI4( ps
->u
.ulVal
, &(pd
->u
.uiVal
) );
1124 res
= VarUI2FromR4( ps
->u
.fltVal
, &(pd
->u
.uiVal
) );
1127 res
= VarUI2FromR8( ps
->u
.dblVal
, &(pd
->u
.uiVal
) );
1130 res
= VarUI2FromDate( ps
->u
.date
, &(pd
->u
.uiVal
) );
1133 res
= VarUI2FromBool( ps
->u
.boolVal
, &(pd
->u
.uiVal
) );
1136 res
= VarUI2FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.uiVal
) );
1139 res
= VarUI2FromCy( ps
->u
.cyVal
, &(pd
->u
.uiVal
) );
1140 case( VT_DISPATCH
):
1141 /*res = VarUI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.uiVal) );*/
1143 /*res = VarUI2From32( ps->u.lVal, &(pd->u.uiVal) );*/
1145 /*res = VarUI2FromDec32( ps->u.deiVal, &(pd->u.uiVal) );*/
1147 res
= DISP_E_TYPEMISMATCH
;
1148 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1158 res
= VarUI4FromI1( ps
->u
.cVal
, &(pd
->u
.ulVal
) );
1161 res
= VarUI4FromI2( ps
->u
.iVal
, &(pd
->u
.ulVal
) );
1165 res
= VarUI4FromI4( ps
->u
.lVal
, &(pd
->u
.ulVal
) );
1168 res
= VarUI4FromUI1( ps
->u
.bVal
, &(pd
->u
.ulVal
) );
1171 res
= VarUI4FromUI2( ps
->u
.uiVal
, &(pd
->u
.ulVal
) );
1174 res
= VariantCopy( pd
, ps
);
1177 res
= VarUI4FromR4( ps
->u
.fltVal
, &(pd
->u
.ulVal
) );
1180 res
= VarUI4FromR8( ps
->u
.dblVal
, &(pd
->u
.ulVal
) );
1183 res
= VarUI4FromDate( ps
->u
.date
, &(pd
->u
.ulVal
) );
1186 res
= VarUI4FromBool( ps
->u
.boolVal
, &(pd
->u
.ulVal
) );
1189 res
= VarUI4FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.ulVal
) );
1192 res
= VarUI4FromCy( ps
->u
.cyVal
, &(pd
->u
.ulVal
) );
1193 case( VT_DISPATCH
):
1194 /*res = VarUI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.ulVal) );*/
1196 /*res = VarUI4From32( ps->u.lVal, &(pd->u.ulVal) );*/
1198 /*res = VarUI4FromDec32( ps->u.deiVal, &(pd->u.ulVal) );*/
1200 res
= DISP_E_TYPEMISMATCH
;
1201 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1210 res
= VarR4FromI1( ps
->u
.cVal
, &(pd
->u
.fltVal
) );
1213 res
= VarR4FromI2( ps
->u
.iVal
, &(pd
->u
.fltVal
) );
1217 res
= VarR4FromI4( ps
->u
.lVal
, &(pd
->u
.fltVal
) );
1220 res
= VarR4FromUI1( ps
->u
.bVal
, &(pd
->u
.fltVal
) );
1223 res
= VarR4FromUI2( ps
->u
.uiVal
, &(pd
->u
.fltVal
) );
1227 res
= VarR4FromUI4( ps
->u
.ulVal
, &(pd
->u
.fltVal
) );
1230 res
= VariantCopy( pd
, ps
);
1233 res
= VarR4FromR8( ps
->u
.dblVal
, &(pd
->u
.fltVal
) );
1236 res
= VarR4FromDate( ps
->u
.date
, &(pd
->u
.fltVal
) );
1239 res
= VarR4FromBool( ps
->u
.boolVal
, &(pd
->u
.fltVal
) );
1242 res
= VarR4FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.fltVal
) );
1245 res
= VarR4FromCy( ps
->u
.cyVal
, &(pd
->u
.fltVal
) );
1246 case( VT_DISPATCH
):
1247 /*res = VarR4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.fltVal) );*/
1249 /*res = VarR4From32( ps->u.lVal, &(pd->u.fltVal) );*/
1251 /*res = VarR4FromDec32( ps->u.deiVal, &(pd->u.fltVal) );*/
1253 res
= DISP_E_TYPEMISMATCH
;
1254 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1263 res
= VarR8FromI1( ps
->u
.cVal
, &(pd
->u
.dblVal
) );
1266 res
= VarR8FromI2( ps
->u
.iVal
, &(pd
->u
.dblVal
) );
1270 res
= VarR8FromI4( ps
->u
.lVal
, &(pd
->u
.dblVal
) );
1273 res
= VarR8FromUI1( ps
->u
.bVal
, &(pd
->u
.dblVal
) );
1276 res
= VarR8FromUI2( ps
->u
.uiVal
, &(pd
->u
.dblVal
) );
1280 res
= VarR8FromUI4( ps
->u
.ulVal
, &(pd
->u
.dblVal
) );
1283 res
= VarR8FromR4( ps
->u
.fltVal
, &(pd
->u
.dblVal
) );
1286 res
= VariantCopy( pd
, ps
);
1289 res
= VarR8FromDate( ps
->u
.date
, &(pd
->u
.dblVal
) );
1292 res
= VarR8FromBool( ps
->u
.boolVal
, &(pd
->u
.dblVal
) );
1295 res
= VarR8FromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.dblVal
) );
1298 res
= VarR8FromCy( ps
->u
.cyVal
, &(pd
->u
.dblVal
) );
1299 case( VT_DISPATCH
):
1300 /*res = VarR8FromDisp32( ps->u.pdispVal, lcid, &(pd->u.dblVal) );*/
1302 /*res = VarR8From32( ps->u.lVal, &(pd->u.dblVal) );*/
1304 /*res = VarR8FromDec32( ps->u.deiVal, &(pd->u.dblVal) );*/
1306 res
= DISP_E_TYPEMISMATCH
;
1307 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1316 res
= VarDateFromI1( ps
->u
.cVal
, &(pd
->u
.date
) );
1319 res
= VarDateFromI2( ps
->u
.iVal
, &(pd
->u
.date
) );
1322 res
= VarDateFromInt( ps
->u
.intVal
, &(pd
->u
.date
) );
1325 res
= VarDateFromI4( ps
->u
.lVal
, &(pd
->u
.date
) );
1328 res
= VarDateFromUI1( ps
->u
.bVal
, &(pd
->u
.date
) );
1331 res
= VarDateFromUI2( ps
->u
.uiVal
, &(pd
->u
.date
) );
1334 res
= VarDateFromUint( ps
->u
.uintVal
, &(pd
->u
.date
) );
1337 res
= VarDateFromUI4( ps
->u
.ulVal
, &(pd
->u
.date
) );
1340 res
= VarDateFromR4( ps
->u
.fltVal
, &(pd
->u
.date
) );
1343 res
= VarDateFromR8( ps
->u
.dblVal
, &(pd
->u
.date
) );
1346 res
= VariantCopy( pd
, ps
);
1349 res
= VarDateFromBool( ps
->u
.boolVal
, &(pd
->u
.date
) );
1352 res
= VarDateFromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.date
) );
1355 res
= VarDateFromCy( ps
->u
.cyVal
, &(pd
->u
.date
) );
1356 case( VT_DISPATCH
):
1357 /*res = VarDateFromDisp32( ps->u.pdispVal, lcid, &(pd->u.date) );*/
1359 /*res = VarDateFrom32( ps->u.lVal, &(pd->u.date) );*/
1361 /*res = VarDateFromDec32( ps->u.deiVal, &(pd->u.date) );*/
1363 res
= DISP_E_TYPEMISMATCH
;
1364 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1373 res
= VarBoolFromI1( ps
->u
.cVal
, &(pd
->u
.boolVal
) );
1376 res
= VarBoolFromI2( ps
->u
.iVal
, &(pd
->u
.boolVal
) );
1379 res
= VarBoolFromInt( ps
->u
.intVal
, &(pd
->u
.boolVal
) );
1382 res
= VarBoolFromI4( ps
->u
.lVal
, &(pd
->u
.boolVal
) );
1385 res
= VarBoolFromUI1( ps
->u
.bVal
, &(pd
->u
.boolVal
) );
1388 res
= VarBoolFromUI2( ps
->u
.uiVal
, &(pd
->u
.boolVal
) );
1391 res
= VarBoolFromUint( ps
->u
.uintVal
, &(pd
->u
.boolVal
) );
1394 res
= VarBoolFromUI4( ps
->u
.ulVal
, &(pd
->u
.boolVal
) );
1397 res
= VarBoolFromR4( ps
->u
.fltVal
, &(pd
->u
.boolVal
) );
1400 res
= VarBoolFromR8( ps
->u
.dblVal
, &(pd
->u
.boolVal
) );
1403 res
= VarBoolFromDate( ps
->u
.date
, &(pd
->u
.boolVal
) );
1406 res
= VariantCopy( pd
, ps
);
1409 res
= VarBoolFromStr( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.boolVal
) );
1412 res
= VarBoolFromCy( ps
->u
.cyVal
, &(pd
->u
.boolVal
) );
1413 case( VT_DISPATCH
):
1414 /*res = VarBoolFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
1416 /*res = VarBoolFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
1418 /*res = VarBoolFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
1420 res
= DISP_E_TYPEMISMATCH
;
1421 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1430 res
= VarBstrFromI1( ps
->u
.cVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1433 res
= VarBstrFromI2( ps
->u
.iVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1436 res
= VarBstrFromInt( ps
->u
.intVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1439 res
= VarBstrFromI4( ps
->u
.lVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1442 res
= VarBstrFromUI1( ps
->u
.bVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1445 res
= VarBstrFromUI2( ps
->u
.uiVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1448 res
= VarBstrFromUint( ps
->u
.uintVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1451 res
= VarBstrFromUI4( ps
->u
.ulVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1454 res
= VarBstrFromR4( ps
->u
.fltVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1457 res
= VarBstrFromR8( ps
->u
.dblVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1460 res
= VarBstrFromDate( ps
->u
.date
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1463 res
= VarBstrFromBool( ps
->u
.boolVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1466 res
= VariantCopy( pd
, ps
);
1469 /*res = VarBstrFromCy32( ps->u.cyVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1470 case( VT_DISPATCH
):
1471 /*res = VarBstrFromDisp32( ps->u.pdispVal, lcid, lcid, dwFlags, &(pd->u.bstrVal) );*/
1473 /*res = VarBstrFrom32( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1475 /*res = VarBstrFromDec32( ps->u.deiVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1477 res
= DISP_E_TYPEMISMATCH
;
1478 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1487 res
= VarCyFromI1( ps
->u
.cVal
, &(pd
->u
.cyVal
) );
1490 res
= VarCyFromI2( ps
->u
.iVal
, &(pd
->u
.cyVal
) );
1493 res
= VarCyFromInt( ps
->u
.intVal
, &(pd
->u
.cyVal
) );
1496 res
= VarCyFromI4( ps
->u
.lVal
, &(pd
->u
.cyVal
) );
1499 res
= VarCyFromUI1( ps
->u
.bVal
, &(pd
->u
.cyVal
) );
1502 res
= VarCyFromUI2( ps
->u
.uiVal
, &(pd
->u
.cyVal
) );
1505 res
= VarCyFromUint( ps
->u
.uintVal
, &(pd
->u
.cyVal
) );
1508 res
= VarCyFromUI4( ps
->u
.ulVal
, &(pd
->u
.cyVal
) );
1511 res
= VarCyFromR4( ps
->u
.fltVal
, &(pd
->u
.cyVal
) );
1514 res
= VarCyFromR8( ps
->u
.dblVal
, &(pd
->u
.cyVal
) );
1517 res
= VarCyFromDate( ps
->u
.date
, &(pd
->u
.cyVal
) );
1520 res
= VarCyFromBool( ps
->u
.date
, &(pd
->u
.cyVal
) );
1523 res
= VariantCopy( pd
, ps
);
1526 /*res = VarCyFromStr32( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cyVal) );*/
1527 case( VT_DISPATCH
):
1528 /*res = VarCyFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
1530 /*res = VarCyFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
1532 /*res = VarCyFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
1534 res
= DISP_E_TYPEMISMATCH
;
1535 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1541 res
= DISP_E_TYPEMISMATCH
;
1542 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1549 /******************************************************************************
1550 * ValidateVtRange [INTERNAL]
1552 * Used internally by the hi-level Variant API to determine
1553 * if the vartypes are valid.
1555 static HRESULT WINAPI
ValidateVtRange( VARTYPE vt
)
1557 /* if by value we must make sure it is in the
1558 * range of the valid types.
1560 if( ( vt
& VT_TYPEMASK
) > VT_MAXVALIDTYPE
)
1562 return DISP_E_BADVARTYPE
;
1568 /******************************************************************************
1569 * ValidateVartype [INTERNAL]
1571 * Used internally by the hi-level Variant API to determine
1572 * if the vartypes are valid.
1574 static HRESULT WINAPI
ValidateVariantType( VARTYPE vt
)
1578 /* check if we have a valid argument.
1582 /* if by reference check that the type is in
1583 * the valid range and that it is not of empty or null type
1585 if( ( vt
& VT_TYPEMASK
) == VT_EMPTY
||
1586 ( vt
& VT_TYPEMASK
) == VT_NULL
||
1587 ( vt
& VT_TYPEMASK
) > VT_MAXVALIDTYPE
)
1595 res
= ValidateVtRange( vt
);
1601 /******************************************************************************
1602 * ValidateVt [INTERNAL]
1604 * Used internally by the hi-level Variant API to determine
1605 * if the vartypes are valid.
1607 static HRESULT WINAPI
ValidateVt( VARTYPE vt
)
1611 /* check if we have a valid argument.
1615 /* if by reference check that the type is in
1616 * the valid range and that it is not of empty or null type
1618 if( ( vt
& VT_TYPEMASK
) == VT_EMPTY
||
1619 ( vt
& VT_TYPEMASK
) == VT_NULL
||
1620 ( vt
& VT_TYPEMASK
) > VT_MAXVALIDTYPE
)
1622 res
= DISP_E_BADVARTYPE
;
1628 res
= ValidateVtRange( vt
);
1638 /******************************************************************************
1639 * VariantInit32 [OLEAUT32.8]
1641 * Initializes the Variant. Unlike VariantClear it does not interpret the current
1642 * contents of the Variant.
1644 void WINAPI
VariantInit(VARIANTARG
* pvarg
)
1646 TRACE(ole
,"(%p),stub\n",pvarg
);
1648 memset(pvarg
, 0, sizeof (VARIANTARG
));
1649 pvarg
->vt
= VT_EMPTY
;
1654 /******************************************************************************
1655 * VariantClear32 [OLEAUT32.9]
1657 * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
1658 * sets the wReservedX field to 0. The current contents of the VARIANT are
1659 * freed. If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
1660 * released. If VT_ARRAY the array is freed.
1662 HRESULT WINAPI
VariantClear(VARIANTARG
* pvarg
)
1665 TRACE(ole
,"(%p)\n",pvarg
);
1667 res
= ValidateVariantType( pvarg
->vt
);
1670 if( !( pvarg
->vt
& VT_BYREF
) )
1673 * The VT_ARRAY flag is a special case of a safe array.
1675 if ( (pvarg
->vt
& VT_ARRAY
) != 0)
1677 SafeArrayDestroy(pvarg
->u
.parray
);
1681 switch( pvarg
->vt
& VT_TYPEMASK
)
1684 SysFreeString( pvarg
->u
.bstrVal
);
1686 case( VT_DISPATCH
):
1692 case( VT_SAFEARRAY
):
1693 SafeArrayDestroy(pvarg
->u
.parray
);
1702 * Empty all the fields and mark the type as empty.
1704 memset(pvarg
, 0, sizeof (VARIANTARG
));
1705 pvarg
->vt
= VT_EMPTY
;
1711 /******************************************************************************
1712 * VariantCopy32 [OLEAUT32.10]
1714 * Frees up the designation variant and makes a copy of the source.
1716 HRESULT WINAPI
VariantCopy(VARIANTARG
* pvargDest
, VARIANTARG
* pvargSrc
)
1720 TRACE(ole
,"(%p, %p)\n", pvargDest
, pvargSrc
);
1722 res
= ValidateVariantType( pvargSrc
->vt
);
1724 /* If the pointer are to the same variant we don't need
1727 if( pvargDest
!= pvargSrc
&& res
== S_OK
)
1729 res
= VariantClear( pvargDest
);
1733 if( pvargSrc
->vt
& VT_BYREF
)
1735 /* In the case of byreference we only need
1736 * to copy the pointer.
1738 pvargDest
->u
= pvargSrc
->u
;
1739 pvargDest
->vt
= pvargSrc
->vt
;
1744 * The VT_ARRAY flag is another way to designate a safe array.
1746 if (pvargSrc
->vt
& VT_ARRAY
)
1748 SafeArrayCopy(pvargSrc
->u
.parray
, &pvargDest
->u
.parray
);
1752 /* In the case of by value we need to
1753 * copy the actuall value. In the case of
1754 * VT_BSTR a copy of the string is made,
1755 * if VT_DISPATCH or VT_IUNKNOWN AddReff is
1756 * called to increment the object's reference count.
1758 switch( pvargSrc
->vt
& VT_TYPEMASK
)
1761 pvargDest
->u
.bstrVal
= SysAllocString( pvargSrc
->u
.bstrVal
);
1763 case( VT_DISPATCH
):
1769 case( VT_SAFEARRAY
):
1770 SafeArrayCopy(pvargSrc
->u
.parray
, &pvargDest
->u
.parray
);
1773 pvargDest
->u
= pvargSrc
->u
;
1778 pvargDest
->vt
= pvargSrc
->vt
;
1787 /******************************************************************************
1788 * VariantCopyInd32 [OLEAUT32.11]
1790 * Frees up the destination variant and makes a copy of the source. If
1791 * the source is of type VT_BYREF it performs the necessary indirections.
1793 HRESULT WINAPI
VariantCopyInd(VARIANT
* pvargDest
, VARIANTARG
* pvargSrc
)
1797 TRACE(ole
,"(%p, %p)\n", pvargDest
, pvargSrc
);
1799 res
= ValidateVariantType( pvargSrc
->vt
);
1804 if( pvargSrc
->vt
& VT_BYREF
)
1807 VariantInit( &varg
);
1809 /* handle the in place copy.
1811 if( pvargDest
== pvargSrc
)
1813 /* we will use a copy of the source instead.
1815 res
= VariantCopy( &varg
, pvargSrc
);
1821 res
= VariantClear( pvargDest
);
1826 * The VT_ARRAY flag is another way to designate a safearray variant.
1828 if ( pvargSrc
->vt
& VT_ARRAY
)
1830 SafeArrayCopy(*pvargSrc
->u
.pparray
, &pvargDest
->u
.parray
);
1834 /* In the case of by reference we need
1835 * to copy the date pointed to by the variant.
1838 /* Get the variant type.
1840 switch( pvargSrc
->vt
& VT_TYPEMASK
)
1843 pvargDest
->u
.bstrVal
= SysAllocString( *(pvargSrc
->u
.pbstrVal
) );
1845 case( VT_DISPATCH
):
1849 /* Prevent from cycling. According to tests on
1850 * VariantCopyInd in Windows and the documentation
1851 * this API dereferences the inner Variants to only one depth.
1852 * If the inner Variant itself contains an
1853 * other inner variant the E_INVALIDARG error is
1856 if( pvargSrc
->wReserved1
& PROCESSING_INNER_VARIANT
)
1858 /* If we get here we are attempting to deference
1859 * an inner variant that that is itself contained
1860 * in an inner variant so report E_INVALIDARG error.
1866 /* Set the processing inner variant flag.
1867 * We will set this flag in the inner variant
1868 * that will be passed to the VariantCopyInd function.
1870 (pvargSrc
->u
.pvarVal
)->wReserved1
|= PROCESSING_INNER_VARIANT
;
1872 /* Dereference the inner variant.
1874 res
= VariantCopyInd( pvargDest
, pvargSrc
->u
.pvarVal
);
1880 case( VT_SAFEARRAY
):
1881 SafeArrayCopy(*pvargSrc
->u
.pparray
, &pvargDest
->u
.parray
);
1884 /* This is a by reference Variant which means that the union
1885 * part of the Variant contains a pointer to some data of
1886 * type "pvargSrc->vt & VT_TYPEMASK".
1887 * We will deference this data in a generic fashion using
1888 * the void pointer "Variant.u.byref".
1889 * We will copy this data into the union of the destination
1892 memcpy( &pvargDest
->u
, pvargSrc
->u
.byref
, SizeOfVariantData( pvargSrc
) );
1897 pvargDest
->vt
= pvargSrc
->vt
& VT_TYPEMASK
;
1901 /* this should not fail.
1903 VariantClear( &varg
);
1907 res
= VariantCopy( pvargDest
, pvargSrc
);
1913 /******************************************************************************
1914 * VariantChangeType32 [OLEAUT32.12]
1916 HRESULT WINAPI
VariantChangeType(VARIANTARG
* pvargDest
, VARIANTARG
* pvargSrc
,
1917 USHORT wFlags
, VARTYPE vt
)
1919 return VariantChangeTypeEx( pvargDest
, pvargSrc
, 0, wFlags
, vt
);
1922 /******************************************************************************
1923 * VariantChangeTypeEx32 [OLEAUT32.147]
1925 HRESULT WINAPI
VariantChangeTypeEx(VARIANTARG
* pvargDest
, VARIANTARG
* pvargSrc
,
1926 LCID lcid
, USHORT wFlags
, VARTYPE vt
)
1930 VariantInit( &varg
);
1932 TRACE(ole
,"(%p, %p, %ld, %u, %u),stub\n", pvargDest
, pvargSrc
, lcid
, wFlags
, vt
);
1934 /* validate our source argument.
1936 res
= ValidateVariantType( pvargSrc
->vt
);
1938 /* validate the vartype.
1942 res
= ValidateVt( vt
);
1945 /* if we are doing an in-place conversion make a copy of the source.
1947 if( res
== S_OK
&& pvargDest
== pvargSrc
)
1949 res
= VariantCopy( &varg
, pvargSrc
);
1955 /* free up the destination variant.
1957 res
= VariantClear( pvargDest
);
1962 if( pvargSrc
->vt
& VT_BYREF
)
1964 /* Convert the source variant to a "byvalue" variant.
1967 VariantInit( &Variant
);
1968 res
= VariantCopyInd( &Variant
, pvargSrc
);
1971 res
= Coerce( pvargDest
, lcid
, wFlags
, &Variant
, vt
);
1972 /* this should not fail.
1974 VariantClear( &Variant
);
1980 /* Use the current "byvalue" source variant.
1982 res
= Coerce( pvargDest
, lcid
, wFlags
, pvargSrc
, vt
);
1985 /* this should not fail.
1987 VariantClear( &varg
);
1989 /* set the type of the destination
2000 /******************************************************************************
2001 * VarUI1FromI232 [OLEAUT32.130]
2003 HRESULT WINAPI
VarUI1FromI2(short sIn
, BYTE
* pbOut
)
2005 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pbOut
);
2007 /* Check range of value.
2009 if( sIn
< UI1_MIN
|| sIn
> UI1_MAX
)
2011 return DISP_E_OVERFLOW
;
2014 *pbOut
= (BYTE
) sIn
;
2019 /******************************************************************************
2020 * VarUI1FromI432 [OLEAUT32.131]
2022 HRESULT WINAPI
VarUI1FromI4(LONG lIn
, BYTE
* pbOut
)
2024 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pbOut
);
2026 /* Check range of value.
2028 if( lIn
< UI1_MIN
|| lIn
> UI1_MAX
)
2030 return DISP_E_OVERFLOW
;
2033 *pbOut
= (BYTE
) lIn
;
2039 /******************************************************************************
2040 * VarUI1FromR432 [OLEAUT32.132]
2042 HRESULT WINAPI
VarUI1FromR4(FLOAT fltIn
, BYTE
* pbOut
)
2044 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pbOut
);
2046 /* Check range of value.
2048 fltIn
= round( fltIn
);
2049 if( fltIn
< UI1_MIN
|| fltIn
> UI1_MAX
)
2051 return DISP_E_OVERFLOW
;
2054 *pbOut
= (BYTE
) fltIn
;
2059 /******************************************************************************
2060 * VarUI1FromR832 [OLEAUT32.133]
2062 HRESULT WINAPI
VarUI1FromR8(double dblIn
, BYTE
* pbOut
)
2064 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pbOut
);
2066 /* Check range of value.
2068 dblIn
= round( dblIn
);
2069 if( dblIn
< UI1_MIN
|| dblIn
> UI1_MAX
)
2071 return DISP_E_OVERFLOW
;
2074 *pbOut
= (BYTE
) dblIn
;
2079 /******************************************************************************
2080 * VarUI1FromDate32 [OLEAUT32.135]
2082 HRESULT WINAPI
VarUI1FromDate(DATE dateIn
, BYTE
* pbOut
)
2084 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pbOut
);
2086 /* Check range of value.
2088 dateIn
= round( dateIn
);
2089 if( dateIn
< UI1_MIN
|| dateIn
> UI1_MAX
)
2091 return DISP_E_OVERFLOW
;
2094 *pbOut
= (BYTE
) dateIn
;
2099 /******************************************************************************
2100 * VarUI1FromBool32 [OLEAUT32.138]
2102 HRESULT WINAPI
VarUI1FromBool(VARIANT_BOOL boolIn
, BYTE
* pbOut
)
2104 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pbOut
);
2106 *pbOut
= (BYTE
) boolIn
;
2111 /******************************************************************************
2112 * VarUI1FromI132 [OLEAUT32.237]
2114 HRESULT WINAPI
VarUI1FromI1(CHAR cIn
, BYTE
* pbOut
)
2116 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pbOut
);
2123 /******************************************************************************
2124 * VarUI1FromUI232 [OLEAUT32.238]
2126 HRESULT WINAPI
VarUI1FromUI2(USHORT uiIn
, BYTE
* pbOut
)
2128 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pbOut
);
2130 /* Check range of value.
2132 if( uiIn
> UI1_MAX
)
2134 return DISP_E_OVERFLOW
;
2137 *pbOut
= (BYTE
) uiIn
;
2142 /******************************************************************************
2143 * VarUI1FromUI432 [OLEAUT32.239]
2145 HRESULT WINAPI
VarUI1FromUI4(ULONG ulIn
, BYTE
* pbOut
)
2147 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pbOut
);
2149 /* Check range of value.
2151 if( ulIn
> UI1_MAX
)
2153 return DISP_E_OVERFLOW
;
2156 *pbOut
= (BYTE
) ulIn
;
2162 /******************************************************************************
2163 * VarUI1FromStr32 [OLEAUT32.54]
2165 HRESULT WINAPI
VarUI1FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, BYTE
* pbOut
)
2167 double dValue
= 0.0;
2168 LPSTR pNewString
= NULL
;
2170 TRACE( ole
, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn
, lcid
, dwFlags
, pbOut
);
2172 /* Check if we have a valid argument
2174 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2175 RemoveCharacterFromString( pNewString
, "," );
2176 if( IsValidRealString( pNewString
) == FALSE
)
2178 return DISP_E_TYPEMISMATCH
;
2181 /* Convert the valid string to a floating point number.
2183 dValue
= atof( pNewString
);
2185 /* We don't need the string anymore so free it.
2187 HeapFree( GetProcessHeap(), 0 , pNewString
);
2189 /* Check range of value.
2191 dValue
= round( dValue
);
2192 if( dValue
< UI1_MIN
|| dValue
> UI1_MAX
)
2194 return DISP_E_OVERFLOW
;
2197 *pbOut
= (BYTE
) dValue
;
2202 /**********************************************************************
2203 * VarUI1FromCy32 [OLEAUT32.134]
2204 * Convert currency to unsigned char
2206 HRESULT WINAPI
VarUI1FromCy(CY cyIn
, BYTE
* pbOut
) {
2207 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2209 if (t
> UI1_MAX
|| t
< UI1_MIN
) return DISP_E_OVERFLOW
;
2215 /******************************************************************************
2216 * VarI2FromUI132 [OLEAUT32.48]
2218 HRESULT WINAPI
VarI2FromUI1(BYTE bIn
, short* psOut
)
2220 TRACE( ole
, "( 0x%08x, %p ), stub\n", bIn
, psOut
);
2222 *psOut
= (short) bIn
;
2227 /******************************************************************************
2228 * VarI2FromI432 [OLEAUT32.49]
2230 HRESULT WINAPI
VarI2FromI4(LONG lIn
, short* psOut
)
2232 TRACE( ole
, "( %lx, %p ), stub\n", lIn
, psOut
);
2234 /* Check range of value.
2236 if( lIn
< I2_MIN
|| lIn
> I2_MAX
)
2238 return DISP_E_OVERFLOW
;
2241 *psOut
= (short) lIn
;
2246 /******************************************************************************
2247 * VarI2FromR432 [OLEAUT32.50]
2249 HRESULT WINAPI
VarI2FromR4(FLOAT fltIn
, short* psOut
)
2251 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, psOut
);
2253 /* Check range of value.
2255 fltIn
= round( fltIn
);
2256 if( fltIn
< I2_MIN
|| fltIn
> I2_MAX
)
2258 return DISP_E_OVERFLOW
;
2261 *psOut
= (short) fltIn
;
2266 /******************************************************************************
2267 * VarI2FromR832 [OLEAUT32.51]
2269 HRESULT WINAPI
VarI2FromR8(double dblIn
, short* psOut
)
2271 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, psOut
);
2273 /* Check range of value.
2275 dblIn
= round( dblIn
);
2276 if( dblIn
< I2_MIN
|| dblIn
> I2_MAX
)
2278 return DISP_E_OVERFLOW
;
2281 *psOut
= (short) dblIn
;
2286 /******************************************************************************
2287 * VarI2FromDate32 [OLEAUT32.53]
2289 HRESULT WINAPI
VarI2FromDate(DATE dateIn
, short* psOut
)
2291 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, psOut
);
2293 /* Check range of value.
2295 dateIn
= round( dateIn
);
2296 if( dateIn
< I2_MIN
|| dateIn
> I2_MAX
)
2298 return DISP_E_OVERFLOW
;
2301 *psOut
= (short) dateIn
;
2306 /******************************************************************************
2307 * VarI2FromBool32 [OLEAUT32.56]
2309 HRESULT WINAPI
VarI2FromBool(VARIANT_BOOL boolIn
, short* psOut
)
2311 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, psOut
);
2313 *psOut
= (short) boolIn
;
2318 /******************************************************************************
2319 * VarI2FromI132 [OLEAUT32.48]
2321 HRESULT WINAPI
VarI2FromI1(CHAR cIn
, short* psOut
)
2323 TRACE( ole
, "( %c, %p ), stub\n", cIn
, psOut
);
2325 *psOut
= (short) cIn
;
2330 /******************************************************************************
2331 * VarI2FromUI232 [OLEAUT32.206]
2333 HRESULT WINAPI
VarI2FromUI2(USHORT uiIn
, short* psOut
)
2335 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, psOut
);
2337 /* Check range of value.
2341 return DISP_E_OVERFLOW
;
2344 *psOut
= (short) uiIn
;
2349 /******************************************************************************
2350 * VarI2FromUI432 [OLEAUT32.49]
2352 HRESULT WINAPI
VarI2FromUI4(ULONG ulIn
, short* psOut
)
2354 TRACE( ole
, "( %lx, %p ), stub\n", ulIn
, psOut
);
2356 /* Check range of value.
2358 if( ulIn
< I2_MIN
|| ulIn
> I2_MAX
)
2360 return DISP_E_OVERFLOW
;
2363 *psOut
= (short) ulIn
;
2368 /******************************************************************************
2369 * VarI2FromStr32 [OLEAUT32.54]
2371 HRESULT WINAPI
VarI2FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, short* psOut
)
2373 double dValue
= 0.0;
2374 LPSTR pNewString
= NULL
;
2376 TRACE( ole
, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn
, lcid
, dwFlags
, psOut
);
2378 /* Check if we have a valid argument
2380 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2381 RemoveCharacterFromString( pNewString
, "," );
2382 if( IsValidRealString( pNewString
) == FALSE
)
2384 return DISP_E_TYPEMISMATCH
;
2387 /* Convert the valid string to a floating point number.
2389 dValue
= atof( pNewString
);
2391 /* We don't need the string anymore so free it.
2393 HeapFree( GetProcessHeap(), 0, pNewString
);
2395 /* Check range of value.
2397 dValue
= round( dValue
);
2398 if( dValue
< I2_MIN
|| dValue
> I2_MAX
)
2400 return DISP_E_OVERFLOW
;
2403 *psOut
= (short) dValue
;
2408 /**********************************************************************
2409 * VarI2FromCy32 [OLEAUT32.52]
2410 * Convert currency to signed short
2412 HRESULT WINAPI
VarI2FromCy(CY cyIn
, short* psOut
) {
2413 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2415 if (t
> I2_MAX
|| t
< I2_MIN
) return DISP_E_OVERFLOW
;
2421 /******************************************************************************
2422 * VarI4FromUI132 [OLEAUT32.58]
2424 HRESULT WINAPI
VarI4FromUI1(BYTE bIn
, LONG
* plOut
)
2426 TRACE( ole
, "( %X, %p ), stub\n", bIn
, plOut
);
2428 *plOut
= (LONG
) bIn
;
2434 /******************************************************************************
2435 * VarI4FromR432 [OLEAUT32.60]
2437 HRESULT WINAPI
VarI4FromR4(FLOAT fltIn
, LONG
* plOut
)
2439 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, plOut
);
2441 /* Check range of value.
2443 fltIn
= round( fltIn
);
2444 if( fltIn
< I4_MIN
|| fltIn
> I4_MAX
)
2446 return DISP_E_OVERFLOW
;
2449 *plOut
= (LONG
) fltIn
;
2454 /******************************************************************************
2455 * VarI4FromR832 [OLEAUT32.61]
2457 HRESULT WINAPI
VarI4FromR8(double dblIn
, LONG
* plOut
)
2459 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, plOut
);
2461 /* Check range of value.
2463 dblIn
= round( dblIn
);
2464 if( dblIn
< I4_MIN
|| dblIn
> I4_MAX
)
2466 return DISP_E_OVERFLOW
;
2469 *plOut
= (LONG
) dblIn
;
2474 /******************************************************************************
2475 * VarI4FromDate32 [OLEAUT32.63]
2477 HRESULT WINAPI
VarI4FromDate(DATE dateIn
, LONG
* plOut
)
2479 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, plOut
);
2481 /* Check range of value.
2483 dateIn
= round( dateIn
);
2484 if( dateIn
< I4_MIN
|| dateIn
> I4_MAX
)
2486 return DISP_E_OVERFLOW
;
2489 *plOut
= (LONG
) dateIn
;
2494 /******************************************************************************
2495 * VarI4FromBool32 [OLEAUT32.66]
2497 HRESULT WINAPI
VarI4FromBool(VARIANT_BOOL boolIn
, LONG
* plOut
)
2499 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, plOut
);
2501 *plOut
= (LONG
) boolIn
;
2506 /******************************************************************************
2507 * VarI4FromI132 [OLEAUT32.209]
2509 HRESULT WINAPI
VarI4FromI1(CHAR cIn
, LONG
* plOut
)
2511 TRACE( ole
, "( %c, %p ), stub\n", cIn
, plOut
);
2513 *plOut
= (LONG
) cIn
;
2518 /******************************************************************************
2519 * VarI4FromUI232 [OLEAUT32.210]
2521 HRESULT WINAPI
VarI4FromUI2(USHORT uiIn
, LONG
* plOut
)
2523 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, plOut
);
2525 *plOut
= (LONG
) uiIn
;
2530 /******************************************************************************
2531 * VarI4FromUI432 [OLEAUT32.211]
2533 HRESULT WINAPI
VarI4FromUI4(ULONG ulIn
, LONG
* plOut
)
2535 TRACE( ole
, "( %lx, %p ), stub\n", ulIn
, plOut
);
2537 /* Check range of value.
2539 if( ulIn
< I4_MIN
|| ulIn
> I4_MAX
)
2541 return DISP_E_OVERFLOW
;
2544 *plOut
= (LONG
) ulIn
;
2549 /******************************************************************************
2550 * VarI4FromI232 [OLEAUT32.59]
2552 HRESULT WINAPI
VarI4FromI2(short sIn
, LONG
* plOut
)
2554 TRACE( ole
, "( %d, %p ), stub\n", sIn
, plOut
);
2556 *plOut
= (LONG
) sIn
;
2561 /******************************************************************************
2562 * VarI4FromStr32 [OLEAUT32.64]
2564 HRESULT WINAPI
VarI4FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, LONG
* plOut
)
2566 double dValue
= 0.0;
2567 LPSTR pNewString
= NULL
;
2569 TRACE( ole
, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn
, lcid
, dwFlags
, plOut
);
2571 /* Check if we have a valid argument
2573 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2574 RemoveCharacterFromString( pNewString
, "," );
2575 if( IsValidRealString( pNewString
) == FALSE
)
2577 return DISP_E_TYPEMISMATCH
;
2580 /* Convert the valid string to a floating point number.
2582 dValue
= atof( pNewString
);
2584 /* We don't need the string anymore so free it.
2586 HeapFree( GetProcessHeap(), 0, pNewString
);
2588 /* Check range of value.
2590 dValue
= round( dValue
);
2591 if( dValue
< I4_MIN
|| dValue
> I4_MAX
)
2593 return DISP_E_OVERFLOW
;
2596 *plOut
= (LONG
) dValue
;
2601 /**********************************************************************
2602 * VarI4FromCy32 [OLEAUT32.62]
2603 * Convert currency to signed long
2605 HRESULT WINAPI
VarI4FromCy(CY cyIn
, LONG
* plOut
) {
2606 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2608 if (t
> I4_MAX
|| t
< I4_MIN
) return DISP_E_OVERFLOW
;
2614 /******************************************************************************
2615 * VarR4FromUI132 [OLEAUT32.68]
2617 HRESULT WINAPI
VarR4FromUI1(BYTE bIn
, FLOAT
* pfltOut
)
2619 TRACE( ole
, "( %X, %p ), stub\n", bIn
, pfltOut
);
2621 *pfltOut
= (FLOAT
) bIn
;
2626 /******************************************************************************
2627 * VarR4FromI232 [OLEAUT32.69]
2629 HRESULT WINAPI
VarR4FromI2(short sIn
, FLOAT
* pfltOut
)
2631 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pfltOut
);
2633 *pfltOut
= (FLOAT
) sIn
;
2638 /******************************************************************************
2639 * VarR4FromI432 [OLEAUT32.70]
2641 HRESULT WINAPI
VarR4FromI4(LONG lIn
, FLOAT
* pfltOut
)
2643 TRACE( ole
, "( %lx, %p ), stub\n", lIn
, pfltOut
);
2645 *pfltOut
= (FLOAT
) lIn
;
2650 /******************************************************************************
2651 * VarR4FromR832 [OLEAUT32.71]
2653 HRESULT WINAPI
VarR4FromR8(double dblIn
, FLOAT
* pfltOut
)
2655 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pfltOut
);
2657 /* Check range of value.
2659 if( dblIn
< -(FLT_MAX
) || dblIn
> FLT_MAX
)
2661 return DISP_E_OVERFLOW
;
2664 *pfltOut
= (FLOAT
) dblIn
;
2669 /******************************************************************************
2670 * VarR4FromDate32 [OLEAUT32.73]
2672 HRESULT WINAPI
VarR4FromDate(DATE dateIn
, FLOAT
* pfltOut
)
2674 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pfltOut
);
2676 /* Check range of value.
2678 if( dateIn
< -(FLT_MAX
) || dateIn
> FLT_MAX
)
2680 return DISP_E_OVERFLOW
;
2683 *pfltOut
= (FLOAT
) dateIn
;
2688 /******************************************************************************
2689 * VarR4FromBool32 [OLEAUT32.76]
2691 HRESULT WINAPI
VarR4FromBool(VARIANT_BOOL boolIn
, FLOAT
* pfltOut
)
2693 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pfltOut
);
2695 *pfltOut
= (FLOAT
) boolIn
;
2700 /******************************************************************************
2701 * VarR4FromI132 [OLEAUT32.213]
2703 HRESULT WINAPI
VarR4FromI1(CHAR cIn
, FLOAT
* pfltOut
)
2705 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pfltOut
);
2707 *pfltOut
= (FLOAT
) cIn
;
2712 /******************************************************************************
2713 * VarR4FromUI232 [OLEAUT32.214]
2715 HRESULT WINAPI
VarR4FromUI2(USHORT uiIn
, FLOAT
* pfltOut
)
2717 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pfltOut
);
2719 *pfltOut
= (FLOAT
) uiIn
;
2724 /******************************************************************************
2725 * VarR4FromUI432 [OLEAUT32.215]
2727 HRESULT WINAPI
VarR4FromUI4(ULONG ulIn
, FLOAT
* pfltOut
)
2729 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pfltOut
);
2731 *pfltOut
= (FLOAT
) ulIn
;
2736 /******************************************************************************
2737 * VarR4FromStr32 [OLEAUT32.74]
2739 HRESULT WINAPI
VarR4FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, FLOAT
* pfltOut
)
2741 double dValue
= 0.0;
2742 LPSTR pNewString
= NULL
;
2744 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pfltOut
);
2746 /* Check if we have a valid argument
2748 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2749 RemoveCharacterFromString( pNewString
, "," );
2750 if( IsValidRealString( pNewString
) == FALSE
)
2752 return DISP_E_TYPEMISMATCH
;
2755 /* Convert the valid string to a floating point number.
2757 dValue
= atof( pNewString
);
2759 /* We don't need the string anymore so free it.
2761 HeapFree( GetProcessHeap(), 0, pNewString
);
2763 /* Check range of value.
2765 if( dValue
< -(FLT_MAX
) || dValue
> FLT_MAX
)
2767 return DISP_E_OVERFLOW
;
2770 *pfltOut
= (FLOAT
) dValue
;
2775 /**********************************************************************
2776 * VarR4FromCy32 [OLEAUT32.72]
2777 * Convert currency to float
2779 HRESULT WINAPI
VarR4FromCy(CY cyIn
, FLOAT
* pfltOut
) {
2780 *pfltOut
= (FLOAT
)((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2785 /******************************************************************************
2786 * VarR8FromUI132 [OLEAUT32.68]
2788 HRESULT WINAPI
VarR8FromUI1(BYTE bIn
, double* pdblOut
)
2790 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pdblOut
);
2792 *pdblOut
= (double) bIn
;
2797 /******************************************************************************
2798 * VarR8FromI232 [OLEAUT32.69]
2800 HRESULT WINAPI
VarR8FromI2(short sIn
, double* pdblOut
)
2802 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pdblOut
);
2804 *pdblOut
= (double) sIn
;
2809 /******************************************************************************
2810 * VarR8FromI432 [OLEAUT32.70]
2812 HRESULT WINAPI
VarR8FromI4(LONG lIn
, double* pdblOut
)
2814 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pdblOut
);
2816 *pdblOut
= (double) lIn
;
2821 /******************************************************************************
2822 * VarR8FromR432 [OLEAUT32.81]
2824 HRESULT WINAPI
VarR8FromR4(FLOAT fltIn
, double* pdblOut
)
2826 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pdblOut
);
2828 *pdblOut
= (double) fltIn
;
2833 /******************************************************************************
2834 * VarR8FromDate32 [OLEAUT32.83]
2836 HRESULT WINAPI
VarR8FromDate(DATE dateIn
, double* pdblOut
)
2838 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pdblOut
);
2840 *pdblOut
= (double) dateIn
;
2845 /******************************************************************************
2846 * VarR8FromBool32 [OLEAUT32.86]
2848 HRESULT WINAPI
VarR8FromBool(VARIANT_BOOL boolIn
, double* pdblOut
)
2850 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pdblOut
);
2852 *pdblOut
= (double) boolIn
;
2857 /******************************************************************************
2858 * VarR8FromI132 [OLEAUT32.217]
2860 HRESULT WINAPI
VarR8FromI1(CHAR cIn
, double* pdblOut
)
2862 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pdblOut
);
2864 *pdblOut
= (double) cIn
;
2869 /******************************************************************************
2870 * VarR8FromUI232 [OLEAUT32.218]
2872 HRESULT WINAPI
VarR8FromUI2(USHORT uiIn
, double* pdblOut
)
2874 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pdblOut
);
2876 *pdblOut
= (double) uiIn
;
2881 /******************************************************************************
2882 * VarR8FromUI432 [OLEAUT32.219]
2884 HRESULT WINAPI
VarR8FromUI4(ULONG ulIn
, double* pdblOut
)
2886 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pdblOut
);
2888 *pdblOut
= (double) ulIn
;
2893 /******************************************************************************
2894 * VarR8FromStr32 [OLEAUT32.84]
2896 HRESULT WINAPI
VarR8FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, double* pdblOut
)
2898 double dValue
= 0.0;
2899 LPSTR pNewString
= NULL
;
2901 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pdblOut
);
2903 /* Check if we have a valid argument
2905 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2906 RemoveCharacterFromString( pNewString
, "," );
2907 if( IsValidRealString( pNewString
) == FALSE
)
2909 return DISP_E_TYPEMISMATCH
;
2912 /* Convert the valid string to a floating point number.
2914 dValue
= atof( pNewString
);
2916 /* We don't need the string anymore so free it.
2918 HeapFree( GetProcessHeap(), 0, pNewString
);
2925 /**********************************************************************
2926 * VarR8FromCy32 [OLEAUT32.82]
2927 * Convert currency to double
2929 HRESULT WINAPI
VarR8FromCy(CY cyIn
, double* pdblOut
) {
2930 *pdblOut
= (double)((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2935 /******************************************************************************
2936 * VarDateFromUI132 [OLEAUT32.]
2938 HRESULT WINAPI
VarDateFromUI1(BYTE bIn
, DATE
* pdateOut
)
2940 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pdateOut
);
2942 *pdateOut
= (DATE
) bIn
;
2947 /******************************************************************************
2948 * VarDateFromI232 [OLEAUT32.222]
2950 HRESULT WINAPI
VarDateFromI2(short sIn
, DATE
* pdateOut
)
2952 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pdateOut
);
2954 *pdateOut
= (DATE
) sIn
;
2959 /******************************************************************************
2960 * VarDateFromI432 [OLEAUT32.90]
2962 HRESULT WINAPI
VarDateFromI4(LONG lIn
, DATE
* pdateOut
)
2964 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pdateOut
);
2966 if( lIn
< DATE_MIN
|| lIn
> DATE_MAX
)
2968 return DISP_E_OVERFLOW
;
2971 *pdateOut
= (DATE
) lIn
;
2976 /******************************************************************************
2977 * VarDateFromR432 [OLEAUT32.91]
2979 HRESULT WINAPI
VarDateFromR4(FLOAT fltIn
, DATE
* pdateOut
)
2981 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pdateOut
);
2983 if( ceil(fltIn
) < DATE_MIN
|| floor(fltIn
) > DATE_MAX
)
2985 return DISP_E_OVERFLOW
;
2988 *pdateOut
= (DATE
) fltIn
;
2993 /******************************************************************************
2994 * VarDateFromR832 [OLEAUT32.92]
2996 HRESULT WINAPI
VarDateFromR8(double dblIn
, DATE
* pdateOut
)
2998 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pdateOut
);
3000 if( ceil(dblIn
) < DATE_MIN
|| floor(dblIn
) > DATE_MAX
)
3002 return DISP_E_OVERFLOW
;
3005 *pdateOut
= (DATE
) dblIn
;
3010 /******************************************************************************
3011 * VarDateFromStr32 [OLEAUT32.94]
3012 * The string representing the date is composed of two parts, a date and time.
3014 * The format of the time is has follows:
3015 * hh[:mm][:ss][AM|PM]
3016 * Whitespace can be inserted anywhere between these tokens. A whitespace consists
3017 * of space and/or tab characters, which are ignored.
3019 * The formats for the date part are has follows:
3023 * January dd[,] [yy]yy
3026 * Whitespace can be inserted anywhere between these tokens.
3028 * The formats for the date and time string are has follows.
3029 * date[whitespace][time]
3030 * [time][whitespace]date
3032 * These are the only characters allowed in a string representing a date and time:
3033 * [A-Z] [a-z] [0-9] ':' '-' '/' ',' ' ' '\t'
3035 HRESULT WINAPI
VarDateFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, DATE
* pdateOut
)
3038 struct tm TM
= { 0,0,0,0,0,0,0,0,0 };
3040 TRACE( ole
, "( %p, %lx, %lx, %p ), stub\n", strIn
, lcid
, dwFlags
, pdateOut
);
3042 if( DateTimeStringToTm( strIn
, lcid
, &TM
) )
3044 if( TmToDATE( &TM
, pdateOut
) == FALSE
)
3051 ret
= DISP_E_TYPEMISMATCH
;
3058 /******************************************************************************
3059 * VarDateFromI132 [OLEAUT32.221]
3061 HRESULT WINAPI
VarDateFromI1(CHAR cIn
, DATE
* pdateOut
)
3063 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pdateOut
);
3065 *pdateOut
= (DATE
) cIn
;
3070 /******************************************************************************
3071 * VarDateFromUI232 [OLEAUT32.222]
3073 HRESULT WINAPI
VarDateFromUI2(USHORT uiIn
, DATE
* pdateOut
)
3075 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pdateOut
);
3077 if( uiIn
> DATE_MAX
)
3079 return DISP_E_OVERFLOW
;
3082 *pdateOut
= (DATE
) uiIn
;
3087 /******************************************************************************
3088 * VarDateFromUI432 [OLEAUT32.223]
3090 HRESULT WINAPI
VarDateFromUI4(ULONG ulIn
, DATE
* pdateOut
)
3092 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pdateOut
);
3094 if( ulIn
< DATE_MIN
|| ulIn
> DATE_MAX
)
3096 return DISP_E_OVERFLOW
;
3099 *pdateOut
= (DATE
) ulIn
;
3104 /******************************************************************************
3105 * VarDateFromBool32 [OLEAUT32.96]
3107 HRESULT WINAPI
VarDateFromBool(VARIANT_BOOL boolIn
, DATE
* pdateOut
)
3109 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pdateOut
);
3111 *pdateOut
= (DATE
) boolIn
;
3116 /**********************************************************************
3117 * VarDateFromCy32 [OLEAUT32.93]
3118 * Convert currency to date
3120 HRESULT WINAPI
VarDateFromCy(CY cyIn
, DATE
* pdateOut
) {
3121 *pdateOut
= (DATE
)((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
3123 if (*pdateOut
> DATE_MAX
|| *pdateOut
< DATE_MIN
) return DISP_E_TYPEMISMATCH
;
3127 /******************************************************************************
3128 * VarBstrFromUI132 [OLEAUT32.108]
3130 HRESULT WINAPI
VarBstrFromUI1(BYTE bVal
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3132 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", bVal
, lcid
, dwFlags
, pbstrOut
);
3133 sprintf( pBuffer
, "%d", bVal
);
3135 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3140 /******************************************************************************
3141 * VarBstrFromI232 [OLEAUT32.109]
3143 HRESULT WINAPI
VarBstrFromI2(short iVal
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3145 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", iVal
, lcid
, dwFlags
, pbstrOut
);
3146 sprintf( pBuffer
, "%d", iVal
);
3147 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3152 /******************************************************************************
3153 * VarBstrFromI432 [OLEAUT32.110]
3155 HRESULT WINAPI
VarBstrFromI4(LONG lIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3157 TRACE( ole
, "( %ld, %ld, %ld, %p ), stub\n", lIn
, lcid
, dwFlags
, pbstrOut
);
3159 sprintf( pBuffer
, "%ld", lIn
);
3160 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3165 /******************************************************************************
3166 * VarBstrFromR432 [OLEAUT32.111]
3168 HRESULT WINAPI
VarBstrFromR4(FLOAT fltIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3170 TRACE( ole
, "( %f, %ld, %ld, %p ), stub\n", fltIn
, lcid
, dwFlags
, pbstrOut
);
3172 sprintf( pBuffer
, "%.7g", fltIn
);
3173 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3178 /******************************************************************************
3179 * VarBstrFromR832 [OLEAUT32.112]
3181 HRESULT WINAPI
VarBstrFromR8(double dblIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3183 TRACE( ole
, "( %f, %ld, %ld, %p ), stub\n", dblIn
, lcid
, dwFlags
, pbstrOut
);
3185 sprintf( pBuffer
, "%.15g", dblIn
);
3186 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3191 /******************************************************************************
3192 * VarBstrFromDate32 [OLEAUT32.114]
3194 * The date is implemented using an 8 byte floating-point number.
3195 * Days are represented by whole numbers increments starting with 0.00 has
3196 * being December 30 1899, midnight.
3197 * The hours are expressed as the fractional part of the number.
3198 * December 30 1899 at midnight = 0.00
3199 * January 1 1900 at midnight = 2.00
3200 * January 4 1900 at 6 AM = 5.25
3201 * January 4 1900 at noon = 5.50
3202 * December 29 1899 at midnight = -1.00
3203 * December 18 1899 at midnight = -12.00
3204 * December 18 1899 at 6AM = -12.25
3205 * December 18 1899 at 6PM = -12.75
3206 * December 19 1899 at midnight = -11.00
3207 * The tm structure is as follows:
3209 * int tm_sec; seconds after the minute - [0,59]
3210 * int tm_min; minutes after the hour - [0,59]
3211 * int tm_hour; hours since midnight - [0,23]
3212 * int tm_mday; day of the month - [1,31]
3213 * int tm_mon; months since January - [0,11]
3214 * int tm_year; years
3215 * int tm_wday; days since Sunday - [0,6]
3216 * int tm_yday; days since January 1 - [0,365]
3217 * int tm_isdst; daylight savings time flag
3220 HRESULT WINAPI
VarBstrFromDate(DATE dateIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3222 struct tm TM
= {0,0,0,0,0,0,0,0,0};
3224 TRACE( ole
, "( %f, %ld, %ld, %p ), stub\n", dateIn
, lcid
, dwFlags
, pbstrOut
);
3226 if( DateToTm( dateIn
, lcid
, &TM
) == FALSE
)
3228 return E_INVALIDARG
;
3231 if( lcid
& VAR_DATEVALUEONLY
)
3232 strftime( pBuffer
, BUFFER_MAX
, "%x", &TM
);
3233 else if( lcid
& VAR_TIMEVALUEONLY
)
3234 strftime( pBuffer
, BUFFER_MAX
, "%X", &TM
);
3236 strftime( pBuffer
, BUFFER_MAX
, "%x %X", &TM
);
3238 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3243 /******************************************************************************
3244 * VarBstrFromBool32 [OLEAUT32.116]
3246 HRESULT WINAPI
VarBstrFromBool(VARIANT_BOOL boolIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3248 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", boolIn
, lcid
, dwFlags
, pbstrOut
);
3250 if( boolIn
== VARIANT_FALSE
)
3252 sprintf( pBuffer
, "False" );
3256 sprintf( pBuffer
, "True" );
3259 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3264 /******************************************************************************
3265 * VarBstrFromI132 [OLEAUT32.229]
3267 HRESULT WINAPI
VarBstrFromI1(CHAR cIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3269 TRACE( ole
, "( %c, %ld, %ld, %p ), stub\n", cIn
, lcid
, dwFlags
, pbstrOut
);
3270 sprintf( pBuffer
, "%d", cIn
);
3271 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3276 /******************************************************************************
3277 * VarBstrFromUI232 [OLEAUT32.230]
3279 HRESULT WINAPI
VarBstrFromUI2(USHORT uiIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3281 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", uiIn
, lcid
, dwFlags
, pbstrOut
);
3282 sprintf( pBuffer
, "%d", uiIn
);
3283 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3288 /******************************************************************************
3289 * VarBstrFromUI432 [OLEAUT32.231]
3291 HRESULT WINAPI
VarBstrFromUI4(ULONG ulIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
)
3293 TRACE( ole
, "( %ld, %ld, %ld, %p ), stub\n", ulIn
, lcid
, dwFlags
, pbstrOut
);
3294 sprintf( pBuffer
, "%ld", ulIn
);
3295 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3300 /******************************************************************************
3301 * VarBoolFromUI132 [OLEAUT32.118]
3303 HRESULT WINAPI
VarBoolFromUI1(BYTE bIn
, VARIANT_BOOL
* pboolOut
)
3305 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pboolOut
);
3309 *pboolOut
= VARIANT_FALSE
;
3313 *pboolOut
= VARIANT_TRUE
;
3319 /******************************************************************************
3320 * VarBoolFromI232 [OLEAUT32.119]
3322 HRESULT WINAPI
VarBoolFromI2(short sIn
, VARIANT_BOOL
* pboolOut
)
3324 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pboolOut
);
3328 *pboolOut
= VARIANT_FALSE
;
3332 *pboolOut
= VARIANT_TRUE
;
3338 /******************************************************************************
3339 * VarBoolFromI432 [OLEAUT32.120]
3341 HRESULT WINAPI
VarBoolFromI4(LONG lIn
, VARIANT_BOOL
* pboolOut
)
3343 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pboolOut
);
3347 *pboolOut
= VARIANT_FALSE
;
3351 *pboolOut
= VARIANT_TRUE
;
3357 /******************************************************************************
3358 * VarBoolFromR432 [OLEAUT32.121]
3360 HRESULT WINAPI
VarBoolFromR4(FLOAT fltIn
, VARIANT_BOOL
* pboolOut
)
3362 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pboolOut
);
3366 *pboolOut
= VARIANT_FALSE
;
3370 *pboolOut
= VARIANT_TRUE
;
3376 /******************************************************************************
3377 * VarBoolFromR832 [OLEAUT32.122]
3379 HRESULT WINAPI
VarBoolFromR8(double dblIn
, VARIANT_BOOL
* pboolOut
)
3381 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pboolOut
);
3385 *pboolOut
= VARIANT_FALSE
;
3389 *pboolOut
= VARIANT_TRUE
;
3395 /******************************************************************************
3396 * VarBoolFromDate32 [OLEAUT32.123]
3398 HRESULT WINAPI
VarBoolFromDate(DATE dateIn
, VARIANT_BOOL
* pboolOut
)
3400 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pboolOut
);
3404 *pboolOut
= VARIANT_FALSE
;
3408 *pboolOut
= VARIANT_TRUE
;
3414 /******************************************************************************
3415 * VarBoolFromStr32 [OLEAUT32.125]
3417 HRESULT WINAPI
VarBoolFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, VARIANT_BOOL
* pboolOut
)
3420 char* pNewString
= NULL
;
3422 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pboolOut
);
3424 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3426 if( pNewString
== NULL
|| strlen( pNewString
) == 0 )
3428 ret
= DISP_E_TYPEMISMATCH
;
3433 if( strncasecmp( pNewString
, "True", strlen( pNewString
) ) == 0 )
3435 *pboolOut
= VARIANT_TRUE
;
3437 else if( strncasecmp( pNewString
, "False", strlen( pNewString
) ) == 0 )
3439 *pboolOut
= VARIANT_FALSE
;
3443 /* Try converting the string to a floating point number.
3445 double dValue
= 0.0;
3446 HRESULT res
= VarR8FromStr( strIn
, lcid
, dwFlags
, &dValue
);
3449 ret
= DISP_E_TYPEMISMATCH
;
3451 else if( dValue
== 0.0 )
3453 *pboolOut
= VARIANT_FALSE
;
3457 *pboolOut
= VARIANT_TRUE
;
3462 HeapFree( GetProcessHeap(), 0, pNewString
);
3467 /******************************************************************************
3468 * VarBoolFromI132 [OLEAUT32.233]
3470 HRESULT WINAPI
VarBoolFromI1(CHAR cIn
, VARIANT_BOOL
* pboolOut
)
3472 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pboolOut
);
3476 *pboolOut
= VARIANT_FALSE
;
3480 *pboolOut
= VARIANT_TRUE
;
3486 /******************************************************************************
3487 * VarBoolFromUI232 [OLEAUT32.234]
3489 HRESULT WINAPI
VarBoolFromUI2(USHORT uiIn
, VARIANT_BOOL
* pboolOut
)
3491 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pboolOut
);
3495 *pboolOut
= VARIANT_FALSE
;
3499 *pboolOut
= VARIANT_TRUE
;
3505 /******************************************************************************
3506 * VarBoolFromUI432 [OLEAUT32.235]
3508 HRESULT WINAPI
VarBoolFromUI4(ULONG ulIn
, VARIANT_BOOL
* pboolOut
)
3510 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pboolOut
);
3514 *pboolOut
= VARIANT_FALSE
;
3518 *pboolOut
= VARIANT_TRUE
;
3524 /**********************************************************************
3525 * VarBoolFromCy32 [OLEAUT32.124]
3526 * Convert currency to boolean
3528 HRESULT WINAPI
VarBoolFromCy(CY cyIn
, VARIANT_BOOL
* pboolOut
) {
3529 if (cyIn
.u
.Hi
|| cyIn
.u
.Lo
) *pboolOut
= -1;
3535 /******************************************************************************
3536 * VarI1FromUI132 [OLEAUT32.244]
3538 HRESULT WINAPI
VarI1FromUI1(BYTE bIn
, CHAR
* pcOut
)
3540 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pcOut
);
3542 /* Check range of value.
3544 if( bIn
> CHAR_MAX
)
3546 return DISP_E_OVERFLOW
;
3549 *pcOut
= (CHAR
) bIn
;
3554 /******************************************************************************
3555 * VarI1FromI232 [OLEAUT32.245]
3557 HRESULT WINAPI
VarI1FromI2(short uiIn
, CHAR
* pcOut
)
3559 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pcOut
);
3561 if( uiIn
> CHAR_MAX
)
3563 return DISP_E_OVERFLOW
;
3566 *pcOut
= (CHAR
) uiIn
;
3571 /******************************************************************************
3572 * VarI1FromI432 [OLEAUT32.246]
3574 HRESULT WINAPI
VarI1FromI4(LONG lIn
, CHAR
* pcOut
)
3576 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pcOut
);
3578 if( lIn
< CHAR_MIN
|| lIn
> CHAR_MAX
)
3580 return DISP_E_OVERFLOW
;
3583 *pcOut
= (CHAR
) lIn
;
3588 /******************************************************************************
3589 * VarI1FromR432 [OLEAUT32.247]
3591 HRESULT WINAPI
VarI1FromR4(FLOAT fltIn
, CHAR
* pcOut
)
3593 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pcOut
);
3595 fltIn
= round( fltIn
);
3596 if( fltIn
< CHAR_MIN
|| fltIn
> CHAR_MAX
)
3598 return DISP_E_OVERFLOW
;
3601 *pcOut
= (CHAR
) fltIn
;
3606 /******************************************************************************
3607 * VarI1FromR832 [OLEAUT32.248]
3609 HRESULT WINAPI
VarI1FromR8(double dblIn
, CHAR
* pcOut
)
3611 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pcOut
);
3613 dblIn
= round( dblIn
);
3614 if( dblIn
< CHAR_MIN
|| dblIn
> CHAR_MAX
)
3616 return DISP_E_OVERFLOW
;
3619 *pcOut
= (CHAR
) dblIn
;
3624 /******************************************************************************
3625 * VarI1FromDate32 [OLEAUT32.249]
3627 HRESULT WINAPI
VarI1FromDate(DATE dateIn
, CHAR
* pcOut
)
3629 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pcOut
);
3631 dateIn
= round( dateIn
);
3632 if( dateIn
< CHAR_MIN
|| dateIn
> CHAR_MAX
)
3634 return DISP_E_OVERFLOW
;
3637 *pcOut
= (CHAR
) dateIn
;
3642 /******************************************************************************
3643 * VarI1FromStr32 [OLEAUT32.251]
3645 HRESULT WINAPI
VarI1FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, CHAR
* pcOut
)
3647 double dValue
= 0.0;
3648 LPSTR pNewString
= NULL
;
3650 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pcOut
);
3652 /* Check if we have a valid argument
3654 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3655 RemoveCharacterFromString( pNewString
, "," );
3656 if( IsValidRealString( pNewString
) == FALSE
)
3658 return DISP_E_TYPEMISMATCH
;
3661 /* Convert the valid string to a floating point number.
3663 dValue
= atof( pNewString
);
3665 /* We don't need the string anymore so free it.
3667 HeapFree( GetProcessHeap(), 0, pNewString
);
3669 /* Check range of value.
3671 dValue
= round( dValue
);
3672 if( dValue
< CHAR_MIN
|| dValue
> CHAR_MAX
)
3674 return DISP_E_OVERFLOW
;
3677 *pcOut
= (CHAR
) dValue
;
3682 /******************************************************************************
3683 * VarI1FromBool32 [OLEAUT32.253]
3685 HRESULT WINAPI
VarI1FromBool(VARIANT_BOOL boolIn
, CHAR
* pcOut
)
3687 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pcOut
);
3689 *pcOut
= (CHAR
) boolIn
;
3694 /******************************************************************************
3695 * VarI1FromUI232 [OLEAUT32.254]
3697 HRESULT WINAPI
VarI1FromUI2(USHORT uiIn
, CHAR
* pcOut
)
3699 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pcOut
);
3701 if( uiIn
> CHAR_MAX
)
3703 return DISP_E_OVERFLOW
;
3706 *pcOut
= (CHAR
) uiIn
;
3711 /******************************************************************************
3712 * VarI1FromUI432 [OLEAUT32.255]
3714 HRESULT WINAPI
VarI1FromUI4(ULONG ulIn
, CHAR
* pcOut
)
3716 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pcOut
);
3718 if( ulIn
> CHAR_MAX
)
3720 return DISP_E_OVERFLOW
;
3723 *pcOut
= (CHAR
) ulIn
;
3728 /**********************************************************************
3729 * VarI1FromCy32 [OLEAUT32.250]
3730 * Convert currency to signed char
3732 HRESULT WINAPI
VarI1FromCy(CY cyIn
, CHAR
* pcOut
) {
3733 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
3735 if (t
> CHAR_MAX
|| t
< CHAR_MIN
) return DISP_E_OVERFLOW
;
3741 /******************************************************************************
3742 * VarUI2FromUI132 [OLEAUT32.257]
3744 HRESULT WINAPI
VarUI2FromUI1(BYTE bIn
, USHORT
* puiOut
)
3746 TRACE( ole
, "( %d, %p ), stub\n", bIn
, puiOut
);
3748 *puiOut
= (USHORT
) bIn
;
3753 /******************************************************************************
3754 * VarUI2FromI232 [OLEAUT32.258]
3756 HRESULT WINAPI
VarUI2FromI2(short uiIn
, USHORT
* puiOut
)
3758 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, puiOut
);
3760 if( uiIn
< UI2_MIN
)
3762 return DISP_E_OVERFLOW
;
3765 *puiOut
= (USHORT
) uiIn
;
3770 /******************************************************************************
3771 * VarUI2FromI432 [OLEAUT32.259]
3773 HRESULT WINAPI
VarUI2FromI4(LONG lIn
, USHORT
* puiOut
)
3775 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, puiOut
);
3777 if( lIn
< UI2_MIN
|| lIn
> UI2_MAX
)
3779 return DISP_E_OVERFLOW
;
3782 *puiOut
= (USHORT
) lIn
;
3787 /******************************************************************************
3788 * VarUI2FromR432 [OLEAUT32.260]
3790 HRESULT WINAPI
VarUI2FromR4(FLOAT fltIn
, USHORT
* puiOut
)
3792 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, puiOut
);
3794 fltIn
= round( fltIn
);
3795 if( fltIn
< UI2_MIN
|| fltIn
> UI2_MAX
)
3797 return DISP_E_OVERFLOW
;
3800 *puiOut
= (USHORT
) fltIn
;
3805 /******************************************************************************
3806 * VarUI2FromR832 [OLEAUT32.261]
3808 HRESULT WINAPI
VarUI2FromR8(double dblIn
, USHORT
* puiOut
)
3810 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, puiOut
);
3812 dblIn
= round( dblIn
);
3813 if( dblIn
< UI2_MIN
|| dblIn
> UI2_MAX
)
3815 return DISP_E_OVERFLOW
;
3818 *puiOut
= (USHORT
) dblIn
;
3823 /******************************************************************************
3824 * VarUI2FromDate32 [OLEAUT32.262]
3826 HRESULT WINAPI
VarUI2FromDate(DATE dateIn
, USHORT
* puiOut
)
3828 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, puiOut
);
3830 dateIn
= round( dateIn
);
3831 if( dateIn
< UI2_MIN
|| dateIn
> UI2_MAX
)
3833 return DISP_E_OVERFLOW
;
3836 *puiOut
= (USHORT
) dateIn
;
3841 /******************************************************************************
3842 * VarUI2FromStr32 [OLEAUT32.264]
3844 HRESULT WINAPI
VarUI2FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, USHORT
* puiOut
)
3846 double dValue
= 0.0;
3847 LPSTR pNewString
= NULL
;
3849 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, puiOut
);
3851 /* Check if we have a valid argument
3853 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3854 RemoveCharacterFromString( pNewString
, "," );
3855 if( IsValidRealString( pNewString
) == FALSE
)
3857 return DISP_E_TYPEMISMATCH
;
3860 /* Convert the valid string to a floating point number.
3862 dValue
= atof( pNewString
);
3864 /* We don't need the string anymore so free it.
3866 HeapFree( GetProcessHeap(), 0, pNewString
);
3868 /* Check range of value.
3870 dValue
= round( dValue
);
3871 if( dValue
< UI2_MIN
|| dValue
> UI2_MAX
)
3873 return DISP_E_OVERFLOW
;
3876 *puiOut
= (USHORT
) dValue
;
3881 /******************************************************************************
3882 * VarUI2FromBool32 [OLEAUT32.266]
3884 HRESULT WINAPI
VarUI2FromBool(VARIANT_BOOL boolIn
, USHORT
* puiOut
)
3886 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, puiOut
);
3888 *puiOut
= (USHORT
) boolIn
;
3893 /******************************************************************************
3894 * VarUI2FromI132 [OLEAUT32.267]
3896 HRESULT WINAPI
VarUI2FromI1(CHAR cIn
, USHORT
* puiOut
)
3898 TRACE( ole
, "( %c, %p ), stub\n", cIn
, puiOut
);
3900 *puiOut
= (USHORT
) cIn
;
3905 /******************************************************************************
3906 * VarUI2FromUI432 [OLEAUT32.268]
3908 HRESULT WINAPI
VarUI2FromUI4(ULONG ulIn
, USHORT
* puiOut
)
3910 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, puiOut
);
3912 if( ulIn
< UI2_MIN
|| ulIn
> UI2_MAX
)
3914 return DISP_E_OVERFLOW
;
3917 *puiOut
= (USHORT
) ulIn
;
3922 /******************************************************************************
3923 * VarUI4FromStr32 [OLEAUT32.277]
3925 HRESULT WINAPI
VarUI4FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, ULONG
* pulOut
)
3927 double dValue
= 0.0;
3928 LPSTR pNewString
= NULL
;
3930 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pulOut
);
3932 /* Check if we have a valid argument
3934 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3935 RemoveCharacterFromString( pNewString
, "," );
3936 if( IsValidRealString( pNewString
) == FALSE
)
3938 return DISP_E_TYPEMISMATCH
;
3941 /* Convert the valid string to a floating point number.
3943 dValue
= atof( pNewString
);
3945 /* We don't need the string anymore so free it.
3947 HeapFree( GetProcessHeap(), 0, pNewString
);
3949 /* Check range of value.
3951 dValue
= round( dValue
);
3952 if( dValue
< UI4_MIN
|| dValue
> UI4_MAX
)
3954 return DISP_E_OVERFLOW
;
3957 *pulOut
= (ULONG
) dValue
;
3962 /**********************************************************************
3963 * VarUI2FromCy32 [OLEAUT32.263]
3964 * Convert currency to unsigned short
3966 HRESULT WINAPI
VarUI2FromCy(CY cyIn
, USHORT
* pusOut
) {
3967 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
3969 if (t
> UI2_MAX
|| t
< UI2_MIN
) return DISP_E_OVERFLOW
;
3971 *pusOut
= (USHORT
)t
;
3976 /******************************************************************************
3977 * VarUI4FromUI132 [OLEAUT32.270]
3979 HRESULT WINAPI
VarUI4FromUI1(BYTE bIn
, ULONG
* pulOut
)
3981 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pulOut
);
3983 *pulOut
= (USHORT
) bIn
;
3988 /******************************************************************************
3989 * VarUI4FromI232 [OLEAUT32.271]
3991 HRESULT WINAPI
VarUI4FromI2(short uiIn
, ULONG
* pulOut
)
3993 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pulOut
);
3995 if( uiIn
< UI4_MIN
)
3997 return DISP_E_OVERFLOW
;
4000 *pulOut
= (ULONG
) uiIn
;
4005 /******************************************************************************
4006 * VarUI4FromI432 [OLEAUT32.272]
4008 HRESULT WINAPI
VarUI4FromI4(LONG lIn
, ULONG
* pulOut
)
4010 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pulOut
);
4014 return DISP_E_OVERFLOW
;
4017 *pulOut
= (ULONG
) lIn
;
4022 /******************************************************************************
4023 * VarUI4FromR432 [OLEAUT32.273]
4025 HRESULT WINAPI
VarUI4FromR4(FLOAT fltIn
, ULONG
* pulOut
)
4027 fltIn
= round( fltIn
);
4028 if( fltIn
< UI4_MIN
|| fltIn
> UI4_MAX
)
4030 return DISP_E_OVERFLOW
;
4033 *pulOut
= (ULONG
) fltIn
;
4038 /******************************************************************************
4039 * VarUI4FromR832 [OLEAUT32.274]
4041 HRESULT WINAPI
VarUI4FromR8(double dblIn
, ULONG
* pulOut
)
4043 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pulOut
);
4045 dblIn
= round( dblIn
);
4046 if( dblIn
< UI4_MIN
|| dblIn
> UI4_MAX
)
4048 return DISP_E_OVERFLOW
;
4051 *pulOut
= (ULONG
) dblIn
;
4056 /******************************************************************************
4057 * VarUI4FromDate32 [OLEAUT32.275]
4059 HRESULT WINAPI
VarUI4FromDate(DATE dateIn
, ULONG
* pulOut
)
4061 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pulOut
);
4063 dateIn
= round( dateIn
);
4064 if( dateIn
< UI4_MIN
|| dateIn
> UI4_MAX
)
4066 return DISP_E_OVERFLOW
;
4069 *pulOut
= (ULONG
) dateIn
;
4074 /******************************************************************************
4075 * VarUI4FromBool32 [OLEAUT32.279]
4077 HRESULT WINAPI
VarUI4FromBool(VARIANT_BOOL boolIn
, ULONG
* pulOut
)
4079 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pulOut
);
4081 *pulOut
= (ULONG
) boolIn
;
4086 /******************************************************************************
4087 * VarUI4FromI132 [OLEAUT32.280]
4089 HRESULT WINAPI
VarUI4FromI1(CHAR cIn
, ULONG
* pulOut
)
4091 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pulOut
);
4093 *pulOut
= (ULONG
) cIn
;
4098 /******************************************************************************
4099 * VarUI4FromUI232 [OLEAUT32.281]
4101 HRESULT WINAPI
VarUI4FromUI2(USHORT uiIn
, ULONG
* pulOut
)
4103 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pulOut
);
4105 *pulOut
= (ULONG
) uiIn
;
4110 /**********************************************************************
4111 * VarUI4FromCy32 [OLEAUT32.276]
4112 * Convert currency to unsigned long
4114 HRESULT WINAPI
VarUI4FromCy(CY cyIn
, ULONG
* pulOut
) {
4115 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
4117 if (t
> UI4_MAX
|| t
< UI4_MIN
) return DISP_E_OVERFLOW
;
4124 /**********************************************************************
4125 * VarCyFromUI132 [OLEAUT32.98]
4126 * Convert unsigned char to currency
4128 HRESULT WINAPI
VarCyFromUI1(BYTE bIn
, CY
* pcyOut
) {
4130 pcyOut
->u
.Lo
= ((ULONG
)bIn
) * 10000;
4135 /**********************************************************************
4136 * VarCyFromI232 [OLEAUT32.99]
4137 * Convert signed short to currency
4139 HRESULT WINAPI
VarCyFromI2(short sIn
, CY
* pcyOut
) {
4140 if (sIn
< 0) pcyOut
->u
.Hi
= -1;
4141 else pcyOut
->u
.Hi
= 0;
4142 pcyOut
->u
.Lo
= ((ULONG
)sIn
) * 10000;
4147 /**********************************************************************
4148 * VarCyFromI432 [OLEAUT32.100]
4149 * Convert signed long to currency
4151 HRESULT WINAPI
VarCyFromI4(LONG lIn
, CY
* pcyOut
) {
4152 double t
= (double)lIn
* (double)10000;
4153 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4154 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4155 if (lIn
< 0) pcyOut
->u
.Hi
--;
4160 /**********************************************************************
4161 * VarCyFromR432 [OLEAUT32.101]
4162 * Convert float to currency
4164 HRESULT WINAPI
VarCyFromR4(FLOAT fltIn
, CY
* pcyOut
) {
4165 double t
= round((double)fltIn
* (double)10000);
4166 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4167 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4168 if (fltIn
< 0) pcyOut
->u
.Hi
--;
4173 /**********************************************************************
4174 * VarCyFromR832 [OLEAUT32.102]
4175 * Convert double to currency
4177 HRESULT WINAPI
VarCyFromR8(double dblIn
, CY
* pcyOut
) {
4178 double t
= round(dblIn
* (double)10000);
4179 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4180 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4181 if (dblIn
< 0) pcyOut
->u
.Hi
--;
4186 /**********************************************************************
4187 * VarCyFromDate32 [OLEAUT32.103]
4188 * Convert date to currency
4190 HRESULT WINAPI
VarCyFromDate(DATE dateIn
, CY
* pcyOut
) {
4191 double t
= round((double)dateIn
* (double)10000);
4192 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4193 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4194 if (dateIn
< 0) pcyOut
->u
.Hi
--;
4199 /**********************************************************************
4200 * VarCyFromBool32 [OLEAUT32.106]
4201 * Convert boolean to currency
4203 HRESULT WINAPI
VarCyFromBool(VARIANT_BOOL boolIn
, CY
* pcyOut
) {
4204 if (boolIn
< 0) pcyOut
->u
.Hi
= -1;
4205 else pcyOut
->u
.Hi
= 0;
4206 pcyOut
->u
.Lo
= (ULONG
)boolIn
* (ULONG
)10000;
4211 /**********************************************************************
4212 * VarCyFromI132 [OLEAUT32.225]
4213 * Convert signed char to currency
4215 HRESULT WINAPI
VarCyFromI1(CHAR cIn
, CY
* pcyOut
) {
4216 if (cIn
< 0) pcyOut
->u
.Hi
= -1;
4217 else pcyOut
->u
.Hi
= 0;
4218 pcyOut
->u
.Lo
= (ULONG
)cIn
* (ULONG
)10000;
4223 /**********************************************************************
4224 * VarCyFromUI232 [OLEAUT32.226]
4225 * Convert unsigned short to currency
4227 HRESULT WINAPI
VarCyFromUI2(USHORT usIn
, CY
* pcyOut
) {
4229 pcyOut
->u
.Lo
= (ULONG
)usIn
* (ULONG
)10000;
4234 /**********************************************************************
4235 * VarCyFromUI432 [OLEAUT32.227]
4236 * Convert unsigned long to currency
4238 HRESULT WINAPI
VarCyFromUI4(ULONG ulIn
, CY
* pcyOut
) {
4239 double t
= (double)ulIn
* (double)10000;
4240 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4241 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4247 /**********************************************************************
4248 * DosDateTimeToVariantTime [OLEAUT32.14]
4249 * Convert dos representation of time to the date and time representation
4250 * stored in a variant.
4252 INT WINAPI
DosDateTimeToVariantTime(USHORT wDosDate
, USHORT wDosTime
,
4257 TRACE( ole
, "( 0x%x, 0x%x, 0x%p ), stub\n", wDosDate
, wDosTime
, pvtime
);
4259 t
.tm_sec
= (wDosTime
& 0x001f) * 2;
4260 t
.tm_min
= (wDosTime
& 0x07e0) >> 5;
4261 t
.tm_hour
= (wDosTime
& 0xf800) >> 11;
4263 t
.tm_mday
= (wDosDate
& 0x001f);
4264 t
.tm_mon
= (wDosDate
& 0x01e0) >> 5;
4265 t
.tm_year
= ((wDosDate
& 0xfe00) >> 9) + 1980;
4267 return TmToDATE( &t
, pvtime
);