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.
42 # define FLT_MAX MAXFLOAT
44 # error "Can't find #define for MAXFLOAT/FLT_MAX"
50 static const char CHAR_MAX
= 127;
51 static const char CHAR_MIN
= -128;
52 static const BYTE UI1_MAX
= 255;
53 static const BYTE UI1_MIN
= 0;
54 static const unsigned short UI2_MAX
= 65535;
55 static const unsigned short UI2_MIN
= 0;
56 static const short I2_MAX
= 32767;
57 static const short I2_MIN
= -32768;
58 static const unsigned long UI4_MAX
= 4294967295U;
59 static const unsigned long UI4_MIN
= 0;
60 static const long I4_MAX
= 2147483647;
61 static const long I4_MIN
= -(2147483648U);
62 static const DATE DATE_MIN
= -657434;
63 static const DATE DATE_MAX
= 2958465;
66 /* This mask is used to set a flag in wReserved1 of
67 * the VARIANTARG structure. The flag indicates if
68 * the API function is using an inner variant or not.
70 #define PROCESSING_INNER_VARIANT 0x0001
72 /* General use buffer.
74 #define BUFFER_MAX 1024
75 static char pBuffer
[BUFFER_MAX
];
78 * Note a leap year is one that is a multiple of 4
79 * but not of a 100. Except if it is a multiple of
80 * 400 then it is a leap year.
82 /* According to postgeSQL date parsing functions there is
83 * a leap year when this expression is true.
84 * (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
85 * So according to this there is 365.2515 days in one year.
86 * One + every four years: 1/4 -> 365.25
87 * One - every 100 years: 1/100 -> 365.001
88 * One + every 400 years: 1/400 -> 365.0025
90 static const double DAYS_IN_ONE_YEAR
= 365.2515;
94 /******************************************************************************
95 * DateTimeStringToTm [INTERNAL]
97 * Converts a string representation of a date and/or time to a tm structure.
99 * Note this function uses the postgresql date parsing functions found
100 * in the parsedt.c file.
102 * Returns TRUE if successfull.
104 * Note: This function does not parse the day of the week,
105 * daylight savings time. It will only fill the followin fields in
106 * the tm struct, tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
108 ******************************************************************************/
109 static BOOL32
DateTimeStringToTm( OLECHAR32
* strIn
, LCID lcid
, struct tm
* pTm
)
116 char *field
[MAXDATEFIELDS
];
117 int ftype
[MAXDATEFIELDS
];
118 char lowstr
[MAXDATELEN
+ 1];
119 char* strDateTime
= NULL
;
121 /* Convert the string to ASCII since this is the only format
122 * postgesql can handle.
124 strDateTime
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
126 if( strDateTime
!= NULL
)
128 /* Make sure we don't go over the maximum length
129 * accepted by postgesql.
131 if( strlen( strDateTime
) <= MAXDATELEN
)
133 if( ParseDateTime( strDateTime
, lowstr
, field
, ftype
, MAXDATEFIELDS
, &nf
) == 0 )
135 if( lcid
& VAR_DATEVALUEONLY
)
137 /* Get the date information.
138 * It returns 0 if date information was
139 * present and 1 if only time information was present.
140 * -1 if an error occures.
142 if( DecodeDateTime(field
, ftype
, nf
, &dtype
, pTm
, &fsec
, &tzp
) == 0 )
144 /* Eliminate the time information since we
145 * were asked to get date information only.
153 if( lcid
& VAR_TIMEVALUEONLY
)
155 /* Get time information only.
157 if( DecodeTimeOnly(field
, ftype
, nf
, &dtype
, pTm
, &fsec
) == 0 )
164 /* Get both date and time information.
165 * It returns 0 if date information was
166 * present and 1 if only time information was present.
167 * -1 if an error occures.
169 if( DecodeDateTime(field
, ftype
, nf
, &dtype
, pTm
, &fsec
, &tzp
) != -1 )
176 HeapFree( GetProcessHeap(), 0, strDateTime
);
187 /******************************************************************************
188 * TmToDATE [INTERNAL]
190 * The date is implemented using an 8 byte floating-point number.
191 * Days are represented by whole numbers increments starting with 0.00 has
192 * being December 30 1899, midnight.
193 * The hours are expressed as the fractional part of the number.
194 * December 30 1899 at midnight = 0.00
195 * January 1 1900 at midnight = 2.00
196 * January 4 1900 at 6 AM = 5.25
197 * January 4 1900 at noon = 5.50
198 * December 29 1899 at midnight = -1.00
199 * December 18 1899 at midnight = -12.00
200 * December 18 1899 at 6AM = -12.25
201 * December 18 1899 at 6PM = -12.75
202 * December 19 1899 at midnight = -11.00
203 * The tm structure is as follows:
205 * int tm_sec; seconds after the minute - [0,59]
206 * int tm_min; minutes after the hour - [0,59]
207 * int tm_hour; hours since midnight - [0,23]
208 * int tm_mday; day of the month - [1,31]
209 * int tm_mon; months since January - [0,11]
211 * int tm_wday; days since Sunday - [0,6]
212 * int tm_yday; days since January 1 - [0,365]
213 * int tm_isdst; daylight savings time flag
216 * Note: This function does not use the tm_wday, tm_yday, tm_wday,
217 * and tm_isdst fields of the tm structure. And only converts years
220 * Returns TRUE if successfull.
222 static BOOL32
TmToDATE( struct tm
* pTm
, DATE
*pDateOut
)
224 if( (pTm
->tm_year
- 1900) >= 0 )
228 /* Start at 1. This is the way DATE is defined.
229 * January 1, 1900 at Midnight is 1.00.
230 * January 1, 1900 at 6AM is 1.25.
235 /* Add the number of days corresponding to
238 *pDateOut
+= (pTm
->tm_year
- 1900) * 365;
240 /* Add the leap days in the previous years between now and 1900.
241 * Note a leap year is one that is a multiple of 4
242 * but not of a 100. Except if it is a multiple of
243 * 400 then it is a leap year.
245 *pDateOut
+= ( (pTm
->tm_year
- 1) / 4 ) - ( 1900 / 4 );
246 *pDateOut
-= ( (pTm
->tm_year
- 1) / 100 ) - ( 1900 / 100 );
247 *pDateOut
+= ( (pTm
->tm_year
- 1) / 400 ) - ( 1900 / 400 );
249 /* Set the leap year flag if the
250 * current year specified by tm_year is a
251 * leap year. This will be used to add a day
254 if( isleap( pTm
->tm_year
) )
257 /* Add the number of days corresponding to
260 switch( pTm
->tm_mon
)
266 *pDateOut
+= ( 59 + leapYear
);
269 *pDateOut
+= ( 90 + leapYear
);
272 *pDateOut
+= ( 120 + leapYear
);
275 *pDateOut
+= ( 151 + leapYear
);
278 *pDateOut
+= ( 181 + leapYear
);
281 *pDateOut
+= ( 212 + leapYear
);
284 *pDateOut
+= ( 243 + leapYear
);
287 *pDateOut
+= ( 273 + leapYear
);
290 *pDateOut
+= ( 304 + leapYear
);
293 *pDateOut
+= ( 334 + leapYear
);
296 /* Add the number of days in this month.
298 *pDateOut
+= pTm
->tm_mday
;
300 /* Add the number of seconds, minutes, and hours
301 * to the DATE. Note these are the fracionnal part
302 * of the DATE so seconds / number of seconds in a day.
304 *pDateOut
+= pTm
->tm_hour
/ 24.0;
305 *pDateOut
+= pTm
->tm_min
/ 1440.0;
306 *pDateOut
+= pTm
->tm_sec
/ 86400.0;
312 /******************************************************************************
313 * DateToTm [INTERNAL]
315 * This function converst a windows DATE to a tm structure.
317 * It does not fill all the fields of the tm structure.
318 * Here is a list of the fields that are filled:
319 * tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
321 * Note this function does not support dates before the January 1, 1900
322 * or ( dateIn < 2.0 ).
324 * Returns TRUE if successfull.
326 static BOOL32
DateToTm( DATE dateIn
, LCID lcid
, struct tm
* pTm
)
328 /* Do not process dates smaller than January 1, 1900.
329 * Which corresponds to 2.0 in the windows DATE format.
333 double decimalPart
= 0.0;
334 double wholePart
= 0.0;
348 /* Because of the nature of DATE format witch
349 * associates 2.0 to January 1, 1900. We will
350 * remove 1.0 from the whole part of the DATE
351 * so that in the following code 1.0
352 * will correspond to January 1, 1900.
353 * This simplyfies the processing of the DATE value.
357 wholePart
= (double) floor( dateIn
);
358 decimalPart
= fmod( dateIn
, wholePart
);
360 if( !(lcid
& VAR_TIMEVALUEONLY
) )
364 double yearsSince1900
= 0;
365 /* Start at 1900, this where the DATE time 0.0 starts.
368 /* find in what year the day in the "wholePart" falls into.
369 * add the value to the year field.
371 yearsSince1900
= floor( wholePart
/ DAYS_IN_ONE_YEAR
);
372 pTm
->tm_year
+= yearsSince1900
;
373 /* determine if this is a leap year.
375 if( isleap( pTm
->tm_year
) )
377 /* find what day of that year does the "wholePart" corresponds to.
378 * Note: nDay is in [1-366] format
380 nDay
= (int) ( wholePart
- floor( yearsSince1900
* DAYS_IN_ONE_YEAR
) );
381 /* Set the tm_yday value.
382 * Note: The day is must be converted from [1-366] to [0-365]
384 //pTm->tm_yday = nDay - 1;
385 /* find which mount this day corresponds to.
392 else if( nDay
<= ( 59 + leapYear
) )
394 pTm
->tm_mday
= nDay
- 31;
397 else if( nDay
<= ( 90 + leapYear
) )
399 pTm
->tm_mday
= nDay
- ( 59 + leapYear
);
402 else if( nDay
<= ( 120 + leapYear
) )
404 pTm
->tm_mday
= nDay
- ( 90 + leapYear
);
407 else if( nDay
<= ( 151 + leapYear
) )
409 pTm
->tm_mday
= nDay
- ( 120 + leapYear
);
412 else if( nDay
<= ( 181 + leapYear
) )
414 pTm
->tm_mday
= nDay
- ( 151 + leapYear
);
417 else if( nDay
<= ( 212 + leapYear
) )
419 pTm
->tm_mday
= nDay
- ( 181 + leapYear
);
422 else if( nDay
<= ( 243 + leapYear
) )
424 pTm
->tm_mday
= nDay
- ( 212 + leapYear
);
427 else if( nDay
<= ( 273 + leapYear
) )
429 pTm
->tm_mday
= nDay
- ( 243 + leapYear
);
432 else if( nDay
<= ( 304 + leapYear
) )
434 pTm
->tm_mday
= nDay
- ( 273 + leapYear
);
437 else if( nDay
<= ( 334 + leapYear
) )
439 pTm
->tm_mday
= nDay
- ( 304 + leapYear
);
442 else if( nDay
<= ( 365 + leapYear
) )
444 pTm
->tm_mday
= nDay
- ( 334 + leapYear
);
448 if( !(lcid
& VAR_DATEVALUEONLY
) )
450 /* find the number of seconds in this day.
451 * fractional part times, hours, minutes, seconds.
453 pTm
->tm_hour
= (int) ( decimalPart
* 24 );
454 pTm
->tm_min
= (int) ( ( ( decimalPart
* 24 ) - pTm
->tm_hour
) * 60 );
455 pTm
->tm_sec
= (int) ( ( ( decimalPart
* 24 * 60 ) - ( pTm
->tm_hour
* 60 ) - pTm
->tm_min
) * 60 );
464 /******************************************************************************
465 * SizeOfVariantData [INTERNAL]
467 * This function finds the size of the data referenced by a Variant based
468 * the type "vt" of the Variant.
470 static int SizeOfVariantData( VARIANT
* parg
)
473 switch( parg
->vt
& VT_TYPEMASK
)
476 size
= sizeof(short);
488 size
= sizeof(unsigned short);
491 size
= sizeof(unsigned int);
494 size
= sizeof(unsigned long);
497 size
= sizeof(float);
500 size
= sizeof(double);
506 size
= sizeof(VARIANT_BOOL
);
509 size
= sizeof(void*);
516 FIXME(ole
,"Add size information for type vt=%d\n", parg
->vt
& VT_TYPEMASK
);
522 /******************************************************************************
523 * StringDupAtoBstr [INTERNAL]
526 static BSTR32
StringDupAtoBstr( char* strIn
)
529 OLECHAR32
* pNewString
= NULL
;
530 pNewString
= HEAP_strdupAtoW( GetProcessHeap(), 0, strIn
);
531 bstr
= SysAllocString32( pNewString
);
532 HeapFree( GetProcessHeap(), 0, pNewString
);
536 /******************************************************************************
539 * Round the double value to the nearest integer value.
541 static double round( double d
)
543 double decimals
= 0.0, integerValue
= 0.0, roundedValue
= 0.0;
544 BOOL32 bEvenNumber
= FALSE
;
547 /* Save the sign of the number
549 nSign
= (d
>= 0.0) ? 1 : -1;
552 /* Remove the decimals.
554 integerValue
= floor( d
);
556 /* Set the Even flag. This is used to round the number when
557 * the decimals are exactly 1/2. If the integer part is
558 * odd the number is rounded up. If the integer part
559 * is even the number is rounded down. Using this method
560 * numbers are rounded up|down half the time.
562 bEvenNumber
= (((short)fmod(integerValue
, 2)) == 0) ? TRUE
: FALSE
;
564 /* Remove the integral part of the number.
566 decimals
= d
- integerValue
;
568 /* Note: Ceil returns the smallest integer that is greater that x.
569 * and floor returns the largest integer that is less than or equal to x.
573 /* If the decimal part is greater than 1/2
575 roundedValue
= ceil( d
);
577 else if( decimals
< 0.5 )
579 /* If the decimal part is smaller than 1/2
581 roundedValue
= floor( d
);
585 /* the decimals are exactly 1/2 so round according to
586 * the bEvenNumber flag.
590 roundedValue
= floor( d
);
594 roundedValue
= ceil( d
);
598 return roundedValue
* nSign
;
601 /******************************************************************************
602 * RemoveCharacterFromString [INTERNAL]
604 * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
606 static void RemoveCharacterFromString( LPSTR str
, LPSTR strOfCharToRemove
)
608 LPSTR pNewString
= NULL
;
609 LPSTR strToken
= NULL
;
612 /* Check if we have a valid argument
616 pNewString
= strdup( str
);
618 strToken
= strtok( pNewString
, strOfCharToRemove
);
619 while( strToken
!= NULL
) {
620 strcat( str
, strToken
);
621 strToken
= strtok( NULL
, strOfCharToRemove
);
628 /******************************************************************************
629 * GetValidRealString [INTERNAL]
631 * Checks if the string is of proper format to be converted to a real value.
633 static BOOL32
IsValidRealString( LPSTR strRealString
)
635 /* Real values that have a decimal point are required to either have
636 * digits before or after the decimal point. We will assume that
637 * we do not have any digits at either position. If we do encounter
638 * some we will disable this flag.
640 BOOL32 bDigitsRequired
= TRUE
;
641 /* Processed fields in the string representation of the real number.
643 BOOL32 bWhiteSpaceProcessed
= FALSE
;
644 BOOL32 bFirstSignProcessed
= FALSE
;
645 BOOL32 bFirstDigitsProcessed
= FALSE
;
646 BOOL32 bDecimalPointProcessed
= FALSE
;
647 BOOL32 bSecondDigitsProcessed
= FALSE
;
648 BOOL32 bExponentProcessed
= FALSE
;
649 BOOL32 bSecondSignProcessed
= FALSE
;
650 BOOL32 bThirdDigitsProcessed
= FALSE
;
651 /* Assume string parameter "strRealString" is valid and try to disprove it.
653 BOOL32 bValidRealString
= TRUE
;
655 /* Used to count the number of tokens in the "strRealString".
657 LPSTR strToken
= NULL
;
661 /* Check if we have a valid argument
663 if( strRealString
== NULL
)
665 bValidRealString
= FALSE
;
668 if( bValidRealString
== TRUE
)
670 /* Make sure we only have ONE token in the string.
672 strToken
= strtok( strRealString
, " " );
673 while( strToken
!= NULL
) {
675 strToken
= strtok( NULL
, " " );
680 bValidRealString
= FALSE
;
685 /* Make sure this token contains only valid characters.
686 * The string argument to atof has the following form:
687 * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
688 * Whitespace consists of space and|or <TAB> characters, which are ignored.
689 * Sign is either plus '+' or minus '-'.
690 * Digits are one or more decimal digits.
691 * Note: If no digits appear before the decimal point, at least one must
692 * appear after the decimal point.
693 * The decimal digits may be followed by an exponent.
694 * An Exponent consists of an introductory letter ( D, d, E, or e) and
695 * an optionally signed decimal integer.
697 pChar
= strRealString
;
698 while( bValidRealString
== TRUE
&& *pChar
!= '\0' )
706 if( bWhiteSpaceProcessed
||
707 bFirstSignProcessed
||
708 bFirstDigitsProcessed
||
709 bDecimalPointProcessed
||
710 bSecondDigitsProcessed
||
711 bExponentProcessed
||
712 bSecondSignProcessed
||
713 bThirdDigitsProcessed
)
715 bValidRealString
= FALSE
;
722 if( bFirstSignProcessed
== FALSE
)
724 if( bFirstDigitsProcessed
||
725 bDecimalPointProcessed
||
726 bSecondDigitsProcessed
||
727 bExponentProcessed
||
728 bSecondSignProcessed
||
729 bThirdDigitsProcessed
)
731 bValidRealString
= FALSE
;
733 bWhiteSpaceProcessed
= TRUE
;
734 bFirstSignProcessed
= TRUE
;
736 else if( bSecondSignProcessed
== FALSE
)
738 /* Note: The exponent must be present in
739 * order to accept the second sign...
741 if( bExponentProcessed
== FALSE
||
742 bThirdDigitsProcessed
||
745 bValidRealString
= FALSE
;
747 bFirstSignProcessed
= TRUE
;
748 bWhiteSpaceProcessed
= TRUE
;
749 bFirstDigitsProcessed
= TRUE
;
750 bDecimalPointProcessed
= TRUE
;
751 bSecondDigitsProcessed
= TRUE
;
752 bSecondSignProcessed
= TRUE
;
768 if( bFirstDigitsProcessed
== FALSE
)
770 if( bDecimalPointProcessed
||
771 bSecondDigitsProcessed
||
772 bExponentProcessed
||
773 bSecondSignProcessed
||
774 bThirdDigitsProcessed
)
776 bValidRealString
= FALSE
;
778 bFirstSignProcessed
= TRUE
;
779 bWhiteSpaceProcessed
= TRUE
;
780 /* We have found some digits before the decimal point
781 * so disable the "Digits required" flag.
783 bDigitsRequired
= FALSE
;
785 else if( bSecondDigitsProcessed
== FALSE
)
787 if( bExponentProcessed
||
788 bSecondSignProcessed
||
789 bThirdDigitsProcessed
)
791 bValidRealString
= FALSE
;
793 bFirstSignProcessed
= TRUE
;
794 bWhiteSpaceProcessed
= TRUE
;
795 bFirstDigitsProcessed
= TRUE
;
796 bDecimalPointProcessed
= TRUE
;
797 /* We have found some digits after the decimal point
798 * so disable the "Digits required" flag.
800 bDigitsRequired
= FALSE
;
802 else if( bThirdDigitsProcessed
== FALSE
)
804 /* Getting here means everything else should be processed.
805 * If we get anything else than a decimal following this
806 * digit it will be flagged by the other cases, so
807 * we do not really need to do anything in here.
811 /* If DecimalPoint...
814 if( bDecimalPointProcessed
||
815 bSecondDigitsProcessed
||
816 bExponentProcessed
||
817 bSecondSignProcessed
||
818 bThirdDigitsProcessed
)
820 bValidRealString
= FALSE
;
822 bFirstSignProcessed
= TRUE
;
823 bWhiteSpaceProcessed
= TRUE
;
824 bFirstDigitsProcessed
= TRUE
;
825 bDecimalPointProcessed
= TRUE
;
833 if( bExponentProcessed
||
834 bSecondSignProcessed
||
835 bThirdDigitsProcessed
||
838 bValidRealString
= FALSE
;
840 bFirstSignProcessed
= TRUE
;
841 bWhiteSpaceProcessed
= TRUE
;
842 bFirstDigitsProcessed
= TRUE
;
843 bDecimalPointProcessed
= TRUE
;
844 bSecondDigitsProcessed
= TRUE
;
845 bExponentProcessed
= TRUE
;
848 bValidRealString
= FALSE
;
851 /* Process next character.
856 /* If the required digits were not present we have an invalid
857 * string representation of a real number.
859 if( bDigitsRequired
== TRUE
)
861 bValidRealString
= FALSE
;
864 return bValidRealString
;
868 /******************************************************************************
871 * This function dispatches execution to the proper conversion API
872 * to do the necessary coercion.
874 static HRESULT
Coerce( VARIANTARG
* pd
, LCID lcid
, ULONG dwFlags
, VARIANTARG
* ps
, VARTYPE vt
)
877 unsigned short vtFrom
= 0;
878 vtFrom
= ps
->vt
& VT_TYPEMASK
;
880 /* Note: Since "long" and "int" values both have 4 bytes and are both signed integers
881 * "int" will be treated as "long" in the following code.
882 * The same goes for there unsigned versions.
889 res
= VariantClear32( pd
);
892 res
= VariantClear32( pd
);
902 res
= VariantCopy32( pd
, ps
);
905 res
= VarI1FromI232( ps
->u
.iVal
, &(pd
->u
.cVal
) );
909 res
= VarI1FromI432( ps
->u
.lVal
, &(pd
->u
.cVal
) );
912 res
= VarI1FromUI132( ps
->u
.bVal
, &(pd
->u
.cVal
) );
915 res
= VarI1FromUI232( ps
->u
.uiVal
, &(pd
->u
.cVal
) );
919 res
= VarI1FromUI432( ps
->u
.ulVal
, &(pd
->u
.cVal
) );
922 res
= VarI1FromR432( ps
->u
.fltVal
, &(pd
->u
.cVal
) );
925 res
= VarI1FromR832( ps
->u
.dblVal
, &(pd
->u
.cVal
) );
928 res
= VarI1FromDate32( ps
->u
.date
, &(pd
->u
.cVal
) );
931 res
= VarI1FromBool32( ps
->u
.boolVal
, &(pd
->u
.cVal
) );
934 res
= VarI1FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.cVal
) );
937 res
= VarI1FromCy32( ps
->u
.cyVal
, &(pd
->u
.cVal
) );
939 /*res = VarI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.cVal) );*/
941 /*res = VarI1From32( ps->u.lVal, &(pd->u.cVal) );*/
943 /*res = VarI1FromDec32( ps->u.decVal, &(pd->u.cVal) );*/
945 res
= DISP_E_TYPEMISMATCH
;
946 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
955 res
= VarI2FromI132( ps
->u
.cVal
, &(pd
->u
.iVal
) );
958 res
= VariantCopy32( pd
, ps
);
962 res
= VarI2FromI432( ps
->u
.lVal
, &(pd
->u
.iVal
) );
965 res
= VarI2FromUI132( ps
->u
.bVal
, &(pd
->u
.iVal
) );
968 res
= VarI2FromUI232( ps
->u
.uiVal
, &(pd
->u
.iVal
) );
972 res
= VarI2FromUI432( ps
->u
.ulVal
, &(pd
->u
.iVal
) );
975 res
= VarI2FromR432( ps
->u
.fltVal
, &(pd
->u
.iVal
) );
978 res
= VarI2FromR832( ps
->u
.dblVal
, &(pd
->u
.iVal
) );
981 res
= VarI2FromDate32( ps
->u
.date
, &(pd
->u
.iVal
) );
984 res
= VarI2FromBool32( ps
->u
.boolVal
, &(pd
->u
.iVal
) );
987 res
= VarI2FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.iVal
) );
990 res
= VarI2FromCy32( ps
->u
.cyVal
, &(pd
->u
.iVal
) );
992 /*res = VarI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.iVal) );*/
994 /*res = VarI2From32( ps->u.lVal, &(pd->u.iVal) );*/
996 /*res = VarI2FromDec32( ps->u.deiVal, &(pd->u.iVal) );*/
998 res
= DISP_E_TYPEMISMATCH
;
999 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1009 res
= VarI4FromI132( ps
->u
.cVal
, &(pd
->u
.lVal
) );
1012 res
= VarI4FromI232( ps
->u
.iVal
, &(pd
->u
.lVal
) );
1016 res
= VariantCopy32( pd
, ps
);
1019 res
= VarI4FromUI132( ps
->u
.bVal
, &(pd
->u
.lVal
) );
1022 res
= VarI4FromUI232( ps
->u
.uiVal
, &(pd
->u
.lVal
) );
1026 res
= VarI4FromUI432( ps
->u
.ulVal
, &(pd
->u
.lVal
) );
1029 res
= VarI4FromR432( ps
->u
.fltVal
, &(pd
->u
.lVal
) );
1032 res
= VarI4FromR832( ps
->u
.dblVal
, &(pd
->u
.lVal
) );
1035 res
= VarI4FromDate32( ps
->u
.date
, &(pd
->u
.lVal
) );
1038 res
= VarI4FromBool32( ps
->u
.boolVal
, &(pd
->u
.lVal
) );
1041 res
= VarI4FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.lVal
) );
1044 res
= VarI4FromCy32( ps
->u
.cyVal
, &(pd
->u
.lVal
) );
1045 case( VT_DISPATCH
):
1046 /*res = VarI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.lVal) );*/
1048 /*res = VarI4From32( ps->u.lVal, &(pd->u.lVal) );*/
1050 /*res = VarI4FromDec32( ps->u.deiVal, &(pd->u.lVal) );*/
1052 res
= DISP_E_TYPEMISMATCH
;
1053 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1062 res
= VarUI1FromI132( ps
->u
.cVal
, &(pd
->u
.bVal
) );
1065 res
= VarUI1FromI232( ps
->u
.iVal
, &(pd
->u
.bVal
) );
1069 res
= VarUI1FromI432( ps
->u
.lVal
, &(pd
->u
.bVal
) );
1072 res
= VariantCopy32( pd
, ps
);
1075 res
= VarUI1FromUI232( ps
->u
.uiVal
, &(pd
->u
.bVal
) );
1079 res
= VarUI1FromUI432( ps
->u
.ulVal
, &(pd
->u
.bVal
) );
1082 res
= VarUI1FromR432( ps
->u
.fltVal
, &(pd
->u
.bVal
) );
1085 res
= VarUI1FromR832( ps
->u
.dblVal
, &(pd
->u
.bVal
) );
1088 res
= VarUI1FromDate32( ps
->u
.date
, &(pd
->u
.bVal
) );
1091 res
= VarUI1FromBool32( ps
->u
.boolVal
, &(pd
->u
.bVal
) );
1094 res
= VarUI1FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.bVal
) );
1097 res
= VarUI1FromCy32( ps
->u
.cyVal
, &(pd
->u
.bVal
) );
1098 case( VT_DISPATCH
):
1099 /*res = VarUI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.bVal) );*/
1101 /*res = VarUI1From32( ps->u.lVal, &(pd->u.bVal) );*/
1103 /*res = VarUI1FromDec32( ps->u.deiVal, &(pd->u.bVal) );*/
1105 res
= DISP_E_TYPEMISMATCH
;
1106 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1115 res
= VarUI2FromI132( ps
->u
.cVal
, &(pd
->u
.uiVal
) );
1118 res
= VarUI2FromI232( ps
->u
.iVal
, &(pd
->u
.uiVal
) );
1122 res
= VarUI2FromI432( ps
->u
.lVal
, &(pd
->u
.uiVal
) );
1125 res
= VarUI2FromUI132( ps
->u
.bVal
, &(pd
->u
.uiVal
) );
1128 res
= VariantCopy32( pd
, ps
);
1132 res
= VarUI2FromUI432( ps
->u
.ulVal
, &(pd
->u
.uiVal
) );
1135 res
= VarUI2FromR432( ps
->u
.fltVal
, &(pd
->u
.uiVal
) );
1138 res
= VarUI2FromR832( ps
->u
.dblVal
, &(pd
->u
.uiVal
) );
1141 res
= VarUI2FromDate32( ps
->u
.date
, &(pd
->u
.uiVal
) );
1144 res
= VarUI2FromBool32( ps
->u
.boolVal
, &(pd
->u
.uiVal
) );
1147 res
= VarUI2FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.uiVal
) );
1150 res
= VarUI2FromCy32( ps
->u
.cyVal
, &(pd
->u
.uiVal
) );
1151 case( VT_DISPATCH
):
1152 /*res = VarUI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.uiVal) );*/
1154 /*res = VarUI2From32( ps->u.lVal, &(pd->u.uiVal) );*/
1156 /*res = VarUI2FromDec32( ps->u.deiVal, &(pd->u.uiVal) );*/
1158 res
= DISP_E_TYPEMISMATCH
;
1159 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1169 res
= VarUI4FromI132( ps
->u
.cVal
, &(pd
->u
.ulVal
) );
1172 res
= VarUI4FromI232( ps
->u
.iVal
, &(pd
->u
.ulVal
) );
1176 res
= VarUI4FromI432( ps
->u
.lVal
, &(pd
->u
.ulVal
) );
1179 res
= VarUI4FromUI132( ps
->u
.bVal
, &(pd
->u
.ulVal
) );
1182 res
= VarUI4FromUI232( ps
->u
.uiVal
, &(pd
->u
.ulVal
) );
1185 res
= VariantCopy32( pd
, ps
);
1188 res
= VarUI4FromR432( ps
->u
.fltVal
, &(pd
->u
.ulVal
) );
1191 res
= VarUI4FromR832( ps
->u
.dblVal
, &(pd
->u
.ulVal
) );
1194 res
= VarUI4FromDate32( ps
->u
.date
, &(pd
->u
.ulVal
) );
1197 res
= VarUI4FromBool32( ps
->u
.boolVal
, &(pd
->u
.ulVal
) );
1200 res
= VarUI4FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.ulVal
) );
1203 res
= VarUI4FromCy32( ps
->u
.cyVal
, &(pd
->u
.ulVal
) );
1204 case( VT_DISPATCH
):
1205 /*res = VarUI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.ulVal) );*/
1207 /*res = VarUI4From32( ps->u.lVal, &(pd->u.ulVal) );*/
1209 /*res = VarUI4FromDec32( ps->u.deiVal, &(pd->u.ulVal) );*/
1211 res
= DISP_E_TYPEMISMATCH
;
1212 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1221 res
= VarR4FromI132( ps
->u
.cVal
, &(pd
->u
.fltVal
) );
1224 res
= VarR4FromI232( ps
->u
.iVal
, &(pd
->u
.fltVal
) );
1228 res
= VarR4FromI432( ps
->u
.lVal
, &(pd
->u
.fltVal
) );
1231 res
= VarR4FromUI132( ps
->u
.bVal
, &(pd
->u
.fltVal
) );
1234 res
= VarR4FromUI232( ps
->u
.uiVal
, &(pd
->u
.fltVal
) );
1238 res
= VarR4FromUI432( ps
->u
.ulVal
, &(pd
->u
.fltVal
) );
1241 res
= VariantCopy32( pd
, ps
);
1244 res
= VarR4FromR832( ps
->u
.dblVal
, &(pd
->u
.fltVal
) );
1247 res
= VarR4FromDate32( ps
->u
.date
, &(pd
->u
.fltVal
) );
1250 res
= VarR4FromBool32( ps
->u
.boolVal
, &(pd
->u
.fltVal
) );
1253 res
= VarR4FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.fltVal
) );
1256 res
= VarR4FromCy32( ps
->u
.cyVal
, &(pd
->u
.fltVal
) );
1257 case( VT_DISPATCH
):
1258 /*res = VarR4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.fltVal) );*/
1260 /*res = VarR4From32( ps->u.lVal, &(pd->u.fltVal) );*/
1262 /*res = VarR4FromDec32( ps->u.deiVal, &(pd->u.fltVal) );*/
1264 res
= DISP_E_TYPEMISMATCH
;
1265 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1274 res
= VarR8FromI132( ps
->u
.cVal
, &(pd
->u
.dblVal
) );
1277 res
= VarR8FromI232( ps
->u
.iVal
, &(pd
->u
.dblVal
) );
1281 res
= VarR8FromI432( ps
->u
.lVal
, &(pd
->u
.dblVal
) );
1284 res
= VarR8FromUI132( ps
->u
.bVal
, &(pd
->u
.dblVal
) );
1287 res
= VarR8FromUI232( ps
->u
.uiVal
, &(pd
->u
.dblVal
) );
1291 res
= VarR8FromUI432( ps
->u
.ulVal
, &(pd
->u
.dblVal
) );
1294 res
= VarR8FromR432( ps
->u
.fltVal
, &(pd
->u
.dblVal
) );
1297 res
= VariantCopy32( pd
, ps
);
1300 res
= VarR8FromDate32( ps
->u
.date
, &(pd
->u
.dblVal
) );
1303 res
= VarR8FromBool32( ps
->u
.boolVal
, &(pd
->u
.dblVal
) );
1306 res
= VarR8FromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.dblVal
) );
1309 res
= VarR8FromCy32( ps
->u
.cyVal
, &(pd
->u
.dblVal
) );
1310 case( VT_DISPATCH
):
1311 /*res = VarR8FromDisp32( ps->u.pdispVal, lcid, &(pd->u.dblVal) );*/
1313 /*res = VarR8From32( ps->u.lVal, &(pd->u.dblVal) );*/
1315 /*res = VarR8FromDec32( ps->u.deiVal, &(pd->u.dblVal) );*/
1317 res
= DISP_E_TYPEMISMATCH
;
1318 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1327 res
= VarDateFromI132( ps
->u
.cVal
, &(pd
->u
.date
) );
1330 res
= VarDateFromI232( ps
->u
.iVal
, &(pd
->u
.date
) );
1333 res
= VarDateFromInt32( ps
->u
.intVal
, &(pd
->u
.date
) );
1336 res
= VarDateFromI432( ps
->u
.lVal
, &(pd
->u
.date
) );
1339 res
= VarDateFromUI132( ps
->u
.bVal
, &(pd
->u
.date
) );
1342 res
= VarDateFromUI232( ps
->u
.uiVal
, &(pd
->u
.date
) );
1345 res
= VarDateFromUint32( ps
->u
.uintVal
, &(pd
->u
.date
) );
1348 res
= VarDateFromUI432( ps
->u
.ulVal
, &(pd
->u
.date
) );
1351 res
= VarDateFromR432( ps
->u
.fltVal
, &(pd
->u
.date
) );
1354 res
= VarDateFromR832( ps
->u
.dblVal
, &(pd
->u
.date
) );
1357 res
= VariantCopy32( pd
, ps
);
1360 res
= VarDateFromBool32( ps
->u
.boolVal
, &(pd
->u
.date
) );
1363 res
= VarDateFromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.date
) );
1366 res
= VarDateFromCy32( ps
->u
.cyVal
, &(pd
->u
.date
) );
1367 case( VT_DISPATCH
):
1368 /*res = VarDateFromDisp32( ps->u.pdispVal, lcid, &(pd->u.date) );*/
1370 /*res = VarDateFrom32( ps->u.lVal, &(pd->u.date) );*/
1372 /*res = VarDateFromDec32( ps->u.deiVal, &(pd->u.date) );*/
1374 res
= DISP_E_TYPEMISMATCH
;
1375 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1384 res
= VarBoolFromI132( ps
->u
.cVal
, &(pd
->u
.boolVal
) );
1387 res
= VarBoolFromI232( ps
->u
.iVal
, &(pd
->u
.boolVal
) );
1390 res
= VarBoolFromInt32( ps
->u
.intVal
, &(pd
->u
.boolVal
) );
1393 res
= VarBoolFromI432( ps
->u
.lVal
, &(pd
->u
.boolVal
) );
1396 res
= VarBoolFromUI132( ps
->u
.bVal
, &(pd
->u
.boolVal
) );
1399 res
= VarBoolFromUI232( ps
->u
.uiVal
, &(pd
->u
.boolVal
) );
1402 res
= VarBoolFromUint32( ps
->u
.uintVal
, &(pd
->u
.boolVal
) );
1405 res
= VarBoolFromUI432( ps
->u
.ulVal
, &(pd
->u
.boolVal
) );
1408 res
= VarBoolFromR432( ps
->u
.fltVal
, &(pd
->u
.boolVal
) );
1411 res
= VarBoolFromR832( ps
->u
.dblVal
, &(pd
->u
.boolVal
) );
1414 res
= VarBoolFromDate32( ps
->u
.date
, &(pd
->u
.boolVal
) );
1417 res
= VariantCopy32( pd
, ps
);
1420 res
= VarBoolFromStr32( ps
->u
.bstrVal
, lcid
, dwFlags
, &(pd
->u
.boolVal
) );
1423 res
= VarBoolFromCy32( ps
->u
.cyVal
, &(pd
->u
.boolVal
) );
1424 case( VT_DISPATCH
):
1425 /*res = VarBoolFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
1427 /*res = VarBoolFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
1429 /*res = VarBoolFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
1431 res
= DISP_E_TYPEMISMATCH
;
1432 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1441 res
= VarBstrFromI132( ps
->u
.cVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1444 res
= VarBstrFromI232( ps
->u
.iVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1447 res
= VarBstrFromInt32( ps
->u
.intVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1450 res
= VarBstrFromI432( ps
->u
.lVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1453 res
= VarBstrFromUI132( ps
->u
.bVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1456 res
= VarBstrFromUI232( ps
->u
.uiVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1459 res
= VarBstrFromUint32( ps
->u
.uintVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1462 res
= VarBstrFromUI432( ps
->u
.ulVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1465 res
= VarBstrFromR432( ps
->u
.fltVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1468 res
= VarBstrFromR832( ps
->u
.dblVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1471 res
= VarBstrFromDate32( ps
->u
.date
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1474 res
= VarBstrFromBool32( ps
->u
.boolVal
, lcid
, dwFlags
, &(pd
->u
.bstrVal
) );
1477 res
= VariantCopy32( pd
, ps
);
1480 /*res = VarBstrFromCy32( ps->u.cyVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1481 case( VT_DISPATCH
):
1482 /*res = VarBstrFromDisp32( ps->u.pdispVal, lcid, lcid, dwFlags, &(pd->u.bstrVal) );*/
1484 /*res = VarBstrFrom32( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1486 /*res = VarBstrFromDec32( ps->u.deiVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1488 res
= DISP_E_TYPEMISMATCH
;
1489 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1498 res
= VarCyFromI132( ps
->u
.cVal
, &(pd
->u
.cyVal
) );
1501 res
= VarCyFromI232( ps
->u
.iVal
, &(pd
->u
.cyVal
) );
1504 res
= VarCyFromInt32( ps
->u
.intVal
, &(pd
->u
.cyVal
) );
1507 res
= VarCyFromI432( ps
->u
.lVal
, &(pd
->u
.cyVal
) );
1510 res
= VarCyFromUI132( ps
->u
.bVal
, &(pd
->u
.cyVal
) );
1513 res
= VarCyFromUI232( ps
->u
.uiVal
, &(pd
->u
.cyVal
) );
1516 res
= VarCyFromUint32( ps
->u
.uintVal
, &(pd
->u
.cyVal
) );
1519 res
= VarCyFromUI432( ps
->u
.ulVal
, &(pd
->u
.cyVal
) );
1522 res
= VarCyFromR432( ps
->u
.fltVal
, &(pd
->u
.cyVal
) );
1525 res
= VarCyFromR832( ps
->u
.dblVal
, &(pd
->u
.cyVal
) );
1528 res
= VarCyFromDate32( ps
->u
.date
, &(pd
->u
.cyVal
) );
1531 res
= VarCyFromBool32( ps
->u
.date
, &(pd
->u
.cyVal
) );
1534 res
= VariantCopy32( pd
, ps
);
1537 /*res = VarCyFromStr32( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cyVal) );*/
1538 case( VT_DISPATCH
):
1539 /*res = VarCyFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
1541 /*res = VarCyFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
1543 /*res = VarCyFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
1545 res
= DISP_E_TYPEMISMATCH
;
1546 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1552 res
= DISP_E_TYPEMISMATCH
;
1553 FIXME(ole
,"Coercion from %d to %d\n", vtFrom
, vt
);
1560 /******************************************************************************
1561 * ValidateVtRange [INTERNAL]
1563 * Used internally by the hi-level Variant API to determine
1564 * if the vartypes are valid.
1566 static HRESULT WINAPI
ValidateVtRange( VARTYPE vt
)
1568 /* if by value we must make sure it is in the
1569 * range of the valid types.
1571 if( ( vt
& VT_TYPEMASK
) > VT_MAXVALIDTYPE
)
1573 return DISP_E_BADVARTYPE
;
1579 /******************************************************************************
1580 * ValidateVartype [INTERNAL]
1582 * Used internally by the hi-level Variant API to determine
1583 * if the vartypes are valid.
1585 static HRESULT WINAPI
ValidateVariantType( VARTYPE vt
)
1589 /* check if we have a valid argument.
1593 /* if by reference check that the type is in
1594 * the valid range and that it is not of empty or null type
1596 if( ( vt
& VT_TYPEMASK
) == VT_EMPTY
||
1597 ( vt
& VT_TYPEMASK
) == VT_NULL
||
1598 ( vt
& VT_TYPEMASK
) > VT_MAXVALIDTYPE
)
1606 res
= ValidateVtRange( vt
);
1612 /******************************************************************************
1613 * ValidateVt [INTERNAL]
1615 * Used internally by the hi-level Variant API to determine
1616 * if the vartypes are valid.
1618 static HRESULT WINAPI
ValidateVt( VARTYPE vt
)
1622 /* check if we have a valid argument.
1626 /* if by reference check that the type is in
1627 * the valid range and that it is not of empty or null type
1629 if( ( vt
& VT_TYPEMASK
) == VT_EMPTY
||
1630 ( vt
& VT_TYPEMASK
) == VT_NULL
||
1631 ( vt
& VT_TYPEMASK
) > VT_MAXVALIDTYPE
)
1633 res
= DISP_E_BADVARTYPE
;
1639 res
= ValidateVtRange( vt
);
1649 /******************************************************************************
1650 * VariantInit32 [OLEAUT32.8]
1652 * Initializes the Variant. Unlike VariantClear it does not interpret the current
1653 * contents of the Variant.
1655 void WINAPI
VariantInit32(VARIANTARG
* pvarg
)
1657 TRACE(ole
,"(%p),stub\n",pvarg
);
1659 pvarg
->vt
= VT_EMPTY
;
1660 pvarg
->wReserved1
= 0;
1661 pvarg
->wReserved2
= 0;
1662 pvarg
->wReserved3
= 0;
1667 /******************************************************************************
1668 * VariantClear32 [OLEAUT32.9]
1670 * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
1671 * sets the wReservedX field to 0. The current contents of the VARIANT are
1672 * freed. If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
1673 * released. If VT_ARRAY the array is freed.
1675 HRESULT WINAPI
VariantClear32(VARIANTARG
* pvarg
)
1678 TRACE(ole
,"(%p),stub\n",pvarg
);
1680 res
= ValidateVariantType( pvarg
->vt
);
1683 if( !( pvarg
->vt
& VT_BYREF
) )
1685 switch( pvarg
->vt
& VT_TYPEMASK
)
1688 SysFreeString32( pvarg
->u
.bstrVal
);
1690 case( VT_DISPATCH
):
1696 case( VT_SAFEARRAY
):
1703 /* Set the fields to empty.
1705 pvarg
->wReserved1
= 0;
1706 pvarg
->wReserved2
= 0;
1707 pvarg
->wReserved3
= 0;
1708 pvarg
->vt
= VT_EMPTY
;
1714 /******************************************************************************
1715 * VariantCopy32 [OLEAUT32.10]
1717 * Frees up the designation variant and makes a copy of the source.
1719 HRESULT WINAPI
VariantCopy32(VARIANTARG
* pvargDest
, VARIANTARG
* pvargSrc
)
1722 TRACE(ole
,"(%p, %p),stub\n", pvargDest
, pvargSrc
);
1724 res
= ValidateVariantType( pvargSrc
->vt
);
1725 /* If the pointer are to the same variant we don't need
1728 if( pvargDest
!= pvargSrc
&& res
== S_OK
)
1730 res
= VariantClear32( pvargDest
);
1734 if( pvargSrc
->vt
& VT_BYREF
)
1736 /* In the case of byreference we only need
1737 * to copy the pointer.
1739 pvargDest
->u
= pvargSrc
->u
;
1740 pvargDest
->vt
= pvargSrc
->vt
;
1744 /* In the case of by value we need to
1745 * copy the actuall value. In the case of
1746 * VT_BSTR a copy of the string is made,
1747 * if VT_ARRAY the entire array is copied
1748 * if VT_DISPATCH or VT_IUNKNOWN AddReff is
1749 * called to increment the object's reference count.
1751 switch( pvargSrc
->vt
& VT_TYPEMASK
)
1754 pvargDest
->u
.bstrVal
= SysAllocString32( pvargSrc
->u
.bstrVal
);
1756 case( VT_DISPATCH
):
1762 case( VT_SAFEARRAY
):
1765 pvargDest
->u
= pvargSrc
->u
;
1768 pvargDest
->vt
= pvargSrc
->vt
;
1777 /******************************************************************************
1778 * VariantCopyInd32 [OLEAUT32.11]
1780 * Frees up the destination variant and makes a copy of the source. If
1781 * the source is of type VT_BYREF it performs the necessary indirections.
1783 HRESULT WINAPI
VariantCopyInd32(VARIANT
* pvargDest
, VARIANTARG
* pvargSrc
)
1786 TRACE(ole
,"(%p, %p),stub\n", pvargDest
, pvargSrc
);
1788 res
= ValidateVariantType( pvargSrc
->vt
);
1792 if( pvargSrc
->vt
& VT_BYREF
)
1795 VariantInit32( &varg
);
1796 /* handle the in place copy.
1798 if( pvargDest
== pvargSrc
)
1800 /* we will use a copy of the source instead.
1802 res
= VariantCopy32( &varg
, pvargSrc
);
1807 res
= VariantClear32( pvargDest
);
1810 /* In the case of by reference we need
1811 * to copy the date pointed to by the variant.
1813 /* Get the variant type.
1815 switch( pvargSrc
->vt
& VT_TYPEMASK
)
1818 pvargDest
->u
.bstrVal
= SysAllocString32( *(pvargSrc
->u
.pbstrVal
) );
1820 case( VT_DISPATCH
):
1824 /* Prevent from cycling. According to tests on
1825 * VariantCopyInd in Windows and the documentation
1826 * this API dereferences the inner Variants to only one depth.
1827 * If the inner Variant itself contains an
1828 * other inner variant the E_INVALIDARG error is
1831 if( pvargSrc
->wReserved1
& PROCESSING_INNER_VARIANT
)
1833 /* If we get here we are attempting to deference
1834 * an inner variant that that is itself contained
1835 * in an inner variant so report E_INVALIDARG error.
1841 /* Set the processing inner variant flag.
1842 * We will set this flag in the inner variant
1843 * that will be passed to the VariantCopyInd function.
1845 (pvargSrc
->u
.pvarVal
)->wReserved1
|= PROCESSING_INNER_VARIANT
;
1846 /* Dereference the inner variant.
1848 res
= VariantCopyInd32( pvargDest
, pvargSrc
->u
.pvarVal
);
1854 case( VT_SAFEARRAY
):
1857 /* This is a by reference Variant which means that the union
1858 * part of the Variant contains a pointer to some data of
1859 * type "pvargSrc->vt & VT_TYPEMASK".
1860 * We will deference this data in a generic fashion using
1861 * the void pointer "Variant.u.byref".
1862 * We will copy this data into the union of the destination
1865 memcpy( &pvargDest
->u
, pvargSrc
->u
.byref
, SizeOfVariantData( pvargSrc
) );
1868 pvargDest
->vt
= pvargSrc
->vt
& VT_TYPEMASK
;
1871 /* this should not fail.
1873 VariantClear32( &varg
);
1877 res
= VariantCopy32( pvargDest
, pvargSrc
);
1882 /******************************************************************************
1883 * VariantChangeType32 [OLEAUT32.12]
1885 HRESULT WINAPI
VariantChangeType32(VARIANTARG
* pvargDest
, VARIANTARG
* pvargSrc
,
1886 USHORT wFlags
, VARTYPE vt
)
1888 return VariantChangeTypeEx32( pvargDest
, pvargSrc
, 0, wFlags
, vt
);
1891 /******************************************************************************
1892 * VariantChangeTypeEx32 [OLEAUT32.147]
1894 HRESULT WINAPI
VariantChangeTypeEx32(VARIANTARG
* pvargDest
, VARIANTARG
* pvargSrc
,
1895 LCID lcid
, USHORT wFlags
, VARTYPE vt
)
1899 VariantInit32( &varg
);
1901 TRACE(ole
,"(%p, %p, %ld, %u, %u),stub\n", pvargDest
, pvargSrc
, lcid
, wFlags
, vt
);
1903 /* validate our source argument.
1905 res
= ValidateVariantType( pvargSrc
->vt
);
1907 /* validate the vartype.
1911 res
= ValidateVt( vt
);
1914 /* if we are doing an in-place conversion make a copy of the source.
1916 if( res
== S_OK
&& pvargDest
== pvargSrc
)
1918 res
= VariantCopy32( &varg
, pvargSrc
);
1924 /* free up the destination variant.
1926 res
= VariantClear32( pvargDest
);
1931 if( pvargSrc
->vt
& VT_BYREF
)
1933 /* Convert the source variant to a "byvalue" variant.
1936 VariantInit32( &Variant
);
1937 res
= VariantCopyInd32( &Variant
, pvargSrc
);
1940 res
= Coerce( pvargDest
, lcid
, wFlags
, &Variant
, vt
);
1941 /* this should not fail.
1943 VariantClear32( &Variant
);
1949 /* Use the current "byvalue" source variant.
1951 res
= Coerce( pvargDest
, lcid
, wFlags
, pvargSrc
, vt
);
1954 /* this should not fail.
1956 VariantClear32( &varg
);
1964 /******************************************************************************
1965 * VarUI1FromI232 [OLEAUT32.130]
1967 HRESULT WINAPI
VarUI1FromI232(short sIn
, BYTE
* pbOut
)
1969 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pbOut
);
1971 /* Check range of value.
1973 if( sIn
< UI1_MIN
|| sIn
> UI1_MAX
)
1975 return DISP_E_OVERFLOW
;
1978 *pbOut
= (BYTE
) sIn
;
1983 /******************************************************************************
1984 * VarUI1FromI432 [OLEAUT32.131]
1986 HRESULT WINAPI
VarUI1FromI432(LONG lIn
, BYTE
* pbOut
)
1988 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pbOut
);
1990 /* Check range of value.
1992 if( lIn
< UI1_MIN
|| lIn
> UI1_MAX
)
1994 return DISP_E_OVERFLOW
;
1997 *pbOut
= (BYTE
) lIn
;
2003 /******************************************************************************
2004 * VarUI1FromR432 [OLEAUT32.132]
2006 HRESULT WINAPI
VarUI1FromR432(FLOAT fltIn
, BYTE
* pbOut
)
2008 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pbOut
);
2010 /* Check range of value.
2012 fltIn
= round( fltIn
);
2013 if( fltIn
< UI1_MIN
|| fltIn
> UI1_MAX
)
2015 return DISP_E_OVERFLOW
;
2018 *pbOut
= (BYTE
) fltIn
;
2023 /******************************************************************************
2024 * VarUI1FromR832 [OLEAUT32.133]
2026 HRESULT WINAPI
VarUI1FromR832(double dblIn
, BYTE
* pbOut
)
2028 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pbOut
);
2030 /* Check range of value.
2032 dblIn
= round( dblIn
);
2033 if( dblIn
< UI1_MIN
|| dblIn
> UI1_MAX
)
2035 return DISP_E_OVERFLOW
;
2038 *pbOut
= (BYTE
) dblIn
;
2043 /******************************************************************************
2044 * VarUI1FromDate32 [OLEAUT32.135]
2046 HRESULT WINAPI
VarUI1FromDate32(DATE dateIn
, BYTE
* pbOut
)
2048 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pbOut
);
2050 /* Check range of value.
2052 dateIn
= round( dateIn
);
2053 if( dateIn
< UI1_MIN
|| dateIn
> UI1_MAX
)
2055 return DISP_E_OVERFLOW
;
2058 *pbOut
= (BYTE
) dateIn
;
2063 /******************************************************************************
2064 * VarUI1FromBool32 [OLEAUT32.138]
2066 HRESULT WINAPI
VarUI1FromBool32(VARIANT_BOOL boolIn
, BYTE
* pbOut
)
2068 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pbOut
);
2070 *pbOut
= (BYTE
) boolIn
;
2075 /******************************************************************************
2076 * VarUI1FromI132 [OLEAUT32.237]
2078 HRESULT WINAPI
VarUI1FromI132(CHAR cIn
, BYTE
* pbOut
)
2080 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pbOut
);
2087 /******************************************************************************
2088 * VarUI1FromUI232 [OLEAUT32.238]
2090 HRESULT WINAPI
VarUI1FromUI232(USHORT uiIn
, BYTE
* pbOut
)
2092 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pbOut
);
2094 /* Check range of value.
2096 if( uiIn
> UI1_MAX
)
2098 return DISP_E_OVERFLOW
;
2101 *pbOut
= (BYTE
) uiIn
;
2106 /******************************************************************************
2107 * VarUI1FromUI432 [OLEAUT32.239]
2109 HRESULT WINAPI
VarUI1FromUI432(ULONG ulIn
, BYTE
* pbOut
)
2111 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pbOut
);
2113 /* Check range of value.
2115 if( ulIn
> UI1_MAX
)
2117 return DISP_E_OVERFLOW
;
2120 *pbOut
= (BYTE
) ulIn
;
2126 /******************************************************************************
2127 * VarUI1FromStr32 [OLEAUT32.54]
2129 HRESULT WINAPI
VarUI1FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, BYTE
* pbOut
)
2131 double dValue
= 0.0;
2132 LPSTR pNewString
= NULL
;
2134 TRACE( ole
, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn
, lcid
, dwFlags
, pbOut
);
2136 /* Check if we have a valid argument
2138 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2139 RemoveCharacterFromString( pNewString
, "," );
2140 if( IsValidRealString( pNewString
) == FALSE
)
2142 return DISP_E_TYPEMISMATCH
;
2145 /* Convert the valid string to a floating point number.
2147 dValue
= atof( pNewString
);
2149 /* We don't need the string anymore so free it.
2151 HeapFree( GetProcessHeap(), 0 , pNewString
);
2153 /* Check range of value.
2155 dValue
= round( dValue
);
2156 if( dValue
< UI1_MIN
|| dValue
> UI1_MAX
)
2158 return DISP_E_OVERFLOW
;
2161 *pbOut
= (BYTE
) dValue
;
2166 /**********************************************************************
2167 * VarUI1FromCy32 [OLEAUT32.134]
2168 * Convert currency to unsigned char
2170 HRESULT WINAPI
VarUI1FromCy32(CY cyIn
, BYTE
* pbOut
) {
2171 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2173 if (t
> UI1_MAX
|| t
< UI1_MIN
) return DISP_E_OVERFLOW
;
2179 /******************************************************************************
2180 * VarI2FromUI132 [OLEAUT32.48]
2182 HRESULT WINAPI
VarI2FromUI132(BYTE bIn
, short* psOut
)
2184 TRACE( ole
, "( 0x%08x, %p ), stub\n", bIn
, psOut
);
2186 *psOut
= (short) bIn
;
2191 /******************************************************************************
2192 * VarI2FromI432 [OLEAUT32.49]
2194 HRESULT WINAPI
VarI2FromI432(LONG lIn
, short* psOut
)
2196 TRACE( ole
, "( %lx, %p ), stub\n", lIn
, psOut
);
2198 /* Check range of value.
2200 if( lIn
< I2_MIN
|| lIn
> I2_MAX
)
2202 return DISP_E_OVERFLOW
;
2205 *psOut
= (short) lIn
;
2210 /******************************************************************************
2211 * VarI2FromR432 [OLEAUT32.50]
2213 HRESULT WINAPI
VarI2FromR432(FLOAT fltIn
, short* psOut
)
2215 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, psOut
);
2217 /* Check range of value.
2219 fltIn
= round( fltIn
);
2220 if( fltIn
< I2_MIN
|| fltIn
> I2_MAX
)
2222 return DISP_E_OVERFLOW
;
2225 *psOut
= (short) fltIn
;
2230 /******************************************************************************
2231 * VarI2FromR832 [OLEAUT32.51]
2233 HRESULT WINAPI
VarI2FromR832(double dblIn
, short* psOut
)
2235 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, psOut
);
2237 /* Check range of value.
2239 dblIn
= round( dblIn
);
2240 if( dblIn
< I2_MIN
|| dblIn
> I2_MAX
)
2242 return DISP_E_OVERFLOW
;
2245 *psOut
= (short) dblIn
;
2250 /******************************************************************************
2251 * VarI2FromDate32 [OLEAUT32.53]
2253 HRESULT WINAPI
VarI2FromDate32(DATE dateIn
, short* psOut
)
2255 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, psOut
);
2257 /* Check range of value.
2259 dateIn
= round( dateIn
);
2260 if( dateIn
< I2_MIN
|| dateIn
> I2_MAX
)
2262 return DISP_E_OVERFLOW
;
2265 *psOut
= (short) dateIn
;
2270 /******************************************************************************
2271 * VarI2FromBool32 [OLEAUT32.56]
2273 HRESULT WINAPI
VarI2FromBool32(VARIANT_BOOL boolIn
, short* psOut
)
2275 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, psOut
);
2277 *psOut
= (short) boolIn
;
2282 /******************************************************************************
2283 * VarI2FromI132 [OLEAUT32.48]
2285 HRESULT WINAPI
VarI2FromI132(CHAR cIn
, short* psOut
)
2287 TRACE( ole
, "( %c, %p ), stub\n", cIn
, psOut
);
2289 *psOut
= (short) cIn
;
2294 /******************************************************************************
2295 * VarI2FromUI232 [OLEAUT32.206]
2297 HRESULT WINAPI
VarI2FromUI232(USHORT uiIn
, short* psOut
)
2299 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, psOut
);
2301 /* Check range of value.
2305 return DISP_E_OVERFLOW
;
2308 *psOut
= (short) uiIn
;
2313 /******************************************************************************
2314 * VarI2FromUI432 [OLEAUT32.49]
2316 HRESULT WINAPI
VarI2FromUI432(ULONG ulIn
, short* psOut
)
2318 TRACE( ole
, "( %lx, %p ), stub\n", ulIn
, psOut
);
2320 /* Check range of value.
2322 if( ulIn
< I2_MIN
|| ulIn
> I2_MAX
)
2324 return DISP_E_OVERFLOW
;
2327 *psOut
= (short) ulIn
;
2332 /******************************************************************************
2333 * VarI2FromStr32 [OLEAUT32.54]
2335 HRESULT WINAPI
VarI2FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, short* psOut
)
2337 double dValue
= 0.0;
2338 LPSTR pNewString
= NULL
;
2340 TRACE( ole
, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn
, lcid
, dwFlags
, psOut
);
2342 /* Check if we have a valid argument
2344 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2345 RemoveCharacterFromString( pNewString
, "," );
2346 if( IsValidRealString( pNewString
) == FALSE
)
2348 return DISP_E_TYPEMISMATCH
;
2351 /* Convert the valid string to a floating point number.
2353 dValue
= atof( pNewString
);
2355 /* We don't need the string anymore so free it.
2357 HeapFree( GetProcessHeap(), 0, pNewString
);
2359 /* Check range of value.
2361 dValue
= round( dValue
);
2362 if( dValue
< I2_MIN
|| dValue
> I2_MAX
)
2364 return DISP_E_OVERFLOW
;
2367 *psOut
= (short) dValue
;
2372 /**********************************************************************
2373 * VarI2FromCy32 [OLEAUT32.52]
2374 * Convert currency to signed short
2376 HRESULT WINAPI
VarI2FromCy32(CY cyIn
, short* psOut
) {
2377 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2379 if (t
> I2_MAX
|| t
< I2_MIN
) return DISP_E_OVERFLOW
;
2385 /******************************************************************************
2386 * VarI4FromUI132 [OLEAUT32.58]
2388 HRESULT WINAPI
VarI4FromUI132(BYTE bIn
, LONG
* plOut
)
2390 TRACE( ole
, "( %X, %p ), stub\n", bIn
, plOut
);
2392 *plOut
= (LONG
) bIn
;
2398 /******************************************************************************
2399 * VarI4FromR432 [OLEAUT32.60]
2401 HRESULT WINAPI
VarI4FromR432(FLOAT fltIn
, LONG
* plOut
)
2403 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, plOut
);
2405 /* Check range of value.
2407 fltIn
= round( fltIn
);
2408 if( fltIn
< I4_MIN
|| fltIn
> I4_MAX
)
2410 return DISP_E_OVERFLOW
;
2413 *plOut
= (LONG
) fltIn
;
2418 /******************************************************************************
2419 * VarI4FromR832 [OLEAUT32.61]
2421 HRESULT WINAPI
VarI4FromR832(double dblIn
, LONG
* plOut
)
2423 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, plOut
);
2425 /* Check range of value.
2427 dblIn
= round( dblIn
);
2428 if( dblIn
< I4_MIN
|| dblIn
> I4_MAX
)
2430 return DISP_E_OVERFLOW
;
2433 *plOut
= (LONG
) dblIn
;
2438 /******************************************************************************
2439 * VarI4FromDate32 [OLEAUT32.63]
2441 HRESULT WINAPI
VarI4FromDate32(DATE dateIn
, LONG
* plOut
)
2443 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, plOut
);
2445 /* Check range of value.
2447 dateIn
= round( dateIn
);
2448 if( dateIn
< I4_MIN
|| dateIn
> I4_MAX
)
2450 return DISP_E_OVERFLOW
;
2453 *plOut
= (LONG
) dateIn
;
2458 /******************************************************************************
2459 * VarI4FromBool32 [OLEAUT32.66]
2461 HRESULT WINAPI
VarI4FromBool32(VARIANT_BOOL boolIn
, LONG
* plOut
)
2463 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, plOut
);
2465 *plOut
= (LONG
) boolIn
;
2470 /******************************************************************************
2471 * VarI4FromI132 [OLEAUT32.209]
2473 HRESULT WINAPI
VarI4FromI132(CHAR cIn
, LONG
* plOut
)
2475 TRACE( ole
, "( %c, %p ), stub\n", cIn
, plOut
);
2477 *plOut
= (LONG
) cIn
;
2482 /******************************************************************************
2483 * VarI4FromUI232 [OLEAUT32.210]
2485 HRESULT WINAPI
VarI4FromUI232(USHORT uiIn
, LONG
* plOut
)
2487 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, plOut
);
2489 *plOut
= (LONG
) uiIn
;
2494 /******************************************************************************
2495 * VarI4FromUI432 [OLEAUT32.211]
2497 HRESULT WINAPI
VarI4FromUI432(ULONG ulIn
, LONG
* plOut
)
2499 TRACE( ole
, "( %lx, %p ), stub\n", ulIn
, plOut
);
2501 /* Check range of value.
2503 if( ulIn
< I4_MIN
|| ulIn
> I4_MAX
)
2505 return DISP_E_OVERFLOW
;
2508 *plOut
= (LONG
) ulIn
;
2513 /******************************************************************************
2514 * VarI4FromI232 [OLEAUT32.59]
2516 HRESULT WINAPI
VarI4FromI232(short sIn
, LONG
* plOut
)
2518 TRACE( ole
, "( %d, %p ), stub\n", sIn
, plOut
);
2520 *plOut
= (LONG
) sIn
;
2525 /******************************************************************************
2526 * VarI4FromStr32 [OLEAUT32.64]
2528 HRESULT WINAPI
VarI4FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, LONG
* plOut
)
2530 double dValue
= 0.0;
2531 LPSTR pNewString
= NULL
;
2533 TRACE( ole
, "( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn
, lcid
, dwFlags
, plOut
);
2535 /* Check if we have a valid argument
2537 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2538 RemoveCharacterFromString( pNewString
, "," );
2539 if( IsValidRealString( pNewString
) == FALSE
)
2541 return DISP_E_TYPEMISMATCH
;
2544 /* Convert the valid string to a floating point number.
2546 dValue
= atof( pNewString
);
2548 /* We don't need the string anymore so free it.
2550 HeapFree( GetProcessHeap(), 0, pNewString
);
2552 /* Check range of value.
2554 dValue
= round( dValue
);
2555 if( dValue
< I4_MIN
|| dValue
> I4_MAX
)
2557 return DISP_E_OVERFLOW
;
2560 *plOut
= (LONG
) dValue
;
2565 /**********************************************************************
2566 * VarI4FromCy32 [OLEAUT32.62]
2567 * Convert currency to signed long
2569 HRESULT WINAPI
VarI4FromCy32(CY cyIn
, LONG
* plOut
) {
2570 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2572 if (t
> I4_MAX
|| t
< I4_MIN
) return DISP_E_OVERFLOW
;
2578 /******************************************************************************
2579 * VarR4FromUI132 [OLEAUT32.68]
2581 HRESULT WINAPI
VarR4FromUI132(BYTE bIn
, FLOAT
* pfltOut
)
2583 TRACE( ole
, "( %X, %p ), stub\n", bIn
, pfltOut
);
2585 *pfltOut
= (FLOAT
) bIn
;
2590 /******************************************************************************
2591 * VarR4FromI232 [OLEAUT32.69]
2593 HRESULT WINAPI
VarR4FromI232(short sIn
, FLOAT
* pfltOut
)
2595 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pfltOut
);
2597 *pfltOut
= (FLOAT
) sIn
;
2602 /******************************************************************************
2603 * VarR4FromI432 [OLEAUT32.70]
2605 HRESULT WINAPI
VarR4FromI432(LONG lIn
, FLOAT
* pfltOut
)
2607 TRACE( ole
, "( %lx, %p ), stub\n", lIn
, pfltOut
);
2609 *pfltOut
= (FLOAT
) lIn
;
2614 /******************************************************************************
2615 * VarR4FromR832 [OLEAUT32.71]
2617 HRESULT WINAPI
VarR4FromR832(double dblIn
, FLOAT
* pfltOut
)
2619 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pfltOut
);
2621 /* Check range of value.
2623 if( dblIn
< -(FLT_MAX
) || dblIn
> FLT_MAX
)
2625 return DISP_E_OVERFLOW
;
2628 *pfltOut
= (FLOAT
) dblIn
;
2633 /******************************************************************************
2634 * VarR4FromDate32 [OLEAUT32.73]
2636 HRESULT WINAPI
VarR4FromDate32(DATE dateIn
, FLOAT
* pfltOut
)
2638 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pfltOut
);
2640 /* Check range of value.
2642 if( dateIn
< -(FLT_MAX
) || dateIn
> FLT_MAX
)
2644 return DISP_E_OVERFLOW
;
2647 *pfltOut
= (FLOAT
) dateIn
;
2652 /******************************************************************************
2653 * VarR4FromBool32 [OLEAUT32.76]
2655 HRESULT WINAPI
VarR4FromBool32(VARIANT_BOOL boolIn
, FLOAT
* pfltOut
)
2657 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pfltOut
);
2659 *pfltOut
= (FLOAT
) boolIn
;
2664 /******************************************************************************
2665 * VarR4FromI132 [OLEAUT32.213]
2667 HRESULT WINAPI
VarR4FromI132(CHAR cIn
, FLOAT
* pfltOut
)
2669 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pfltOut
);
2671 *pfltOut
= (FLOAT
) cIn
;
2676 /******************************************************************************
2677 * VarR4FromUI232 [OLEAUT32.214]
2679 HRESULT WINAPI
VarR4FromUI232(USHORT uiIn
, FLOAT
* pfltOut
)
2681 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pfltOut
);
2683 *pfltOut
= (FLOAT
) uiIn
;
2688 /******************************************************************************
2689 * VarR4FromUI432 [OLEAUT32.215]
2691 HRESULT WINAPI
VarR4FromUI432(ULONG ulIn
, FLOAT
* pfltOut
)
2693 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pfltOut
);
2695 *pfltOut
= (FLOAT
) ulIn
;
2700 /******************************************************************************
2701 * VarR4FromStr32 [OLEAUT32.74]
2703 HRESULT WINAPI
VarR4FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, FLOAT
* pfltOut
)
2705 double dValue
= 0.0;
2706 LPSTR pNewString
= NULL
;
2708 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pfltOut
);
2710 /* Check if we have a valid argument
2712 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2713 RemoveCharacterFromString( pNewString
, "," );
2714 if( IsValidRealString( pNewString
) == FALSE
)
2716 return DISP_E_TYPEMISMATCH
;
2719 /* Convert the valid string to a floating point number.
2721 dValue
= atof( pNewString
);
2723 /* We don't need the string anymore so free it.
2725 HeapFree( GetProcessHeap(), 0, pNewString
);
2727 /* Check range of value.
2729 if( dValue
< -(FLT_MAX
) || dValue
> FLT_MAX
)
2731 return DISP_E_OVERFLOW
;
2734 *pfltOut
= (FLOAT
) dValue
;
2739 /**********************************************************************
2740 * VarR4FromCy32 [OLEAUT32.72]
2741 * Convert currency to float
2743 HRESULT WINAPI
VarR4FromCy32(CY cyIn
, FLOAT
* pfltOut
) {
2744 *pfltOut
= (FLOAT
)((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2749 /******************************************************************************
2750 * VarR8FromUI132 [OLEAUT32.68]
2752 HRESULT WINAPI
VarR8FromUI132(BYTE bIn
, double* pdblOut
)
2754 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pdblOut
);
2756 *pdblOut
= (double) bIn
;
2761 /******************************************************************************
2762 * VarR8FromI232 [OLEAUT32.69]
2764 HRESULT WINAPI
VarR8FromI232(short sIn
, double* pdblOut
)
2766 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pdblOut
);
2768 *pdblOut
= (double) sIn
;
2773 /******************************************************************************
2774 * VarR8FromI432 [OLEAUT32.70]
2776 HRESULT WINAPI
VarR8FromI432(LONG lIn
, double* pdblOut
)
2778 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pdblOut
);
2780 *pdblOut
= (double) lIn
;
2785 /******************************************************************************
2786 * VarR8FromR432 [OLEAUT32.81]
2788 HRESULT WINAPI
VarR8FromR432(FLOAT fltIn
, double* pdblOut
)
2790 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pdblOut
);
2792 *pdblOut
= (double) fltIn
;
2797 /******************************************************************************
2798 * VarR8FromDate32 [OLEAUT32.83]
2800 HRESULT WINAPI
VarR8FromDate32(DATE dateIn
, double* pdblOut
)
2802 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pdblOut
);
2804 *pdblOut
= (double) dateIn
;
2809 /******************************************************************************
2810 * VarR8FromBool32 [OLEAUT32.86]
2812 HRESULT WINAPI
VarR8FromBool32(VARIANT_BOOL boolIn
, double* pdblOut
)
2814 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pdblOut
);
2816 *pdblOut
= (double) boolIn
;
2821 /******************************************************************************
2822 * VarR8FromI132 [OLEAUT32.217]
2824 HRESULT WINAPI
VarR8FromI132(CHAR cIn
, double* pdblOut
)
2826 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pdblOut
);
2828 *pdblOut
= (double) cIn
;
2833 /******************************************************************************
2834 * VarR8FromUI232 [OLEAUT32.218]
2836 HRESULT WINAPI
VarR8FromUI232(USHORT uiIn
, double* pdblOut
)
2838 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pdblOut
);
2840 *pdblOut
= (double) uiIn
;
2845 /******************************************************************************
2846 * VarR8FromUI432 [OLEAUT32.219]
2848 HRESULT WINAPI
VarR8FromUI432(ULONG ulIn
, double* pdblOut
)
2850 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pdblOut
);
2852 *pdblOut
= (double) ulIn
;
2857 /******************************************************************************
2858 * VarR8FromStr32 [OLEAUT32.84]
2860 HRESULT WINAPI
VarR8FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, double* pdblOut
)
2862 double dValue
= 0.0;
2863 LPSTR pNewString
= NULL
;
2865 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pdblOut
);
2867 /* Check if we have a valid argument
2869 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
2870 RemoveCharacterFromString( pNewString
, "," );
2871 if( IsValidRealString( pNewString
) == FALSE
)
2873 return DISP_E_TYPEMISMATCH
;
2876 /* Convert the valid string to a floating point number.
2878 dValue
= atof( pNewString
);
2880 /* We don't need the string anymore so free it.
2882 HeapFree( GetProcessHeap(), 0, pNewString
);
2889 /**********************************************************************
2890 * VarR8FromCy32 [OLEAUT32.82]
2891 * Convert currency to double
2893 HRESULT WINAPI
VarR8FromCy32(CY cyIn
, double* pdblOut
) {
2894 *pdblOut
= (double)((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
2899 /******************************************************************************
2900 * VarDateFromUI132 [OLEAUT32.]
2902 HRESULT WINAPI
VarDateFromUI132(BYTE bIn
, DATE
* pdateOut
)
2904 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pdateOut
);
2906 *pdateOut
= (DATE
) bIn
;
2911 /******************************************************************************
2912 * VarDateFromI232 [OLEAUT32.222]
2914 HRESULT WINAPI
VarDateFromI232(short sIn
, DATE
* pdateOut
)
2916 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pdateOut
);
2918 *pdateOut
= (DATE
) sIn
;
2923 /******************************************************************************
2924 * VarDateFromI432 [OLEAUT32.90]
2926 HRESULT WINAPI
VarDateFromI432(LONG lIn
, DATE
* pdateOut
)
2928 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pdateOut
);
2930 if( lIn
< DATE_MIN
|| lIn
> DATE_MAX
)
2932 return DISP_E_OVERFLOW
;
2935 *pdateOut
= (DATE
) lIn
;
2940 /******************************************************************************
2941 * VarDateFromR432 [OLEAUT32.91]
2943 HRESULT WINAPI
VarDateFromR432(FLOAT fltIn
, DATE
* pdateOut
)
2945 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pdateOut
);
2947 if( ceil(fltIn
) < DATE_MIN
|| floor(fltIn
) > DATE_MAX
)
2949 return DISP_E_OVERFLOW
;
2952 *pdateOut
= (DATE
) fltIn
;
2957 /******************************************************************************
2958 * VarDateFromR832 [OLEAUT32.92]
2960 HRESULT WINAPI
VarDateFromR832(double dblIn
, DATE
* pdateOut
)
2962 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pdateOut
);
2964 if( ceil(dblIn
) < DATE_MIN
|| floor(dblIn
) > DATE_MAX
)
2966 return DISP_E_OVERFLOW
;
2969 *pdateOut
= (DATE
) dblIn
;
2974 /******************************************************************************
2975 * VarDateFromStr32 [OLEAUT32.94]
2976 * The string representing the date is composed of two parts, a date and time.
2978 * The format of the time is has follows:
2979 * hh[:mm][:ss][AM|PM]
2980 * Whitespace can be inserted anywhere between these tokens. A whitespace consists
2981 * of space and/or tab characters, which are ignored.
2983 * The formats for the date part are has follows:
2987 * January dd[,] [yy]yy
2990 * Whitespace can be inserted anywhere between these tokens.
2992 * The formats for the date and time string are has follows.
2993 * date[whitespace][time]
2994 * [time][whitespace]date
2996 * These are the only characters allowed in a string representing a date and time:
2997 * [A-Z] [a-z] [0-9] ':' '-' '/' ',' ' ' '\t'
2999 HRESULT WINAPI
VarDateFromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, DATE
* pdateOut
)
3002 struct tm TM
= { 0,0,0,0,0,0,0,0,0 };
3004 TRACE( ole
, "( %p, %lx, %lx, %p ), stub\n", strIn
, lcid
, dwFlags
, pdateOut
);
3006 if( DateTimeStringToTm( strIn
, lcid
, &TM
) )
3008 if( TmToDATE( &TM
, pdateOut
) == FALSE
)
3015 ret
= DISP_E_TYPEMISMATCH
;
3022 /******************************************************************************
3023 * VarDateFromI132 [OLEAUT32.221]
3025 HRESULT WINAPI
VarDateFromI132(CHAR cIn
, DATE
* pdateOut
)
3027 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pdateOut
);
3029 *pdateOut
= (DATE
) cIn
;
3034 /******************************************************************************
3035 * VarDateFromUI232 [OLEAUT32.222]
3037 HRESULT WINAPI
VarDateFromUI232(USHORT uiIn
, DATE
* pdateOut
)
3039 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pdateOut
);
3041 if( uiIn
> DATE_MAX
)
3043 return DISP_E_OVERFLOW
;
3046 *pdateOut
= (DATE
) uiIn
;
3051 /******************************************************************************
3052 * VarDateFromUI432 [OLEAUT32.223]
3054 HRESULT WINAPI
VarDateFromUI432(ULONG ulIn
, DATE
* pdateOut
)
3056 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pdateOut
);
3058 if( ulIn
< DATE_MIN
|| ulIn
> DATE_MAX
)
3060 return DISP_E_OVERFLOW
;
3063 *pdateOut
= (DATE
) ulIn
;
3068 /******************************************************************************
3069 * VarDateFromBool32 [OLEAUT32.96]
3071 HRESULT WINAPI
VarDateFromBool32(VARIANT_BOOL boolIn
, DATE
* pdateOut
)
3073 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pdateOut
);
3075 *pdateOut
= (DATE
) boolIn
;
3080 /**********************************************************************
3081 * VarDateFromCy32 [OLEAUT32.93]
3082 * Convert currency to date
3084 HRESULT WINAPI
VarDateFromCy32(CY cyIn
, DATE
* pdateOut
) {
3085 *pdateOut
= (DATE
)((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
3087 if (*pdateOut
> DATE_MAX
|| *pdateOut
< DATE_MIN
) return DISP_E_TYPEMISMATCH
;
3091 /******************************************************************************
3092 * VarBstrFromUI132 [OLEAUT32.108]
3094 HRESULT WINAPI
VarBstrFromUI132(BYTE bVal
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3096 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", bVal
, lcid
, dwFlags
, pbstrOut
);
3097 sprintf( pBuffer
, "%d", bVal
);
3099 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3104 /******************************************************************************
3105 * VarBstrFromI232 [OLEAUT32.109]
3107 HRESULT WINAPI
VarBstrFromI232(short iVal
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3109 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", iVal
, lcid
, dwFlags
, pbstrOut
);
3110 sprintf( pBuffer
, "%d", iVal
);
3111 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3116 /******************************************************************************
3117 * VarBstrFromI432 [OLEAUT32.110]
3119 HRESULT WINAPI
VarBstrFromI432(LONG lIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3121 TRACE( ole
, "( %ld, %ld, %ld, %p ), stub\n", lIn
, lcid
, dwFlags
, pbstrOut
);
3123 sprintf( pBuffer
, "%ld", lIn
);
3124 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3129 /******************************************************************************
3130 * VarBstrFromR432 [OLEAUT32.111]
3132 HRESULT WINAPI
VarBstrFromR432(FLOAT fltIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3134 TRACE( ole
, "( %f, %ld, %ld, %p ), stub\n", fltIn
, lcid
, dwFlags
, pbstrOut
);
3136 sprintf( pBuffer
, "%.7g", fltIn
);
3137 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3142 /******************************************************************************
3143 * VarBstrFromR832 [OLEAUT32.112]
3145 HRESULT WINAPI
VarBstrFromR832(double dblIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3147 TRACE( ole
, "( %f, %ld, %ld, %p ), stub\n", dblIn
, lcid
, dwFlags
, pbstrOut
);
3149 sprintf( pBuffer
, "%.15g", dblIn
);
3150 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3155 /******************************************************************************
3156 * VarBstrFromDate32 [OLEAUT32.114]
3158 * The date is implemented using an 8 byte floating-point number.
3159 * Days are represented by whole numbers increments starting with 0.00 has
3160 * being December 30 1899, midnight.
3161 * The hours are expressed as the fractional part of the number.
3162 * December 30 1899 at midnight = 0.00
3163 * January 1 1900 at midnight = 2.00
3164 * January 4 1900 at 6 AM = 5.25
3165 * January 4 1900 at noon = 5.50
3166 * December 29 1899 at midnight = -1.00
3167 * December 18 1899 at midnight = -12.00
3168 * December 18 1899 at 6AM = -12.25
3169 * December 18 1899 at 6PM = -12.75
3170 * December 19 1899 at midnight = -11.00
3171 * The tm structure is as follows:
3173 * int tm_sec; seconds after the minute - [0,59]
3174 * int tm_min; minutes after the hour - [0,59]
3175 * int tm_hour; hours since midnight - [0,23]
3176 * int tm_mday; day of the month - [1,31]
3177 * int tm_mon; months since January - [0,11]
3178 * int tm_year; years
3179 * int tm_wday; days since Sunday - [0,6]
3180 * int tm_yday; days since January 1 - [0,365]
3181 * int tm_isdst; daylight savings time flag
3184 HRESULT WINAPI
VarBstrFromDate32(DATE dateIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3186 struct tm TM
= {0,0,0,0,0,0,0,0,0};
3188 TRACE( ole
, "( %f, %ld, %ld, %p ), stub\n", dateIn
, lcid
, dwFlags
, pbstrOut
);
3190 if( DateToTm( dateIn
, lcid
, &TM
) == FALSE
)
3192 return E_INVALIDARG
;
3195 if( lcid
& VAR_DATEVALUEONLY
)
3196 strftime( pBuffer
, BUFFER_MAX
, "%x", &TM
);
3197 else if( lcid
& VAR_TIMEVALUEONLY
)
3198 strftime( pBuffer
, BUFFER_MAX
, "%X", &TM
);
3200 strftime( pBuffer
, BUFFER_MAX
, "%x %X", &TM
);
3202 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3207 /******************************************************************************
3208 * VarBstrFromBool32 [OLEAUT32.116]
3210 HRESULT WINAPI
VarBstrFromBool32(VARIANT_BOOL boolIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3212 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", boolIn
, lcid
, dwFlags
, pbstrOut
);
3214 if( boolIn
== VARIANT_FALSE
)
3216 sprintf( pBuffer
, "False" );
3220 sprintf( pBuffer
, "True" );
3223 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3228 /******************************************************************************
3229 * VarBstrFromI132 [OLEAUT32.229]
3231 HRESULT WINAPI
VarBstrFromI132(CHAR cIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3233 TRACE( ole
, "( %c, %ld, %ld, %p ), stub\n", cIn
, lcid
, dwFlags
, pbstrOut
);
3234 sprintf( pBuffer
, "%d", cIn
);
3235 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3240 /******************************************************************************
3241 * VarBstrFromUI232 [OLEAUT32.230]
3243 HRESULT WINAPI
VarBstrFromUI232(USHORT uiIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3245 TRACE( ole
, "( %d, %ld, %ld, %p ), stub\n", uiIn
, lcid
, dwFlags
, pbstrOut
);
3246 sprintf( pBuffer
, "%d", uiIn
);
3247 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3252 /******************************************************************************
3253 * VarBstrFromUI432 [OLEAUT32.231]
3255 HRESULT WINAPI
VarBstrFromUI432(ULONG ulIn
, LCID lcid
, ULONG dwFlags
, BSTR32
* pbstrOut
)
3257 TRACE( ole
, "( %ld, %ld, %ld, %p ), stub\n", ulIn
, lcid
, dwFlags
, pbstrOut
);
3258 sprintf( pBuffer
, "%ld", ulIn
);
3259 *pbstrOut
= StringDupAtoBstr( pBuffer
);
3264 /******************************************************************************
3265 * VarBoolFromUI132 [OLEAUT32.118]
3267 HRESULT WINAPI
VarBoolFromUI132(BYTE bIn
, VARIANT_BOOL
* pboolOut
)
3269 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pboolOut
);
3273 *pboolOut
= VARIANT_FALSE
;
3277 *pboolOut
= VARIANT_TRUE
;
3283 /******************************************************************************
3284 * VarBoolFromI232 [OLEAUT32.119]
3286 HRESULT WINAPI
VarBoolFromI232(short sIn
, VARIANT_BOOL
* pboolOut
)
3288 TRACE( ole
, "( %d, %p ), stub\n", sIn
, pboolOut
);
3292 *pboolOut
= VARIANT_FALSE
;
3296 *pboolOut
= VARIANT_TRUE
;
3302 /******************************************************************************
3303 * VarBoolFromI432 [OLEAUT32.120]
3305 HRESULT WINAPI
VarBoolFromI432(LONG lIn
, VARIANT_BOOL
* pboolOut
)
3307 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pboolOut
);
3311 *pboolOut
= VARIANT_FALSE
;
3315 *pboolOut
= VARIANT_TRUE
;
3321 /******************************************************************************
3322 * VarBoolFromR432 [OLEAUT32.121]
3324 HRESULT WINAPI
VarBoolFromR432(FLOAT fltIn
, VARIANT_BOOL
* pboolOut
)
3326 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pboolOut
);
3330 *pboolOut
= VARIANT_FALSE
;
3334 *pboolOut
= VARIANT_TRUE
;
3340 /******************************************************************************
3341 * VarBoolFromR832 [OLEAUT32.122]
3343 HRESULT WINAPI
VarBoolFromR832(double dblIn
, VARIANT_BOOL
* pboolOut
)
3345 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pboolOut
);
3349 *pboolOut
= VARIANT_FALSE
;
3353 *pboolOut
= VARIANT_TRUE
;
3359 /******************************************************************************
3360 * VarBoolFromDate32 [OLEAUT32.123]
3362 HRESULT WINAPI
VarBoolFromDate32(DATE dateIn
, VARIANT_BOOL
* pboolOut
)
3364 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pboolOut
);
3368 *pboolOut
= VARIANT_FALSE
;
3372 *pboolOut
= VARIANT_TRUE
;
3378 /******************************************************************************
3379 * VarBoolFromStr32 [OLEAUT32.125]
3381 HRESULT WINAPI
VarBoolFromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, VARIANT_BOOL
* pboolOut
)
3384 char* pNewString
= NULL
;
3386 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pboolOut
);
3388 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3390 if( pNewString
== NULL
|| strlen( pNewString
) == 0 )
3392 ret
= DISP_E_TYPEMISMATCH
;
3397 if( strncasecmp( pNewString
, "True", strlen( pNewString
) ) == 0 )
3399 *pboolOut
= VARIANT_TRUE
;
3401 else if( strncasecmp( pNewString
, "False", strlen( pNewString
) ) == 0 )
3403 *pboolOut
= VARIANT_FALSE
;
3407 /* Try converting the string to a floating point number.
3409 double dValue
= 0.0;
3410 HRESULT res
= VarR8FromStr32( strIn
, lcid
, dwFlags
, &dValue
);
3413 ret
= DISP_E_TYPEMISMATCH
;
3415 else if( dValue
== 0.0 )
3417 *pboolOut
= VARIANT_FALSE
;
3421 *pboolOut
= VARIANT_TRUE
;
3426 HeapFree( GetProcessHeap(), 0, pNewString
);
3431 /******************************************************************************
3432 * VarBoolFromI132 [OLEAUT32.233]
3434 HRESULT WINAPI
VarBoolFromI132(CHAR cIn
, VARIANT_BOOL
* pboolOut
)
3436 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pboolOut
);
3440 *pboolOut
= VARIANT_FALSE
;
3444 *pboolOut
= VARIANT_TRUE
;
3450 /******************************************************************************
3451 * VarBoolFromUI232 [OLEAUT32.234]
3453 HRESULT WINAPI
VarBoolFromUI232(USHORT uiIn
, VARIANT_BOOL
* pboolOut
)
3455 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pboolOut
);
3459 *pboolOut
= VARIANT_FALSE
;
3463 *pboolOut
= VARIANT_TRUE
;
3469 /******************************************************************************
3470 * VarBoolFromUI432 [OLEAUT32.235]
3472 HRESULT WINAPI
VarBoolFromUI432(ULONG ulIn
, VARIANT_BOOL
* pboolOut
)
3474 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pboolOut
);
3478 *pboolOut
= VARIANT_FALSE
;
3482 *pboolOut
= VARIANT_TRUE
;
3488 /**********************************************************************
3489 * VarBoolFromCy32 [OLEAUT32.124]
3490 * Convert currency to boolean
3492 HRESULT WINAPI
VarBoolFromCy32(CY cyIn
, VARIANT_BOOL
* pboolOut
) {
3493 if (cyIn
.u
.Hi
|| cyIn
.u
.Lo
) *pboolOut
= -1;
3499 /******************************************************************************
3500 * VarI1FromUI132 [OLEAUT32.244]
3502 HRESULT WINAPI
VarI1FromUI132(BYTE bIn
, CHAR
* pcOut
)
3504 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pcOut
);
3506 /* Check range of value.
3508 if( bIn
> CHAR_MAX
)
3510 return DISP_E_OVERFLOW
;
3513 *pcOut
= (CHAR
) bIn
;
3518 /******************************************************************************
3519 * VarI1FromI232 [OLEAUT32.245]
3521 HRESULT WINAPI
VarI1FromI232(short uiIn
, CHAR
* pcOut
)
3523 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pcOut
);
3525 if( uiIn
> CHAR_MAX
)
3527 return DISP_E_OVERFLOW
;
3530 *pcOut
= (CHAR
) uiIn
;
3535 /******************************************************************************
3536 * VarI1FromI432 [OLEAUT32.246]
3538 HRESULT WINAPI
VarI1FromI432(LONG lIn
, CHAR
* pcOut
)
3540 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pcOut
);
3542 if( lIn
< CHAR_MIN
|| lIn
> CHAR_MAX
)
3544 return DISP_E_OVERFLOW
;
3547 *pcOut
= (CHAR
) lIn
;
3552 /******************************************************************************
3553 * VarI1FromR432 [OLEAUT32.247]
3555 HRESULT WINAPI
VarI1FromR432(FLOAT fltIn
, CHAR
* pcOut
)
3557 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, pcOut
);
3559 fltIn
= round( fltIn
);
3560 if( fltIn
< CHAR_MIN
|| fltIn
> CHAR_MAX
)
3562 return DISP_E_OVERFLOW
;
3565 *pcOut
= (CHAR
) fltIn
;
3570 /******************************************************************************
3571 * VarI1FromR832 [OLEAUT32.248]
3573 HRESULT WINAPI
VarI1FromR832(double dblIn
, CHAR
* pcOut
)
3575 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pcOut
);
3577 dblIn
= round( dblIn
);
3578 if( dblIn
< CHAR_MIN
|| dblIn
> CHAR_MAX
)
3580 return DISP_E_OVERFLOW
;
3583 *pcOut
= (CHAR
) dblIn
;
3588 /******************************************************************************
3589 * VarI1FromDate32 [OLEAUT32.249]
3591 HRESULT WINAPI
VarI1FromDate32(DATE dateIn
, CHAR
* pcOut
)
3593 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pcOut
);
3595 dateIn
= round( dateIn
);
3596 if( dateIn
< CHAR_MIN
|| dateIn
> CHAR_MAX
)
3598 return DISP_E_OVERFLOW
;
3601 *pcOut
= (CHAR
) dateIn
;
3606 /******************************************************************************
3607 * VarI1FromStr32 [OLEAUT32.251]
3609 HRESULT WINAPI
VarI1FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, CHAR
* pcOut
)
3611 double dValue
= 0.0;
3612 LPSTR pNewString
= NULL
;
3614 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pcOut
);
3616 /* Check if we have a valid argument
3618 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3619 RemoveCharacterFromString( pNewString
, "," );
3620 if( IsValidRealString( pNewString
) == FALSE
)
3622 return DISP_E_TYPEMISMATCH
;
3625 /* Convert the valid string to a floating point number.
3627 dValue
= atof( pNewString
);
3629 /* We don't need the string anymore so free it.
3631 HeapFree( GetProcessHeap(), 0, pNewString
);
3633 /* Check range of value.
3635 dValue
= round( dValue
);
3636 if( dValue
< CHAR_MIN
|| dValue
> CHAR_MAX
)
3638 return DISP_E_OVERFLOW
;
3641 *pcOut
= (CHAR
) dValue
;
3646 /******************************************************************************
3647 * VarI1FromBool32 [OLEAUT32.253]
3649 HRESULT WINAPI
VarI1FromBool32(VARIANT_BOOL boolIn
, CHAR
* pcOut
)
3651 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pcOut
);
3653 *pcOut
= (CHAR
) boolIn
;
3658 /******************************************************************************
3659 * VarI1FromUI232 [OLEAUT32.254]
3661 HRESULT WINAPI
VarI1FromUI232(USHORT uiIn
, CHAR
* pcOut
)
3663 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pcOut
);
3665 if( uiIn
> CHAR_MAX
)
3667 return DISP_E_OVERFLOW
;
3670 *pcOut
= (CHAR
) uiIn
;
3675 /******************************************************************************
3676 * VarI1FromUI432 [OLEAUT32.255]
3678 HRESULT WINAPI
VarI1FromUI432(ULONG ulIn
, CHAR
* pcOut
)
3680 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, pcOut
);
3682 if( ulIn
> CHAR_MAX
)
3684 return DISP_E_OVERFLOW
;
3687 *pcOut
= (CHAR
) ulIn
;
3692 /**********************************************************************
3693 * VarI1FromCy32 [OLEAUT32.250]
3694 * Convert currency to signed char
3696 HRESULT WINAPI
VarI1FromCy32(CY cyIn
, CHAR
* pcOut
) {
3697 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
3699 if (t
> CHAR_MAX
|| t
< CHAR_MIN
) return DISP_E_OVERFLOW
;
3705 /******************************************************************************
3706 * VarUI2FromUI132 [OLEAUT32.257]
3708 HRESULT WINAPI
VarUI2FromUI132(BYTE bIn
, USHORT
* puiOut
)
3710 TRACE( ole
, "( %d, %p ), stub\n", bIn
, puiOut
);
3712 *puiOut
= (USHORT
) bIn
;
3717 /******************************************************************************
3718 * VarUI2FromI232 [OLEAUT32.258]
3720 HRESULT WINAPI
VarUI2FromI232(short uiIn
, USHORT
* puiOut
)
3722 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, puiOut
);
3724 if( uiIn
< UI2_MIN
)
3726 return DISP_E_OVERFLOW
;
3729 *puiOut
= (USHORT
) uiIn
;
3734 /******************************************************************************
3735 * VarUI2FromI432 [OLEAUT32.259]
3737 HRESULT WINAPI
VarUI2FromI432(LONG lIn
, USHORT
* puiOut
)
3739 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, puiOut
);
3741 if( lIn
< UI2_MIN
|| lIn
> UI2_MAX
)
3743 return DISP_E_OVERFLOW
;
3746 *puiOut
= (USHORT
) lIn
;
3751 /******************************************************************************
3752 * VarUI2FromR432 [OLEAUT32.260]
3754 HRESULT WINAPI
VarUI2FromR432(FLOAT fltIn
, USHORT
* puiOut
)
3756 TRACE( ole
, "( %f, %p ), stub\n", fltIn
, puiOut
);
3758 fltIn
= round( fltIn
);
3759 if( fltIn
< UI2_MIN
|| fltIn
> UI2_MAX
)
3761 return DISP_E_OVERFLOW
;
3764 *puiOut
= (USHORT
) fltIn
;
3769 /******************************************************************************
3770 * VarUI2FromR832 [OLEAUT32.261]
3772 HRESULT WINAPI
VarUI2FromR832(double dblIn
, USHORT
* puiOut
)
3774 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, puiOut
);
3776 dblIn
= round( dblIn
);
3777 if( dblIn
< UI2_MIN
|| dblIn
> UI2_MAX
)
3779 return DISP_E_OVERFLOW
;
3782 *puiOut
= (USHORT
) dblIn
;
3787 /******************************************************************************
3788 * VarUI2FromDate32 [OLEAUT32.262]
3790 HRESULT WINAPI
VarUI2FromDate32(DATE dateIn
, USHORT
* puiOut
)
3792 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, puiOut
);
3794 dateIn
= round( dateIn
);
3795 if( dateIn
< UI2_MIN
|| dateIn
> UI2_MAX
)
3797 return DISP_E_OVERFLOW
;
3800 *puiOut
= (USHORT
) dateIn
;
3805 /******************************************************************************
3806 * VarUI2FromStr32 [OLEAUT32.264]
3808 HRESULT WINAPI
VarUI2FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, USHORT
* puiOut
)
3810 double dValue
= 0.0;
3811 LPSTR pNewString
= NULL
;
3813 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, puiOut
);
3815 /* Check if we have a valid argument
3817 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3818 RemoveCharacterFromString( pNewString
, "," );
3819 if( IsValidRealString( pNewString
) == FALSE
)
3821 return DISP_E_TYPEMISMATCH
;
3824 /* Convert the valid string to a floating point number.
3826 dValue
= atof( pNewString
);
3828 /* We don't need the string anymore so free it.
3830 HeapFree( GetProcessHeap(), 0, pNewString
);
3832 /* Check range of value.
3834 dValue
= round( dValue
);
3835 if( dValue
< UI2_MIN
|| dValue
> UI2_MAX
)
3837 return DISP_E_OVERFLOW
;
3840 *puiOut
= (USHORT
) dValue
;
3845 /******************************************************************************
3846 * VarUI2FromBool32 [OLEAUT32.266]
3848 HRESULT WINAPI
VarUI2FromBool32(VARIANT_BOOL boolIn
, USHORT
* puiOut
)
3850 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, puiOut
);
3852 *puiOut
= (USHORT
) boolIn
;
3857 /******************************************************************************
3858 * VarUI2FromI132 [OLEAUT32.267]
3860 HRESULT WINAPI
VarUI2FromI132(CHAR cIn
, USHORT
* puiOut
)
3862 TRACE( ole
, "( %c, %p ), stub\n", cIn
, puiOut
);
3864 *puiOut
= (USHORT
) cIn
;
3869 /******************************************************************************
3870 * VarUI2FromUI432 [OLEAUT32.268]
3872 HRESULT WINAPI
VarUI2FromUI432(ULONG ulIn
, USHORT
* puiOut
)
3874 TRACE( ole
, "( %ld, %p ), stub\n", ulIn
, puiOut
);
3876 if( ulIn
< UI2_MIN
|| ulIn
> UI2_MAX
)
3878 return DISP_E_OVERFLOW
;
3881 *puiOut
= (USHORT
) ulIn
;
3886 /******************************************************************************
3887 * VarUI4FromStr32 [OLEAUT32.277]
3889 HRESULT WINAPI
VarUI4FromStr32(OLECHAR32
* strIn
, LCID lcid
, ULONG dwFlags
, ULONG
* pulOut
)
3891 double dValue
= 0.0;
3892 LPSTR pNewString
= NULL
;
3894 TRACE( ole
, "( %p, %ld, %ld, %p ), stub\n", strIn
, lcid
, dwFlags
, pulOut
);
3896 /* Check if we have a valid argument
3898 pNewString
= HEAP_strdupWtoA( GetProcessHeap(), 0, strIn
);
3899 RemoveCharacterFromString( pNewString
, "," );
3900 if( IsValidRealString( pNewString
) == FALSE
)
3902 return DISP_E_TYPEMISMATCH
;
3905 /* Convert the valid string to a floating point number.
3907 dValue
= atof( pNewString
);
3909 /* We don't need the string anymore so free it.
3911 HeapFree( GetProcessHeap(), 0, pNewString
);
3913 /* Check range of value.
3915 dValue
= round( dValue
);
3916 if( dValue
< UI4_MIN
|| dValue
> UI4_MAX
)
3918 return DISP_E_OVERFLOW
;
3921 *pulOut
= (ULONG
) dValue
;
3926 /**********************************************************************
3927 * VarUI2FromCy32 [OLEAUT32.263]
3928 * Convert currency to unsigned short
3930 HRESULT WINAPI
VarUI2FromCy32(CY cyIn
, USHORT
* pusOut
) {
3931 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
3933 if (t
> UI2_MAX
|| t
< UI2_MIN
) return DISP_E_OVERFLOW
;
3935 *pusOut
= (USHORT
)t
;
3940 /******************************************************************************
3941 * VarUI4FromUI132 [OLEAUT32.270]
3943 HRESULT WINAPI
VarUI4FromUI132(BYTE bIn
, ULONG
* pulOut
)
3945 TRACE( ole
, "( %d, %p ), stub\n", bIn
, pulOut
);
3947 *pulOut
= (USHORT
) bIn
;
3952 /******************************************************************************
3953 * VarUI4FromI232 [OLEAUT32.271]
3955 HRESULT WINAPI
VarUI4FromI232(short uiIn
, ULONG
* pulOut
)
3957 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pulOut
);
3959 if( uiIn
< UI4_MIN
)
3961 return DISP_E_OVERFLOW
;
3964 *pulOut
= (ULONG
) uiIn
;
3969 /******************************************************************************
3970 * VarUI4FromI432 [OLEAUT32.272]
3972 HRESULT WINAPI
VarUI4FromI432(LONG lIn
, ULONG
* pulOut
)
3974 TRACE( ole
, "( %ld, %p ), stub\n", lIn
, pulOut
);
3978 return DISP_E_OVERFLOW
;
3981 *pulOut
= (ULONG
) lIn
;
3986 /******************************************************************************
3987 * VarUI4FromR432 [OLEAUT32.273]
3989 HRESULT WINAPI
VarUI4FromR432(FLOAT fltIn
, ULONG
* pulOut
)
3991 fltIn
= round( fltIn
);
3992 if( fltIn
< UI4_MIN
|| fltIn
> UI4_MAX
)
3994 return DISP_E_OVERFLOW
;
3997 *pulOut
= (ULONG
) fltIn
;
4002 /******************************************************************************
4003 * VarUI4FromR832 [OLEAUT32.274]
4005 HRESULT WINAPI
VarUI4FromR832(double dblIn
, ULONG
* pulOut
)
4007 TRACE( ole
, "( %f, %p ), stub\n", dblIn
, pulOut
);
4009 dblIn
= round( dblIn
);
4010 if( dblIn
< UI4_MIN
|| dblIn
> UI4_MAX
)
4012 return DISP_E_OVERFLOW
;
4015 *pulOut
= (ULONG
) dblIn
;
4020 /******************************************************************************
4021 * VarUI4FromDate32 [OLEAUT32.275]
4023 HRESULT WINAPI
VarUI4FromDate32(DATE dateIn
, ULONG
* pulOut
)
4025 TRACE( ole
, "( %f, %p ), stub\n", dateIn
, pulOut
);
4027 dateIn
= round( dateIn
);
4028 if( dateIn
< UI4_MIN
|| dateIn
> UI4_MAX
)
4030 return DISP_E_OVERFLOW
;
4033 *pulOut
= (ULONG
) dateIn
;
4038 /******************************************************************************
4039 * VarUI4FromBool32 [OLEAUT32.279]
4041 HRESULT WINAPI
VarUI4FromBool32(VARIANT_BOOL boolIn
, ULONG
* pulOut
)
4043 TRACE( ole
, "( %d, %p ), stub\n", boolIn
, pulOut
);
4045 *pulOut
= (ULONG
) boolIn
;
4050 /******************************************************************************
4051 * VarUI4FromI132 [OLEAUT32.280]
4053 HRESULT WINAPI
VarUI4FromI132(CHAR cIn
, ULONG
* pulOut
)
4055 TRACE( ole
, "( %c, %p ), stub\n", cIn
, pulOut
);
4057 *pulOut
= (ULONG
) cIn
;
4062 /******************************************************************************
4063 * VarUI4FromUI232 [OLEAUT32.281]
4065 HRESULT WINAPI
VarUI4FromUI232(USHORT uiIn
, ULONG
* pulOut
)
4067 TRACE( ole
, "( %d, %p ), stub\n", uiIn
, pulOut
);
4069 *pulOut
= (ULONG
) uiIn
;
4074 /**********************************************************************
4075 * VarUI4FromCy32 [OLEAUT32.276]
4076 * Convert currency to unsigned long
4078 HRESULT WINAPI
VarUI4FromCy32(CY cyIn
, ULONG
* pulOut
) {
4079 double t
= round((((double)cyIn
.u
.Hi
* 4294967296.0) + (double)cyIn
.u
.Lo
) / 10000);
4081 if (t
> UI4_MAX
|| t
< UI4_MIN
) return DISP_E_OVERFLOW
;
4088 /**********************************************************************
4089 * VarCyFromUI132 [OLEAUT32.98]
4090 * Convert unsigned char to currency
4092 HRESULT WINAPI
VarCyFromUI132(BYTE bIn
, CY
* pcyOut
) {
4094 pcyOut
->u
.Lo
= ((ULONG
)bIn
) * 10000;
4099 /**********************************************************************
4100 * VarCyFromI232 [OLEAUT32.99]
4101 * Convert signed short to currency
4103 HRESULT WINAPI
VarCyFromI232(short sIn
, CY
* pcyOut
) {
4104 if (sIn
< 0) pcyOut
->u
.Hi
= -1;
4105 else pcyOut
->u
.Hi
= 0;
4106 pcyOut
->u
.Lo
= ((ULONG
)sIn
) * 10000;
4111 /**********************************************************************
4112 * VarCyFromI432 [OLEAUT32.100]
4113 * Convert signed long to currency
4115 HRESULT WINAPI
VarCyFromI432(LONG lIn
, CY
* pcyOut
) {
4116 double t
= (double)lIn
* (double)10000;
4117 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4118 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4119 if (lIn
< 0) pcyOut
->u
.Hi
--;
4124 /**********************************************************************
4125 * VarCyFromR432 [OLEAUT32.101]
4126 * Convert float to currency
4128 HRESULT WINAPI
VarCyFromR432(FLOAT fltIn
, CY
* pcyOut
) {
4129 double t
= round((double)fltIn
* (double)10000);
4130 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4131 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4132 if (fltIn
< 0) pcyOut
->u
.Hi
--;
4137 /**********************************************************************
4138 * VarCyFromR832 [OLEAUT32.102]
4139 * Convert double to currency
4141 HRESULT WINAPI
VarCyFromR832(double dblIn
, CY
* pcyOut
) {
4142 double t
= round(dblIn
* (double)10000);
4143 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4144 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4145 if (dblIn
< 0) pcyOut
->u
.Hi
--;
4150 /**********************************************************************
4151 * VarCyFromDate32 [OLEAUT32.103]
4152 * Convert date to currency
4154 HRESULT WINAPI
VarCyFromDate32(DATE dateIn
, CY
* pcyOut
) {
4155 double t
= round((double)dateIn
* (double)10000);
4156 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4157 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);
4158 if (dateIn
< 0) pcyOut
->u
.Hi
--;
4163 /**********************************************************************
4164 * VarCyFromBool32 [OLEAUT32.106]
4165 * Convert boolean to currency
4167 HRESULT WINAPI
VarCyFromBool32(VARIANT_BOOL boolIn
, CY
* pcyOut
) {
4168 if (boolIn
< 0) pcyOut
->u
.Hi
= -1;
4169 else pcyOut
->u
.Hi
= 0;
4170 pcyOut
->u
.Lo
= (ULONG
)boolIn
* (ULONG
)10000;
4175 /**********************************************************************
4176 * VarCyFromI132 [OLEAUT32.225]
4177 * Convert signed char to currency
4179 HRESULT WINAPI
VarCyFromI132(CHAR cIn
, CY
* pcyOut
) {
4180 if (cIn
< 0) pcyOut
->u
.Hi
= -1;
4181 else pcyOut
->u
.Hi
= 0;
4182 pcyOut
->u
.Lo
= (ULONG
)cIn
* (ULONG
)10000;
4187 /**********************************************************************
4188 * VarCyFromUI232 [OLEAUT32.226]
4189 * Convert unsigned short to currency
4191 HRESULT WINAPI
VarCyFromUI232(USHORT usIn
, CY
* pcyOut
) {
4193 pcyOut
->u
.Lo
= (ULONG
)usIn
* (ULONG
)10000;
4198 /**********************************************************************
4199 * VarCyFromUI432 [OLEAUT32.227]
4200 * Convert unsigned long to currency
4202 HRESULT WINAPI
VarCyFromUI432(ULONG ulIn
, CY
* pcyOut
) {
4203 double t
= (double)ulIn
* (double)10000;
4204 pcyOut
->u
.Hi
= (LONG
)(t
/ (double)4294967296.0);
4205 pcyOut
->u
.Lo
= (ULONG
)fmod(t
, (double)4294967296.0);