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