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