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