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