?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed DECIMAL_SETZERO
[wine.git] / dlls / oleaut32 / variant.c
blob7f038ed7e128f01d7529a5c09cb63cc93a01c43d
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 fracionnal 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_EMPTY ):
1543 res = S_OK;
1544 V_UNION(pd,boolVal) = VARIANT_FALSE;
1545 break;
1546 case( VT_I1 ):
1547 res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
1548 break;
1549 case( VT_I2 ):
1550 res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
1551 break;
1552 case( VT_INT ):
1553 res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
1554 break;
1555 case( VT_I4 ):
1556 res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
1557 break;
1558 case( VT_UI1 ):
1559 res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
1560 break;
1561 case( VT_UI2 ):
1562 res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
1563 break;
1564 case( VT_UINT ):
1565 res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
1566 break;
1567 case( VT_UI4 ):
1568 res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
1569 break;
1570 case( VT_R4 ):
1571 res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
1572 break;
1573 case( VT_R8 ):
1574 res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
1575 break;
1576 case( VT_DATE ):
1577 res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
1578 break;
1579 case( VT_BSTR ):
1580 res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
1581 break;
1582 case( VT_CY ):
1583 res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
1584 break;
1585 case( VT_DISPATCH ):
1586 /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
1587 case( VT_DECIMAL ):
1588 /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
1589 case( VT_UNKNOWN ):
1590 default:
1591 res = DISP_E_TYPEMISMATCH;
1592 FIXME("Coercion from %d to VT_BOOL\n", vtFrom);
1593 break;
1594 }
1595 break;
1596
1597 case( VT_BSTR ):
1598 switch( vtFrom )
1599 {
1600 case( VT_EMPTY ):
1601 if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
1602 res = S_OK;
1603 else
1604 res = E_OUTOFMEMORY;
1605 break;
1606 case( VT_I1 ):
1607 res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
1608 break;
1609 case( VT_I2 ):
1610 res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
1611 break;
1612 case( VT_INT ):
1613 res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
1614 break;
1615 case( VT_I4 ):
1616 res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
1617 break;
1618 case( VT_UI1 ):
1619 res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
1620 break;
1621 case( VT_UI2 ):
1622 res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
1623 break;
1624 case( VT_UINT ):
1625 res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
1626 break;
1627 case( VT_UI4 ):
1628 res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
1629 break;
1630 case( VT_R4 ):
1631 res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
1632 break;
1633 case( VT_R8 ):
1634 res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
1635 break;
1636 case( VT_DATE ):
1637 res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
1638 break;
1639 case( VT_BOOL ):
1640 res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
1641 break;
1642 case( VT_BSTR ):
1643 res = VariantCopy( pd, ps );
1644 break;
1645 case( VT_CY ):
1646 res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
1647 break;
1648 case( VT_DISPATCH ):
1649 /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
1650 case( VT_DECIMAL ):
1651 /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
1652 case( VT_UNKNOWN ):
1653 default:
1654 res = DISP_E_TYPEMISMATCH;
1655 FIXME("Coercion from %d to VT_BSTR\n", vtFrom);
1656 break;
1657 }
1658 break;
1659
1660 case( VT_CY ):
1661 switch( vtFrom )
1662 {
1663 case( VT_I1 ):
1664 res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
1665 break;
1666 case( VT_I2 ):
1667 res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
1668 break;
1669 case( VT_INT ):
1670 res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
1671 break;
1672 case( VT_I4 ):
1673 res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
1674 break;
1675 case( VT_UI1 ):
1676 res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
1677 break;
1678 case( VT_UI2 ):
1679 res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
1680 break;
1681 case( VT_UINT ):
1682 res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
1683 break;
1684 case( VT_UI4 ):
1685 res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
1686 break;
1687 case( VT_R4 ):
1688 res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
1689 break;
1690 case( VT_R8 ):
1691 res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
1692 break;
1693 case( VT_DATE ):
1694 res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
1695 break;
1696 case( VT_BOOL ):
1697 res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
1698 break;
1699 case( VT_CY ):
1700 res = VariantCopy( pd, ps );
1701 break;
1702 case( VT_BSTR ):
1703 res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
1704 break;
1705 case( VT_DISPATCH ):
1706 /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
1707 case( VT_DECIMAL ):
1708 /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
1709 break;
1710 case( VT_UNKNOWN ):
1711 default:
1712 res = DISP_E_TYPEMISMATCH;
1713 FIXME("Coercion from %d to VT_CY\n", vtFrom);
1714 break;
1715 }
1716 break;
1717
1718 case( VT_UNKNOWN ):
1719 switch (vtFrom) {
1720 case VT_DISPATCH:
1721 if (V_DISPATCH(ps) == NULL) {
1722 V_UNKNOWN(pd) = NULL;
1723 } else {
1724 res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd));
1725 }
1726 break;
1727 case VT_EMPTY: case VT_NULL: case VT_I2: case VT_I4:
1728 case VT_R4: case VT_R8: case VT_CY: case VT_DATE:
1729 case VT_BSTR: case VT_ERROR: case VT_BOOL:
1730 case VT_VARIANT: case VT_DECIMAL: case VT_I1: case VT_UI1:
1731 case VT_UI2: case VT_UI4: case VT_I8: case VT_UI8: case VT_INT:
1732 case VT_UINT: case VT_VOID: case VT_HRESULT: case VT_PTR:
1733 case VT_SAFEARRAY: case VT_CARRAY: case VT_USERDEFINED:
1734 case VT_LPSTR: case VT_LPWSTR: case VT_RECORD: case VT_FILETIME:
1735 case VT_BLOB: case VT_STREAM: case VT_STORAGE:
1736 case VT_STREAMED_OBJECT: case VT_STORED_OBJECT: case VT_BLOB_OBJECT:
1737 case VT_CF: case VT_CLSID:
1738 res = DISP_E_TYPEMISMATCH;
1739 break;
1740 default:
1741 FIXME("Coercion from %d to VT_UNKNOWN unhandled.\n", vtFrom);
1742 res = DISP_E_BADVARTYPE;
1743 break;
1744 }
1745 break;
1746
1747 case( VT_DISPATCH ):
1748 switch (vtFrom) {
1749 case VT_UNKNOWN:
1750 if (V_UNION(ps,punkVal) == NULL) {
1751 V_UNION(pd,pdispVal) = NULL;
1752 } else {
1753 res = IUnknown_QueryInterface(V_UNION(ps,punkVal), &IID_IDispatch, (LPVOID*)&V_UNION(pd,pdispVal));
1754 }
1755 break;
1756 case VT_EMPTY: case VT_NULL: case VT_I2: case VT_I4:
1757 case VT_R4: case VT_R8: case VT_CY: case VT_DATE:
1758 case VT_BSTR: case VT_ERROR: case VT_BOOL:
1759 case VT_VARIANT: case VT_DECIMAL: case VT_I1: case VT_UI1:
1760 case VT_UI2: case VT_UI4: case VT_I8: case VT_UI8: case VT_INT:
1761 case VT_UINT: case VT_VOID: case VT_HRESULT:
1762 case VT_SAFEARRAY: case VT_CARRAY: case VT_USERDEFINED:
1763 case VT_LPSTR: case VT_LPWSTR: case VT_RECORD: case VT_FILETIME:
1764 case VT_BLOB: case VT_STREAM: case VT_STORAGE:
1765 case VT_STREAMED_OBJECT: case VT_STORED_OBJECT: case VT_BLOB_OBJECT:
1766 case VT_CF: case VT_CLSID:
1767 res = DISP_E_TYPEMISMATCH;
1768 break;
1769 case VT_PTR:
1770 V_UNION(pd,pdispVal) = V_UNION(ps,pdispVal);
1771 break;
1772 default:
1773 FIXME("Coercion from %d to VT_DISPATCH unhandled.\n", vtFrom);
1774 res = DISP_E_BADVARTYPE;
1775 break;
1776 }
1777 break;
1778
1779 default:
1780 res = DISP_E_TYPEMISMATCH;
1781 FIXME("Coercion from %d to %d\n", vtFrom, vt );
1782 break;
1783 }
1784
1785 return res;
1786 }
1787
1788 /******************************************************************************
1789 * ValidateVtRange [INTERNAL]
1790 *
1791 * Used internally by the hi-level Variant API to determine
1792 * if the vartypes are valid.
1793 */
1794 static HRESULT WINAPI ValidateVtRange( VARTYPE vt )
1795 {
1796 /* if by value we must make sure it is in the
1797 * range of the valid types.
1798 */
1799 if( ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1800 {
1801 return DISP_E_BADVARTYPE;
1802 }
1803 return S_OK;
1804 }
1805
1806
1807 /******************************************************************************
1808 * ValidateVartype [INTERNAL]
1809 *
1810 * Used internally by the hi-level Variant API to determine
1811 * if the vartypes are valid.
1812 */
1813 static HRESULT WINAPI ValidateVariantType( VARTYPE vt )
1814 {
1815 HRESULT res = S_OK;
1816
1817 /* check if we have a valid argument.
1818 */
1819 if( vt & VT_BYREF )
1820 {
1821 /* if by reference check that the type is in
1822 * the valid range and that it is not of empty or null type
1823 */
1824 if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1825 ( vt & VT_TYPEMASK ) == VT_NULL ||
1826 ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1827 {
1828 res = DISP_E_BADVARTYPE;
1829 }
1830
1831 }
1832 else
1833 {
1834 res = ValidateVtRange( vt );
1835 }
1836
1837 return res;
1838 }
1839
1840 /******************************************************************************
1841 * ValidateVt [INTERNAL]
1842 *
1843 * Used internally by the hi-level Variant API to determine
1844 * if the vartypes are valid.
1845 */
1846 static HRESULT WINAPI ValidateVt( VARTYPE vt )
1847 {
1848 HRESULT res = S_OK;
1849
1850 /* check if we have a valid argument.
1851 */
1852 if( vt & VT_BYREF )
1853 {
1854 /* if by reference check that the type is in
1855 * the valid range and that it is not of empty or null type
1856 */
1857 if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
1858 ( vt & VT_TYPEMASK ) == VT_NULL ||
1859 ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
1860 {
1861 res = DISP_E_BADVARTYPE;
1862 }
1863
1864 }
1865 else
1866 {
1867 res = ValidateVtRange( vt );
1868 }
1869
1870 return res;
1871 }
1872
1873
1874
1875
1876
1877 /******************************************************************************
1878 * VariantInit [OLEAUT32.8]
1879 *
1880 * Initializes the Variant. Unlike VariantClear it does not interpret
1881 * the current contents of the Variant.
1882 */
1883 void WINAPI VariantInit(VARIANTARG* pvarg)
1884 {
1885 TRACE("(%p)\n",pvarg);
1886
1887 memset(pvarg, 0, sizeof (VARIANTARG));
1888 V_VT(pvarg) = VT_EMPTY;
1889
1890 return;
1891 }
1892
1893 /******************************************************************************
1894 * VariantClear [OLEAUT32.9]
1895 *
1896 * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
1897 * sets the wReservedX field to 0. The current contents of the VARIANT are
1898 * freed. If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
1899 * released. If VT_ARRAY the array is freed.
1900 */
1901 HRESULT WINAPI VariantClear(VARIANTARG* pvarg)
1902 {
1903 HRESULT res = S_OK;
1904 TRACE("(%p)\n",pvarg);
1905
1906 res = ValidateVariantType( V_VT(pvarg) );
1907 if( res == S_OK )
1908 {
1909 if( !( V_VT(pvarg) & VT_BYREF ) )
1910 {
1911 /*
1912 * The VT_ARRAY flag is a special case of a safe array.
1913 */
1914 if ( (V_VT(pvarg) & VT_ARRAY) != 0)
1915 {
1916 SafeArrayDestroy(V_UNION(pvarg,parray));
1917 }
1918 else
1919 {
1920 switch( V_VT(pvarg) & VT_TYPEMASK )
1921 {
1922 case( VT_BSTR ):
1923 SysFreeString( V_UNION(pvarg,bstrVal) );
1924 break;
1925 case( VT_DISPATCH ):
1926 if(V_UNION(pvarg,pdispVal)!=NULL)
1927 IDispatch_Release(V_UNION(pvarg,pdispVal));
1928 break;
1929 case( VT_VARIANT ):
1930 VariantClear(V_UNION(pvarg,pvarVal));
1931 break;
1932 case( VT_UNKNOWN ):
1933 if(V_UNION(pvarg,punkVal)!=NULL)
1934 IUnknown_Release(V_UNION(pvarg,punkVal));
1935 break;
1936 case( VT_SAFEARRAY ):
1937 SafeArrayDestroy(V_UNION(pvarg,parray));
1938 break;
1939 default:
1940 break;
1941 }
1942 }
1943 }
1944
1945 /*
1946 * Empty all the fields and mark the type as empty.
1947 */
1948 memset(pvarg, 0, sizeof (VARIANTARG));
1949 V_VT(pvarg) = VT_EMPTY;
1950 }
1951
1952 return res;
1953 }
1954
1955 /******************************************************************************
1956 * VariantCopy [OLEAUT32.10]
1957 *
1958 * Frees up the designation variant and makes a copy of the source.
1959 */
1960 HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
1961 {
1962 HRESULT res = S_OK;
1963
1964 TRACE("(%p, %p), vt=%d\n", pvargDest, pvargSrc, V_VT(pvargSrc));
1965
1966 res = ValidateVariantType( V_VT(pvargSrc) );
1967
1968 /* If the pointer are to the same variant we don't need
1969 * to do anything.
1970 */
1971 if( pvargDest != pvargSrc && res == S_OK )
1972 {
1973 VariantClear( pvargDest ); /* result is not checked */
1974
1975 if( V_VT(pvargSrc) & VT_BYREF )
1976 {
1977 /* In the case of byreference we only need
1978 * to copy the pointer.
1979 */
1980 pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
1981 V_VT(pvargDest) = V_VT(pvargSrc);
1982 }
1983 else
1984 {
1985 /*
1986 * The VT_ARRAY flag is another way to designate a safe array.
1987 */
1988 if (V_VT(pvargSrc) & VT_ARRAY)
1989 {
1990 SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
1991 }
1992 else
1993 {
1994 /* In the case of by value we need to
1995 * copy the actual value. In the case of
1996 * VT_BSTR a copy of the string is made,
1997 * if VT_DISPATCH or VT_IUNKNOWN AddRef is
1998 * called to increment the object's reference count.
1999 */
2000 switch( V_VT(pvargSrc) & VT_TYPEMASK )
2001 {
2002 case( VT_BSTR ):
2003 V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( V_UNION(pvargSrc,bstrVal) );
2004 break;
2005 case( VT_DISPATCH ):
2006 V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
2007 if (V_UNION(pvargDest,pdispVal)!=NULL)
2008 IDispatch_AddRef(V_UNION(pvargDest,pdispVal));
2009 break;
2010 case( VT_VARIANT ):
2011 VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
2012 break;
2013 case( VT_UNKNOWN ):
2014 V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
2015 if (V_UNION(pvargDest,pdispVal)!=NULL)
2016 IUnknown_AddRef(V_UNION(pvargDest,punkVal));
2017 break;
2018 case( VT_SAFEARRAY ):
2019 SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
2020 break;
2021 default:
2022 pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
2023 break;
2024 }
2025 }
2026 V_VT(pvargDest) = V_VT(pvargSrc);
2027 dump_Variant(pvargDest);
2028 }
2029 }
2030
2031 return res;
2032 }
2033
2034
2035 /******************************************************************************
2036 * VariantCopyInd [OLEAUT32.11]
2037 *
2038 * Frees up the destination variant and makes a copy of the source. If
2039 * the source is of type VT_BYREF it performs the necessary indirections.
2040 */
2041 HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
2042 {
2043 HRESULT res = S_OK;
2044
2045 TRACE("(%p, %p)\n", pvargDest, pvargSrc);
2046
2047 res = ValidateVariantType( V_VT(pvargSrc) );
2048
2049 if( res != S_OK )
2050 return res;
2051
2052 if( V_VT(pvargSrc) & VT_BYREF )
2053 {
2054 VARIANTARG varg;
2055 VariantInit( &varg );
2056
2057 /* handle the in place copy.
2058 */
2059 if( pvargDest == pvargSrc )
2060 {
2061 /* we will use a copy of the source instead.
2062 */
2063 res = VariantCopy( &varg, pvargSrc );
2064 pvargSrc = &varg;
2065 }
2066
2067 if( res == S_OK )
2068 {
2069 res = VariantClear( pvargDest );
2070
2071 if( res == S_OK )
2072 {
2073 /*
2074 * The VT_ARRAY flag is another way to designate a safearray variant.
2075 */
2076 if ( V_VT(pvargSrc) & VT_ARRAY)
2077 {
2078 SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
2079 }
2080 else
2081 {
2082 /* In the case of by reference we need
2083 * to copy the date pointed to by the variant.
2084 */
2085
2086 /* Get the variant type.
2087 */
2088 switch( V_VT(pvargSrc) & VT_TYPEMASK )
2089 {
2090 case( VT_BSTR ):
2091 V_UNION(pvargDest,bstrVal) = SYSDUPSTRING( *(V_UNION(pvargSrc,pbstrVal)) );
2092 break;
2093 case( VT_DISPATCH ):
2094 V_UNION(pvargDest,pdispVal) = *V_UNION(pvargSrc,ppdispVal);
2095 if (V_UNION(pvargDest,pdispVal)!=NULL)
2096 IDispatch_AddRef(V_UNION(pvargDest,pdispVal));
2097 break;
2098 case( VT_VARIANT ):
2099 {
2100 /* Prevent from cycling. According to tests on
2101 * VariantCopyInd in Windows and the documentation
2102 * this API dereferences the inner Variants to only one depth.
2103 * If the inner Variant itself contains an
2104 * other inner variant the E_INVALIDARG error is
2105 * returned.
2106 */
2107 if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
2108 {
2109 /* If we get here we are attempting to deference
2110 * an inner variant that that is itself contained
2111 * in an inner variant so report E_INVALIDARG error.
2112 */
2113 res = E_INVALIDARG;
2114 }
2115 else
2116 {
2117 /* Set the processing inner variant flag.
2118 * We will set this flag in the inner variant
2119 * that will be passed to the VariantCopyInd function.
2120 */
2121 (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
2122
2123 /* Dereference the inner variant.
2124 */
2125 res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
2126 /* We must also copy its type, I think.
2127 */
2128 V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
2129 }
2130 }
2131 break;
2132 case( VT_UNKNOWN ):
2133 V_UNION(pvargDest,punkVal) = *V_UNION(pvargSrc,ppunkVal);
2134 if (V_UNION(pvargDest,pdispVal)!=NULL)
2135 IUnknown_AddRef(V_UNION(pvargDest,punkVal));
2136 break;
2137 case( VT_SAFEARRAY ):
2138 SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
2139 break;
2140 default:
2141 /* This is a by reference Variant which means that the union
2142 * part of the Variant contains a pointer to some data of
2143 * type "V_VT(pvargSrc) & VT_TYPEMASK".
2144 * We will deference this data in a generic fashion using
2145 * the void pointer "Variant.u.byref".
2146 * We will copy this data into the union of the destination
2147 * Variant.
2148 */
2149 memcpy( &pvargDest->n1.n2.n3, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
2150 break;
2151 }
2152 }
2153
2154 if (res == S_OK) V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
2155 }
2156 }
2157
2158 /* this should not fail.
2159 */
2160 VariantClear( &varg );
2161 }
2162 else
2163 {
2164 res = VariantCopy( pvargDest, pvargSrc );
2165 }
2166
2167 return res;
2168 }
2169
2170 /******************************************************************************
2171 * Coerces a full safearray. Not optimal code.
2172 */
2173 static HRESULT
2174 coerce_array(
2175 VARIANTARG* src, VARIANTARG *dst, LCID lcid, USHORT wFlags, VARTYPE vt
2176 ) {
2177 SAFEARRAY *sarr = V_ARRAY(src);
2178 HRESULT hres;
2179 LPVOID data;
2180 VARTYPE vartype;
2181
2182 SafeArrayGetVartype(sarr,&vartype);
2183 switch (vt) {
2184 case VT_BSTR:
2185 if (sarr->cDims != 1) {
2186 FIXME("Can not coerce array with dim %d into BSTR\n", sarr->cDims);
2187 return E_FAIL;
2188 }
2189 switch (V_VT(src) & VT_TYPEMASK) {
2190 case VT_UI1:
2191 hres = SafeArrayAccessData(sarr, &data);
2192 if (FAILED(hres)) return hres;
2193
2194 /* Yes, just memcpied apparently. */
2195 V_BSTR(dst) = SysAllocStringByteLen(data, sarr->rgsabound[0].cElements);
2196 hres = SafeArrayUnaccessData(sarr);
2197 if (FAILED(hres)) return hres;
2198 break;
2199 default:
2200 FIXME("Cannot coerce array of %d into BSTR yet. Please report!\n", V_VT(src) & VT_TYPEMASK);
2201 return E_FAIL;
2202 }
2203 break;
2204 case VT_SAFEARRAY:
2205 V_VT(dst) = VT_SAFEARRAY;
2206 return SafeArrayCopy(sarr, &V_ARRAY(dst));
2207 default:
2208 FIXME("Cannot coerce array of vt 0x%x/0x%x into vt 0x%x yet. Please report/implement!\n", vartype, V_VT(src), vt);
2209 return E_FAIL;
2210 }
2211 return S_OK;
2212 }
2213
2214 /******************************************************************************
2215 * VariantChangeType [OLEAUT32.12]
2216 */
2217 HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
2218 USHORT wFlags, VARTYPE vt)
2219 {
2220 return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
2221 }
2222
2223 /******************************************************************************
2224 * VariantChangeTypeEx [OLEAUT32.147]
2225 */
2226 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
2227 LCID lcid, USHORT wFlags, VARTYPE vt)
2228 {
2229 HRESULT res = S_OK;
2230 VARIANTARG varg;
2231 VariantInit( &varg );
2232
2233 TRACE("(%p, %p, %ld, %u, %u) vt=%d\n", pvargDest, pvargSrc, lcid, wFlags, vt, V_VT(pvargSrc));
2234 TRACE("Src Var:\n");
2235 dump_Variant(pvargSrc);
2236
2237 /* validate our source argument.
2238 */
2239 res = ValidateVariantType( V_VT(pvargSrc) );
2240
2241 /* validate the vartype.
2242 */
2243 if( res == S_OK )
2244 {
2245 res = ValidateVt( vt );
2246 }
2247
2248 /* if we are doing an in-place conversion make a copy of the source.
2249 */
2250 if( res == S_OK && pvargDest == pvargSrc )
2251 {
2252 res = VariantCopy( &varg, pvargSrc );
2253 pvargSrc = &varg;
2254 }
2255
2256 if( res == S_OK )
2257 {
2258 /* free up the destination variant.
2259 */
2260 res = VariantClear( pvargDest );
2261 }
2262
2263 if( res == S_OK )
2264 {
2265 if( V_VT(pvargSrc) & VT_BYREF )
2266 {
2267 /* Convert the source variant to a "byvalue" variant.
2268 */
2269 VARIANTARG Variant;
2270
2271 if ((V_VT(pvargSrc) & 0xf000) != VT_BYREF) {
2272 FIXME("VT_TYPEMASK %x is unhandled.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2273 return E_FAIL;
2274 }
2275
2276 VariantInit( &Variant );
2277 res = VariantCopyInd( &Variant, pvargSrc );
2278 if( res == S_OK )
2279 {
2280 res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
2281 /* this should not fail.
2282 */
2283 VariantClear( &Variant );
2284 }
2285 } else {
2286 if (V_VT(pvargSrc) & VT_ARRAY) {
2287 if ((V_VT(pvargSrc) & 0xf000) != VT_ARRAY) {
2288 FIXME("VT_TYPEMASK %x is unhandled in VT_ARRAY.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2289 return E_FAIL;
2290 }
2291 V_VT(pvargDest) = VT_ARRAY | vt;
2292 res = coerce_array(pvargSrc, pvargDest, lcid, wFlags, vt);
2293 } else {
2294 if ((V_VT(pvargSrc) & 0xf000)) {
2295 FIXME("VT_TYPEMASK %x is unhandled in normal case.\n",V_VT(pvargSrc) & VT_TYPEMASK);
2296 return E_FAIL;
2297 }
2298 /* Use the current "byvalue" source variant.
2299 */
2300 res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
2301 }
2302 }
2303 }
2304 /* this should not fail.
2305 */
2306 VariantClear( &varg );
2307
2308 /* set the type of the destination
2309 */
2310 if ( res == S_OK )
2311 V_VT(pvargDest) = vt;
2312
2313 TRACE("Dest Var:\n");
2314 dump_Variant(pvargDest);
2315
2316 return res;
2317 }
2318
2319
2320
2321
2322 /******************************************************************************
2323 * VarUI1FromI2 [OLEAUT32.130]
2324 */
2325 HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut)
2326 {
2327 TRACE("( %d, %p ), stub\n", sIn, pbOut );
2328
2329 /* Check range of value.
2330 */
2331 if( sIn < UI1_MIN || sIn > UI1_MAX )
2332 {
2333 return DISP_E_OVERFLOW;
2334 }
2335
2336 *pbOut = (BYTE) sIn;
2337
2338 return S_OK;
2339 }
2340
2341 /******************************************************************************
2342 * VarUI1FromI4 [OLEAUT32.131]
2343 */
2344 HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut)
2345 {
2346 TRACE("( %ld, %p ), stub\n", lIn, pbOut );
2347
2348 /* Check range of value.
2349 */
2350 if( lIn < UI1_MIN || lIn > UI1_MAX )
2351 {
2352 return DISP_E_OVERFLOW;
2353 }
2354
2355 *pbOut = (BYTE) lIn;
2356
2357 return S_OK;
2358 }
2359
2360
2361 /******************************************************************************
2362 * VarUI1FromR4 [OLEAUT32.132]
2363 */
2364 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
2365 {
2366 TRACE("( %f, %p ), stub\n", fltIn, pbOut );
2367
2368 /* Check range of value.
2369 */
2370 fltIn = round( fltIn );
2371 if( fltIn < UI1_MIN || fltIn > UI1_MAX )
2372 {
2373 return DISP_E_OVERFLOW;
2374 }
2375
2376 *pbOut = (BYTE) fltIn;
2377
2378 return S_OK;
2379 }
2380
2381 /******************************************************************************
2382 * VarUI1FromR8 [OLEAUT32.133]
2383 */
2384 HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
2385 {
2386 TRACE("( %f, %p ), stub\n", dblIn, pbOut );
2387
2388 /* Check range of value.
2389 */
2390 dblIn = round( dblIn );
2391 if( dblIn < UI1_MIN || dblIn > UI1_MAX )
2392 {
2393 return DISP_E_OVERFLOW;
2394 }
2395
2396 *pbOut = (BYTE) dblIn;
2397
2398 return S_OK;
2399 }
2400
2401 /******************************************************************************
2402 * VarUI1FromDate [OLEAUT32.135]
2403 */
2404 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
2405 {
2406 TRACE("( %f, %p ), stub\n", dateIn, pbOut );
2407
2408 /* Check range of value.
2409 */
2410 dateIn = round( dateIn );
2411 if( dateIn < UI1_MIN || dateIn > UI1_MAX )
2412 {
2413 return DISP_E_OVERFLOW;
2414 }
2415
2416 *pbOut = (BYTE) dateIn;
2417
2418 return S_OK;
2419 }
2420
2421 /******************************************************************************
2422 * VarUI1FromBool [OLEAUT32.138]
2423 */
2424 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
2425 {
2426 TRACE("( %d, %p ), stub\n", boolIn, pbOut );
2427
2428 *pbOut = (BYTE) boolIn;
2429
2430 return S_OK;
2431 }
2432
2433 /******************************************************************************
2434 * VarUI1FromI1 [OLEAUT32.237]
2435 */
2436 HRESULT WINAPI VarUI1FromI1(CHAR cIn, BYTE* pbOut)
2437 {
2438 TRACE("( %c, %p ), stub\n", cIn, pbOut );
2439
2440 *pbOut = cIn;
2441
2442 return S_OK;
2443 }
2444
2445 /******************************************************************************
2446 * VarUI1FromUI2 [OLEAUT32.238]
2447 */
2448 HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut)
2449 {
2450 TRACE("( %d, %p ), stub\n", uiIn, pbOut );
2451
2452 /* Check range of value.
2453 */
2454 if( uiIn > UI1_MAX )
2455 {
2456 return DISP_E_OVERFLOW;
2457 }
2458
2459 *pbOut = (BYTE) uiIn;
2460
2461 return S_OK;
2462 }
2463
2464 /******************************************************************************
2465 * VarUI1FromUI4 [OLEAUT32.239]
2466 */
2467 HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
2468 {
2469 TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
2470
2471 /* Check range of value.
2472 */
2473 if( ulIn > UI1_MAX )
2474 {
2475 return DISP_E_OVERFLOW;
2476 }
2477
2478 *pbOut = (BYTE) ulIn;
2479
2480 return S_OK;
2481 }
2482
2483
2484 /******************************************************************************
2485 * VarUI1FromStr [OLEAUT32.136]
2486 */
2487 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
2488 {
2489 double dValue = 0.0;
2490 LPSTR pNewString = NULL;
2491
2492 TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
2493
2494 /* Check if we have a valid argument
2495 */
2496 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2497 RemoveCharacterFromString( pNewString, "," );
2498 if( IsValidRealString( pNewString ) == FALSE )
2499 {
2500 return DISP_E_TYPEMISMATCH;
2501 }
2502
2503 /* Convert the valid string to a floating point number.
2504 */
2505 dValue = atof( pNewString );
2506
2507 /* We don't need the string anymore so free it.
2508 */
2509 HeapFree( GetProcessHeap(), 0 , pNewString );
2510
2511 /* Check range of value.
2512 */
2513 dValue = round( dValue );
2514 if( dValue < UI1_MIN || dValue > UI1_MAX )
2515 {
2516 return DISP_E_OVERFLOW;
2517 }
2518
2519 *pbOut = (BYTE) dValue;
2520
2521 return S_OK;
2522 }
2523
2524 /**********************************************************************
2525 * VarUI1FromCy [OLEAUT32.134]
2526 * Convert currency to unsigned char
2527 */
2528 HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
2529 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2530
2531 if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
2532
2533 *pbOut = (BYTE)t;
2534 return S_OK;
2535 }
2536
2537 /******************************************************************************
2538 * VarI2FromUI1 [OLEAUT32.48]
2539 */
2540 HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut)
2541 {
2542 TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
2543
2544 *psOut = (short) bIn;
2545
2546 return S_OK;
2547 }
2548
2549 /******************************************************************************
2550 * VarI2FromI4 [OLEAUT32.49]
2551 */
2552 HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut)
2553 {
2554 TRACE("( %lx, %p ), stub\n", lIn, psOut );
2555
2556 /* Check range of value.
2557 */
2558 if( lIn < I2_MIN || lIn > I2_MAX )
2559 {
2560 return DISP_E_OVERFLOW;
2561 }
2562
2563 *psOut = (short) lIn;
2564
2565 return S_OK;
2566 }
2567
2568 /******************************************************************************
2569 * VarI2FromR4 [OLEAUT32.50]
2570 */
2571 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut)
2572 {
2573 TRACE("( %f, %p ), stub\n", fltIn, psOut );
2574
2575 /* Check range of value.
2576 */
2577 fltIn = round( fltIn );
2578 if( fltIn < I2_MIN || fltIn > I2_MAX )
2579 {
2580 return DISP_E_OVERFLOW;
2581 }
2582
2583 *psOut = (short) fltIn;
2584
2585 return S_OK;
2586 }
2587
2588 /******************************************************************************
2589 * VarI2FromR8 [OLEAUT32.51]
2590 */
2591 HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut)
2592 {
2593 TRACE("( %f, %p ), stub\n", dblIn, psOut );
2594
2595 /* Check range of value.
2596 */
2597 dblIn = round( dblIn );
2598 if( dblIn < I2_MIN || dblIn > I2_MAX )
2599 {
2600 return DISP_E_OVERFLOW;
2601 }
2602
2603 *psOut = (short) dblIn;
2604
2605 return S_OK;
2606 }
2607
2608 /******************************************************************************
2609 * VarI2FromDate [OLEAUT32.53]
2610 */
2611 HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut)
2612 {
2613 TRACE("( %f, %p ), stub\n", dateIn, psOut );
2614
2615 /* Check range of value.
2616 */
2617 dateIn = round( dateIn );
2618 if( dateIn < I2_MIN || dateIn > I2_MAX )
2619 {
2620 return DISP_E_OVERFLOW;
2621 }
2622
2623 *psOut = (short) dateIn;
2624
2625 return S_OK;
2626 }
2627
2628 /******************************************************************************
2629 * VarI2FromBool [OLEAUT32.56]
2630 */
2631 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut)
2632 {
2633 TRACE("( %d, %p ), stub\n", boolIn, psOut );
2634
2635 *psOut = (short) boolIn;
2636
2637 return S_OK;
2638 }
2639
2640 /******************************************************************************
2641 * VarI2FromI1 [OLEAUT32.205]
2642 */
2643 HRESULT WINAPI VarI2FromI1(CHAR cIn, short* psOut)
2644 {
2645 TRACE("( %c, %p ), stub\n", cIn, psOut );
2646
2647 *psOut = (short) cIn;
2648
2649 return S_OK;
2650 }
2651
2652 /******************************************************************************
2653 * VarI2FromUI2 [OLEAUT32.206]
2654 */
2655 HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut)
2656 {
2657 TRACE("( %d, %p ), stub\n", uiIn, psOut );
2658
2659 /* Check range of value.
2660 */
2661 if( uiIn > I2_MAX )
2662 {
2663 return DISP_E_OVERFLOW;
2664 }
2665
2666 *psOut = (short) uiIn;
2667
2668 return S_OK;
2669 }
2670
2671 /******************************************************************************
2672 * VarI2FromUI4 [OLEAUT32.207]
2673 */
2674 HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
2675 {
2676 TRACE("( %lx, %p ), stub\n", ulIn, psOut );
2677
2678 /* Check range of value.
2679 */
2680 if( ulIn < I2_MIN || ulIn > I2_MAX )
2681 {
2682 return DISP_E_OVERFLOW;
2683 }
2684
2685 *psOut = (short) ulIn;
2686
2687 return S_OK;
2688 }
2689
2690 /******************************************************************************
2691 * VarI2FromStr [OLEAUT32.54]
2692 */
2693 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut)
2694 {
2695 double dValue = 0.0;
2696 LPSTR pNewString = NULL;
2697
2698 TRACE("( %s, 0x%08lx, 0x%08lx, %p ), stub\n", debugstr_w(strIn), lcid, dwFlags, psOut );
2699
2700 /* Check if we have a valid argument
2701 */
2702 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2703 RemoveCharacterFromString( pNewString, "," );
2704 if( IsValidRealString( pNewString ) == FALSE )
2705 {
2706 return DISP_E_TYPEMISMATCH;
2707 }
2708
2709 /* Convert the valid string to a floating point number.
2710 */
2711 dValue = atof( pNewString );
2712
2713 /* We don't need the string anymore so free it.
2714 */
2715 HeapFree( GetProcessHeap(), 0, pNewString );
2716
2717 /* Check range of value.
2718 */
2719 dValue = round( dValue );
2720 if( dValue < I2_MIN || dValue > I2_MAX )
2721 {
2722 return DISP_E_OVERFLOW;
2723 }
2724
2725 *psOut = (short) dValue;
2726
2727 return S_OK;
2728 }
2729
2730 /**********************************************************************
2731 * VarI2FromCy [OLEAUT32.52]
2732 * Convert currency to signed short
2733 */
2734 HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
2735 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2736
2737 if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
2738
2739 *psOut = (SHORT)t;
2740 return S_OK;
2741 }
2742
2743 /******************************************************************************
2744 * VarI4FromUI1 [OLEAUT32.58]
2745 */
2746 HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut)
2747 {
2748 TRACE("( %X, %p ), stub\n", bIn, plOut );
2749
2750 *plOut = (LONG) bIn;
2751
2752 return S_OK;
2753 }
2754
2755
2756 /******************************************************************************
2757 * VarI4FromR4 [OLEAUT32.60]
2758 */
2759 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut)
2760 {
2761 TRACE("( %f, %p ), stub\n", fltIn, plOut );
2762
2763 /* Check range of value.
2764 */
2765 fltIn = round( fltIn );
2766 if( fltIn < I4_MIN || fltIn > I4_MAX )
2767 {
2768 return DISP_E_OVERFLOW;
2769 }
2770
2771 *plOut = (LONG) fltIn;
2772
2773 return S_OK;
2774 }
2775
2776 /******************************************************************************
2777 * VarI4FromR8 [OLEAUT32.61]
2778 */
2779 HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut)
2780 {
2781 TRACE("( %f, %p ), stub\n", dblIn, plOut );
2782
2783 /* Check range of value.
2784 */
2785 dblIn = round( dblIn );
2786 if( dblIn < I4_MIN || dblIn > I4_MAX )
2787 {
2788 return DISP_E_OVERFLOW;
2789 }
2790
2791 *plOut = (LONG) dblIn;
2792
2793 return S_OK;
2794 }
2795
2796 /******************************************************************************
2797 * VarI4FromDate [OLEAUT32.63]
2798 */
2799 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut)
2800 {
2801 TRACE("( %f, %p ), stub\n", dateIn, plOut );
2802
2803 /* Check range of value.
2804 */
2805 dateIn = round( dateIn );
2806 if( dateIn < I4_MIN || dateIn > I4_MAX )
2807 {
2808 return DISP_E_OVERFLOW;
2809 }
2810
2811 *plOut = (LONG) dateIn;
2812
2813 return S_OK;
2814 }
2815
2816 /******************************************************************************
2817 * VarI4FromBool [OLEAUT32.66]
2818 */
2819 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut)
2820 {
2821 TRACE("( %d, %p ), stub\n", boolIn, plOut );
2822
2823 *plOut = (LONG) boolIn;
2824
2825 return S_OK;
2826 }
2827
2828 /******************************************************************************
2829 * VarI4FromI1 [OLEAUT32.209]
2830 */
2831 HRESULT WINAPI VarI4FromI1(CHAR cIn, LONG* plOut)
2832 {
2833 TRACE("( %c, %p ), stub\n", cIn, plOut );
2834
2835 *plOut = (LONG) cIn;
2836
2837 return S_OK;
2838 }
2839
2840 /******************************************************************************
2841 * VarI4FromUI2 [OLEAUT32.210]
2842 */
2843 HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut)
2844 {
2845 TRACE("( %d, %p ), stub\n", uiIn, plOut );
2846
2847 *plOut = (LONG) uiIn;
2848
2849 return S_OK;
2850 }
2851
2852 /******************************************************************************
2853 * VarI4FromUI4 [OLEAUT32.211]
2854 */
2855 HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut)
2856 {
2857 TRACE("( %lx, %p ), stub\n", ulIn, plOut );
2858
2859 /* Check range of value.
2860 */
2861 if( ulIn < I4_MIN || ulIn > I4_MAX )
2862 {
2863 return DISP_E_OVERFLOW;
2864 }
2865
2866 *plOut = (LONG) ulIn;
2867
2868 return S_OK;
2869 }
2870
2871 /******************************************************************************
2872 * VarI4FromI2 [OLEAUT32.59]
2873 */
2874 HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut)
2875 {
2876 TRACE("( %d, %p ), stub\n", sIn, plOut );
2877
2878 *plOut = (LONG) sIn;
2879
2880 return S_OK;
2881 }
2882
2883 /******************************************************************************
2884 * VarI4FromStr [OLEAUT32.64]
2885 */
2886 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut)
2887 {
2888 double dValue = 0.0;
2889 LPSTR pNewString = NULL;
2890
2891 TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
2892
2893 /* Check if we have a valid argument
2894 */
2895 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
2896 RemoveCharacterFromString( pNewString, "," );
2897 if( IsValidRealString( pNewString ) == FALSE )
2898 {
2899 return DISP_E_TYPEMISMATCH;
2900 }
2901
2902 /* Convert the valid string to a floating point number.
2903 */
2904 dValue = atof( pNewString );
2905
2906 /* We don't need the string anymore so free it.
2907 */
2908 HeapFree( GetProcessHeap(), 0, pNewString );
2909
2910 /* Check range of value.
2911 */
2912 dValue = round( dValue );
2913 if( dValue < I4_MIN || dValue > I4_MAX )
2914 {
2915 return DISP_E_OVERFLOW;
2916 }
2917
2918 *plOut = (LONG) dValue;
2919
2920 return S_OK;
2921 }
2922
2923 /**********************************************************************
2924 * VarI4FromCy [OLEAUT32.62]
2925 * Convert currency to signed long
2926 */
2927 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
2928 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
2929
2930 if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
2931
2932 *plOut = (LONG)t;
2933 return S_OK;
2934 }
2935
2936 /******************************************************************************
2937 * VarR4FromUI1 [OLEAUT32.68]
2938 */
2939 HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut)
2940 {
2941 TRACE("( %X, %p ), stub\n", bIn, pfltOut );
2942
2943 *pfltOut = (FLOAT) bIn;
2944
2945 return S_OK;
2946 }
2947
2948 /******************************************************************************
2949 * VarR4FromI2 [OLEAUT32.69]
2950 */
2951 HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut)
2952 {
2953 TRACE("( %d, %p ), stub\n", sIn, pfltOut );
2954
2955 *pfltOut = (FLOAT) sIn;
2956
2957 return S_OK;
2958 }
2959
2960 /******************************************************************************
2961 * VarR4FromI4 [OLEAUT32.70]
2962 */
2963 HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut)
2964 {
2965 TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
2966
2967 *pfltOut = (FLOAT) lIn;
2968
2969 return S_OK;
2970 }
2971
2972 /******************************************************************************
2973 * VarR4FromR8 [OLEAUT32.71]
2974 */
2975 HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut)
2976 {
2977 TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
2978
2979 /* Check range of value.
2980 */
2981 if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
2982 {
2983 return DISP_E_OVERFLOW;
2984 }
2985
2986 *pfltOut = (FLOAT) dblIn;
2987
2988 return S_OK;
2989 }
2990
2991 /******************************************************************************
2992 * VarR4FromDate [OLEAUT32.73]
2993 */
2994 HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut)
2995 {
2996 TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
2997
2998 /* Check range of value.
2999 */
3000 if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
3001 {
3002 return DISP_E_OVERFLOW;
3003 }
3004
3005 *pfltOut = (FLOAT) dateIn;
3006
3007 return S_OK;
3008 }
3009
3010 /******************************************************************************
3011 * VarR4FromBool [OLEAUT32.76]
3012 */
3013 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut)
3014 {
3015 TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
3016
3017 *pfltOut = (FLOAT) boolIn;
3018
3019 return S_OK;
3020 }
3021
3022 /******************************************************************************
3023 * VarR4FromI1 [OLEAUT32.213]
3024 */
3025 HRESULT WINAPI VarR4FromI1(CHAR cIn, FLOAT* pfltOut)
3026 {
3027 TRACE("( %c, %p ), stub\n", cIn, pfltOut );
3028
3029 *pfltOut = (FLOAT) cIn;
3030
3031 return S_OK;
3032 }
3033
3034 /******************************************************************************
3035 * VarR4FromUI2 [OLEAUT32.214]
3036 */
3037 HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut)
3038 {
3039 TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
3040
3041 *pfltOut = (FLOAT) uiIn;
3042
3043 return S_OK;
3044 }
3045
3046 /******************************************************************************
3047 * VarR4FromUI4 [OLEAUT32.215]
3048 */
3049 HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut)
3050 {
3051 TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
3052
3053 *pfltOut = (FLOAT) ulIn;
3054
3055 return S_OK;
3056 }
3057
3058 /******************************************************************************
3059 * VarR4FromStr [OLEAUT32.74]
3060 */
3061 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut)
3062 {
3063 double dValue = 0.0;
3064 LPSTR pNewString = NULL;
3065
3066 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
3067
3068 /* Check if we have a valid argument
3069 */
3070 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3071 RemoveCharacterFromString( pNewString, "," );
3072 if( IsValidRealString( pNewString ) == FALSE )
3073 {
3074 return DISP_E_TYPEMISMATCH;
3075 }
3076
3077 /* Convert the valid string to a floating point number.
3078 */
3079 dValue = atof( pNewString );
3080
3081 /* We don't need the string anymore so free it.
3082 */
3083 HeapFree( GetProcessHeap(), 0, pNewString );
3084
3085 /* Check range of value.
3086 */
3087 if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
3088 {
3089 return DISP_E_OVERFLOW;
3090 }
3091
3092 *pfltOut = (FLOAT) dValue;
3093
3094 return S_OK;
3095 }
3096
3097 /**********************************************************************
3098 * VarR4FromCy [OLEAUT32.72]
3099 * Convert currency to float
3100 */
3101 HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
3102 *pfltOut = (FLOAT)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3103
3104 return S_OK;
3105 }
3106
3107 /******************************************************************************
3108 * VarR8FromUI1 [OLEAUT32.78]
3109 */
3110 HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
3111 {
3112 TRACE("( %d, %p ), stub\n", bIn, pdblOut );
3113
3114 *pdblOut = (double) bIn;
3115
3116 return S_OK;
3117 }
3118
3119 /******************************************************************************
3120 * VarR8FromI2 [OLEAUT32.79]
3121 */
3122 HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
3123 {
3124 TRACE("( %d, %p ), stub\n", sIn, pdblOut );
3125
3126 *pdblOut = (double) sIn;
3127
3128 return S_OK;
3129 }
3130
3131 /******************************************************************************
3132 * VarR8FromI4 [OLEAUT32.80]
3133 */
3134 HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
3135 {
3136 TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
3137
3138 *pdblOut = (double) lIn;
3139
3140 return S_OK;
3141 }
3142
3143 /******************************************************************************
3144 * VarR8FromR4 [OLEAUT32.81]
3145 */
3146 HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut)
3147 {
3148 TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
3149
3150 *pdblOut = (double) fltIn;
3151
3152 return S_OK;
3153 }
3154
3155 /******************************************************************************
3156 * VarR8FromDate [OLEAUT32.83]
3157 */
3158 HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut)
3159 {
3160 TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
3161
3162 *pdblOut = (double) dateIn;
3163
3164 return S_OK;
3165 }
3166
3167 /******************************************************************************
3168 * VarR8FromBool [OLEAUT32.86]
3169 */
3170 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut)
3171 {
3172 TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
3173
3174 *pdblOut = (double) boolIn;
3175
3176 return S_OK;
3177 }
3178
3179 /******************************************************************************
3180 * VarR8FromI1 [OLEAUT32.217]
3181 */
3182 HRESULT WINAPI VarR8FromI1(CHAR cIn, double* pdblOut)
3183 {
3184 TRACE("( %c, %p ), stub\n", cIn, pdblOut );
3185
3186 *pdblOut = (double) cIn;
3187
3188 return S_OK;
3189 }
3190
3191 /******************************************************************************
3192 * VarR8FromUI2 [OLEAUT32.218]
3193 */
3194 HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut)
3195 {
3196 TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
3197
3198 *pdblOut = (double) uiIn;
3199
3200 return S_OK;
3201 }
3202
3203 /******************************************************************************
3204 * VarR8FromUI4 [OLEAUT32.219]
3205 */
3206 HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut)
3207 {
3208 TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
3209
3210 *pdblOut = (double) ulIn;
3211
3212 return S_OK;
3213 }
3214
3215 /******************************************************************************
3216 * VarR8FromStr [OLEAUT32.84]
3217 */
3218 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut)
3219 {
3220 double dValue = 0.0;
3221 LPSTR pNewString = NULL;
3222
3223 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3224 TRACE("( %s, %ld, %ld, %p ), stub\n", pNewString, lcid, dwFlags, pdblOut );
3225
3226 /* Check if we have a valid argument
3227 */
3228 RemoveCharacterFromString( pNewString, "," );
3229 if( IsValidRealString( pNewString ) == FALSE )
3230 {
3231 return DISP_E_TYPEMISMATCH;
3232 }
3233
3234 /* Convert the valid string to a floating point number.
3235 */
3236 dValue = atof( pNewString );
3237
3238 /* We don't need the string anymore so free it.
3239 */
3240 HeapFree( GetProcessHeap(), 0, pNewString );
3241
3242 *pdblOut = dValue;
3243
3244 return S_OK;
3245 }
3246
3247 /**********************************************************************
3248 * VarR8FromCy [OLEAUT32.82]
3249 * Convert currency to double
3250 */
3251 HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
3252 *pdblOut = (double)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3253 TRACE("%lu %ld -> %f\n", cyIn.s.Hi, cyIn.s.Lo, *pdblOut);
3254 return S_OK;
3255 }
3256
3257 /******************************************************************************
3258 * VarDateFromUI1 [OLEAUT32.88]
3259 */
3260 HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
3261 {
3262 TRACE("( %d, %p ), stub\n", bIn, pdateOut );
3263
3264 *pdateOut = (DATE) bIn;
3265
3266 return S_OK;
3267 }
3268
3269 /******************************************************************************
3270 * VarDateFromI2 [OLEAUT32.89]
3271 */
3272 HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
3273 {
3274 TRACE("( %d, %p ), stub\n", sIn, pdateOut );
3275
3276 *pdateOut = (DATE) sIn;
3277
3278 return S_OK;
3279 }
3280
3281 /******************************************************************************
3282 * VarDateFromI4 [OLEAUT32.90]
3283 */
3284 HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
3285 {
3286 TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
3287
3288 if( lIn < DATE_MIN || lIn > DATE_MAX )
3289 {
3290 return DISP_E_OVERFLOW;
3291 }
3292
3293 *pdateOut = (DATE) lIn;
3294
3295 return S_OK;
3296 }
3297
3298 /******************************************************************************
3299 * VarDateFromR4 [OLEAUT32.91]
3300 */
3301 HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
3302 {
3303 TRACE("( %f, %p ), stub\n", fltIn, pdateOut );
3304
3305 if( ceil(fltIn) < DATE_MIN || floor(fltIn) > DATE_MAX )
3306 {
3307 return DISP_E_OVERFLOW;
3308 }
3309
3310 *pdateOut = (DATE) fltIn;
3311
3312 return S_OK;
3313 }
3314
3315 /******************************************************************************
3316 * VarDateFromR8 [OLEAUT32.92]
3317 */
3318 HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
3319 {
3320 TRACE("( %f, %p ), stub\n", dblIn, pdateOut );
3321
3322 if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
3323 {
3324 return DISP_E_OVERFLOW;
3325 }
3326
3327 *pdateOut = (DATE) dblIn;
3328
3329 return S_OK;
3330 }
3331
3332 /******************************************************************************
3333 * VarDateFromStr [OLEAUT32.94]
3334 * The string representing the date is composed of two parts, a date and time.
3335 *
3336 * The format of the time is has follows:
3337 * hh[:mm][:ss][AM|PM]
3338 * Whitespace can be inserted anywhere between these tokens. A whitespace consists
3339 * of space and/or tab characters, which are ignored.
3340 *
3341 * The formats for the date part are has follows:
3342 * mm/[dd/][yy]yy
3343 * [dd/]mm/[yy]yy
3344 * [yy]yy/mm/dd
3345 * January dd[,] [yy]yy
3346 * dd January [yy]yy
3347 * [yy]yy January dd
3348 * Whitespace can be inserted anywhere between these tokens.
3349 *
3350 * The formats for the date and time string are has follows.
3351 * date[whitespace][time]
3352 * [time][whitespace]date
3353 *
3354 * These are the only characters allowed in a string representing a date and time:
3355 * [A-Z] [a-z] [0-9] ':' '-' '/' ',' ' ' '\t'
3356 */
3357 HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
3358 {
3359 HRESULT ret = S_OK;
3360 struct tm TM;
3361
3362 memset( &TM, 0, sizeof(TM) );
3363
3364 TRACE("( %p, %lx, %lx, %p ), stub\n", strIn, lcid, dwFlags, pdateOut );
3365
3366 if( DateTimeStringToTm( strIn, dwFlags, &TM ) )
3367 {
3368 if( TmToDATE( &TM, pdateOut ) == FALSE )
3369 {
3370 ret = E_INVALIDARG;
3371 }
3372 }
3373 else
3374 {
3375 ret = DISP_E_TYPEMISMATCH;
3376 }
3377 TRACE("Return value %f\n", *pdateOut);
3378 return ret;
3379 }
3380
3381 /******************************************************************************
3382 * VarDateFromI1 [OLEAUT32.221]
3383 */
3384 HRESULT WINAPI VarDateFromI1(CHAR cIn, DATE* pdateOut)
3385 {
3386 TRACE("( %c, %p ), stub\n", cIn, pdateOut );
3387
3388 *pdateOut = (DATE) cIn;
3389
3390 return S_OK;
3391 }
3392
3393 /******************************************************************************
3394 * VarDateFromUI2 [OLEAUT32.222]
3395 */
3396 HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
3397 {
3398 TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
3399
3400 if( uiIn > DATE_MAX )
3401 {
3402 return DISP_E_OVERFLOW;
3403 }
3404
3405 *pdateOut = (DATE) uiIn;
3406
3407 return S_OK;
3408 }
3409
3410 /******************************************************************************
3411 * VarDateFromUI4 [OLEAUT32.223]
3412 */
3413 HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
3414 {
3415 TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
3416
3417 if( ulIn < DATE_MIN || ulIn > DATE_MAX )
3418 {
3419 return DISP_E_OVERFLOW;
3420 }
3421
3422 *pdateOut = (DATE) ulIn;
3423
3424 return S_OK;
3425 }
3426
3427 /******************************************************************************
3428 * VarDateFromBool [OLEAUT32.96]
3429 */
3430 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
3431 {
3432 TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
3433
3434 *pdateOut = (DATE) boolIn;
3435
3436 return S_OK;
3437 }
3438
3439 /**********************************************************************
3440 * VarDateFromCy [OLEAUT32.93]
3441 * Convert currency to date
3442 */
3443 HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut) {
3444 *pdateOut = (DATE)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
3445
3446 if (*pdateOut > DATE_MAX || *pdateOut < DATE_MIN) return DISP_E_TYPEMISMATCH;
3447 return S_OK;
3448 }
3449
3450 /******************************************************************************
3451 * VarBstrFromUI1 [OLEAUT32.108]
3452 */
3453 HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3454 {
3455 TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
3456 sprintf( pBuffer, "%d", bVal );
3457
3458 *pbstrOut = StringDupAtoBstr( pBuffer );
3459
3460 return S_OK;
3461 }
3462
3463 /******************************************************************************
3464 * VarBstrFromI2 [OLEAUT32.109]
3465 */
3466 HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3467 {
3468 TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
3469 sprintf( pBuffer, "%d", iVal );
3470 *pbstrOut = StringDupAtoBstr( pBuffer );
3471
3472 return S_OK;
3473 }
3474
3475 /******************************************************************************
3476 * VarBstrFromI4 [OLEAUT32.110]
3477 */
3478 HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3479 {
3480 TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
3481
3482 sprintf( pBuffer, "%ld", lIn );
3483 *pbstrOut = StringDupAtoBstr( pBuffer );
3484
3485 return S_OK;
3486 }
3487
3488 /******************************************************************************
3489 * VarBstrFromR4 [OLEAUT32.111]
3490 */
3491 HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3492 {
3493 TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
3494
3495 sprintf( pBuffer, "%.7G", fltIn );
3496 *pbstrOut = StringDupAtoBstr( pBuffer );
3497
3498 return S_OK;
3499 }
3500
3501 /******************************************************************************
3502 * VarBstrFromR8 [OLEAUT32.112]
3503 */
3504 HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3505 {
3506 TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
3507
3508 sprintf( pBuffer, "%.15G", dblIn );
3509 *pbstrOut = StringDupAtoBstr( pBuffer );
3510
3511 return S_OK;
3512 }
3513
3514 /******************************************************************************
3515 * VarBstrFromCy [OLEAUT32.113]
3516 */
3517 HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut) {
3518 HRESULT rc = S_OK;
3519 double curVal = 0.0;
3520
3521 TRACE("([cyIn], %08lx, %08lx, %p), partial stub (no flags handled).\n", lcid, dwFlags, pbstrOut);
3522
3523 /* Firstly get the currency in a double, then put it in a buffer */
3524 rc = VarR8FromCy(cyIn, &curVal);
3525 if (rc == S_OK) {
3526 sprintf(pBuffer, "%G", curVal);
3527 *pbstrOut = StringDupAtoBstr( pBuffer );
3528 }
3529 return rc;
3530 }
3531
3532
3533 /******************************************************************************
3534 * VarBstrFromDate [OLEAUT32.114]
3535 *
3536 * The date is implemented using an 8 byte floating-point number.
3537 * Days are represented by whole numbers increments starting with 0.00 as
3538 * being December 30 1899, midnight.
3539 * The hours are expressed as the fractional part of the number.
3540 * December 30 1899 at midnight = 0.00
3541 * January 1 1900 at midnight = 2.00
3542 * January 4 1900 at 6 AM = 5.25
3543 * January 4 1900 at noon = 5.50
3544 * December 29 1899 at midnight = -1.00
3545 * December 18 1899 at midnight = -12.00
3546 * December 18 1899 at 6AM = -12.25
3547 * December 18 1899 at 6PM = -12.75
3548 * December 19 1899 at midnight = -11.00
3549 * The tm structure is as follows:
3550 * struct tm {
3551 * int tm_sec; seconds after the minute - [0,59]
3552 * int tm_min; minutes after the hour - [0,59]
3553 * int tm_hour; hours since midnight - [0,23]
3554 * int tm_mday; day of the month - [1,31]
3555 * int tm_mon; months since January - [0,11]
3556 * int tm_year; years
3557 * int tm_wday; days since Sunday - [0,6]
3558 * int tm_yday; days since January 1 - [0,365]
3559 * int tm_isdst; daylight savings time flag
3560 * };
3561 */
3562 HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3563 {
3564 struct tm TM;
3565 memset( &TM, 0, sizeof(TM) );
3566
3567 TRACE("( %20.20f, %ld, %ld, %p ), stub\n", dateIn, lcid, dwFlags, pbstrOut );
3568
3569 if( DateToTm( dateIn, dwFlags, &TM ) == FALSE )
3570 {
3571 return E_INVALIDARG;
3572 }
3573
3574 if( dwFlags & VAR_DATEVALUEONLY )
3575 strftime( pBuffer, BUFFER_MAX, "%x", &TM );
3576 else if( dwFlags & VAR_TIMEVALUEONLY )
3577 strftime( pBuffer, BUFFER_MAX, "%X", &TM );
3578 else
3579 strftime( pBuffer, BUFFER_MAX, "%x %X", &TM );
3580
3581 TRACE("result: %s\n", pBuffer);
3582 *pbstrOut = StringDupAtoBstr( pBuffer );
3583 return S_OK;
3584 }
3585
3586 /******************************************************************************
3587 * VarBstrFromBool [OLEAUT32.116]
3588 */
3589 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3590 {
3591 TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
3592
3593 sprintf( pBuffer, (boolIn == VARIANT_FALSE) ? "False" : "True" );
3594
3595 *pbstrOut = StringDupAtoBstr( pBuffer );
3596
3597 return S_OK;
3598 }
3599
3600 /******************************************************************************
3601 * VarBstrFromI1 [OLEAUT32.229]
3602 */
3603 HRESULT WINAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3604 {
3605 TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
3606 sprintf( pBuffer, "%d", cIn );
3607 *pbstrOut = StringDupAtoBstr( pBuffer );
3608
3609 return S_OK;
3610 }
3611
3612 /******************************************************************************
3613 * VarBstrFromUI2 [OLEAUT32.230]
3614 */
3615 HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3616 {
3617 TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
3618 sprintf( pBuffer, "%d", uiIn );
3619 *pbstrOut = StringDupAtoBstr( pBuffer );
3620
3621 return S_OK;
3622 }
3623
3624 /******************************************************************************
3625 * VarBstrFromUI4 [OLEAUT32.231]
3626 */
3627 HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3628 {
3629 TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
3630 sprintf( pBuffer, "%ld", ulIn );
3631 *pbstrOut = StringDupAtoBstr( pBuffer );
3632
3633 return S_OK;
3634 }
3635
3636 /******************************************************************************
3637 * VarBstrFromDec [OLEAUT32.@]
3638 */
3639 HRESULT WINAPI VarBstrFromDec(DECIMAL* pDecIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
3640 { FIXME("%c%08lx%08lx%08lx E%02x stub\n",
3641 (pDecIn->u.s.sign == DECIMAL_NEG) ? '-' :
3642 (pDecIn->u.s.sign == 0) ? '+' : '?',
3643 pDecIn->Hi32, pDecIn->u1.s1.Mid32, pDecIn->u1.s1.Lo32,
3644 pDecIn->u.s.scale);
3645 return E_INVALIDARG;
3646 }
3647
3648 /******************************************************************************
3649 * VarBoolFromUI1 [OLEAUT32.118]
3650 */
3651 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
3652 {
3653 TRACE("( %d, %p ), stub\n", bIn, pboolOut );
3654
3655 if( bIn == 0 )
3656 {
3657 *pboolOut = VARIANT_FALSE;
3658 }
3659 else
3660 {
3661 *pboolOut = VARIANT_TRUE;
3662 }
3663
3664 return S_OK;
3665 }
3666
3667 /******************************************************************************
3668 * VarBoolFromI2 [OLEAUT32.119]
3669 */
3670 HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
3671 {
3672 TRACE("( %d, %p ), stub\n", sIn, pboolOut );
3673
3674 *pboolOut = (sIn) ? VARIANT_TRUE : VARIANT_FALSE;
3675
3676 return S_OK;
3677 }
3678
3679 /******************************************************************************
3680 * VarBoolFromI4 [OLEAUT32.120]
3681 */
3682 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
3683 {
3684 TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
3685
3686 *pboolOut = (lIn) ? VARIANT_TRUE : VARIANT_FALSE;
3687
3688 return S_OK;
3689 }
3690
3691 /******************************************************************************
3692 * VarBoolFromR4 [OLEAUT32.121]
3693 */
3694 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
3695 {
3696 TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
3697
3698 *pboolOut = (fltIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3699
3700 return S_OK;
3701 }
3702
3703 /******************************************************************************
3704 * VarBoolFromR8 [OLEAUT32.122]
3705 */
3706 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
3707 {
3708 TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
3709
3710 *pboolOut = (dblIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3711
3712 return S_OK;
3713 }
3714
3715 /******************************************************************************
3716 * VarBoolFromDate [OLEAUT32.123]
3717 */
3718 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
3719 {
3720 TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
3721
3722 *pboolOut = (dateIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3723
3724 return S_OK;
3725 }
3726
3727 /******************************************************************************
3728 * VarBoolFromStr [OLEAUT32.125]
3729 */
3730 HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
3731 {
3732 HRESULT ret = S_OK;
3733 char* pNewString = NULL;
3734
3735 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
3736
3737 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3738
3739 if( pNewString == NULL || strlen( pNewString ) == 0 )
3740 {
3741 ret = DISP_E_TYPEMISMATCH;
3742 }
3743
3744 if( ret == S_OK )
3745 {
3746 if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
3747 {
3748 *pboolOut = VARIANT_TRUE;
3749 }
3750 else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
3751 {
3752 *pboolOut = VARIANT_FALSE;
3753 }
3754 else
3755 {
3756 /* Try converting the string to a floating point number.
3757 */
3758 double dValue = 0.0;
3759 HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
3760 if( res != S_OK )
3761 {
3762 ret = DISP_E_TYPEMISMATCH;
3763 }
3764 else
3765 *pboolOut = (dValue == 0.0) ?
3766 VARIANT_FALSE : VARIANT_TRUE;
3767 }
3768 }
3769
3770 HeapFree( GetProcessHeap(), 0, pNewString );
3771
3772 return ret;
3773 }
3774
3775 /******************************************************************************
3776 * VarBoolFromI1 [OLEAUT32.233]
3777 */
3778 HRESULT WINAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL* pboolOut)
3779 {
3780 TRACE("( %c, %p ), stub\n", cIn, pboolOut );
3781
3782 *pboolOut = (cIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3783
3784 return S_OK;
3785 }
3786
3787 /******************************************************************************
3788 * VarBoolFromUI2 [OLEAUT32.234]
3789 */
3790 HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
3791 {
3792 TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
3793
3794 *pboolOut = (uiIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3795
3796 return S_OK;
3797 }
3798
3799 /******************************************************************************
3800 * VarBoolFromUI4 [OLEAUT32.235]
3801 */
3802 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
3803 {
3804 TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
3805
3806 *pboolOut = (ulIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3807
3808 return S_OK;
3809 }
3810
3811 /**********************************************************************
3812 * VarBoolFromCy [OLEAUT32.124]
3813 * Convert currency to boolean
3814 */
3815 HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) {
3816 if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
3817 else *pboolOut = 0;
3818
3819 return S_OK;
3820 }
3821
3822 /******************************************************************************
3823 * VarI1FromUI1 [OLEAUT32.244]
3824 */
3825 HRESULT WINAPI VarI1FromUI1(BYTE bIn, CHAR* pcOut)
3826 {
3827 TRACE("( %d, %p ), stub\n", bIn, pcOut );
3828
3829 /* Check range of value.
3830 */
3831 if( bIn > CHAR_MAX )
3832 {
3833 return DISP_E_OVERFLOW;
3834 }
3835
3836 *pcOut = (CHAR) bIn;
3837
3838 return S_OK;
3839 }
3840
3841 /******************************************************************************
3842 * VarI1FromI2 [OLEAUT32.245]
3843 */
3844 HRESULT WINAPI VarI1FromI2(short uiIn, CHAR* pcOut)
3845 {
3846 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3847
3848 if( uiIn > CHAR_MAX )
3849 {
3850 return DISP_E_OVERFLOW;
3851 }
3852
3853 *pcOut = (CHAR) uiIn;
3854
3855 return S_OK;
3856 }
3857
3858 /******************************************************************************
3859 * VarI1FromI4 [OLEAUT32.246]
3860 */
3861 HRESULT WINAPI VarI1FromI4(LONG lIn, CHAR* pcOut)
3862 {
3863 TRACE("( %ld, %p ), stub\n", lIn, pcOut );
3864
3865 if( lIn < CHAR_MIN || lIn > CHAR_MAX )
3866 {
3867 return DISP_E_OVERFLOW;
3868 }
3869
3870 *pcOut = (CHAR) lIn;
3871
3872 return S_OK;
3873 }
3874
3875 /******************************************************************************
3876 * VarI1FromR4 [OLEAUT32.247]
3877 */
3878 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, CHAR* pcOut)
3879 {
3880 TRACE("( %f, %p ), stub\n", fltIn, pcOut );
3881
3882 fltIn = round( fltIn );
3883 if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
3884 {
3885 return DISP_E_OVERFLOW;
3886 }
3887
3888 *pcOut = (CHAR) fltIn;
3889
3890 return S_OK;
3891 }
3892
3893 /******************************************************************************
3894 * VarI1FromR8 [OLEAUT32.248]
3895 */
3896 HRESULT WINAPI VarI1FromR8(double dblIn, CHAR* pcOut)
3897 {
3898 TRACE("( %f, %p ), stub\n", dblIn, pcOut );
3899
3900 dblIn = round( dblIn );
3901 if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
3902 {
3903 return DISP_E_OVERFLOW;
3904 }
3905
3906 *pcOut = (CHAR) dblIn;
3907
3908 return S_OK;
3909 }
3910
3911 /******************************************************************************
3912 * VarI1FromDate [OLEAUT32.249]
3913 */
3914 HRESULT WINAPI VarI1FromDate(DATE dateIn, CHAR* pcOut)
3915 {
3916 TRACE("( %f, %p ), stub\n", dateIn, pcOut );
3917
3918 dateIn = round( dateIn );
3919 if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
3920 {
3921 return DISP_E_OVERFLOW;
3922 }
3923
3924 *pcOut = (CHAR) dateIn;
3925
3926 return S_OK;
3927 }
3928
3929 /******************************************************************************
3930 * VarI1FromStr [OLEAUT32.251]
3931 */
3932 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CHAR* pcOut)
3933 {
3934 double dValue = 0.0;
3935 LPSTR pNewString = NULL;
3936
3937 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
3938
3939 /* Check if we have a valid argument
3940 */
3941 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3942 RemoveCharacterFromString( pNewString, "," );
3943 if( IsValidRealString( pNewString ) == FALSE )
3944 {
3945 return DISP_E_TYPEMISMATCH;
3946 }
3947
3948 /* Convert the valid string to a floating point number.
3949 */
3950 dValue = atof( pNewString );
3951
3952 /* We don't need the string anymore so free it.
3953 */
3954 HeapFree( GetProcessHeap(), 0, pNewString );
3955
3956 /* Check range of value.
3957 */
3958 dValue = round( dValue );
3959 if( dValue < CHAR_MIN || dValue > CHAR_MAX )
3960 {
3961 return DISP_E_OVERFLOW;
3962 }
3963
3964 *pcOut = (CHAR) dValue;
3965
3966 return S_OK;
3967 }
3968
3969 /******************************************************************************
3970 * VarI1FromBool [OLEAUT32.253]
3971 */
3972 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR* pcOut)
3973 {
3974 TRACE("( %d, %p ), stub\n", boolIn, pcOut );
3975
3976 *pcOut = (CHAR) boolIn;
3977
3978 return S_OK;
3979 }
3980
3981 /******************************************************************************
3982 * VarI1FromUI2 [OLEAUT32.254]
3983 */
3984 HRESULT WINAPI VarI1FromUI2(USHORT uiIn, CHAR* pcOut)
3985 {
3986 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3987
3988 if( uiIn > CHAR_MAX )
3989 {
3990 return DISP_E_OVERFLOW;
3991 }
3992
3993 *pcOut = (CHAR) uiIn;
3994
3995 return S_OK;
3996 }
3997
3998 /******************************************************************************
3999 * VarI1FromUI4 [OLEAUT32.255]
4000 */
4001 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut)
4002 {
4003 TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
4004
4005 if( ulIn > CHAR_MAX )
4006 {
4007 return DISP_E_OVERFLOW;
4008 }
4009
4010 *pcOut = (CHAR) ulIn;
4011
4012 return S_OK;
4013 }
4014
4015 /**********************************************************************
4016 * VarI1FromCy [OLEAUT32.250]
4017 * Convert currency to signed char
4018 */
4019 HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) {
4020 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4021
4022 if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
4023
4024 *pcOut = (CHAR)t;
4025 return S_OK;
4026 }
4027
4028 /******************************************************************************
4029 * VarUI2FromUI1 [OLEAUT32.257]
4030 */
4031 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
4032 {
4033 TRACE("( %d, %p ), stub\n", bIn, puiOut );
4034
4035 *puiOut = (USHORT) bIn;
4036
4037 return S_OK;
4038 }
4039
4040 /******************************************************************************
4041 * VarUI2FromI2 [OLEAUT32.258]
4042 */
4043 HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
4044 {
4045 TRACE("( %d, %p ), stub\n", uiIn, puiOut );
4046
4047 if( uiIn < UI2_MIN )
4048 {
4049 return DISP_E_OVERFLOW;
4050 }
4051
4052 *puiOut = (USHORT) uiIn;
4053
4054 return S_OK;
4055 }
4056
4057 /******************************************************************************
4058 * VarUI2FromI4 [OLEAUT32.259]
4059 */
4060 HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
4061 {
4062 TRACE("( %ld, %p ), stub\n", lIn, puiOut );
4063
4064 if( lIn < UI2_MIN || lIn > UI2_MAX )
4065 {
4066 return DISP_E_OVERFLOW;
4067 }
4068
4069 *puiOut = (USHORT) lIn;
4070
4071 return S_OK;
4072 }
4073
4074 /******************************************************************************
4075 * VarUI2FromR4 [OLEAUT32.260]
4076 */
4077 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
4078 {
4079 TRACE("( %f, %p ), stub\n", fltIn, puiOut );
4080
4081 fltIn = round( fltIn );
4082 if( fltIn < UI2_MIN || fltIn > UI2_MAX )
4083 {
4084 return DISP_E_OVERFLOW;
4085 }
4086
4087 *puiOut = (USHORT) fltIn;
4088
4089 return S_OK;
4090 }
4091
4092 /******************************************************************************
4093 * VarUI2FromR8 [OLEAUT32.261]
4094 */
4095 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
4096 {
4097 TRACE("( %f, %p ), stub\n", dblIn, puiOut );
4098
4099 dblIn = round( dblIn );
4100 if( dblIn < UI2_MIN || dblIn > UI2_MAX )
4101 {
4102 return DISP_E_OVERFLOW;
4103 }
4104
4105 *puiOut = (USHORT) dblIn;
4106
4107 return S_OK;
4108 }
4109
4110 /******************************************************************************
4111 * VarUI2FromDate [OLEAUT32.262]
4112 */
4113 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
4114 {
4115 TRACE("( %f, %p ), stub\n", dateIn, puiOut );
4116
4117 dateIn = round( dateIn );
4118 if( dateIn < UI2_MIN || dateIn > UI2_MAX )
4119 {
4120 return DISP_E_OVERFLOW;
4121 }
4122
4123 *puiOut = (USHORT) dateIn;
4124
4125 return S_OK;
4126 }
4127
4128 /******************************************************************************
4129 * VarUI2FromStr [OLEAUT32.264]
4130 */
4131 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
4132 {
4133 double dValue = 0.0;
4134 LPSTR pNewString = NULL;
4135
4136 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
4137
4138 /* Check if we have a valid argument
4139 */
4140 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4141 RemoveCharacterFromString( pNewString, "," );
4142 if( IsValidRealString( pNewString ) == FALSE )
4143 {
4144 return DISP_E_TYPEMISMATCH;
4145 }
4146
4147 /* Convert the valid string to a floating point number.
4148 */
4149 dValue = atof( pNewString );
4150
4151 /* We don't need the string anymore so free it.
4152 */
4153 HeapFree( GetProcessHeap(), 0, pNewString );
4154
4155 /* Check range of value.
4156 */
4157 dValue = round( dValue );
4158 if( dValue < UI2_MIN || dValue > UI2_MAX )
4159 {
4160 return DISP_E_OVERFLOW;
4161 }
4162
4163 *puiOut = (USHORT) dValue;
4164
4165 return S_OK;
4166 }
4167
4168 /******************************************************************************
4169 * VarUI2FromBool [OLEAUT32.266]
4170 */
4171 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
4172 {
4173 TRACE("( %d, %p ), stub\n", boolIn, puiOut );
4174
4175 *puiOut = (USHORT) boolIn;
4176
4177 return S_OK;
4178 }
4179
4180 /******************************************************************************
4181 * VarUI2FromI1 [OLEAUT32.267]
4182 */
4183 HRESULT WINAPI VarUI2FromI1(CHAR cIn, USHORT* puiOut)
4184 {
4185 TRACE("( %c, %p ), stub\n", cIn, puiOut );
4186
4187 *puiOut = (USHORT) cIn;
4188
4189 return S_OK;
4190 }
4191
4192 /******************************************************************************
4193 * VarUI2FromUI4 [OLEAUT32.268]
4194 */
4195 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
4196 {
4197 TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
4198
4199 if( ulIn > UI2_MAX )
4200 {
4201 return DISP_E_OVERFLOW;
4202 }
4203
4204 *puiOut = (USHORT) ulIn;
4205
4206 return S_OK;
4207 }
4208
4209 /******************************************************************************
4210 * VarUI4FromStr [OLEAUT32.277]
4211 */
4212 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
4213 {
4214 double dValue = 0.0;
4215 LPSTR pNewString = NULL;
4216
4217 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
4218
4219 /* Check if we have a valid argument
4220 */
4221 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4222 RemoveCharacterFromString( pNewString, "," );
4223 if( IsValidRealString( pNewString ) == FALSE )
4224 {
4225 return DISP_E_TYPEMISMATCH;
4226 }
4227
4228 /* Convert the valid string to a floating point number.
4229 */
4230 dValue = atof( pNewString );
4231
4232 /* We don't need the string anymore so free it.
4233 */
4234 HeapFree( GetProcessHeap(), 0, pNewString );
4235
4236 /* Check range of value.
4237 */
4238 dValue = round( dValue );
4239 if( dValue < UI4_MIN || dValue > UI4_MAX )
4240 {
4241 return DISP_E_OVERFLOW;
4242 }
4243
4244 *pulOut = (ULONG) dValue;
4245
4246 return S_OK;
4247 }
4248
4249 /**********************************************************************
4250 * VarUI2FromCy [OLEAUT32.263]
4251 * Convert currency to unsigned short
4252 */
4253 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
4254 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4255
4256 if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
4257
4258 *pusOut = (USHORT)t;
4259
4260 return S_OK;
4261 }
4262
4263 /******************************************************************************
4264 * VarUI4FromUI1 [OLEAUT32.270]
4265 */
4266 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
4267 {
4268 TRACE("( %d, %p ), stub\n", bIn, pulOut );
4269
4270 *pulOut = (USHORT) bIn;
4271
4272 return S_OK;
4273 }
4274
4275 /******************************************************************************
4276 * VarUI4FromI2 [OLEAUT32.271]
4277 */
4278 HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
4279 {
4280 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4281
4282 if( uiIn < UI4_MIN )
4283 {
4284 return DISP_E_OVERFLOW;
4285 }
4286
4287 *pulOut = (ULONG) uiIn;
4288
4289 return S_OK;
4290 }
4291
4292 /******************************************************************************
4293 * VarUI4FromI4 [OLEAUT32.272]
4294 */
4295 HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
4296 {
4297 TRACE("( %ld, %p ), stub\n", lIn, pulOut );
4298
4299 if( lIn < 0 )
4300 {
4301 return DISP_E_OVERFLOW;
4302 }
4303
4304 *pulOut = (ULONG) lIn;
4305
4306 return S_OK;
4307 }
4308
4309 /******************************************************************************
4310 * VarUI4FromR4 [OLEAUT32.273]
4311 */
4312 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
4313 {
4314 fltIn = round( fltIn );
4315 if( fltIn < UI4_MIN || fltIn > UI4_MAX )
4316 {
4317 return DISP_E_OVERFLOW;
4318 }
4319
4320 *pulOut = (ULONG) fltIn;
4321
4322 return S_OK;
4323 }
4324
4325 /******************************************************************************
4326 * VarUI4FromR8 [OLEAUT32.274]
4327 */
4328 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
4329 {
4330 TRACE("( %f, %p ), stub\n", dblIn, pulOut );
4331
4332 dblIn = round( dblIn );
4333 if( dblIn < UI4_MIN || dblIn > UI4_MAX )
4334 {
4335 return DISP_E_OVERFLOW;
4336 }
4337
4338 *pulOut = (ULONG) dblIn;
4339
4340 return S_OK;
4341 }
4342
4343 /******************************************************************************
4344 * VarUI4FromDate [OLEAUT32.275]
4345 */
4346 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
4347 {
4348 TRACE("( %f, %p ), stub\n", dateIn, pulOut );
4349
4350 dateIn = round( dateIn );
4351 if( dateIn < UI4_MIN || dateIn > UI4_MAX )
4352 {
4353 return DISP_E_OVERFLOW;
4354 }
4355
4356 *pulOut = (ULONG) dateIn;
4357
4358 return S_OK;
4359 }
4360
4361 /******************************************************************************
4362 * VarUI4FromBool [OLEAUT32.279]
4363 */
4364 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
4365 {
4366 TRACE("( %d, %p ), stub\n", boolIn, pulOut );
4367
4368 *pulOut = (ULONG) boolIn;
4369
4370 return S_OK;
4371 }
4372
4373 /******************************************************************************
4374 * VarUI4FromI1 [OLEAUT32.280]
4375 */
4376 HRESULT WINAPI VarUI4FromI1(CHAR cIn, ULONG* pulOut)
4377 {
4378 TRACE("( %c, %p ), stub\n", cIn, pulOut );
4379
4380 *pulOut = (ULONG) cIn;
4381
4382 return S_OK;
4383 }
4384
4385 /******************************************************************************
4386 * VarUI4FromUI2 [OLEAUT32.281]
4387 */
4388 HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
4389 {
4390 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4391
4392 *pulOut = (ULONG) uiIn;
4393
4394 return S_OK;
4395 }
4396
4397 /**********************************************************************
4398 * VarUI4FromCy [OLEAUT32.276]
4399 * Convert currency to unsigned long
4400 */
4401 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
4402 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4403
4404 if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
4405
4406 *pulOut = (ULONG)t;
4407
4408 return S_OK;
4409 }
4410
4411 /**********************************************************************
4412 * VarCyFromUI1 [OLEAUT32.98]
4413 * Convert unsigned char to currency
4414 */
4415 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
4416 pcyOut->s.Hi = 0;
4417 pcyOut->s.Lo = ((ULONG)bIn) * 10000;
4418
4419 return S_OK;
4420 }
4421
4422 /**********************************************************************
4423 * VarCyFromI2 [OLEAUT32.99]
4424 * Convert signed short to currency
4425 */
4426 HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
4427 if (sIn < 0) pcyOut->s.Hi = -1;
4428 else pcyOut->s.Hi = 0;
4429 pcyOut->s.Lo = ((ULONG)sIn) * 10000;
4430
4431 return S_OK;
4432 }
4433
4434 /**********************************************************************
4435 * VarCyFromI4 [OLEAUT32.100]
4436 * Convert signed long to currency
4437 */
4438 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
4439 double t = (double)lIn * (double)10000;
4440 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4441 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4442 if (lIn < 0) pcyOut->s.Hi--;
4443
4444 return S_OK;
4445 }
4446
4447 /**********************************************************************
4448 * VarCyFromR4 [OLEAUT32.101]
4449 * Convert float to currency
4450 */
4451 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
4452 double t = round((double)fltIn * (double)10000);
4453 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4454 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4455 if (fltIn < 0) pcyOut->s.Hi--;
4456
4457 return S_OK;
4458 }
4459
4460 /**********************************************************************
4461 * VarCyFromR8 [OLEAUT32.102]
4462 * Convert double to currency
4463 */
4464 HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
4465 double t = round(dblIn * (double)10000);
4466 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4467 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4468 if (dblIn < 0) pcyOut->s.Hi--;
4469
4470 return S_OK;
4471 }
4472
4473 /**********************************************************************
4474 * VarCyFromDate [OLEAUT32.103]
4475 * Convert date to currency
4476 */
4477 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
4478 double t = round((double)dateIn * (double)10000);
4479 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4480 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4481 if (dateIn < 0) pcyOut->s.Hi--;
4482
4483 return S_OK;
4484 }
4485
4486 /**********************************************************************
4487 * VarCyFromStr [OLEAUT32.104]
4488 * FIXME: Never tested with decimal seperator other than '.'
4489 */
4490 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
4491
4492 LPSTR pNewString = NULL;
4493 char *decSep = NULL;
4494 char *strPtr,*curPtr = NULL;
4495 int size, rc;
4496 double currencyVal = 0.0;
4497
4498
4499 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4500 TRACE("( '%s', 0x%08lx, 0x%08lx, %p )\n", pNewString, lcid, dwFlags, pcyOut );
4501
4502 /* Get locale information - Decimal Seperator (size includes 0x00) */
4503 size = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, NULL, 0);
4504 decSep = (char *) malloc(size);
4505 rc = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, decSep, size);
4506 TRACE("Decimal Seperator is '%s'\n", decSep);
4507
4508 /* Now copy to temporary buffer, skipping any character except 0-9 and
4509 the decimal seperator */
4510 curPtr = pBuffer; /* Current position in string being built */
4511 strPtr = pNewString; /* Current position in supplied currenct string */
4512
4513 while (*strPtr) {
4514 /* If decimal seperator, skip it and put '.' in string */
4515 if (strncmp(strPtr, decSep, (size-1)) == 0) {
4516 strPtr = strPtr + (size-1);
4517 *curPtr = '.';
4518 curPtr++;
4519 } else if ((*strPtr == '+' || *strPtr == '-') ||
4520 (*strPtr >= '0' && *strPtr <= '9')) {
4521 *curPtr = *strPtr;
4522 strPtr++;
4523 curPtr++;
4524 } else strPtr++;
4525 }
4526 *curPtr = 0x00;
4527
4528 /* Try to get currency into a double */
4529 currencyVal = atof(pBuffer);
4530 TRACE("Converted string '%s' to %f\n", pBuffer, currencyVal);
4531
4532 /* Free allocated storage */
4533 HeapFree( GetProcessHeap(), 0, pNewString );
4534 free(decSep);
4535
4536 /* Convert double -> currency using internal routine */
4537 return VarCyFromR8(currencyVal, pcyOut);
4538 }
4539
4540
4541 /**********************************************************************
4542 * VarCyFromBool [OLEAUT32.106]
4543 * Convert boolean to currency
4544 */
4545 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
4546 if (boolIn < 0) pcyOut->s.Hi = -1;
4547 else pcyOut->s.Hi = 0;
4548 pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
4549
4550 return S_OK;
4551 }
4552
4553 /**********************************************************************
4554 * VarCyFromI1 [OLEAUT32.225]
4555 * Convert signed char to currency
4556 */
4557 HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pcyOut) {
4558 if (cIn < 0) pcyOut->s.Hi = -1;
4559 else pcyOut->s.Hi = 0;
4560 pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
4561
4562 return S_OK;
4563 }
4564
4565 /**********************************************************************
4566 * VarCyFromUI2 [OLEAUT32.226]
4567 * Convert unsigned short to currency
4568 */
4569 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
4570 pcyOut->s.Hi = 0;
4571 pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
4572
4573 return S_OK;
4574 }
4575
4576 /**********************************************************************
4577 * VarCyFromUI4 [OLEAUT32.227]
4578 * Convert unsigned long to currency
4579 */
4580 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) {
4581 double t = (double)ulIn * (double)10000;
4582 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4583 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4584
4585 return S_OK;
4586 }
4587
4588 /**********************************************************************
4589 * VarDecFromStr [OLEAUT32.@]
4590 */
4591 HRESULT WINAPI VarDecFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags,
4592 DECIMAL* pdecOut)
4593 { WCHAR *p=strIn;
4594 ULONGLONG t;
4595 ULONG cy;
4596
4597 DECIMAL_SETZERO(pdecOut);
4598
4599 if(*p == (WCHAR)'-')pdecOut->u.s.sign= DECIMAL_NEG;
4600 if((*p == (WCHAR)'-') || (*p == (WCHAR)'+')) p++;
4601 for(;*p != (WCHAR)0; p++) {
4602 if((*p < (WCHAR)'0')||(*p > (WCHAR)'9')) goto error ;
4603 t = (ULONGLONG)pdecOut->u1.s1.Lo32 *(ULONGLONG)10
4604 + (ULONGLONG)(*p -(WCHAR)'0');
4605 cy = (ULONG)(t >> 32);
4606 pdecOut->u1.s1.Lo32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4607 t = (ULONGLONG)pdecOut->u1.s1.Mid32 * (ULONGLONG)10
4608 + (ULONGLONG)cy;
4609 cy = (ULONG)(t >> 32);
4610 pdecOut->u1.s1.Mid32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4611 t = (ULONGLONG)pdecOut->Hi32 * (ULONGLONG)10
4612 + (ULONGLONG)cy;
4613 cy = (ULONG)(t >> 32);
4614 pdecOut->Hi32 = (ULONG)(t & (ULONGLONG)UI4_MAX);
4615 if(cy) goto overflow ;
4616 }
4617 TRACE("%s -> sign %02x,hi %08lx,mid %08lx, lo%08lx, scale %08x\n",
4618 debugstr_w(strIn),
4619 pdecOut->u.s.sign, pdecOut->Hi32, pdecOut->u1.s1.Mid32,
4620 pdecOut->u1.s1.Lo32, pdecOut->u.s.scale);
4621 return S_OK;
4622
4623 overflow:
4624 /* like NT4 SP5 */
4625 pdecOut->Hi32 = pdecOut->u1.s1.Mid32 = pdecOut->u1.s1.Lo32 = 0xffffffff;
4626 return DISP_E_OVERFLOW;
4627
4628 error:
4629 ERR("%s: unknown char at pos %d\n",
4630 debugstr_w(strIn), p - strIn + 1);
4631 return DISP_E_TYPEMISMATCH;
4632 }
4633
4634 /**********************************************************************
4635 * DosDateTimeToVariantTime [OLEAUT32.14]
4636 * Convert dos representation of time to the date and time representation
4637 * stored in a variant.
4638 */
4639 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
4640 DATE *pvtime)
4641 {
4642 struct tm t;
4643
4644 TRACE("( 0x%x, 0x%x, %p ), stub\n", wDosDate, wDosTime, pvtime );
4645
4646 t.tm_sec = (wDosTime & 0x001f) * 2;
4647 t.tm_min = (wDosTime & 0x07e0) >> 5;
4648 t.tm_hour = (wDosTime & 0xf800) >> 11;
4649
4650 t.tm_mday = (wDosDate & 0x001f);
4651 t.tm_mon = (wDosDate & 0x01e0) >> 5;
4652 t.tm_year = ((wDosDate & 0xfe00) >> 9) + 1980;
4653
4654 return TmToDATE( &t, pvtime );
4655 }
4656
4657
4658 /**********************************************************************
4659 * VarParseNumFromStr [OLEAUT32.46]
4660 */
4661 HRESULT WINAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags,
4662 NUMPARSE * pnumprs, BYTE * rgbDig)
4663 {
4664 int i,lastent=0;
4665 int cDig;
4666 BOOL foundNum=FALSE;
4667
4668 FIXME("(%s,flags=%lx,....), partial stub!\n",debugstr_w(strIn),dwFlags);
4669 FIXME("numparse: cDig=%d, InFlags=%lx\n",pnumprs->cDig,pnumprs->dwInFlags);
4670
4671 /* The other struct components are to be set by us */
4672 memset(rgbDig,0,pnumprs->cDig);
4673
4674 /* FIXME: Just patching some values in */
4675 pnumprs->nPwr10 = 0;
4676 pnumprs->nBaseShift = 0;
4677 pnumprs->cchUsed = lastent;
4678 pnumprs->dwOutFlags = NUMPRS_DECIMAL;
4679
4680 cDig = 0;
4681 for (i=0; strIn[i] ;i++) {
4682 if ((strIn[i]>='0') && (strIn[i]<='9')) {
4683 foundNum = TRUE;
4684 if (pnumprs->cDig > cDig) {
4685 *(rgbDig++)=strIn[i]-'0';
4686 cDig++;
4687 lastent = i;
4688 }
4689 } else if ((strIn[i]=='-') && (foundNum==FALSE)) {
4690 pnumprs->dwOutFlags |= NUMPRS_NEG;
4691 }
4692 }
4693 pnumprs->cDig = cDig;
4694 TRACE("numparse out: cDig=%d, OutFlags=%lx\n",pnumprs->cDig,pnumprs->dwOutFlags);
4695 return S_OK;
4696 }
4697
4698
4699 /**********************************************************************
4700 * VarNumFromParseNum [OLEAUT32.47]
4701 */
4702 HRESULT WINAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig,
4703 ULONG dwVtBits, VARIANT * pvar)
4704 {
4705 DWORD xint;
4706 int i;
4707 FIXME("(..,dwVtBits=%lx,....), partial stub!\n",dwVtBits);
4708
4709 xint = 0;
4710 for (i=0;i<pnumprs->cDig;i++)
4711 xint = xint*10 + rgbDig[i];
4712
4713 if (pnumprs->dwOutFlags & NUMPRS_NEG) {
4714 xint = xint * -1;
4715 }
4716
4717 VariantInit(pvar);
4718 if (dwVtBits & VTBIT_I4) {
4719 V_VT(pvar) = VT_I4;
4720 V_UNION(pvar,intVal) = xint;
4721 return S_OK;
4722 }
4723 if (dwVtBits & VTBIT_R8) {
4724 V_VT(pvar) = VT_R8;
4725 V_UNION(pvar,dblVal) = xint;
4726 return S_OK;
4727 }
4728 if (dwVtBits & VTBIT_R4) {
4729 V_VT(pvar) = VT_R4;
4730 V_UNION(pvar,fltVal) = xint;
4731 return S_OK;
4732 }
4733 if (dwVtBits & VTBIT_I2) {
4734 V_VT(pvar) = VT_I2;
4735 V_UNION(pvar,iVal) = xint;
4736 return S_OK;
4737 }
4738 /* FIXME: Currency should be from a double */
4739 if (dwVtBits & VTBIT_CY) {
4740 V_VT(pvar) = VT_CY;
4741 TRACE("Calculated currency is xint=%ld\n", xint);
4742 VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4743 TRACE("Calculated cy is %ld,%lu\n", V_UNION(pvar,cyVal).s.Hi, V_UNION(pvar,cyVal).s.Lo);
4744 return VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4745 }
4746
4747 FIXME("vtbitmask is unsupported %lx, int=%d\n",dwVtBits, (int) xint);
4748 return E_FAIL;
4749 }
4750
4751
4752 /**********************************************************************
4753 * VarFormatDateTime [OLEAUT32.97]
4754 */
4755 HRESULT WINAPI VarFormatDateTime(LPVARIANT var, INT format, ULONG dwFlags, BSTR *out)
4756 {
4757 FIXME("%p %d %lx %p\n", var, format, dwFlags, out);
4758 return E_NOTIMPL;
4759 }
4760
4761 /**********************************************************************
4762 * VarFormatCurrency [OLEAUT32.127]
4763 */
4764 HRESULT WINAPI VarFormatCurrency(LPVARIANT var, INT digits, INT lead, INT paren, INT group, ULONG dwFlags, BSTR *out)
4765 {
4766 FIXME("%p %d %d %d %d %lx %p\n", var, digits, lead, paren, group, dwFlags, out);
4767 return E_NOTIMPL;
4768 }
4769
4770 /**********************************************************************
4771 * VariantTimeToDosDateTime [OLEAUT32.13]
4772 * Convert variant representation of time to the date and time representation
4773 * stored in dos.
4774 */
4775 INT WINAPI VariantTimeToDosDateTime(DATE pvtime, USHORT *wDosDate, USHORT *wDosTime)
4776 {
4777 struct tm t;
4778 *wDosTime = 0;
4779 *wDosDate = 0;
4780
4781 TRACE("( 0x%x, 0x%x, %p ), stub\n", *wDosDate, *wDosTime, &pvtime );
4782
4783 if (DateToTm(pvtime, 0, &t) < 0) return 0;
4784
4785 *wDosTime = *wDosTime | (t.tm_sec / 2);
4786 *wDosTime = *wDosTime | (t.tm_min << 5);
4787 *wDosTime = *wDosTime | (t.tm_hour << 11);
4788
4789 *wDosDate = *wDosDate | t.tm_mday ;
4790 *wDosDate = *wDosDate | t.tm_mon << 5;
4791 *wDosDate = *wDosDate | ((t.tm_year - 1980) << 9) ;
4792
4793 return 1;
4794 }
4795
4796
4797 /***********************************************************************
4798 * SystemTimeToVariantTime [OLEAUT32.184]
4799 */
4800 HRESULT WINAPI SystemTimeToVariantTime( LPSYSTEMTIME lpSystemTime, double *pvtime )
4801 {
4802 struct tm t;
4803
4804 TRACE(" %d/%d/%d %d:%d:%d\n",
4805 lpSystemTime->wMonth, lpSystemTime->wDay,
4806 lpSystemTime->wYear, lpSystemTime->wHour,
4807 lpSystemTime->wMinute, lpSystemTime->wSecond);
4808
4809 if (lpSystemTime->wYear >= 1900)
4810 {
4811 t.tm_sec = lpSystemTime->wSecond;
4812 t.tm_min = lpSystemTime->wMinute;
4813 t.tm_hour = lpSystemTime->wHour;
4814
4815 t.tm_mday = lpSystemTime->wDay;
4816 t.tm_mon = lpSystemTime->wMonth - 1; /* tm_mon is 0..11, wMonth is 1..12 */
4817 t.tm_year = lpSystemTime->wYear;
4818
4819 return TmToDATE( &t, pvtime );
4820 }
4821 else
4822 {
4823 double tmpDate;
4824 long firstDayOfNextYear;
4825 long thisDay;
4826 long leftInYear;
4827 long result;
4828
4829 double decimalPart = 0.0;
4830
4831 t.tm_sec = lpSystemTime->wSecond;
4832 t.tm_min = lpSystemTime->wMinute;
4833 t.tm_hour = lpSystemTime->wHour;
4834
4835 /* Step year forward the same number of years before 1900 */
4836 t.tm_year = 1900 + 1899 - lpSystemTime->wYear;
4837 t.tm_mon = lpSystemTime->wMonth - 1;
4838 t.tm_mday = lpSystemTime->wDay;
4839
4840 /* Calculate date */
4841 TmToDATE( &t, pvtime );
4842
4843 thisDay = (double) floor( *pvtime );
4844 decimalPart = fmod( *pvtime, thisDay );
4845
4846 /* Now, calculate the same time for the first of Jan that year */
4847 t.tm_mon = 0;
4848 t.tm_mday = 1;
4849 t.tm_sec = 0;
4850 t.tm_min = 0;
4851 t.tm_hour = 0;
4852 t.tm_year = t.tm_year+1;
4853 TmToDATE( &t, &tmpDate );
4854 firstDayOfNextYear = (long) floor(tmpDate);
4855
4856 /* Finally since we know the size of the year, subtract the two to get
4857 remaining time in the year */
4858 leftInYear = firstDayOfNextYear - thisDay;
4859
4860 /* Now we want full years up to the year in question, and remainder of year
4861 of the year in question */
4862 if (isleap(lpSystemTime->wYear) ) {
4863 TRACE("Extra day due to leap year\n");
4864 result = 2.0 - ((firstDayOfNextYear - 366) + leftInYear - 2.0);
4865 } else {
4866 result = 2.0 - ((firstDayOfNextYear - 365) + leftInYear - 2.0);
4867 }
4868 *pvtime = (double) result + decimalPart;
4869 TRACE("<1899 support: returned %f, 1st day %ld, thisday %ld, left %ld\n", *pvtime, firstDayOfNextYear, thisDay, leftInYear);
4870
4871 return 1;
4872 }
4873
4874 return 0;
4875 }
4876
4877 /***********************************************************************
4878 * VariantTimeToSystemTime [OLEAUT32.185]
4879 */
4880 HRESULT WINAPI VariantTimeToSystemTime( double vtime, LPSYSTEMTIME lpSystemTime )
4881 {
4882 double t = 0, timeofday = 0;
4883
4884 static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4885 static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4886
4887 /* The Month_Code is used to find the Day of the Week (LY = LeapYear)*/
4888 static const BYTE Month_Code[] = {0, 1, 4, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4889 static const BYTE Month_Code_LY[] = {0, 0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4890
4891 /* The Century_Code is used to find the Day of the Week */
4892 static const BYTE Century_Code[] = {0, 6, 4, 2};
4893
4894 struct tm r;
4895
4896 TRACE(" Variant = %f SYSTEMTIME ptr %p\n", vtime, lpSystemTime);
4897
4898 if (vtime >= 0)
4899 {
4900
4901 if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4902
4903 lpSystemTime->wSecond = r.tm_sec;
4904 lpSystemTime->wMinute = r.tm_min;
4905 lpSystemTime->wHour = r.tm_hour;
4906 lpSystemTime->wDay = r.tm_mday;
4907 lpSystemTime->wMonth = r.tm_mon;
4908
4909 if (lpSystemTime->wMonth == 12)
4910 lpSystemTime->wMonth = 1;
4911 else
4912 lpSystemTime->wMonth++;
4913
4914 lpSystemTime->wYear = r.tm_year;
4915 }
4916 else
4917 {
4918 vtime = -1*vtime;
4919
4920 if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4921
4922 lpSystemTime->wSecond = r.tm_sec;
4923 lpSystemTime->wMinute = r.tm_min;
4924 lpSystemTime->wHour = r.tm_hour;
4925
4926 lpSystemTime->wMonth = 13 - r.tm_mon;
4927
4928 if (lpSystemTime->wMonth == 1)
4929 lpSystemTime->wMonth = 12;
4930 else
4931 lpSystemTime->wMonth--;
4932
4933 lpSystemTime->wYear = 1899 - (r.tm_year - 1900);
4934
4935 if (!isleap(lpSystemTime->wYear) )
4936 lpSystemTime->wDay = Days_Per_Month[13 - lpSystemTime->wMonth] - r.tm_mday;
4937 else
4938 lpSystemTime->wDay = Days_Per_Month_LY[13 - lpSystemTime->wMonth] - r.tm_mday;
4939
4940
4941 }
4942
4943 if (!isleap(lpSystemTime->wYear))
4944 {
4945 /*
4946 (Century_Code+Month_Code+Year_Code+Day) % 7
4947
4948 The century code repeats every 400 years , so the array
4949 works out like this,
4950
4951 Century_Code[0] is for 16th/20th Centry
4952 Century_Code[1] is for 17th/21th Centry
4953 Century_Code[2] is for 18th/22th Centry
4954 Century_Code[3] is for 19th/23th Centry
4955
4956 The year code is found with the formula (year + (year / 4))
4957 the "year" must be between 0 and 99 .
4958
4959 The Month Code (Month_Code[1]) starts with January and
4960 ends with December.
4961 */
4962
4963 lpSystemTime->wDayOfWeek = (
4964 Century_Code[(( (lpSystemTime->wYear+100) - lpSystemTime->wYear%100) /100) %4]+
4965 ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4966 Month_Code[lpSystemTime->wMonth]+
4967 lpSystemTime->wDay) % 7;
4968
4969 if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4970 else lpSystemTime->wDayOfWeek -= 1;
4971 }
4972 else
4973 {
4974 lpSystemTime->wDayOfWeek = (
4975 Century_Code[(((lpSystemTime->wYear+100) - lpSystemTime->wYear%100)/100)%4]+
4976 ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4977 Month_Code_LY[lpSystemTime->wMonth]+
4978 lpSystemTime->wDay) % 7;
4979
4980 if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4981 else lpSystemTime->wDayOfWeek -= 1;
4982 }
4983
4984 t = floor(vtime);
4985 timeofday = vtime - t;
4986
4987 lpSystemTime->wMilliseconds = (timeofday
4988 - lpSystemTime->wHour*(1/24)
4989 - lpSystemTime->wMinute*(1/1440)
4990 - lpSystemTime->wSecond*(1/86400) )*(1/5184000);
4991
4992 return 1;
4993 }
4994
4995 /***********************************************************************
4996 * VarUdateFromDate [OLEAUT32.331]
4997 */
4998 HRESULT WINAPI VarUdateFromDate( DATE datein, ULONG dwFlags, UDATE *pudateout)
4999 {
5000 HRESULT i = 0;
5001 static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5002 static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5003
5004 TRACE("DATE = %f\n", (double)datein);
5005 i = VariantTimeToSystemTime(datein, &(pudateout->st) );
5006
5007 if (i)
5008 {
5009 pudateout->wDayOfYear = 0;
5010
5011 if (isleap(pudateout->st.wYear))
5012 {
5013 for (i =1; i<pudateout->st.wMonth; i++)
5014 pudateout->wDayOfYear += Days_Per_Month[i];
5015 }
5016 else
5017 {
5018 for (i =1; i<pudateout->st.wMonth; i++)
5019 pudateout->wDayOfYear += Days_Per_Month_LY[i];
5020 }
5021
5022 pudateout->wDayOfYear += pudateout->st.wDay;
5023 dwFlags = 0; /*VAR_VALIDDATE*/
5024 }
5025 else dwFlags = 0;
5026
5027 return i;
5028 }
5029
5030 /***********************************************************************
5031 * VarDateFromUdate [OLEAUT32.330]
5032 */
5033 HRESULT WINAPI VarDateFromUdate(UDATE *pudateout,
5034 ULONG dwFlags, DATE *datein)
5035 {
5036 HRESULT i;
5037 double t = 0;
5038 TRACE(" %d/%d/%d %d:%d:%d\n",
5039 pudateout->st.wMonth, pudateout->st.wDay,
5040 pudateout->st.wYear, pudateout->st.wHour,
5041 pudateout->st.wMinute, pudateout->st.wSecond);
5042
5043
5044 i = SystemTimeToVariantTime(&(pudateout->st), &t);
5045 *datein = t;
5046
5047 if (i) return S_OK;
5048 else return E_INVALIDARG;
5049 }
5050
5051
5052 /**********************************************************************
5053 * VarBstrCmp [OLEAUT32.314]
5054 *
5055 * flags can be:
5056 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5057 * NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5058 *
5059 */
5060 HRESULT WINAPI VarBstrCmp(BSTR left, BSTR right, LCID lcid, DWORD flags)
5061 {
5062 INT r;
5063
5064 TRACE("( %s %s %ld %lx ) partial stub\n", debugstr_w(left), debugstr_w(right), lcid, flags);
5065
5066 /* Contrary to the MSDN, this returns eq for null vs null, null vs L"" and L"" vs NULL */
5067 if((!left) || (!right)) {
5068
5069 if (!left && (!right || *right==0)) return VARCMP_EQ;
5070 else if (!right && (!left || *left==0)) return VARCMP_EQ;
5071 else return VARCMP_NULL;
5072 }
5073
5074 if(flags&NORM_IGNORECASE)
5075 r = lstrcmpiW(left,right);
5076 else
5077 r = lstrcmpW(left,right);
5078
5079 if(r<0)
5080 return VARCMP_LT;
5081 if(r>0)
5082 return VARCMP_GT;
5083
5084 return VARCMP_EQ;
5085 }
5086
5087 /**********************************************************************
5088 * VarBstrCat [OLEAUT32.313]
5089 */
5090 HRESULT WINAPI VarBstrCat(BSTR left, BSTR right, BSTR *out)
5091 {
5092 BSTR result;
5093 int size = 0;
5094
5095 TRACE("( %s %s %p )\n", debugstr_w(left), debugstr_w(right), out);
5096
5097 /* On Windows, NULL parms are still handled (as empty strings) */
5098 if (left) size=size + lstrlenW(left);
5099 if (right) size=size + lstrlenW(right);
5100
5101 if (out) {
5102 result = SysAllocStringLen(NULL, size);
5103 *out = result;
5104 if (left) lstrcatW(result,left);
5105 if (right) lstrcatW(result,right);
5106 TRACE("result = %s, [%p]\n", debugstr_w(result), result);
5107 }
5108 return S_OK;
5109 }
5110
5111 /**********************************************************************
5112 * VarCat [OLEAUT32.318]
5113 */
5114 HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out)
5115 {
5116 /* Should we VariantClear out? */
5117 /* Can we handle array, vector, by ref etc. */
5118 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL &&
5119 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5120 {
5121 V_VT(out) = VT_NULL;
5122 return S_OK;
5123 }
5124
5125 if (V_VT(left) == VT_BSTR && V_VT(right) == VT_BSTR)
5126 {
5127 V_VT(out) = VT_BSTR;
5128 VarBstrCat (V_BSTR(left), V_BSTR(right), &V_BSTR(out));
5129 return S_OK;
5130 }
5131 if (V_VT(left) == VT_BSTR) {
5132 VARIANT bstrvar;
5133 HRESULT hres;
5134
5135 V_VT(out) = VT_BSTR;
5136 hres = VariantChangeTypeEx(&bstrvar,right,0,0,VT_BSTR);
5137 if (hres) {
5138 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5139 return hres;
5140 }
5141 VarBstrCat (V_BSTR(left), V_BSTR(&bstrvar), &V_BSTR(out));
5142 return S_OK;
5143 }
5144 if (V_VT(right) == VT_BSTR) {
5145 VARIANT bstrvar;
5146 HRESULT hres;
5147
5148 V_VT(out) = VT_BSTR;
5149 hres = VariantChangeTypeEx(&bstrvar,left,0,0,VT_BSTR);
5150 if (hres) {
5151 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5152 return hres;
5153 }
5154 VarBstrCat (V_BSTR(&bstrvar), V_BSTR(right), &V_BSTR(out));
5155 return S_OK;
5156 }
5157 FIXME ("types %d / %d not supported\n",V_VT(left)&VT_TYPEMASK, V_VT(right)&VT_TYPEMASK);
5158 return S_OK;
5159 }
5160
5161 /**********************************************************************
5162 * VarCmp [OLEAUT32.176]
5163 *
5164 * flags can be:
5165 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5166 * NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5167 *
5168 */
5169 HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
5170 {
5171
5172
5173 BOOL lOk = TRUE;
5174 BOOL rOk = TRUE;
5175 LONGLONG lVal = -1;
5176 LONGLONG rVal = -1;
5177 VARIANT rv,lv;
5178 DWORD xmask;
5179 HRESULT rc;
5180
5181 VariantInit(&lv);VariantInit(&rv);
5182 V_VT(right) &= ~0x8000; /* hack since we sometime get this flag. */
5183 V_VT(left) &= ~0x8000; /* hack since we sometime get this flag. */
5184
5185 TRACE("Left Var:\n");
5186 dump_Variant(left);
5187 TRACE("Right Var:\n");
5188 dump_Variant(right);
5189
5190 /* If either are null, then return VARCMP_NULL */
5191 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL ||
5192 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5193 return VARCMP_NULL;
5194
5195 /* Strings - use VarBstrCmp */
5196 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5197 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5198 return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags);
5199 }
5200
5201 xmask = (1<<(V_VT(left)&VT_TYPEMASK))|(1<<(V_VT(right)&VT_TYPEMASK));
5202 if (xmask & (1<<VT_R8)) {
5203 rc = VariantChangeType(&lv,left,0,VT_R8);
5204 if (FAILED(rc)) return rc;
5205 rc = VariantChangeType(&rv,right,0,VT_R8);
5206 if (FAILED(rc)) return rc;
5207
5208 if (V_R8(&lv) == V_R8(&rv)) return VARCMP_EQ;
5209 if (V_R8(&lv) < V_R8(&rv)) return VARCMP_LT;
5210 if (V_R8(&lv) > V_R8(&rv)) return VARCMP_GT;
5211 return E_FAIL; /* can't get here */
5212 }
5213 if (xmask & (1<<VT_R4)) {
5214 rc = VariantChangeType(&lv,left,0,VT_R4);
5215 if (FAILED(rc)) return rc;
5216 rc = VariantChangeType(&rv,right,0,VT_R4);
5217 if (FAILED(rc)) return rc;
5218
5219 if (V_R4(&lv) == V_R4(&rv)) return VARCMP_EQ;
5220 if (V_R4(&lv) < V_R4(&rv)) return VARCMP_LT;
5221 if (V_R4(&lv) > V_R4(&rv)) return VARCMP_GT;
5222 return E_FAIL; /* can't get here */
5223 }
5224
5225 /* Integers - Ideally like to use VarDecCmp, but no Dec support yet
5226 Use LONGLONG to maximize ranges */
5227 lOk = TRUE;
5228 switch (V_VT(left)&VT_TYPEMASK) {
5229 case VT_I1 : lVal = V_UNION(left,cVal); break;
5230 case VT_I2 : lVal = V_UNION(left,iVal); break;
5231 case VT_I4 : lVal = V_UNION(left,lVal); break;
5232 case VT_INT : lVal = V_UNION(left,lVal); break;
5233 case VT_UI1 : lVal = V_UNION(left,bVal); break;
5234 case VT_UI2 : lVal = V_UNION(left,uiVal); break;
5235 case VT_UI4 : lVal = V_UNION(left,ulVal); break;
5236 case VT_UINT : lVal = V_UNION(left,ulVal); break;
5237 case VT_BOOL : lVal = V_UNION(left,boolVal); break;
5238 default: lOk = FALSE;
5239 }
5240
5241 rOk = TRUE;
5242 switch (V_VT(right)&VT_TYPEMASK) {
5243 case VT_I1 : rVal = V_UNION(right,cVal); break;
5244 case VT_I2 : rVal = V_UNION(right,iVal); break;
5245 case VT_I4 : rVal = V_UNION(right,lVal); break;
5246 case VT_INT : rVal = V_UNION(right,lVal); break;
5247 case VT_UI1 : rVal = V_UNION(right,bVal); break;
5248 case VT_UI2 : rVal = V_UNION(right,uiVal); break;
5249 case VT_UI4 : rVal = V_UNION(right,ulVal); break;
5250 case VT_UINT : rVal = V_UNION(right,ulVal); break;
5251 case VT_BOOL : rVal = V_UNION(right,boolVal); break;
5252 default: rOk = FALSE;
5253 }
5254
5255 if (lOk && rOk) {
5256 if (lVal < rVal) {
5257 return VARCMP_LT;
5258 } else if (lVal > rVal) {
5259 return VARCMP_GT;
5260 } else {
5261 return VARCMP_EQ;
5262 }
5263 }
5264
5265 /* Strings - use VarBstrCmp */
5266 if ((V_VT(left)&VT_TYPEMASK) == VT_DATE &&
5267 (V_VT(right)&VT_TYPEMASK) == VT_DATE) {
5268
5269 if (floor(V_UNION(left,date)) == floor(V_UNION(right,date))) {
5270 /* Due to floating point rounding errors, calculate varDate in whole numbers) */
5271 double wholePart = 0.0;
5272 double leftR;
5273 double rightR;
5274
5275 /* Get the fraction * 24*60*60 to make it into whole seconds */
5276 wholePart = (double) floor( V_UNION(left,date) );
5277 if (wholePart == 0) wholePart = 1;
5278 leftR = floor(fmod( V_UNION(left,date), wholePart ) * (24*60*60));
5279
5280 wholePart = (double) floor( V_UNION(right,date) );
5281 if (wholePart == 0) wholePart = 1;
5282 rightR = floor(fmod( V_UNION(right,date), wholePart ) * (24*60*60));
5283
5284 if (leftR < rightR) {
5285 return VARCMP_LT;
5286 } else if (leftR > rightR) {
5287 return VARCMP_GT;
5288 } else {
5289 return VARCMP_EQ;
5290 }
5291
5292 } else if (V_UNION(left,date) < V_UNION(right,date)) {
5293 return VARCMP_LT;
5294 } else if (V_UNION(left,date) > V_UNION(right,date)) {
5295 return VARCMP_GT;
5296 }
5297 }
5298 FIXME("VarCmp partial implementation, doesnt support vt 0x%x / 0x%x\n",V_VT(left), V_VT(right));
5299 return E_FAIL;
5300 }
5301
5302 /**********************************************************************
5303 * VarAnd [OLEAUT32.142]
5304 *
5305 */
5306 HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5307 {
5308 HRESULT rc = E_FAIL;
5309
5310 TRACE("Left Var:\n");
5311 dump_Variant(left);
5312 TRACE("Right Var:\n");
5313 dump_Variant(right);
5314
5315 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5316 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5317
5318 V_VT(result) = VT_BOOL;
5319 if (V_BOOL(left) && V_BOOL(right)) {
5320 V_BOOL(result) = VARIANT_TRUE;
5321 } else {
5322 V_BOOL(result) = VARIANT_FALSE;
5323 }
5324 rc = S_OK;
5325
5326 } else {
5327 /* Integers */
5328 BOOL lOk = TRUE;
5329 BOOL rOk = TRUE;
5330 LONGLONG lVal = -1;
5331 LONGLONG rVal = -1;
5332 LONGLONG res = -1;
5333 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
5334 becomes I4, even unsigned ints (incl. UI2) */
5335
5336 lOk = TRUE;
5337 switch (V_VT(left)&VT_TYPEMASK) {
5338 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5339 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5340 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5341 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5342 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5343 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5344 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5345 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5346 default: lOk = FALSE;
5347 }
5348
5349 rOk = TRUE;
5350 switch (V_VT(right)&VT_TYPEMASK) {
5351 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5352 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5353 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5354 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5355 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5356 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5357 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5358 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5359 default: rOk = FALSE;
5360 }
5361
5362 if (lOk && rOk) {
5363 res = (lVal & rVal);
5364 V_VT(result) = resT;
5365 switch (resT) {
5366 case VT_I2 : V_UNION(result,iVal) = res; break;
5367 case VT_I4 : V_UNION(result,lVal) = res; break;
5368 default:
5369 FIXME("Unexpected result variant type %x\n", resT);
5370 V_UNION(result,lVal) = res;
5371 }
5372 rc = S_OK;
5373
5374 } else {
5375 FIXME("VarAnd stub\n");
5376 }
5377 }
5378
5379 TRACE("rc=%d, Result:\n", (int) rc);
5380 dump_Variant(result);
5381 return rc;
5382 }
5383
5384 /**********************************************************************
5385 * VarAdd [OLEAUT32.141]
5386 * FIXME: From MSDN: If ... Then
5387 * Both expressions are of the string type Concatenated.
5388 * One expression is a string type and the other a character Addition.
5389 * One expression is numeric and the other is a string Addition.
5390 * Both expressions are numeric Addition.
5391 * Either expression is NULL NULL is returned.
5392 * Both expressions are empty Integer subtype is returned.
5393 *
5394 */
5395 HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5396 {
5397 HRESULT rc = E_FAIL;
5398
5399 TRACE("Left Var:\n");
5400 dump_Variant(left);
5401 TRACE("Right Var:\n");
5402 dump_Variant(right);
5403
5404 /* Handle strings as concat */
5405 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5406 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5407 V_VT(result) = VT_BSTR;
5408 rc = VarBstrCat(V_BSTR(left), V_BSTR(right), &V_BSTR(result));
5409 } else {
5410
5411 /* Integers */
5412 BOOL lOk = TRUE;
5413 BOOL rOk = TRUE;
5414 LONGLONG lVal = -1;
5415 LONGLONG rVal = -1;
5416 LONGLONG res = -1;
5417 int resT = 0; /* Testing has shown I2 + I2 == I2, all else
5418 becomes I4 */
5419
5420 lOk = TRUE;
5421 switch (V_VT(left)&VT_TYPEMASK) {
5422 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5423 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5424 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5425 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5426 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5427 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5428 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5429 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5430 default: lOk = FALSE;
5431 }
5432
5433 rOk = TRUE;
5434 switch (V_VT(right)&VT_TYPEMASK) {
5435 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5436 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5437 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5438 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5439 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5440 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5441 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5442 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5443 default: rOk = FALSE;
5444 }
5445
5446 if (lOk && rOk) {
5447 res = (lVal + rVal);
5448 V_VT(result) = resT;
5449 switch (resT) {
5450 case VT_I2 : V_UNION(result,iVal) = res; break;
5451 case VT_I4 : V_UNION(result,lVal) = res; break;
5452 default:
5453 FIXME("Unexpected result variant type %x\n", resT);
5454 V_UNION(result,lVal) = res;
5455 }
5456 rc = S_OK;
5457
5458 } else {
5459 FIXME("unimplemented part\n");
5460 }
5461 }
5462
5463 TRACE("rc=%d, Result:\n", (int) rc);
5464 dump_Variant(result);
5465 return rc;
5466 }
5467
5468 /**********************************************************************
5469 * VarMul [OLEAUT32.156]
5470 *
5471 */
5472 HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5473 {
5474 HRESULT rc = E_FAIL;
5475 VARTYPE lvt,rvt,resvt;
5476 VARIANT lv,rv;
5477 BOOL found;
5478
5479 TRACE("left: ");dump_Variant(left);
5480 TRACE("right: ");dump_Variant(right);
5481
5482 VariantInit(&lv);VariantInit(&rv);
5483 lvt = V_VT(left)&VT_TYPEMASK;
5484 rvt = V_VT(right)&VT_TYPEMASK;
5485 found = FALSE;resvt=VT_VOID;
5486 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5487 found = TRUE;
5488 resvt = VT_R8;
5489 }
5490 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)))) {
5491 found = TRUE;
5492 resvt = VT_I4;
5493 }
5494 if (!found) {
5495 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5496 return E_FAIL;
5497 }
5498 rc = VariantChangeType(&lv, left, 0, resvt);
5499 if (FAILED(rc)) {
5500 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5501 return rc;
5502 }
5503 rc = VariantChangeType(&rv, right, 0, resvt);
5504 if (FAILED(rc)) {
5505 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5506 return rc;
5507 }
5508 switch (resvt) {
5509 case VT_R8:
5510 V_VT(result) = resvt;
5511 V_R8(result) = V_R8(&lv) * V_R8(&rv);
5512 rc = S_OK;
5513 break;
5514 case VT_I4:
5515 V_VT(result) = resvt;
5516 V_I4(result) = V_I4(&lv) * V_I4(&rv);
5517 rc = S_OK;
5518 break;
5519 }
5520 TRACE("rc=%d, Result:\n", (int) rc);
5521 dump_Variant(result);
5522 return rc;
5523 }
5524
5525 /**********************************************************************
5526 * VarDiv [OLEAUT32.143]
5527 *
5528 */
5529 HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5530 {
5531 HRESULT rc = E_FAIL;
5532 VARTYPE lvt,rvt,resvt;
5533 VARIANT lv,rv;
5534 BOOL found;
5535
5536 TRACE("left: ");dump_Variant(left);
5537 TRACE("right: ");dump_Variant(right);
5538
5539 VariantInit(&lv);VariantInit(&rv);
5540 lvt = V_VT(left)&VT_TYPEMASK;
5541 rvt = V_VT(right)&VT_TYPEMASK;
5542 found = FALSE;resvt = VT_VOID;
5543 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5544 found = TRUE;
5545 resvt = VT_R8;
5546 }
5547 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)))) {
5548 found = TRUE;
5549 resvt = VT_I4;
5550 }
5551 if (!found) {
5552 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5553 return E_FAIL;
5554 }
5555 rc = VariantChangeType(&lv, left, 0, resvt);
5556 if (FAILED(rc)) {
5557 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5558 return rc;
5559 }
5560 rc = VariantChangeType(&rv, right, 0, resvt);
5561 if (FAILED(rc)) {
5562 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5563 return rc;
5564 }
5565 switch (resvt) {
5566 case VT_R8:
5567 V_VT(result) = resvt;
5568 V_R8(result) = V_R8(&lv) / V_R8(&rv);
5569 rc = S_OK;
5570 break;
5571 case VT_I4:
5572 V_VT(result) = resvt;
5573 V_I4(result) = V_I4(&lv) / V_I4(&rv);
5574 rc = S_OK;
5575 break;
5576 }
5577 TRACE("rc=%d, Result:\n", (int) rc);
5578 dump_Variant(result);
5579 return rc;
5580 }
5581
5582 /**********************************************************************
5583 * VarSub [OLEAUT32.159]
5584 *
5585 */
5586 HRESULT WINAPI VarSub(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5587 {
5588 HRESULT rc = E_FAIL;
5589 VARTYPE lvt,rvt,resvt;
5590 VARIANT lv,rv;
5591 BOOL found;
5592
5593 TRACE("left: ");dump_Variant(left);
5594 TRACE("right: ");dump_Variant(right);
5595
5596 VariantInit(&lv);VariantInit(&rv);
5597 lvt = V_VT(left)&VT_TYPEMASK;
5598 rvt = V_VT(right)&VT_TYPEMASK;
5599 found = FALSE;resvt = VT_VOID;
5600 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5601 found = TRUE;
5602 resvt = VT_R8;
5603 }
5604 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)))) {
5605 found = TRUE;
5606 resvt = VT_I4;
5607 }
5608 if (!found) {
5609 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5610 return E_FAIL;
5611 }
5612 rc = VariantChangeType(&lv, left, 0, resvt);
5613 if (FAILED(rc)) {
5614 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5615 return rc;
5616 }
5617 rc = VariantChangeType(&rv, right, 0, resvt);
5618 if (FAILED(rc)) {
5619 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5620 return rc;
5621 }
5622 switch (resvt) {
5623 case VT_R8:
5624 V_VT(result) = resvt;
5625 V_R8(result) = V_R8(&lv) - V_R8(&rv);
5626 rc = S_OK;
5627 break;
5628 case VT_I4:
5629 V_VT(result) = resvt;
5630 V_I4(result) = V_I4(&lv) - V_I4(&rv);
5631 rc = S_OK;
5632 break;
5633 }
5634 TRACE("rc=%d, Result:\n", (int) rc);
5635 dump_Variant(result);
5636 return rc;
5637 }
5638
5639 /**********************************************************************
5640 * VarOr [OLEAUT32.157]
5641 *
5642 */
5643 HRESULT WINAPI VarOr(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5644 {
5645 HRESULT rc = E_FAIL;
5646
5647 TRACE("Left Var:\n");
5648 dump_Variant(left);
5649 TRACE("Right Var:\n");
5650 dump_Variant(right);
5651
5652 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5653 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5654
5655 V_VT(result) = VT_BOOL;
5656 if (V_BOOL(left) || V_BOOL(right)) {
5657 V_BOOL(result) = VARIANT_TRUE;
5658 } else {
5659 V_BOOL(result) = VARIANT_FALSE;
5660 }
5661 rc = S_OK;
5662
5663 } else {
5664 /* Integers */
5665 BOOL lOk = TRUE;
5666 BOOL rOk = TRUE;
5667 LONGLONG lVal = -1;
5668 LONGLONG rVal = -1;
5669 LONGLONG res = -1;
5670 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
5671 becomes I4, even unsigned ints (incl. UI2) */
5672
5673 lOk = TRUE;
5674 switch (V_VT(left)&VT_TYPEMASK) {
5675 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5676 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5677 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5678 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5679 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5680 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5681 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5682 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5683 default: lOk = FALSE;
5684 }
5685
5686 rOk = TRUE;
5687 switch (V_VT(right)&VT_TYPEMASK) {
5688 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5689 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5690 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5691 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5692 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5693 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5694 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5695 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5696 default: rOk = FALSE;
5697 }
5698
5699 if (lOk && rOk) {
5700 res = (lVal | rVal);
5701 V_VT(result) = resT;
5702 switch (resT) {
5703 case VT_I2 : V_UNION(result,iVal) = res; break;
5704 case VT_I4 : V_UNION(result,lVal) = res; break;
5705 default:
5706 FIXME("Unexpected result variant type %x\n", resT);
5707 V_UNION(result,lVal) = res;
5708 }
5709 rc = S_OK;
5710
5711 } else {
5712 FIXME("unimplemented part\n");
5713 }
5714 }
5715
5716 TRACE("rc=%d, Result:\n", (int) rc);
5717 dump_Variant(result);
5718 return rc;
5719 }
5720
5721 /**********************************************************************
5722 * VarNot [OLEAUT32.174]
5723 *
5724 */
5725 HRESULT WINAPI VarNot(LPVARIANT in, LPVARIANT result)
5726 {
5727 HRESULT rc = E_FAIL;
5728
5729 TRACE("Var In:\n");
5730 dump_Variant(in);
5731
5732 if ((V_VT(in)&VT_TYPEMASK) == VT_BOOL) {
5733
5734 V_VT(result) = VT_BOOL;
5735 if (V_BOOL(in)) {
5736 V_BOOL(result) = VARIANT_FALSE;
5737 } else {
5738 V_BOOL(result) = VARIANT_TRUE;
5739 }
5740 rc = S_OK;
5741
5742 } else {
5743 FIXME("VarNot stub\n");
5744 }
5745
5746 TRACE("rc=%d, Result:\n", (int) rc);
5747 dump_Variant(result);
5748 return rc;
5749 }
5750
5751 /**********************************************************************
5752 * VarTokenizeFormatString [OLEAUT32.140]
5753 *
5754 * From investigation on W2K, a list is built up which is:
5755 *
5756 * <0x00> AA BB - Copy from AA for BB chars (Note 1 byte with wrap!)
5757 * <token> - Insert appropriate token
5758 *
5759 */
5760 HRESULT WINAPI VarTokenizeFormatString(LPOLESTR format, LPBYTE rgbTok,
5761 int cbTok, int iFirstDay, int iFirstWeek,
5762 LCID lcid, int *pcbActual) {
5763
5764 FORMATHDR *hdr;
5765 int realLen, formatLeft;
5766 BYTE *pData;
5767 LPSTR pFormatA, pStart;
5768 int checkStr;
5769 BOOL insertCopy = FALSE;
5770 LPSTR copyFrom = NULL;
5771
5772 TRACE("'%s', %p %d %d %d only date support\n", debugstr_w(format), rgbTok, cbTok,
5773 iFirstDay, iFirstWeek);
5774
5775 /* Big enough for header? */
5776 if (cbTok < sizeof(FORMATHDR)) {
5777 return TYPE_E_BUFFERTOOSMALL;
5778 }
5779
5780 /* Insert header */
5781 hdr = (FORMATHDR *) rgbTok;
5782 memset(hdr, 0x00, sizeof(FORMATHDR));
5783 hdr->hex3 = 0x03; /* No idea what these are */
5784 hdr->hex6 = 0x06;
5785
5786 /* Start parsing string */
5787 realLen = sizeof(FORMATHDR);
5788 pData = rgbTok + realLen;
5789 pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5790 pStart = pFormatA;
5791 formatLeft = strlen(pFormatA);
5792
5793 /* Work through the format */
5794 while (*pFormatA != 0x00) {
5795
5796 checkStr = 0;
5797 while (checkStr>=0 && (formatTokens[checkStr].tokenSize != 0x00)) {
5798 if (formatLeft >= formatTokens[checkStr].tokenSize &&
5799 strncmp(formatTokens[checkStr].str, pFormatA,
5800 formatTokens[checkStr].tokenSize) == 0) {
5801 TRACE("match on '%s'\n", formatTokens[checkStr].str);
5802
5803 /* Found Match! */
5804
5805 /* If we have skipped chars, insert the copy */
5806 if (insertCopy == TRUE) {
5807
5808 if ((realLen + 3) > cbTok) {
5809 HeapFree( GetProcessHeap(), 0, pFormatA );
5810 return TYPE_E_BUFFERTOOSMALL;
5811 }
5812 insertCopy = FALSE;
5813 *pData = TOK_COPY;
5814 pData++;
5815 *pData = (BYTE)(copyFrom - pStart);
5816 pData++;
5817 *pData = (BYTE)(pFormatA - copyFrom);
5818 pData++;
5819 realLen = realLen + 3;
5820 }
5821
5822
5823 /* Now insert the token itself */
5824 if ((realLen + 1) > cbTok) {
5825 HeapFree( GetProcessHeap(), 0, pFormatA );
5826 return TYPE_E_BUFFERTOOSMALL;
5827 }
5828 *pData = formatTokens[checkStr].tokenId;
5829 pData = pData + 1;
5830 realLen = realLen + 1;
5831
5832 pFormatA = pFormatA + formatTokens[checkStr].tokenSize;
5833 formatLeft = formatLeft - formatTokens[checkStr].tokenSize;
5834 checkStr = -1; /* Flag as found and break out of while loop */
5835 } else {
5836 checkStr++;
5837 }
5838 }
5839
5840 /* Did we ever match a token? */
5841 if (checkStr != -1 && insertCopy == FALSE) {
5842 TRACE("No match - need to insert copy from %p [%p]\n", pFormatA, pStart);
5843 insertCopy = TRUE;
5844 copyFrom = pFormatA;
5845 } else if (checkStr != -1) {
5846 pFormatA = pFormatA + 1;
5847 }
5848
5849 }
5850
5851 /* Finally, if we have skipped chars, insert the copy */
5852 if (insertCopy == TRUE) {
5853
5854 TRACE("Chars left over, so still copy %p,%p,%p\n", copyFrom, pStart, pFormatA);
5855 if ((realLen + 3) > cbTok) {
5856 HeapFree( GetProcessHeap(), 0, pFormatA );
5857 return TYPE_E_BUFFERTOOSMALL;
5858 }
5859 insertCopy = FALSE;
5860 *pData = TOK_COPY;
5861 pData++;
5862 *pData = (BYTE)(copyFrom - pStart);
5863 pData++;
5864 *pData = (BYTE)(pFormatA - copyFrom);
5865 pData++;
5866 realLen = realLen + 3;
5867 }
5868
5869 /* Finally insert the terminator */
5870 if ((realLen + 1) > cbTok) {
5871 HeapFree( GetProcessHeap(), 0, pFormatA );
5872 return TYPE_E_BUFFERTOOSMALL;
5873 }
5874 *pData++ = TOK_END;
5875 realLen = realLen + 1;
5876
5877 /* Finally fill in the length */
5878 hdr->len = realLen;
5879 *pcbActual = realLen;
5880
5881 #if 0
5882 { int i,j;
5883 for (i=0; i<realLen; i=i+0x10) {
5884 printf(" %4.4x : ", i);
5885 for (j=0; j<0x10 && (i+j < realLen); j++) {
5886 printf("%2.2x ", rgbTok[i+j]);
5887 }
5888 printf("\n");
5889 }
5890 }
5891 #endif
5892 HeapFree( GetProcessHeap(), 0, pFormatA );
5893
5894 return S_OK;
5895 }
5896
5897 /**********************************************************************
5898 * VarFormatFromTokens [OLEAUT32.139]
5899 * FIXME: No account of flags or iFirstDay etc
5900 */
5901 HRESULT WINAPI VarFormatFromTokens(LPVARIANT varIn, LPOLESTR format,
5902 LPBYTE pbTokCur, ULONG dwFlags, BSTR *pbstrOut,
5903 LCID lcid) {
5904
5905 FORMATHDR *hdr = (FORMATHDR *)pbTokCur;
5906 BYTE *pData = pbTokCur + sizeof (FORMATHDR);
5907 LPSTR pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5908 char output[BUFFER_MAX];
5909 char *pNextPos;
5910 int size, whichToken;
5911 VARIANTARG Variant;
5912 struct tm TM;
5913
5914
5915
5916 TRACE("'%s', %p %lx %p only date support\n", pFormatA, pbTokCur, dwFlags, pbstrOut);
5917 TRACE("varIn:\n");
5918 dump_Variant(varIn);
5919
5920 memset(output, 0x00, BUFFER_MAX);
5921 pNextPos = output;
5922
5923 while (*pData != TOK_END && ((pData - pbTokCur) <= (hdr->len))) {
5924
5925 TRACE("Output looks like : '%s'\n", output);
5926
5927 /* Convert varient to appropriate data type */
5928 whichToken = 0;
5929 while ((formatTokens[whichToken].tokenSize != 0x00) &&
5930 (formatTokens[whichToken].tokenId != *pData)) {
5931 whichToken++;
5932 }
5933
5934 /* Use Variant local from here downwards as always correct type */
5935 if (formatTokens[whichToken].tokenSize > 0 &&
5936 formatTokens[whichToken].varTypeRequired != 0) {
5937 VariantInit( &Variant );
5938 if (Coerce( &Variant, lcid, dwFlags, varIn,
5939 formatTokens[whichToken].varTypeRequired ) != S_OK) {
5940 HeapFree( GetProcessHeap(), 0, pFormatA );
5941 return DISP_E_TYPEMISMATCH;
5942 } else if (formatTokens[whichToken].varTypeRequired == VT_DATE) {
5943 if( DateToTm( V_UNION(&Variant,date), dwFlags, &TM ) == FALSE ) {
5944 HeapFree( GetProcessHeap(), 0, pFormatA );
5945 return E_INVALIDARG;
5946 }
5947 }
5948 }
5949
5950 TRACE("Looking for match on token '%x'\n", *pData);
5951 switch (*pData) {
5952 case TOK_COPY:
5953 TRACE("Copy from %d for %d bytes\n", *(pData+1), *(pData+2));
5954 memcpy(pNextPos, &pFormatA[*(pData+1)], *(pData+2));
5955 pNextPos = pNextPos + *(pData+2);
5956 pData = pData + 3;
5957 break;
5958
5959 case TOK_COLON :
5960 /* Get locale information - Time Seperator */
5961 size = GetLocaleInfoA(lcid, LOCALE_STIME, NULL, 0);
5962 GetLocaleInfoA(lcid, LOCALE_STIME, pNextPos, size);
5963 TRACE("TOK_COLON Time seperator is '%s'\n", pNextPos);
5964 pNextPos = pNextPos + size;
5965 pData = pData + 1;
5966 break;
5967
5968 case TOK_SLASH :
5969 /* Get locale information - Date Seperator */
5970 size = GetLocaleInfoA(lcid, LOCALE_SDATE, NULL, 0);
5971 GetLocaleInfoA(lcid, LOCALE_SDATE, pNextPos, size);
5972 TRACE("TOK_COLON Time seperator is '%s'\n", pNextPos);
5973 pNextPos = pNextPos + size;
5974 pData = pData + 1;
5975 break;
5976
5977 case TOK_d :
5978 sprintf(pNextPos, "%d", TM.tm_mday);
5979 pNextPos = pNextPos + strlen(pNextPos);
5980 pData = pData + 1;
5981 break;
5982
5983 case TOK_dd :
5984 sprintf(pNextPos, "%2.2d", TM.tm_mday);
5985 pNextPos = pNextPos + strlen(pNextPos);
5986 pData = pData + 1;
5987 break;
5988
5989 case TOK_w :
5990 sprintf(pNextPos, "%d", TM.tm_wday+1);
5991 pNextPos = pNextPos + strlen(pNextPos);
5992 pData = pData + 1;
5993 break;
5994
5995 case TOK_m :
5996 sprintf(pNextPos, "%d", TM.tm_mon+1);
5997 pNextPos = pNextPos + strlen(pNextPos);
5998 pData = pData + 1;
5999 break;
6000
6001 case TOK_mm :
6002 sprintf(pNextPos, "%2.2d", TM.tm_mon+1);
6003 pNextPos = pNextPos + strlen(pNextPos);
6004 pData = pData + 1;
6005 break;
6006
6007 case TOK_q :
6008 sprintf(pNextPos, "%d", ((TM.tm_mon+1)/4)+1);
6009 pNextPos = pNextPos + strlen(pNextPos);
6010 pData = pData + 1;
6011 break;
6012
6013 case TOK_y :
6014 sprintf(pNextPos, "%2.2d", TM.tm_yday+1);
6015 pNextPos = pNextPos + strlen(pNextPos);
6016 pData = pData + 1;
6017 break;
6018
6019 case TOK_yy :
6020 sprintf(pNextPos, "%2.2d", TM.tm_year);
6021 pNextPos = pNextPos + strlen(pNextPos);
6022 pData = pData + 1;
6023 break;
6024
6025 case TOK_yyyy :
6026 sprintf(pNextPos, "%4.4d", TM.tm_year);
6027 pNextPos = pNextPos + strlen(pNextPos);
6028 pData = pData + 1;
6029 break;
6030
6031 case TOK_h :
6032 sprintf(pNextPos, "%d", TM.tm_hour);
6033 pNextPos = pNextPos + strlen(pNextPos);
6034 pData = pData + 1;
6035 break;
6036
6037 case TOK_Hh :
6038 sprintf(pNextPos, "%2.2d", TM.tm_hour);
6039 pNextPos = pNextPos + strlen(pNextPos);
6040 pData = pData + 1;
6041 break;
6042
6043 case TOK_N :
6044 sprintf(pNextPos, "%d", TM.tm_min);
6045 pNextPos = pNextPos + strlen(pNextPos);
6046 pData = pData + 1;
6047 break;
6048
6049 case TOK_Nn :
6050 sprintf(pNextPos, "%2.2d", TM.tm_min);
6051 pNextPos = pNextPos + strlen(pNextPos);
6052 pData = pData + 1;
6053 break;
6054
6055 case TOK_S :
6056 sprintf(pNextPos, "%d", TM.tm_sec);
6057 pNextPos = pNextPos + strlen(pNextPos);
6058 pData = pData + 1;
6059 break;
6060
6061 case TOK_Ss :
6062 sprintf(pNextPos, "%2.2d", TM.tm_sec);
6063 pNextPos = pNextPos + strlen(pNextPos);
6064 pData = pData + 1;
6065 break;
6066
6067 /* FIXME: To Do! */
6068 case TOK_ttttt :
6069 case TOK_AMsPM :
6070 case TOK_amspm :
6071 case TOK_AsP :
6072 case TOK_asp :
6073 case TOK_AMPM :
6074 case TOK_c :
6075 case TOK_ddd :
6076 case TOK_dddd :
6077 case TOK_ddddd :
6078 case TOK_dddddd :
6079 case TOK_ww :
6080 case TOK_mmm :
6081 case TOK_mmmm :
6082 default:
6083 FIXME("Unhandled token for VarFormat %d\n", *pData);
6084 HeapFree( GetProcessHeap(), 0, pFormatA );
6085 return E_INVALIDARG;
6086 }
6087
6088 }
6089
6090 *pbstrOut = StringDupAtoBstr( output );
6091 HeapFree( GetProcessHeap(), 0, pFormatA );
6092 return S_OK;
6093 }
6094
6095 /**********************************************************************
6096 * VarFormat [OLEAUT32.87]
6097 *
6098 */
6099 HRESULT WINAPI VarFormat(LPVARIANT varIn, LPOLESTR format,
6100 int firstDay, int firstWeek, ULONG dwFlags,
6101 BSTR *pbstrOut) {
6102
6103 LPSTR pNewString = NULL;
6104 HRESULT rc = S_OK;
6105
6106 TRACE("mostly stub! format='%s' day=%d, wk=%d, flags=%ld\n",
6107 debugstr_w(format), firstDay, firstWeek, dwFlags);
6108 TRACE("varIn:\n");
6109 dump_Variant(varIn);
6110
6111 /* Note: Must Handle references type Variants (contain ptrs
6112 to values rather than values */
6113
6114 /* Get format string */
6115 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
6116
6117 /* FIXME: Handle some simple pre-definted format strings : */
6118 if (((V_VT(varIn)&VT_TYPEMASK) == VT_CY) && (lstrcmpiA(pNewString, "Currency") == 0)) {
6119
6120 /* Can't use VarBstrFromCy as it does not put currency sign on nor decimal places */
6121 double curVal;
6122
6123
6124 /* Handle references type Variants (contain ptrs to values rather than values */
6125 if (V_VT(varIn)&VT_BYREF) {
6126 rc = VarR8FromCy(*(CY *)V_UNION(varIn,byref), &curVal);
6127 } else {
6128 rc = VarR8FromCy(V_UNION(varIn,cyVal), &curVal);
6129 }
6130
6131 if (rc == S_OK) {
6132 char tmpStr[BUFFER_MAX];
6133 sprintf(tmpStr, "%f", curVal);
6134 if (GetCurrencyFormatA(GetUserDefaultLCID(), dwFlags, tmpStr, NULL, pBuffer, BUFFER_MAX) == 0) {
6135 return E_FAIL;
6136 } else {
6137 *pbstrOut = StringDupAtoBstr( pBuffer );
6138 }
6139 }
6140
6141 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_DATE) {
6142
6143 /* Attempt to do proper formatting! */
6144 int firstToken = -1;
6145
6146 rc = VarTokenizeFormatString(format, pBuffer, sizeof(pBuffer), firstDay,
6147 firstWeek, GetUserDefaultLCID(), &firstToken);
6148 if (rc==S_OK) {
6149 rc = VarFormatFromTokens(varIn, format, pBuffer, dwFlags, pbstrOut, GetUserDefaultLCID());
6150 }
6151
6152 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_R8) {
6153 if (V_VT(varIn)&VT_BYREF) {
6154 sprintf(pBuffer, "%f", *V_UNION(varIn,pdblVal));
6155 } else {
6156 sprintf(pBuffer, "%f", V_UNION(varIn,dblVal));
6157 }
6158 *pbstrOut = StringDupAtoBstr( pBuffer );
6159 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_I2) {
6160 if (V_VT(varIn)&VT_BYREF) {
6161 sprintf(pBuffer, "%d", *V_UNION(varIn,piVal));
6162 } else {
6163 sprintf(pBuffer, "%d", V_UNION(varIn,iVal));
6164 }
6165 *pbstrOut = StringDupAtoBstr( pBuffer );
6166 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_BSTR) {
6167 if (V_VT(varIn)&VT_BYREF)
6168 *pbstrOut = SysAllocString( *V_UNION(varIn,pbstrVal) );
6169 else
6170 *pbstrOut = SysAllocString( V_UNION(varIn,bstrVal) );
6171 } else {
6172 FIXME("VarFormat: Unsupported format %d!\n", V_VT(varIn)&VT_TYPEMASK);
6173 *pbstrOut = StringDupAtoBstr( "??" );
6174 }
6175
6176 /* Free allocated storage */
6177 HeapFree( GetProcessHeap(), 0, pNewString );
6178 TRACE("result: '%s'\n", debugstr_w(*pbstrOut));
6179 return rc;
6180 }
6181
6182 /**********************************************************************
6183 * VarCyMulI4 [OLEAUT32.304]
6184 * Multiply currency value by integer
6185 */
6186 HRESULT WINAPI VarCyMulI4(CY cyIn, LONG mulBy, CY *pcyOut) {
6187
6188 double cyVal = 0;
6189 HRESULT rc = S_OK;
6190
6191 rc = VarR8FromCy(cyIn, &cyVal);
6192 if (rc == S_OK) {
6193 rc = VarCyFromR8((cyVal * (double) mulBy), pcyOut);
6194 TRACE("Multiply %f by %ld = %f [%ld,%lu]\n", cyVal, mulBy, (cyVal * (double) mulBy),
6195 pcyOut->s.Hi, pcyOut->s.Lo);
6196 }
6197 return rc;
6198 }
Windows API implementation