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