source: trunk/src/oleaut32/variant.c@ 7916

Last change on this file since 7916 was 7916, checked in by sandervl, 24 years ago

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