?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Small spelling/punctuation fixes.
[wine/wine64.git] / dlls / oleaut32 / variant.c
blob4b22ee5ebbae5fe87aa72502db23c390e026edeb
1 /*
2 * VARIANT
3 *
4 * Copyright 1998 Jean-Claude Cote
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * NOTES
21 * This implements the low-level and hi-level APIs for manipulating VARIANTs.
22 * The low-level APIs are used to do data coercion between different data types.
23 * The hi-level APIs are built on top of these low-level APIs and handle
24 * initialization, copying, destroying and changing the type of VARIANTs.
25 *
26 * TODO:
27 * - The Variant APIs do not support international languages, currency
28 * types, number formating and calendar. They only support U.S. English format.
29 * - The Variant APIs do not the following types: IUknown, IDispatch, DECIMAL and SafeArray.
30 * The prototypes for these are commented out in the oleauto.h file. They need
31 * to be implemented and cases need to be added to the switches of the existing APIs.
32 * - The parsing of date for the VarDateFromStr is not complete.
33 * - The date manipulations do not support dates prior to 1900.
34 * - The parsing does not accept as many formats as the Windows implementation.
35 */
36
37 #include "config.h"
38
39 #include <string.h>
40 #include <stdlib.h>
41 #include <stdio.h>
42 #include <math.h>
43 #include <time.h>
44
45 #ifdef HAVE_FLOAT_H
46 # include <float.h>
47 #endif
48
49 #define NONAMELESSUNION
50 #define NONAMELESSSTRUCT
51 #include "windef.h"
52 #include "oleauto.h"
53 #include "heap.h"
54 #include "wine/debug.h"
55 #include "winerror.h"
56 #include "parsedt.h"
57 #include "typelib.h"
58 #include "winternl.h"
59
60 WINE_DEFAULT_DEBUG_CHANNEL(ole);
61
62 #define SYSDUPSTRING(str) SysAllocStringLen((str), SysStringLen(str))
63
64 #ifndef FLT_MAX
65 # ifdef MAXFLOAT
66 # define FLT_MAX MAXFLOAT
67 # else
68 # error "Can't find #define for MAXFLOAT/FLT_MAX"
69 # endif
70 #endif
71
72 #undef CHAR_MAX
73 #undef CHAR_MIN
74 static const char CHAR_MAX = 127;
75 static const char CHAR_MIN = -128;
76 static const BYTE UI1_MAX = 255;
77 static const BYTE UI1_MIN = 0;
78 static const unsigned short UI2_MAX = 65535;
79 static const unsigned short UI2_MIN = 0;
80 static const short I2_MAX = 32767;
81 static const short I2_MIN = -32768;
82 static const unsigned long UI4_MAX = 4294967295U;
83 static const unsigned long UI4_MIN = 0;
84 static const long I4_MAX = 2147483647;
85 static const long I4_MIN = -(2147483648U);
86 static const DATE DATE_MIN = -657434;
87 static const DATE DATE_MAX = 2958465;
88
89 /* the largest valid type
90 */
91 #define VT_MAXVALIDTYPE VT_CLSID
92
93 /* This mask is used to set a flag in wReserved1 of
94 * the VARIANTARG structure. The flag indicates if
95 * the API function is using an inner variant or not.
96 */
97 #define PROCESSING_INNER_VARIANT 0x0001
98
99 /* General use buffer.
100 */
101 #define BUFFER_MAX 1024
102 static char pBuffer[BUFFER_MAX];
103
104 /*
105 * Note a leap year is one that is a multiple of 4
106 * but not of a 100. Except if it is a multiple of
107 * 400 then it is a leap year.
108 */
109
110 /*
111 * Use 365 days/year and a manual calculation for leap year days
112 * to keep arithmetic simple
113 */
114 static const double DAYS_IN_ONE_YEAR = 365.0;
115
116 /*
117 * Token definitions for Varient Formatting
118 * Worked out by experimentation on a w2k machine. Doesnt appear to be
119 * documented anywhere obviously so keeping definitions internally
120 *
121 */
122 /* Pre defined tokens */
123 #define TOK_COPY 0x00
124 #define TOK_END 0x02
125 #define LARGEST_TOKENID 6
126
127 /* Mapping of token name to id put into the tokenized form
128 Note testing on W2K shows aaaa and oooo are not parsed??!! */
129 #define TOK_COLON 0x03
130 #define TOK_SLASH 0x04
131 #define TOK_c 0x05
132 #define TOK_d 0x08
133 #define TOK_dd 0x09
134 #define TOK_ddd 0x0a
135 #define TOK_dddd 0x0b
136 #define TOK_ddddd 0x0c
137 #define TOK_dddddd 0x0d
138 #define TOK_w 0x0f
139 #define TOK_ww 0x10
140 #define TOK_m 0x11
141 #define TOK_mm 0x12
142 #define TOK_mmm 0x13
143 #define TOK_mmmm 0x14
144 #define TOK_q 0x06
145 #define TOK_y 0x15
146 #define TOK_yy 0x16
147 #define TOK_yyyy 0x18
148 #define TOK_h 0x1e
149 #define TOK_Hh 0x1f
150 #define TOK_N 0x1a
151 #define TOK_Nn 0x1b
152 #define TOK_S 0x1c
153 #define TOK_Ss 0x1d
154 #define TOK_ttttt 0x07
155 #define TOK_AMsPM 0x2f
156 #define TOK_amspm 0x32
157 #define TOK_AsP 0x30
158 #define TOK_asp 0x33
159 #define TOK_AMPM 0x2e
160
161 typedef struct tagFORMATTOKEN {
162 char *str;
163 BYTE tokenSize;
164 BYTE tokenId;
165 int varTypeRequired;
166 } FORMATTOKEN;
167
168 typedef struct tagFORMATHDR {
169 BYTE len;
170 BYTE hex3;
171 BYTE hex6;
172 BYTE reserved[8];
173 } FORMATHDR;
174
175 FORMATTOKEN formatTokens[] = { /* FIXME: Only date formats so far */
176 {":" , 1, TOK_COLON , 0},
177 {"/" , 1, TOK_SLASH , 0},
178 {"c" , 1, TOK_c , VT_DATE},
179 {"dddddd", 6, TOK_dddddd , VT_DATE},
180 {"ddddd" , 5, TOK_ddddd , VT_DATE},
181 {"dddd" , 4, TOK_dddd , VT_DATE},
182 {"ddd" , 3, TOK_ddd , VT_DATE},
183 {"dd" , 2, TOK_dd , VT_DATE},
184 {"d" , 1, TOK_d , VT_DATE},
185 {"ww" , 2, TOK_ww , VT_DATE},
186 {"w" , 1, TOK_w , VT_DATE},
187 {"mmmm" , 4, TOK_mmmm , VT_DATE},
188 {"mmm" , 3, TOK_mmm , VT_DATE},
189 {"mm" , 2, TOK_mm , VT_DATE},
190 {"m" , 1, TOK_m , VT_DATE},
191 {"q" , 1, TOK_q , VT_DATE},
192 {"yyyy" , 4, TOK_yyyy , VT_DATE},
193 {"yy" , 2, TOK_yy , VT_DATE},
194 {"y" , 1, TOK_y , VT_DATE},
195 {"h" , 1, TOK_h , VT_DATE},
196 {"Hh" , 2, TOK_Hh , VT_DATE},
197 {"Nn" , 2, TOK_Nn , VT_DATE},
198 {"N" , 1, TOK_N , VT_DATE},
199 {"S" , 1, TOK_S , VT_DATE},
200 {"Ss" , 2, TOK_Ss , VT_DATE},
201 {"ttttt" , 5, TOK_ttttt , VT_DATE},
202 {"AM/PM" , 5, TOK_AMsPM , VT_DATE},
203 {"am/pm" , 5, TOK_amspm , VT_DATE},
204 {"A/P" , 3, TOK_AsP , VT_DATE},
205 {"a/p" , 3, TOK_asp , VT_DATE},
206 {"AMPM" , 4, TOK_AMPM , VT_DATE},
207 {0x00 , 0, 0 , VT_NULL}
208 };
209
210 /******************************************************************************
211 * DateTimeStringToTm [INTERNAL]
212 *
213 * Converts a string representation of a date and/or time to a tm structure.
214 *
215 * Note this function uses the postgresql date parsing functions found
216 * in the parsedt.c file.
217 *
218 * Returns TRUE if successful.
219 *
220 * Note: This function does not parse the day of the week,
221 * daylight savings time. It will only fill the followin fields in
222 * the tm struct, tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
223 *
224 ******************************************************************************/
225 static BOOL DateTimeStringToTm( OLECHAR* strIn, DWORD dwFlags, struct tm* pTm )
226 {
227 BOOL res = FALSE;
228 double fsec;
229 int tzp;
230 int dtype;
231 int nf;
232 char *field[MAXDATEFIELDS];
233 int ftype[MAXDATEFIELDS];
234 char lowstr[MAXDATELEN + 1];
235 char* strDateTime = NULL;
236
237 /* Convert the string to ASCII since this is the only format
238 * postgesql can handle.
239 */
240 strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
241
242 if( strDateTime != NULL )
243 {
244 /* Make sure we don't go over the maximum length
245 * accepted by postgesql.
246 */
247 if( strlen( strDateTime ) <= MAXDATELEN )
248 {
249 if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
250 {
251 if( dwFlags & VAR_DATEVALUEONLY )
252 {
253 /* Get the date information.
254 * It returns 0 if date information was
255 * present and 1 if only time information was present.
256 * -1 if an error occures.
257 */
258 if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
259 {
260 /* Eliminate the time information since we
261 * were asked to get date information only.
262 */
263 pTm->tm_sec = 0;
264 pTm->tm_min = 0;
265 pTm->tm_hour = 0;
266 res = TRUE;
267 }
268 }
269 if( dwFlags & VAR_TIMEVALUEONLY )
270 {
271 /* Get time information only.
272 */
273 if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
274 {
275 res = TRUE;
276 }
277 }
278 else
279 {
280 /* Get both date and time information.
281 * It returns 0 if date information was
282 * present and 1 if only time information was present.
283 * -1 if an error occures.
284 */
285 if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
286 {
287 res = TRUE;
288 }
289 }
290 }
291 }
292 HeapFree( GetProcessHeap(), 0, strDateTime );
293 }
294
295 return res;
296 }
297
298
299
300
301
302
303 /******************************************************************************
304 * TmToDATE [INTERNAL]
305 *
306 * The date is implemented using an 8 byte floating-point number.
307 * Days are represented by whole numbers increments starting with 0.00 has
308 * being December 30 1899, midnight.
309 * The hours are expressed as the fractional part of the number.
310 * December 30 1899 at midnight = 0.00
311 * January 1 1900 at midnight = 2.00
312 * January 4 1900 at 6 AM = 5.25
313 * January 4 1900 at noon = 5.50
314 * December 29 1899 at midnight = -1.00
315 * December 18 1899 at midnight = -12.00
316 * December 18 1899 at 6AM = -12.25
317 * December 18 1899 at 6PM = -12.75
318 * December 19 1899 at midnight = -11.00
319 * The tm structure is as follows:
320 * struct tm {
321 * int tm_sec; seconds after the minute - [0,59]
322 * int tm_min; minutes after the hour - [0,59]
323 * int tm_hour; hours since midnight - [0,23]
324 * int tm_mday; day of the month - [1,31]
325 * int tm_mon; months since January - [0,11]
326 * int tm_year; years
327 * int tm_wday; days since Sunday - [0,6]
328 * int tm_yday; days since January 1 - [0,365]
329 * int tm_isdst; daylight savings time flag
330 * };
331 *
332 * Note: This function does not use the tm_wday, tm_yday, tm_wday,
333 * and tm_isdst fields of the tm structure. And only converts years
334 * after 1900.
335 *
336 * Returns TRUE if successful.
337 */
338 static BOOL TmToDATE( struct tm* pTm, DATE *pDateOut )
339 {
340 int leapYear = 0;
341
342 /* Hmmm... An uninitialized Date in VB is December 30 1899 so
343 Start at 0. This is the way DATE is defined. */
344
345 /* Start at 1. This is the way DATE is defined.
346 * January 1, 1900 at Midnight is 1.00.
347 * January 1, 1900 at 6AM is 1.25.
348 * and so on.
349 */
350 *pDateOut = 1;
351
352 if( (pTm->tm_year - 1900) >= 0 ) {
353
354 /* Add the number of days corresponding to
355 * tm_year.
356 */
357 *pDateOut += (pTm->tm_year - 1900) * 365;
358
359 /* Add the leap days in the previous years between now and 1900.
360 * Note a leap year is one that is a multiple of 4
361 * but not of a 100. Except if it is a multiple of
362 * 400 then it is a leap year.
363 * Copied + reversed functionality into TmToDate
364 */
365 *pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
366 *pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
367 *pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
368
369 /* Set the leap year flag if the
370 * current year specified by tm_year is a
371 * leap year. This will be used to add a day
372 * to the day count.
373 */
374 if( isleap( pTm->tm_year ) )
375 leapYear = 1;
376
377 /* Add the number of days corresponding to
378 * the month. (remember tm_mon is 0..11)
379 */
380 switch( pTm->tm_mon )
381 {
382 case 1:
383 *pDateOut += 31;
384 break;
385 case 2:
386 *pDateOut += ( 59 + leapYear );
387 break;
388 case 3:
389 *pDateOut += ( 90 + leapYear );
390 break;
391 case 4:
392 *pDateOut += ( 120 + leapYear );
393 break;
394 case 5:
395 *pDateOut += ( 151 + leapYear );
396 break;
397 case 6:
398 *pDateOut += ( 181 + leapYear );
399 break;
400 case 7:
401 *pDateOut += ( 212 + leapYear );
402 break;
403 case 8:
404 *pDateOut += ( 243 + leapYear );
405 break;
406 case 9:
407 *pDateOut += ( 273 + leapYear );
408 break;
409 case 10:
410 *pDateOut += ( 304 + leapYear );
411 break;
412 case 11:
413 *pDateOut += ( 334 + leapYear );
414 break;
415 }
416 /* Add the number of days in this month.
417 */
418 *pDateOut += pTm->tm_mday;
419
420 /* Add the number of seconds, minutes, and hours
421 * to the DATE. Note these are the fractional part
422 * of the DATE so seconds / number of seconds in a day.
423 */
424 } else {
425 *pDateOut = 0;
426 }
427
428 *pDateOut += pTm->tm_hour / 24.0;
429 *pDateOut += pTm->tm_min / 1440.0;
430 *pDateOut += pTm->tm_sec / 86400.0;
431 return TRUE;
432 }
433
434 /******************************************************************************
435 * DateToTm [INTERNAL]
436 *
437 * This function converts a windows DATE to a tm structure.
438 *
439 * It does not fill all the fields of the tm structure.
440 * Here is a list of the fields that are filled:
441 * tm_sec, tm_min, tm_hour, tm_year, tm_day, tm_mon.
442 *
443 * Note this function does not support dates before the January 1, 1900
444 * or ( dateIn < 2.0 ).
445 *
446 * Returns TRUE if successful.
447 */
448 BOOL DateToTm( DATE dateIn, DWORD dwFlags, struct tm* pTm )
449 {
450 double decimalPart = 0.0;
451 double wholePart = 0.0;
452
453 memset(pTm,0,sizeof(*pTm));
454
455 /* Because of the nature of DATE format which
456 * associates 2.0 to January 1, 1900. We will
457 * remove 1.0 from the whole part of the DATE
458 * so that in the following code 1.0
459 * will correspond to January 1, 1900.
460 * This simplifies the processing of the DATE value.
461 */
462 decimalPart = fmod( dateIn, 1.0 ); /* Do this before the -1, otherwise 0.xx goes negative */
463 dateIn -= 1.0;
464 wholePart = (double) floor( dateIn );
465
466 if( !(dwFlags & VAR_TIMEVALUEONLY) )
467 {
468 unsigned int nDay = 0;
469 int leapYear = 0;
470 double yearsSince1900 = 0;
471
472 /* Hard code dates smaller than January 1, 1900. */
473 if( dateIn < 2.0 ) {
474 pTm->tm_year = 1899;
475 pTm->tm_mon = 11; /* December as tm_mon is 0..11 */
476 if( dateIn < 1.0 ) {
477 pTm->tm_mday = 30;
478 dateIn = dateIn * -1.0; /* Ensure +ve for time calculation */
479 decimalPart = decimalPart * -1.0; /* Ensure +ve for time calculation */
480 } else {
481 pTm->tm_mday = 31;
482 }
483
484 } else {
485
486 /* Start at 1900, this is where the DATE time 0.0 starts.
487 */
488 pTm->tm_year = 1900;
489 /* find in what year the day in the "wholePart" falls into.
490 * add the value to the year field.
491 */
492 yearsSince1900 = floor( (wholePart / DAYS_IN_ONE_YEAR) + 0.001 );
493 pTm->tm_year += yearsSince1900;
494 /* determine if this is a leap year.
495 */
496 if( isleap( pTm->tm_year ) )
497 {
498 leapYear = 1;
499 wholePart++;
500 }
501
502 /* find what day of that year the "wholePart" corresponds to.
503 * Note: nDay is in [1-366] format
504 */
505 nDay = (((unsigned int) wholePart) - ((pTm->tm_year-1900) * DAYS_IN_ONE_YEAR ));
506
507 /* Remove the leap days in the previous years between now and 1900.
508 * Note a leap year is one that is a multiple of 4
509 * but not of a 100. Except if it is a multiple of
510 * 400 then it is a leap year.
511 * Copied + reversed functionality from TmToDate
512 */
513 nDay -= ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
514 nDay += ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
515 nDay -= ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
516
517 /* Set the tm_yday value.
518 * Note: The day must be converted from [1-366] to [0-365]
519 */
520 /*pTm->tm_yday = nDay - 1;*/
521 /* find which month this day corresponds to.
522 */
523 if( nDay <= 31 )
524 {
525 pTm->tm_mday = nDay;
526 pTm->tm_mon = 0;
527 }
528 else if( nDay <= ( 59 + leapYear ) )
529 {
530 pTm->tm_mday = nDay - 31;
531 pTm->tm_mon = 1;
532 }
533 else if( nDay <= ( 90 + leapYear ) )
534 {
535 pTm->tm_mday = nDay - ( 59 + leapYear );
536 pTm->tm_mon = 2;
537 }
538 else if( nDay <= ( 120 + leapYear ) )
539 {
540 pTm->tm_mday = nDay - ( 90 + leapYear );
541 pTm->tm_mon = 3;
542 }
543 else if( nDay <= ( 151 + leapYear ) )
544 {
545 pTm->tm_mday = nDay - ( 120 + leapYear );
546 pTm->tm_mon = 4;
547 }
548 else if( nDay <= ( 181 + leapYear ) )
549 {
550 pTm->tm_mday = nDay - ( 151 + leapYear );
551 pTm->tm_mon = 5;
552 }
553 else if( nDay <= ( 212 + leapYear ) )
554 {
555 pTm->tm_mday = nDay - ( 181 + leapYear );
556 pTm->tm_mon = 6;
557 }
558 else if( nDay <= ( 243 + leapYear ) )
559 {
560 pTm->tm_mday = nDay - ( 212 + leapYear );
561 pTm->tm_mon = 7;
562 }
563 else if( nDay <= ( 273 + leapYear ) )
564 {
565 pTm->tm_mday = nDay - ( 243 + leapYear );
566 pTm->tm_mon = 8;
567 }
568 else if( nDay <= ( 304 + leapYear ) )
569 {
570 pTm->tm_mday = nDay - ( 273 + leapYear );
571 pTm->tm_mon = 9;
572 }
573 else if( nDay <= ( 334 + leapYear ) )
574 {
575 pTm->tm_mday = nDay - ( 304 + leapYear );
576 pTm->tm_mon = 10;
577 }
578 else if( nDay <= ( 365 + leapYear ) )
579 {
580 pTm->tm_mday = nDay - ( 334 + leapYear );
581 pTm->tm_mon = 11;
582 }
583 }
584 }
585 if( !(dwFlags & VAR_DATEVALUEONLY) )
586 {
587 /* find the number of seconds in this day.
588 * fractional part times, hours, minutes, seconds.
589 * Note: 0.1 is hack to ensure figures come out in whole numbers
590 * due to floating point inaccuracies
591 */
592 pTm->tm_hour = (int) ( decimalPart * 24 );
593 pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
594 /* Note: 0.1 is hack to ensure seconds come out in whole numbers
595 due to floating point inaccuracies */
596 pTm->tm_sec = (int) (( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 ) + 0.1);
597 }
598 return TRUE;
599 }
600
601
602
603 /******************************************************************************
604 * SizeOfVariantData [INTERNAL]
605 *
606 * This function finds the size of the data referenced by a Variant based
607 * the type "vt" of the Variant.
608 */
609 static int SizeOfVariantData( VARIANT* parg )
610 {
611 int size = 0;
612 switch( V_VT(parg) & VT_TYPEMASK )
613 {
614 case( VT_I2 ):
615 size = sizeof(short);
616 break;
617 case( VT_INT ):
618 size = sizeof(int);
619 break;
620 case( VT_I4 ):
621 size = sizeof(long);
622 break;
623 case( VT_UI1 ):
624 size = sizeof(BYTE);
625 break;
626 case( VT_UI2 ):
627 size = sizeof(unsigned short);
628 break;
629 case( VT_UINT ):
630 size = sizeof(unsigned int);
631 break;
632 case( VT_UI4 ):
633 size = sizeof(unsigned long);
634 break;
635 case( VT_R4 ):
636 size = sizeof(float);
637 break;
638 case( VT_R8 ):
639 size = sizeof(double);
640 break;
641 case( VT_DATE ):
642 size = sizeof(DATE);
643 break;
644 case( VT_BOOL ):
645 size = sizeof(VARIANT_BOOL);
646 break;
647 case( VT_BSTR ):
648 case( VT_DISPATCH ):
649 case( VT_UNKNOWN ):
650 size = sizeof(void*);
651 break;
652 case( VT_CY ):
653 size = sizeof(CY);
654 break;
655 case( VT_DECIMAL ): /* hmm, tricky, DECIMAL is only VT_BYREF */
656 default:
657 FIXME("Add size information for type vt=%d\n", V_VT(parg) & VT_TYPEMASK );
658 break;
659 }
660
661 return size;
662 }
663 /******************************************************************************
664 * StringDupAtoBstr [INTERNAL]
665 *
666 */
667 static BSTR StringDupAtoBstr( char* strIn )
668 {
669 BSTR bstr = NULL;
670 OLECHAR* pNewString = NULL;
671 UNICODE_STRING usBuffer;
672
673 RtlCreateUnicodeStringFromAsciiz( &usBuffer, strIn );
674 pNewString = usBuffer.Buffer;
675
676 bstr = SysAllocString( pNewString );
677 RtlFreeUnicodeString( &usBuffer );
678 return bstr;
679 }
680
681 /******************************************************************************
682 * round [INTERNAL]
683 *
684 * Round the double value to the nearest integer value.
685 */
686 static double round( double d )
687 {
688 double decimals = 0.0, integerValue = 0.0, roundedValue = 0.0;
689 BOOL bEvenNumber = FALSE;
690 int nSign = 0;
691
692 /* Save the sign of the number
693 */
694 nSign = (d >= 0.0) ? 1 : -1;
695 d = fabs( d );
696
697 /* Remove the decimals.
698 */
699 integerValue = floor( d );
700
701 /* Set the Even flag. This is used to round the number when
702 * the decimals are exactly 1/2. If the integer part is
703 * odd the number is rounded up. If the integer part
704 * is even the number is rounded down. Using this method
705 * numbers are rounded up|down half the time.
706 */
707 bEvenNumber = (((short)fmod(integerValue, 2)) == 0) ? TRUE : FALSE;
708
709 /* Remove the integral part of the number.
710 */
711 decimals = d - integerValue;
712
713 /* Note: Ceil returns the smallest integer that is greater that x.
714 * and floor returns the largest integer that is less than or equal to x.
715 */
716 if( decimals > 0.5 )
717 {
718 /* If the decimal part is greater than 1/2
719 */
720 roundedValue = ceil( d );
721 }
722 else if( decimals < 0.5 )
723 {
724 /* If the decimal part is smaller than 1/2
725 */
726 roundedValue = floor( d );
727 }
728 else
729 {
730 /* the decimals are exactly 1/2 so round according to
731 * the bEvenNumber flag.
732 */
733 if( bEvenNumber )
734 {
735 roundedValue = floor( d );
736 }
737 else
738 {
739 roundedValue = ceil( d );
740 }
741 }
742
743 return roundedValue * nSign;
744 }
745
746 /******************************************************************************
747 * RemoveCharacterFromString [INTERNAL]
748 *
749 * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
750 */
751 static void RemoveCharacterFromString( LPSTR str, LPSTR strOfCharToRemove )
752 {
753 LPSTR pNewString = NULL;
754 LPSTR strToken = NULL;
755
756 /* Check if we have a valid argument
757 */
758 if( str != NULL )
759 {
760 pNewString = strdup( str );
761 str[0] = '\0';
762 strToken = strtok( pNewString, strOfCharToRemove );
763 while( strToken != NULL ) {
764 strcat( str, strToken );
765 strToken = strtok( NULL, strOfCharToRemove );
766 }
767 free( pNewString );
768 }
769 return;
770 }
771
772 /******************************************************************************
773 * GetValidRealString [INTERNAL]
774 *
775 * Checks if the string is of proper format to be converted to a real value.
776 */
777 static BOOL IsValidRealString( LPSTR strRealString )
778 {
779 /* Real values that have a decimal point are required to either have
780 * digits before or after the decimal point. We will assume that
781 * we do not have any digits at either position. If we do encounter
782 * some we will disable this flag.
783 */
784 BOOL bDigitsRequired = TRUE;
785 /* Processed fields in the string representation of the real number.
786 */
787 BOOL bWhiteSpaceProcessed = FALSE;
788 BOOL bFirstSignProcessed = FALSE;
789 BOOL bFirstDigitsProcessed = FALSE;
790 BOOL bDecimalPointProcessed = FALSE;
791 BOOL bSecondDigitsProcessed = FALSE;
792 BOOL bExponentProcessed = FALSE;
793 BOOL bSecondSignProcessed = FALSE;
794 BOOL bThirdDigitsProcessed = FALSE;
795 /* Assume string parameter "strRealString" is valid and try to disprove it.
796 */
797 BOOL bValidRealString = TRUE;
798
799 /* Used to count the number of tokens in the "strRealString".
800 */
801 LPSTR strToken = NULL;
802 int nTokens = 0;
803 LPSTR pChar = NULL;
804
805 /* Check if we have a valid argument
806 */
807 if( strRealString == NULL )
808 {
809 bValidRealString = FALSE;
810 }
811
812 if( bValidRealString == TRUE )
813 {
814 /* Make sure we only have ONE token in the string.
815 */
816 strToken = strtok( strRealString, " " );
817 while( strToken != NULL ) {
818 nTokens++;
819 strToken = strtok( NULL, " " );
820 }
821
822 if( nTokens != 1 )
823 {
824 bValidRealString = FALSE;
825 }
826 }
827
828
829 /* Make sure this token contains only valid characters.
830 * The string argument to atof has the following form:
831 * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
832 * Whitespace consists of space and|or <TAB> characters, which are ignored.
833 * Sign is either plus '+' or minus '-'.
834 * Digits are one or more decimal digits.
835 * Note: If no digits appear before the decimal point, at least one must
836 * appear after the decimal point.
837 * The decimal digits may be followed by an exponent.
838 * An Exponent consists of an introductory letter ( D, d, E, or e) and
839 * an optionally signed decimal integer.
840 */
841 pChar = strRealString;
842 while( bValidRealString == TRUE && *pChar != '\0' )
843 {
844 switch( *pChar )
845 {
846 /* If whitespace...
847 */
848 case ' ':
849 case '\t':
850 if( bWhiteSpaceProcessed ||
851 bFirstSignProcessed ||
852 bFirstDigitsProcessed ||
853 bDecimalPointProcessed ||
854 bSecondDigitsProcessed ||
855 bExponentProcessed ||
856 bSecondSignProcessed ||
857 bThirdDigitsProcessed )
858 {
859 bValidRealString = FALSE;
860 }
861 break;
862 /* If sign...
863 */
864 case '+':
865 case '-':
866 if( bFirstSignProcessed == FALSE )
867 {
868 if( bFirstDigitsProcessed ||
869 bDecimalPointProcessed ||
870 bSecondDigitsProcessed ||
871 bExponentProcessed ||
872 bSecondSignProcessed ||
873 bThirdDigitsProcessed )
874 {
875 bValidRealString = FALSE;
876 }
877 bWhiteSpaceProcessed = TRUE;
878 bFirstSignProcessed = TRUE;
879 }
880 else if( bSecondSignProcessed == FALSE )
881 {
882 /* Note: The exponent must be present in
883 * order to accept the second sign...
884 */
885 if( bExponentProcessed == FALSE ||
886 bThirdDigitsProcessed ||
887 bDigitsRequired )
888 {
889 bValidRealString = FALSE;
890 }
891 bFirstSignProcessed = TRUE;
892 bWhiteSpaceProcessed = TRUE;
893 bFirstDigitsProcessed = TRUE;
894 bDecimalPointProcessed = TRUE;
895 bSecondDigitsProcessed = TRUE;
896 bSecondSignProcessed = TRUE;
897 }
898 break;
899
900 /* If decimals...
901 */
902 case '0':
903 case '1':
904 case '2':
905 case '3':
906 case '4':
907 case '5':
908 case '6':
909 case '7':
910 case '8':
911 case '9':
912 if( bFirstDigitsProcessed == FALSE )
913 {
914 if( bDecimalPointProcessed ||
915 bSecondDigitsProcessed ||
916 bExponentProcessed ||
917 bSecondSignProcessed ||
918 bThirdDigitsProcessed )
919 {
920 bValidRealString = FALSE;
921 }
922 bFirstSignProcessed = TRUE;
923 bWhiteSpaceProcessed = TRUE;
924 /* We have found some digits before the decimal point
925 * so disable the "Digits required" flag.
926 */
927 bDigitsRequired = FALSE;
928 }
929 else if( bSecondDigitsProcessed == FALSE )
930 {
931 if( bExponentProcessed ||
932 bSecondSignProcessed ||
933 bThirdDigitsProcessed )
934 {
935 bValidRealString = FALSE;
936 }
937 bFirstSignProcessed = TRUE;
938 bWhiteSpaceProcessed = TRUE;
939 bFirstDigitsProcessed = TRUE;
940 bDecimalPointProcessed = TRUE;
941 /* We have found some digits after the decimal point
942 * so disable the "Digits required" flag.
943 */
944 bDigitsRequired = FALSE;
945 }
946 else if( bThirdDigitsProcessed == FALSE )
947 {
948 /* Getting here means everything else should be processed.
949 * If we get anything else than a decimal following this
950 * digit it will be flagged by the other cases, so
951 * we do not really need to do anything in here.
952 */
953 }
954 break;
955 /* If DecimalPoint...
956 */
957 case '.':
958 if( bDecimalPointProcessed ||
959 bSecondDigitsProcessed ||
960 bExponentProcessed ||
961 bSecondSignProcessed ||
962 bThirdDigitsProcessed )
963 {
964 bValidRealString = FALSE;
965 }
966 bFirstSignProcessed = TRUE;
967 bWhiteSpaceProcessed = TRUE;
968 bFirstDigitsProcessed = TRUE;
969 bDecimalPointProcessed = TRUE;
970 break;
971 /* If Exponent...
972 */
973 case 'e':
974 case 'E':
975 case 'd':
976 case 'D':
977 if( bExponentProcessed ||
978 bSecondSignProcessed ||
979 bThirdDigitsProcessed ||
980 bDigitsRequired )
981 {
982 bValidRealString = FALSE;
983 }
984 bFirstSignProcessed = TRUE;
985 bWhiteSpaceProcessed = TRUE;
986 bFirstDigitsProcessed = TRUE;
987 bDecimalPointProcessed = TRUE;
988 bSecondDigitsProcessed = TRUE;
989 bExponentProcessed = TRUE;
990 break;
991 default:
992 bValidRealString = FALSE;
993 break;
994 }
995 /* Process next character.
996 */
997 pChar++;
998 }
999
1000 /* If the required digits were not present we have an invalid
1001 * string representation of a real number.
1002 */
1003 if( bDigitsRequired == TRUE )
1004 {
1005 bValidRealString = FALSE;
1006 }
1007
1008 return bValidRealString;
1009 }
1010
1011
1012 /******************************************************************************
1013 * Coerce [INTERNAL]
1014 *
1015 * This function dispatches execution to the proper conversion API
1016 * to do the necessary coercion.
1017 *
1018 * FIXME: Passing down dwFlags to the conversion functions is wrong, this
1019 * is a different flagmask. Check MSDN.
1020 */
1021 static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt )
1022 {
1023 HRESULT res = S_OK;
1024 unsigned short vtFrom = 0;
1025 vtFrom = V_VT(ps) & VT_TYPEMASK;
1026
1027
1028 /* Note: Since "long" and "int" values both have 4 bytes and are
1029 * both signed integers "int" will be treated as "long" in the
1030 * following code.
1031 * The same goes for their unsigned versions.
1032 */
1033
1034 /* Trivial Case: If the coercion is from two types that are
1035 * identical then we can blindly copy from one argument to another.*/
1036 if ((vt==vtFrom))
1037 return VariantCopy(pd,ps);
1038
1039 /* Cases requiring thought*/
1040 switch( vt )
1041 {
1042
1043 case( VT_EMPTY ):
1044 res = VariantClear( pd );
1045 break;
1046 case( VT_NULL ):
1047 res = VariantClear( pd );
1048 if( res == S_OK )
1049 {
1050 V_VT(pd) = VT_NULL;
1051 }
1052 break;
1053 case( VT_I1 ):
1054 switch( vtFrom )
1055 {
1056 case( VT_I2 ):
1057 res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) );
1058 break;
1059 case( VT_INT ):
1060 case( VT_I4 ):
1061 res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) );
1062 break;
1063 case( VT_UI1 ):
1064 res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) );
1065 break;
1066 case( VT_UI2 ):
1067 res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) );
1068 break;
1069 case( VT_UINT ):
1070 case( VT_UI4 ):
1071 res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) );
1072 break;
1073 case( VT_R4 ):
1074 res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) );
1075 break;
1076 case( VT_R8 ):
1077 res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) );
1078 break;
1079 case( VT_DATE ):
1080 res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) );
1081 break;
1082 case( VT_BOOL ):
1083 res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) );
1084 break;
1085 case( VT_BSTR ):
1086 res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) );
1087 break;
1088 case( VT_CY ):
1089 res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) );
1090 break;
1091 case( VT_DISPATCH ):
1092 /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/
1093 case( VT_DECIMAL ):
1094 /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/
1095 case( VT_UNKNOWN ):
1096 default:
1097 res = DISP_E_TYPEMISMATCH;
1098 FIXME("Coercion from %d to VT_I1\n", vtFrom );
1099 break;
1100 }
1101 break;
1102
1103 case( VT_I2 ):
1104 switch( vtFrom )
1105 {
1106 case( VT_I1 ):
1107 res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) );
1108 break;
1109 case( VT_INT ):
1110 case( VT_I4 ):
1111 res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) );
1112 break;
1113 case( VT_UI1 ):
1114 res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) );
1115 break;
1116 case( VT_UI2 ):
1117 res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) );
1118 break;
1119 case( VT_UINT ):
1120 case( VT_UI4 ):
1121 res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) );
1122 break;
1123 case( VT_R4 ):
1124 res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) );
1125 break;
1126 case( VT_R8 ):
1127 res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) );
1128 break;
1129 case( VT_DATE ):
1130 res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) );
1131 break;
1132 case( VT_BOOL ):
1133 res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) );
1134 break;
1135 case( VT_BSTR ):
1136 res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) );
1137 break;
1138 case( VT_CY ):
1139 res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) );
1140 break;
1141 case( VT_DISPATCH ):
1142 /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/
1143 case( VT_DECIMAL ):
1144 /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/
1145 case( VT_UNKNOWN ):
1146 default:
1147 res = DISP_E_TYPEMISMATCH;
1148 FIXME("Coercion from %d to VT_I2\n", vtFrom);
1149 break;
1150 }
1151 break;
1152
1153 case( VT_INT ):
1154 case( VT_I4 ):
1155 switch( vtFrom )
1156 {
1157 case( VT_EMPTY ):
1158 V_UNION(pd,lVal) = 0;
1159 res = S_OK;
1160 break;
1161 case( VT_I1 ):
1162 res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) );
1163 break;
1164 case( VT_I2 ):
1165 res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) );
1166
1167 break;
1168 case( VT_ERROR ):
1169 V_UNION(pd,lVal) = V_UNION(pd,scode);
1170 res = S_OK;
1171 break;
1172 case( VT_INT ):
1173 case( VT_I4 ):
1174 res = VariantCopy( pd, ps );
1175 break;
1176 case( VT_UI1 ):
1177 res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) );
1178 break;
1179 case( VT_UI2 ):
1180 res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) );
1181 break;
1182 case( VT_UINT ):
1183 case( VT_UI4 ):
1184 res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) );
1185 break;
1186 case( VT_R4 ):
1187 res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) );
1188 break;
1189 case( VT_R8 ):
1190 res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) );
1191 break;
1192 case( VT_DATE ):
1193 res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) );
1194 break;
1195 case( VT_BOOL ):
1196 res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) );
1197 break;
1198 case( VT_BSTR ):
1199 res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) );
1200 break;
1201 case( VT_CY ):
1202 res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) );
1203 break;
1204 case( VT_DISPATCH ):
1205 /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/
1206 case( VT_DECIMAL ):
1207 /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/
1208 case( VT_UNKNOWN ):
1209 default:
1210 res = DISP_E_TYPEMISMATCH;
1211 FIXME("Coercion from %d to VT_INT/VT_I4\n", vtFrom);
1212 break;
1213 }
1214 break;
1215
1216 case( VT_UI1 ):
1217 switch( vtFrom )
1218 {
1219 case( VT_I1 ):
1220 res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) );
1221 break;
1222 case( VT_I2 ):
1223 res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) );
1224 break;
1225 case( VT_INT ):
1226 case( VT_I4 ):
1227 res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) );
1228 break;
1229 case( VT_UI1 ):
1230 res = VariantCopy( pd, ps );
1231 break;
1232 case( VT_UI2 ):
1233 res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) );
1234 break;
1235 case( VT_UINT ):
1236 case( VT_UI4 ):
1237 res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) );
1238 break;
1239 case( VT_R4 ):
1240 res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) );
1241 break;
1242 case( VT_R8 ):
1243 res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) );
1244 break;
1245 case( VT_DATE ):
1246 res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) );
1247 break;
1248 case( VT_BOOL ):
1249 res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) );
1250 break;
1251 case( VT_BSTR ):
1252 res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) );
1253 break;
1254 case( VT_CY ):
1255 res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) );
1256 break;
1257 case( VT_DISPATCH ):
1258 /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/
1259 case( VT_DECIMAL ):
1260 /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/
1261 case( VT_UNKNOWN ):
1262 default:
1263 res = DISP_E_TYPEMISMATCH;
1264 FIXME("Coercion from %d to VT_UI1\n", vtFrom);
1265 break;
1266 }
1267 break;
1268
1269 case( VT_UI2 ):
1270 switch( vtFrom )
1271 {
1272 case( VT_I1 ):
1273 res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) );
1274 break;
1275 case( VT_I2 ):
1276 res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) );
1277 break;
1278 case( VT_INT ):
1279 case( VT_I4 ):
1280 res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) );
1281 break;
1282 case( VT_UI1 ):
1283 res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) );
1284 break;
1285 case( VT_UI2 ):
1286 res = VariantCopy( pd, ps );
1287 break;
1288 case( VT_UINT ):
1289 case( VT_UI4 ):
1290 res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) );
1291 break;
1292 case( VT_R4 ):
1293 res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) );
1294 break;
1295 case( VT_R8 ):
1296 res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) );
1297 break;
1298 case( VT_DATE ):
1299 res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) );
1300 break;
1301 case( VT_BOOL ):
1302 res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) );
1303 break;
1304 case( VT_BSTR ):
1305 res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) );
1306 break;
1307 case( VT_CY ):
1308 res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) );
1309 break;
1310 case( VT_DISPATCH ):
1311 /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/
1312 case( VT_DECIMAL ):
1313 /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/
1314 case( VT_UNKNOWN ):
1315 default:
1316 res = DISP_E_TYPEMISMATCH;
1317 FIXME("Coercion from %d to VT_UI2\n", vtFrom);
1318 break;
1319 }
1320 break;
1321
1322 case( VT_UINT ):
1323 case( VT_UI4 ):
1324 switch( vtFrom )
1325 {
1326 case( VT_I1 ):
1327 res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) );
1328 break;
1329 case( VT_I2 ):
1330 res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) );
1331 break;
1332 case( VT_INT ):
1333 case( VT_I4 ):
1334 res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) );
1335 break;
1336 case( VT_UI1 ):
1337 res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) );
1338 break;
1339 case( VT_UI2 ):
1340 res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) );
1341 break;
1342 case( VT_UI4 ):
1343 res = VariantCopy( pd, ps );
1344 break;
1345 case( VT_R4 ):
1346 res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) );
1347 break;
1348 case( VT_R8 ):
1349 res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) );
1350 break;
1351 case( VT_DATE ):
1352 res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) );
1353 break;
1354 case( VT_BOOL ):
1355 res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) );
1356 break;
1357 case( VT_BSTR ):
1358 res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) );
1359 break;
1360 case( VT_CY ):
1361 res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) );
1362 break;
1363 case( VT_DISPATCH ):
1364 /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/
1365 case( VT_DECIMAL ):
1366 /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/
1367 case( VT_UNKNOWN ):
1368 default:
1369 res = DISP_E_TYPEMISMATCH;
1370 FIXME("Coercion from %d to VT_UINT/VT_UI4\n", vtFrom);
1371 break;
1372 }
1373 break;
1374
1375 case( VT_R4 ):
1376 switch( vtFrom )
1377 {
1378 case( VT_I1 ):
1379 res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) );
1380 break;
1381 case( VT_I2 ):
1382 res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) );
1383 break;
1384 case( VT_INT ):
1385 case( VT_I4 ):
1386 res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) );
1387 break;
1388 case( VT_UI1 ):
1389 res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) );
1390 break;
1391 case( VT_UI2 ):
1392 res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) );
1393 break;
1394 case( VT_UINT ):
1395 case( VT_UI4 ):
1396 res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) );
1397 break;
1398 case( VT_R4 ):
1399 res = VariantCopy( pd, ps );
1400 break;
1401 case( VT_R8 ):
1402 res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) );
1403 break;
1404 case( VT_DATE ):
1405 res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) );
1406 break;
1407 case( VT_BOOL ):
1408 res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) );
1409 break;
1410 case( VT_BSTR ):
1411 res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) );
1412 break;
1413 case( VT_CY ):
1414 res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) );
1415 break;
1416 case( VT_ERROR ):
1417 V_UNION(pd,fltVal) = V_UNION(ps,scode);
1418 res = S_OK;
1419 break;
1420 case( VT_DISPATCH ):
1421 /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/
1422 case( VT_DECIMAL ):
1423 /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/
1424 case( VT_UNKNOWN ):
1425 default:
1426 res = DISP_E_TYPEMISMATCH;
1427 FIXME("Coercion from %d to VT_R4\n", vtFrom);
1428 break;
1429 }
1430 break;
1431
1432 case( VT_R8 ):
1433 switch( vtFrom )
1434 {
1435 case( VT_I1 ):
1436 res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) );
1437 break;
1438 case( VT_I2 ):
1439 res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) );
1440 break;
1441 case( VT_INT ):
1442 case( VT_I4 ):
1443 res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) );
1444 break;
1445 case( VT_UI1 ):
1446 res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) );
1447 break;
1448 case( VT_UI2 ):
1449 res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) );
1450 break;
1451 case( VT_UINT ):
1452 case( VT_UI4 ):
1453 res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) );
1454 break;
1455 case( VT_R4 ):
1456 res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) );
1457 break;
1458 case( VT_R8 ):
1459 res = VariantCopy( pd, ps );
1460 break;
1461 case( VT_DATE ):
1462 res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) );
1463 break;
1464 case( VT_BOOL ):
1465 res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) );
1466 break;
1467 case( VT_BSTR ):
1468 res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) );
1469 break;
1470 case( VT_CY ):
1471 res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) );
1472 break;
1473 case( VT_DISPATCH ):
1474 /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/
1475 case( VT_DECIMAL ):
1476 /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/
1477 case( VT_UNKNOWN ):
1478 default:
1479 res = DISP_E_TYPEMISMATCH;
1480 FIXME("Coercion from %d to VT_R8\n", vtFrom);
1481 break;
1482 }
1483 break;
1484
1485 case( VT_DATE ):
1486 switch( vtFrom )
1487 {
1488 case( VT_I1 ):
1489 res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) );
1490 break;
1491 case( VT_I2 ):
1492 res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) );
1493 break;
1494 case( VT_INT ):
1495 res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) );
1496 break;
1497 case( VT_I4 ):
1498 res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) );
1499 break;
1500 case( VT_UI1 ):
1501 res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) );
1502 break;
1503 case( VT_UI2 ):
1504 res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) );
1505 break;
1506 case( VT_UINT ):
1507 res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) );
1508 break;
1509 case( VT_UI4 ):
1510 res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) );
1511 break;
1512 case( VT_R4 ):
1513 res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) );
1514 break;
1515 case( VT_R8 ):
1516 res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) );
1517 break;
1518 case( VT_BOOL ):
1519 res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) );
1520 break;
1521 case( VT_BSTR ):
1522 res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) );
1523 break;
1524 case( VT_CY ):
1525 res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) );
1526 break;
1527 case( VT_DISPATCH ):
1528 /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/
1529 case( VT_DECIMAL ):
1530 /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/
1531 case( VT_UNKNOWN ):
1532 default:
1533 res = DISP_E_TYPEMISMATCH;
1534 FIXME("Coercion from %d to VT_DATE\n", vtFrom);
1535 break;
1536 }
1537 break;
1538
1539 case( VT_BOOL ):
1540 switch( vtFrom )
1541 {
1542 case( VT_NULL ):
1543 case( VT_EMPTY ):
1544 res = S_OK;
1545 V_UNION(pd,boolVal) = VARIANT_FALSE;
1546 break;
1547 case( VT_I1 ):
1548 res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
1549 break;
1550 case( VT_I2 ):
1551 res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
1552 break;
1553 case( VT_INT ):
1554 res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
1555 break;
1556 case( VT_I4 ):
1557 res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
1558 break;
1559 case( VT_UI1 ):
1560 res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
1561 break;
1562 case( VT_UI2 ):
1563 res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
1564 break;
1565 case( VT_UINT ):
1566 res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
1567 break;
1568 case( VT_UI4 ):
1569 res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
1570 break;
1571 case( VT_R4 ):
1572 res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
1573 break;
1574 case( VT_R8 ):
1575 res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
1576 break;
1577 case( VT_DATE ):
1578 res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
1579 break;
1580 case( VT_BSTR ):
1581 res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
1582 break;
1583 case( VT_CY ):
1584 res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
1585 break;
1586 case( VT_DISPATCH ):
1587 /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
1588 case( VT_DECIMAL ):
1589 /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
1590 case( VT_UNKNOWN ):
1591 default:
1592 res = DISP_E_TYPEMISMATCH;
1593 FIXME("Coercion from %d to VT_BOOL\n", vtFrom);
1594 break;
1595 }
1596 break;
1597
1598 case( VT_BSTR ):
1599 switch( vtFrom )
1600 {
1601 case( VT_EMPTY ):
1602 if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
1603 res = S_OK;
1604 else
1605 res = E_OUTOFMEMORY;
1606 break;
1607 case( VT_I1 ):
1608 res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
1609 break;
1610 case( VT_I2 ):
1611 res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
1612 break;
1613 case( VT_INT ):
1614 res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
1615 break;
1616 case( VT_I4 ):
1617 res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
1618 break;
1619 case( VT_UI1 ):
1620 res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
1621 break;
1622 case( VT_UI2 ):
1623 res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
1624 break;
1625 case( VT_UINT ):
1626 res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
1627 break;
1628 case( VT_UI4 ):
1629 res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
1630 break;
1631 case( VT_R4 ):
1632 res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
1633 break;
1634 case( VT_R8 ):
1635 res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
1636 break;
1637 case( VT_DATE ):
1638 res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
1639 break;
1640 case( VT_BOOL ):
1641 res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
1642 break;
1643 case( VT_BSTR ):
1644 res = VariantCopy( pd, ps );
1645 break;
1646 case( VT_CY ):
1647 res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
1648 break;
1649 case( VT_DISPATCH ):
1650 /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
1651 case( VT_DECIMAL ):
1652 /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
1653 case( VT_UNKNOWN ):
1654 default:
1655 res = DISP_E_TYPEMISMATCH;
1656 FIXME("Coercion from %d to VT_BSTR\n", vtFrom);
1657 break;
1658 }
1659 break;
1660
1661 case( VT_CY ):
1662 switch( vtFrom )
1663 {
1664 case( VT_I1 ):
1665 res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
1666 break;
1667 case( VT_I2 ):
1668 res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
1669 break;
1670 case( VT_INT ):
1671 res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
1672 break;
1673 case( VT_I4 ):
1674 res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
1675 break;
1676 case( VT_UI1 ):
1677 res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
1678 break;
1679 case( VT_UI2 ):
1680 res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
1681 break;
1682 case( VT_UINT ):
1683 res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
1684 break;
1685 case( VT_UI4 ):
1686 res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
1687 break;
1688 case( VT_R4 ):
1689 res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
1690 break;
1691 case( VT_R8 ):
1692 res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
1693 break;
1694 case( VT_DATE ):
1695 res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
1696 break;
1697 case( VT_BOOL ):
1698 res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
1699 break;
1700 case( VT_CY ):
1701 res = VariantCopy( pd, ps );
1702 break;
1703 case( VT_BSTR ):
1704 res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
1705 break;
1706 case( VT_DISPATCH ):
1707 /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
1708 case( VT_DECIMAL ):
1709 /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
1710 break;
1711 case( VT_UNKNOWN ):
1712 default:
1713 res = DISP_E_TYPEMISMATCH;
1714 FIXME("Coercion from %d to VT_CY\n", vtFrom);
1715 break;
1716 }
1717 break;
1718
1719 case( VT_UNKNOWN ):
1720 switch (vtFrom) {
1721 case VT_DISPATCH:
1722 if (V_DISPATCH(ps) == NULL) {
1723 V_UNKNOWN(pd) = NULL;
1724 } else {
1725 res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd));
1726 }
1727 break;
1728 case VT_EMPTY: case VT_NULL: case VT_I2: case VT_I4:
1729 case VT_R4: case VT_R8: case VT_CY: case VT_DATE:
1730 case VT_BSTR: case VT_ERROR: case VT_BOOL:
1731 case VT_VARIANT: case VT_DECIMAL: case VT_I1: case VT_UI1:
1732 case VT_UI2: case VT_UI4: case VT_I8: case VT_UI8: case VT_INT:
1733 case VT_UINT: case VT_VOID: case VT_HRESULT: case VT_PTR:
1734 case VT_SAFEARRAY: case VT_CARRAY: case VT_USERDEFINED:
1735 case VT_LPSTR: case VT_LPWSTR: case VT_RECORD: case VT_FILETIME:
1736 case VT_BLOB: case VT_STREAM: case VT_STORAGE:
1737 case VT_STREAMED_OBJECT: case VT_STORED_OBJECT: case VT_BLOB_OBJECT:
1738 case VT_CF: case VT_CLSID:
1739 res = DISP_E_TYPEMISMATCH;
1740 break;
1741 default:
1742 FIXME("Coercion from %d to VT_UNKNOWN unhandled.\n", vtFrom);
1743 res = DISP_E_BADVARTYPE;
1744 break;
1745 }
1746 break;
1747
1748 case( VT_DISPATCH ):
1749 switch (vtFrom) {
1750 case VT_UNKNOWN:
1751 if (V_UNION(ps,punkVal) == NULL) {
1752 V_UNION(pd,pdispVal) = NULL;
1753 } else {
1754 res = IUnknown_QueryInterface(V_UNION(ps,punkVal), &IID_IDispatch, (LPVOID*)&V_UNION(pd,pdispVal));
1755 }
1756 break;
1757 case VT_EMPTY: case VT_NULL: case VT_I2: case VT_I4:
1758 case VT_R4: case VT_R8: case VT_CY: case VT_DATE:
1759 case VT_BSTR: case VT_ERROR: case VT_BOOL:
1760 case VT_VARIANT: case VT_DECIMAL: case VT_I1: case VT_UI1:
1761 case VT_UI2: case VT_UI4: case VT_I8: case VT_UI8: case VT_INT:
1762 case VT_UINT: case VT_VOID: case VT_HRESULT:
1763 case VT_SAFEARRAY: case VT_CARRAY: case VT_USERDEFINED:
1764 case VT_LPSTR: case VT_LPWSTR: case VT_RECORD: case VT_FILETIME:
1765 case VT_BLOB: case VT_STREAM: case VT_STORAGE:
1766 case VT_STREAMED_OBJECT: case VT_STORED_OBJECT: case VT_BLOB_OBJECT:
1767 case VT_CF: case VT_CLSID:
1768 res = DISP_E_TYPEMISMATCH;
1769 break;
1770 case VT_PTR:
1771 V_UNION(pd,pdispVal) = V_UNION(ps,pdispVal);
1772 break;
1773 default:
1774 FIXME("Coercion from %d to VT_DISPATCH unhandled.\n", vtFrom);
1775 res = DISP_E_BADVARTYPE;
1776 break;
1777 }
1778 break;
1779
1780 default:
1781 res = DISP_E_TYPEMISMATCH;
1782 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1783 break;
1784 }
1785
1786 return res;
1787 }
1788
1789 /******************************************************************************
1790 * ValidateVtRange [INTERNAL]
1791 *
1792 * Used internally by the hi-level Variant API to determine
1793 * if the vartypes are valid.
1794 */
1795 static HRESULT WINAPI ValidateVtRange( VARTYPE vt )
1796 {
1797 /* if by value we must make sure it is in the
1798 * range of the valid types.
1799 */
1800 if( ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1801 {
1802 return DISP_E_BADVARTYPE;
1803 }
1804 return S_OK;
1805 }
1806
1807
1808 /******************************************************************************
1809 * ValidateVartype [INTERNAL]
1810 *
1811 * Used internally by the hi-level Variant API to determine
1812 * if the vartypes are valid.
1813 */
1814 static HRESULT WINAPI ValidateVariantType( VARTYPE vt )
1815 {
1816 HRESULT res = S_OK;
1817
1818 /* check if we have a valid argument.
1819 */
1820 if( vt & VT_BYREF )
1821 {
1822 /* if by reference check that the type is in
1823 * the valid range and that it is not of empty or null type
1824 */
1825 if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1826 ( vt & VT_TYPEMASK ) == VT_NULL ||
1827 ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1828 {
1829 res = DISP_E_BADVARTYPE;
1830 }
1831
1832 }
1833 else
1834 {
1835 res = ValidateVtRange( vt );
1836 }
1837
1838 return res;
1839 }
1840
1841 /******************************************************************************
1842 * ValidateVt [INTERNAL]
1843 *
1844 * Used internally by the hi-level Variant API to determine
1845 * if the vartypes are valid.
1846 */
1847 static HRESULT WINAPI ValidateVt( VARTYPE vt )
1848 {
1849 HRESULT res = S_OK;
1850
1851 /* check if we have a valid argument.
1852 */
1853 if( vt & VT_BYREF )
1854 {
1855 /* if by reference check that the type is in
1856 * the valid range and that it is not of empty or null type
1857 */
1858 if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1859 ( vt & VT_TYPEMASK ) == VT_NULL ||
1860 ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1861 {
1862 res = DISP_E_BADVARTYPE;
1863 }
1864
1865 }
1866 else
1867 {
1868 res = ValidateVtRange( vt );
1869 }
1870
1871 return res;
1872 }
1873
1874
1875
1876
1877
1878 /******************************************************************************
1879 * VariantInit [OLEAUT32.8]
1880 *
1881 * Initializes the Variant. Unlike VariantClear it does not interpret
1882 * the current contents of the Variant.
1883 */
1884 void WINAPI VariantInit(VARIANTARG* pvarg)
1885 {
1886 TRACE("(%p)\n",pvarg);
1887
1888 memset(pvarg, 0, sizeof (VARIANTARG));
1889 V_VT(pvarg) = VT_EMPTY;
1890
1891 return;
1892 }
1893
1894 /******************************************************************************
1895 * VariantClear [OLEAUT32.9]
1896 *
1897 * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
1898 * sets the wReservedX field to 0. The current contents of the VARIANT are
1899 * freed. If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
1900 * released. If VT_ARRAY the array is freed.
1901 */
1902 HRESULT WINAPI VariantClear(VARIANTARG* pvarg)
1903 {
1904 HRESULT res = S_OK;
1905 TRACE("(%p)\n",pvarg);
1906
1907 res = ValidateVariantType( V_VT(pvarg) );
1908 if( res == S_OK )
1909 {
1910 if( !( V_VT(pvarg) & VT_BYREF ) )
1911 {
1912 /*
1913 * The VT_ARRAY flag is a special case of a safe array.
1914 */
1915 if ( (V_VT(pvarg) & VT_ARRAY) != 0)
1916 {
1917 SafeArrayDestroy(V_UNION(pvarg,parray));
1918 }
1919 else
1920 {
1921 switch( V_VT(pvarg) & VT_TYPEMASK )
1922 {
1923 case( VT_BSTR ):
1924 SysFreeString( V_UNION(pvarg,bstrVal) );
1925 break;
1926 case( VT_DISPATCH ):
1927 if(V_UNION(pvarg,pdispVal)!=NULL)
1928 IDispatch_Release(V_UNION(pvarg,pdispVal));
1929 break;
1930 case( VT_VARIANT ):
1931 VariantClear(V_UNION(pvarg,pvarVal));
1932 break;
1933 case( VT_UNKNOWN ):
1934 if(V_UNION(pvarg,punkVal)!=NULL)
1935 IUnknown_Release(V_UNION(pvarg,punkVal));
1936 break;
1937 case( VT_SAFEARRAY ):
1938 SafeArrayDestroy(V_UNION(pvarg,parray));
1939 break;
1940 default:
1941 break;
1942 }
1943 }
1944 }
1945
1946 /*
1947 * Empty all the fields and mark the type as empty.
1948 */
1949 memset(pvarg, 0, sizeof (VARIANTARG));
1950 V_VT(pvarg) = VT_EMPTY;
1951 }
1952
1953 return res;
1954 }
1955
1956 /******************************************************************************
1957 * VariantCopy [OLEAUT32.10]
1958 *
1959 * Frees up the designation variant and makes a copy of the source.
1960 */
1961 HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
1962 {
1963 HRESULT res = S_OK;
1964
1965 TRACE("(%p, %p), vt=%d\n", pvargDest, pvargSrc, V_VT(pvargSrc));
1966
1967 res = ValidateVariantType( V_VT(pvargSrc) );
1968
1969 /* If the pointer are to the same variant we don't need
1970 * to do anything.
1971 */
1972 if( pvargDest != pvargSrc && res == S_OK )
1973 {
1974 VariantClear( pvargDest ); /* result is not checked */
1975
1976 if( V_VT(pvargSrc) & VT_BYREF )
1977 {
1978 /* In the case of byreference we only need
1979 * to copy the pointer.
1980 */
1981 pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
1982 V_VT(pvargDest) = V_VT(pvargSrc);
1983 }
1984 else
1985 {
1986 /*
1987 * The VT_ARRAY flag is another way to designate a safe array.
1988 */
1989 if (V_VT(pvargSrc) & VT_ARRAY)
1990 {
1991 SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
1992 }
1993 else
1994 {
1995 /* In the case of by value we need to
1996 * copy the actual value. In the case of
1997 * VT_BSTR a copy of the string is made,
1998 * if VT_DISPATCH or VT_IUNKNOWN AddRef is
1999 * called to increment the object's reference count.
2000 */
2001 switch( V_VT(pvargSrc) & VT_TYPEMASK )
2002 {
2003 case( VT_BSTR ):
2004 V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( V_UNION(pvargSrc,bstrVal) );
2005 break;
2006 case( VT_DISPATCH ):
2007 V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
2008 if (V_UNION(pvargDest,pdispVal)!=NULL)
2009 IDispatch_AddRef(V_UNION(pvargDest,pdispVal));
2010 break;
2011 case( VT_VARIANT ):
2012 VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
2013 break;
2014 case( VT_UNKNOWN ):
2015 V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
2016 if (V_UNION(pvargDest,pdispVal)!=NULL)
2017 IUnknown_AddRef(V_UNION(pvargDest,punkVal));
2018 break;
2019 case( VT_SAFEARRAY ):
2020 SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
2021 break;
2022 default:
2023 pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
2024 break;
2025 }
2026 }
2027 V_VT(pvargDest) = V_VT(pvargSrc);
2028 dump_Variant(pvargDest);
2029 }
2030 }
2031
2032 return res;
2033 }
2034
2035
2036 /******************************************************************************
2037 * VariantCopyInd [OLEAUT32.11]
2038 *
2039 * Frees up the destination variant and makes a copy of the source. If
2040 * the source is of type VT_BYREF it performs the necessary indirections.
2041 */
2042 HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
2043 {
2044 HRESULT res = S_OK;
2045
2046 TRACE("(%p, %p)\n", pvargDest, pvargSrc);
2047
2048 res = ValidateVariantType( V_VT(pvargSrc) );
2049
2050 if( res != S_OK )
2051 return res;
2052
2053 if( V_VT(pvargSrc) & VT_BYREF )
2054 {
2055 VARIANTARG varg;
2056 VariantInit( &varg );
2057
2058 /* handle the in place copy.
2059 */
2060 if( pvargDest == pvargSrc )
2061 {
2062 /* we will use a copy of the source instead.
2063 */
2064 res = VariantCopy( &varg, pvargSrc );
2065 pvargSrc = &varg;
2066 }
2067
2068 if( res == S_OK )
2069 {
2070 res = VariantClear( pvargDest );
2071
2072 if( res == S_OK )
2073 {
2074 /*
2075 * The VT_ARRAY flag is another way to designate a safearray variant.
2076 */
2077 if ( V_VT(pvargSrc) & VT_ARRAY)
2078 {
2079 SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
2080 }
2081 else
2082 {
2083 /* In the case of by reference we need
2084 * to copy the date pointed to by the variant.
2085 */
2086
2087 /* Get the variant type.
2088 */
2089 switch( V_VT(pvargSrc) & VT_TYPEMASK )
2090 {
2091 case( VT_BSTR ):
2092 V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( *(V_UNION(pvargSrc,pbstrVal)) );
2093 break;
2094 case( VT_DISPATCH ):
2095 V_UNION(pvargDest,pdispVal) = *V_UNION(pvargSrc,ppdispVal);
2096 if (V_UNION(pvargDest,pdispVal)!=NULL)
2097 IDispatch_AddRef(V_UNION(pvargDest,pdispVal));
2098 break;
2099 case( VT_VARIANT ):
2100 {
2101 /* Prevent from cycling. According to tests on
2102 * VariantCopyInd in Windows and the documentation
2103 * this API dereferences the inner Variants to only one depth.
2104 * If the inner Variant itself contains an
2105 * other inner variant the E_INVALIDARG error is
2106 * returned.
2107 */
2108 if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
2109 {
2110 /* If we get here we are attempting to deference
2111 * an inner variant that that is itself contained
2112 * in an inner variant so report E_INVALIDARG error.
2113 */
2114 res = E_INVALIDARG;
2115 }
2116 else
2117 {
2118 /* Set the processing inner variant flag.
2119 * We will set this flag in the inner variant
2120 * that will be passed to the VariantCopyInd function.
2121 */
2122 (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
2123
2124 /* Dereference the inner variant.
2125 */
2126 res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
2127 /* We must also copy its type, I think.
2128 */
2129 V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
2130 }
2131 }
2132 break;
2133 case( VT_UNKNOWN ):
2134 V_UNION(pvargDest,punkVal) = *V_UNION(pvargSrc,ppunkVal);
2135 if (V_UNION(pvargDest,pdispVal)!=NULL)
2136 IUnknown_AddRef(V_UNION(pvargDest,punkVal));
2137 break;
2138 case( VT_SAFEARRAY ):
2139 SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
2140 break;
2141 default:
2142 /* This is a by reference Variant which means that the union
2143 * part of the Variant contains a pointer to some data of
2144 * type "V_VT(pvargSrc) & VT_TYPEMASK".
2145 * We will deference this data in a generic fashion using
2146 * the void pointer "Variant.u.byref".
2147 * We will copy this data into the union of the destination
2148 * Variant.
2149 */
2150 memcpy( &pvargDest->n1.n2.n3, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
2151 break;
2152 }
2153 }
2154
2155 if (res == S_OK) V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
2156 }
2157 }
2158
2159 /* this should not fail.
2160 */
2161 VariantClear( &varg );
2162 }
2163 else
2164 {
2165 res = VariantCopy( pvargDest, pvargSrc );
2166 }
2167
2168 return res;
2169 }
2170
2171 /******************************************************************************
2172 * Coerces a full safearray. Not optimal code.
2173 */
2174 static HRESULT
2175 coerce_array(
2176 VARIANTARG* src, VARIANTARG *dst, LCID lcid, USHORT wFlags, VARTYPE vt
2177 ) {
2178 SAFEARRAY *sarr = V_ARRAY(src);
2179 HRESULT hres;
2180 LPVOID data;
2181 VARTYPE vartype;
2182
2183 SafeArrayGetVartype(sarr,&vartype);
2184 switch (vt) {
2185 case VT_BSTR:
2186 if (sarr->cDims != 1) {
2187 FIXME("Can not coerce array with dim %d into BSTR\n", sarr->cDims);
2188 return E_FAIL;
2189 }
2190 switch (V_VT(src) & VT_TYPEMASK) {
2191 case VT_UI1:
2192 hres = SafeArrayAccessData(sarr, &data);
2193 if (FAILED(hres)) return hres;
2194
2195 /* Yes, just memcpied apparently. */
2196 V_BSTR(dst) = SysAllocStringByteLen(data, sarr->rgsabound[0].cElements);
2197 hres = SafeArrayUnaccessData(sarr);
2198 if (FAILED(hres)) return hres;
2199 break;
2200 default:
2201 FIXME("Cannot coerce array of %d into BSTR yet. Please report!\n", V_VT(src) & VT_TYPEMASK);
2202 return E_FAIL;
2203 }
2204 break;
2205 case VT_SAFEARRAY:
2206 V_VT(dst) = VT_SAFEARRAY;
2207 return SafeArrayCopy(sarr, &V_ARRAY(dst));
2208 default:
2209 FIXME("Cannot coerce array of vt 0x%x/0x%x into vt 0x%x yet. Please report/implement!\n", vartype, V_VT(src), vt);
2210 return E_FAIL;
2211 }
2212 return S_OK;
2213 }
2214
2215 /******************************************************************************
2216 * VariantChangeType [OLEAUT32.12]
2217 */
2218 HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
2219 USHORT wFlags, VARTYPE vt)
2220 {
2221 return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
2222 }
2223
2224 /******************************************************************************
2225 * VariantChangeTypeEx [OLEAUT32.147]
2226 */
2227 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
2228 LCID lcid, USHORT wFlags, VARTYPE vt)
2229 {
2230 HRESULT res = S_OK;
2231 VARIANTARG varg;
2232 VariantInit( &varg );
2233
2234 TRACE("(%p, %p, %ld, %u, %u) vt=%d\n", pvargDest, pvargSrc, lcid, wFlags, vt, V_VT(pvargSrc));
2235 TRACE("Src Var:\n");
2236 dump_Variant(pvargSrc);
2237
2238 /* validate our source argument.
2239 */
2240 res = ValidateVariantType( V_VT(pvargSrc) );
2241
2242 /* validate the vartype.
2243 */
2244 if( res == S_OK )
2245 {
2246 res = ValidateVt( vt );
2247 }
2248
2249 /* if we are doing an in-place conversion make a copy of the source.
2250 */
2251 if( res == S_OK && pvargDest == pvargSrc )
2252 {
2253 res = VariantCopy( &varg, pvargSrc );
2254 pvargSrc = &varg;
2255 }
2256
2257 if( res == S_OK )
2258 {
2259 /* free up the destination variant.
2260 */
2261 res = VariantClear( pvargDest );
2262 }
2263
2264 if( res == S_OK )
2265 {
2266 if( V_VT(pvargSrc) & VT_BYREF )
2267 {
2268 /* Convert the source variant to a "byvalue" variant.
2269 */
2270 VARIANTARG Variant;
2271
2272 if ((V_VT(pvargSrc) & 0xf000) != VT_BYREF) {
2273 FIXME("VT_TYPEMASK %x is unhandled.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2274 return E_FAIL;
2275 }
2276
2277 VariantInit( &Variant );
2278 res = VariantCopyInd( &Variant, pvargSrc );
2279 if( res == S_OK )
2280 {
2281 res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
2282 /* this should not fail.
2283 */
2284 VariantClear( &Variant );
2285 }
2286 } else {
2287 if (V_VT(pvargSrc) & VT_ARRAY) {
2288 if ((V_VT(pvargSrc) & 0xf000) != VT_ARRAY) {
2289 FIXME("VT_TYPEMASK %x is unhandled in VT_ARRAY.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2290 return E_FAIL;
2291 }
2292 V_VT(pvargDest) = VT_ARRAY | vt;
2293 res = coerce_array(pvargSrc, pvargDest, lcid, wFlags, vt);
2294 } else {
2295 if ((V_VT(pvargSrc) & 0xf000)) {
2296 FIXME("VT_TYPEMASK %x is unhandled in normal case.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2297 return E_FAIL;
2298 }
2299 /* Use the current "byvalue" source variant.
2300 */
2301 res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
2302 }
2303 }
2304 }
2305 /* this should not fail.
2306 */
2307 VariantClear( &varg );
2308
2309 /* set the type of the destination
2310 */
2311 if ( res == S_OK )
2312 V_VT(pvargDest) = vt;
2313
2314 TRACE("Dest Var:\n");
2315 dump_Variant(pvargDest);
2316
2317 return res;
2318 }
2319
2320
2321
2322
2323 /******************************************************************************
2324 * VarUI1FromI2 [OLEAUT32.130]
2325 */
2326 HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut)
2327 {
2328 TRACE("( %d, %p ), stub\n", sIn, pbOut );
2329
2330 /* Check range of value.
2331 */
2332 if( sIn < UI1_MIN || sIn > UI1_MAX )
2333 {
2334 return DISP_E_OVERFLOW;
2335 }
2336
2337 *pbOut = (BYTE) sIn;
2338
2339 return S_OK;
2340 }
2341
2342 /******************************************************************************
2343 * VarUI1FromI4 [OLEAUT32.131]
2344 */
2345 HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut)
2346 {
2347 TRACE("( %ld, %p ), stub\n", lIn, pbOut );
2348
2349 /* Check range of value.
2350 */
2351 if( lIn < UI1_MIN || lIn > UI1_MAX )
2352 {
2353 return DISP_E_OVERFLOW;
2354 }
2355
2356 *pbOut = (BYTE) lIn;
2357
2358 return S_OK;
2359 }
2360
2361
2362 /******************************************************************************
2363 * VarUI1FromR4 [OLEAUT32.132]
2364 */
2365 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
2366 {
2367 TRACE("( %f, %p ), stub\n", fltIn, pbOut );
2368
2369 /* Check range of value.
2370 */
2371 fltIn = round( fltIn );
2372 if( fltIn < UI1_MIN || fltIn > UI1_MAX )
2373 {
2374 return DISP_E_OVERFLOW;
2375 }
2376
2377 *pbOut = (BYTE) fltIn;
2378
2379 return S_OK;
2380 }
2381
2382 /******************************************************************************
2383 * VarUI1FromR8 [OLEAUT32.133]
2384 */
2385 HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
2386 {
2387 TRACE("( %f, %p ), stub\n", dblIn, pbOut );
2388
2389 /* Check range of value.
2390 */
2391 dblIn = round( dblIn );
2392 if( dblIn < UI1_MIN || dblIn > UI1_MAX )
2393 {
2394 return DISP_E_OVERFLOW;
2395 }
2396
2397 *pbOut = (BYTE) dblIn;
2398
2399 return S_OK;
2400 }
2401
2402 /******************************************************************************
2403 * VarUI1FromDate [OLEAUT32.135]
2404 */
2405 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
2406 {
2407 TRACE("( %f, %p ), stub\n", dateIn, pbOut );
2408
2409 /* Check range of value.
2410 */
2411 dateIn = round( dateIn );
2412 if( dateIn < UI1_MIN || dateIn > UI1_MAX )
2413 {
2414 return DISP_E_OVERFLOW;
2415 }
2416
2417 *pbOut = (BYTE) dateIn;
2418
2419 return S_OK;
2420 }
2421
2422 /******************************************************************************
2423 * VarUI1FromBool [OLEAUT32.138]
2424 */
2425 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
2426 {
2427 TRACE("( %d, %p ), stub\n", boolIn, pbOut );
2428
2429 *pbOut = (BYTE) boolIn;
2430
2431 return S_OK;
2432 }
2433
2434 /******************************************************************************
2435 * VarUI1FromI1 [OLEAUT32.237]
2436 */
2437 HRESULT WINAPI VarUI1FromI1(signed char cIn, BYTE* pbOut)
2438 {
2439 TRACE("( %c, %p ), stub\n", cIn, pbOut );
2440
2441 *pbOut = cIn;
2442
2443 return S_OK;
2444 }
2445
2446 /******************************************************************************
2447 * VarUI1FromUI2 [OLEAUT32.238]
2448 */
2449 HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut)
2450 {
2451 TRACE("( %d, %p ), stub\n", uiIn, pbOut );
2452
2453 /* Check range of value.
2454 */
2455 if( uiIn > UI1_MAX )
2456 {
2457 return DISP_E_OVERFLOW;
2458 }
2459
2460 *pbOut = (BYTE) uiIn;
2461
2462 return S_OK;
2463 }
2464
2465 /******************************************************************************
2466 * VarUI1FromUI4 [OLEAUT32.239]
2467 */
2468 HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
2469 {
2470 TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
2471
2472 /* Check range of value.
2473 */
2474 if( ulIn > UI1_MAX )
2475 {
2476 return DISP_E_OVERFLOW;
2477 }
2478
2479 *pbOut = (BYTE) ulIn;
2480
2481 return S_OK;
2482 }
2483
2484
2485 /******************************************************************************
2486 * VarUI1FromStr [OLEAUT32.136]
2487 */
2488 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
2489 {
2490 double dValue = 0.0;
2491 LPSTR pNewString = NULL;
2492
2493 TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
2494
2495 /* Check if we have a valid argument
2496 */
2497 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2498 RemoveCharacterFromString( pNewString, "," );
2499 if( IsValidRealString( pNewString ) == FALSE )
2500 {
2501 return DISP_E_TYPEMISMATCH;
2502 }
2503
2504 /* Convert the valid string to a floating point number.
2505 */
2506 dValue = atof( pNewString );
2507
2508 /* We don't need the string anymore so free it.
2509 */
2510 HeapFree( GetProcessHeap(), 0 , pNewString );
2511
2512 /* Check range of value.
2513 */
2514 dValue = round( dValue );
2515 if( dValue < UI1_MIN || dValue > UI1_MAX )
2516 {
2517 return DISP_E_OVERFLOW;
2518 }
2519
2520 *pbOut = (BYTE) dValue;
2521
2522 return S_OK;
2523 }
2524
2525 /**********************************************************************
2526 * VarUI1FromCy [OLEAUT32.134]
2527 * Convert currency to unsigned char
2528 */
2529 HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
2530 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2531
2532 if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
2533
2534 *pbOut = (BYTE)t;
2535 return S_OK;
2536 }
2537
2538 /******************************************************************************
2539 * VarI2FromUI1 [OLEAUT32.48]
2540 */
2541 HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut)
2542 {
2543 TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
2544
2545 *psOut = (short) bIn;
2546
2547 return S_OK;
2548 }
2549
2550 /******************************************************************************
2551 * VarI2FromI4 [OLEAUT32.49]
2552 */
2553 HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut)
2554 {
2555 TRACE("( %lx, %p ), stub\n", lIn, psOut );
2556
2557 /* Check range of value.
2558 */
2559 if( lIn < I2_MIN || lIn > I2_MAX )
2560 {
2561 return DISP_E_OVERFLOW;
2562 }
2563
2564 *psOut = (short) lIn;
2565
2566 return S_OK;
2567 }
2568
2569 /******************************************************************************
2570 * VarI2FromR4 [OLEAUT32.50]
2571 */
2572 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut)
2573 {
2574 TRACE("( %f, %p ), stub\n", fltIn, psOut );
2575
2576 /* Check range of value.
2577 */
2578 fltIn = round( fltIn );
2579 if( fltIn < I2_MIN || fltIn > I2_MAX )
2580 {
2581 return DISP_E_OVERFLOW;
2582 }
2583
2584 *psOut = (short) fltIn;
2585
2586 return S_OK;
2587 }
2588
2589 /******************************************************************************
2590 * VarI2FromR8 [OLEAUT32.51]
2591 */
2592 HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut)
2593 {
2594 TRACE("( %f, %p ), stub\n", dblIn, psOut );
2595
2596 /* Check range of value.
2597 */
2598 dblIn = round( dblIn );
2599 if( dblIn < I2_MIN || dblIn > I2_MAX )
2600 {
2601 return DISP_E_OVERFLOW;
2602 }
2603
2604 *psOut = (short) dblIn;
2605
2606 return S_OK;
2607 }
2608
2609 /******************************************************************************
2610 * VarI2FromDate [OLEAUT32.53]
2611 */
2612 HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut)
2613 {
2614 TRACE("( %f, %p ), stub\n", dateIn, psOut );
2615
2616 /* Check range of value.
2617 */
2618 dateIn = round( dateIn );
2619 if( dateIn < I2_MIN || dateIn > I2_MAX )
2620 {
2621 return DISP_E_OVERFLOW;
2622 }
2623
2624 *psOut = (short) dateIn;
2625
2626 return S_OK;
2627 }
2628
2629 /******************************************************************************
2630 * VarI2FromBool [OLEAUT32.56]
2631 */
2632 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut)
2633 {
2634 TRACE("( %d, %p ), stub\n", boolIn, psOut );
2635
2636 *psOut = (short) boolIn;
2637
2638 return S_OK;
2639 }
2640
2641 /******************************************************************************
2642 * VarI2FromI1 [OLEAUT32.205]
2643 */
2644 HRESULT WINAPI VarI2FromI1(signed char cIn, short* psOut)
2645 {
2646 TRACE("( %c, %p ), stub\n", cIn, psOut );
2647
2648 *psOut = (short) cIn;
2649
2650 return S_OK;
2651 }
2652
2653 /******************************************************************************
2654 * VarI2FromUI2 [OLEAUT32.206]
2655 */
2656 HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut)
2657 {
2658 TRACE("( %d, %p ), stub\n", uiIn, psOut );
2659
2660 /* Check range of value.
2661 */
2662 if( uiIn > I2_MAX )
2663 {
2664 return DISP_E_OVERFLOW;
2665 }
2666
2667 *psOut = (short) uiIn;
2668
2669 return S_OK;
2670 }
2671
2672 /******************************************************************************
2673 * VarI2FromUI4 [OLEAUT32.207]
2674 */
2675 HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
2676 {
2677 TRACE("( %lx, %p ), stub\n", ulIn, psOut );
2678
2679 /* Check range of value.
2680 */
2681 if( ulIn < I2_MIN || ulIn > I2_MAX )
2682 {
2683 return DISP_E_OVERFLOW;
2684 }
2685
2686 *psOut = (short) ulIn;
2687
2688 return S_OK;
2689 }
2690
2691 /******************************************************************************
2692 * VarI2FromStr [OLEAUT32.54]
2693 */
2694 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut)
2695 {
2696 double dValue = 0.0;
2697 LPSTR pNewString = NULL;
2698
2699 TRACE("( %s, 0x%08lx, 0x%08lx, %p ), stub\n", debugstr_w(strIn), lcid, dwFlags, psOut );
2700
2701 /* Check if we have a valid argument
2702 */
2703 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2704 RemoveCharacterFromString( pNewString, "," );
2705 if( IsValidRealString( pNewString ) == FALSE )
2706 {
2707 return DISP_E_TYPEMISMATCH;
2708 }
2709
2710 /* Convert the valid string to a floating point number.
2711 */
2712 dValue = atof( pNewString );
2713
2714 /* We don't need the string anymore so free it.
2715 */
2716 HeapFree( GetProcessHeap(), 0, pNewString );
2717
2718 /* Check range of value.
2719 */
2720 dValue = round( dValue );
2721 if( dValue < I2_MIN || dValue > I2_MAX )
2722 {
2723 return DISP_E_OVERFLOW;
2724 }
2725
2726 *psOut = (short) dValue;
2727
2728 return S_OK;
2729 }
2730
2731 /**********************************************************************
2732 * VarI2FromCy [OLEAUT32.52]
2733 * Convert currency to signed short
2734 */
2735 HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
2736 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2737
2738 if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
2739
2740 *psOut = (SHORT)t;
2741 return S_OK;
2742 }
2743
2744 /******************************************************************************
2745 * VarI4FromUI1 [OLEAUT32.58]
2746 */
2747 HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut)
2748 {
2749 TRACE("( %X, %p ), stub\n", bIn, plOut );
2750
2751 *plOut = (LONG) bIn;
2752
2753 return S_OK;
2754 }
2755
2756
2757 /******************************************************************************
2758 * VarI4FromR4 [OLEAUT32.60]
2759 */
2760 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut)
2761 {
2762 TRACE("( %f, %p ), stub\n", fltIn, plOut );
2763
2764 /* Check range of value.
2765 */
2766 fltIn = round( fltIn );
2767 if( fltIn < I4_MIN || fltIn > I4_MAX )
2768 {
2769 return DISP_E_OVERFLOW;
2770 }
2771
2772 *plOut = (LONG) fltIn;
2773
2774 return S_OK;
2775 }
2776
2777 /******************************************************************************
2778 * VarI4FromR8 [OLEAUT32.61]
2779 */
2780 HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut)
2781 {
2782 TRACE("( %f, %p ), stub\n", dblIn, plOut );
2783
2784 /* Check range of value.
2785 */
2786 dblIn = round( dblIn );
2787 if( dblIn < I4_MIN || dblIn > I4_MAX )
2788 {
2789 return DISP_E_OVERFLOW;
2790 }
2791
2792 *plOut = (LONG) dblIn;
2793
2794 return S_OK;
2795 }
2796
2797 /******************************************************************************
2798 * VarI4FromDate [OLEAUT32.63]
2799 */
2800 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut)
2801 {
2802 TRACE("( %f, %p ), stub\n", dateIn, plOut );
2803
2804 /* Check range of value.
2805 */
2806 dateIn = round( dateIn );
2807 if( dateIn < I4_MIN || dateIn > I4_MAX )
2808 {
2809 return DISP_E_OVERFLOW;
2810 }
2811
2812 *plOut = (LONG) dateIn;
2813
2814 return S_OK;
2815 }
2816
2817 /******************************************************************************
2818 * VarI4FromBool [OLEAUT32.66]
2819 */
2820 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut)
2821 {
2822 TRACE("( %d, %p ), stub\n", boolIn, plOut );
2823
2824 *plOut = (LONG) boolIn;
2825
2826 return S_OK;
2827 }
2828
2829 /******************************************************************************
2830 * VarI4FromI1 [OLEAUT32.209]
2831 */
2832 HRESULT WINAPI VarI4FromI1(signed char cIn, LONG* plOut)
2833 {
2834 TRACE("( %c, %p ), stub\n", cIn, plOut );
2835
2836 *plOut = (LONG) cIn;
2837
2838 return S_OK;
2839 }
2840
2841 /******************************************************************************
2842 * VarI4FromUI2 [OLEAUT32.210]
2843 */
2844 HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut)
2845 {
2846 TRACE("( %d, %p ), stub\n", uiIn, plOut );
2847
2848 *plOut = (LONG) uiIn;
2849
2850 return S_OK;
2851 }
2852
2853 /******************************************************************************
2854 * VarI4FromUI4 [OLEAUT32.211]
2855 */
2856 HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut)
2857 {
2858 TRACE("( %lx, %p ), stub\n", ulIn, plOut );
2859
2860 /* Check range of value.
2861 */
2862 if( ulIn < I4_MIN || ulIn > I4_MAX )
2863 {
2864 return DISP_E_OVERFLOW;
2865 }
2866
2867 *plOut = (LONG) ulIn;
2868
2869 return S_OK;
2870 }
2871
2872 /******************************************************************************
2873 * VarI4FromI2 [OLEAUT32.59]
2874 */
2875 HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut)
2876 {
2877 TRACE("( %d, %p ), stub\n", sIn, plOut );
2878
2879 *plOut = (LONG) sIn;
2880
2881 return S_OK;
2882 }
2883
2884 /******************************************************************************
2885 * VarI4FromStr [OLEAUT32.64]
2886 */
2887 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut)
2888 {
2889 double dValue = 0.0;
2890 LPSTR pNewString = NULL;
2891
2892 TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
2893
2894 /* Check if we have a valid argument
2895 */
2896 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2897 RemoveCharacterFromString( pNewString, "," );
2898 if( IsValidRealString( pNewString ) == FALSE )
2899 {
2900 return DISP_E_TYPEMISMATCH;
2901 }
2902
2903 /* Convert the valid string to a floating point number.
2904 */
2905 dValue = atof( pNewString );
2906
2907 /* We don't need the string anymore so free it.
2908 */
2909 HeapFree( GetProcessHeap(), 0, pNewString );
2910
2911 /* Check range of value.
2912 */
2913 dValue = round( dValue );
2914 if( dValue < I4_MIN || dValue > I4_MAX )
2915 {
2916 return DISP_E_OVERFLOW;
2917 }
2918
2919 *plOut = (LONG) dValue;
2920
2921 return S_OK;
2922 }
2923
2924 /**********************************************************************
2925 * VarI4FromCy [OLEAUT32.62]
2926 * Convert currency to signed long
2927 */
2928 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
2929 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2930
2931 if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
2932
2933 *plOut = (LONG)t;
2934 return S_OK;
2935 }
2936
2937 /******************************************************************************
2938 * VarR4FromUI1 [OLEAUT32.68]
2939 */
2940 HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut)
2941 {
2942 TRACE("( %X, %p ), stub\n", bIn, pfltOut );
2943
2944 *pfltOut = (FLOAT) bIn;
2945
2946 return S_OK;
2947 }
2948
2949 /******************************************************************************
2950 * VarR4FromI2 [OLEAUT32.69]
2951 */
2952 HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut)
2953 {
2954 TRACE("( %d, %p ), stub\n", sIn, pfltOut );
2955
2956 *pfltOut = (FLOAT) sIn;
2957
2958 return S_OK;
2959 }
2960
2961 /******************************************************************************
2962 * VarR4FromI4 [OLEAUT32.70]
2963 */
2964 HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut)
2965 {
2966 TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
2967
2968 *pfltOut = (FLOAT) lIn;
2969
2970 return S_OK;
2971 }
2972
2973 /******************************************************************************
2974 * VarR4FromR8 [OLEAUT32.71]
2975 */
2976 HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut)
2977 {
2978 TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
2979
2980 /* Check range of value.
2981 */
2982 if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
2983 {
2984 return DISP_E_OVERFLOW;
2985 }
2986
2987 *pfltOut = (FLOAT) dblIn;
2988
2989 return S_OK;
2990 }
2991
2992 /******************************************************************************
2993 * VarR4FromDate [OLEAUT32.73]
2994 */
2995 HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut)
2996 {
2997 TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
2998
2999 /* Check range of value.
3000 */
3001 if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
3002 {
3003 return DISP_E_OVERFLOW;
3004 }
3005
3006 *pfltOut = (FLOAT) dateIn;
3007
3008 return S_OK;
3009 }
3010
3011 /******************************************************************************
3012 * VarR4FromBool [OLEAUT32.76]
3013 */
3014 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut)
3015 {
3016 TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
3017
3018 *pfltOut = (FLOAT) boolIn;
3019
3020 return S_OK;
3021 }
3022
3023 /******************************************************************************
3024 * VarR4FromI1 [OLEAUT32.213]
3025 */
3026 HRESULT WINAPI VarR4FromI1(signed char cIn, FLOAT* pfltOut)
3027 {
3028 TRACE("( %c, %p ), stub\n", cIn, pfltOut );
3029
3030 *pfltOut = (FLOAT) cIn;
3031
3032 return S_OK;
3033 }
3034
3035 /******************************************************************************
3036 * VarR4FromUI2 [OLEAUT32.214]
3037 */
3038 HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut)
3039 {
3040 TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
3041
3042 *pfltOut = (FLOAT) uiIn;
3043
3044 return S_OK;
3045 }
3046
3047 /******************************************************************************
3048 * VarR4FromUI4 [OLEAUT32.215]
3049 */
3050 HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut)
3051 {
3052 TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
3053
3054 *pfltOut = (FLOAT) ulIn;
3055
3056 return S_OK;
3057 }
3058
3059 /******************************************************************************
3060 * VarR4FromStr [OLEAUT32.74]
3061 */
3062 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut)
3063 {
3064 double dValue = 0.0;
3065 LPSTR pNewString = NULL;
3066
3067 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
3068
3069 /* Check if we have a valid argument
3070 */
3071 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3072 RemoveCharacterFromString( pNewString, "," );
3073 if( IsValidRealString( pNewString ) == FALSE )
3074 {
3075 return DISP_E_TYPEMISMATCH;
3076 }
3077
3078 /* Convert the valid string to a floating point number.
3079 */
3080 dValue = atof( pNewString );
3081
3082 /* We don't need the string anymore so free it.
3083 */
3084 HeapFree( GetProcessHeap(), 0, pNewString );
3085
3086 /* Check range of value.
3087 */
3088 if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
3089 {
3090 return DISP_E_OVERFLOW;
3091 }
3092
3093 *pfltOut = (FLOAT) dValue;
3094
3095 return S_OK;
3096 }
3097
3098 /**********************************************************************
3099 * VarR4FromCy [OLEAUT32.72]
3100 * Convert currency to float
3101 */
3102 HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
3103 *pfltOut = (FLOAT)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3104
3105 return S_OK;
3106 }
3107
3108 /******************************************************************************
3109 * VarR8FromUI1 [OLEAUT32.78]
3110 */
3111 HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
3112 {
3113 TRACE("( %d, %p ), stub\n", bIn, pdblOut );
3114
3115 *pdblOut = (double) bIn;
3116
3117 return S_OK;
3118 }
3119
3120 /******************************************************************************
3121 * VarR8FromI2 [OLEAUT32.79]
3122 */
3123 HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
3124 {
3125 TRACE("( %d, %p ), stub\n", sIn, pdblOut );
3126
3127 *pdblOut = (double) sIn;
3128
3129 return S_OK;
3130 }
3131
3132 /******************************************************************************
3133 * VarR8FromI4 [OLEAUT32.80]
3134 */
3135 HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
3136 {
3137 TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
3138
3139 *pdblOut = (double) lIn;
3140
3141 return S_OK;
3142 }
3143
3144 /******************************************************************************
3145 * VarR8FromR4 [OLEAUT32.81]
3146 */
3147 HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut)
3148 {
3149 TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
3150
3151 *pdblOut = (double) fltIn;
3152
3153 return S_OK;
3154 }
3155
3156 /******************************************************************************
3157 * VarR8FromDate [OLEAUT32.83]
3158 */
3159 HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut)
3160 {
3161 TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
3162
3163 *pdblOut = (double) dateIn;
3164
3165 return S_OK;
3166 }
3167
3168 /******************************************************************************
3169 * VarR8FromBool [OLEAUT32.86]
3170 */
3171 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut)
3172 {
3173 TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
3174
3175 *pdblOut = (double) boolIn;
3176
3177 return S_OK;
3178 }
3179
3180 /******************************************************************************
3181 * VarR8FromI1 [OLEAUT32.217]
3182 */
3183 HRESULT WINAPI VarR8FromI1(signed char cIn, double* pdblOut)
3184 {
3185 TRACE("( %c, %p ), stub\n", cIn, pdblOut );
3186
3187 *pdblOut = (double) cIn;
3188
3189 return S_OK;
3190 }
3191
3192 /******************************************************************************
3193 * VarR8FromUI2 [OLEAUT32.218]
3194 */
3195 HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut)
3196 {
3197 TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
3198
3199 *pdblOut = (double) uiIn;
3200
3201 return S_OK;
3202 }
3203
3204 /******************************************************************************
3205 * VarR8FromUI4 [OLEAUT32.219]
3206 */
3207 HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut)
3208 {
3209 TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
3210
3211 *pdblOut = (double) ulIn;
3212
3213 return S_OK;
3214 }
3215
3216 /******************************************************************************
3217 * VarR8FromStr [OLEAUT32.84]
3218 */
3219 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut)
3220 {
3221 double dValue = 0.0;
3222 LPSTR pNewString = NULL;
3223
3224 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3225 TRACE("( %s, %ld, %ld, %p ), stub\n", pNewString, lcid, dwFlags, pdblOut );
3226
3227 /* Check if we have a valid argument
3228 */
3229 RemoveCharacterFromString( pNewString, "," );
3230 if( IsValidRealString( pNewString ) == FALSE )
3231 {
3232 return DISP_E_TYPEMISMATCH;
3233 }
3234
3235 /* Convert the valid string to a floating point number.
3236 */
3237 dValue = atof( pNewString );
3238
3239 /* We don't need the string anymore so free it.
3240 */
3241 HeapFree( GetProcessHeap(), 0, pNewString );
3242
3243 *pdblOut = dValue;
3244
3245 return S_OK;
3246 }
3247
3248 /**********************************************************************
3249 * VarR8FromCy [OLEAUT32.82]
3250 * Convert currency to double
3251 */
3252 HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
3253 *pdblOut = (double)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3254 TRACE("%lu %ld -> %f\n", cyIn.s.Hi, cyIn.s.Lo, *pdblOut);
3255 return S_OK;
3256 }
3257
3258 /******************************************************************************
3259 * VarDateFromUI1 [OLEAUT32.88]
3260 */
3261 HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
3262 {
3263 TRACE("( %d, %p ), stub\n", bIn, pdateOut );
3264
3265 *pdateOut = (DATE) bIn;
3266
3267 return S_OK;
3268 }
3269
3270 /******************************************************************************
3271 * VarDateFromI2 [OLEAUT32.89]
3272 */
3273 HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
3274 {
3275 TRACE("( %d, %p ), stub\n", sIn, pdateOut );
3276
3277 *pdateOut = (DATE) sIn;
3278
3279 return S_OK;
3280 }
3281
3282 /******************************************************************************
3283 * VarDateFromI4 [OLEAUT32.90]
3284 */
3285 HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
3286 {
3287 TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
3288
3289 if( lIn < DATE_MIN || lIn > DATE_MAX )
3290 {
3291 return DISP_E_OVERFLOW;
3292 }
3293
3294 *pdateOut = (DATE) lIn;
3295
3296 return S_OK;
3297 }
3298
3299 /******************************************************************************
3300 * VarDateFromR4 [OLEAUT32.91]
3301 */
3302 HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
3303 {
3304 TRACE("( %f, %p ), stub\n", fltIn, pdateOut );
3305
3306 if( ceil(fltIn) < DATE_MIN || floor(fltIn) > DATE_MAX )
3307 {
3308 return DISP_E_OVERFLOW;
3309 }
3310
3311 *pdateOut = (DATE) fltIn;
3312
3313 return S_OK;
3314 }
3315
3316 /******************************************************************************
3317 * VarDateFromR8 [OLEAUT32.92]
3318 */
3319 HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
3320 {
3321 TRACE("( %f, %p ), stub\n", dblIn, pdateOut );
3322
3323 if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
3324 {
3325 return DISP_E_OVERFLOW;
3326 }
3327
3328 *pdateOut = (DATE) dblIn;
3329
3330 return S_OK;
3331 }
3332
3333 /******************************************************************************
3334 * VarDateFromStr [OLEAUT32.94]
3335 * The string representing the date is composed of two parts, a date and time.
3336 *
3337 * The format of the time is has follows:
3338 * hh[:mm][:ss][AM|PM]
3339 * Whitespace can be inserted anywhere between these tokens. A whitespace consists
3340 * of space and/or tab characters, which are ignored.
3341 *
3342 * The formats for the date part are has follows:
3343 * mm/[dd/][yy]yy
3344 * [dd/]mm/[yy]yy
3345 * [yy]yy/mm/dd
3346 * January dd[,] [yy]yy
3347 * dd January [yy]yy
3348 * [yy]yy January dd
3349 * Whitespace can be inserted anywhere between these tokens.
3350 *
3351 * The formats for the date and time string are has follows.
3352 * date[whitespace][time]
3353 * [time][whitespace]date
3354 *
3355 * These are the only characters allowed in a string representing a date and time:
3356 * [A-Z] [a-z] [0-9] ':' '-' '/' ',' ' ' '\t'
3357 */
3358 HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
3359 {
3360 HRESULT ret = S_OK;
3361 struct tm TM;
3362
3363 memset( &TM, 0, sizeof(TM) );
3364
3365 TRACE("( %p, %lx, %lx, %p ), stub\n", strIn, lcid, dwFlags, pdateOut );
3366
3367 if( DateTimeStringToTm( strIn, dwFlags, &TM ) )
3368 {
3369 if( TmToDATE( &TM, pdateOut ) == FALSE )
3370 {
3371 ret = E_INVALIDARG;
3372 }
3373 }
3374 else
3375 {
3376 ret = DISP_E_TYPEMISMATCH;
3377 }
3378 TRACE("Return value %f\n", *pdateOut);
3379 return ret;
3380 }
3381
3382 /******************************************************************************
3383 * VarDateFromI1 [OLEAUT32.221]
3384 */
3385 HRESULT WINAPI VarDateFromI1(signed char cIn, DATE* pdateOut)
3386 {
3387 TRACE("( %c, %p ), stub\n", cIn, pdateOut );
3388
3389 *pdateOut = (DATE) cIn;
3390
3391 return S_OK;
3392 }
3393
3394 /******************************************************************************
3395 * VarDateFromUI2 [OLEAUT32.222]
3396 */
3397 HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
3398 {
3399 TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
3400
3401 if( uiIn > DATE_MAX )
3402 {
3403 return DISP_E_OVERFLOW;
3404 }
3405
3406 *pdateOut = (DATE) uiIn;
3407
3408 return S_OK;
3409 }
3410
3411 /******************************************************************************
3412 * VarDateFromUI4 [OLEAUT32.223]
3413 */
3414 HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
3415 {
3416 TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
3417
3418 if( ulIn < DATE_MIN || ulIn > DATE_MAX )
3419 {
3420 return DISP_E_OVERFLOW;
3421 }
3422
3423 *pdateOut = (DATE) ulIn;
3424
3425 return S_OK;
3426 }
3427
3428 /******************************************************************************
3429 * VarDateFromBool [OLEAUT32.96]
3430 */
3431 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
3432 {
3433 TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
3434
3435 *pdateOut = (DATE) boolIn;
3436
3437 return S_OK;
3438 }
3439
3440 /**********************************************************************
3441 * VarDateFromCy [OLEAUT32.93]
3442 * Convert currency to date
3443 */
3444 HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut) {
3445 *pdateOut = (DATE)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3446
3447 if (*pdateOut > DATE_MAX || *pdateOut < DATE_MIN) return DISP_E_TYPEMISMATCH;
3448 return S_OK;
3449 }
3450
3451 /******************************************************************************
3452 * VarBstrFromUI1 [OLEAUT32.108]
3453 */
3454 HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3455 {
3456 TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
3457 sprintf( pBuffer, "%d", bVal );
3458
3459 *pbstrOut = StringDupAtoBstr( pBuffer );
3460
3461 return S_OK;
3462 }
3463
3464 /******************************************************************************
3465 * VarBstrFromI2 [OLEAUT32.109]
3466 */
3467 HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3468 {
3469 TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
3470 sprintf( pBuffer, "%d", iVal );
3471 *pbstrOut = StringDupAtoBstr( pBuffer );
3472
3473 return S_OK;
3474 }
3475
3476 /******************************************************************************
3477 * VarBstrFromI4 [OLEAUT32.110]
3478 */
3479 HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3480 {
3481 TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
3482
3483 sprintf( pBuffer, "%ld", lIn );
3484 *pbstrOut = StringDupAtoBstr( pBuffer );
3485
3486 return S_OK;
3487 }
3488
3489 /******************************************************************************
3490 * VarBstrFromR4 [OLEAUT32.111]
3491 */
3492 HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3493 {
3494 TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
3495
3496 sprintf( pBuffer, "%.7G", fltIn );
3497 *pbstrOut = StringDupAtoBstr( pBuffer );
3498
3499 return S_OK;
3500 }
3501
3502 /******************************************************************************
3503 * VarBstrFromR8 [OLEAUT32.112]
3504 */
3505 HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3506 {
3507 TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
3508
3509 sprintf( pBuffer, "%.15G", dblIn );
3510 *pbstrOut = StringDupAtoBstr( pBuffer );
3511
3512 return S_OK;
3513 }
3514
3515 /******************************************************************************
3516 * VarBstrFromCy [OLEAUT32.113]
3517 */
3518 HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut) {
3519 HRESULT rc = S_OK;
3520 double curVal = 0.0;
3521
3522 TRACE("([cyIn], %08lx, %08lx, %p), partial stub (no flags handled).\n", lcid, dwFlags, pbstrOut);
3523
3524 /* Firstly get the currency in a double, then put it in a buffer */
3525 rc = VarR8FromCy(cyIn, &curVal);
3526 if (rc == S_OK) {
3527 sprintf(pBuffer, "%G", curVal);
3528 *pbstrOut = StringDupAtoBstr( pBuffer );
3529 }
3530 return rc;
3531 }
3532
3533
3534 /******************************************************************************
3535 * VarBstrFromDate [OLEAUT32.114]
3536 *
3537 * The date is implemented using an 8 byte floating-point number.
3538 * Days are represented by whole numbers increments starting with 0.00 as
3539 * being December 30 1899, midnight.
3540 * The hours are expressed as the fractional part of the number.
3541 * December 30 1899 at midnight = 0.00
3542 * January 1 1900 at midnight = 2.00
3543 * January 4 1900 at 6 AM = 5.25
3544 * January 4 1900 at noon = 5.50
3545 * December 29 1899 at midnight = -1.00
3546 * December 18 1899 at midnight = -12.00
3547 * December 18 1899 at 6AM = -12.25
3548 * December 18 1899 at 6PM = -12.75
3549 * December 19 1899 at midnight = -11.00
3550 * The tm structure is as follows:
3551 * struct tm {
3552 * int tm_sec; seconds after the minute - [0,59]
3553 * int tm_min; minutes after the hour - [0,59]
3554 * int tm_hour; hours since midnight - [0,23]
3555 * int tm_mday; day of the month - [1,31]
3556 * int tm_mon; months since January - [0,11]
3557 * int tm_year; years
3558 * int tm_wday; days since Sunday - [0,6]
3559 * int tm_yday; days since January 1 - [0,365]
3560 * int tm_isdst; daylight savings time flag
3561 * };
3562 */
3563 HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3564 {
3565 struct tm TM;
3566 memset( &TM, 0, sizeof(TM) );
3567
3568 TRACE("( %20.20f, %ld, %ld, %p ), stub\n", dateIn, lcid, dwFlags, pbstrOut );
3569
3570 if( DateToTm( dateIn, dwFlags, &TM ) == FALSE )
3571 {
3572 return E_INVALIDARG;
3573 }
3574
3575 if( dwFlags & VAR_DATEVALUEONLY )
3576 strftime( pBuffer, BUFFER_MAX, "%x", &TM );
3577 else if( dwFlags & VAR_TIMEVALUEONLY )
3578 strftime( pBuffer, BUFFER_MAX, "%X", &TM );
3579 else
3580 strftime( pBuffer, BUFFER_MAX, "%x %X", &TM );
3581
3582 TRACE("result: %s\n", pBuffer);
3583 *pbstrOut = StringDupAtoBstr( pBuffer );
3584 return S_OK;
3585 }
3586
3587 /******************************************************************************
3588 * VarBstrFromBool [OLEAUT32.116]
3589 */
3590 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3591 {
3592 TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
3593
3594 sprintf( pBuffer, (boolIn == VARIANT_FALSE) ? "False" : "True" );
3595
3596 *pbstrOut = StringDupAtoBstr( pBuffer );
3597
3598 return S_OK;
3599 }
3600
3601 /******************************************************************************
3602 * VarBstrFromI1 [OLEAUT32.229]
3603 */
3604 HRESULT WINAPI VarBstrFromI1(signed char cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3605 {
3606 TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
3607 sprintf( pBuffer, "%d", cIn );
3608 *pbstrOut = StringDupAtoBstr( pBuffer );
3609
3610 return S_OK;
3611 }
3612
3613 /******************************************************************************
3614 * VarBstrFromUI2 [OLEAUT32.230]
3615 */
3616 HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3617 {
3618 TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
3619 sprintf( pBuffer, "%d", uiIn );
3620 *pbstrOut = StringDupAtoBstr( pBuffer );
3621
3622 return S_OK;
3623 }
3624
3625 /******************************************************************************
3626 * VarBstrFromUI4 [OLEAUT32.231]
3627 */
3628 HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3629 {
3630 TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
3631 sprintf( pBuffer, "%ld", ulIn );
3632 *pbstrOut = StringDupAtoBstr( pBuffer );
3633
3634 return S_OK;
3635 }
3636
3637 /******************************************************************************
3638 * VarBstrFromDec [OLEAUT32.@]
3639 */
3640 HRESULT WINAPI VarBstrFromDec(DECIMAL* pDecIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3641 {
3642 if(!pDecIn->u.s.sign && !pDecIn->u.s.scale &&
3643 !pDecIn->Hi32 && !pDecIn->u1.s1.Mid32)
3644 return VarBstrFromUI4(pDecIn->u1.s1.Lo32, lcid, dwFlags, pbstrOut);
3645 FIXME("%c%08lx%08lx%08lx E%02x stub\n",
3646 (pDecIn->u.s.sign == DECIMAL_NEG) ? '-' :
3647 (pDecIn->u.s.sign == 0) ? '+' : '?',
3648 pDecIn->Hi32, pDecIn->u1.s1.Mid32, pDecIn->u1.s1.Lo32,
3649 pDecIn->u.s.scale);
3650 return E_INVALIDARG;
3651 }
3652
3653 /******************************************************************************
3654 * VarBoolFromUI1 [OLEAUT32.118]
3655 */
3656 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
3657 {
3658 TRACE("( %d, %p ), stub\n", bIn, pboolOut );
3659
3660 if( bIn == 0 )
3661 {
3662 *pboolOut = VARIANT_FALSE;
3663 }
3664 else
3665 {
3666 *pboolOut = VARIANT_TRUE;
3667 }
3668
3669 return S_OK;
3670 }
3671
3672 /******************************************************************************
3673 * VarBoolFromI2 [OLEAUT32.119]
3674 */
3675 HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
3676 {
3677 TRACE("( %d, %p ), stub\n", sIn, pboolOut );
3678
3679 *pboolOut = (sIn) ? VARIANT_TRUE : VARIANT_FALSE;
3680
3681 return S_OK;
3682 }
3683
3684 /******************************************************************************
3685 * VarBoolFromI4 [OLEAUT32.120]
3686 */
3687 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
3688 {
3689 TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
3690
3691 *pboolOut = (lIn) ? VARIANT_TRUE : VARIANT_FALSE;
3692
3693 return S_OK;
3694 }
3695
3696 /******************************************************************************
3697 * VarBoolFromR4 [OLEAUT32.121]
3698 */
3699 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
3700 {
3701 TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
3702
3703 *pboolOut = (fltIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3704
3705 return S_OK;
3706 }
3707
3708 /******************************************************************************
3709 * VarBoolFromR8 [OLEAUT32.122]
3710 */
3711 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
3712 {
3713 TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
3714
3715 *pboolOut = (dblIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3716
3717 return S_OK;
3718 }
3719
3720 /******************************************************************************
3721 * VarBoolFromDate [OLEAUT32.123]
3722 */
3723 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
3724 {
3725 TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
3726
3727 *pboolOut = (dateIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3728
3729 return S_OK;
3730 }
3731
3732 /******************************************************************************
3733 * VarBoolFromStr [OLEAUT32.125]
3734 */
3735 HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
3736 {
3737 HRESULT ret = S_OK;
3738 char* pNewString = NULL;
3739
3740 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
3741
3742 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3743
3744 if( pNewString == NULL || strlen( pNewString ) == 0 )
3745 {
3746 ret = DISP_E_TYPEMISMATCH;
3747 }
3748
3749 if( ret == S_OK )
3750 {
3751 if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
3752 {
3753 *pboolOut = VARIANT_TRUE;
3754 }
3755 else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
3756 {
3757 *pboolOut = VARIANT_FALSE;
3758 }
3759 else
3760 {
3761 /* Try converting the string to a floating point number.
3762 */
3763 double dValue = 0.0;
3764 HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
3765 if( res != S_OK )
3766 {
3767 ret = DISP_E_TYPEMISMATCH;
3768 }
3769 else
3770 *pboolOut = (dValue == 0.0) ?
3771 VARIANT_FALSE : VARIANT_TRUE;
3772 }
3773 }
3774
3775 HeapFree( GetProcessHeap(), 0, pNewString );
3776
3777 return ret;
3778 }
3779
3780 /******************************************************************************
3781 * VarBoolFromI1 [OLEAUT32.233]
3782 */
3783 HRESULT WINAPI VarBoolFromI1(signed char cIn, VARIANT_BOOL* pboolOut)
3784 {
3785 TRACE("( %c, %p ), stub\n", cIn, pboolOut );
3786
3787 *pboolOut = (cIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3788
3789 return S_OK;
3790 }
3791
3792 /******************************************************************************
3793 * VarBoolFromUI2 [OLEAUT32.234]
3794 */
3795 HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
3796 {
3797 TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
3798
3799 *pboolOut = (uiIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3800
3801 return S_OK;
3802 }
3803
3804 /******************************************************************************
3805 * VarBoolFromUI4 [OLEAUT32.235]
3806 */
3807 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
3808 {
3809 TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
3810
3811 *pboolOut = (ulIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3812
3813 return S_OK;
3814 }
3815
3816 /**********************************************************************
3817 * VarBoolFromCy [OLEAUT32.124]
3818 * Convert currency to boolean
3819 */
3820 HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) {
3821 if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
3822 else *pboolOut = 0;
3823
3824 return S_OK;
3825 }
3826
3827 /******************************************************************************
3828 * VarI1FromUI1 [OLEAUT32.244]
3829 */
3830 HRESULT WINAPI VarI1FromUI1(BYTE bIn, signed char *pcOut)
3831 {
3832 TRACE("( %d, %p ), stub\n", bIn, pcOut );
3833
3834 /* Check range of value.
3835 */
3836 if( bIn > CHAR_MAX )
3837 {
3838 return DISP_E_OVERFLOW;
3839 }
3840
3841 *pcOut = (CHAR) bIn;
3842
3843 return S_OK;
3844 }
3845
3846 /******************************************************************************
3847 * VarI1FromI2 [OLEAUT32.245]
3848 */
3849 HRESULT WINAPI VarI1FromI2(short uiIn, signed char *pcOut)
3850 {
3851 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3852
3853 if( uiIn > CHAR_MAX )
3854 {
3855 return DISP_E_OVERFLOW;
3856 }
3857
3858 *pcOut = (CHAR) uiIn;
3859
3860 return S_OK;
3861 }
3862
3863 /******************************************************************************
3864 * VarI1FromI4 [OLEAUT32.246]
3865 */
3866 HRESULT WINAPI VarI1FromI4(LONG lIn, signed char *pcOut)
3867 {
3868 TRACE("( %ld, %p ), stub\n", lIn, pcOut );
3869
3870 if( lIn < CHAR_MIN || lIn > CHAR_MAX )
3871 {
3872 return DISP_E_OVERFLOW;
3873 }
3874
3875 *pcOut = (CHAR) lIn;
3876
3877 return S_OK;
3878 }
3879
3880 /******************************************************************************
3881 * VarI1FromR4 [OLEAUT32.247]
3882 */
3883 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, signed char *pcOut)
3884 {
3885 TRACE("( %f, %p ), stub\n", fltIn, pcOut );
3886
3887 fltIn = round( fltIn );
3888 if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
3889 {
3890 return DISP_E_OVERFLOW;
3891 }
3892
3893 *pcOut = (CHAR) fltIn;
3894
3895 return S_OK;
3896 }
3897
3898 /******************************************************************************
3899 * VarI1FromR8 [OLEAUT32.248]
3900 */
3901 HRESULT WINAPI VarI1FromR8(double dblIn, signed char *pcOut)
3902 {
3903 TRACE("( %f, %p ), stub\n", dblIn, pcOut );
3904
3905 dblIn = round( dblIn );
3906 if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
3907 {
3908 return DISP_E_OVERFLOW;
3909 }
3910
3911 *pcOut = (CHAR) dblIn;
3912
3913 return S_OK;
3914 }
3915
3916 /******************************************************************************
3917 * VarI1FromDate [OLEAUT32.249]
3918 */
3919 HRESULT WINAPI VarI1FromDate(DATE dateIn, signed char *pcOut)
3920 {
3921 TRACE("( %f, %p ), stub\n", dateIn, pcOut );
3922
3923 dateIn = round( dateIn );
3924 if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
3925 {
3926 return DISP_E_OVERFLOW;
3927 }
3928
3929 *pcOut = (CHAR) dateIn;
3930
3931 return S_OK;
3932 }
3933
3934 /******************************************************************************
3935 * VarI1FromStr [OLEAUT32.251]
3936 */
3937 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed char *pcOut)
3938 {
3939 double dValue = 0.0;
3940 LPSTR pNewString = NULL;
3941
3942 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
3943
3944 /* Check if we have a valid argument
3945 */
3946 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3947 RemoveCharacterFromString( pNewString, "," );
3948 if( IsValidRealString( pNewString ) == FALSE )
3949 {
3950 return DISP_E_TYPEMISMATCH;
3951 }
3952
3953 /* Convert the valid string to a floating point number.
3954 */
3955 dValue = atof( pNewString );
3956
3957 /* We don't need the string anymore so free it.
3958 */
3959 HeapFree( GetProcessHeap(), 0, pNewString );
3960
3961 /* Check range of value.
3962 */
3963 dValue = round( dValue );
3964 if( dValue < CHAR_MIN || dValue > CHAR_MAX )
3965 {
3966 return DISP_E_OVERFLOW;
3967 }
3968
3969 *pcOut = (CHAR) dValue;
3970
3971 return S_OK;
3972 }
3973
3974 /******************************************************************************
3975 * VarI1FromBool [OLEAUT32.253]
3976 */
3977 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, signed char *pcOut)
3978 {
3979 TRACE("( %d, %p ), stub\n", boolIn, pcOut );
3980
3981 *pcOut = (CHAR) boolIn;
3982
3983 return S_OK;
3984 }
3985
3986 /******************************************************************************
3987 * VarI1FromUI2 [OLEAUT32.254]
3988 */
3989 HRESULT WINAPI VarI1FromUI2(USHORT uiIn, signed char *pcOut)
3990 {
3991 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3992
3993 if( uiIn > CHAR_MAX )
3994 {
3995 return DISP_E_OVERFLOW;
3996 }
3997
3998 *pcOut = (CHAR) uiIn;
3999
4000 return S_OK;
4001 }
4002
4003 /******************************************************************************
4004 * VarI1FromUI4 [OLEAUT32.255]
4005 */
4006 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, signed char *pcOut)
4007 {
4008 TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
4009
4010 if( ulIn > CHAR_MAX )
4011 {
4012 return DISP_E_OVERFLOW;
4013 }
4014
4015 *pcOut = (CHAR) ulIn;
4016
4017 return S_OK;
4018 }
4019
4020 /**********************************************************************
4021 * VarI1FromCy [OLEAUT32.250]
4022 * Convert currency to signed char
4023 */
4024 HRESULT WINAPI VarI1FromCy(CY cyIn, signed char *pcOut) {
4025 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4026
4027 if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
4028
4029 *pcOut = (CHAR)t;
4030 return S_OK;
4031 }
4032
4033 /******************************************************************************
4034 * VarUI2FromUI1 [OLEAUT32.257]
4035 */
4036 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
4037 {
4038 TRACE("( %d, %p ), stub\n", bIn, puiOut );
4039
4040 *puiOut = (USHORT) bIn;
4041
4042 return S_OK;
4043 }
4044
4045 /******************************************************************************
4046 * VarUI2FromI2 [OLEAUT32.258]
4047 */
4048 HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
4049 {
4050 TRACE("( %d, %p ), stub\n", uiIn, puiOut );
4051
4052 if( uiIn < UI2_MIN )
4053 {
4054 return DISP_E_OVERFLOW;
4055 }
4056
4057 *puiOut = (USHORT) uiIn;
4058
4059 return S_OK;
4060 }
4061
4062 /******************************************************************************
4063 * VarUI2FromI4 [OLEAUT32.259]
4064 */
4065 HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
4066 {
4067 TRACE("( %ld, %p ), stub\n", lIn, puiOut );
4068
4069 if( lIn < UI2_MIN || lIn > UI2_MAX )
4070 {
4071 return DISP_E_OVERFLOW;
4072 }
4073
4074 *puiOut = (USHORT) lIn;
4075
4076 return S_OK;
4077 }
4078
4079 /******************************************************************************
4080 * VarUI2FromR4 [OLEAUT32.260]
4081 */
4082 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
4083 {
4084 TRACE("( %f, %p ), stub\n", fltIn, puiOut );
4085
4086 fltIn = round( fltIn );
4087 if( fltIn < UI2_MIN || fltIn > UI2_MAX )
4088 {
4089 return DISP_E_OVERFLOW;
4090 }
4091
4092 *puiOut = (USHORT) fltIn;
4093
4094 return S_OK;
4095 }
4096
4097 /******************************************************************************
4098 * VarUI2FromR8 [OLEAUT32.261]
4099 */
4100 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
4101 {
4102 TRACE("( %f, %p ), stub\n", dblIn, puiOut );
4103
4104 dblIn = round( dblIn );
4105 if( dblIn < UI2_MIN || dblIn > UI2_MAX )
4106 {
4107 return DISP_E_OVERFLOW;
4108 }
4109
4110 *puiOut = (USHORT) dblIn;
4111
4112 return S_OK;
4113 }
4114
4115 /******************************************************************************
4116 * VarUI2FromDate [OLEAUT32.262]
4117 */
4118 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
4119 {
4120 TRACE("( %f, %p ), stub\n", dateIn, puiOut );
4121
4122 dateIn = round( dateIn );
4123 if( dateIn < UI2_MIN || dateIn > UI2_MAX )
4124 {
4125 return DISP_E_OVERFLOW;
4126 }
4127
4128 *puiOut = (USHORT) dateIn;
4129
4130 return S_OK;
4131 }
4132
4133 /******************************************************************************
4134 * VarUI2FromStr [OLEAUT32.264]
4135 */
4136 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
4137 {
4138 double dValue = 0.0;
4139 LPSTR pNewString = NULL;
4140
4141 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
4142
4143 /* Check if we have a valid argument
4144 */
4145 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4146 RemoveCharacterFromString( pNewString, "," );
4147 if( IsValidRealString( pNewString ) == FALSE )
4148 {
4149 return DISP_E_TYPEMISMATCH;
4150 }
4151
4152 /* Convert the valid string to a floating point number.
4153 */
4154 dValue = atof( pNewString );
4155
4156 /* We don't need the string anymore so free it.
4157 */
4158 HeapFree( GetProcessHeap(), 0, pNewString );
4159
4160 /* Check range of value.
4161 */
4162 dValue = round( dValue );
4163 if( dValue < UI2_MIN || dValue > UI2_MAX )
4164 {
4165 return DISP_E_OVERFLOW;
4166 }
4167
4168 *puiOut = (USHORT) dValue;
4169
4170 return S_OK;
4171 }
4172
4173 /******************************************************************************
4174 * VarUI2FromBool [OLEAUT32.266]
4175 */
4176 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
4177 {
4178 TRACE("( %d, %p ), stub\n", boolIn, puiOut );
4179
4180 *puiOut = (USHORT) boolIn;
4181
4182 return S_OK;
4183 }
4184
4185 /******************************************************************************
4186 * VarUI2FromI1 [OLEAUT32.267]
4187 */
4188 HRESULT WINAPI VarUI2FromI1(signed char cIn, USHORT* puiOut)
4189 {
4190 TRACE("( %c, %p ), stub\n", cIn, puiOut );
4191
4192 *puiOut = (USHORT) cIn;
4193
4194 return S_OK;
4195 }
4196
4197 /******************************************************************************
4198 * VarUI2FromUI4 [OLEAUT32.268]
4199 */
4200 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
4201 {
4202 TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
4203
4204 if( ulIn > UI2_MAX )
4205 {
4206 return DISP_E_OVERFLOW;
4207 }
4208
4209 *puiOut = (USHORT) ulIn;
4210
4211 return S_OK;
4212 }
4213
4214 /******************************************************************************
4215 * VarUI4FromStr [OLEAUT32.277]
4216 */
4217 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
4218 {
4219 double dValue = 0.0;
4220 LPSTR pNewString = NULL;
4221
4222 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
4223
4224 /* Check if we have a valid argument
4225 */
4226 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4227 RemoveCharacterFromString( pNewString, "," );
4228 if( IsValidRealString( pNewString ) == FALSE )
4229 {
4230 return DISP_E_TYPEMISMATCH;
4231 }
4232
4233 /* Convert the valid string to a floating point number.
4234 */
4235 dValue = atof( pNewString );
4236
4237 /* We don't need the string anymore so free it.
4238 */
4239 HeapFree( GetProcessHeap(), 0, pNewString );
4240
4241 /* Check range of value.
4242 */
4243 dValue = round( dValue );
4244 if( dValue < UI4_MIN || dValue > UI4_MAX )
4245 {
4246 return DISP_E_OVERFLOW;
4247 }
4248
4249 *pulOut = (ULONG) dValue;
4250
4251 return S_OK;
4252 }
4253
4254 /**********************************************************************
4255 * VarUI2FromCy [OLEAUT32.263]
4256 * Convert currency to unsigned short
4257 */
4258 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
4259 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4260
4261 if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
4262
4263 *pusOut = (USHORT)t;
4264
4265 return S_OK;
4266 }
4267
4268 /******************************************************************************
4269 * VarUI4FromUI1 [OLEAUT32.270]
4270 */
4271 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
4272 {
4273 TRACE("( %d, %p ), stub\n", bIn, pulOut );
4274
4275 *pulOut = (USHORT) bIn;
4276
4277 return S_OK;
4278 }
4279
4280 /******************************************************************************
4281 * VarUI4FromI2 [OLEAUT32.271]
4282 */
4283 HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
4284 {
4285 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4286
4287 if( uiIn < UI4_MIN )
4288 {
4289 return DISP_E_OVERFLOW;
4290 }
4291
4292 *pulOut = (ULONG) uiIn;
4293
4294 return S_OK;
4295 }
4296
4297 /******************************************************************************
4298 * VarUI4FromI4 [OLEAUT32.272]
4299 */
4300 HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
4301 {
4302 TRACE("( %ld, %p ), stub\n", lIn, pulOut );
4303
4304 if( lIn < 0 )
4305 {
4306 return DISP_E_OVERFLOW;
4307 }
4308
4309 *pulOut = (ULONG) lIn;
4310
4311 return S_OK;
4312 }
4313
4314 /******************************************************************************
4315 * VarUI4FromR4 [OLEAUT32.273]
4316 */
4317 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
4318 {
4319 fltIn = round( fltIn );
4320 if( fltIn < UI4_MIN || fltIn > UI4_MAX )
4321 {
4322 return DISP_E_OVERFLOW;
4323 }
4324
4325 *pulOut = (ULONG) fltIn;
4326
4327 return S_OK;
4328 }
4329
4330 /******************************************************************************
4331 * VarUI4FromR8 [OLEAUT32.274]
4332 */
4333 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
4334 {
4335 TRACE("( %f, %p ), stub\n", dblIn, pulOut );
4336
4337 dblIn = round( dblIn );
4338 if( dblIn < UI4_MIN || dblIn > UI4_MAX )
4339 {
4340 return DISP_E_OVERFLOW;
4341 }
4342
4343 *pulOut = (ULONG) dblIn;
4344
4345 return S_OK;
4346 }
4347
4348 /******************************************************************************
4349 * VarUI4FromDate [OLEAUT32.275]
4350 */
4351 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
4352 {
4353 TRACE("( %f, %p ), stub\n", dateIn, pulOut );
4354
4355 dateIn = round( dateIn );
4356 if( dateIn < UI4_MIN || dateIn > UI4_MAX )
4357 {
4358 return DISP_E_OVERFLOW;
4359 }
4360
4361 *pulOut = (ULONG) dateIn;
4362
4363 return S_OK;
4364 }
4365
4366 /******************************************************************************
4367 * VarUI4FromBool [OLEAUT32.279]
4368 */
4369 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
4370 {
4371 TRACE("( %d, %p ), stub\n", boolIn, pulOut );
4372
4373 *pulOut = (ULONG) boolIn;
4374
4375 return S_OK;
4376 }
4377
4378 /******************************************************************************
4379 * VarUI4FromI1 [OLEAUT32.280]
4380 */
4381 HRESULT WINAPI VarUI4FromI1(signed char cIn, ULONG* pulOut)
4382 {
4383 TRACE("( %c, %p ), stub\n", cIn, pulOut );
4384
4385 *pulOut = (ULONG) cIn;
4386
4387 return S_OK;
4388 }
4389
4390 /******************************************************************************
4391 * VarUI4FromUI2 [OLEAUT32.281]
4392 */
4393 HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
4394 {
4395 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4396
4397 *pulOut = (ULONG) uiIn;
4398
4399 return S_OK;
4400 }
4401
4402 /**********************************************************************
4403 * VarUI4FromCy [OLEAUT32.276]
4404 * Convert currency to unsigned long
4405 */
4406 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
4407 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4408
4409 if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
4410
4411 *pulOut = (ULONG)t;
4412
4413 return S_OK;
4414 }
4415
4416 /**********************************************************************
4417 * VarCyFromUI1 [OLEAUT32.98]
4418 * Convert unsigned char to currency
4419 */
4420 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
4421 pcyOut->s.Hi = 0;
4422 pcyOut->s.Lo = ((ULONG)bIn) * 10000;
4423
4424 return S_OK;
4425 }
4426
4427 /**********************************************************************
4428 * VarCyFromI2 [OLEAUT32.99]
4429 * Convert signed short to currency
4430 */
4431 HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
4432 if (sIn < 0) pcyOut->s.Hi = -1;
4433 else pcyOut->s.Hi = 0;
4434 pcyOut->s.Lo = ((ULONG)sIn) * 10000;
4435
4436 return S_OK;
4437 }
4438
4439 /**********************************************************************
4440 * VarCyFromI4 [OLEAUT32.100]
4441 * Convert signed long to currency
4442 */
4443 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
4444 double t = (double)lIn * (double)10000;
4445 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4446 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4447 if (lIn < 0) pcyOut->s.Hi--;
4448
4449 return S_OK;
4450 }
4451
4452 /**********************************************************************
4453 * VarCyFromR4 [OLEAUT32.101]
4454 * Convert float to currency
4455 */
4456 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
4457 double t = round((double)fltIn * (double)10000);
4458 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4459 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4460 if (fltIn < 0) pcyOut->s.Hi--;
4461
4462 return S_OK;
4463 }
4464
4465 /**********************************************************************
4466 * VarCyFromR8 [OLEAUT32.102]
4467 * Convert double to currency
4468 */
4469 HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
4470 double t = round(dblIn * (double)10000);
4471 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4472 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4473 if (dblIn < 0) pcyOut->s.Hi--;
4474
4475 return S_OK;
4476 }
4477
4478 /**********************************************************************
4479 * VarCyFromDate [OLEAUT32.103]
4480 * Convert date to currency
4481 */
4482 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
4483 double t = round((double)dateIn * (double)10000);
4484 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4485 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4486 if (dateIn < 0) pcyOut->s.Hi--;
4487
4488 return S_OK;
4489 }
4490
4491 /**********************************************************************
4492 * VarCyFromStr [OLEAUT32.104]
4493 * FIXME: Never tested with decimal separator other than '.'
4494 */
4495 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
4496
4497 LPSTR pNewString = NULL;
4498 char *decSep = NULL;
4499 char *strPtr,*curPtr = NULL;
4500 int size, rc;
4501 double currencyVal = 0.0;
4502
4503
4504 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4505 TRACE("( '%s', 0x%08lx, 0x%08lx, %p )\n", pNewString, lcid, dwFlags, pcyOut );
4506
4507 /* Get locale information - Decimal Separator (size includes 0x00) */
4508 size = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, NULL, 0);
4509 decSep = (char *) malloc(size);
4510 rc = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, decSep, size);
4511 TRACE("Decimal Separator is '%s'\n", decSep);
4512
4513 /* Now copy to temporary buffer, skipping any character except 0-9 and
4514 the decimal separator */
4515 curPtr = pBuffer; /* Current position in string being built */
4516 strPtr = pNewString; /* Current position in supplied currenct string */
4517
4518 while (*strPtr) {
4519 /* If decimal separator, skip it and put '.' in string */
4520 if (strncmp(strPtr, decSep, (size-1)) == 0) {
4521 strPtr = strPtr + (size-1);
4522 *curPtr = '.';
4523 curPtr++;
4524 } else if ((*strPtr == '+' || *strPtr == '-') ||
4525 (*strPtr >= '0' && *strPtr <= '9')) {
4526 *curPtr = *strPtr;
4527 strPtr++;
4528 curPtr++;
4529 } else strPtr++;
4530 }
4531 *curPtr = 0x00;
4532
4533 /* Try to get currency into a double */
4534 currencyVal = atof(pBuffer);
4535 TRACE("Converted string '%s' to %f\n", pBuffer, currencyVal);
4536
4537 /* Free allocated storage */
4538 HeapFree( GetProcessHeap(), 0, pNewString );
4539 free(decSep);
4540
4541 /* Convert double -> currency using internal routine */
4542 return VarCyFromR8(currencyVal, pcyOut);
4543 }
4544
4545
4546 /**********************************************************************
4547 * VarCyFromBool [OLEAUT32.106]
4548 * Convert boolean to currency
4549 */
4550 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
4551 if (boolIn < 0) pcyOut->s.Hi = -1;
4552 else pcyOut->s.Hi = 0;
4553 pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
4554
4555 return S_OK;
4556 }
4557
4558 /**********************************************************************
4559 * VarCyFromI1 [OLEAUT32.225]
4560 * Convert signed char to currency
4561 */
4562 HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pcyOut) {
4563 if (cIn < 0) pcyOut->s.Hi = -1;
4564 else pcyOut->s.Hi = 0;
4565 pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
4566
4567 return S_OK;
4568 }
4569
4570 /**********************************************************************
4571 * VarCyFromUI2 [OLEAUT32.226]
4572 * Convert unsigned short to currency
4573 */
4574 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
4575 pcyOut->s.Hi = 0;
4576 pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
4577
4578 return S_OK;
4579 }
4580
4581 /**********************************************************************
4582 * VarCyFromUI4 [OLEAUT32.227]
4583 * Convert unsigned long to currency
4584 */
4585 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) {
4586 double t = (double)ulIn * (double)10000;
4587 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4588 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4589
4590 return S_OK;
4591 }
4592
4593 /**********************************************************************
4594 * VarDecFromStr [OLEAUT32.@]
4595 */
4596 HRESULT WINAPI VarDecFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags,
4597 DECIMAL* pdecOut)
4598 { WCHAR *p=strIn;
4599 ULONGLONG t;
4600 ULONG cy;
4601
4602 DECIMAL_SETZERO(pdecOut);
4603
4604 if(*p == (WCHAR)'-')pdecOut->u.s.sign= DECIMAL_NEG;
4605 if((*p == (WCHAR)'-') || (*p == (WCHAR)'+')) p++;
4606 for(;*p != (WCHAR)0; p++) {
4607 if((*p < (WCHAR)'0')||(*p > (WCHAR)'9')) goto error ;
4608 t = (ULONGLONG)pdecOut->u1.s1.Lo32 *(ULONGLONG)10
4609 + (ULONGLONG)(*p -(WCHAR)'0');
4610 cy = (ULONG)(t >> 32);
4611 pdecOut->u1.s1.Lo32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4612 t = (ULONGLONG)pdecOut->u1.s1.Mid32 * (ULONGLONG)10
4613 + (ULONGLONG)cy;
4614 cy = (ULONG)(t >> 32);
4615 pdecOut->u1.s1.Mid32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4616 t = (ULONGLONG)pdecOut->Hi32 * (ULONGLONG)10
4617 + (ULONGLONG)cy;
4618 cy = (ULONG)(t >> 32);
4619 pdecOut->Hi32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4620 if(cy) goto overflow ;
4621 }
4622 TRACE("%s -> sign %02x,hi %08lx,mid %08lx, lo%08lx, scale %08x\n",
4623 debugstr_w(strIn),
4624 pdecOut->u.s.sign, pdecOut->Hi32, pdecOut->u1.s1.Mid32,
4625 pdecOut->u1.s1.Lo32, pdecOut->u.s.scale);
4626 return S_OK;
4627
4628 overflow:
4629 /* like NT4 SP5 */
4630 pdecOut->Hi32 = pdecOut->u1.s1.Mid32 = pdecOut->u1.s1.Lo32 = 0xffffffff;
4631 return DISP_E_OVERFLOW;
4632
4633 error:
4634 ERR("%s: unknown char at pos %d\n",
4635 debugstr_w(strIn), p - strIn + 1);
4636 return DISP_E_TYPEMISMATCH;
4637 }
4638
4639 /**********************************************************************
4640 * DosDateTimeToVariantTime [OLEAUT32.14]
4641 * Convert dos representation of time to the date and time representation
4642 * stored in a variant.
4643 */
4644 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
4645 DATE *pvtime)
4646 {
4647 struct tm t;
4648
4649 TRACE("( 0x%x, 0x%x, %p ), stub\n", wDosDate, wDosTime, pvtime );
4650
4651 t.tm_sec = (wDosTime & 0x001f) * 2;
4652 t.tm_min = (wDosTime & 0x07e0) >> 5;
4653 t.tm_hour = (wDosTime & 0xf800) >> 11;
4654
4655 t.tm_mday = (wDosDate & 0x001f);
4656 t.tm_mon = (wDosDate & 0x01e0) >> 5;
4657 t.tm_year = ((wDosDate & 0xfe00) >> 9) + 1980;
4658
4659 return TmToDATE( &t, pvtime );
4660 }
4661
4662
4663 /**********************************************************************
4664 * VarParseNumFromStr [OLEAUT32.46]
4665 */
4666 HRESULT WINAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags,
4667 NUMPARSE * pnumprs, BYTE * rgbDig)
4668 {
4669 int i,lastent=0;
4670 int cDig;
4671 BOOL foundNum=FALSE;
4672
4673 FIXME("(%s,flags=%lx,....), partial stub!\n",debugstr_w(strIn),dwFlags);
4674 FIXME("numparse: cDig=%d, InFlags=%lx\n",pnumprs->cDig,pnumprs->dwInFlags);
4675
4676 /* The other struct components are to be set by us */
4677 memset(rgbDig,0,pnumprs->cDig);
4678
4679 /* FIXME: Just patching some values in */
4680 pnumprs->nPwr10 = 0;
4681 pnumprs->nBaseShift = 0;
4682 pnumprs->cchUsed = lastent;
4683 pnumprs->dwOutFlags = NUMPRS_DECIMAL;
4684
4685 cDig = 0;
4686 for (i=0; strIn[i] ;i++) {
4687 if ((strIn[i]>='0') && (strIn[i]<='9')) {
4688 foundNum = TRUE;
4689 if (pnumprs->cDig > cDig) {
4690 *(rgbDig++)=strIn[i]-'0';
4691 cDig++;
4692 lastent = i;
4693 }
4694 } else if ((strIn[i]=='-') && (foundNum==FALSE)) {
4695 pnumprs->dwOutFlags |= NUMPRS_NEG;
4696 }
4697 }
4698 pnumprs->cDig = cDig;
4699 TRACE("numparse out: cDig=%d, OutFlags=%lx\n",pnumprs->cDig,pnumprs->dwOutFlags);
4700 return S_OK;
4701 }
4702
4703
4704 /**********************************************************************
4705 * VarNumFromParseNum [OLEAUT32.47]
4706 */
4707 HRESULT WINAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig,
4708 ULONG dwVtBits, VARIANT * pvar)
4709 {
4710 DWORD xint;
4711 int i;
4712 FIXME("(..,dwVtBits=%lx,....), partial stub!\n",dwVtBits);
4713
4714 xint = 0;
4715 for (i=0;i<pnumprs->cDig;i++)
4716 xint = xint*10 + rgbDig[i];
4717
4718 if (pnumprs->dwOutFlags & NUMPRS_NEG) {
4719 xint = xint * -1;
4720 }
4721
4722 VariantInit(pvar);
4723 if (dwVtBits & VTBIT_I4) {
4724 V_VT(pvar) = VT_I4;
4725 V_UNION(pvar,intVal) = xint;
4726 return S_OK;
4727 }
4728 if (dwVtBits & VTBIT_R8) {
4729 V_VT(pvar) = VT_R8;
4730 V_UNION(pvar,dblVal) = xint;
4731 return S_OK;
4732 }
4733 if (dwVtBits & VTBIT_R4) {
4734 V_VT(pvar) = VT_R4;
4735 V_UNION(pvar,fltVal) = xint;
4736 return S_OK;
4737 }
4738 if (dwVtBits & VTBIT_I2) {
4739 V_VT(pvar) = VT_I2;
4740 V_UNION(pvar,iVal) = xint;
4741 return S_OK;
4742 }
4743 /* FIXME: Currency should be from a double */
4744 if (dwVtBits & VTBIT_CY) {
4745 V_VT(pvar) = VT_CY;
4746 TRACE("Calculated currency is xint=%ld\n", xint);
4747 VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4748 TRACE("Calculated cy is %ld,%lu\n", V_UNION(pvar,cyVal).s.Hi, V_UNION(pvar,cyVal).s.Lo);
4749 return VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4750 }
4751
4752 FIXME("vtbitmask is unsupported %lx, int=%d\n",dwVtBits, (int) xint);
4753 return E_FAIL;
4754 }
4755
4756
4757 /**********************************************************************
4758 * VarFormatDateTime [OLEAUT32.97]
4759 */
4760 HRESULT WINAPI VarFormatDateTime(LPVARIANT var, INT format, ULONG dwFlags, BSTR *out)
4761 {
4762 FIXME("%p %d %lx %p\n", var, format, dwFlags, out);
4763 return E_NOTIMPL;
4764 }
4765
4766 /**********************************************************************
4767 * VarFormatCurrency [OLEAUT32.127]
4768 */
4769 HRESULT WINAPI VarFormatCurrency(LPVARIANT var, INT digits, INT lead, INT paren, INT group, ULONG dwFlags, BSTR *out)
4770 {
4771 FIXME("%p %d %d %d %d %lx %p\n", var, digits, lead, paren, group, dwFlags, out);
4772 return E_NOTIMPL;
4773 }
4774
4775 /**********************************************************************
4776 * VariantTimeToDosDateTime [OLEAUT32.13]
4777 * Convert variant representation of time to the date and time representation
4778 * stored in dos.
4779 */
4780 INT WINAPI VariantTimeToDosDateTime(DATE pvtime, USHORT *wDosDate, USHORT *wDosTime)
4781 {
4782 struct tm t;
4783 *wDosTime = 0;
4784 *wDosDate = 0;
4785
4786 TRACE("( 0x%x, 0x%x, %p ), stub\n", *wDosDate, *wDosTime, &pvtime );
4787
4788 if (DateToTm(pvtime, 0, &t) < 0) return 0;
4789
4790 *wDosTime = *wDosTime | (t.tm_sec / 2);
4791 *wDosTime = *wDosTime | (t.tm_min << 5);
4792 *wDosTime = *wDosTime | (t.tm_hour << 11);
4793
4794 *wDosDate = *wDosDate | t.tm_mday ;
4795 *wDosDate = *wDosDate | t.tm_mon << 5;
4796 *wDosDate = *wDosDate | ((t.tm_year - 1980) << 9) ;
4797
4798 return 1;
4799 }
4800
4801
4802 /***********************************************************************
4803 * SystemTimeToVariantTime [OLEAUT32.184]
4804 */
4805 HRESULT WINAPI SystemTimeToVariantTime( LPSYSTEMTIME lpSystemTime, double *pvtime )
4806 {
4807 struct tm t;
4808
4809 TRACE(" %d/%d/%d %d:%d:%d\n",
4810 lpSystemTime->wMonth, lpSystemTime->wDay,
4811 lpSystemTime->wYear, lpSystemTime->wHour,
4812 lpSystemTime->wMinute, lpSystemTime->wSecond);
4813
4814 if (lpSystemTime->wYear >= 1900)
4815 {
4816 t.tm_sec = lpSystemTime->wSecond;
4817 t.tm_min = lpSystemTime->wMinute;
4818 t.tm_hour = lpSystemTime->wHour;
4819
4820 t.tm_mday = lpSystemTime->wDay;
4821 t.tm_mon = lpSystemTime->wMonth - 1; /* tm_mon is 0..11, wMonth is 1..12 */
4822 t.tm_year = lpSystemTime->wYear;
4823
4824 return TmToDATE( &t, pvtime );
4825 }
4826 else
4827 {
4828 double tmpDate;
4829 long firstDayOfNextYear;
4830 long thisDay;
4831 long leftInYear;
4832 long result;
4833
4834 double decimalPart = 0.0;
4835
4836 t.tm_sec = lpSystemTime->wSecond;
4837 t.tm_min = lpSystemTime->wMinute;
4838 t.tm_hour = lpSystemTime->wHour;
4839
4840 /* Step year forward the same number of years before 1900 */
4841 t.tm_year = 1900 + 1899 - lpSystemTime->wYear;
4842 t.tm_mon = lpSystemTime->wMonth - 1;
4843 t.tm_mday = lpSystemTime->wDay;
4844
4845 /* Calculate date */
4846 TmToDATE( &t, pvtime );
4847
4848 thisDay = (double) floor( *pvtime );
4849 decimalPart = fmod( *pvtime, thisDay );
4850
4851 /* Now, calculate the same time for the first of Jan that year */
4852 t.tm_mon = 0;
4853 t.tm_mday = 1;
4854 t.tm_sec = 0;
4855 t.tm_min = 0;
4856 t.tm_hour = 0;
4857 t.tm_year = t.tm_year+1;
4858 TmToDATE( &t, &tmpDate );
4859 firstDayOfNextYear = (long) floor(tmpDate);
4860
4861 /* Finally since we know the size of the year, subtract the two to get
4862 remaining time in the year */
4863 leftInYear = firstDayOfNextYear - thisDay;
4864
4865 /* Now we want full years up to the year in question, and remainder of year
4866 of the year in question */
4867 if (isleap(lpSystemTime->wYear) ) {
4868 TRACE("Extra day due to leap year\n");
4869 result = 2.0 - ((firstDayOfNextYear - 366) + leftInYear - 2.0);
4870 } else {
4871 result = 2.0 - ((firstDayOfNextYear - 365) + leftInYear - 2.0);
4872 }
4873 *pvtime = (double) result + decimalPart;
4874 TRACE("<1899 support: returned %f, 1st day %ld, thisday %ld, left %ld\n", *pvtime, firstDayOfNextYear, thisDay, leftInYear);
4875
4876 return 1;
4877 }
4878
4879 return 0;
4880 }
4881
4882 /***********************************************************************
4883 * VariantTimeToSystemTime [OLEAUT32.185]
4884 */
4885 HRESULT WINAPI VariantTimeToSystemTime( double vtime, LPSYSTEMTIME lpSystemTime )
4886 {
4887 double t = 0, timeofday = 0;
4888
4889 static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4890 static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4891
4892 /* The Month_Code is used to find the Day of the Week (LY = LeapYear)*/
4893 static const BYTE Month_Code[] = {0, 1, 4, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4894 static const BYTE Month_Code_LY[] = {0, 0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4895
4896 /* The Century_Code is used to find the Day of the Week */
4897 static const BYTE Century_Code[] = {0, 6, 4, 2};
4898
4899 struct tm r;
4900
4901 TRACE(" Variant = %f SYSTEMTIME ptr %p\n", vtime, lpSystemTime);
4902
4903 if (vtime >= 0)
4904 {
4905
4906 if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4907
4908 lpSystemTime->wSecond = r.tm_sec;
4909 lpSystemTime->wMinute = r.tm_min;
4910 lpSystemTime->wHour = r.tm_hour;
4911 lpSystemTime->wDay = r.tm_mday;
4912 lpSystemTime->wMonth = r.tm_mon;
4913
4914 if (lpSystemTime->wMonth == 12)
4915 lpSystemTime->wMonth = 1;
4916 else
4917 lpSystemTime->wMonth++;
4918
4919 lpSystemTime->wYear = r.tm_year;
4920 }
4921 else
4922 {
4923 vtime = -1*vtime;
4924
4925 if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4926
4927 lpSystemTime->wSecond = r.tm_sec;
4928 lpSystemTime->wMinute = r.tm_min;
4929 lpSystemTime->wHour = r.tm_hour;
4930
4931 lpSystemTime->wMonth = 13 - r.tm_mon;
4932
4933 if (lpSystemTime->wMonth == 1)
4934 lpSystemTime->wMonth = 12;
4935 else
4936 lpSystemTime->wMonth--;
4937
4938 lpSystemTime->wYear = 1899 - (r.tm_year - 1900);
4939
4940 if (!isleap(lpSystemTime->wYear) )
4941 lpSystemTime->wDay = Days_Per_Month[13 - lpSystemTime->wMonth] - r.tm_mday;
4942 else
4943 lpSystemTime->wDay = Days_Per_Month_LY[13 - lpSystemTime->wMonth] - r.tm_mday;
4944
4945
4946 }
4947
4948 if (!isleap(lpSystemTime->wYear))
4949 {
4950 /*
4951 (Century_Code+Month_Code+Year_Code+Day) % 7
4952
4953 The century code repeats every 400 years , so the array
4954 works out like this,
4955
4956 Century_Code[0] is for 16th/20th Centry
4957 Century_Code[1] is for 17th/21th Centry
4958 Century_Code[2] is for 18th/22th Centry
4959 Century_Code[3] is for 19th/23th Centry
4960
4961 The year code is found with the formula (year + (year / 4))
4962 the "year" must be between 0 and 99 .
4963
4964 The Month Code (Month_Code[1]) starts with January and
4965 ends with December.
4966 */
4967
4968 lpSystemTime->wDayOfWeek = (
4969 Century_Code[(( (lpSystemTime->wYear+100) - lpSystemTime->wYear%100) /100) %4]+
4970 ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4971 Month_Code[lpSystemTime->wMonth]+
4972 lpSystemTime->wDay) % 7;
4973
4974 if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4975 else lpSystemTime->wDayOfWeek -= 1;
4976 }
4977 else
4978 {
4979 lpSystemTime->wDayOfWeek = (
4980 Century_Code[(((lpSystemTime->wYear+100) - lpSystemTime->wYear%100)/100)%4]+
4981 ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4982 Month_Code_LY[lpSystemTime->wMonth]+
4983 lpSystemTime->wDay) % 7;
4984
4985 if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4986 else lpSystemTime->wDayOfWeek -= 1;
4987 }
4988
4989 t = floor(vtime);
4990 timeofday = vtime - t;
4991
4992 lpSystemTime->wMilliseconds = (timeofday
4993 - lpSystemTime->wHour*(1/24)
4994 - lpSystemTime->wMinute*(1/1440)
4995 - lpSystemTime->wSecond*(1/86400) )*(1/5184000);
4996
4997 return 1;
4998 }
4999
5000 /***********************************************************************
5001 * VarUdateFromDate [OLEAUT32.331]
5002 */
5003 HRESULT WINAPI VarUdateFromDate( DATE datein, ULONG dwFlags, UDATE *pudateout)
5004 {
5005 HRESULT i = 0;
5006 static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5007 static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5008
5009 TRACE("DATE = %f\n", (double)datein);
5010 i = VariantTimeToSystemTime(datein, &(pudateout->st) );
5011
5012 if (i)
5013 {
5014 pudateout->wDayOfYear = 0;
5015
5016 if (isleap(pudateout->st.wYear))
5017 {
5018 for (i =1; i<pudateout->st.wMonth; i++)
5019 pudateout->wDayOfYear += Days_Per_Month[i];
5020 }
5021 else
5022 {
5023 for (i =1; i<pudateout->st.wMonth; i++)
5024 pudateout->wDayOfYear += Days_Per_Month_LY[i];
5025 }
5026
5027 pudateout->wDayOfYear += pudateout->st.wDay;
5028 dwFlags = 0; /*VAR_VALIDDATE*/
5029 }
5030 else dwFlags = 0;
5031
5032 return i;
5033 }
5034
5035 /***********************************************************************
5036 * VarDateFromUdate [OLEAUT32.330]
5037 */
5038 HRESULT WINAPI VarDateFromUdate(UDATE *pudateout,
5039 ULONG dwFlags, DATE *datein)
5040 {
5041 HRESULT i;
5042 double t = 0;
5043 TRACE(" %d/%d/%d %d:%d:%d\n",
5044 pudateout->st.wMonth, pudateout->st.wDay,
5045 pudateout->st.wYear, pudateout->st.wHour,
5046 pudateout->st.wMinute, pudateout->st.wSecond);
5047
5048
5049 i = SystemTimeToVariantTime(&(pudateout->st), &t);
5050 *datein = t;
5051
5052 if (i) return S_OK;
5053 else return E_INVALIDARG;
5054 }
5055
5056
5057 /**********************************************************************
5058 * VarBstrCmp [OLEAUT32.314]
5059 *
5060 * flags can be:
5061 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5062 * NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5063 *
5064 */
5065 HRESULT WINAPI VarBstrCmp(BSTR left, BSTR right, LCID lcid, DWORD flags)
5066 {
5067 INT r;
5068
5069 TRACE("( %s %s %ld %lx ) partial stub\n", debugstr_w(left), debugstr_w(right), lcid, flags);
5070
5071 /* Contrary to the MSDN, this returns eq for null vs null, null vs L"" and L"" vs NULL */
5072 if((!left) || (!right)) {
5073
5074 if (!left && (!right || *right==0)) return VARCMP_EQ;
5075 else if (!right && (!left || *left==0)) return VARCMP_EQ;
5076 else return VARCMP_NULL;
5077 }
5078
5079 if(flags&NORM_IGNORECASE)
5080 r = lstrcmpiW(left,right);
5081 else
5082 r = lstrcmpW(left,right);
5083
5084 if(r<0)
5085 return VARCMP_LT;
5086 if(r>0)
5087 return VARCMP_GT;
5088
5089 return VARCMP_EQ;
5090 }
5091
5092 /**********************************************************************
5093 * VarBstrCat [OLEAUT32.313]
5094 */
5095 HRESULT WINAPI VarBstrCat(BSTR left, BSTR right, BSTR *out)
5096 {
5097 BSTR result;
5098 int size = 0;
5099
5100 TRACE("( %s %s %p )\n", debugstr_w(left), debugstr_w(right), out);
5101
5102 /* On Windows, NULL parms are still handled (as empty strings) */
5103 if (left) size=size + lstrlenW(left);
5104 if (right) size=size + lstrlenW(right);
5105
5106 if (out) {
5107 result = SysAllocStringLen(NULL, size);
5108 *out = result;
5109 if (left) lstrcatW(result,left);
5110 if (right) lstrcatW(result,right);
5111 TRACE("result = %s, [%p]\n", debugstr_w(result), result);
5112 }
5113 return S_OK;
5114 }
5115
5116 /**********************************************************************
5117 * VarCat [OLEAUT32.318]
5118 */
5119 HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out)
5120 {
5121 /* Should we VariantClear out? */
5122 /* Can we handle array, vector, by ref etc. */
5123 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL &&
5124 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5125 {
5126 V_VT(out) = VT_NULL;
5127 return S_OK;
5128 }
5129
5130 if (V_VT(left) == VT_BSTR && V_VT(right) == VT_BSTR)
5131 {
5132 V_VT(out) = VT_BSTR;
5133 VarBstrCat (V_BSTR(left), V_BSTR(right), &V_BSTR(out));
5134 return S_OK;
5135 }
5136 if (V_VT(left) == VT_BSTR) {
5137 VARIANT bstrvar;
5138 HRESULT hres;
5139
5140 V_VT(out) = VT_BSTR;
5141 hres = VariantChangeTypeEx(&bstrvar,right,0,0,VT_BSTR);
5142 if (hres) {
5143 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5144 return hres;
5145 }
5146 VarBstrCat (V_BSTR(left), V_BSTR(&bstrvar), &V_BSTR(out));
5147 return S_OK;
5148 }
5149 if (V_VT(right) == VT_BSTR) {
5150 VARIANT bstrvar;
5151 HRESULT hres;
5152
5153 V_VT(out) = VT_BSTR;
5154 hres = VariantChangeTypeEx(&bstrvar,left,0,0,VT_BSTR);
5155 if (hres) {
5156 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5157 return hres;
5158 }
5159 VarBstrCat (V_BSTR(&bstrvar), V_BSTR(right), &V_BSTR(out));
5160 return S_OK;
5161 }
5162 FIXME ("types %d / %d not supported\n",V_VT(left)&VT_TYPEMASK, V_VT(right)&VT_TYPEMASK);
5163 return S_OK;
5164 }
5165
5166 /**********************************************************************
5167 * VarCmp [OLEAUT32.176]
5168 *
5169 * flags can be:
5170 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5171 * NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5172 *
5173 */
5174 HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
5175 {
5176
5177
5178 BOOL lOk = TRUE;
5179 BOOL rOk = TRUE;
5180 LONGLONG lVal = -1;
5181 LONGLONG rVal = -1;
5182 VARIANT rv,lv;
5183 DWORD xmask;
5184 HRESULT rc;
5185
5186 VariantInit(&lv);VariantInit(&rv);
5187 V_VT(right) &= ~0x8000; /* hack since we sometime get this flag. */
5188 V_VT(left) &= ~0x8000; /* hack since we sometime get this flag. */
5189
5190 TRACE("Left Var:\n");
5191 dump_Variant(left);
5192 TRACE("Right Var:\n");
5193 dump_Variant(right);
5194
5195 /* If either are null, then return VARCMP_NULL */
5196 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL ||
5197 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5198 return VARCMP_NULL;
5199
5200 /* Strings - use VarBstrCmp */
5201 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5202 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5203 return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags);
5204 }
5205
5206 xmask = (1<<(V_VT(left)&VT_TYPEMASK))|(1<<(V_VT(right)&VT_TYPEMASK));
5207 if (xmask & (1<<VT_R8)) {
5208 rc = VariantChangeType(&lv,left,0,VT_R8);
5209 if (FAILED(rc)) return rc;
5210 rc = VariantChangeType(&rv,right,0,VT_R8);
5211 if (FAILED(rc)) return rc;
5212
5213 if (V_R8(&lv) == V_R8(&rv)) return VARCMP_EQ;
5214 if (V_R8(&lv) < V_R8(&rv)) return VARCMP_LT;
5215 if (V_R8(&lv) > V_R8(&rv)) return VARCMP_GT;
5216 return E_FAIL; /* can't get here */
5217 }
5218 if (xmask & (1<<VT_R4)) {
5219 rc = VariantChangeType(&lv,left,0,VT_R4);
5220 if (FAILED(rc)) return rc;
5221 rc = VariantChangeType(&rv,right,0,VT_R4);
5222 if (FAILED(rc)) return rc;
5223
5224 if (V_R4(&lv) == V_R4(&rv)) return VARCMP_EQ;
5225 if (V_R4(&lv) < V_R4(&rv)) return VARCMP_LT;
5226 if (V_R4(&lv) > V_R4(&rv)) return VARCMP_GT;
5227 return E_FAIL; /* can't get here */
5228 }
5229
5230 /* Integers - Ideally like to use VarDecCmp, but no Dec support yet
5231 Use LONGLONG to maximize ranges */
5232 lOk = TRUE;
5233 switch (V_VT(left)&VT_TYPEMASK) {
5234 case VT_I1 : lVal = V_UNION(left,cVal); break;
5235 case VT_I2 : lVal = V_UNION(left,iVal); break;
5236 case VT_I4 : lVal = V_UNION(left,lVal); break;
5237 case VT_INT : lVal = V_UNION(left,lVal); break;
5238 case VT_UI1 : lVal = V_UNION(left,bVal); break;
5239 case VT_UI2 : lVal = V_UNION(left,uiVal); break;
5240 case VT_UI4 : lVal = V_UNION(left,ulVal); break;
5241 case VT_UINT : lVal = V_UNION(left,ulVal); break;
5242 case VT_BOOL : lVal = V_UNION(left,boolVal); break;
5243 default: lOk = FALSE;
5244 }
5245
5246 rOk = TRUE;
5247 switch (V_VT(right)&VT_TYPEMASK) {
5248 case VT_I1 : rVal = V_UNION(right,cVal); break;
5249 case VT_I2 : rVal = V_UNION(right,iVal); break;
5250 case VT_I4 : rVal = V_UNION(right,lVal); break;
5251 case VT_INT : rVal = V_UNION(right,lVal); break;
5252 case VT_UI1 : rVal = V_UNION(right,bVal); break;
5253 case VT_UI2 : rVal = V_UNION(right,uiVal); break;
5254 case VT_UI4 : rVal = V_UNION(right,ulVal); break;
5255 case VT_UINT : rVal = V_UNION(right,ulVal); break;
5256 case VT_BOOL : rVal = V_UNION(right,boolVal); break;
5257 default: rOk = FALSE;
5258 }
5259
5260 if (lOk && rOk) {
5261 if (lVal < rVal) {
5262 return VARCMP_LT;
5263 } else if (lVal > rVal) {
5264 return VARCMP_GT;
5265 } else {
5266 return VARCMP_EQ;
5267 }
5268 }
5269
5270 /* Strings - use VarBstrCmp */
5271 if ((V_VT(left)&VT_TYPEMASK) == VT_DATE &&
5272 (V_VT(right)&VT_TYPEMASK) == VT_DATE) {
5273
5274 if (floor(V_UNION(left,date)) == floor(V_UNION(right,date))) {
5275 /* Due to floating point rounding errors, calculate varDate in whole numbers) */
5276 double wholePart = 0.0;
5277 double leftR;
5278 double rightR;
5279
5280 /* Get the fraction * 24*60*60 to make it into whole seconds */
5281 wholePart = (double) floor( V_UNION(left,date) );
5282 if (wholePart == 0) wholePart = 1;
5283 leftR = floor(fmod( V_UNION(left,date), wholePart ) * (24*60*60));
5284
5285 wholePart = (double) floor( V_UNION(right,date) );
5286 if (wholePart == 0) wholePart = 1;
5287 rightR = floor(fmod( V_UNION(right,date), wholePart ) * (24*60*60));
5288
5289 if (leftR < rightR) {
5290 return VARCMP_LT;
5291 } else if (leftR > rightR) {
5292 return VARCMP_GT;
5293 } else {
5294 return VARCMP_EQ;
5295 }
5296
5297 } else if (V_UNION(left,date) < V_UNION(right,date)) {
5298 return VARCMP_LT;
5299 } else if (V_UNION(left,date) > V_UNION(right,date)) {
5300 return VARCMP_GT;
5301 }
5302 }
5303 FIXME("VarCmp partial implementation, doesnt support vt 0x%x / 0x%x\n",V_VT(left), V_VT(right));
5304 return E_FAIL;
5305 }
5306
5307 /**********************************************************************
5308 * VarAnd [OLEAUT32.142]
5309 *
5310 */
5311 HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5312 {
5313 HRESULT rc = E_FAIL;
5314
5315 TRACE("Left Var:\n");
5316 dump_Variant(left);
5317 TRACE("Right Var:\n");
5318 dump_Variant(right);
5319
5320 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5321 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5322
5323 V_VT(result) = VT_BOOL;
5324 if (V_BOOL(left) && V_BOOL(right)) {
5325 V_BOOL(result) = VARIANT_TRUE;
5326 } else {
5327 V_BOOL(result) = VARIANT_FALSE;
5328 }
5329 rc = S_OK;
5330
5331 } else {
5332 /* Integers */
5333 BOOL lOk = TRUE;
5334 BOOL rOk = TRUE;
5335 LONGLONG lVal = -1;
5336 LONGLONG rVal = -1;
5337 LONGLONG res = -1;
5338 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
5339 becomes I4, even unsigned ints (incl. UI2) */
5340
5341 lOk = TRUE;
5342 switch (V_VT(left)&VT_TYPEMASK) {
5343 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5344 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5345 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5346 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5347 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5348 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5349 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5350 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5351 default: lOk = FALSE;
5352 }
5353
5354 rOk = TRUE;
5355 switch (V_VT(right)&VT_TYPEMASK) {
5356 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5357 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5358 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5359 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5360 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5361 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5362 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5363 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5364 default: rOk = FALSE;
5365 }
5366
5367 if (lOk && rOk) {
5368 res = (lVal & rVal);
5369 V_VT(result) = resT;
5370 switch (resT) {
5371 case VT_I2 : V_UNION(result,iVal) = res; break;
5372 case VT_I4 : V_UNION(result,lVal) = res; break;
5373 default:
5374 FIXME("Unexpected result variant type %x\n", resT);
5375 V_UNION(result,lVal) = res;
5376 }
5377 rc = S_OK;
5378
5379 } else {
5380 FIXME("VarAnd stub\n");
5381 }
5382 }
5383
5384 TRACE("rc=%d, Result:\n", (int) rc);
5385 dump_Variant(result);
5386 return rc;
5387 }
5388
5389 /**********************************************************************
5390 * VarAdd [OLEAUT32.141]
5391 * FIXME: From MSDN: If ... Then
5392 * Both expressions are of the string type Concatenated.
5393 * One expression is a string type and the other a character Addition.
5394 * One expression is numeric and the other is a string Addition.
5395 * Both expressions are numeric Addition.
5396 * Either expression is NULL NULL is returned.
5397 * Both expressions are empty Integer subtype is returned.
5398 *
5399 */
5400 HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5401 {
5402 HRESULT rc = E_FAIL;
5403
5404 TRACE("Left Var:\n");
5405 dump_Variant(left);
5406 TRACE("Right Var:\n");
5407 dump_Variant(right);
5408
5409 if ((V_VT(left)&VT_TYPEMASK) == VT_EMPTY)
5410 return VariantCopy(result,right);
5411
5412 if ((V_VT(right)&VT_TYPEMASK) == VT_EMPTY)
5413 return VariantCopy(result,left);
5414
5415 if (((V_VT(left)&VT_TYPEMASK) == VT_R8) || ((V_VT(right)&VT_TYPEMASK) == VT_R8)) {
5416 BOOL lOk = TRUE;
5417 BOOL rOk = TRUE;
5418 double lVal = -1;
5419 double rVal = -1;
5420 double res = -1;
5421
5422 lOk = TRUE;
5423 switch (V_VT(left)&VT_TYPEMASK) {
5424 case VT_I1 : lVal = V_UNION(left,cVal); break;
5425 case VT_I2 : lVal = V_UNION(left,iVal); break;
5426 case VT_I4 : lVal = V_UNION(left,lVal); break;
5427 case VT_INT : lVal = V_UNION(left,lVal); break;
5428 case VT_UI1 : lVal = V_UNION(left,bVal); break;
5429 case VT_UI2 : lVal = V_UNION(left,uiVal); break;
5430 case VT_UI4 : lVal = V_UNION(left,ulVal); break;
5431 case VT_UINT : lVal = V_UNION(left,ulVal); break;
5432 case VT_R4 : lVal = V_UNION(left,fltVal); break;
5433 case VT_R8 : lVal = V_UNION(left,dblVal); break;
5434 case VT_NULL : lVal = 0.0; break;
5435 default: lOk = FALSE;
5436 }
5437
5438 rOk = TRUE;
5439 switch (V_VT(right)&VT_TYPEMASK) {
5440 case VT_I1 : rVal = V_UNION(right,cVal); break;
5441 case VT_I2 : rVal = V_UNION(right,iVal); break;
5442 case VT_I4 : rVal = V_UNION(right,lVal); break;
5443 case VT_INT : rVal = V_UNION(right,lVal); break;
5444 case VT_UI1 : rVal = V_UNION(right,bVal); break;
5445 case VT_UI2 : rVal = V_UNION(right,uiVal); break;
5446 case VT_UI4 : rVal = V_UNION(right,ulVal); break;
5447 case VT_UINT : rVal = V_UNION(right,ulVal); break;
5448 case VT_R4 : rVal = V_UNION(right,fltVal);break;
5449 case VT_R8 : rVal = V_UNION(right,dblVal);break;
5450 case VT_NULL : rVal = 0.0; break;
5451 default: rOk = FALSE;
5452 }
5453
5454 if (lOk && rOk) {
5455 res = (lVal + rVal);
5456 V_VT(result) = VT_R8;
5457 V_UNION(result,dblVal) = res;
5458 rc = S_OK;
5459 } else {
5460 FIXME("Unhandled type pair %d / %d in double addition.\n",
5461 (V_VT(left)&VT_TYPEMASK),
5462 (V_VT(right)&VT_TYPEMASK)
5463 );
5464 }
5465 return rc;
5466 }
5467
5468 /* Handle strings as concat */
5469 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5470 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5471 V_VT(result) = VT_BSTR;
5472 rc = VarBstrCat(V_BSTR(left), V_BSTR(right), &V_BSTR(result));
5473 } else {
5474
5475 /* Integers */
5476 BOOL lOk = TRUE;
5477 BOOL rOk = TRUE;
5478 LONGLONG lVal = -1;
5479 LONGLONG rVal = -1;
5480 LONGLONG res = -1;
5481 int resT = 0; /* Testing has shown I2 + I2 == I2, all else
5482 becomes I4 */
5483
5484 lOk = TRUE;
5485 switch (V_VT(left)&VT_TYPEMASK) {
5486 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5487 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5488 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5489 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5490 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5491 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5492 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5493 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5494 case VT_NULL : lVal = 0; resT = VT_I4; break;
5495 default: lOk = FALSE;
5496 }
5497
5498 rOk = TRUE;
5499 switch (V_VT(right)&VT_TYPEMASK) {
5500 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5501 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5502 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5503 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5504 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5505 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5506 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5507 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5508 case VT_NULL : rVal = 0; resT=VT_I4; break;
5509 default: rOk = FALSE;
5510 }
5511
5512 if (lOk && rOk) {
5513 res = (lVal + rVal);
5514 V_VT(result) = resT;
5515 switch (resT) {
5516 case VT_I2 : V_UNION(result,iVal) = res; break;
5517 case VT_I4 : V_UNION(result,lVal) = res; break;
5518 default:
5519 FIXME("Unexpected result variant type %x\n", resT);
5520 V_UNION(result,lVal) = res;
5521 }
5522 rc = S_OK;
5523
5524 } else {
5525 FIXME("unimplemented part (0x%x + 0x%x)\n",V_VT(left), V_VT(right));
5526 }
5527 }
5528
5529 TRACE("rc=%d, Result:\n", (int) rc);
5530 dump_Variant(result);
5531 return rc;
5532 }
5533
5534 /**********************************************************************
5535 * VarMul [OLEAUT32.156]
5536 *
5537 */
5538 HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5539 {
5540 HRESULT rc = E_FAIL;
5541 VARTYPE lvt,rvt,resvt;
5542 VARIANT lv,rv;
5543 BOOL found;
5544
5545 TRACE("left: ");dump_Variant(left);
5546 TRACE("right: ");dump_Variant(right);
5547
5548 VariantInit(&lv);VariantInit(&rv);
5549 lvt = V_VT(left)&VT_TYPEMASK;
5550 rvt = V_VT(right)&VT_TYPEMASK;
5551 found = FALSE;resvt=VT_VOID;
5552 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5553 found = TRUE;
5554 resvt = VT_R8;
5555 }
5556 if (!found && (((1<<lvt) | (1<<rvt)) & ((1<<VT_I1)|(1<<VT_I2)|(1<<VT_UI1)|(1<<VT_UI2)|(1<<VT_I4)|(1<<VT_UI4)|(1<<VT_INT)|(1<<VT_UINT)))) {
5557 found = TRUE;
5558 resvt = VT_I4;
5559 }
5560 if (!found) {
5561 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5562 return E_FAIL;
5563 }
5564 rc = VariantChangeType(&lv, left, 0, resvt);
5565 if (FAILED(rc)) {
5566 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5567 return rc;
5568 }
5569 rc = VariantChangeType(&rv, right, 0, resvt);
5570 if (FAILED(rc)) {
5571 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5572 return rc;
5573 }
5574 switch (resvt) {
5575 case VT_R8:
5576 V_VT(result) = resvt;
5577 V_R8(result) = V_R8(&lv) * V_R8(&rv);
5578 rc = S_OK;
5579 break;
5580 case VT_I4:
5581 V_VT(result) = resvt;
5582 V_I4(result) = V_I4(&lv) * V_I4(&rv);
5583 rc = S_OK;
5584 break;
5585 }
5586 TRACE("rc=%d, Result:\n", (int) rc);
5587 dump_Variant(result);
5588 return rc;
5589 }
5590
5591 /**********************************************************************
5592 * VarDiv [OLEAUT32.143]
5593 *
5594 */
5595 HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5596 {
5597 HRESULT rc = E_FAIL;
5598 VARTYPE lvt,rvt,resvt;
5599 VARIANT lv,rv;
5600 BOOL found;
5601
5602 TRACE("left: ");dump_Variant(left);
5603 TRACE("right: ");dump_Variant(right);
5604
5605 VariantInit(&lv);VariantInit(&rv);
5606 lvt = V_VT(left)&VT_TYPEMASK;
5607 rvt = V_VT(right)&VT_TYPEMASK;
5608 found = FALSE;resvt = VT_VOID;
5609 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5610 found = TRUE;
5611 resvt = VT_R8;
5612 }
5613 if (!found && (((1<<lvt) | (1<<rvt)) & ((1<<VT_I1)|(1<<VT_I2)|(1<<VT_UI1)|(1<<VT_UI2)|(1<<VT_I4)|(1<<VT_UI4)|(1<<VT_INT)|(1<<VT_UINT)))) {
5614 found = TRUE;
5615 resvt = VT_I4;
5616 }
5617 if (!found) {
5618 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5619 return E_FAIL;
5620 }
5621 rc = VariantChangeType(&lv, left, 0, resvt);
5622 if (FAILED(rc)) {
5623 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5624 return rc;
5625 }
5626 rc = VariantChangeType(&rv, right, 0, resvt);
5627 if (FAILED(rc)) {
5628 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5629 return rc;
5630 }
5631 switch (resvt) {
5632 case VT_R8:
5633 V_VT(result) = resvt;
5634 V_R8(result) = V_R8(&lv) / V_R8(&rv);
5635 rc = S_OK;
5636 break;
5637 case VT_I4:
5638 V_VT(result) = resvt;
5639 V_I4(result) = V_I4(&lv) / V_I4(&rv);
5640 rc = S_OK;
5641 break;
5642 }
5643 TRACE("rc=%d, Result:\n", (int) rc);
5644 dump_Variant(result);
5645 return rc;
5646 }
5647
5648 /**********************************************************************
5649 * VarSub [OLEAUT32.159]
5650 *
5651 */
5652 HRESULT WINAPI VarSub(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5653 {
5654 HRESULT rc = E_FAIL;
5655 VARTYPE lvt,rvt,resvt;
5656 VARIANT lv,rv;
5657 BOOL found;
5658
5659 TRACE("left: ");dump_Variant(left);
5660 TRACE("right: ");dump_Variant(right);
5661
5662 VariantInit(&lv);VariantInit(&rv);
5663 lvt = V_VT(left)&VT_TYPEMASK;
5664 rvt = V_VT(right)&VT_TYPEMASK;
5665 found = FALSE;resvt = VT_VOID;
5666 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5667 found = TRUE;
5668 resvt = VT_R8;
5669 }
5670 if (!found && (((1<<lvt) | (1<<rvt)) & ((1<<VT_I1)|(1<<VT_I2)|(1<<VT_UI1)|(1<<VT_UI2)|(1<<VT_I4)|(1<<VT_UI4)|(1<<VT_INT)|(1<<VT_UINT)))) {
5671 found = TRUE;
5672 resvt = VT_I4;
5673 }
5674 if (!found) {
5675 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5676 return E_FAIL;
5677 }
5678 rc = VariantChangeType(&lv, left, 0, resvt);
5679 if (FAILED(rc)) {
5680 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5681 return rc;
5682 }
5683 rc = VariantChangeType(&rv, right, 0, resvt);
5684 if (FAILED(rc)) {
5685 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5686 return rc;
5687 }
5688 switch (resvt) {
5689 case VT_R8:
5690 V_VT(result) = resvt;
5691 V_R8(result) = V_R8(&lv) - V_R8(&rv);
5692 rc = S_OK;
5693 break;
5694 case VT_I4:
5695 V_VT(result) = resvt;
5696 V_I4(result) = V_I4(&lv) - V_I4(&rv);
5697 rc = S_OK;
5698 break;
5699 }
5700 TRACE("rc=%d, Result:\n", (int) rc);
5701 dump_Variant(result);
5702 return rc;
5703 }
5704
5705 /**********************************************************************
5706 * VarOr [OLEAUT32.157]
5707 *
5708 */
5709 HRESULT WINAPI VarOr(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5710 {
5711 HRESULT rc = E_FAIL;
5712
5713 TRACE("Left Var:\n");
5714 dump_Variant(left);
5715 TRACE("Right Var:\n");
5716 dump_Variant(right);
5717
5718 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5719 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5720
5721 V_VT(result) = VT_BOOL;
5722 if (V_BOOL(left) || V_BOOL(right)) {
5723 V_BOOL(result) = VARIANT_TRUE;
5724 } else {
5725 V_BOOL(result) = VARIANT_FALSE;
5726 }
5727 rc = S_OK;
5728
5729 } else {
5730 /* Integers */
5731 BOOL lOk = TRUE;
5732 BOOL rOk = TRUE;
5733 LONGLONG lVal = -1;
5734 LONGLONG rVal = -1;
5735 LONGLONG res = -1;
5736 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
5737 becomes I4, even unsigned ints (incl. UI2) */
5738
5739 lOk = TRUE;
5740 switch (V_VT(left)&VT_TYPEMASK) {
5741 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5742 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5743 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5744 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5745 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5746 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5747 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5748 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5749 default: lOk = FALSE;
5750 }
5751
5752 rOk = TRUE;
5753 switch (V_VT(right)&VT_TYPEMASK) {
5754 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5755 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5756 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5757 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5758 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5759 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5760 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5761 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5762 default: rOk = FALSE;
5763 }
5764
5765 if (lOk && rOk) {
5766 res = (lVal | rVal);
5767 V_VT(result) = resT;
5768 switch (resT) {
5769 case VT_I2 : V_UNION(result,iVal) = res; break;
5770 case VT_I4 : V_UNION(result,lVal) = res; break;
5771 default:
5772 FIXME("Unexpected result variant type %x\n", resT);
5773 V_UNION(result,lVal) = res;
5774 }
5775 rc = S_OK;
5776
5777 } else {
5778 FIXME("unimplemented part\n");
5779 }
5780 }
5781
5782 TRACE("rc=%d, Result:\n", (int) rc);
5783 dump_Variant(result);
5784 return rc;
5785 }
5786
5787 /**********************************************************************
5788 * VarNot [OLEAUT32.174]
5789 *
5790 */
5791 HRESULT WINAPI VarNot(LPVARIANT in, LPVARIANT result)
5792 {
5793 HRESULT rc = E_FAIL;
5794
5795 TRACE("Var In:\n");
5796 dump_Variant(in);
5797
5798 if ((V_VT(in)&VT_TYPEMASK) == VT_BOOL) {
5799
5800 V_VT(result) = VT_BOOL;
5801 if (V_BOOL(in)) {
5802 V_BOOL(result) = VARIANT_FALSE;
5803 } else {
5804 V_BOOL(result) = VARIANT_TRUE;
5805 }
5806 rc = S_OK;
5807
5808 } else {
5809 FIXME("VarNot stub\n");
5810 }
5811
5812 TRACE("rc=%d, Result:\n", (int) rc);
5813 dump_Variant(result);
5814 return rc;
5815 }
5816
5817 /**********************************************************************
5818 * VarTokenizeFormatString [OLEAUT32.140]
5819 *
5820 * From investigation on W2K, a list is built up which is:
5821 *
5822 * <0x00> AA BB - Copy from AA for BB chars (Note 1 byte with wrap!)
5823 * <token> - Insert appropriate token
5824 *
5825 */
5826 HRESULT WINAPI VarTokenizeFormatString(LPOLESTR format, LPBYTE rgbTok,
5827 int cbTok, int iFirstDay, int iFirstWeek,
5828 LCID lcid, int *pcbActual) {
5829
5830 FORMATHDR *hdr;
5831 int realLen, formatLeft;
5832 BYTE *pData;
5833 LPSTR pFormatA, pStart;
5834 int checkStr;
5835 BOOL insertCopy = FALSE;
5836 LPSTR copyFrom = NULL;
5837
5838 TRACE("'%s', %p %d %d %d only date support\n", debugstr_w(format), rgbTok, cbTok,
5839 iFirstDay, iFirstWeek);
5840
5841 /* Big enough for header? */
5842 if (cbTok < sizeof(FORMATHDR)) {
5843 return TYPE_E_BUFFERTOOSMALL;
5844 }
5845
5846 /* Insert header */
5847 hdr = (FORMATHDR *) rgbTok;
5848 memset(hdr, 0x00, sizeof(FORMATHDR));
5849 hdr->hex3 = 0x03; /* No idea what these are */
5850 hdr->hex6 = 0x06;
5851
5852 /* Start parsing string */
5853 realLen = sizeof(FORMATHDR);
5854 pData = rgbTok + realLen;
5855 pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5856 pStart = pFormatA;
5857 formatLeft = strlen(pFormatA);
5858
5859 /* Work through the format */
5860 while (*pFormatA != 0x00) {
5861
5862 checkStr = 0;
5863 while (checkStr>=0 && (formatTokens[checkStr].tokenSize != 0x00)) {
5864 if (formatLeft >= formatTokens[checkStr].tokenSize &&
5865 strncmp(formatTokens[checkStr].str, pFormatA,
5866 formatTokens[checkStr].tokenSize) == 0) {
5867 TRACE("match on '%s'\n", formatTokens[checkStr].str);
5868
5869 /* Found Match! */
5870
5871 /* If we have skipped chars, insert the copy */
5872 if (insertCopy == TRUE) {
5873
5874 if ((realLen + 3) > cbTok) {
5875 HeapFree( GetProcessHeap(), 0, pFormatA );
5876 return TYPE_E_BUFFERTOOSMALL;
5877 }
5878 insertCopy = FALSE;
5879 *pData = TOK_COPY;
5880 pData++;
5881 *pData = (BYTE)(copyFrom - pStart);
5882 pData++;
5883 *pData = (BYTE)(pFormatA - copyFrom);
5884 pData++;
5885 realLen = realLen + 3;
5886 }
5887
5888
5889 /* Now insert the token itself */
5890 if ((realLen + 1) > cbTok) {
5891 HeapFree( GetProcessHeap(), 0, pFormatA );
5892 return TYPE_E_BUFFERTOOSMALL;
5893 }
5894 *pData = formatTokens[checkStr].tokenId;
5895 pData = pData + 1;
5896 realLen = realLen + 1;
5897
5898 pFormatA = pFormatA + formatTokens[checkStr].tokenSize;
5899 formatLeft = formatLeft - formatTokens[checkStr].tokenSize;
5900 checkStr = -1; /* Flag as found and break out of while loop */
5901 } else {
5902 checkStr++;
5903 }
5904 }
5905
5906 /* Did we ever match a token? */
5907 if (checkStr != -1 && insertCopy == FALSE) {
5908 TRACE("No match - need to insert copy from %p [%p]\n", pFormatA, pStart);
5909 insertCopy = TRUE;
5910 copyFrom = pFormatA;
5911 } else if (checkStr != -1) {
5912 pFormatA = pFormatA + 1;
5913 }
5914
5915 }
5916
5917 /* Finally, if we have skipped chars, insert the copy */
5918 if (insertCopy == TRUE) {
5919
5920 TRACE("Chars left over, so still copy %p,%p,%p\n", copyFrom, pStart, pFormatA);
5921 if ((realLen + 3) > cbTok) {
5922 HeapFree( GetProcessHeap(), 0, pFormatA );
5923 return TYPE_E_BUFFERTOOSMALL;
5924 }
5925 insertCopy = FALSE;
5926 *pData = TOK_COPY;
5927 pData++;
5928 *pData = (BYTE)(copyFrom - pStart);
5929 pData++;
5930 *pData = (BYTE)(pFormatA - copyFrom);
5931 pData++;
5932 realLen = realLen + 3;
5933 }
5934
5935 /* Finally insert the terminator */
5936 if ((realLen + 1) > cbTok) {
5937 HeapFree( GetProcessHeap(), 0, pFormatA );
5938 return TYPE_E_BUFFERTOOSMALL;
5939 }
5940 *pData++ = TOK_END;
5941 realLen = realLen + 1;
5942
5943 /* Finally fill in the length */
5944 hdr->len = realLen;
5945 *pcbActual = realLen;
5946
5947 #if 0
5948 { int i,j;
5949 for (i=0; i<realLen; i=i+0x10) {
5950 printf(" %4.4x : ", i);
5951 for (j=0; j<0x10 && (i+j < realLen); j++) {
5952 printf("%2.2x ", rgbTok[i+j]);
5953 }
5954 printf("\n");
5955 }
5956 }
5957 #endif
5958 HeapFree( GetProcessHeap(), 0, pFormatA );
5959
5960 return S_OK;
5961 }
5962
5963 /**********************************************************************
5964 * VarFormatFromTokens [OLEAUT32.139]
5965 * FIXME: No account of flags or iFirstDay etc
5966 */
5967 HRESULT WINAPI VarFormatFromTokens(LPVARIANT varIn, LPOLESTR format,
5968 LPBYTE pbTokCur, ULONG dwFlags, BSTR *pbstrOut,
5969 LCID lcid) {
5970
5971 FORMATHDR *hdr = (FORMATHDR *)pbTokCur;
5972 BYTE *pData = pbTokCur + sizeof (FORMATHDR);
5973 LPSTR pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5974 char output[BUFFER_MAX];
5975 char *pNextPos;
5976 int size, whichToken;
5977 VARIANTARG Variant;
5978 struct tm TM;
5979
5980
5981
5982 TRACE("'%s', %p %lx %p only date support\n", pFormatA, pbTokCur, dwFlags, pbstrOut);
5983 TRACE("varIn:\n");
5984 dump_Variant(varIn);
5985
5986 memset(output, 0x00, BUFFER_MAX);
5987 pNextPos = output;
5988
5989 while (*pData != TOK_END && ((pData - pbTokCur) <= (hdr->len))) {
5990
5991 TRACE("Output looks like : '%s'\n", output);
5992
5993 /* Convert varient to appropriate data type */
5994 whichToken = 0;
5995 while ((formatTokens[whichToken].tokenSize != 0x00) &&
5996 (formatTokens[whichToken].tokenId != *pData)) {
5997 whichToken++;
5998 }
5999
6000 /* Use Variant local from here downwards as always correct type */
6001 if (formatTokens[whichToken].tokenSize > 0 &&
6002 formatTokens[whichToken].varTypeRequired != 0) {
6003 VariantInit( &Variant );
6004 if (Coerce( &Variant, lcid, dwFlags, varIn,
6005 formatTokens[whichToken].varTypeRequired ) != S_OK) {
6006 HeapFree( GetProcessHeap(), 0, pFormatA );
6007 return DISP_E_TYPEMISMATCH;
6008 } else if (formatTokens[whichToken].varTypeRequired == VT_DATE) {
6009 if( DateToTm( V_UNION(&Variant,date), dwFlags, &TM ) == FALSE ) {
6010 HeapFree( GetProcessHeap(), 0, pFormatA );
6011 return E_INVALIDARG;
6012 }
6013 }
6014 }
6015
6016 TRACE("Looking for match on token '%x'\n", *pData);
6017 switch (*pData) {
6018 case TOK_COPY:
6019 TRACE("Copy from %d for %d bytes\n", *(pData+1), *(pData+2));
6020 memcpy(pNextPos, &pFormatA[*(pData+1)], *(pData+2));
6021 pNextPos = pNextPos + *(pData+2);
6022 pData = pData + 3;
6023 break;
6024
6025 case TOK_COLON :
6026 /* Get locale information - Time Separator */
6027 size = GetLocaleInfoA(lcid, LOCALE_STIME, NULL, 0);
6028 GetLocaleInfoA(lcid, LOCALE_STIME, pNextPos, size);
6029 TRACE("TOK_COLON Time separator is '%s'\n", pNextPos);
6030 pNextPos = pNextPos + size;
6031 pData = pData + 1;
6032 break;
6033
6034 case TOK_SLASH :
6035 /* Get locale information - Date Separator */
6036 size = GetLocaleInfoA(lcid, LOCALE_SDATE, NULL, 0);
6037 GetLocaleInfoA(lcid, LOCALE_SDATE, pNextPos, size);
6038 TRACE("TOK_COLON Time separator is '%s'\n", pNextPos);
6039 pNextPos = pNextPos + size;
6040 pData = pData + 1;
6041 break;
6042
6043 case TOK_d :
6044 sprintf(pNextPos, "%d", TM.tm_mday);
6045 pNextPos = pNextPos + strlen(pNextPos);
6046 pData = pData + 1;
6047 break;
6048
6049 case TOK_dd :
6050 sprintf(pNextPos, "%2.2d", TM.tm_mday);
6051 pNextPos = pNextPos + strlen(pNextPos);
6052 pData = pData + 1;
6053 break;
6054
6055 case TOK_w :
6056 sprintf(pNextPos, "%d", TM.tm_wday+1);
6057 pNextPos = pNextPos + strlen(pNextPos);
6058 pData = pData + 1;
6059 break;
6060
6061 case TOK_m :
6062 sprintf(pNextPos, "%d", TM.tm_mon+1);
6063 pNextPos = pNextPos + strlen(pNextPos);
6064 pData = pData + 1;
6065 break;
6066
6067 case TOK_mm :
6068 sprintf(pNextPos, "%2.2d", TM.tm_mon+1);
6069 pNextPos = pNextPos + strlen(pNextPos);
6070 pData = pData + 1;
6071 break;
6072
6073 case TOK_q :
6074 sprintf(pNextPos, "%d", ((TM.tm_mon+1)/4)+1);
6075 pNextPos = pNextPos + strlen(pNextPos);
6076 pData = pData + 1;
6077 break;
6078
6079 case TOK_y :
6080 sprintf(pNextPos, "%2.2d", TM.tm_yday+1);
6081 pNextPos = pNextPos + strlen(pNextPos);
6082 pData = pData + 1;
6083 break;
6084
6085 case TOK_yy :
6086 sprintf(pNextPos, "%2.2d", TM.tm_year);
6087 pNextPos = pNextPos + strlen(pNextPos);
6088 pData = pData + 1;
6089 break;
6090
6091 case TOK_yyyy :
6092 sprintf(pNextPos, "%4.4d", TM.tm_year);
6093 pNextPos = pNextPos + strlen(pNextPos);
6094 pData = pData + 1;
6095 break;
6096
6097 case TOK_h :
6098 sprintf(pNextPos, "%d", TM.tm_hour);
6099 pNextPos = pNextPos + strlen(pNextPos);
6100 pData = pData + 1;
6101 break;
6102
6103 case TOK_Hh :
6104 sprintf(pNextPos, "%2.2d", TM.tm_hour);
6105 pNextPos = pNextPos + strlen(pNextPos);
6106 pData = pData + 1;
6107 break;
6108
6109 case TOK_N :
6110 sprintf(pNextPos, "%d", TM.tm_min);
6111 pNextPos = pNextPos + strlen(pNextPos);
6112 pData = pData + 1;
6113 break;
6114
6115 case TOK_Nn :
6116 sprintf(pNextPos, "%2.2d", TM.tm_min);
6117 pNextPos = pNextPos + strlen(pNextPos);
6118 pData = pData + 1;
6119 break;
6120
6121 case TOK_S :
6122 sprintf(pNextPos, "%d", TM.tm_sec);
6123 pNextPos = pNextPos + strlen(pNextPos);
6124 pData = pData + 1;
6125 break;
6126
6127 case TOK_Ss :
6128 sprintf(pNextPos, "%2.2d", TM.tm_sec);
6129 pNextPos = pNextPos + strlen(pNextPos);
6130 pData = pData + 1;
6131 break;
6132
6133 /* FIXME: To Do! */
6134 case TOK_ttttt :
6135 case TOK_AMsPM :
6136 case TOK_amspm :
6137 case TOK_AsP :
6138 case TOK_asp :
6139 case TOK_AMPM :
6140 case TOK_c :
6141 case TOK_ddd :
6142 case TOK_dddd :
6143 case TOK_ddddd :
6144 case TOK_dddddd :
6145 case TOK_ww :
6146 case TOK_mmm :
6147 case TOK_mmmm :
6148 default:
6149 FIXME("Unhandled token for VarFormat %d\n", *pData);
6150 HeapFree( GetProcessHeap(), 0, pFormatA );
6151 return E_INVALIDARG;
6152 }
6153
6154 }
6155
6156 *pbstrOut = StringDupAtoBstr( output );
6157 HeapFree( GetProcessHeap(), 0, pFormatA );
6158 return S_OK;
6159 }
6160
6161 /**********************************************************************
6162 * VarFormat [OLEAUT32.87]
6163 *
6164 */
6165 HRESULT WINAPI VarFormat(LPVARIANT varIn, LPOLESTR format,
6166 int firstDay, int firstWeek, ULONG dwFlags,
6167 BSTR *pbstrOut) {
6168
6169 LPSTR pNewString = NULL;
6170 HRESULT rc = S_OK;
6171
6172 TRACE("mostly stub! format='%s' day=%d, wk=%d, flags=%ld\n",
6173 debugstr_w(format), firstDay, firstWeek, dwFlags);
6174 TRACE("varIn:\n");
6175 dump_Variant(varIn);
6176
6177 /* Note: Must Handle references type Variants (contain ptrs
6178 to values rather than values */
6179
6180 /* Get format string */
6181 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
6182
6183 /* FIXME: Handle some simple pre-definted format strings : */
6184 if (((V_VT(varIn)&VT_TYPEMASK) == VT_CY) && (lstrcmpiA(pNewString, "Currency") == 0)) {
6185
6186 /* Can't use VarBstrFromCy as it does not put currency sign on nor decimal places */
6187 double curVal;
6188
6189
6190 /* Handle references type Variants (contain ptrs to values rather than values */
6191 if (V_VT(varIn)&VT_BYREF) {
6192 rc = VarR8FromCy(*(CY *)V_UNION(varIn,byref), &curVal);
6193 } else {
6194 rc = VarR8FromCy(V_UNION(varIn,cyVal), &curVal);
6195 }
6196
6197 if (rc == S_OK) {
6198 char tmpStr[BUFFER_MAX];
6199 sprintf(tmpStr, "%f", curVal);
6200 if (GetCurrencyFormatA(GetUserDefaultLCID(), dwFlags, tmpStr, NULL, pBuffer, BUFFER_MAX) == 0) {
6201 return E_FAIL;
6202 } else {
6203 *pbstrOut = StringDupAtoBstr( pBuffer );
6204 }
6205 }
6206
6207 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_DATE) {
6208
6209 /* Attempt to do proper formatting! */
6210 int firstToken = -1;
6211
6212 rc = VarTokenizeFormatString(format, pBuffer, sizeof(pBuffer), firstDay,
6213 firstWeek, GetUserDefaultLCID(), &firstToken);
6214 if (rc==S_OK) {
6215 rc = VarFormatFromTokens(varIn, format, pBuffer, dwFlags, pbstrOut, GetUserDefaultLCID());
6216 }
6217
6218 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_R8) {
6219 if (V_VT(varIn)&VT_BYREF) {
6220 sprintf(pBuffer, "%f", *V_UNION(varIn,pdblVal));
6221 } else {
6222 sprintf(pBuffer, "%f", V_UNION(varIn,dblVal));
6223 }
6224 *pbstrOut = StringDupAtoBstr( pBuffer );
6225 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_I2) {
6226 if (V_VT(varIn)&VT_BYREF) {
6227 sprintf(pBuffer, "%d", *V_UNION(varIn,piVal));
6228 } else {
6229 sprintf(pBuffer, "%d", V_UNION(varIn,iVal));
6230 }
6231 *pbstrOut = StringDupAtoBstr( pBuffer );
6232 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_BSTR) {
6233 if (V_VT(varIn)&VT_BYREF)
6234 *pbstrOut = SysAllocString( *V_UNION(varIn,pbstrVal) );
6235 else
6236 *pbstrOut = SysAllocString( V_UNION(varIn,bstrVal) );
6237 } else {
6238 FIXME("VarFormat: Unsupported format %d!\n", V_VT(varIn)&VT_TYPEMASK);
6239 *pbstrOut = StringDupAtoBstr( "??" );
6240 }
6241
6242 /* Free allocated storage */
6243 HeapFree( GetProcessHeap(), 0, pNewString );
6244 TRACE("result: '%s'\n", debugstr_w(*pbstrOut));
6245 return rc;
6246 }
6247
6248 /**********************************************************************
6249 * VarCyMulI4 [OLEAUT32.304]
6250 * Multiply currency value by integer
6251 */
6252 HRESULT WINAPI VarCyMulI4(CY cyIn, LONG mulBy, CY *pcyOut) {
6253
6254 double cyVal = 0;
6255 HRESULT rc = S_OK;
6256
6257 rc = VarR8FromCy(cyIn, &cyVal);
6258 if (rc == S_OK) {
6259 rc = VarCyFromR8((cyVal * (double) mulBy), pcyOut);
6260 TRACE("Multiply %f by %ld = %f [%ld,%lu]\n", cyVal, mulBy, (cyVal * (double) mulBy),
6261 pcyOut->s.Hi, pcyOut->s.Lo);
6262 }
6263 return rc;
6264 }