?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed a few inter-dll dependencies.
[wine/multimedia.git] / dlls / oleaut32 / variant.c
blob0895c547d1868f422906ffdfe268f017f5e26161
1 /*
2 * VARIANT
3 *
4 * Copyright 1998 Jean-Claude Cote
5 *
6 * NOTES
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.
11 *
12 * TODO:
13 * - The Variant APIs 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.
21 */
22
23 #include "config.h"
24
25 #include <string.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <math.h>
29 #include <time.h>
30
31 #ifdef HAVE_FLOAT_H
32 # include <float.h>
33 #endif
34
35 #include "windef.h"
36 #include "oleauto.h"
37 #include "heap.h"
38 #include "debugtools.h"
39 #include "winerror.h"
40 #include "parsedt.h"
41
42 DEFAULT_DEBUG_CHANNEL(ole);
43
44 #ifndef FLT_MAX
45 # ifdef MAXFLOAT
46 # define FLT_MAX MAXFLOAT
47 # else
48 # error "Can't find #define for MAXFLOAT/FLT_MAX"
49 # endif
50 #endif
51
52 #undef CHAR_MAX
53 #undef CHAR_MIN
54 static const char CHAR_MAX = 127;
55 static const char CHAR_MIN = -128;
56 static const BYTE UI1_MAX = 255;
57 static const BYTE UI1_MIN = 0;
58 static const unsigned short UI2_MAX = 65535;
59 static const unsigned short UI2_MIN = 0;
60 static const short I2_MAX = 32767;
61 static const short I2_MIN = -32768;
62 static const unsigned long UI4_MAX = 4294967295U;
63 static const unsigned long UI4_MIN = 0;
64 static const long I4_MAX = 2147483647;
65 static const long I4_MIN = -(2147483648U);
66 static const DATE DATE_MIN = -657434;
67 static const DATE DATE_MAX = 2958465;
68
69
70 /* This mask is used to set a flag in wReserved1 of
71 * the VARIANTARG structure. The flag indicates if
72 * the API function is using an inner variant or not.
73 */
74 #define PROCESSING_INNER_VARIANT 0x0001
75
76 /* General use buffer.
77 */
78 #define BUFFER_MAX 1024
79 static char pBuffer[BUFFER_MAX];
80
81 /*
82 * Note a leap year is one that is a multiple of 4
83 * but not of a 100. Except if it is a multiple of
84 * 400 then it is a leap year.
85 */
86 /* According to postgeSQL date parsing functions there is
87 * a leap year when this expression is true.
88 * (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
89 * So according to this there is 365.2515 days in one year.
90 * One + every four years: 1/4 -> 365.25
91 * One - every 100 years: 1/100 -> 365.01
92 * One + every 400 years: 1/400 -> 365.0025
93 */
94 /* static const double DAYS_IN_ONE_YEAR = 365.2515;
95 *
96 * ^^ Might this be the key to an easy way to factor large prime numbers?
97 * Let's try using arithmetic. <lawson_whitney@juno.com> 7 Mar 2000
98 */
99 static const double DAYS_IN_ONE_YEAR = 365.2425;
100
101 /******************************************************************************
102 * DateTimeStringToTm [INTERNAL]
103 *
104 * Converts a string representation of a date and/or time to a tm structure.
105 *
106 * Note this function uses the postgresql date parsing functions found
107 * in the parsedt.c file.
108 *
109 * Returns TRUE if successfull.
110 *
111 * Note: This function does not parse the day of the week,
112 * daylight savings time. It will only fill the followin fields in
113 * the tm struct, tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
114 *
115 ******************************************************************************/
116 static BOOL DateTimeStringToTm( OLECHAR* strIn, LCID lcid, struct tm* pTm )
117 {
118 BOOL res = FALSE;
119 double fsec;
120 int tzp;
121 int dtype;
122 int nf;
123 char *field[MAXDATEFIELDS];
124 int ftype[MAXDATEFIELDS];
125 char lowstr[MAXDATELEN + 1];
126 char* strDateTime = NULL;
127
128 /* Convert the string to ASCII since this is the only format
129 * postgesql can handle.
130 */
131 strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
132
133 if( strDateTime != NULL )
134 {
135 /* Make sure we don't go over the maximum length
136 * accepted by postgesql.
137 */
138 if( strlen( strDateTime ) <= MAXDATELEN )
139 {
140 if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
141 {
142 if( lcid & VAR_DATEVALUEONLY )
143 {
144 /* Get the date information.
145 * It returns 0 if date information was
146 * present and 1 if only time information was present.
147 * -1 if an error occures.
148 */
149 if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
150 {
151 /* Eliminate the time information since we
152 * were asked to get date information only.
153 */
154 pTm->tm_sec = 0;
155 pTm->tm_min = 0;
156 pTm->tm_hour = 0;
157 res = TRUE;
158 }
159 }
160 if( lcid & VAR_TIMEVALUEONLY )
161 {
162 /* Get time information only.
163 */
164 if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
165 {
166 res = TRUE;
167 }
168 }
169 else
170 {
171 /* Get both date and time information.
172 * It returns 0 if date information was
173 * present and 1 if only time information was present.
174 * -1 if an error occures.
175 */
176 if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
177 {
178 res = TRUE;
179 }
180 }
181 }
182 }
183 HeapFree( GetProcessHeap(), 0, strDateTime );
184 }
185
186 return res;
187 }
188
189
190
191
192
193
194 /******************************************************************************
195 * TmToDATE [INTERNAL]
196 *
197 * The date is implemented using an 8 byte floating-point number.
198 * Days are represented by whole numbers increments starting with 0.00 has
199 * being December 30 1899, midnight.
200 * The hours are expressed as the fractional part of the number.
201 * December 30 1899 at midnight = 0.00
202 * January 1 1900 at midnight = 2.00
203 * January 4 1900 at 6 AM = 5.25
204 * January 4 1900 at noon = 5.50
205 * December 29 1899 at midnight = -1.00
206 * December 18 1899 at midnight = -12.00
207 * December 18 1899 at 6AM = -12.25
208 * December 18 1899 at 6PM = -12.75
209 * December 19 1899 at midnight = -11.00
210 * The tm structure is as follows:
211 * struct tm {
212 * int tm_sec; seconds after the minute - [0,59]
213 * int tm_min; minutes after the hour - [0,59]
214 * int tm_hour; hours since midnight - [0,23]
215 * int tm_mday; day of the month - [1,31]
216 * int tm_mon; months since January - [0,11]
217 * int tm_year; years
218 * int tm_wday; days since Sunday - [0,6]
219 * int tm_yday; days since January 1 - [0,365]
220 * int tm_isdst; daylight savings time flag
221 * };
222 *
223 * Note: This function does not use the tm_wday, tm_yday, tm_wday,
224 * and tm_isdst fields of the tm structure. And only converts years
225 * after 1900.
226 *
227 * Returns TRUE if successfull.
228 */
229 static BOOL TmToDATE( struct tm* pTm, DATE *pDateOut )
230 {
231 if( (pTm->tm_year - 1900) >= 0 )
232 {
233 int leapYear = 0;
234
235 /* Start at 1. This is the way DATE is defined.
236 * January 1, 1900 at Midnight is 1.00.
237 * January 1, 1900 at 6AM is 1.25.
238 * and so on.
239 */
240 *pDateOut = 1;
241
242 /* Add the number of days corresponding to
243 * tm_year.
244 */
245 *pDateOut += (pTm->tm_year - 1900) * 365;
246
247 /* Add the leap days in the previous years between now and 1900.
248 * Note a leap year is one that is a multiple of 4
249 * but not of a 100. Except if it is a multiple of
250 * 400 then it is a leap year.
251 */
252 *pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
253 *pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
254 *pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
255
256 /* Set the leap year flag if the
257 * current year specified by tm_year is a
258 * leap year. This will be used to add a day
259 * to the day count.
260 */
261 if( isleap( pTm->tm_year ) )
262 leapYear = 1;
263
264 /* Add the number of days corresponding to
265 * the month.
266 */
267 switch( pTm->tm_mon )
268 {
269 case 2:
270 *pDateOut += 31;
271 break;
272 case 3:
273 *pDateOut += ( 59 + leapYear );
274 break;
275 case 4:
276 *pDateOut += ( 90 + leapYear );
277 break;
278 case 5:
279 *pDateOut += ( 120 + leapYear );
280 break;
281 case 6:
282 *pDateOut += ( 151 + leapYear );
283 break;
284 case 7:
285 *pDateOut += ( 181 + leapYear );
286 break;
287 case 8:
288 *pDateOut += ( 212 + leapYear );
289 break;
290 case 9:
291 *pDateOut += ( 243 + leapYear );
292 break;
293 case 10:
294 *pDateOut += ( 273 + leapYear );
295 break;
296 case 11:
297 *pDateOut += ( 304 + leapYear );
298 break;
299 case 12:
300 *pDateOut += ( 334 + leapYear );
301 break;
302 }
303 /* Add the number of days in this month.
304 */
305 *pDateOut += pTm->tm_mday;
306
307 /* Add the number of seconds, minutes, and hours
308 * to the DATE. Note these are the fracionnal part
309 * of the DATE so seconds / number of seconds in a day.
310 */
311 *pDateOut += pTm->tm_hour / 24.0;
312 *pDateOut += pTm->tm_min / 1440.0;
313 *pDateOut += pTm->tm_sec / 86400.0;
314 return TRUE;
315 }
316 return FALSE;
317 }
318
319 /******************************************************************************
320 * DateToTm [INTERNAL]
321 *
322 * This function converst a windows DATE to a tm structure.
323 *
324 * It does not fill all the fields of the tm structure.
325 * Here is a list of the fields that are filled:
326 * tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
327 *
328 * Note this function does not support dates before the January 1, 1900
329 * or ( dateIn < 2.0 ).
330 *
331 * Returns TRUE if successfull.
332 */
333 static BOOL DateToTm( DATE dateIn, LCID lcid, struct tm* pTm )
334 {
335 /* Do not process dates smaller than January 1, 1900.
336 * Which corresponds to 2.0 in the windows DATE format.
337 */
338 if( dateIn >= 2.0 )
339 {
340 double decimalPart = 0.0;
341 double wholePart = 0.0;
342
343 memset(pTm,0,sizeof(*pTm));
344
345 /* Because of the nature of DATE format witch
346 * associates 2.0 to January 1, 1900. We will
347 * remove 1.0 from the whole part of the DATE
348 * so that in the following code 1.0
349 * will correspond to January 1, 1900.
350 * This simplyfies the processing of the DATE value.
351 */
352 dateIn -= 1.0;
353
354 wholePart = (double) floor( dateIn );
355 decimalPart = fmod( dateIn, wholePart );
356
357 if( !(lcid & VAR_TIMEVALUEONLY) )
358 {
359 int nDay = 0;
360 int leapYear = 0;
361 double yearsSince1900 = 0;
362 /* Start at 1900, this where the DATE time 0.0 starts.
363 */
364 pTm->tm_year = 1900;
365 /* find in what year the day in the "wholePart" falls into.
366 * add the value to the year field.
367 */
368 yearsSince1900 = floor( (wholePart / DAYS_IN_ONE_YEAR) + 0.001 );
369 pTm->tm_year += yearsSince1900;
370 /* determine if this is a leap year.
371 */
372 if( isleap( pTm->tm_year ) )
373 {
374 leapYear = 1;
375 wholePart++;
376 }
377
378 /* find what day of that year does the "wholePart" corresponds to.
379 * Note: nDay is in [1-366] format
380 */
381 nDay = (int) ( wholePart - floor( yearsSince1900 * DAYS_IN_ONE_YEAR ) );
382 /* Set the tm_yday value.
383 * Note: The day is must be converted from [1-366] to [0-365]
384 */
385 /*pTm->tm_yday = nDay - 1;*/
386 /* find which mount this day corresponds to.
387 */
388 if( nDay <= 31 )
389 {
390 pTm->tm_mday = nDay;
391 pTm->tm_mon = 0;
392 }
393 else if( nDay <= ( 59 + leapYear ) )
394 {
395 pTm->tm_mday = nDay - 31;
396 pTm->tm_mon = 1;
397 }
398 else if( nDay <= ( 90 + leapYear ) )
399 {
400 pTm->tm_mday = nDay - ( 59 + leapYear );
401 pTm->tm_mon = 2;
402 }
403 else if( nDay <= ( 120 + leapYear ) )
404 {
405 pTm->tm_mday = nDay - ( 90 + leapYear );
406 pTm->tm_mon = 3;
407 }
408 else if( nDay <= ( 151 + leapYear ) )
409 {
410 pTm->tm_mday = nDay - ( 120 + leapYear );
411 pTm->tm_mon = 4;
412 }
413 else if( nDay <= ( 181 + leapYear ) )
414 {
415 pTm->tm_mday = nDay - ( 151 + leapYear );
416 pTm->tm_mon = 5;
417 }
418 else if( nDay <= ( 212 + leapYear ) )
419 {
420 pTm->tm_mday = nDay - ( 181 + leapYear );
421 pTm->tm_mon = 6;
422 }
423 else if( nDay <= ( 243 + leapYear ) )
424 {
425 pTm->tm_mday = nDay - ( 212 + leapYear );
426 pTm->tm_mon = 7;
427 }
428 else if( nDay <= ( 273 + leapYear ) )
429 {
430 pTm->tm_mday = nDay - ( 243 + leapYear );
431 pTm->tm_mon = 8;
432 }
433 else if( nDay <= ( 304 + leapYear ) )
434 {
435 pTm->tm_mday = nDay - ( 273 + leapYear );
436 pTm->tm_mon = 9;
437 }
438 else if( nDay <= ( 334 + leapYear ) )
439 {
440 pTm->tm_mday = nDay - ( 304 + leapYear );
441 pTm->tm_mon = 10;
442 }
443 else if( nDay <= ( 365 + leapYear ) )
444 {
445 pTm->tm_mday = nDay - ( 334 + leapYear );
446 pTm->tm_mon = 11;
447 }
448 }
449 if( !(lcid & VAR_DATEVALUEONLY) )
450 {
451 /* find the number of seconds in this day.
452 * fractional part times, hours, minutes, seconds.
453 */
454 pTm->tm_hour = (int) ( decimalPart * 24 );
455 pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
456 pTm->tm_sec = (int) ( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 );
457 }
458 return TRUE;
459 }
460 return FALSE;
461 }
462
463
464
465 /******************************************************************************
466 * SizeOfVariantData [INTERNAL]
467 *
468 * This function finds the size of the data referenced by a Variant based
469 * the type "vt" of the Variant.
470 */
471 static int SizeOfVariantData( VARIANT* parg )
472 {
473 int size = 0;
474 switch( parg->vt & VT_TYPEMASK )
475 {
476 case( VT_I2 ):
477 size = sizeof(short);
478 break;
479 case( VT_INT ):
480 size = sizeof(int);
481 break;
482 case( VT_I4 ):
483 size = sizeof(long);
484 break;
485 case( VT_UI1 ):
486 size = sizeof(BYTE);
487 break;
488 case( VT_UI2 ):
489 size = sizeof(unsigned short);
490 break;
491 case( VT_UINT ):
492 size = sizeof(unsigned int);
493 break;
494 case( VT_UI4 ):
495 size = sizeof(unsigned long);
496 break;
497 case( VT_R4 ):
498 size = sizeof(float);
499 break;
500 case( VT_R8 ):
501 size = sizeof(double);
502 break;
503 case( VT_DATE ):
504 size = sizeof(DATE);
505 break;
506 case( VT_BOOL ):
507 size = sizeof(VARIANT_BOOL);
508 break;
509 case( VT_BSTR ):
510 size = sizeof(void*);
511 break;
512 case( VT_CY ):
513 case( VT_DISPATCH ):
514 case( VT_UNKNOWN ):
515 case( VT_DECIMAL ):
516 default:
517 FIXME("Add size information for type vt=%d\n", parg->vt & VT_TYPEMASK );
518 break;
519 }
520
521 return size;
522 }
523 /******************************************************************************
524 * StringDupAtoBstr [INTERNAL]
525 *
526 */
527 static BSTR StringDupAtoBstr( char* strIn )
528 {
529 BSTR bstr = NULL;
530 OLECHAR* pNewString = NULL;
531 pNewString = HEAP_strdupAtoW( GetProcessHeap(), 0, strIn );
532 bstr = SysAllocString( pNewString );
533 HeapFree( GetProcessHeap(), 0, pNewString );
534 return bstr;
535 }
536
537 /******************************************************************************
538 * round [INTERNAL]
539 *
540 * Round the double value to the nearest integer value.
541 */
542 static double round( double d )
543 {
544 double decimals = 0.0, integerValue = 0.0, roundedValue = 0.0;
545 BOOL bEvenNumber = FALSE;
546 int nSign = 0;
547
548 /* Save the sign of the number
549 */
550 nSign = (d >= 0.0) ? 1 : -1;
551 d = fabs( d );
552
553 /* Remove the decimals.
554 */
555 integerValue = floor( d );
556
557 /* Set the Even flag. This is used to round the number when
558 * the decimals are exactly 1/2. If the integer part is
559 * odd the number is rounded up. If the integer part
560 * is even the number is rounded down. Using this method
561 * numbers are rounded up|down half the time.
562 */
563 bEvenNumber = (((short)fmod(integerValue, 2)) == 0) ? TRUE : FALSE;
564
565 /* Remove the integral part of the number.
566 */
567 decimals = d - integerValue;
568
569 /* Note: Ceil returns the smallest integer that is greater that x.
570 * and floor returns the largest integer that is less than or equal to x.
571 */
572 if( decimals > 0.5 )
573 {
574 /* If the decimal part is greater than 1/2
575 */
576 roundedValue = ceil( d );
577 }
578 else if( decimals < 0.5 )
579 {
580 /* If the decimal part is smaller than 1/2
581 */
582 roundedValue = floor( d );
583 }
584 else
585 {
586 /* the decimals are exactly 1/2 so round according to
587 * the bEvenNumber flag.
588 */
589 if( bEvenNumber )
590 {
591 roundedValue = floor( d );
592 }
593 else
594 {
595 roundedValue = ceil( d );
596 }
597 }
598
599 return roundedValue * nSign;
600 }
601
602 /******************************************************************************
603 * RemoveCharacterFromString [INTERNAL]
604 *
605 * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
606 */
607 static void RemoveCharacterFromString( LPSTR str, LPSTR strOfCharToRemove )
608 {
609 LPSTR pNewString = NULL;
610 LPSTR strToken = NULL;
611
612
613 /* Check if we have a valid argument
614 */
615 if( str != NULL )
616 {
617 pNewString = strdup( str );
618 str[0] = '\0';
619 strToken = strtok( pNewString, strOfCharToRemove );
620 while( strToken != NULL ) {
621 strcat( str, strToken );
622 strToken = strtok( NULL, strOfCharToRemove );
623 }
624 free( pNewString );
625 }
626 return;
627 }
628
629 /******************************************************************************
630 * GetValidRealString [INTERNAL]
631 *
632 * Checks if the string is of proper format to be converted to a real value.
633 */
634 static BOOL IsValidRealString( LPSTR strRealString )
635 {
636 /* Real values that have a decimal point are required to either have
637 * digits before or after the decimal point. We will assume that
638 * we do not have any digits at either position. If we do encounter
639 * some we will disable this flag.
640 */
641 BOOL bDigitsRequired = TRUE;
642 /* Processed fields in the string representation of the real number.
643 */
644 BOOL bWhiteSpaceProcessed = FALSE;
645 BOOL bFirstSignProcessed = FALSE;
646 BOOL bFirstDigitsProcessed = FALSE;
647 BOOL bDecimalPointProcessed = FALSE;
648 BOOL bSecondDigitsProcessed = FALSE;
649 BOOL bExponentProcessed = FALSE;
650 BOOL bSecondSignProcessed = FALSE;
651 BOOL bThirdDigitsProcessed = FALSE;
652 /* Assume string parameter "strRealString" is valid and try to disprove it.
653 */
654 BOOL bValidRealString = TRUE;
655
656 /* Used to count the number of tokens in the "strRealString".
657 */
658 LPSTR strToken = NULL;
659 int nTokens = 0;
660 LPSTR pChar = NULL;
661
662 /* Check if we have a valid argument
663 */
664 if( strRealString == NULL )
665 {
666 bValidRealString = FALSE;
667 }
668
669 if( bValidRealString == TRUE )
670 {
671 /* Make sure we only have ONE token in the string.
672 */
673 strToken = strtok( strRealString, " " );
674 while( strToken != NULL ) {
675 nTokens++;
676 strToken = strtok( NULL, " " );
677 }
678
679 if( nTokens != 1 )
680 {
681 bValidRealString = FALSE;
682 }
683 }
684
685
686 /* Make sure this token contains only valid characters.
687 * The string argument to atof has the following form:
688 * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
689 * Whitespace consists of space and|or <TAB> characters, which are ignored.
690 * Sign is either plus '+' or minus '-'.
691 * Digits are one or more decimal digits.
692 * Note: If no digits appear before the decimal point, at least one must
693 * appear after the decimal point.
694 * The decimal digits may be followed by an exponent.
695 * An Exponent consists of an introductory letter ( D, d, E, or e) and
696 * an optionally signed decimal integer.
697 */
698 pChar = strRealString;
699 while( bValidRealString == TRUE && *pChar != '\0' )
700 {
701 switch( *pChar )
702 {
703 /* If whitespace...
704 */
705 case ' ':
706 case '\t':
707 if( bWhiteSpaceProcessed ||
708 bFirstSignProcessed ||
709 bFirstDigitsProcessed ||
710 bDecimalPointProcessed ||
711 bSecondDigitsProcessed ||
712 bExponentProcessed ||
713 bSecondSignProcessed ||
714 bThirdDigitsProcessed )
715 {
716 bValidRealString = FALSE;
717 }
718 break;
719 /* If sign...
720 */
721 case '+':
722 case '-':
723 if( bFirstSignProcessed == FALSE )
724 {
725 if( bFirstDigitsProcessed ||
726 bDecimalPointProcessed ||
727 bSecondDigitsProcessed ||
728 bExponentProcessed ||
729 bSecondSignProcessed ||
730 bThirdDigitsProcessed )
731 {
732 bValidRealString = FALSE;
733 }
734 bWhiteSpaceProcessed = TRUE;
735 bFirstSignProcessed = TRUE;
736 }
737 else if( bSecondSignProcessed == FALSE )
738 {
739 /* Note: The exponent must be present in
740 * order to accept the second sign...
741 */
742 if( bExponentProcessed == FALSE ||
743 bThirdDigitsProcessed ||
744 bDigitsRequired )
745 {
746 bValidRealString = FALSE;
747 }
748 bFirstSignProcessed = TRUE;
749 bWhiteSpaceProcessed = TRUE;
750 bFirstDigitsProcessed = TRUE;
751 bDecimalPointProcessed = TRUE;
752 bSecondDigitsProcessed = TRUE;
753 bSecondSignProcessed = TRUE;
754 }
755 break;
756
757 /* If decimals...
758 */
759 case '0':
760 case '1':
761 case '2':
762 case '3':
763 case '4':
764 case '5':
765 case '6':
766 case '7':
767 case '8':
768 case '9':
769 if( bFirstDigitsProcessed == FALSE )
770 {
771 if( bDecimalPointProcessed ||
772 bSecondDigitsProcessed ||
773 bExponentProcessed ||
774 bSecondSignProcessed ||
775 bThirdDigitsProcessed )
776 {
777 bValidRealString = FALSE;
778 }
779 bFirstSignProcessed = TRUE;
780 bWhiteSpaceProcessed = TRUE;
781 /* We have found some digits before the decimal point
782 * so disable the "Digits required" flag.
783 */
784 bDigitsRequired = FALSE;
785 }
786 else if( bSecondDigitsProcessed == FALSE )
787 {
788 if( bExponentProcessed ||
789 bSecondSignProcessed ||
790 bThirdDigitsProcessed )
791 {
792 bValidRealString = FALSE;
793 }
794 bFirstSignProcessed = TRUE;
795 bWhiteSpaceProcessed = TRUE;
796 bFirstDigitsProcessed = TRUE;
797 bDecimalPointProcessed = TRUE;
798 /* We have found some digits after the decimal point
799 * so disable the "Digits required" flag.
800 */
801 bDigitsRequired = FALSE;
802 }
803 else if( bThirdDigitsProcessed == FALSE )
804 {
805 /* Getting here means everything else should be processed.
806 * If we get anything else than a decimal following this
807 * digit it will be flagged by the other cases, so
808 * we do not really need to do anything in here.
809 */
810 }
811 break;
812 /* If DecimalPoint...
813 */
814 case '.':
815 if( bDecimalPointProcessed ||
816 bSecondDigitsProcessed ||
817 bExponentProcessed ||
818 bSecondSignProcessed ||
819 bThirdDigitsProcessed )
820 {
821 bValidRealString = FALSE;
822 }
823 bFirstSignProcessed = TRUE;
824 bWhiteSpaceProcessed = TRUE;
825 bFirstDigitsProcessed = TRUE;
826 bDecimalPointProcessed = TRUE;
827 break;
828 /* If Exponent...
829 */
830 case 'e':
831 case 'E':
832 case 'd':
833 case 'D':
834 if( bExponentProcessed ||
835 bSecondSignProcessed ||
836 bThirdDigitsProcessed ||
837 bDigitsRequired )
838 {
839 bValidRealString = FALSE;
840 }
841 bFirstSignProcessed = TRUE;
842 bWhiteSpaceProcessed = TRUE;
843 bFirstDigitsProcessed = TRUE;
844 bDecimalPointProcessed = TRUE;
845 bSecondDigitsProcessed = TRUE;
846 bExponentProcessed = TRUE;
847 break;
848 default:
849 bValidRealString = FALSE;
850 break;
851 }
852 /* Process next character.
853 */
854 pChar++;
855 }
856
857 /* If the required digits were not present we have an invalid
858 * string representation of a real number.
859 */
860 if( bDigitsRequired == TRUE )
861 {
862 bValidRealString = FALSE;
863 }
864
865 return bValidRealString;
866 }
867
868
869 /******************************************************************************
870 * Coerce [INTERNAL]
871 *
872 * This function dispatches execution to the proper conversion API
873 * to do the necessary coercion.
874 */
875 static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt )
876 {
877 HRESULT res = S_OK;
878 unsigned short vtFrom = 0;
879 vtFrom = ps->vt & VT_TYPEMASK;
880
881 /* Note: Since "long" and "int" values both have 4 bytes and are
882 * both signed integers "int" will be treated as "long" in the
883 * following code.
884 * The same goes for their unsigned versions.
885 */
886
887 /* Trivial Case: If the coercion is from two types that are
888 * identical then we can blindly copy from one argument to another.*/
889 if ((vt==vtFrom))
890 {
891 return VariantCopy(pd,ps);
892 }
893
894 /* Cases requiring thought*/
895 switch( vt )
896 {
897
898 case( VT_EMPTY ):
899 res = VariantClear( pd );
900 break;
901 case( VT_NULL ):
902 res = VariantClear( pd );
903 if( res == S_OK )
904 {
905 pd->vt = VT_NULL;
906 }
907 break;
908 case( VT_I1 ):
909 switch( vtFrom )
910 {
911 case( VT_I1 ):
912 res = VariantCopy( pd, ps );
913 break;
914 case( VT_I2 ):
915 res = VarI1FromI2( ps->u.iVal, &(pd->u.cVal) );
916 break;
917 case( VT_INT ):
918 case( VT_I4 ):
919 res = VarI1FromI4( ps->u.lVal, &(pd->u.cVal) );
920 break;
921 case( VT_UI1 ):
922 res = VarI1FromUI1( ps->u.bVal, &(pd->u.cVal) );
923 break;
924 case( VT_UI2 ):
925 res = VarI1FromUI2( ps->u.uiVal, &(pd->u.cVal) );
926 break;
927 case( VT_UINT ):
928 case( VT_UI4 ):
929 res = VarI1FromUI4( ps->u.ulVal, &(pd->u.cVal) );
930 break;
931 case( VT_R4 ):
932 res = VarI1FromR4( ps->u.fltVal, &(pd->u.cVal) );
933 break;
934 case( VT_R8 ):
935 res = VarI1FromR8( ps->u.dblVal, &(pd->u.cVal) );
936 break;
937 case( VT_DATE ):
938 res = VarI1FromDate( ps->u.date, &(pd->u.cVal) );
939 break;
940 case( VT_BOOL ):
941 res = VarI1FromBool( ps->u.boolVal, &(pd->u.cVal) );
942 break;
943 case( VT_BSTR ):
944 res = VarI1FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cVal) );
945 break;
946 case( VT_CY ):
947 res = VarI1FromCy( ps->u.cyVal, &(pd->u.cVal) );
948 case( VT_DISPATCH ):
949 /*res = VarI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.cVal) );*/
950 case( VT_UNKNOWN ):
951 /*res = VarI1From32( ps->u.lVal, &(pd->u.cVal) );*/
952 case( VT_DECIMAL ):
953 /*res = VarI1FromDec32( ps->u.decVal, &(pd->u.cVal) );*/
954 default:
955 res = DISP_E_TYPEMISMATCH;
956 FIXME("Coercion from %d to %d\n", vtFrom, vt );
957 break;
958 }
959 break;
960
961 case( VT_I2 ):
962 switch( vtFrom )
963 {
964 case( VT_I1 ):
965 res = VarI2FromI1( ps->u.cVal, &(pd->u.iVal) );
966 break;
967 case( VT_I2 ):
968 res = VariantCopy( pd, ps );
969 break;
970 case( VT_INT ):
971 case( VT_I4 ):
972 res = VarI2FromI4( ps->u.lVal, &(pd->u.iVal) );
973 break;
974 case( VT_UI1 ):
975 res = VarI2FromUI1( ps->u.bVal, &(pd->u.iVal) );
976 break;
977 case( VT_UI2 ):
978 res = VarI2FromUI2( ps->u.uiVal, &(pd->u.iVal) );
979 break;
980 case( VT_UINT ):
981 case( VT_UI4 ):
982 res = VarI2FromUI4( ps->u.ulVal, &(pd->u.iVal) );
983 break;
984 case( VT_R4 ):
985 res = VarI2FromR4( ps->u.fltVal, &(pd->u.iVal) );
986 break;
987 case( VT_R8 ):
988 res = VarI2FromR8( ps->u.dblVal, &(pd->u.iVal) );
989 break;
990 case( VT_DATE ):
991 res = VarI2FromDate( ps->u.date, &(pd->u.iVal) );
992 break;
993 case( VT_BOOL ):
994 res = VarI2FromBool( ps->u.boolVal, &(pd->u.iVal) );
995 break;
996 case( VT_BSTR ):
997 res = VarI2FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.iVal) );
998 break;
999 case( VT_CY ):
1000 res = VarI2FromCy( ps->u.cyVal, &(pd->u.iVal) );
1001 case( VT_DISPATCH ):
1002 /*res = VarI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.iVal) );*/
1003 case( VT_UNKNOWN ):
1004 /*res = VarI2From32( ps->u.lVal, &(pd->u.iVal) );*/
1005 case( VT_DECIMAL ):
1006 /*res = VarI2FromDec32( ps->u.deiVal, &(pd->u.iVal) );*/
1007 default:
1008 res = DISP_E_TYPEMISMATCH;
1009 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1010 break;
1011 }
1012 break;
1013
1014 case( VT_INT ):
1015 case( VT_I4 ):
1016 switch( vtFrom )
1017 {
1018 case( VT_I1 ):
1019 res = VarI4FromI1( ps->u.cVal, &(pd->u.lVal) );
1020 break;
1021 case( VT_I2 ):
1022 res = VarI4FromI2( ps->u.iVal, &(pd->u.lVal) );
1023 break;
1024 case( VT_INT ):
1025 case( VT_I4 ):
1026 res = VariantCopy( pd, ps );
1027 break;
1028 case( VT_UI1 ):
1029 res = VarI4FromUI1( ps->u.bVal, &(pd->u.lVal) );
1030 break;
1031 case( VT_UI2 ):
1032 res = VarI4FromUI2( ps->u.uiVal, &(pd->u.lVal) );
1033 break;
1034 case( VT_UINT ):
1035 case( VT_UI4 ):
1036 res = VarI4FromUI4( ps->u.ulVal, &(pd->u.lVal) );
1037 break;
1038 case( VT_R4 ):
1039 res = VarI4FromR4( ps->u.fltVal, &(pd->u.lVal) );
1040 break;
1041 case( VT_R8 ):
1042 res = VarI4FromR8( ps->u.dblVal, &(pd->u.lVal) );
1043 break;
1044 case( VT_DATE ):
1045 res = VarI4FromDate( ps->u.date, &(pd->u.lVal) );
1046 break;
1047 case( VT_BOOL ):
1048 res = VarI4FromBool( ps->u.boolVal, &(pd->u.lVal) );
1049 break;
1050 case( VT_BSTR ):
1051 res = VarI4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.lVal) );
1052 break;
1053 case( VT_CY ):
1054 res = VarI4FromCy( ps->u.cyVal, &(pd->u.lVal) );
1055 case( VT_DISPATCH ):
1056 /*res = VarI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.lVal) );*/
1057 case( VT_UNKNOWN ):
1058 /*res = VarI4From32( ps->u.lVal, &(pd->u.lVal) );*/
1059 case( VT_DECIMAL ):
1060 /*res = VarI4FromDec32( ps->u.deiVal, &(pd->u.lVal) );*/
1061 default:
1062 res = DISP_E_TYPEMISMATCH;
1063 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1064 break;
1065 }
1066 break;
1067
1068 case( VT_UI1 ):
1069 switch( vtFrom )
1070 {
1071 case( VT_I1 ):
1072 res = VarUI1FromI1( ps->u.cVal, &(pd->u.bVal) );
1073 break;
1074 case( VT_I2 ):
1075 res = VarUI1FromI2( ps->u.iVal, &(pd->u.bVal) );
1076 break;
1077 case( VT_INT ):
1078 case( VT_I4 ):
1079 res = VarUI1FromI4( ps->u.lVal, &(pd->u.bVal) );
1080 break;
1081 case( VT_UI1 ):
1082 res = VariantCopy( pd, ps );
1083 break;
1084 case( VT_UI2 ):
1085 res = VarUI1FromUI2( ps->u.uiVal, &(pd->u.bVal) );
1086 break;
1087 case( VT_UINT ):
1088 case( VT_UI4 ):
1089 res = VarUI1FromUI4( ps->u.ulVal, &(pd->u.bVal) );
1090 break;
1091 case( VT_R4 ):
1092 res = VarUI1FromR4( ps->u.fltVal, &(pd->u.bVal) );
1093 break;
1094 case( VT_R8 ):
1095 res = VarUI1FromR8( ps->u.dblVal, &(pd->u.bVal) );
1096 break;
1097 case( VT_DATE ):
1098 res = VarUI1FromDate( ps->u.date, &(pd->u.bVal) );
1099 break;
1100 case( VT_BOOL ):
1101 res = VarUI1FromBool( ps->u.boolVal, &(pd->u.bVal) );
1102 break;
1103 case( VT_BSTR ):
1104 res = VarUI1FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.bVal) );
1105 break;
1106 case( VT_CY ):
1107 res = VarUI1FromCy( ps->u.cyVal, &(pd->u.bVal) );
1108 case( VT_DISPATCH ):
1109 /*res = VarUI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.bVal) );*/
1110 case( VT_UNKNOWN ):
1111 /*res = VarUI1From32( ps->u.lVal, &(pd->u.bVal) );*/
1112 case( VT_DECIMAL ):
1113 /*res = VarUI1FromDec32( ps->u.deiVal, &(pd->u.bVal) );*/
1114 default:
1115 res = DISP_E_TYPEMISMATCH;
1116 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1117 break;
1118 }
1119 break;
1120
1121 case( VT_UI2 ):
1122 switch( vtFrom )
1123 {
1124 case( VT_I1 ):
1125 res = VarUI2FromI1( ps->u.cVal, &(pd->u.uiVal) );
1126 break;
1127 case( VT_I2 ):
1128 res = VarUI2FromI2( ps->u.iVal, &(pd->u.uiVal) );
1129 break;
1130 case( VT_INT ):
1131 case( VT_I4 ):
1132 res = VarUI2FromI4( ps->u.lVal, &(pd->u.uiVal) );
1133 break;
1134 case( VT_UI1 ):
1135 res = VarUI2FromUI1( ps->u.bVal, &(pd->u.uiVal) );
1136 break;
1137 case( VT_UI2 ):
1138 res = VariantCopy( pd, ps );
1139 break;
1140 case( VT_UINT ):
1141 case( VT_UI4 ):
1142 res = VarUI2FromUI4( ps->u.ulVal, &(pd->u.uiVal) );
1143 break;
1144 case( VT_R4 ):
1145 res = VarUI2FromR4( ps->u.fltVal, &(pd->u.uiVal) );
1146 break;
1147 case( VT_R8 ):
1148 res = VarUI2FromR8( ps->u.dblVal, &(pd->u.uiVal) );
1149 break;
1150 case( VT_DATE ):
1151 res = VarUI2FromDate( ps->u.date, &(pd->u.uiVal) );
1152 break;
1153 case( VT_BOOL ):
1154 res = VarUI2FromBool( ps->u.boolVal, &(pd->u.uiVal) );
1155 break;
1156 case( VT_BSTR ):
1157 res = VarUI2FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.uiVal) );
1158 break;
1159 case( VT_CY ):
1160 res = VarUI2FromCy( ps->u.cyVal, &(pd->u.uiVal) );
1161 case( VT_DISPATCH ):
1162 /*res = VarUI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.uiVal) );*/
1163 case( VT_UNKNOWN ):
1164 /*res = VarUI2From32( ps->u.lVal, &(pd->u.uiVal) );*/
1165 case( VT_DECIMAL ):
1166 /*res = VarUI2FromDec32( ps->u.deiVal, &(pd->u.uiVal) );*/
1167 default:
1168 res = DISP_E_TYPEMISMATCH;
1169 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1170 break;
1171 }
1172 break;
1173
1174 case( VT_UINT ):
1175 case( VT_UI4 ):
1176 switch( vtFrom )
1177 {
1178 case( VT_I1 ):
1179 res = VarUI4FromI1( ps->u.cVal, &(pd->u.ulVal) );
1180 break;
1181 case( VT_I2 ):
1182 res = VarUI4FromI2( ps->u.iVal, &(pd->u.ulVal) );
1183 break;
1184 case( VT_INT ):
1185 case( VT_I4 ):
1186 res = VarUI4FromI4( ps->u.lVal, &(pd->u.ulVal) );
1187 break;
1188 case( VT_UI1 ):
1189 res = VarUI4FromUI1( ps->u.bVal, &(pd->u.ulVal) );
1190 break;
1191 case( VT_UI2 ):
1192 res = VarUI4FromUI2( ps->u.uiVal, &(pd->u.ulVal) );
1193 break;
1194 case( VT_UI4 ):
1195 res = VariantCopy( pd, ps );
1196 break;
1197 case( VT_R4 ):
1198 res = VarUI4FromR4( ps->u.fltVal, &(pd->u.ulVal) );
1199 break;
1200 case( VT_R8 ):
1201 res = VarUI4FromR8( ps->u.dblVal, &(pd->u.ulVal) );
1202 break;
1203 case( VT_DATE ):
1204 res = VarUI4FromDate( ps->u.date, &(pd->u.ulVal) );
1205 break;
1206 case( VT_BOOL ):
1207 res = VarUI4FromBool( ps->u.boolVal, &(pd->u.ulVal) );
1208 break;
1209 case( VT_BSTR ):
1210 res = VarUI4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.ulVal) );
1211 break;
1212 case( VT_CY ):
1213 res = VarUI4FromCy( ps->u.cyVal, &(pd->u.ulVal) );
1214 case( VT_DISPATCH ):
1215 /*res = VarUI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.ulVal) );*/
1216 case( VT_UNKNOWN ):
1217 /*res = VarUI4From32( ps->u.lVal, &(pd->u.ulVal) );*/
1218 case( VT_DECIMAL ):
1219 /*res = VarUI4FromDec32( ps->u.deiVal, &(pd->u.ulVal) );*/
1220 default:
1221 res = DISP_E_TYPEMISMATCH;
1222 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1223 break;
1224 }
1225 break;
1226
1227 case( VT_R4 ):
1228 switch( vtFrom )
1229 {
1230 case( VT_I1 ):
1231 res = VarR4FromI1( ps->u.cVal, &(pd->u.fltVal) );
1232 break;
1233 case( VT_I2 ):
1234 res = VarR4FromI2( ps->u.iVal, &(pd->u.fltVal) );
1235 break;
1236 case( VT_INT ):
1237 case( VT_I4 ):
1238 res = VarR4FromI4( ps->u.lVal, &(pd->u.fltVal) );
1239 break;
1240 case( VT_UI1 ):
1241 res = VarR4FromUI1( ps->u.bVal, &(pd->u.fltVal) );
1242 break;
1243 case( VT_UI2 ):
1244 res = VarR4FromUI2( ps->u.uiVal, &(pd->u.fltVal) );
1245 break;
1246 case( VT_UINT ):
1247 case( VT_UI4 ):
1248 res = VarR4FromUI4( ps->u.ulVal, &(pd->u.fltVal) );
1249 break;
1250 case( VT_R4 ):
1251 res = VariantCopy( pd, ps );
1252 break;
1253 case( VT_R8 ):
1254 res = VarR4FromR8( ps->u.dblVal, &(pd->u.fltVal) );
1255 break;
1256 case( VT_DATE ):
1257 res = VarR4FromDate( ps->u.date, &(pd->u.fltVal) );
1258 break;
1259 case( VT_BOOL ):
1260 res = VarR4FromBool( ps->u.boolVal, &(pd->u.fltVal) );
1261 break;
1262 case( VT_BSTR ):
1263 res = VarR4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.fltVal) );
1264 break;
1265 case( VT_CY ):
1266 res = VarR4FromCy( ps->u.cyVal, &(pd->u.fltVal) );
1267 case( VT_DISPATCH ):
1268 /*res = VarR4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.fltVal) );*/
1269 case( VT_UNKNOWN ):
1270 /*res = VarR4From32( ps->u.lVal, &(pd->u.fltVal) );*/
1271 case( VT_DECIMAL ):
1272 /*res = VarR4FromDec32( ps->u.deiVal, &(pd->u.fltVal) );*/
1273 default:
1274 res = DISP_E_TYPEMISMATCH;
1275 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1276 break;
1277 }
1278 break;
1279
1280 case( VT_R8 ):
1281 switch( vtFrom )
1282 {
1283 case( VT_I1 ):
1284 res = VarR8FromI1( ps->u.cVal, &(pd->u.dblVal) );
1285 break;
1286 case( VT_I2 ):
1287 res = VarR8FromI2( ps->u.iVal, &(pd->u.dblVal) );
1288 break;
1289 case( VT_INT ):
1290 case( VT_I4 ):
1291 res = VarR8FromI4( ps->u.lVal, &(pd->u.dblVal) );
1292 break;
1293 case( VT_UI1 ):
1294 res = VarR8FromUI1( ps->u.bVal, &(pd->u.dblVal) );
1295 break;
1296 case( VT_UI2 ):
1297 res = VarR8FromUI2( ps->u.uiVal, &(pd->u.dblVal) );
1298 break;
1299 case( VT_UINT ):
1300 case( VT_UI4 ):
1301 res = VarR8FromUI4( ps->u.ulVal, &(pd->u.dblVal) );
1302 break;
1303 case( VT_R4 ):
1304 res = VarR8FromR4( ps->u.fltVal, &(pd->u.dblVal) );
1305 break;
1306 case( VT_R8 ):
1307 res = VariantCopy( pd, ps );
1308 break;
1309 case( VT_DATE ):
1310 res = VarR8FromDate( ps->u.date, &(pd->u.dblVal) );
1311 break;
1312 case( VT_BOOL ):
1313 res = VarR8FromBool( ps->u.boolVal, &(pd->u.dblVal) );
1314 break;
1315 case( VT_BSTR ):
1316 res = VarR8FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.dblVal) );
1317 break;
1318 case( VT_CY ):
1319 res = VarR8FromCy( ps->u.cyVal, &(pd->u.dblVal) );
1320 case( VT_DISPATCH ):
1321 /*res = VarR8FromDisp32( ps->u.pdispVal, lcid, &(pd->u.dblVal) );*/
1322 case( VT_UNKNOWN ):
1323 /*res = VarR8From32( ps->u.lVal, &(pd->u.dblVal) );*/
1324 case( VT_DECIMAL ):
1325 /*res = VarR8FromDec32( ps->u.deiVal, &(pd->u.dblVal) );*/
1326 default:
1327 res = DISP_E_TYPEMISMATCH;
1328 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1329 break;
1330 }
1331 break;
1332
1333 case( VT_DATE ):
1334 switch( vtFrom )
1335 {
1336 case( VT_I1 ):
1337 res = VarDateFromI1( ps->u.cVal, &(pd->u.date) );
1338 break;
1339 case( VT_I2 ):
1340 res = VarDateFromI2( ps->u.iVal, &(pd->u.date) );
1341 break;
1342 case( VT_INT ):
1343 res = VarDateFromInt( ps->u.intVal, &(pd->u.date) );
1344 break;
1345 case( VT_I4 ):
1346 res = VarDateFromI4( ps->u.lVal, &(pd->u.date) );
1347 break;
1348 case( VT_UI1 ):
1349 res = VarDateFromUI1( ps->u.bVal, &(pd->u.date) );
1350 break;
1351 case( VT_UI2 ):
1352 res = VarDateFromUI2( ps->u.uiVal, &(pd->u.date) );
1353 break;
1354 case( VT_UINT ):
1355 res = VarDateFromUint( ps->u.uintVal, &(pd->u.date) );
1356 break;
1357 case( VT_UI4 ):
1358 res = VarDateFromUI4( ps->u.ulVal, &(pd->u.date) );
1359 break;
1360 case( VT_R4 ):
1361 res = VarDateFromR4( ps->u.fltVal, &(pd->u.date) );
1362 break;
1363 case( VT_R8 ):
1364 res = VarDateFromR8( ps->u.dblVal, &(pd->u.date) );
1365 break;
1366 case( VT_DATE ):
1367 res = VariantCopy( pd, ps );
1368 break;
1369 case( VT_BOOL ):
1370 res = VarDateFromBool( ps->u.boolVal, &(pd->u.date) );
1371 break;
1372 case( VT_BSTR ):
1373 res = VarDateFromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.date) );
1374 break;
1375 case( VT_CY ):
1376 res = VarDateFromCy( ps->u.cyVal, &(pd->u.date) );
1377 case( VT_DISPATCH ):
1378 /*res = VarDateFromDisp32( ps->u.pdispVal, lcid, &(pd->u.date) );*/
1379 case( VT_UNKNOWN ):
1380 /*res = VarDateFrom32( ps->u.lVal, &(pd->u.date) );*/
1381 case( VT_DECIMAL ):
1382 /*res = VarDateFromDec32( ps->u.deiVal, &(pd->u.date) );*/
1383 default:
1384 res = DISP_E_TYPEMISMATCH;
1385 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1386 break;
1387 }
1388 break;
1389
1390 case( VT_BOOL ):
1391 switch( vtFrom )
1392 {
1393 case( VT_I1 ):
1394 res = VarBoolFromI1( ps->u.cVal, &(pd->u.boolVal) );
1395 break;
1396 case( VT_I2 ):
1397 res = VarBoolFromI2( ps->u.iVal, &(pd->u.boolVal) );
1398 break;
1399 case( VT_INT ):
1400 res = VarBoolFromInt( ps->u.intVal, &(pd->u.boolVal) );
1401 break;
1402 case( VT_I4 ):
1403 res = VarBoolFromI4( ps->u.lVal, &(pd->u.boolVal) );
1404 break;
1405 case( VT_UI1 ):
1406 res = VarBoolFromUI1( ps->u.bVal, &(pd->u.boolVal) );
1407 break;
1408 case( VT_UI2 ):
1409 res = VarBoolFromUI2( ps->u.uiVal, &(pd->u.boolVal) );
1410 break;
1411 case( VT_UINT ):
1412 res = VarBoolFromUint( ps->u.uintVal, &(pd->u.boolVal) );
1413 break;
1414 case( VT_UI4 ):
1415 res = VarBoolFromUI4( ps->u.ulVal, &(pd->u.boolVal) );
1416 break;
1417 case( VT_R4 ):
1418 res = VarBoolFromR4( ps->u.fltVal, &(pd->u.boolVal) );
1419 break;
1420 case( VT_R8 ):
1421 res = VarBoolFromR8( ps->u.dblVal, &(pd->u.boolVal) );
1422 break;
1423 case( VT_DATE ):
1424 res = VarBoolFromDate( ps->u.date, &(pd->u.boolVal) );
1425 break;
1426 case( VT_BOOL ):
1427 res = VariantCopy( pd, ps );
1428 break;
1429 case( VT_BSTR ):
1430 res = VarBoolFromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.boolVal) );
1431 break;
1432 case( VT_CY ):
1433 res = VarBoolFromCy( ps->u.cyVal, &(pd->u.boolVal) );
1434 case( VT_DISPATCH ):
1435 /*res = VarBoolFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
1436 case( VT_UNKNOWN ):
1437 /*res = VarBoolFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
1438 case( VT_DECIMAL ):
1439 /*res = VarBoolFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
1440 default:
1441 res = DISP_E_TYPEMISMATCH;
1442 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1443 break;
1444 }
1445 break;
1446
1447 case( VT_BSTR ):
1448 switch( vtFrom )
1449 {
1450 case( VT_I1 ):
1451 res = VarBstrFromI1( ps->u.cVal, lcid, dwFlags, &(pd->u.bstrVal) );
1452 break;
1453 case( VT_I2 ):
1454 res = VarBstrFromI2( ps->u.iVal, lcid, dwFlags, &(pd->u.bstrVal) );
1455 break;
1456 case( VT_INT ):
1457 res = VarBstrFromInt( ps->u.intVal, lcid, dwFlags, &(pd->u.bstrVal) );
1458 break;
1459 case( VT_I4 ):
1460 res = VarBstrFromI4( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );
1461 break;
1462 case( VT_UI1 ):
1463 res = VarBstrFromUI1( ps->u.bVal, lcid, dwFlags, &(pd->u.bstrVal) );
1464 break;
1465 case( VT_UI2 ):
1466 res = VarBstrFromUI2( ps->u.uiVal, lcid, dwFlags, &(pd->u.bstrVal) );
1467 break;
1468 case( VT_UINT ):
1469 res = VarBstrFromUint( ps->u.uintVal, lcid, dwFlags, &(pd->u.bstrVal) );
1470 break;
1471 case( VT_UI4 ):
1472 res = VarBstrFromUI4( ps->u.ulVal, lcid, dwFlags, &(pd->u.bstrVal) );
1473 break;
1474 case( VT_R4 ):
1475 res = VarBstrFromR4( ps->u.fltVal, lcid, dwFlags, &(pd->u.bstrVal) );
1476 break;
1477 case( VT_R8 ):
1478 res = VarBstrFromR8( ps->u.dblVal, lcid, dwFlags, &(pd->u.bstrVal) );
1479 break;
1480 case( VT_DATE ):
1481 res = VarBstrFromDate( ps->u.date, lcid, dwFlags, &(pd->u.bstrVal) );
1482 break;
1483 case( VT_BOOL ):
1484 res = VarBstrFromBool( ps->u.boolVal, lcid, dwFlags, &(pd->u.bstrVal) );
1485 break;
1486 case( VT_BSTR ):
1487 res = VariantCopy( pd, ps );
1488 break;
1489 case( VT_CY ):
1490 /*res = VarBstrFromCy32( ps->u.cyVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1491 case( VT_DISPATCH ):
1492 /*res = VarBstrFromDisp32( ps->u.pdispVal, lcid, lcid, dwFlags, &(pd->u.bstrVal) );*/
1493 case( VT_UNKNOWN ):
1494 /*res = VarBstrFrom32( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1495 case( VT_DECIMAL ):
1496 /*res = VarBstrFromDec32( ps->u.deiVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
1497 default:
1498 res = DISP_E_TYPEMISMATCH;
1499 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1500 break;
1501 }
1502 break;
1503
1504 case( VT_CY ):
1505 switch( vtFrom )
1506 {
1507 case( VT_I1 ):
1508 res = VarCyFromI1( ps->u.cVal, &(pd->u.cyVal) );
1509 break;
1510 case( VT_I2 ):
1511 res = VarCyFromI2( ps->u.iVal, &(pd->u.cyVal) );
1512 break;
1513 case( VT_INT ):
1514 res = VarCyFromInt( ps->u.intVal, &(pd->u.cyVal) );
1515 break;
1516 case( VT_I4 ):
1517 res = VarCyFromI4( ps->u.lVal, &(pd->u.cyVal) );
1518 break;
1519 case( VT_UI1 ):
1520 res = VarCyFromUI1( ps->u.bVal, &(pd->u.cyVal) );
1521 break;
1522 case( VT_UI2 ):
1523 res = VarCyFromUI2( ps->u.uiVal, &(pd->u.cyVal) );
1524 break;
1525 case( VT_UINT ):
1526 res = VarCyFromUint( ps->u.uintVal, &(pd->u.cyVal) );
1527 break;
1528 case( VT_UI4 ):
1529 res = VarCyFromUI4( ps->u.ulVal, &(pd->u.cyVal) );
1530 break;
1531 case( VT_R4 ):
1532 res = VarCyFromR4( ps->u.fltVal, &(pd->u.cyVal) );
1533 break;
1534 case( VT_R8 ):
1535 res = VarCyFromR8( ps->u.dblVal, &(pd->u.cyVal) );
1536 break;
1537 case( VT_DATE ):
1538 res = VarCyFromDate( ps->u.date, &(pd->u.cyVal) );
1539 break;
1540 case( VT_BOOL ):
1541 res = VarCyFromBool( ps->u.date, &(pd->u.cyVal) );
1542 break;
1543 case( VT_CY ):
1544 res = VariantCopy( pd, ps );
1545 break;
1546 case( VT_BSTR ):
1547 /*res = VarCyFromStr32( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cyVal) );*/
1548 case( VT_DISPATCH ):
1549 /*res = VarCyFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
1550 case( VT_UNKNOWN ):
1551 /*res = VarCyFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
1552 case( VT_DECIMAL ):
1553 /*res = VarCyFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
1554 default:
1555 res = DISP_E_TYPEMISMATCH;
1556 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1557 break;
1558 }
1559 break;
1560
1561 default:
1562 res = DISP_E_TYPEMISMATCH;
1563 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1564 break;
1565 }
1566
1567 return res;
1568 }
1569
1570 /******************************************************************************
1571 * ValidateVtRange [INTERNAL]
1572 *
1573 * Used internally by the hi-level Variant API to determine
1574 * if the vartypes are valid.
1575 */
1576 static HRESULT WINAPI ValidateVtRange( VARTYPE vt )
1577 {
1578 /* if by value we must make sure it is in the
1579 * range of the valid types.
1580 */
1581 if( ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1582 {
1583 return DISP_E_BADVARTYPE;
1584 }
1585 return S_OK;
1586 }
1587
1588
1589 /******************************************************************************
1590 * ValidateVartype [INTERNAL]
1591 *
1592 * Used internally by the hi-level Variant API to determine
1593 * if the vartypes are valid.
1594 */
1595 static HRESULT WINAPI ValidateVariantType( VARTYPE vt )
1596 {
1597 HRESULT res = S_OK;
1598
1599 /* check if we have a valid argument.
1600 */
1601 if( vt & VT_BYREF )
1602 {
1603 /* if by reference check that the type is in
1604 * the valid range and that it is not of empty or null type
1605 */
1606 if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1607 ( vt & VT_TYPEMASK ) == VT_NULL ||
1608 ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1609 {
1610 res = E_INVALIDARG;
1611 }
1612
1613 }
1614 else
1615 {
1616 res = ValidateVtRange( vt );
1617 }
1618
1619 return res;
1620 }
1621
1622 /******************************************************************************
1623 * ValidateVt [INTERNAL]
1624 *
1625 * Used internally by the hi-level Variant API to determine
1626 * if the vartypes are valid.
1627 */
1628 static HRESULT WINAPI ValidateVt( VARTYPE vt )
1629 {
1630 HRESULT res = S_OK;
1631
1632 /* check if we have a valid argument.
1633 */
1634 if( vt & VT_BYREF )
1635 {
1636 /* if by reference check that the type is in
1637 * the valid range and that it is not of empty or null type
1638 */
1639 if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1640 ( vt & VT_TYPEMASK ) == VT_NULL ||
1641 ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1642 {
1643 res = DISP_E_BADVARTYPE;
1644 }
1645
1646 }
1647 else
1648 {
1649 res = ValidateVtRange( vt );
1650 }
1651
1652 return res;
1653 }
1654
1655
1656
1657
1658
1659 /******************************************************************************
1660 * VariantInit [OLEAUT32.8]
1661 *
1662 * Initializes the Variant. Unlike VariantClear it does not interpret the current
1663 * contents of the Variant.
1664 */
1665 void WINAPI VariantInit(VARIANTARG* pvarg)
1666 {
1667 TRACE("(%p),stub\n",pvarg);
1668
1669 memset(pvarg, 0, sizeof (VARIANTARG));
1670 pvarg->vt = VT_EMPTY;
1671
1672 return;
1673 }
1674
1675 /******************************************************************************
1676 * VariantClear [OLEAUT32.9]
1677 *
1678 * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
1679 * sets the wReservedX field to 0. The current contents of the VARIANT are
1680 * freed. If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
1681 * released. If VT_ARRAY the array is freed.
1682 */
1683 HRESULT WINAPI VariantClear(VARIANTARG* pvarg)
1684 {
1685 HRESULT res = S_OK;
1686 TRACE("(%p)\n",pvarg);
1687
1688 res = ValidateVariantType( pvarg->vt );
1689 if( res == S_OK )
1690 {
1691 if( !( pvarg->vt & VT_BYREF ) )
1692 {
1693 /*
1694 * The VT_ARRAY flag is a special case of a safe array.
1695 */
1696 if ( (pvarg->vt & VT_ARRAY) != 0)
1697 {
1698 SafeArrayDestroy(pvarg->u.parray);
1699 }
1700 else
1701 {
1702 switch( pvarg->vt & VT_TYPEMASK )
1703 {
1704 case( VT_BSTR ):
1705 SysFreeString( pvarg->u.bstrVal );
1706 break;
1707 case( VT_DISPATCH ):
1708 if(pvarg->u.pdispVal!=NULL)
1709 ICOM_CALL(Release,pvarg->u.pdispVal);
1710 break;
1711 case( VT_VARIANT ):
1712 VariantClear(pvarg->u.pvarVal);
1713 break;
1714 case( VT_UNKNOWN ):
1715 if(pvarg->u.punkVal!=NULL)
1716 ICOM_CALL(Release,pvarg->u.punkVal);
1717 break;
1718 case( VT_SAFEARRAY ):
1719 SafeArrayDestroy(pvarg->u.parray);
1720 break;
1721 default:
1722 break;
1723 }
1724 }
1725 }
1726
1727 /*
1728 * Empty all the fields and mark the type as empty.
1729 */
1730 memset(pvarg, 0, sizeof (VARIANTARG));
1731 pvarg->vt = VT_EMPTY;
1732 }
1733
1734 return res;
1735 }
1736
1737 /******************************************************************************
1738 * VariantCopy [OLEAUT32.10]
1739 *
1740 * Frees up the designation variant and makes a copy of the source.
1741 */
1742 HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
1743 {
1744 HRESULT res = S_OK;
1745
1746 TRACE("(%p, %p)\n", pvargDest, pvargSrc);
1747
1748 res = ValidateVariantType( pvargSrc->vt );
1749
1750 /* If the pointer are to the same variant we don't need
1751 * to do anything.
1752 */
1753 if( pvargDest != pvargSrc && res == S_OK )
1754 {
1755 res = VariantClear( pvargDest );
1756
1757 if( res == S_OK )
1758 {
1759 if( pvargSrc->vt & VT_BYREF )
1760 {
1761 /* In the case of byreference we only need
1762 * to copy the pointer.
1763 */
1764 pvargDest->u = pvargSrc->u;
1765 pvargDest->vt = pvargSrc->vt;
1766 }
1767 else
1768 {
1769 /*
1770 * The VT_ARRAY flag is another way to designate a safe array.
1771 */
1772 if (pvargSrc->vt & VT_ARRAY)
1773 {
1774 SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray);
1775 }
1776 else
1777 {
1778 /* In the case of by value we need to
1779 * copy the actuall value. In the case of
1780 * VT_BSTR a copy of the string is made,
1781 * if VT_DISPATCH or VT_IUNKNOWN AddReff is
1782 * called to increment the object's reference count.
1783 */
1784 switch( pvargSrc->vt & VT_TYPEMASK )
1785 {
1786 case( VT_BSTR ):
1787 pvargDest->u.bstrVal = SysAllocString( pvargSrc->u.bstrVal );
1788 break;
1789 case( VT_DISPATCH ):
1790 pvargDest->u.pdispVal = pvargSrc->u.pdispVal;
1791 if (pvargDest->u.pdispVal!=NULL)
1792 ICOM_CALL(AddRef,pvargDest->u.pdispVal);
1793 break;
1794 case( VT_VARIANT ):
1795 VariantCopy(pvargDest->u.pvarVal,pvargSrc->u.pvarVal);
1796 break;
1797 case( VT_UNKNOWN ):
1798 pvargDest->u.punkVal = pvargSrc->u.punkVal;
1799 if (pvargDest->u.pdispVal!=NULL)
1800 ICOM_CALL(AddRef,pvargDest->u.punkVal);
1801 break;
1802 case( VT_SAFEARRAY ):
1803 SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray);
1804 break;
1805 default:
1806 pvargDest->u = pvargSrc->u;
1807 break;
1808 }
1809 }
1810
1811 pvargDest->vt = pvargSrc->vt;
1812 }
1813 }
1814 }
1815
1816 return res;
1817 }
1818
1819
1820 /******************************************************************************
1821 * VariantCopyInd [OLEAUT32.11]
1822 *
1823 * Frees up the destination variant and makes a copy of the source. If
1824 * the source is of type VT_BYREF it performs the necessary indirections.
1825 */
1826 HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
1827 {
1828 HRESULT res = S_OK;
1829
1830 TRACE("(%p, %p)\n", pvargDest, pvargSrc);
1831
1832 res = ValidateVariantType( pvargSrc->vt );
1833
1834 if( res != S_OK )
1835 return res;
1836
1837 if( pvargSrc->vt & VT_BYREF )
1838 {
1839 VARIANTARG varg;
1840 VariantInit( &varg );
1841
1842 /* handle the in place copy.
1843 */
1844 if( pvargDest == pvargSrc )
1845 {
1846 /* we will use a copy of the source instead.
1847 */
1848 res = VariantCopy( &varg, pvargSrc );
1849 pvargSrc = &varg;
1850 }
1851
1852 if( res == S_OK )
1853 {
1854 res = VariantClear( pvargDest );
1855
1856 if( res == S_OK )
1857 {
1858 /*
1859 * The VT_ARRAY flag is another way to designate a safearray variant.
1860 */
1861 if ( pvargSrc->vt & VT_ARRAY)
1862 {
1863 SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray);
1864 }
1865 else
1866 {
1867 /* In the case of by reference we need
1868 * to copy the date pointed to by the variant.
1869 */
1870
1871 /* Get the variant type.
1872 */
1873 switch( pvargSrc->vt & VT_TYPEMASK )
1874 {
1875 case( VT_BSTR ):
1876 pvargDest->u.bstrVal = SysAllocString( *(pvargSrc->u.pbstrVal) );
1877 break;
1878 case( VT_DISPATCH ):
1879 break;
1880 case( VT_VARIANT ):
1881 {
1882 /* Prevent from cycling. According to tests on
1883 * VariantCopyInd in Windows and the documentation
1884 * this API dereferences the inner Variants to only one depth.
1885 * If the inner Variant itself contains an
1886 * other inner variant the E_INVALIDARG error is
1887 * returned.
1888 */
1889 if( pvargSrc->wReserved1 & PROCESSING_INNER_VARIANT )
1890 {
1891 /* If we get here we are attempting to deference
1892 * an inner variant that that is itself contained
1893 * in an inner variant so report E_INVALIDARG error.
1894 */
1895 res = E_INVALIDARG;
1896 }
1897 else
1898 {
1899 /* Set the processing inner variant flag.
1900 * We will set this flag in the inner variant
1901 * that will be passed to the VariantCopyInd function.
1902 */
1903 (pvargSrc->u.pvarVal)->wReserved1 |= PROCESSING_INNER_VARIANT;
1904
1905 /* Dereference the inner variant.
1906 */
1907 res = VariantCopyInd( pvargDest, pvargSrc->u.pvarVal );
1908 /* We must also copy its type, I think.
1909 */
1910 pvargSrc->vt = pvargSrc->u.pvarVal->vt;
1911 }
1912 }
1913 break;
1914 case( VT_UNKNOWN ):
1915 break;
1916 case( VT_SAFEARRAY ):
1917 SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray);
1918 break;
1919 default:
1920 /* This is a by reference Variant which means that the union
1921 * part of the Variant contains a pointer to some data of
1922 * type "pvargSrc->vt & VT_TYPEMASK".
1923 * We will deference this data in a generic fashion using
1924 * the void pointer "Variant.u.byref".
1925 * We will copy this data into the union of the destination
1926 * Variant.
1927 */
1928 memcpy( &pvargDest->u, pvargSrc->u.byref, SizeOfVariantData( pvargSrc ) );
1929 break;
1930 }
1931 }
1932
1933 pvargDest->vt = pvargSrc->vt & VT_TYPEMASK;
1934 }
1935 }
1936
1937 /* this should not fail.
1938 */
1939 VariantClear( &varg );
1940 }
1941 else
1942 {
1943 res = VariantCopy( pvargDest, pvargSrc );
1944 }
1945
1946 return res;
1947 }
1948
1949 /******************************************************************************
1950 * VariantChangeType [OLEAUT32.12]
1951 */
1952 HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
1953 USHORT wFlags, VARTYPE vt)
1954 {
1955 return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
1956 }
1957
1958 /******************************************************************************
1959 * VariantChangeTypeEx [OLEAUT32.147]
1960 */
1961 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
1962 LCID lcid, USHORT wFlags, VARTYPE vt)
1963 {
1964 HRESULT res = S_OK;
1965 VARIANTARG varg;
1966 VariantInit( &varg );
1967
1968 TRACE("(%p, %p, %ld, %u, %u),stub\n", pvargDest, pvargSrc, lcid, wFlags, vt);
1969
1970 /* validate our source argument.
1971 */
1972 res = ValidateVariantType( pvargSrc->vt );
1973
1974 /* validate the vartype.
1975 */
1976 if( res == S_OK )
1977 {
1978 res = ValidateVt( vt );
1979 }
1980
1981 /* if we are doing an in-place conversion make a copy of the source.
1982 */
1983 if( res == S_OK && pvargDest == pvargSrc )
1984 {
1985 res = VariantCopy( &varg, pvargSrc );
1986 pvargSrc = &varg;
1987 }
1988
1989 if( res == S_OK )
1990 {
1991 /* free up the destination variant.
1992 */
1993 res = VariantClear( pvargDest );
1994 }
1995
1996 if( res == S_OK )
1997 {
1998 if( pvargSrc->vt & VT_BYREF )
1999 {
2000 /* Convert the source variant to a "byvalue" variant.
2001 */
2002 VARIANTARG Variant;
2003 VariantInit( &Variant );
2004 res = VariantCopyInd( &Variant, pvargSrc );
2005 if( res == S_OK )
2006 {
2007 res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
2008 /* this should not fail.
2009 */
2010 VariantClear( &Variant );
2011 }
2012
2013 }
2014 else
2015 {
2016 /* Use the current "byvalue" source variant.
2017 */
2018 res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
2019 }
2020 }
2021 /* this should not fail.
2022 */
2023 VariantClear( &varg );
2024
2025 /* set the type of the destination
2026 */
2027 if ( res == S_OK )
2028 pvargDest->vt = vt;
2029
2030 return res;
2031 }
2032
2033
2034
2035
2036 /******************************************************************************
2037 * VarUI1FromI2 [OLEAUT32.130]
2038 */
2039 HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut)
2040 {
2041 TRACE("( %d, %p ), stub\n", sIn, pbOut );
2042
2043 /* Check range of value.
2044 */
2045 if( sIn < UI1_MIN || sIn > UI1_MAX )
2046 {
2047 return DISP_E_OVERFLOW;
2048 }
2049
2050 *pbOut = (BYTE) sIn;
2051
2052 return S_OK;
2053 }
2054
2055 /******************************************************************************
2056 * VarUI1FromI4 [OLEAUT32.131]
2057 */
2058 HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut)
2059 {
2060 TRACE("( %ld, %p ), stub\n", lIn, pbOut );
2061
2062 /* Check range of value.
2063 */
2064 if( lIn < UI1_MIN || lIn > UI1_MAX )
2065 {
2066 return DISP_E_OVERFLOW;
2067 }
2068
2069 *pbOut = (BYTE) lIn;
2070
2071 return S_OK;
2072 }
2073
2074
2075 /******************************************************************************
2076 * VarUI1FromR4 [OLEAUT32.132]
2077 */
2078 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
2079 {
2080 TRACE("( %f, %p ), stub\n", fltIn, pbOut );
2081
2082 /* Check range of value.
2083 */
2084 fltIn = round( fltIn );
2085 if( fltIn < UI1_MIN || fltIn > UI1_MAX )
2086 {
2087 return DISP_E_OVERFLOW;
2088 }
2089
2090 *pbOut = (BYTE) fltIn;
2091
2092 return S_OK;
2093 }
2094
2095 /******************************************************************************
2096 * VarUI1FromR8 [OLEAUT32.133]
2097 */
2098 HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
2099 {
2100 TRACE("( %f, %p ), stub\n", dblIn, pbOut );
2101
2102 /* Check range of value.
2103 */
2104 dblIn = round( dblIn );
2105 if( dblIn < UI1_MIN || dblIn > UI1_MAX )
2106 {
2107 return DISP_E_OVERFLOW;
2108 }
2109
2110 *pbOut = (BYTE) dblIn;
2111
2112 return S_OK;
2113 }
2114
2115 /******************************************************************************
2116 * VarUI1FromDate [OLEAUT32.135]
2117 */
2118 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
2119 {
2120 TRACE("( %f, %p ), stub\n", dateIn, pbOut );
2121
2122 /* Check range of value.
2123 */
2124 dateIn = round( dateIn );
2125 if( dateIn < UI1_MIN || dateIn > UI1_MAX )
2126 {
2127 return DISP_E_OVERFLOW;
2128 }
2129
2130 *pbOut = (BYTE) dateIn;
2131
2132 return S_OK;
2133 }
2134
2135 /******************************************************************************
2136 * VarUI1FromBool [OLEAUT32.138]
2137 */
2138 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
2139 {
2140 TRACE("( %d, %p ), stub\n", boolIn, pbOut );
2141
2142 *pbOut = (BYTE) boolIn;
2143
2144 return S_OK;
2145 }
2146
2147 /******************************************************************************
2148 * VarUI1FromI1 [OLEAUT32.237]
2149 */
2150 HRESULT WINAPI VarUI1FromI1(CHAR cIn, BYTE* pbOut)
2151 {
2152 TRACE("( %c, %p ), stub\n", cIn, pbOut );
2153
2154 *pbOut = cIn;
2155
2156 return S_OK;
2157 }
2158
2159 /******************************************************************************
2160 * VarUI1FromUI2 [OLEAUT32.238]
2161 */
2162 HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut)
2163 {
2164 TRACE("( %d, %p ), stub\n", uiIn, pbOut );
2165
2166 /* Check range of value.
2167 */
2168 if( uiIn > UI1_MAX )
2169 {
2170 return DISP_E_OVERFLOW;
2171 }
2172
2173 *pbOut = (BYTE) uiIn;
2174
2175 return S_OK;
2176 }
2177
2178 /******************************************************************************
2179 * VarUI1FromUI4 [OLEAUT32.239]
2180 */
2181 HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
2182 {
2183 TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
2184
2185 /* Check range of value.
2186 */
2187 if( ulIn > UI1_MAX )
2188 {
2189 return DISP_E_OVERFLOW;
2190 }
2191
2192 *pbOut = (BYTE) ulIn;
2193
2194 return S_OK;
2195 }
2196
2197
2198 /******************************************************************************
2199 * VarUI1FromStr [OLEAUT32.54]
2200 */
2201 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
2202 {
2203 double dValue = 0.0;
2204 LPSTR pNewString = NULL;
2205
2206 TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
2207
2208 /* Check if we have a valid argument
2209 */
2210 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2211 RemoveCharacterFromString( pNewString, "," );
2212 if( IsValidRealString( pNewString ) == FALSE )
2213 {
2214 return DISP_E_TYPEMISMATCH;
2215 }
2216
2217 /* Convert the valid string to a floating point number.
2218 */
2219 dValue = atof( pNewString );
2220
2221 /* We don't need the string anymore so free it.
2222 */
2223 HeapFree( GetProcessHeap(), 0 , pNewString );
2224
2225 /* Check range of value.
2226 */
2227 dValue = round( dValue );
2228 if( dValue < UI1_MIN || dValue > UI1_MAX )
2229 {
2230 return DISP_E_OVERFLOW;
2231 }
2232
2233 *pbOut = (BYTE) dValue;
2234
2235 return S_OK;
2236 }
2237
2238 /**********************************************************************
2239 * VarUI1FromCy [OLEAUT32.134]
2240 * Convert currency to unsigned char
2241 */
2242 HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
2243 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2244
2245 if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
2246
2247 *pbOut = (BYTE)t;
2248 return S_OK;
2249 }
2250
2251 /******************************************************************************
2252 * VarI2FromUI1 [OLEAUT32.48]
2253 */
2254 HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut)
2255 {
2256 TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
2257
2258 *psOut = (short) bIn;
2259
2260 return S_OK;
2261 }
2262
2263 /******************************************************************************
2264 * VarI2FromI4 [OLEAUT32.49]
2265 */
2266 HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut)
2267 {
2268 TRACE("( %lx, %p ), stub\n", lIn, psOut );
2269
2270 /* Check range of value.
2271 */
2272 if( lIn < I2_MIN || lIn > I2_MAX )
2273 {
2274 return DISP_E_OVERFLOW;
2275 }
2276
2277 *psOut = (short) lIn;
2278
2279 return S_OK;
2280 }
2281
2282 /******************************************************************************
2283 * VarI2FromR4 [OLEAUT32.50]
2284 */
2285 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut)
2286 {
2287 TRACE("( %f, %p ), stub\n", fltIn, psOut );
2288
2289 /* Check range of value.
2290 */
2291 fltIn = round( fltIn );
2292 if( fltIn < I2_MIN || fltIn > I2_MAX )
2293 {
2294 return DISP_E_OVERFLOW;
2295 }
2296
2297 *psOut = (short) fltIn;
2298
2299 return S_OK;
2300 }
2301
2302 /******************************************************************************
2303 * VarI2FromR8 [OLEAUT32.51]
2304 */
2305 HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut)
2306 {
2307 TRACE("( %f, %p ), stub\n", dblIn, psOut );
2308
2309 /* Check range of value.
2310 */
2311 dblIn = round( dblIn );
2312 if( dblIn < I2_MIN || dblIn > I2_MAX )
2313 {
2314 return DISP_E_OVERFLOW;
2315 }
2316
2317 *psOut = (short) dblIn;
2318
2319 return S_OK;
2320 }
2321
2322 /******************************************************************************
2323 * VarI2FromDate [OLEAUT32.53]
2324 */
2325 HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut)
2326 {
2327 TRACE("( %f, %p ), stub\n", dateIn, psOut );
2328
2329 /* Check range of value.
2330 */
2331 dateIn = round( dateIn );
2332 if( dateIn < I2_MIN || dateIn > I2_MAX )
2333 {
2334 return DISP_E_OVERFLOW;
2335 }
2336
2337 *psOut = (short) dateIn;
2338
2339 return S_OK;
2340 }
2341
2342 /******************************************************************************
2343 * VarI2FromBool [OLEAUT32.56]
2344 */
2345 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut)
2346 {
2347 TRACE("( %d, %p ), stub\n", boolIn, psOut );
2348
2349 *psOut = (short) boolIn;
2350
2351 return S_OK;
2352 }
2353
2354 /******************************************************************************
2355 * VarI2FromI1 [OLEAUT32.48]
2356 */
2357 HRESULT WINAPI VarI2FromI1(CHAR cIn, short* psOut)
2358 {
2359 TRACE("( %c, %p ), stub\n", cIn, psOut );
2360
2361 *psOut = (short) cIn;
2362
2363 return S_OK;
2364 }
2365
2366 /******************************************************************************
2367 * VarI2FromUI2 [OLEAUT32.206]
2368 */
2369 HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut)
2370 {
2371 TRACE("( %d, %p ), stub\n", uiIn, psOut );
2372
2373 /* Check range of value.
2374 */
2375 if( uiIn > I2_MAX )
2376 {
2377 return DISP_E_OVERFLOW;
2378 }
2379
2380 *psOut = (short) uiIn;
2381
2382 return S_OK;
2383 }
2384
2385 /******************************************************************************
2386 * VarI2FromUI4 [OLEAUT32.49]
2387 */
2388 HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
2389 {
2390 TRACE("( %lx, %p ), stub\n", ulIn, psOut );
2391
2392 /* Check range of value.
2393 */
2394 if( ulIn < I2_MIN || ulIn > I2_MAX )
2395 {
2396 return DISP_E_OVERFLOW;
2397 }
2398
2399 *psOut = (short) ulIn;
2400
2401 return S_OK;
2402 }
2403
2404 /******************************************************************************
2405 * VarI2FromStr [OLEAUT32.54]
2406 */
2407 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut)
2408 {
2409 double dValue = 0.0;
2410 LPSTR pNewString = NULL;
2411
2412 TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, psOut );
2413
2414 /* Check if we have a valid argument
2415 */
2416 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2417 RemoveCharacterFromString( pNewString, "," );
2418 if( IsValidRealString( pNewString ) == FALSE )
2419 {
2420 return DISP_E_TYPEMISMATCH;
2421 }
2422
2423 /* Convert the valid string to a floating point number.
2424 */
2425 dValue = atof( pNewString );
2426
2427 /* We don't need the string anymore so free it.
2428 */
2429 HeapFree( GetProcessHeap(), 0, pNewString );
2430
2431 /* Check range of value.
2432 */
2433 dValue = round( dValue );
2434 if( dValue < I2_MIN || dValue > I2_MAX )
2435 {
2436 return DISP_E_OVERFLOW;
2437 }
2438
2439 *psOut = (short) dValue;
2440
2441 return S_OK;
2442 }
2443
2444 /**********************************************************************
2445 * VarI2FromCy [OLEAUT32.52]
2446 * Convert currency to signed short
2447 */
2448 HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
2449 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2450
2451 if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
2452
2453 *psOut = (SHORT)t;
2454 return S_OK;
2455 }
2456
2457 /******************************************************************************
2458 * VarI4FromUI1 [OLEAUT32.58]
2459 */
2460 HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut)
2461 {
2462 TRACE("( %X, %p ), stub\n", bIn, plOut );
2463
2464 *plOut = (LONG) bIn;
2465
2466 return S_OK;
2467 }
2468
2469
2470 /******************************************************************************
2471 * VarI4FromR4 [OLEAUT32.60]
2472 */
2473 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut)
2474 {
2475 TRACE("( %f, %p ), stub\n", fltIn, plOut );
2476
2477 /* Check range of value.
2478 */
2479 fltIn = round( fltIn );
2480 if( fltIn < I4_MIN || fltIn > I4_MAX )
2481 {
2482 return DISP_E_OVERFLOW;
2483 }
2484
2485 *plOut = (LONG) fltIn;
2486
2487 return S_OK;
2488 }
2489
2490 /******************************************************************************
2491 * VarI4FromR8 [OLEAUT32.61]
2492 */
2493 HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut)
2494 {
2495 TRACE("( %f, %p ), stub\n", dblIn, plOut );
2496
2497 /* Check range of value.
2498 */
2499 dblIn = round( dblIn );
2500 if( dblIn < I4_MIN || dblIn > I4_MAX )
2501 {
2502 return DISP_E_OVERFLOW;
2503 }
2504
2505 *plOut = (LONG) dblIn;
2506
2507 return S_OK;
2508 }
2509
2510 /******************************************************************************
2511 * VarI4FromDate [OLEAUT32.63]
2512 */
2513 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut)
2514 {
2515 TRACE("( %f, %p ), stub\n", dateIn, plOut );
2516
2517 /* Check range of value.
2518 */
2519 dateIn = round( dateIn );
2520 if( dateIn < I4_MIN || dateIn > I4_MAX )
2521 {
2522 return DISP_E_OVERFLOW;
2523 }
2524
2525 *plOut = (LONG) dateIn;
2526
2527 return S_OK;
2528 }
2529
2530 /******************************************************************************
2531 * VarI4FromBool [OLEAUT32.66]
2532 */
2533 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut)
2534 {
2535 TRACE("( %d, %p ), stub\n", boolIn, plOut );
2536
2537 *plOut = (LONG) boolIn;
2538
2539 return S_OK;
2540 }
2541
2542 /******************************************************************************
2543 * VarI4FromI1 [OLEAUT32.209]
2544 */
2545 HRESULT WINAPI VarI4FromI1(CHAR cIn, LONG* plOut)
2546 {
2547 TRACE("( %c, %p ), stub\n", cIn, plOut );
2548
2549 *plOut = (LONG) cIn;
2550
2551 return S_OK;
2552 }
2553
2554 /******************************************************************************
2555 * VarI4FromUI2 [OLEAUT32.210]
2556 */
2557 HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut)
2558 {
2559 TRACE("( %d, %p ), stub\n", uiIn, plOut );
2560
2561 *plOut = (LONG) uiIn;
2562
2563 return S_OK;
2564 }
2565
2566 /******************************************************************************
2567 * VarI4FromUI4 [OLEAUT32.211]
2568 */
2569 HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut)
2570 {
2571 TRACE("( %lx, %p ), stub\n", ulIn, plOut );
2572
2573 /* Check range of value.
2574 */
2575 if( ulIn < I4_MIN || ulIn > I4_MAX )
2576 {
2577 return DISP_E_OVERFLOW;
2578 }
2579
2580 *plOut = (LONG) ulIn;
2581
2582 return S_OK;
2583 }
2584
2585 /******************************************************************************
2586 * VarI4FromI2 [OLEAUT32.59]
2587 */
2588 HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut)
2589 {
2590 TRACE("( %d, %p ), stub\n", sIn, plOut );
2591
2592 *plOut = (LONG) sIn;
2593
2594 return S_OK;
2595 }
2596
2597 /******************************************************************************
2598 * VarI4FromStr [OLEAUT32.64]
2599 */
2600 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut)
2601 {
2602 double dValue = 0.0;
2603 LPSTR pNewString = NULL;
2604
2605 TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
2606
2607 /* Check if we have a valid argument
2608 */
2609 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2610 RemoveCharacterFromString( pNewString, "," );
2611 if( IsValidRealString( pNewString ) == FALSE )
2612 {
2613 return DISP_E_TYPEMISMATCH;
2614 }
2615
2616 /* Convert the valid string to a floating point number.
2617 */
2618 dValue = atof( pNewString );
2619
2620 /* We don't need the string anymore so free it.
2621 */
2622 HeapFree( GetProcessHeap(), 0, pNewString );
2623
2624 /* Check range of value.
2625 */
2626 dValue = round( dValue );
2627 if( dValue < I4_MIN || dValue > I4_MAX )
2628 {
2629 return DISP_E_OVERFLOW;
2630 }
2631
2632 *plOut = (LONG) dValue;
2633
2634 return S_OK;
2635 }
2636
2637 /**********************************************************************
2638 * VarI4FromCy [OLEAUT32.62]
2639 * Convert currency to signed long
2640 */
2641 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
2642 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2643
2644 if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
2645
2646 *plOut = (LONG)t;
2647 return S_OK;
2648 }
2649
2650 /******************************************************************************
2651 * VarR4FromUI1 [OLEAUT32.68]
2652 */
2653 HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut)
2654 {
2655 TRACE("( %X, %p ), stub\n", bIn, pfltOut );
2656
2657 *pfltOut = (FLOAT) bIn;
2658
2659 return S_OK;
2660 }
2661
2662 /******************************************************************************
2663 * VarR4FromI2 [OLEAUT32.69]
2664 */
2665 HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut)
2666 {
2667 TRACE("( %d, %p ), stub\n", sIn, pfltOut );
2668
2669 *pfltOut = (FLOAT) sIn;
2670
2671 return S_OK;
2672 }
2673
2674 /******************************************************************************
2675 * VarR4FromI4 [OLEAUT32.70]
2676 */
2677 HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut)
2678 {
2679 TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
2680
2681 *pfltOut = (FLOAT) lIn;
2682
2683 return S_OK;
2684 }
2685
2686 /******************************************************************************
2687 * VarR4FromR8 [OLEAUT32.71]
2688 */
2689 HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut)
2690 {
2691 TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
2692
2693 /* Check range of value.
2694 */
2695 if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
2696 {
2697 return DISP_E_OVERFLOW;
2698 }
2699
2700 *pfltOut = (FLOAT) dblIn;
2701
2702 return S_OK;
2703 }
2704
2705 /******************************************************************************
2706 * VarR4FromDate [OLEAUT32.73]
2707 */
2708 HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut)
2709 {
2710 TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
2711
2712 /* Check range of value.
2713 */
2714 if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
2715 {
2716 return DISP_E_OVERFLOW;
2717 }
2718
2719 *pfltOut = (FLOAT) dateIn;
2720
2721 return S_OK;
2722 }
2723
2724 /******************************************************************************
2725 * VarR4FromBool [OLEAUT32.76]
2726 */
2727 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut)
2728 {
2729 TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
2730
2731 *pfltOut = (FLOAT) boolIn;
2732
2733 return S_OK;
2734 }
2735
2736 /******************************************************************************
2737 * VarR4FromI1 [OLEAUT32.213]
2738 */
2739 HRESULT WINAPI VarR4FromI1(CHAR cIn, FLOAT* pfltOut)
2740 {
2741 TRACE("( %c, %p ), stub\n", cIn, pfltOut );
2742
2743 *pfltOut = (FLOAT) cIn;
2744
2745 return S_OK;
2746 }
2747
2748 /******************************************************************************
2749 * VarR4FromUI2 [OLEAUT32.214]
2750 */
2751 HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut)
2752 {
2753 TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
2754
2755 *pfltOut = (FLOAT) uiIn;
2756
2757 return S_OK;
2758 }
2759
2760 /******************************************************************************
2761 * VarR4FromUI4 [OLEAUT32.215]
2762 */
2763 HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut)
2764 {
2765 TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
2766
2767 *pfltOut = (FLOAT) ulIn;
2768
2769 return S_OK;
2770 }
2771
2772 /******************************************************************************
2773 * VarR4FromStr [OLEAUT32.74]
2774 */
2775 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut)
2776 {
2777 double dValue = 0.0;
2778 LPSTR pNewString = NULL;
2779
2780 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
2781
2782 /* Check if we have a valid argument
2783 */
2784 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2785 RemoveCharacterFromString( pNewString, "," );
2786 if( IsValidRealString( pNewString ) == FALSE )
2787 {
2788 return DISP_E_TYPEMISMATCH;
2789 }
2790
2791 /* Convert the valid string to a floating point number.
2792 */
2793 dValue = atof( pNewString );
2794
2795 /* We don't need the string anymore so free it.
2796 */
2797 HeapFree( GetProcessHeap(), 0, pNewString );
2798
2799 /* Check range of value.
2800 */
2801 if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
2802 {
2803 return DISP_E_OVERFLOW;
2804 }
2805
2806 *pfltOut = (FLOAT) dValue;
2807
2808 return S_OK;
2809 }
2810
2811 /**********************************************************************
2812 * VarR4FromCy [OLEAUT32.72]
2813 * Convert currency to float
2814 */
2815 HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
2816 *pfltOut = (FLOAT)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2817
2818 return S_OK;
2819 }
2820
2821 /******************************************************************************
2822 * VarR8FromUI1 [OLEAUT32.68]
2823 */
2824 HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
2825 {
2826 TRACE("( %d, %p ), stub\n", bIn, pdblOut );
2827
2828 *pdblOut = (double) bIn;
2829
2830 return S_OK;
2831 }
2832
2833 /******************************************************************************
2834 * VarR8FromI2 [OLEAUT32.69]
2835 */
2836 HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
2837 {
2838 TRACE("( %d, %p ), stub\n", sIn, pdblOut );
2839
2840 *pdblOut = (double) sIn;
2841
2842 return S_OK;
2843 }
2844
2845 /******************************************************************************
2846 * VarR8FromI4 [OLEAUT32.70]
2847 */
2848 HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
2849 {
2850 TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
2851
2852 *pdblOut = (double) lIn;
2853
2854 return S_OK;
2855 }
2856
2857 /******************************************************************************
2858 * VarR8FromR4 [OLEAUT32.81]
2859 */
2860 HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut)
2861 {
2862 TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
2863
2864 *pdblOut = (double) fltIn;
2865
2866 return S_OK;
2867 }
2868
2869 /******************************************************************************
2870 * VarR8FromDate [OLEAUT32.83]
2871 */
2872 HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut)
2873 {
2874 TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
2875
2876 *pdblOut = (double) dateIn;
2877
2878 return S_OK;
2879 }
2880
2881 /******************************************************************************
2882 * VarR8FromBool [OLEAUT32.86]
2883 */
2884 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut)
2885 {
2886 TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
2887
2888 *pdblOut = (double) boolIn;
2889
2890 return S_OK;
2891 }
2892
2893 /******************************************************************************
2894 * VarR8FromI1 [OLEAUT32.217]
2895 */
2896 HRESULT WINAPI VarR8FromI1(CHAR cIn, double* pdblOut)
2897 {
2898 TRACE("( %c, %p ), stub\n", cIn, pdblOut );
2899
2900 *pdblOut = (double) cIn;
2901
2902 return S_OK;
2903 }
2904
2905 /******************************************************************************
2906 * VarR8FromUI2 [OLEAUT32.218]
2907 */
2908 HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut)
2909 {
2910 TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
2911
2912 *pdblOut = (double) uiIn;
2913
2914 return S_OK;
2915 }
2916
2917 /******************************************************************************
2918 * VarR8FromUI4 [OLEAUT32.219]
2919 */
2920 HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut)
2921 {
2922 TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
2923
2924 *pdblOut = (double) ulIn;
2925
2926 return S_OK;
2927 }
2928
2929 /******************************************************************************
2930 * VarR8FromStr [OLEAUT32.84]
2931 */
2932 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut)
2933 {
2934 double dValue = 0.0;
2935 LPSTR pNewString = NULL;
2936
2937 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pdblOut );
2938
2939 /* Check if we have a valid argument
2940 */
2941 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2942 RemoveCharacterFromString( pNewString, "," );
2943 if( IsValidRealString( pNewString ) == FALSE )
2944 {
2945 return DISP_E_TYPEMISMATCH;
2946 }
2947
2948 /* Convert the valid string to a floating point number.
2949 */
2950 dValue = atof( pNewString );
2951
2952 /* We don't need the string anymore so free it.
2953 */
2954 HeapFree( GetProcessHeap(), 0, pNewString );
2955
2956 *pdblOut = dValue;
2957
2958 return S_OK;
2959 }
2960
2961 /**********************************************************************
2962 * VarR8FromCy [OLEAUT32.82]
2963 * Convert currency to double
2964 */
2965 HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
2966 *pdblOut = (double)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2967
2968 return S_OK;
2969 }
2970
2971 /******************************************************************************
2972 * VarDateFromUI1 [OLEAUT32.]
2973 */
2974 HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
2975 {
2976 TRACE("( %d, %p ), stub\n", bIn, pdateOut );
2977
2978 *pdateOut = (DATE) bIn;
2979
2980 return S_OK;
2981 }
2982
2983 /******************************************************************************
2984 * VarDateFromI2 [OLEAUT32.222]
2985 */
2986 HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
2987 {
2988 TRACE("( %d, %p ), stub\n", sIn, pdateOut );
2989
2990 *pdateOut = (DATE) sIn;
2991
2992 return S_OK;
2993 }
2994
2995 /******************************************************************************
2996 * VarDateFromI4 [OLEAUT32.90]
2997 */
2998 HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
2999 {
3000 TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
3001
3002 if( lIn < DATE_MIN || lIn > DATE_MAX )
3003 {
3004 return DISP_E_OVERFLOW;
3005 }
3006
3007 *pdateOut = (DATE) lIn;
3008
3009 return S_OK;
3010 }
3011
3012 /******************************************************************************
3013 * VarDateFromR4 [OLEAUT32.91]
3014 */
3015 HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
3016 {
3017 TRACE("( %f, %p ), stub\n", fltIn, pdateOut );
3018
3019 if( ceil(fltIn) < DATE_MIN || floor(fltIn) > DATE_MAX )
3020 {
3021 return DISP_E_OVERFLOW;
3022 }
3023
3024 *pdateOut = (DATE) fltIn;
3025
3026 return S_OK;
3027 }
3028
3029 /******************************************************************************
3030 * VarDateFromR8 [OLEAUT32.92]
3031 */
3032 HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
3033 {
3034 TRACE("( %f, %p ), stub\n", dblIn, pdateOut );
3035
3036 if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
3037 {
3038 return DISP_E_OVERFLOW;
3039 }
3040
3041 *pdateOut = (DATE) dblIn;
3042
3043 return S_OK;
3044 }
3045
3046 /******************************************************************************
3047 * VarDateFromStr [OLEAUT32.94]
3048 * The string representing the date is composed of two parts, a date and time.
3049 *
3050 * The format of the time is has follows:
3051 * hh[:mm][:ss][AM|PM]
3052 * Whitespace can be inserted anywhere between these tokens. A whitespace consists
3053 * of space and/or tab characters, which are ignored.
3054 *
3055 * The formats for the date part are has follows:
3056 * mm/[dd/][yy]yy
3057 * [dd/]mm/[yy]yy
3058 * [yy]yy/mm/dd
3059 * January dd[,] [yy]yy
3060 * dd January [yy]yy
3061 * [yy]yy January dd
3062 * Whitespace can be inserted anywhere between these tokens.
3063 *
3064 * The formats for the date and time string are has follows.
3065 * date[whitespace][time]
3066 * [time][whitespace]date
3067 *
3068 * These are the only characters allowed in a string representing a date and time:
3069 * [A-Z] [a-z] [0-9] ':' '-' '/' ',' ' ' '\t'
3070 */
3071 HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
3072 {
3073 HRESULT ret = S_OK;
3074 struct tm TM = { 0,0,0,0,0,0,0,0,0 };
3075
3076 TRACE("( %p, %lx, %lx, %p ), stub\n", strIn, lcid, dwFlags, pdateOut );
3077
3078 if( DateTimeStringToTm( strIn, lcid, &TM ) )
3079 {
3080 if( TmToDATE( &TM, pdateOut ) == FALSE )
3081 {
3082 ret = E_INVALIDARG;
3083 }
3084 }
3085 else
3086 {
3087 ret = DISP_E_TYPEMISMATCH;
3088 }
3089
3090
3091 return ret;
3092 }
3093
3094 /******************************************************************************
3095 * VarDateFromI1 [OLEAUT32.221]
3096 */
3097 HRESULT WINAPI VarDateFromI1(CHAR cIn, DATE* pdateOut)
3098 {
3099 TRACE("( %c, %p ), stub\n", cIn, pdateOut );
3100
3101 *pdateOut = (DATE) cIn;
3102
3103 return S_OK;
3104 }
3105
3106 /******************************************************************************
3107 * VarDateFromUI2 [OLEAUT32.222]
3108 */
3109 HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
3110 {
3111 TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
3112
3113 if( uiIn > DATE_MAX )
3114 {
3115 return DISP_E_OVERFLOW;
3116 }
3117
3118 *pdateOut = (DATE) uiIn;
3119
3120 return S_OK;
3121 }
3122
3123 /******************************************************************************
3124 * VarDateFromUI4 [OLEAUT32.223]
3125 */
3126 HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
3127 {
3128 TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
3129
3130 if( ulIn < DATE_MIN || ulIn > DATE_MAX )
3131 {
3132 return DISP_E_OVERFLOW;
3133 }
3134
3135 *pdateOut = (DATE) ulIn;
3136
3137 return S_OK;
3138 }
3139
3140 /******************************************************************************
3141 * VarDateFromBool [OLEAUT32.96]
3142 */
3143 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
3144 {
3145 TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
3146
3147 *pdateOut = (DATE) boolIn;
3148
3149 return S_OK;
3150 }
3151
3152 /**********************************************************************
3153 * VarDateFromCy [OLEAUT32.93]
3154 * Convert currency to date
3155 */
3156 HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut) {
3157 *pdateOut = (DATE)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3158
3159 if (*pdateOut > DATE_MAX || *pdateOut < DATE_MIN) return DISP_E_TYPEMISMATCH;
3160 return S_OK;
3161 }
3162
3163 /******************************************************************************
3164 * VarBstrFromUI1 [OLEAUT32.108]
3165 */
3166 HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3167 {
3168 TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
3169 sprintf( pBuffer, "%d", bVal );
3170
3171 *pbstrOut = StringDupAtoBstr( pBuffer );
3172
3173 return S_OK;
3174 }
3175
3176 /******************************************************************************
3177 * VarBstrFromI2 [OLEAUT32.109]
3178 */
3179 HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3180 {
3181 TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
3182 sprintf( pBuffer, "%d", iVal );
3183 *pbstrOut = StringDupAtoBstr( pBuffer );
3184
3185 return S_OK;
3186 }
3187
3188 /******************************************************************************
3189 * VarBstrFromI4 [OLEAUT32.110]
3190 */
3191 HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3192 {
3193 TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
3194
3195 sprintf( pBuffer, "%ld", lIn );
3196 *pbstrOut = StringDupAtoBstr( pBuffer );
3197
3198 return S_OK;
3199 }
3200
3201 /******************************************************************************
3202 * VarBstrFromR4 [OLEAUT32.111]
3203 */
3204 HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3205 {
3206 TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
3207
3208 sprintf( pBuffer, "%.7g", fltIn );
3209 *pbstrOut = StringDupAtoBstr( pBuffer );
3210
3211 return S_OK;
3212 }
3213
3214 /******************************************************************************
3215 * VarBstrFromR8 [OLEAUT32.112]
3216 */
3217 HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3218 {
3219 TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
3220
3221 sprintf( pBuffer, "%.15g", dblIn );
3222 *pbstrOut = StringDupAtoBstr( pBuffer );
3223
3224 return S_OK;
3225 }
3226
3227 /******************************************************************************
3228 * VarBstrFromCy [OLEAUT32.113]
3229 */
3230 HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut) {
3231 /* FIXME */
3232 return E_NOTIMPL;
3233 }
3234
3235
3236 /******************************************************************************
3237 * VarBstrFromDate [OLEAUT32.114]
3238 *
3239 * The date is implemented using an 8 byte floating-point number.
3240 * Days are represented by whole numbers increments starting with 0.00 has
3241 * being December 30 1899, midnight.
3242 * The hours are expressed as the fractional part of the number.
3243 * December 30 1899 at midnight = 0.00
3244 * January 1 1900 at midnight = 2.00
3245 * January 4 1900 at 6 AM = 5.25
3246 * January 4 1900 at noon = 5.50
3247 * December 29 1899 at midnight = -1.00
3248 * December 18 1899 at midnight = -12.00
3249 * December 18 1899 at 6AM = -12.25
3250 * December 18 1899 at 6PM = -12.75
3251 * December 19 1899 at midnight = -11.00
3252 * The tm structure is as follows:
3253 * struct tm {
3254 * int tm_sec; seconds after the minute - [0,59]
3255 * int tm_min; minutes after the hour - [0,59]
3256 * int tm_hour; hours since midnight - [0,23]
3257 * int tm_mday; day of the month - [1,31]
3258 * int tm_mon; months since January - [0,11]
3259 * int tm_year; years
3260 * int tm_wday; days since Sunday - [0,6]
3261 * int tm_yday; days since January 1 - [0,365]
3262 * int tm_isdst; daylight savings time flag
3263 * };
3264 */
3265 HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3266 {
3267 struct tm TM = {0,0,0,0,0,0,0,0,0};
3268
3269 TRACE("( %f, %ld, %ld, %p ), stub\n", dateIn, lcid, dwFlags, pbstrOut );
3270
3271 if( DateToTm( dateIn, lcid, &TM ) == FALSE )
3272 {
3273 return E_INVALIDARG;
3274 }
3275
3276 if( dwFlags & VAR_DATEVALUEONLY )
3277 strftime( pBuffer, BUFFER_MAX, "%x", &TM );
3278 else if( dwFlags & VAR_TIMEVALUEONLY )
3279 strftime( pBuffer, BUFFER_MAX, "%X", &TM );
3280 else
3281 strftime( pBuffer, BUFFER_MAX, "%x %X", &TM );
3282
3283 *pbstrOut = StringDupAtoBstr( pBuffer );
3284
3285 return S_OK;
3286 }
3287
3288 /******************************************************************************
3289 * VarBstrFromBool [OLEAUT32.116]
3290 */
3291 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3292 {
3293 TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
3294
3295 if( boolIn == VARIANT_FALSE )
3296 {
3297 sprintf( pBuffer, "False" );
3298 }
3299 else
3300 {
3301 sprintf( pBuffer, "True" );
3302 }
3303
3304 *pbstrOut = StringDupAtoBstr( pBuffer );
3305
3306 return S_OK;
3307 }
3308
3309 /******************************************************************************
3310 * VarBstrFromI1 [OLEAUT32.229]
3311 */
3312 HRESULT WINAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3313 {
3314 TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
3315 sprintf( pBuffer, "%d", cIn );
3316 *pbstrOut = StringDupAtoBstr( pBuffer );
3317
3318 return S_OK;
3319 }
3320
3321 /******************************************************************************
3322 * VarBstrFromUI2 [OLEAUT32.230]
3323 */
3324 HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3325 {
3326 TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
3327 sprintf( pBuffer, "%d", uiIn );
3328 *pbstrOut = StringDupAtoBstr( pBuffer );
3329
3330 return S_OK;
3331 }
3332
3333 /******************************************************************************
3334 * VarBstrFromUI4 [OLEAUT32.231]
3335 */
3336 HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3337 {
3338 TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
3339 sprintf( pBuffer, "%ld", ulIn );
3340 *pbstrOut = StringDupAtoBstr( pBuffer );
3341
3342 return S_OK;
3343 }
3344
3345 /******************************************************************************
3346 * VarBoolFromUI1 [OLEAUT32.118]
3347 */
3348 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
3349 {
3350 TRACE("( %d, %p ), stub\n", bIn, pboolOut );
3351
3352 if( bIn == 0 )
3353 {
3354 *pboolOut = VARIANT_FALSE;
3355 }
3356 else
3357 {
3358 *pboolOut = VARIANT_TRUE;
3359 }
3360
3361 return S_OK;
3362 }
3363
3364 /******************************************************************************
3365 * VarBoolFromI2 [OLEAUT32.119]
3366 */
3367 HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
3368 {
3369 TRACE("( %d, %p ), stub\n", sIn, pboolOut );
3370
3371 if( sIn == 0 )
3372 {
3373 *pboolOut = VARIANT_FALSE;
3374 }
3375 else
3376 {
3377 *pboolOut = VARIANT_TRUE;
3378 }
3379
3380 return S_OK;
3381 }
3382
3383 /******************************************************************************
3384 * VarBoolFromI4 [OLEAUT32.120]
3385 */
3386 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
3387 {
3388 TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
3389
3390 if( lIn == 0 )
3391 {
3392 *pboolOut = VARIANT_FALSE;
3393 }
3394 else
3395 {
3396 *pboolOut = VARIANT_TRUE;
3397 }
3398
3399 return S_OK;
3400 }
3401
3402 /******************************************************************************
3403 * VarBoolFromR4 [OLEAUT32.121]
3404 */
3405 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
3406 {
3407 TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
3408
3409 if( fltIn == 0.0 )
3410 {
3411 *pboolOut = VARIANT_FALSE;
3412 }
3413 else
3414 {
3415 *pboolOut = VARIANT_TRUE;
3416 }
3417
3418 return S_OK;
3419 }
3420
3421 /******************************************************************************
3422 * VarBoolFromR8 [OLEAUT32.122]
3423 */
3424 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
3425 {
3426 TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
3427
3428 if( dblIn == 0.0 )
3429 {
3430 *pboolOut = VARIANT_FALSE;
3431 }
3432 else
3433 {
3434 *pboolOut = VARIANT_TRUE;
3435 }
3436
3437 return S_OK;
3438 }
3439
3440 /******************************************************************************
3441 * VarBoolFromDate [OLEAUT32.123]
3442 */
3443 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
3444 {
3445 TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
3446
3447 if( dateIn == 0.0 )
3448 {
3449 *pboolOut = VARIANT_FALSE;
3450 }
3451 else
3452 {
3453 *pboolOut = VARIANT_TRUE;
3454 }
3455
3456 return S_OK;
3457 }
3458
3459 /******************************************************************************
3460 * VarBoolFromStr [OLEAUT32.125]
3461 */
3462 HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
3463 {
3464 HRESULT ret = S_OK;
3465 char* pNewString = NULL;
3466
3467 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
3468
3469 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3470
3471 if( pNewString == NULL || strlen( pNewString ) == 0 )
3472 {
3473 ret = DISP_E_TYPEMISMATCH;
3474 }
3475
3476 if( ret == S_OK )
3477 {
3478 if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
3479 {
3480 *pboolOut = VARIANT_TRUE;
3481 }
3482 else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
3483 {
3484 *pboolOut = VARIANT_FALSE;
3485 }
3486 else
3487 {
3488 /* Try converting the string to a floating point number.
3489 */
3490 double dValue = 0.0;
3491 HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
3492 if( res != S_OK )
3493 {
3494 ret = DISP_E_TYPEMISMATCH;
3495 }
3496 else if( dValue == 0.0 )
3497 {
3498 *pboolOut = VARIANT_FALSE;
3499 }
3500 else
3501 {
3502 *pboolOut = VARIANT_TRUE;
3503 }
3504 }
3505 }
3506
3507 HeapFree( GetProcessHeap(), 0, pNewString );
3508
3509 return ret;
3510 }
3511
3512 /******************************************************************************
3513 * VarBoolFromI1 [OLEAUT32.233]
3514 */
3515 HRESULT WINAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL* pboolOut)
3516 {
3517 TRACE("( %c, %p ), stub\n", cIn, pboolOut );
3518
3519 if( cIn == 0 )
3520 {
3521 *pboolOut = VARIANT_FALSE;
3522 }
3523 else
3524 {
3525 *pboolOut = VARIANT_TRUE;
3526 }
3527
3528 return S_OK;
3529 }
3530
3531 /******************************************************************************
3532 * VarBoolFromUI2 [OLEAUT32.234]
3533 */
3534 HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
3535 {
3536 TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
3537
3538 if( uiIn == 0 )
3539 {
3540 *pboolOut = VARIANT_FALSE;
3541 }
3542 else
3543 {
3544 *pboolOut = VARIANT_TRUE;
3545 }
3546
3547 return S_OK;
3548 }
3549
3550 /******************************************************************************
3551 * VarBoolFromUI4 [OLEAUT32.235]
3552 */
3553 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
3554 {
3555 TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
3556
3557 if( ulIn == 0 )
3558 {
3559 *pboolOut = VARIANT_FALSE;
3560 }
3561 else
3562 {
3563 *pboolOut = VARIANT_TRUE;
3564 }
3565
3566 return S_OK;
3567 }
3568
3569 /**********************************************************************
3570 * VarBoolFromCy [OLEAUT32.124]
3571 * Convert currency to boolean
3572 */
3573 HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) {
3574 if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
3575 else *pboolOut = 0;
3576
3577 return S_OK;
3578 }
3579
3580 /******************************************************************************
3581 * VarI1FromUI1 [OLEAUT32.244]
3582 */
3583 HRESULT WINAPI VarI1FromUI1(BYTE bIn, CHAR* pcOut)
3584 {
3585 TRACE("( %d, %p ), stub\n", bIn, pcOut );
3586
3587 /* Check range of value.
3588 */
3589 if( bIn > CHAR_MAX )
3590 {
3591 return DISP_E_OVERFLOW;
3592 }
3593
3594 *pcOut = (CHAR) bIn;
3595
3596 return S_OK;
3597 }
3598
3599 /******************************************************************************
3600 * VarI1FromI2 [OLEAUT32.245]
3601 */
3602 HRESULT WINAPI VarI1FromI2(short uiIn, CHAR* pcOut)
3603 {
3604 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3605
3606 if( uiIn > CHAR_MAX )
3607 {
3608 return DISP_E_OVERFLOW;
3609 }
3610
3611 *pcOut = (CHAR) uiIn;
3612
3613 return S_OK;
3614 }
3615
3616 /******************************************************************************
3617 * VarI1FromI4 [OLEAUT32.246]
3618 */
3619 HRESULT WINAPI VarI1FromI4(LONG lIn, CHAR* pcOut)
3620 {
3621 TRACE("( %ld, %p ), stub\n", lIn, pcOut );
3622
3623 if( lIn < CHAR_MIN || lIn > CHAR_MAX )
3624 {
3625 return DISP_E_OVERFLOW;
3626 }
3627
3628 *pcOut = (CHAR) lIn;
3629
3630 return S_OK;
3631 }
3632
3633 /******************************************************************************
3634 * VarI1FromR4 [OLEAUT32.247]
3635 */
3636 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, CHAR* pcOut)
3637 {
3638 TRACE("( %f, %p ), stub\n", fltIn, pcOut );
3639
3640 fltIn = round( fltIn );
3641 if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
3642 {
3643 return DISP_E_OVERFLOW;
3644 }
3645
3646 *pcOut = (CHAR) fltIn;
3647
3648 return S_OK;
3649 }
3650
3651 /******************************************************************************
3652 * VarI1FromR8 [OLEAUT32.248]
3653 */
3654 HRESULT WINAPI VarI1FromR8(double dblIn, CHAR* pcOut)
3655 {
3656 TRACE("( %f, %p ), stub\n", dblIn, pcOut );
3657
3658 dblIn = round( dblIn );
3659 if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
3660 {
3661 return DISP_E_OVERFLOW;
3662 }
3663
3664 *pcOut = (CHAR) dblIn;
3665
3666 return S_OK;
3667 }
3668
3669 /******************************************************************************
3670 * VarI1FromDate [OLEAUT32.249]
3671 */
3672 HRESULT WINAPI VarI1FromDate(DATE dateIn, CHAR* pcOut)
3673 {
3674 TRACE("( %f, %p ), stub\n", dateIn, pcOut );
3675
3676 dateIn = round( dateIn );
3677 if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
3678 {
3679 return DISP_E_OVERFLOW;
3680 }
3681
3682 *pcOut = (CHAR) dateIn;
3683
3684 return S_OK;
3685 }
3686
3687 /******************************************************************************
3688 * VarI1FromStr [OLEAUT32.251]
3689 */
3690 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CHAR* pcOut)
3691 {
3692 double dValue = 0.0;
3693 LPSTR pNewString = NULL;
3694
3695 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
3696
3697 /* Check if we have a valid argument
3698 */
3699 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3700 RemoveCharacterFromString( pNewString, "," );
3701 if( IsValidRealString( pNewString ) == FALSE )
3702 {
3703 return DISP_E_TYPEMISMATCH;
3704 }
3705
3706 /* Convert the valid string to a floating point number.
3707 */
3708 dValue = atof( pNewString );
3709
3710 /* We don't need the string anymore so free it.
3711 */
3712 HeapFree( GetProcessHeap(), 0, pNewString );
3713
3714 /* Check range of value.
3715 */
3716 dValue = round( dValue );
3717 if( dValue < CHAR_MIN || dValue > CHAR_MAX )
3718 {
3719 return DISP_E_OVERFLOW;
3720 }
3721
3722 *pcOut = (CHAR) dValue;
3723
3724 return S_OK;
3725 }
3726
3727 /******************************************************************************
3728 * VarI1FromBool [OLEAUT32.253]
3729 */
3730 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR* pcOut)
3731 {
3732 TRACE("( %d, %p ), stub\n", boolIn, pcOut );
3733
3734 *pcOut = (CHAR) boolIn;
3735
3736 return S_OK;
3737 }
3738
3739 /******************************************************************************
3740 * VarI1FromUI2 [OLEAUT32.254]
3741 */
3742 HRESULT WINAPI VarI1FromUI2(USHORT uiIn, CHAR* pcOut)
3743 {
3744 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3745
3746 if( uiIn > CHAR_MAX )
3747 {
3748 return DISP_E_OVERFLOW;
3749 }
3750
3751 *pcOut = (CHAR) uiIn;
3752
3753 return S_OK;
3754 }
3755
3756 /******************************************************************************
3757 * VarI1FromUI4 [OLEAUT32.255]
3758 */
3759 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut)
3760 {
3761 TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
3762
3763 if( ulIn > CHAR_MAX )
3764 {
3765 return DISP_E_OVERFLOW;
3766 }
3767
3768 *pcOut = (CHAR) ulIn;
3769
3770 return S_OK;
3771 }
3772
3773 /**********************************************************************
3774 * VarI1FromCy [OLEAUT32.250]
3775 * Convert currency to signed char
3776 */
3777 HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) {
3778 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3779
3780 if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
3781
3782 *pcOut = (CHAR)t;
3783 return S_OK;
3784 }
3785
3786 /******************************************************************************
3787 * VarUI2FromUI1 [OLEAUT32.257]
3788 */
3789 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
3790 {
3791 TRACE("( %d, %p ), stub\n", bIn, puiOut );
3792
3793 *puiOut = (USHORT) bIn;
3794
3795 return S_OK;
3796 }
3797
3798 /******************************************************************************
3799 * VarUI2FromI2 [OLEAUT32.258]
3800 */
3801 HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
3802 {
3803 TRACE("( %d, %p ), stub\n", uiIn, puiOut );
3804
3805 if( uiIn < UI2_MIN )
3806 {
3807 return DISP_E_OVERFLOW;
3808 }
3809
3810 *puiOut = (USHORT) uiIn;
3811
3812 return S_OK;
3813 }
3814
3815 /******************************************************************************
3816 * VarUI2FromI4 [OLEAUT32.259]
3817 */
3818 HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
3819 {
3820 TRACE("( %ld, %p ), stub\n", lIn, puiOut );
3821
3822 if( lIn < UI2_MIN || lIn > UI2_MAX )
3823 {
3824 return DISP_E_OVERFLOW;
3825 }
3826
3827 *puiOut = (USHORT) lIn;
3828
3829 return S_OK;
3830 }
3831
3832 /******************************************************************************
3833 * VarUI2FromR4 [OLEAUT32.260]
3834 */
3835 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
3836 {
3837 TRACE("( %f, %p ), stub\n", fltIn, puiOut );
3838
3839 fltIn = round( fltIn );
3840 if( fltIn < UI2_MIN || fltIn > UI2_MAX )
3841 {
3842 return DISP_E_OVERFLOW;
3843 }
3844
3845 *puiOut = (USHORT) fltIn;
3846
3847 return S_OK;
3848 }
3849
3850 /******************************************************************************
3851 * VarUI2FromR8 [OLEAUT32.261]
3852 */
3853 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
3854 {
3855 TRACE("( %f, %p ), stub\n", dblIn, puiOut );
3856
3857 dblIn = round( dblIn );
3858 if( dblIn < UI2_MIN || dblIn > UI2_MAX )
3859 {
3860 return DISP_E_OVERFLOW;
3861 }
3862
3863 *puiOut = (USHORT) dblIn;
3864
3865 return S_OK;
3866 }
3867
3868 /******************************************************************************
3869 * VarUI2FromDate [OLEAUT32.262]
3870 */
3871 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
3872 {
3873 TRACE("( %f, %p ), stub\n", dateIn, puiOut );
3874
3875 dateIn = round( dateIn );
3876 if( dateIn < UI2_MIN || dateIn > UI2_MAX )
3877 {
3878 return DISP_E_OVERFLOW;
3879 }
3880
3881 *puiOut = (USHORT) dateIn;
3882
3883 return S_OK;
3884 }
3885
3886 /******************************************************************************
3887 * VarUI2FromStr [OLEAUT32.264]
3888 */
3889 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
3890 {
3891 double dValue = 0.0;
3892 LPSTR pNewString = NULL;
3893
3894 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
3895
3896 /* Check if we have a valid argument
3897 */
3898 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3899 RemoveCharacterFromString( pNewString, "," );
3900 if( IsValidRealString( pNewString ) == FALSE )
3901 {
3902 return DISP_E_TYPEMISMATCH;
3903 }
3904
3905 /* Convert the valid string to a floating point number.
3906 */
3907 dValue = atof( pNewString );
3908
3909 /* We don't need the string anymore so free it.
3910 */
3911 HeapFree( GetProcessHeap(), 0, pNewString );
3912
3913 /* Check range of value.
3914 */
3915 dValue = round( dValue );
3916 if( dValue < UI2_MIN || dValue > UI2_MAX )
3917 {
3918 return DISP_E_OVERFLOW;
3919 }
3920
3921 *puiOut = (USHORT) dValue;
3922
3923 return S_OK;
3924 }
3925
3926 /******************************************************************************
3927 * VarUI2FromBool [OLEAUT32.266]
3928 */
3929 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
3930 {
3931 TRACE("( %d, %p ), stub\n", boolIn, puiOut );
3932
3933 *puiOut = (USHORT) boolIn;
3934
3935 return S_OK;
3936 }
3937
3938 /******************************************************************************
3939 * VarUI2FromI1 [OLEAUT32.267]
3940 */
3941 HRESULT WINAPI VarUI2FromI1(CHAR cIn, USHORT* puiOut)
3942 {
3943 TRACE("( %c, %p ), stub\n", cIn, puiOut );
3944
3945 *puiOut = (USHORT) cIn;
3946
3947 return S_OK;
3948 }
3949
3950 /******************************************************************************
3951 * VarUI2FromUI4 [OLEAUT32.268]
3952 */
3953 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
3954 {
3955 TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
3956
3957 if( ulIn < UI2_MIN || ulIn > UI2_MAX )
3958 {
3959 return DISP_E_OVERFLOW;
3960 }
3961
3962 *puiOut = (USHORT) ulIn;
3963
3964 return S_OK;
3965 }
3966
3967 /******************************************************************************
3968 * VarUI4FromStr [OLEAUT32.277]
3969 */
3970 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
3971 {
3972 double dValue = 0.0;
3973 LPSTR pNewString = NULL;
3974
3975 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
3976
3977 /* Check if we have a valid argument
3978 */
3979 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3980 RemoveCharacterFromString( pNewString, "," );
3981 if( IsValidRealString( pNewString ) == FALSE )
3982 {
3983 return DISP_E_TYPEMISMATCH;
3984 }
3985
3986 /* Convert the valid string to a floating point number.
3987 */
3988 dValue = atof( pNewString );
3989
3990 /* We don't need the string anymore so free it.
3991 */
3992 HeapFree( GetProcessHeap(), 0, pNewString );
3993
3994 /* Check range of value.
3995 */
3996 dValue = round( dValue );
3997 if( dValue < UI4_MIN || dValue > UI4_MAX )
3998 {
3999 return DISP_E_OVERFLOW;
4000 }
4001
4002 *pulOut = (ULONG) dValue;
4003
4004 return S_OK;
4005 }
4006
4007 /**********************************************************************
4008 * VarUI2FromCy [OLEAUT32.263]
4009 * Convert currency to unsigned short
4010 */
4011 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
4012 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4013
4014 if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
4015
4016 *pusOut = (USHORT)t;
4017
4018 return S_OK;
4019 }
4020
4021 /******************************************************************************
4022 * VarUI4FromUI1 [OLEAUT32.270]
4023 */
4024 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
4025 {
4026 TRACE("( %d, %p ), stub\n", bIn, pulOut );
4027
4028 *pulOut = (USHORT) bIn;
4029
4030 return S_OK;
4031 }
4032
4033 /******************************************************************************
4034 * VarUI4FromI2 [OLEAUT32.271]
4035 */
4036 HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
4037 {
4038 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4039
4040 if( uiIn < UI4_MIN )
4041 {
4042 return DISP_E_OVERFLOW;
4043 }
4044
4045 *pulOut = (ULONG) uiIn;
4046
4047 return S_OK;
4048 }
4049
4050 /******************************************************************************
4051 * VarUI4FromI4 [OLEAUT32.272]
4052 */
4053 HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
4054 {
4055 TRACE("( %ld, %p ), stub\n", lIn, pulOut );
4056
4057 if( lIn < UI4_MIN )
4058 {
4059 return DISP_E_OVERFLOW;
4060 }
4061
4062 *pulOut = (ULONG) lIn;
4063
4064 return S_OK;
4065 }
4066
4067 /******************************************************************************
4068 * VarUI4FromR4 [OLEAUT32.273]
4069 */
4070 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
4071 {
4072 fltIn = round( fltIn );
4073 if( fltIn < UI4_MIN || fltIn > UI4_MAX )
4074 {
4075 return DISP_E_OVERFLOW;
4076 }
4077
4078 *pulOut = (ULONG) fltIn;
4079
4080 return S_OK;
4081 }
4082
4083 /******************************************************************************
4084 * VarUI4FromR8 [OLEAUT32.274]
4085 */
4086 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
4087 {
4088 TRACE("( %f, %p ), stub\n", dblIn, pulOut );
4089
4090 dblIn = round( dblIn );
4091 if( dblIn < UI4_MIN || dblIn > UI4_MAX )
4092 {
4093 return DISP_E_OVERFLOW;
4094 }
4095
4096 *pulOut = (ULONG) dblIn;
4097
4098 return S_OK;
4099 }
4100
4101 /******************************************************************************
4102 * VarUI4FromDate [OLEAUT32.275]
4103 */
4104 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
4105 {
4106 TRACE("( %f, %p ), stub\n", dateIn, pulOut );
4107
4108 dateIn = round( dateIn );
4109 if( dateIn < UI4_MIN || dateIn > UI4_MAX )
4110 {
4111 return DISP_E_OVERFLOW;
4112 }
4113
4114 *pulOut = (ULONG) dateIn;
4115
4116 return S_OK;
4117 }
4118
4119 /******************************************************************************
4120 * VarUI4FromBool [OLEAUT32.279]
4121 */
4122 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
4123 {
4124 TRACE("( %d, %p ), stub\n", boolIn, pulOut );
4125
4126 *pulOut = (ULONG) boolIn;
4127
4128 return S_OK;
4129 }
4130
4131 /******************************************************************************
4132 * VarUI4FromI1 [OLEAUT32.280]
4133 */
4134 HRESULT WINAPI VarUI4FromI1(CHAR cIn, ULONG* pulOut)
4135 {
4136 TRACE("( %c, %p ), stub\n", cIn, pulOut );
4137
4138 *pulOut = (ULONG) cIn;
4139
4140 return S_OK;
4141 }
4142
4143 /******************************************************************************
4144 * VarUI4FromUI2 [OLEAUT32.281]
4145 */
4146 HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
4147 {
4148 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4149
4150 *pulOut = (ULONG) uiIn;
4151
4152 return S_OK;
4153 }
4154
4155 /**********************************************************************
4156 * VarUI4FromCy [OLEAUT32.276]
4157 * Convert currency to unsigned long
4158 */
4159 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
4160 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4161
4162 if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
4163
4164 *pulOut = (ULONG)t;
4165
4166 return S_OK;
4167 }
4168
4169 /**********************************************************************
4170 * VarCyFromUI1 [OLEAUT32.98]
4171 * Convert unsigned char to currency
4172 */
4173 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
4174 pcyOut->s.Hi = 0;
4175 pcyOut->s.Lo = ((ULONG)bIn) * 10000;
4176
4177 return S_OK;
4178 }
4179
4180 /**********************************************************************
4181 * VarCyFromI2 [OLEAUT32.99]
4182 * Convert signed short to currency
4183 */
4184 HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
4185 if (sIn < 0) pcyOut->s.Hi = -1;
4186 else pcyOut->s.Hi = 0;
4187 pcyOut->s.Lo = ((ULONG)sIn) * 10000;
4188
4189 return S_OK;
4190 }
4191
4192 /**********************************************************************
4193 * VarCyFromI4 [OLEAUT32.100]
4194 * Convert signed long to currency
4195 */
4196 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
4197 double t = (double)lIn * (double)10000;
4198 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4199 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4200 if (lIn < 0) pcyOut->s.Hi--;
4201
4202 return S_OK;
4203 }
4204
4205 /**********************************************************************
4206 * VarCyFromR4 [OLEAUT32.101]
4207 * Convert float to currency
4208 */
4209 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
4210 double t = round((double)fltIn * (double)10000);
4211 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4212 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4213 if (fltIn < 0) pcyOut->s.Hi--;
4214
4215 return S_OK;
4216 }
4217
4218 /**********************************************************************
4219 * VarCyFromR8 [OLEAUT32.102]
4220 * Convert double to currency
4221 */
4222 HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
4223 double t = round(dblIn * (double)10000);
4224 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4225 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4226 if (dblIn < 0) pcyOut->s.Hi--;
4227
4228 return S_OK;
4229 }
4230
4231 /**********************************************************************
4232 * VarCyFromDate [OLEAUT32.103]
4233 * Convert date to currency
4234 */
4235 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
4236 double t = round((double)dateIn * (double)10000);
4237 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4238 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4239 if (dateIn < 0) pcyOut->s.Hi--;
4240
4241 return S_OK;
4242 }
4243
4244 /**********************************************************************
4245 * VarCyFromStr [OLEAUT32.104]
4246 */
4247 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
4248 /* FIXME */
4249 return E_NOTIMPL;
4250 }
4251
4252
4253 /**********************************************************************
4254 * VarCyFromBool [OLEAUT32.106]
4255 * Convert boolean to currency
4256 */
4257 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
4258 if (boolIn < 0) pcyOut->s.Hi = -1;
4259 else pcyOut->s.Hi = 0;
4260 pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
4261
4262 return S_OK;
4263 }
4264
4265 /**********************************************************************
4266 * VarCyFromI1 [OLEAUT32.225]
4267 * Convert signed char to currency
4268 */
4269 HRESULT WINAPI VarCyFromI1(CHAR cIn, CY* pcyOut) {
4270 if (cIn < 0) pcyOut->s.Hi = -1;
4271 else pcyOut->s.Hi = 0;
4272 pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
4273
4274 return S_OK;
4275 }
4276
4277 /**********************************************************************
4278 * VarCyFromUI2 [OLEAUT32.226]
4279 * Convert unsigned short to currency
4280 */
4281 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
4282 pcyOut->s.Hi = 0;
4283 pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
4284
4285 return S_OK;
4286 }
4287
4288 /**********************************************************************
4289 * VarCyFromUI4 [OLEAUT32.227]
4290 * Convert unsigned long to currency
4291 */
4292 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) {
4293 double t = (double)ulIn * (double)10000;
4294 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4295 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4296
4297 return S_OK;
4298 }
4299
4300
4301 /**********************************************************************
4302 * DosDateTimeToVariantTime [OLEAUT32.14]
4303 * Convert dos representation of time to the date and time representation
4304 * stored in a variant.
4305 */
4306 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
4307 DATE *pvtime)
4308 {
4309 struct tm t;
4310
4311 TRACE("( 0x%x, 0x%x, 0x%p ), stub\n", wDosDate, wDosTime, pvtime );
4312
4313 t.tm_sec = (wDosTime & 0x001f) * 2;
4314 t.tm_min = (wDosTime & 0x07e0) >> 5;
4315 t.tm_hour = (wDosTime & 0xf800) >> 11;
4316
4317 t.tm_mday = (wDosDate & 0x001f);
4318 t.tm_mon = (wDosDate & 0x01e0) >> 5;
4319 t.tm_year = ((wDosDate & 0xfe00) >> 9) + 1980;
4320
4321 return TmToDATE( &t, pvtime );
4322 }
4323
Maarten's multimedia branch